Parse hold notes from MIDI

Author: 12joan

Assets/StreamingAssets/Rhythm Game Data/Demo.mid

@@ -80,7 +80,7 @@ ref byte data2
       switch (metaEventType) {
         case (byte)MetaEventType.Tempo:
           var mspqn = (data[position + 1] << 16) | (data[position + 2] << 8) | data[position + 3];
-          data1 = (byte)(60000000.0 / mspqn);
+          data1 = (byte)Math.Round(60000000.0 / mspqn);
           position += 4;
           return true;
 

Assets/src/MidiParser.cs

@@ -1,77 +1,8 @@
 using System.Collections.Generic;
 using System.Linq;
-using MidiParser;
 using TMPro;
 using UnityEngine;
 
-public enum RhythmGameNoteType {
-  Left = 0,
-  Down = 1,
-  Up = 2,
-  Right = 3,
-};
-
-[System.Serializable]
-public class RhythmGameNote {
-  public RhythmGameNoteType Type;
-  public float Time;
-  public float Duration = 0f;
-
-  public bool IsHold => Duration > 0f;
-  public bool IsInstant => !IsHold;
-
-  public float RelativeTime(float currentTime, bool end = false) =>
-    Time - currentTime + (end ? Duration : 0f);
-}
-
-[System.Serializable]
-public class RhythmGameSong {
-  public float BeatsPerMinute;
-  public List<RhythmGameNote> Notes;
-
-  private static readonly Dictionary<int, RhythmGameNoteType> PITCH_TO_NOTE_TYPE = new()
-  {
-    { 65, RhythmGameNoteType.Left },
-    { 69, RhythmGameNoteType.Down },
-    { 72, RhythmGameNoteType.Up },
-    { 76, RhythmGameNoteType.Right },
-  };
-
-  public static RhythmGameSong ParseMidi(string path) {
-    MidiFile midi = new MidiFile(path);
-
-    if (midi.Tracks.Length != 1)
-      throw new System.Exception("MIDI file should have exactly one track");
-
-    MidiTrack track = midi.Tracks[0];
-
-    List<RhythmGameNote> notes = new();
-    float bpm = 120f;
-
-    foreach (MidiEvent midiEvent in track.MidiEvents) {
-      switch (midiEvent.MidiEventType) {
-        case MidiEventType.MetaEvent:
-          if (midiEvent.MetaEventType == MetaEventType.Tempo) {
-            // TODO: Track a list of tempo change events on the song object
-            bpm = (int)midiEvent.Arg2;
-          }
-          break;
-
-        case MidiEventType.NoteOn:
-          RhythmGameNoteType type = PITCH_TO_NOTE_TYPE[midiEvent.Note];
-          float beat = (float)midiEvent.Time / midi.TicksPerQuarterNote;
-          float time = beat * 60f / bpm;
-          notes.Add(new() { Type = type, Time = time });
-          break;
-
-        // TODO: Parse hold notes
-      }
-    }
-
-    return new RhythmGameSong { BeatsPerMinute = bpm, Notes = notes };
-  }
-}
-
 public class RhythmGame : MonoBehaviour {
   public RhythmGameNotesView NotesView;
   public TMP_Text ScoreText;
@@ -106,7 +37,7 @@ private readonly (float, string)[] NOTE_GRADES = {
   private int MaxPossibleScore;
 
   void Start() {
-    RhythmGameSong song = RhythmGameSong.ParseMidi(
+    RhythmGameSong song = RhythmGameSongParser.ParseMidi(
       System.IO.Path.Combine(Application.streamingAssetsPath, "Rhythm Game Data", "Demo.mid")
     );
 
@@ -151,7 +82,6 @@ void Update() {
     if (WrappedInput.GetButtonUp("Rhythm Game Left")) {
       HandleButtonUp(RhythmGameNoteType.Left);
     }
-
     if (WrappedInput.GetButtonUp("Rhythm Game Down")) {
       HandleButtonUp(RhythmGameNoteType.Down);
     }

Assets/src/RhythmGame.cs

@@ -0,0 +1,18 @@
+public enum RhythmGameNoteType {
+  Left = 0,
+  Down = 1,
+  Up = 2,
+  Right = 3,
+};
+
+public class RhythmGameNote {
+  public RhythmGameNoteType Type;
+  public float Time;
+  public float Duration = 0f;
+
+  public bool IsHold => Duration > 0f;
+  public bool IsInstant => !IsHold;
+
+  public float RelativeTime(float currentTime, bool end = false) =>
+    Time - currentTime + (end ? Duration : 0f);
+}

Assets/src/RhythmGameNote.cs

@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+public class RhythmGameSong {
+  public float BeatsPerMinute;
+  public List<RhythmGameNote> Notes;
+}

Assets/src/RhythmGameNote.cs.meta

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+using MidiParser;
+
+public class RhythmGameSongParser {
+  /**
+   * Each of the four note types is mapped to F4, A4, C5 and E5 respectively
+   * (the gaps on a treble stave in C Major). If a note's duration should be
+   * taken into consideration, it should be shifted up one degree in the C Major
+   * scale (i.e. on a line instead of a gap).
+   */
+  private readonly Dictionary<int, (RhythmGameNoteType, bool IsHold)> MIDI_PITCH_DATA = new()
+  {
+    { 65, (RhythmGameNoteType.Left, false) }, // F4
+    { 67, (RhythmGameNoteType.Left, true) }, // G4
+    { 69, (RhythmGameNoteType.Down, false) }, // A4
+    { 71, (RhythmGameNoteType.Down, true) }, // B4
+    { 72, (RhythmGameNoteType.Up, false) }, // C5
+    { 74, (RhythmGameNoteType.Up, true) }, // D5
+    { 76, (RhythmGameNoteType.Right, false) }, // E5
+    { 77, (RhythmGameNoteType.Right, true) }, // F5
+  };
+
+  private List<RhythmGameNote> Notes = new();
+  private int TicksPerBeat;
+  private float BeatsPerMinute = 120f;
+  private Dictionary<int, MidiEvent> NoteOnEvents = new();
+
+  public static RhythmGameSong ParseMidi(string path) {
+    MidiFile midi = new MidiFile(path);
+
+    if (midi.Tracks.Length != 1)
+      throw new System.Exception("MIDI file should have exactly one track");
+
+    RhythmGameSongParser parser = new(ticksPerBeat: midi.TicksPerQuarterNote);
+    midi.Tracks[0].MidiEvents.ForEach(parser.ParseMidiEvent);
+    return parser.GetSong();
+  }
+
+  private RhythmGameSongParser(int ticksPerBeat) {
+    TicksPerBeat = ticksPerBeat;
+  }
+
+  private void ParseMidiEvent(MidiEvent midiEvent) {
+    switch (midiEvent.MidiEventType) {
+      case MidiEventType.MetaEvent:
+        ParseMetaEvent(midiEvent);
+        break;
+
+      case MidiEventType.NoteOn:
+        ParseNoteOn(midiEvent);
+        break;
+
+      case MidiEventType.NoteOff:
+        ParseNoteOff(midiEvent);
+        break;
+    }
+  }
+
+  private void ParseMetaEvent(MidiEvent midiEvent) {
+    if (midiEvent.MetaEventType == MetaEventType.Tempo) {
+      // TODO: Track a list of tempo change events on the song object
+      BeatsPerMinute = (int)midiEvent.Arg2;
+    }
+  }
+
+  private void ParseNoteOn(MidiEvent midiEvent) {
+    /**
+     * Store the note on event so that we can reference it from the note off
+     * event.
+     */
+    NoteOnEvents[midiEvent.Note] = midiEvent;
+  }
+
+  private void ParseNoteOff(MidiEvent midiEvent) {
+    int pitch = midiEvent.Note;
+    var (type, isHold) = MIDI_PITCH_DATA[pitch];
+
+    float onTime = TicksToSeconds(NoteOnEvents[pitch].Time);
+    float offTime = TicksToSeconds(midiEvent.Time);
+    float actualDuration = offTime - onTime;
+    float effectiveDuration = isHold ? actualDuration : 0f;
+
+    AddNote(type, onTime, effectiveDuration);
+  }
+
+  private void AddNote(RhythmGameNoteType type, float time, float duration) {
+    Notes.Add(
+      new()
+      {
+        Type = type,
+        Time = time,
+        Duration = duration,
+      }
+    );
+  }
+
+  private float TicksToSeconds(float ticks) => ticks / TicksPerBeat * 60f / BeatsPerMinute;
+
+  private RhythmGameSong GetSong() => new() { BeatsPerMinute = BeatsPerMinute, Notes = Notes };
+}