Lanes core

YARG.Core/Chart/Loaders/MoonSong/MoonSongLoader.Drums.cs

@@ -9,6 +9,9 @@ internal partial class MoonSongLoader : ISongLoader
     {
         private bool _discoFlip = false;
 
+        private uint _lastLanePhraseTick;
+        private List<int>? _validLaneNotes = null; 
+
         public InstrumentTrack<DrumNote> LoadDrumsTrack(Instrument instrument)
         {
             _discoFlip = false;
@@ -37,7 +40,10 @@ private DrumNote CreateFourLaneDrumNote(MoonNote moonNote, Dictionary<MoonPhrase
         {
             var pad = GetFourLaneDrumPad(moonNote);
             var noteType = GetDrumNoteType(moonNote);
+
             var generalFlags = GetGeneralFlags(moonNote, currentPhrases);
+            generalFlags = ModifyDrumLaneFlags(moonNote, currentPhrases, generalFlags);
+
             var drumFlags = GetDrumNoteFlags(moonNote, currentPhrases);
 
             double time = _moonSong.TickToTime(moonNote.tick);
@@ -48,7 +54,10 @@ private DrumNote CreateFiveLaneDrumNote(MoonNote moonNote, Dictionary<MoonPhrase
         {
             var pad = GetFiveLaneDrumPad(moonNote);
             var noteType = GetDrumNoteType(moonNote);
+
             var generalFlags = GetGeneralFlags(moonNote, currentPhrases);
+            generalFlags = ModifyDrumLaneFlags(moonNote, currentPhrases, generalFlags);
+
             var drumFlags = GetDrumNoteFlags(moonNote, currentPhrases);
 
             double time = _moonSong.TickToTime(moonNote.tick);
@@ -297,5 +306,118 @@ private DrumNoteFlags GetDrumNoteFlags(MoonNote moonNote, Dictionary<MoonPhrase.
 
             return flags;
         }
+
+        private NoteFlags ModifyDrumLaneFlags(MoonNote moonNote, Dictionary<MoonPhrase.Type, MoonPhrase> currentPhrases, NoteFlags flags)
+        {
+            MoonPhrase? lanePhrase = null;
+            bool isTrill = false;
+
+            if ((flags & NoteFlags.Tremolo) != 0)
+            {
+                currentPhrases.TryGetValue(MoonPhrase.Type.TremoloLane, out lanePhrase);
+            }
+            else if ((flags & NoteFlags.Trill) != 0)
+            {
+                currentPhrases.TryGetValue(MoonPhrase.Type.TrillLane, out lanePhrase);
+                isTrill = true;
+            }
+
+            if (lanePhrase == null)
+            {
+                return flags;
+            }
+
+            if (_validLaneNotes == null || lanePhrase.tick != _lastLanePhraseTick)
+            {
+                _lastLanePhraseTick = lanePhrase.tick;
+                _validLaneNotes = GetValidLaneNotes(moonNote, lanePhrase, isTrill);
+            }
+
+            if (!_validLaneNotes.Contains(moonNote.rawNote))
+            {
+                flags &= ~NoteFlags.Tremolo;
+                flags &= ~NoteFlags.Trill;
+                flags &= ~NoteFlags.LaneStart;
+                flags &= ~NoteFlags.LaneEnd;
+            }
+
+            return flags;
+
+            static List<int> GetValidLaneNotes(MoonNote moonNote, MoonPhrase lanePhrase, bool isTrill)
+            {
+                // Iterate forward every note in this phrase to find the notes that appear the most
+                // Assumes that this will only run when the first note in a phrase is provided
+                Dictionary<int,int> noteTotals = new();
+
+                // Stop searching if the current note value has this much of a lead over the others
+                const int CLINCH_THRESHOLD = 5;
+                int highestTotal = 0;
+
+                for (var noteRef = moonNote; noteRef != null && IsEventInPhrase(noteRef, lanePhrase); noteRef = noteRef.next)
+                {
+                    if (noteRef.isChord && noteRef.drumPad == MoonNote.DrumPad.Kick)
+                    {
+                        // Kick tremolos are only possible with a winning total on non-chorded kicks, no ties with other notes
+                        continue;
+                    }
+
+                    int thisNote = noteRef.rawNote;
+
+                    int thisTotal;
+                    if (noteTotals.ContainsKey(thisNote))
+                    {
+                        thisTotal = ++noteTotals[thisNote];
+                    }
+                    else
+                    {
+                        thisTotal = noteTotals[thisNote] = 1;
+                    }
+
+                    if (thisTotal <= highestTotal)
+                    {
+                        continue;
+                    }
+
+                    highestTotal = thisTotal;
+
+                    if (thisTotal >= CLINCH_THRESHOLD)
+                    {
+                        bool stopSearching = true;
+                        foreach(var (otherNote, otherTotal) in noteTotals)
+                        {
+                            if (otherNote == thisNote)
+                            {
+                                continue;
+                            }
+
+                            if (thisTotal - otherTotal < CLINCH_THRESHOLD)
+                            {
+                                stopSearching = false;
+                                break;
+                            }
+                        }
+
+                        if (stopSearching)
+                        {
+                            // Safe to say this is the only laned note a tremolo phrase
+                            break;
+                        }
+                    }
+                }
+
+                int validNoteTotal = isTrill ? highestTotal - 2 : highestTotal;
+                List<int> validTremoloNotes = new();
+
+                foreach (var (note, total) in noteTotals)
+                {
+                    if (total >= validNoteTotal)
+                    {
+                        validTremoloNotes.Add(note);
+                    }
+                }
+
+                return validTremoloNotes;
+            }
+        }
     }
 }

YARG.Core/Chart/Loaders/MoonSong/MoonSongLoader.cs

@@ -160,7 +160,9 @@ private List<TNote> GetNotes<TNote>(MoonChart moonChart, Difficulty difficulty,
 
                 // Skip Expert+ notes if not on Expert+
                 if (difficulty != Difficulty.ExpertPlus && (moonNote.flags & MoonNote.Flags.InstrumentPlus) != 0)
+                {
                     continue;
+                }
 
                 var newNote = createNote(moonNote, currentPhrases);
                 AddNoteToList(notes, newNote);
@@ -196,7 +198,9 @@ private List<Phrase> GetPhrases(MoonChart moonChart)
                 };
 
                 if (!phraseType.HasValue)
+                {
                     continue;
+                }
 
                 double time = _moonSong.TickToTime(moonPhrase.tick);
                 var newPhrase = new Phrase(phraseType.Value, time, GetLengthInTime(moonPhrase), moonPhrase.tick, moonPhrase.length);
@@ -232,10 +236,14 @@ private NoteFlags GetGeneralFlags(MoonNote moonNote, CurrentPhrases currentPhras
                 flags |= NoteFlags.StarPower;
 
                 if (previous == null || !IsEventInPhrase(previous, starPower))
+                {
                     flags |= NoteFlags.StarPowerStart;
+                }
 
                 if (next == null || !IsEventInPhrase(next, starPower))
+                {
                     flags |= NoteFlags.StarPowerEnd;
+                }
             }
 
             // Solos
@@ -244,10 +252,46 @@ private NoteFlags GetGeneralFlags(MoonNote moonNote, CurrentPhrases currentPhras
                 flags |= NoteFlags.Solo;
 
                 if (previous == null || !IsEventInPhrase(previous, solo))
+                {
                     flags |= NoteFlags.SoloStart;
+                }
 
                 if (next == null || !IsEventInPhrase(next, solo))
+                {
                     flags |= NoteFlags.SoloEnd;
+                }
+            }
+
+            // Trill
+            if (currentPhrases.TryGetValue(MoonPhrase.Type.TrillLane, out var trill) && IsEventInPhrase(moonNote, trill))
+            {
+                flags |= NoteFlags.Trill;
+
+                if (previous == null || !IsEventInPhrase(previous, trill))
+                {
+                    flags |= NoteFlags.LaneStart;
+                }
+
+                if (next == null || !IsEventInPhrase(next, trill))
+                {
+                    flags |= NoteFlags.LaneEnd;
+                }
+            }
+
+            // Tremolo
+            if (currentPhrases.TryGetValue(MoonPhrase.Type.TremoloLane, out var tremolo) && IsEventInPhrase(moonNote, tremolo))
+            {
+                flags |= NoteFlags.Tremolo;
+
+                if (previous == null || !IsEventInPhrase(previous, tremolo))
+                {
+                    flags |= NoteFlags.LaneStart;
+                }
+
+                if (next == null || !IsEventInPhrase(next, tremolo))
+                {
+                    flags |= NoteFlags.LaneEnd;
+                }
             }
 
             return flags;

YARG.Core/Chart/Notes/DrumNote.cs

@@ -21,6 +21,8 @@ public class DrumNote : Note<DrumNote>
 
         public bool IsStarPowerActivator => (DrumFlags & DrumNoteFlags.StarPowerActivator) != 0;
 
+        public override int LaneNote => Pad;
+
         public DrumNote(FourLaneDrumPad pad, DrumNoteType noteType, DrumNoteFlags drumFlags,
             NoteFlags flags, double time, uint tick)
             : this((int)pad, noteType, drumFlags, flags, time, tick)

YARG.Core/Chart/Notes/GuitarNote.cs

@@ -22,6 +22,8 @@ public class GuitarNote : Note<GuitarNote>
         public bool IsExtendedSustain => (GuitarFlags & GuitarNoteFlags.ExtendedSustain) != 0;
         public bool IsDisjoint        => (GuitarFlags & GuitarNoteFlags.Disjoint) != 0;
 
+        public override int LaneNote => NoteMask;
+
         public GuitarNote(FiveFretGuitarFret fret, GuitarNoteType noteType, GuitarNoteFlags guitarFlags,
             NoteFlags flags, double time, double timeLength, uint tick, uint tickLength)
             : this((int) fret, noteType, guitarFlags, flags, time, timeLength, tick, tickLength)

YARG.Core/Chart/Notes/Note.cs

@@ -16,6 +16,11 @@ public enum NoteFlags
         Solo      = 1 << 3,
         SoloStart = 1 << 4,
         SoloEnd   = 1 << 5,
+
+        Tremolo      = 1 << 6,
+        Trill      = 1 << 7,
+        LaneStart = 1 << 8,
+        LaneEnd   = 1 << 9,
     }
 
     public abstract class Note<TNote> : ChartEvent, ICloneable<TNote>
@@ -86,6 +91,14 @@ public AllNotesEnumerator GetEnumerator()
         public bool IsSoloStart => (Flags & NoteFlags.SoloStart) != 0;
         public bool IsSoloEnd   => (Flags & NoteFlags.SoloEnd) != 0;
 
+        public bool IsTremolo => (Flags & NoteFlags.Tremolo) != 0;
+        public bool IsTrill => (Flags & NoteFlags.Trill) != 0;
+        public bool IsLane => IsTremolo || IsTrill;
+        public bool IsLaneStart => (Flags & NoteFlags.LaneStart) != 0;
+        public bool IsLaneEnd   => (Flags & NoteFlags.LaneEnd) != 0;
+
+        public virtual int LaneNote => -1;
+
         /// <summary>
         /// Returns an enumerator that contains all child notes and the parent note itself (allocation free).
         /// </summary>
@@ -110,9 +123,14 @@ protected Note(Note<TNote> other) : base(other)
         public virtual void AddChildNote(TNote note)
         {
             if (note.Tick != Tick)
+            {
                 throw new InvalidOperationException("Child note being added is not on the same tick!");
+            }
+
             if (note.ChildNotes.Count > 0)
+            {
                 throw new InvalidOperationException("Child note being added has its own children!");
+            }
 
             note.Parent = (TNote) this;
             _childNotes.Add(note);
@@ -121,7 +139,10 @@ public virtual void AddChildNote(TNote note)
         public void SetHitState(bool hit, bool includeChildren)
         {
             WasHit = hit;
-            if (!includeChildren) return;
+            if (!includeChildren) 
+            {
+                return;
+            }
 
             foreach (var childNote in _childNotes)
             {
@@ -132,7 +153,10 @@ public void SetHitState(bool hit, bool includeChildren)
         public void SetMissState(bool miss, bool includeChildren)
         {
             WasMissed = miss;
-            if (!includeChildren) return;
+            if (!includeChildren)
+            {
+                return;
+            }
 
             foreach (var childNote in _childNotes)
             {

YARG.Core/Chart/Notes/ProKeysNote.cs

@@ -15,6 +15,8 @@ public class ProKeysNote : Note<ProKeysNote>
 
         public bool IsSustain => TickLength > 0;
 
+        public override int LaneNote => Key;
+
         public ProKeysNote(int key, ProKeysNoteFlags proKeysFlags, NoteFlags flags,
             double time, double timeLength, uint tick, uint tickLength)
             : base(flags, time, timeLength, tick, tickLength)