proper hit detection and tick notes

Author: flustix

fluXis/Modes/Gameplay/Input/GameModeKeybindContainer.cs

@@ -22,7 +22,8 @@ public abstract partial class GameModeKeybindContainer<T> : KeyBindingContainer<
     private readonly Dictionary<int, T> intToActionMap;
     private readonly Dictionary<T, int> actionToIntMap;
 
-    protected GameModeKeybindContainer()
+    protected GameModeKeybindContainer(SimultaneousBindingMode simultaneousMode = SimultaneousBindingMode.Unique, KeyCombinationMatchingMode matchingMode = KeyCombinationMatchingMode.Any)
+        : base(simultaneousMode, matchingMode)
     {
         intToActionMap = Enum.GetValues<T>().ToDictionary(x => Convert.ToInt32(x), x => x);
         actionToIntMap = Enum.GetValues<T>().ToDictionary(x => x, x => Convert.ToInt32(x));

fluXis/Modes/Gameplay/Objects/DrawableHitObject.cs

@@ -24,7 +24,7 @@ public abstract partial class DrawableHitObject : CompositeDrawable
     protected double TimeDelta => Object.Time - Time.Current;
     public abstract bool CanBeRemoved { get; }
 
-    public bool Judged { get; private set; }
+    public bool Judged { get; protected set; }
     public HitWindows HitWindows => hitWindowLazy.Value;
     public Action<DrawableHitObject, double>? OnHit { get; set; }
 
@@ -35,6 +35,25 @@ protected DrawableHitObject(HitObject o)
         Object = o;
         hitWindowLazy = new Lazy<HitWindows>(() => Ruleset.PlayableMode.CreateHitWindowFor(Object));
     }
+
+    protected bool UpdateJudgement(bool byUser)
+    {
+        if (Judged)
+            return false;
+
+        CheckJudgement(byUser, TimeDelta);
+        return Judged;
+    }
+
+    protected virtual void CheckJudgement(bool byUser, double offset) { }
+
+    protected void ApplyResult(double diff)
+    {
+        if (Judged) throw new InvalidOperationException("Can not apply judgement to already judged HitObject.");
+
+        Judged = true;
+        OnHit?.Invoke(this, diff);
+    }
 }
 
 public abstract partial class DrawableHitObject<T> : DrawableHitObject

fluXis/Modes/Gameplay/Objects/GameModeHitObjectManager.cs

@@ -66,14 +66,15 @@ protected override void Update()
 
         while (FutureObjects is { Count: > 0 } && (ShouldBeRendered(FutureObjects[0]) || ActiveObjects.Count < MinimumLoadedHitObject))
         {
-            var hit = createObject(FutureObjects[0]);
+            var hit = FutureObjects[0];
+            var draw = createObject(hit);
 
             FutureObjects.RemoveAt(0);
 
-            if (hit is null) // this will break stuff 100%, but it won't freeze the game
-                PastObjects.Push(FutureObjects[0]);
+            if (draw is null) // this will break stuff 100%, but it won't freeze the game
+                PastObjects.Push(hit);
             else
-                ActiveObjects.Add(hit);
+                ActiveObjects.Add(draw);
         }
 
         while (ActiveObjects.Count > 0 && !ShouldBeRendered(ActiveObjects[0].Object) && ActiveObjects.Count > MinimumLoadedHitObject)
@@ -82,7 +83,7 @@ protected override void Update()
             removeObject(hit, true);
         }
 
-        foreach (var hitObject in ActiveObjects.Where(h => h.CanBeRemoved).Reverse().ToList())
+        foreach (var hitObject in ActiveObjects.Where(h => h.CanBeRemoved).ToList())
             removeObject(hitObject);
 
         while (Ruleset.AllowReverting && PastObjects.Count > 0)

fluXis/Modes/Keys/Gameplay/KeysKeybindContainer.cs

@@ -13,30 +13,22 @@ public partial class KeysKeybindContainer : GameModeKeybindContainer<FluXisGamep
 {
     public override IEnumerable<IKeyBinding> DefaultKeyBindings { get; }
 
-    public bool[] Pressed { get; }
     public double[] PressTimes { get; }
     public FluXisGameplayKeybind[] Keys { get; }
 
     public KeysKeybindContainer(int mode, bool dual)
     {
-        DefaultKeyBindings = GetKeys(mode, dual);
-        Keys = [.. DefaultKeyBindings.Select(x => (FluXisGameplayKeybind)x.Action)];
-
-        if (dual)
-            mode *= 2;
-
-        Pressed = new bool[mode];
-        PressTimes = new double[mode];
+        var binds = DefaultKeyBindings = GetKeys(mode, dual);
+        Keys = [.. binds.Select(x => (FluXisGameplayKeybind)x.Action)];
+        PressTimes = new double[Keys.Length];
     }
 
     protected override Drawable PropagatePressed(IEnumerable<Drawable> drawables, InputState state, FluXisGameplayKeybind pressed, float scrollAmount = 0, bool isPrecise = false, bool repeat = false)
     {
         var idx = Array.IndexOf(Keys, pressed);
         if (idx == -1) return null;
 
-        Pressed[idx] = true;
         PressTimes[idx] = Time.Current;
-
         return base.PropagatePressed(drawables, state, pressed, scrollAmount, isPrecise, repeat);
     }
 
@@ -45,9 +37,7 @@ protected override void PropagateReleased(IEnumerable<Drawable> drawables, Input
         var idx = Array.IndexOf(Keys, released);
         if (idx == -1) return;
 
-        Pressed[idx] = false;
         PressTimes[idx] = 0;
-
         base.PropagateReleased(drawables, state, released);
     }
 
@@ -73,7 +63,7 @@ public static IEnumerable<KeyBinding> GetKeys(int mode, bool dual)
             }
         }
         else
-            binds = Enum.GetValues<FluXisGameplayKeybind>().ToList();
+            binds = [.. Enum.GetValues<FluXisGameplayKeybind>()];
 
         return binds.Select(b => new KeyBinding(GetDefaultFor(b), b));
     }

fluXis/Modes/Keys/Gameplay/Objects/KeysHitObjectManager.cs

@@ -16,7 +16,7 @@ namespace fluXis.Modes.Keys.Gameplay.Objects;
 
 public partial class KeysHitObjectManager : GameModeHitObjectManager
 {
-    protected ScrollGroup DefaultScrollGroup { get; init; }
+    public ScrollGroup DefaultScrollGroup { get; init; }
 
     public float ScrollSpeed
     {
@@ -67,6 +67,7 @@ protected override bool ShouldBeRendered(HitObject obj)
     {
         TimingLine line => new KeysDrawableTimingLine(line),
         { Type: HitObjectType.Normal, LongNote: false } => new DrawableNote(obj),
+        { Type: HitObjectType.Tick } => new DrawableTick(obj),
         _ => null
     };
 

fluXis/Modes/Keys/HitObjects/DrawableLandmine.cs

@@ -1,4 +1,3 @@
-using System;
 using fluXis.Input;
 using fluXis.Map.Structures;
 using fluXis.Scoring;
@@ -30,7 +29,7 @@ private bool didNotGetHit
     [Resolved]
     private GameplayInput input { get; set; }
 
-    private bool isBeingHeld => Keybinds.Pressed[Array.IndexOf(Keybinds.Keys, Keybind)];
+    private bool isBeingHeld => Keybinds.PressedActions.Contains(Keybind);
 
     // next non-landmine HitObject on the column. Only set if the landmine is in the hit window of the next note, null otherwise.
     private HitObject nextNote;

fluXis/Modes/Keys/Map/Objects/Drawable/DrawableKeysHitObject.cs

@@ -1,6 +1,10 @@
+using System;
+using fluXis.Input;
 using fluXis.Map.Structures;
 using fluXis.Modes.Gameplay.Objects;
+using fluXis.Modes.Keys.Gameplay;
 using fluXis.Modes.Keys.Gameplay.Objects;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 
 namespace fluXis.Modes.Keys.Map.Objects.Drawable;
@@ -12,6 +16,9 @@ public abstract partial class DrawableKeysHitObject<T> : DrawableHitObject<T>
 {
     protected new KeysHitObjectManager Manager => (KeysHitObjectManager)base.Manager;
 
+    [Resolved]
+    protected KeysKeybindContainer Keybinds { get; private set; } = null!;
+
     protected int PlayerLane
     {
         get
@@ -25,6 +32,10 @@ protected int PlayerLane
         }
     }
 
+    public FluXisGameplayKeybind Action { get; set; }
+
+    protected double ScrollVelocityTime { get; private set; }
+
     protected DrawableKeysHitObject(T o)
         : base(o)
     {
@@ -34,10 +45,19 @@ protected DrawableKeysHitObject(T o)
         Masking = true;
     }
 
+    [BackgroundDependencyLoader]
+    private void load()
+    {
+        Action = Keybinds.Keys[Math.Clamp(Object.Lane - 1, 0, Keybinds.Keys.Length - 1)];
+
+        var group = Object.ScrollGroup ?? Manager.DefaultScrollGroup;
+        ScrollVelocityTime = group.PositionFromTime(Object.Time);
+    }
+
     protected override void Update()
     {
         base.Update();
 
-        Y = Manager.PositionAtTime(Object.Time);
+        Y = Manager.PositionAtTime(ScrollVelocityTime, Object.ScrollGroup);
     }
 }

fluXis/Modes/Keys/Map/Objects/Drawable/DrawableNote.cs

@@ -1,12 +1,15 @@
+using fluXis.Input;
 using fluXis.Map.Structures;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 
 namespace fluXis.Modes.Keys.Map.Objects.Drawable;
 
 #nullable enable
 
-public partial class DrawableNote : DrawableKeysHitObject<HitObject>
+public partial class DrawableNote : DrawableKeysHitObject<HitObject>, IKeyBindingHandler<FluXisGameplayKeybind>
 {
     public override bool CanBeRemoved => Judged || Time.Current - Object.Time > HitWindows.TimingFor(HitWindows.LowestHitable);
 
@@ -20,4 +23,23 @@ private void load()
     {
         InternalChild = Skin.GetHitObject(PlayerLane, Manager.KeyCount).With(d => d.RelativeSizeAxes = Axes.X);
     }
+
+    protected override void CheckJudgement(bool byUser, double offset)
+    {
+        if (!byUser)
+        {
+            ApplyResult(HitWindows.TimingFor(HitWindows.Lowest));
+            return;
+        }
+
+        if (!HitWindows.CanBeHit(offset))
+            return;
+
+        ApplyResult(offset);
+    }
+
+    public bool OnPressed(KeyBindingPressEvent<FluXisGameplayKeybind> e)
+        => e.Action == Action && UpdateJudgement(true);
+
+    public void OnReleased(KeyBindingReleaseEvent<FluXisGameplayKeybind> e) { }
 }

fluXis/Modes/Keys/Map/Objects/Drawable/DrawableTick.cs

@@ -0,0 +1,110 @@
+using System;
+using fluXis.Input;
+using fluXis.Map.Structures;
+using fluXis.Scoring.Enums;
+using fluXis.Utils.Extensions;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+
+namespace fluXis.Modes.Keys.Map.Objects.Drawable;
+
+#nullable enable
+
+public partial class DrawableTick : DrawableKeysHitObject<HitObject>, IKeyBindingHandler<FluXisGameplayKeybind>
+{
+    public override bool CanBeRemoved => Judged || wouldMiss;
+    private bool wouldMiss => Time.Current - Object.Time > HitWindows.TimingFor(HitWindows.LowestHitable);
+
+    private int actionIndex;
+
+    private bool heldDown;
+    private bool directHit = false;
+    private double? holdStartTime;
+
+    public DrawableTick(HitObject o)
+        : base(o)
+    {
+    }
+
+    [BackgroundDependencyLoader]
+    private void load()
+    {
+        InternalChild = Skin.GetTickNote(PlayerLane, Manager.KeyCount, Object.HoldTime > 0).WithRelativeSize(Axes.X);
+        actionIndex = Array.IndexOf(Keybinds.Keys, Action);
+    }
+
+    protected override void Update()
+    {
+        base.Update();
+
+        heldDown = Keybinds.PressedActions.Contains(Action);
+        holdStartTime = heldDown ? Keybinds.PressTimes[actionIndex] : null;
+
+        if (heldDown) UpdateJudgement(true);
+    }
+
+    protected override void CheckJudgement(bool byUser, double offset)
+    {
+        if (!byUser)
+        {
+            ApplyResult(lagCompensation() ?? HitWindows.TimingFor(HitWindows.Lowest));
+            return;
+        }
+
+        if (offset >= 0 && !directHit)
+            return;
+
+        if (wouldMiss)
+        {
+            var off = lagCompensation();
+
+            if (off != null)
+            {
+                ApplyResult(off.Value);
+                return;
+            }
+        }
+
+        // ObjectManager.PlayHitSound(Data, false);
+        ApplyResult(lagCompensation() ?? offset);
+        return;
+
+        double? lagCompensation()
+        {
+            if (heldDown && holdStartTime != null)
+            {
+                var delta = holdStartTime.Value - Object.Time;
+                return delta < 0 ? 0 : delta;
+            }
+
+            return null;
+        }
+    }
+
+    public bool OnPressed(KeyBindingPressEvent<FluXisGameplayKeybind> e)
+    {
+        if (e.Action != Action)
+            return false;
+
+        var flWindow = HitWindows.TimingFor(Judgement.Flawless);
+
+        if (Math.Abs(TimeDelta) < flWindow)
+        {
+            directHit = true;
+            UpdateJudgement(true);
+            return true;
+        }
+
+        return false;
+    }
+
+    public void OnReleased(KeyBindingReleaseEvent<FluXisGameplayKeybind> e)
+    {
+        if (e.Action != Action)
+            return;
+
+        UpdateJudgement(true);
+    }
+}