Merge pull request #95 from neogeek/hotfix/update-godot-plugin

[hotfix] Updated Godot plugin.

Author: neogeek

GodotPlugin/include/rhythm_game_utilities.cpp

@@ -55,7 +55,7 @@ void rhythm_game_utilities::_bind_methods()
     ClassDB::bind_static_method(
         "rhythm_game_utilities",
         D_METHOD("convert_seconds_to_ticks", "seconds", "resolution",
-                 "bpm_changes"),
+                 "bpm_changes", "time_signature_changes"),
         &rhythm_game_utilities::convert_seconds_to_ticks);
 
     ClassDB::bind_static_method(
@@ -140,19 +140,24 @@ Dictionary rhythm_game_utilities::parse_sections_from_chart(String contents)
     return sections;
 }
 
-Dictionary rhythm_game_utilities::parse_bpm_from_chart_section(Array section)
+Array rhythm_game_utilities::parse_bpm_from_chart_section(Array section)
 {
-    auto bpm_internal = RhythmGameUtilities::ParseBpmFromChartSection(
+    auto bpm_changes_internal = RhythmGameUtilities::ParseBpmFromChartSection(
         convert_section_to_section_internal(section));
 
-    Dictionary bpm;
+    Array bpm_changes;
 
-    for (auto const &[key, val] : bpm_internal)
+    for (auto &bpm_change_internal : bpm_changes_internal)
     {
-        bpm[key] = bpm_internal[key];
+        Dictionary bpm_change;
+
+        bpm_change["position"] = bpm_change_internal.Position;
+        bpm_change["bpm"] = bpm_change_internal.BPM;
+
+        bpm_changes.append(bpm_change);
     }
 
-    return bpm;
+    return bpm_changes;
 }
 
 Dictionary rhythm_game_utilities::parse_lyrics_from_chart_section(Array section)
@@ -199,41 +204,86 @@ Array rhythm_game_utilities::parse_notes_from_chart_section(Array section)
     {
         Dictionary note;
 
+        note["position"] = note_internal.Position;
         note["hand_position"] = note_internal.HandPosition;
         note["length"] = note_internal.Length;
-        note["position"] = note_internal.Position;
 
         notes.append(note);
     }
 
     return notes;
 }
 
-Dictionary
-rhythm_game_utilities::parse_time_signatures_from_chart_section(Array section)
+Array rhythm_game_utilities::parse_time_signatures_from_chart_section(
+    Array section)
 {
     auto time_signatures_internal =
         RhythmGameUtilities::ParseTimeSignaturesFromChartSection(
             convert_section_to_section_internal(section));
 
-    Dictionary time_signatures;
+    Array time_signatures;
 
-    for (auto const &[key, val] : time_signatures_internal)
+    for (auto &time_signature_internal : time_signatures_internal)
     {
-        time_signatures[key] = time_signatures_internal[key];
+        Dictionary time_signature;
+
+        time_signature["position"] = time_signature_internal.Position;
+        time_signature["numerator"] = time_signature_internal.Numerator;
+        time_signature["denominator"] = time_signature_internal.Denominator;
+
+        time_signatures.append(time_signature);
     }
 
     return time_signatures;
 }
 
 // Utilities
 
-int rhythm_game_utilities::convert_seconds_to_ticks(float seconds,
-                                                    int resolution,
-                                                    Dictionary bpm_changes)
+int rhythm_game_utilities::convert_seconds_to_ticks(
+    float seconds, int resolution, Array bpm_changes,
+    Array time_signature_changes)
 {
+    std::vector<RhythmGameUtilities::Tempo> bpm_changes_internal;
+    bpm_changes_internal.reserve(bpm_changes.size());
+
+    for (auto i = 0; i < bpm_changes.size(); i += 1)
+    {
+        RhythmGameUtilities::Tempo bpm_change_internal;
+
+        if (bpm_changes[i].get_type() == Variant::DICTIONARY)
+        {
+            Dictionary variant = bpm_changes[i];
+
+            bpm_change_internal.Position = variant["position"];
+            bpm_change_internal.BPM = variant["bpm"];
+        }
+
+        bpm_changes_internal.push_back(bpm_change_internal);
+    }
+
+    std::vector<RhythmGameUtilities::TimeSignature>
+        time_signature_changes_internal;
+    time_signature_changes_internal.reserve(time_signature_changes.size());
+
+    for (auto i = 0; i < time_signature_changes.size(); i += 1)
+    {
+        RhythmGameUtilities::TimeSignature time_signature_internal;
+
+        if (time_signature_changes[i].get_type() == Variant::DICTIONARY)
+        {
+            Dictionary variant = time_signature_changes[i];
+
+            time_signature_internal.Position = variant["position"];
+            time_signature_internal.Numerator = variant["numerator"];
+            time_signature_internal.Denominator = variant["denominator"];
+        }
+
+        time_signature_changes_internal.push_back(time_signature_internal);
+    }
+
     return RhythmGameUtilities::ConvertSecondsToTicks(
-        seconds, resolution, convert_dictionary_to_map<int, int>(bpm_changes));
+        seconds, resolution, bpm_changes_internal,
+        time_signature_changes_internal);
 }
 
 float rhythm_game_utilities::convert_tick_to_position(int tick, int resolution)
@@ -262,22 +312,39 @@ float rhythm_game_utilities::calculate_accuracy_ratio(int position,
                                                        current_position, delta);
 }
 
-Array rhythm_game_utilities::calculate_beat_bars(Dictionary bpm_changes,
+Array rhythm_game_utilities::calculate_beat_bars(Array bpm_changes,
                                                  int resolution, int ts,
                                                  bool include_half_notes)
 {
-    auto beat_bars = RhythmGameUtilities::CalculateBeatBars(
-        convert_dictionary_to_map<int, int>(bpm_changes), resolution, ts,
-        include_half_notes);
+    std::vector<RhythmGameUtilities::Tempo> bpm_changes_internal;
+    bpm_changes_internal.reserve(bpm_changes.size());
+
+    for (auto i = 0; i < bpm_changes.size(); i += 1)
+    {
+        RhythmGameUtilities::Tempo bpm_change_internal;
+
+        if (bpm_changes[i].get_type() == Variant::DICTIONARY)
+        {
+            Dictionary variant = bpm_changes[i];
+
+            bpm_change_internal.Position = variant["position"];
+            bpm_change_internal.BPM = variant["bpm"];
+        }
+
+        bpm_changes_internal.push_back(bpm_change_internal);
+    }
+
+    auto beat_bars_internal = RhythmGameUtilities::CalculateBeatBars(
+        bpm_changes_internal, resolution, ts, include_half_notes);
 
     Array beat_bars_dictionary_array;
 
-    for (auto &beat_bar : beat_bars)
+    for (auto &beat_bar_internal : beat_bars_internal)
     {
         Dictionary beat_bar_dictionary;
 
-        beat_bar_dictionary["bpm"] = beat_bar.BPM;
-        beat_bar_dictionary["position"] = beat_bar.Position;
+        beat_bar_dictionary["position"] = beat_bar_internal.Position;
+        beat_bar_dictionary["bpm"] = beat_bar_internal.BPM;
 
         beat_bars_dictionary_array.append(beat_bar_dictionary);
     }

GodotPlugin/include/rhythm_game_utilities.h

@@ -26,20 +26,21 @@ class rhythm_game_utilities : public Object
 
     static Dictionary parse_sections_from_chart(String contents);
 
-    static Dictionary parse_bpm_from_chart_section(Array section);
+    static Array parse_bpm_from_chart_section(Array section);
 
     static Dictionary parse_lyrics_from_chart_section(Array section);
 
     static Dictionary parse_meta_data_from_chart_section(Array section);
 
     static Array parse_notes_from_chart_section(Array section);
 
-    static Dictionary parse_time_signatures_from_chart_section(Array section);
+    static Array parse_time_signatures_from_chart_section(Array section);
 
     // Utilities
 
     static int convert_seconds_to_ticks(float seconds, int resolution,
-                                        Dictionary bpm_changes);
+                                        Array bpm_changes,
+                                        Array time_signature_changes);
 
     static float convert_tick_to_position(int tick, int resolution);
 
@@ -51,6 +52,6 @@ class rhythm_game_utilities : public Object
     static float calculate_accuracy_ratio(int position, int current_position,
                                           int delta = 50);
 
-    static Array calculate_beat_bars(Dictionary bpm_changes, int resolution,
-                                     int ts, bool include_half_notes);
+    static Array calculate_beat_bars(Array bpm_changes, int resolution, int ts,
+                                     bool include_half_notes);
 };

GodotPlugin/include/utilities.hpp

@@ -6,22 +6,6 @@
 
 using namespace godot;
 
-template <typename T1, typename T2>
-std::map<T1, T2> convert_dictionary_to_map(Dictionary input)
-{
-    std::map<T1, T2> output;
-
-    auto keys = input.keys();
-
-    for (auto i = 0; i < keys.size(); i += 1)
-    {
-        auto key = keys[i];
-        output[key] = input[key];
-    }
-
-    return output;
-}
-
 std::vector<std::pair<std::string, std::vector<std::string>>>
 convert_section_to_section_internal(Array section)
 {