Reworked, see description

Moved timing to a global timer using the TimeKeeper singleton.
This dramatically improved mistiming, and synced everything that cares to be synced.
Added event bubbling for input.
Reworked ArrowType enum to have strict int values for simplicity.
Simplified dictionaries representing lane based data into arrays
Simplified notearrows to sprite2d and shifted test_scene for easy visual syncing.

Author: LifeHckr

project.godot

@@ -15,6 +15,10 @@ run/main_scene="res://scenes/ChartViewport/test_scene.tscn"
 config/features=PackedStringArray("4.3", "C#", "Forward Plus")
 config/icon="res://icon.svg"
 
+[autoload]
+
+TimeKeeper="*res://scripts/TimeKeeper.cs"
+
 [display]
 
 window/size/viewport_width=640

scenes/ChartViewport/BattleDirector.cs

@@ -16,9 +16,6 @@ public partial class BattleDirector : Node2D
     [Export]
     public NoteManager NM;
 
-    //TODO: Slowly add data based on what it needs.
-    private double _startTime;
-    private double _currentTime;
     private double _timingInterval = .1; //secs
 
     public struct SongData
@@ -29,32 +26,45 @@ public struct SongData
     }
 
     private SongData _curSong;
-    private Dictionary<string, Note[]> LaneNotes;
+    private readonly Note[][] _laneNotes = new Note[][]
+    {
+        Array.Empty<Note>(),
+        Array.Empty<Note>(),
+        Array.Empty<Note>(),
+        Array.Empty<Note>(),
+    };
     private Note[] _notes = Array.Empty<Note>();
 
     public override void _Ready()
     {
-        LaneNotes = new()
-        {
-            { "arrowUp", Array.Empty<Note>() },
-            { "arrowLeft", Array.Empty<Note>() },
-            { "arrowDown", Array.Empty<Note>() },
-            { "arrowRight", Array.Empty<Note>() },
-        };
         AddExampleNote();
 
         CM.PrepChart(_curSong, _notes);
         //TODO: Hook up signals
-        NM.Connect(nameof(NoteManager.NotePressed), new Callable(this, nameof(OnNotePressed)));
-        NM.Connect(nameof(NoteManager.NoteReleased), new Callable(this, nameof(OnNoteReleased)));
-
-        _startTime = (double)Time.GetTicksMsec() / 1000;
+        CM.Connect(nameof(NoteManager.NotePressed), new Callable(this, nameof(OnNotePressed)));
+        CM.Connect(nameof(NoteManager.NoteReleased), new Callable(this, nameof(OnNoteReleased)));
     }
 
     public override void _Process(double delta)
     {
-        _currentTime += delta;
-        //GD.Print($"Current Time: {_currentTime}");
+        TimeKeeper.CurrentTime += delta;
+        //Check beats downwards
+        double curBeat = TimeKeeper.CurrentTime / (60 / (double)_curSong.Bpm);
+        for (int i = 0; i < _laneNotes.Length; i++)
+        {
+            if (_laneNotes[i].Length > 0)
+            {
+                if (curBeat > _laneNotes[i][0].Beat + 1)
+                {
+                    GD.Print($"Beat: {_laneNotes[i][0].Beat} Miss");
+                    GD.Print(TimeKeeper.CurrentTime);
+                    //Cycle note queue
+                    _laneNotes[i].First().Beat += CM._beatsPerLoop;
+                    _laneNotes[i] = _laneNotes[i].Skip(1).Concat(_laneNotes[i].Take(1)).ToArray(); //TODO: No stackoverflow code
+                    CM.HandleNote((NoteArrow.ArrowType)i);
+                }
+            }
+        }
     }
 
     private void AddExampleNote()
@@ -63,55 +73,57 @@ private void AddExampleNote()
         _curSong = new SongData
         {
             Bpm = 120,
-            SongLength = 160,
+            SongLength = 100,
             NumLoops = 5,
         };
         //Add note
-        for (int i = 0; i < 5; i++)
+        for (int i = 0; i < 4; i++)
+        {
+            Note exampleNote = new Note(NoteArrow.ArrowType.Up, i + 3);
+            AddNoteToLane(exampleNote);
+        }
+        for (int i = 0; i < 1; i++)
         {
-            Note exampleNote = new Note(NoteArrow.ArrowType.Left, i + 9);
+            Note exampleNote = new Note(NoteArrow.ArrowType.Left, i + 4);
             AddNoteToLane(exampleNote);
         }
     }
 
     private void AddNoteToLane(Note note)
     {
         _notes = _notes.Append(note).ToArray();
-        LaneNotes[NM.Arrows[note.Type].Key] = LaneNotes[NM.Arrows[note.Type].Key]
-            .Append(note)
-            .ToArray();
+        _laneNotes[(int)note.Type] = _laneNotes[(int)note.Type].Append(note).ToArray();
     }
 
-    private void OnNotePressed(string key)
+    private void OnNotePressed(NoteArrow.ArrowType type)
     {
-        GD.Print("Note pressed: " + key + " at " + _currentTime + " seconds.");
-        CheckNoteTiming(key);
+        //GD.Print("Note pressed: " + type + " at " + _currentTime + " seconds.");
+        CheckNoteTiming(type);
     }
 
     private void OnNoteReleased(NoteArrow.ArrowType arrowType)
     {
-        GD.Print("Note released: " + arrowType + " at " + _currentTime + " seconds.");
+        //GD.Print("Note released: " + arrowType + " at " + _currentTime + " seconds.");
     }
 
-    private void CheckNoteTiming(string arrowString)
+    private void CheckNoteTiming(NoteArrow.ArrowType type)
     {
         //Assume queue structure for notes
         //Know current time, calculate beat timing
-        var curBeat = _currentTime / (60 / (double)_curSong.Bpm);
-        if (LaneNotes[arrowString].Length == 0)
+        double curBeat = TimeKeeper.CurrentTime / (60 / (double)_curSong.Bpm);
+        if (_laneNotes[(int)type].Length == 0)
             return;
-        double beatDif = Math.Abs(curBeat - LaneNotes[arrowString].First().Beat);
-        GD.Print(beatDif);
+        double beatDif = Math.Abs(curBeat - _laneNotes[(int)type].First().Beat);
         if (beatDif > 1)
             return;
-        GD.Print("Note Hit.");
+        GD.Print("Note Hit. Dif: " + beatDif);
+        CM.HandleNote(type);
         //Cycle note queue
-        LaneNotes[arrowString] = LaneNotes[arrowString]
+        _laneNotes[(int)type].First().Beat += CM._beatsPerLoop;
+        _laneNotes[(int)type] = _laneNotes[(int)type] //Credit: Stackoverflow https://stackoverflow.com/questions/49494535/moving-the-first-array-element-to-end-in-c-sharp
             .Skip(1)
-            .Concat(LaneNotes[arrowString].Take(1))
+            .Concat(_laneNotes[(int)type].Take(1))
             .ToArray(); //TODO: No stackoverflow code
-        //Change note visual
-        CM.TriggerArrow();
         //Do timing stuff
         if (beatDif < _timingInterval * 2)
         {

scenes/ChartViewport/ChartManager.cs

@@ -3,32 +3,6 @@
 using Godot;
 using ArrowType = NoteArrow.ArrowType;
 
-/*
-//Lets say this inits all the initial notes and manages the chart BG.
-
-//What does this do?
-//Input, visual looping, timing, battle stuff, combo, note creation
-
-//Focus on the looping
- This should manage creating sprites for notes???
- This should manage subview camera pos and zoom.
-
-Movement should primarily be done from a parent node
-!!Backgrounds need to be big enough/notes and beats spaced enough that when a note goes off screen, it can be teleported in position offscreen
-BackGround probably needs 2 sprites or parallax:
-    Get a set length, based on viewport and loop/song length (Const PLAYWIDTH)
-    Once one BG hits a certain left pos return it to the right pos
-
-Notes are similar, but only need 1 representation.
-    Once hits left bounds return to right bounds
-    (Something else should probably manage refreshing, input, etc)
-    Can probably use an object pool
-
-If timing based input checking:
-    This is enough, notes are visually just sprites
-    Collision based - This might need to manage that, or have a sister manager that does, notes need more stuff on their own
- */
-
 /**
  * @class ChartManager
  * @brief Chart Manager is meant to handle the visual aspects of a battle. Setting up the chart background, initial notes, and handle looping. WIP
@@ -42,22 +16,31 @@ public partial class ChartManager : SubViewportContainer
     [Export]
     public CanvasGroup ChartLoopables;
 
-    public BattleDirector.SongData SongData; //TODO: Maybe. Make settable from outside, but readonly
+    [Signal]
+    public delegate void NotePressedEventHandler(ArrowType arrowType);
+
+    [Signal]
+    public delegate void NoteReleasedEventHandler(ArrowType arrowType);
 
     //Arbitrary vars, play with these
-    private const double ChartLength = 2800; //Might move this to be song specific?
+    private double ChartLength = 2400; //Might move this to be song specific?
 
     //Speed that chart objs should move at, to be synced to song, in theory
-    private double _rateOfChart;
+    private double _rateOfChart; //Speed objects should move at px/s
     private double _loopLen; //secs
-    private int _beatsPerLoop;
+    public int _beatsPerLoop;
 
-    //TODO: Lanes
-    private NoteArrow[] _currentArrows = Array.Empty<NoteArrow>();
+    private NoteArrow[][] _currentArrows = new NoteArrow[][]
+    {
+        Array.Empty<NoteArrow>(),
+        Array.Empty<NoteArrow>(),
+        Array.Empty<NoteArrow>(),
+        Array.Empty<NoteArrow>(),
+    };
 
     private void InitBackgrounds()
     {
-        //TODO: Get better visual for BG's, and/or create BG's on demand. Though we should only ever need 2.
+        //TODO: Get better visual for BG's
         int i = 0;
         foreach (Node child in ChartLoopables.GetChildren())
         {
@@ -66,9 +49,7 @@ private void InitBackgrounds()
                 Loopable loopable = (Loopable)child;
                 //TODO: Consolidate
                 loopable.SetSize(new Vector2((float)ChartLength / 2 + 1, Size.Y));
-                loopable.SetPosition(new Vector2((float)ChartLength / 2 * i, 0));
-                loopable.Bounds = (float)ChartLength / 2;
-                loopable.Speed = (float)_rateOfChart;
+                loopable.Bounds = (float)ChartLength / 2 * i;
 
                 i++;
             }
@@ -82,54 +63,73 @@ private void InitNotes(Note[] notes)
             if (noteData != null)
                 CreateNote(noteData.Type, noteData.Beat);
         }
+        foreach (Note noteData in notes) //Temporary solution
+        {
+            if (noteData != null)
+                CreateNote(noteData.Type, noteData.Beat + _beatsPerLoop);
+        }
     }
 
     public void PrepChart(BattleDirector.SongData songData, Note[] notes)
     {
-        SongData = songData;
-
-        _loopLen = SongData.SongLength / SongData.NumLoops;
-        _beatsPerLoop = (int)(_loopLen / (60f / SongData.Bpm));
+        _loopLen = songData.SongLength / songData.NumLoops;
+        TimeKeeper.LoopLength = (float)_loopLen;
+        _beatsPerLoop = (int)(_loopLen / (60f / songData.Bpm));
+        ChartLength = (float)_loopLen * (float)Math.Floor(ChartLength / _loopLen);
+        TimeKeeper.ChartLength = (float)ChartLength;
 
         _rateOfChart = ChartLength / 2 / _loopLen; //px/s
 
         InitBackgrounds();
         InitNotes(notes);
+
+        NM.Connect(nameof(NoteManager.NotePressed), new Callable(this, nameof(OnNotePressed)));
+        NM.Connect(nameof(NoteManager.NoteReleased), new Callable(this, nameof(OnNoteReleased)));
     }
 
     //TODO: Rework these
     public NoteArrow CreateNote(ArrowType arrow, int beat = 0)
     {
-        var newNote = CreateNote(NM.Arrows[arrow]);
-        newNote.Bounds =
-            (float)((double)beat / _beatsPerLoop * (ChartLength / 2)) - newNote.Size.X / 2; //eww
+        var newNote = CreateNote(NM.Arrows[(int)arrow], beat);
+        newNote.Bounds = (float)((double)beat / _beatsPerLoop * (ChartLength / 2)); //eww
         newNote.Position += Vector2.Right * newNote.Bounds;
         return newNote;
     }
 
-    private NoteArrow CreateNote(NoteManager.ArrowData arrowData)
+    private NoteArrow CreateNote(NoteManager.ArrowData arrowData, int beat)
     {
         var noteScene = ResourceLoader.Load<PackedScene>("res://scenes/NoteManager/note.tscn");
         NoteArrow note = noteScene.Instantiate<NoteArrow>();
 
-        note.Init(arrowData, (float)_rateOfChart, -1);
-        _currentArrows = _currentArrows.Append(note).ToArray();
+        note.Init(arrowData);
+        if (!(beat > _beatsPerLoop))
+        {
+            _currentArrows[(int)arrowData.Type] = _currentArrows[(int)arrowData.Type]
+                .Append(note)
+                .ToArray();
+        }
         ChartLoopables.AddChild(note);
         return note;
     }
 
-    public void TriggerArrow()
+    public void HandleNote(ArrowType type)
+    {
+        _currentArrows[(int)type].First().NoteHit();
+        _currentArrows[(int)type] = _currentArrows[(int)type]
+            .Skip(1)
+            .Concat(_currentArrows[(int)type].Take(1))
+            .ToArray();
+    }
+
+    public void OnNotePressed(ArrowType type)
     {
-        _currentArrows.First().NoteHit();
-        _currentArrows = _currentArrows.Skip(1).ToArray();
+        if (_currentArrows[(int)type].Length == 0)
+            return;
+        EmitSignal(nameof(NotePressed), (int)type);
     }
 
-    //TODO: Queue next notes. Needs Timing System
-    /*The logic:
-     *Spawn in pos is a proportion (intended beat/beats per loop) = (intended pos/track length in px) ->
-     *		intended pos = intended beat / bpl * track length
-     *
-     *		Respawn (probably obj pool, or for now new instantiation)
-     *			When a note's pos is at its intended initial pos, queue up and spawn the next note of its beat at intended pos + track length
-     */
+    public void OnNoteReleased(ArrowType type)
+    {
+        EmitSignal(nameof(NoteReleased), (int)type);
+    }
 }

scenes/ChartViewport/ChartViewport.tscn

@@ -18,25 +18,23 @@ size = Vector2i(480, 220)
 render_target_update_mode = 4
 
 [node name="Camera2D" type="Camera2D" parent="SubViewport"]
-position = Vector2(240, 110)
+position = Vector2(-25, 0)
+anchor_mode = 0
 
 [node name="ChartLoopables" type="CanvasGroup" parent="SubViewport"]
 unique_name_in_owner = true
 
 [node name="ChartBG1" type="TextureRect" parent="SubViewport/ChartLoopables"]
 modulate = Color(2, 2, 2, 1)
-offset_top = -46.0
 offset_right = 701.0
-offset_bottom = 254.0
+offset_bottom = 300.0
 texture = ExtResource("1_0wnka")
 script = ExtResource("3_5u57h")
 
 [node name="ChartBG2" type="TextureRect" parent="SubViewport/ChartLoopables"]
 modulate = Color(2, 2, 2, 1)
-offset_left = 700.0
-offset_top = -46.0
-offset_right = 1401.0
-offset_bottom = 254.0
+offset_right = 701.0
+offset_bottom = 300.0
 texture = ExtResource("1_0wnka")
 script = ExtResource("3_5u57h")
 

scenes/ChartViewport/Loopable.cs

@@ -7,6 +7,7 @@
  */
 public partial class Loopable : TextureRect
 {
+    [Export]
     public float Bounds = 700f; //px Pos to loop or do something at.
     public float Speed = 5; //px/s
 
@@ -15,12 +16,19 @@ public override void _Process(double delta)
     {
         if (Position.X <= -Bounds)
         {
-            Loop();
+            //Loop();
         }
-        Position += Speed * Vector2.Left * (float)delta;
+        Vector2 newPos = Position;
+        newPos.X =
+            (float)(
+                (-TimeKeeper.CurrentTime / TimeKeeper.LoopLength * TimeKeeper.ChartLength)
+                % TimeKeeper.ChartLength
+                / 2
+            ) + Bounds;
+        Position = newPos;
     }
 
-    public virtual void Loop()
+    public void Loop()
     {
         Position = new Vector2(Bounds, Position.Y);
     }