Add landmines

fluXis.Import.Quaver/Map/QuaverMap.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using fluXis.Import.Quaver.Map.Structs;
 using fluXis.Map;
 using fluXis.Map.Structures;
@@ -59,13 +60,49 @@ public MapInfo ToMapInfo()
 
         foreach (var o in HitObjects)
         {
-            mapInfo.HitObjects.Add(new HitObject
+            // we don't support LN mines, so let's just put a bunch of mines every 1/4 beat
+            if (o.Type == "Mine" && o.IsLongNote)
             {
-                Time = o.StartTime,
-                Lane = o.Lane,
-                HoldTime = o.IsLongNote ? o.EndTime - o.StartTime : 0,
-                Group = o.TimingGroup
-            });
+                TimingPoint timingPoint = mapInfo.GetTimingPoint(o.StartTime);
+
+                for (float t = o.StartTime; t < o.EndTime; t += timingPoint.MsPerBeat / 4)
+                {
+                    mapInfo.HitObjects.Add(new HitObject
+                    {
+                        Time = t,
+                        Lane = o.Lane,
+                        Type = 2,
+                        HoldTime = 0,
+                        Group = o.TimingGroup
+                    });
+
+                    timingPoint = mapInfo.GetTimingPoint(o.StartTime); // in case the bpm changes during the LN mine (idk might happen on some weird maps)
+                }
+
+                // if the endtime is too far from the last mine we placed then put a mine directly at the endtime
+                if (Math.Abs(mapInfo.HitObjects.Last().Time - o.EndTime) > timingPoint.MsPerBeat / 16)
+                {
+                    mapInfo.HitObjects.Add(new HitObject
+                    {
+                        Time = o.EndTime,
+                        Lane = o.Lane,
+                        Type = 2,
+                        HoldTime = 0,
+                        Group = o.TimingGroup
+                    });
+                }
+            }
+            else
+            {
+                mapInfo.HitObjects.Add(new HitObject
+                {
+                    Time = o.StartTime,
+                    Lane = o.Lane,
+                    Type = o.Type == "Mine" ? 2 : 0,
+                    HoldTime = o.IsLongNote ? o.EndTime - o.StartTime : 0,
+                    Group = o.TimingGroup
+                });
+            }
         }
 
         foreach (var t in TimingPoints)

fluXis.Import.Quaver/Map/Structs/QuaverHitObjectInfo.cs

@@ -8,6 +8,7 @@ public class QuaverHitObjectInfo
 {
     public float StartTime { get; set; }
     public int Lane { get; set; }
+    public string Type { get; set; }
     public float EndTime { get; set; }
     public string TimingGroup { get; set; }
 

fluXis.Import.Stepmania/Map/StepmaniaFile.cs

@@ -238,6 +238,12 @@ public List<MapInfo> ToMapInfos()
                                 break;
 
                             case StepNote.Mine:
+                                map.HitObjects.Add(new HitObject
+                                {
+                                    Time = (int)Math.Round(time, MidpointRounding.AwayFromZero),
+                                    Lane = i + 1,
+                                    Type = 2,
+                                });
                                 break;
 
                             default:

fluXis.Import.Stepmania/StepmaniaImport.cs

@@ -92,8 +92,9 @@ public override List<RealmMapSet> GetMaps()
 
             foreach (var info in infos)
             {
-                var hits = info.HitObjects.Count(x => !x.LongNote);
-                var lns = info.HitObjects.Count(x => x.LongNote);
+                var hits = info.HitObjects.Count(x => !x.LongNote && x.Type == 1);
+                var lns = info.HitObjects.Count(x => x.LongNote && x.Type == 1);
+                var mines = info.HitObjects.Count(x => x.Landmine);
                 var length = info.HitObjects.Max(x => x.Time);
 
                 var map = new StepManiaRealmMap
@@ -120,6 +121,7 @@ public override List<RealmMapSet> GetMaps()
                         BPMMax = info.TimingPoints.Max(x => x.BPM),
                         NoteCount = hits,
                         LongNoteCount = lns,
+                        LandmineCount = mines,
                         NotesPerSecond = (float)((hits + lns) / (length / 1000f))
                     }
                 };

fluXis/Database/FluXisRealm.cs

@@ -40,8 +40,9 @@ public class FluXisRealm : IDisposable
     /// 18 - Reset online score IDs
     /// 19 - Add `RealmMapUserSettings`
     /// 20 - Added `AudioHash` & 'EnableVisualization' to RealmMap
+    /// 21 - Add `LandmineCount` to `RealmMapFilters`
     /// </summary>
-    private const int schema_version = 20;
+    private const int schema_version = 21;
 
     private Realm updateRealm;
 
@@ -335,6 +336,13 @@ private void migrateTo(Migration migration, ulong targetSchemaVersion)
                 Logger.Log($"(Schema v20) Migration took {sw.ElapsedMilliseconds}ms for {maps.Count} maps");
                 break;
             }
+
+            case 21:
+            {
+                var maps = migration.NewRealm.All<RealmMap>().ToList();
+                maps.ForEach(x => x.Filters.LandmineCount = 0);
+                break;
+            }
         }
     }
 

fluXis/Database/Maps/RealmMapFilters.cs

@@ -15,6 +15,7 @@ public class RealmMapFilters : RealmObject
 
     public int NoteCount { get; set; }
     public int LongNoteCount { get; set; }
+    public int LandmineCount { get; set; }
     public float NotesPerSecond { get; set; }
 
     [Ignored]
@@ -55,6 +56,7 @@ public void Reset()
         BPMMax = 0;
         NoteCount = 0;
         LongNoteCount = 0;
+        LandmineCount = 0;
         NotesPerSecond = 0;
         Effects = 0;
     }

fluXis/Map/Structures/HitObject.cs

@@ -33,16 +33,23 @@ public class HitObject : ITimedObject
     [JsonProperty("group", DefaultValueHandling = DefaultValueHandling.Ignore)]
     public string Group { get; set; }
 
+    [JsonProperty("hidden")]
+    public bool Hidden { get; set; }
+
     /// <summary>
     /// 0 = Normal / Long
     /// 1 = Tick
+    /// 2 = Landmine
     /// </summary>
     [JsonProperty("type")]
     public int Type { get; set; }
 
     [JsonIgnore]
     public bool LongNote => HoldTime > 0 && Type == 0;
 
+    [JsonIgnore]
+    public bool Landmine => Type == 2;
+
     [JsonIgnore]
     public double EndTime
     {

fluXis/Mods/NoMineMod.cs

@@ -0,0 +1,23 @@
+using System;
+using fluXis.Graphics.Sprites.Icons;
+using fluXis.Map;
+using osu.Framework.Graphics.Sprites;
+
+namespace fluXis.Mods;
+
+public class NoMineMod : IMod, IApplicableToMap
+{
+    public string Name => "No Mines";
+    public string Acronym => "NMN";
+    public string Description => "Removes all landmines.";
+    public IconUsage Icon => FontAwesome6.Solid.Flag;
+    public ModType Type => ModType.Misc;
+    public float ScoreMultiplier => .8f;
+    public bool Rankable => true;
+    public Type[] IncompatibleMods => Array.Empty<Type>();
+
+    public void Apply(MapInfo map)
+    {
+        map.HitObjects.RemoveAll(hitObject => hitObject.Landmine);
+    }
+}

fluXis/Online/API/Models/Maps/APIMap.cs

@@ -59,6 +59,9 @@ public class APIMap
     [JsonProperty("long-notes")]
     public int LongNoteCount { get; init; }
 
+    [JsonProperty("landmines")]
+    public int LandmineCount { get; init; }
+
     [JsonProperty("maxcombo")]
     public int MaxCombo { get; init; }
 

fluXis/Online/API/Payloads/Scores/ScoreSubmissionPayload.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using fluXis.Replays;
+using fluXis.Scoring.Enums;
 using Newtonsoft.Json;
 
 namespace fluXis.Online.API.Payloads.Scores;
@@ -41,7 +42,7 @@ public class Result
         [JsonProperty("diff")]
         public double Difference { get; set; }
 
-        [JsonProperty("end")]
-        public bool HoldEnd { get; set; }
+        [JsonProperty("type")]
+        public ResultType Type { get; set; }
     }
 }

fluXis/Online/API/Requests/Scores/ScoreSubmitRequest.cs

@@ -44,7 +44,7 @@ protected override WebRequest CreateWebRequest(string url)
         var results = score.HitResults.Select(x => new ScoreSubmissionPayload.Result
         {
             Difference = x.Difference,
-            HoldEnd = x.HoldEnd
+            Type = x.Type
         });
 
         var payload = new ScoreSubmissionPayload

fluXis/Replays/AutoGenerator.cs

@@ -104,6 +104,7 @@ private IEnumerable<IAction> generateActions()
             for (int i = 0; i < objects.Count; i++)
             {
                 var currentObject = objects[i];
+                if (currentObject.Type == 2) continue;
 
                 if (currentObject.Time < blockedUntil)
                     continue;

fluXis/Scoring/Enums/ResultType.cs

@@ -0,0 +1,8 @@
+namespace fluXis.Scoring.Enums;
+
+public enum ResultType
+{
+    Hit,
+    HoldEnd,
+    Landmine
+};

fluXis/Scoring/HitWindows.cs

@@ -34,10 +34,10 @@ public Judgement JudgementFor(double milliseconds)
     {
         milliseconds = Math.Abs(milliseconds);
 
-        for (var result = Judgement.Flawless; result >= Judgement.Miss; --result)
+        foreach (var timing in Timings)
         {
-            if (milliseconds <= TimingFor(result))
-                return result;
+            if (milliseconds <= timing.Milliseconds)
+                return timing.Judgement;
         }
 
         return Judgement.Miss;

fluXis/Scoring/LandmineWindows.cs

@@ -0,0 +1,17 @@
+using fluXis.Scoring.Enums;
+
+namespace fluXis.Scoring;
+
+public class LandmineWindows : HitWindows
+{
+    public LandmineWindows(float difficulty, float rate)
+        : base(difficulty, rate)
+    {
+    }
+
+    protected override Timing[] CreateTimings(float difficulty, float multiplier) => new Timing[]
+    {
+        new(Judgement.Miss, difficulty, multiplier, 64, 49, 34), //matches "Perfect" judgement from regular HitWindows
+        new(Judgement.Flawless, difficulty, multiplier, 188, 173, 158)
+    };
+}

fluXis/Scoring/Processing/ScoreProcessor.cs

@@ -232,6 +232,8 @@ public static double CalculatePerformance(float rating, float accuracy, int flaw
             val *= 0.6;
         if (mods.Any(x => x is NoEventMod))
             val *= 0.4;
+        if (mods.Any(x => x is NoMineMod))
+            val *= 0.6; // TODO: figure out actual value
 
         return val;
     }

fluXis/Scoring/Structs/HitResult.cs

@@ -16,15 +16,15 @@ namespace fluXis.Scoring.Structs;
     [JsonProperty("judgement")]
     public Judgement Judgement { get; init; }
 
-    [JsonProperty("holdend")]
-    public bool HoldEnd { get; init; }
+    [JsonProperty("result-type")]
+    public ResultType Type { get; init; }
 
-    public HitResult(double time, double diff, Judgement jud, bool end)
+    public HitResult(double time, double diff, Judgement jud, ResultType type)
     {
         Time = time;
         Difference = diff;
         Judgement = jud;
-        HoldEnd = end;
+        Type = type;
     }
 
     [JsonConstructor]

fluXis/Screens/Edit/Tabs/Charting/Blueprints/Placement/LandminePlacementBlueprint.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Linq;
+using fluXis.Screens.Edit.Tabs.Charting.Playfield;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osuTK.Input;
+
+namespace fluXis.Screens.Edit.Tabs.Charting.Blueprints.Placement;
+
+public partial class LandminePlacementBlueprint : NotePlacementBlueprint
+{
+    public override bool AllowPainting => true;
+    private readonly BlueprintNotePiece piece;
+
+    public LandminePlacementBlueprint()
+    {
+        RelativeSizeAxes = Axes.Both;
+        InternalChild = piece = new BlueprintNotePiece
+        {
+            Anchor = Anchor.TopLeft,
+            Origin = Anchor.BottomLeft,
+        };
+        //piece.Child.Colour = Theme.Red;
+
+        Hit.Type = 2;
+    }
+
+    public override void UpdatePlacement(double time, int lane)
+    {
+        base.UpdatePlacement(time, lane);
+
+        piece.Width = EditorHitObjectContainer.NOTEWIDTH;
+        piece.Position = ToLocalSpace(PositionProvider.ScreenSpacePositionAtTime(time, lane));
+    }
+
+    protected override bool OnMouseDown(MouseDownEvent e)
+    {
+        if (e.Button != MouseButton.Left)
+            return false;
+
+        base.OnMouseDown(e);
+        FinishPlacement(true);
+        return true;
+    }
+
+    protected override void OnPlacementFinished(bool commit)
+    {
+        if (Map.MapInfo.HitObjects.Where(x => x.Lane == Hit.Lane).Any(x => Math.Abs(x.Time - Hit.Time) < 10))
+            return;
+
+        base.OnPlacementFinished(commit);
+    }
+}

fluXis/Screens/Edit/Tabs/Charting/ChartingContainer.cs

@@ -45,7 +45,8 @@ public partial class ChartingContainer : EditorTabContainer, IKeyBindingHandler<
         new SelectTool(),
         new SingleNoteTool(),
         new LongNoteTool(),
-        new TickNoteTool()
+        new TickNoteTool(),
+        new LandmineTool()
     };
 
     public IReadOnlyList<EffectTool> EffectTools { get; } = new EffectTool[]
@@ -140,7 +141,7 @@ protected override void LoadComplete()
             new()
             {
                 Title = "Tools",
-                ExtraTitle = "(1-4)",
+                ExtraTitle = "(1-5)",
                 Icon = FontAwesome6.Solid.Pen,
                 Tools = Tools
             },

fluXis/Screens/Edit/Tabs/Charting/Playfield/EditorHitObjectContainer.cs

@@ -62,6 +62,10 @@ private void add(HitObject info)
             case 1:
                 draw = new EditorTickNote(info);
                 break;
+
+            case 2:
+                draw = new EditorLandmine(info);
+                break;
         }
 
         if (draw is null)