Merge pull request #97 from neogeek/hotfix/added-missing-godot-method

[hotfix] Added missing method.

Author: neogeek

Documentation/API/Utilities/FindPositionNearGivenTick.md

@@ -56,6 +56,7 @@ extends Node
 func _ready() -> void:
 	var seconds = 5
 	var resolution = 192
+	var delta = 50
 
 	var notes = [
 		{"position": 768 }, {"position": 960 }, {"position": 1152 },
@@ -64,7 +65,7 @@ func _ready() -> void:
 		{"position": 3072 }, {"position": 3264 }
 	]
 
-	var note = rhythm_game_utilities.find_position_near_given_tick(notes, 750);
+	var note = rhythm_game_utilities.find_position_near_given_tick(notes, 750, delta);
 
 	print(note["position"]) # 768
 ```

GodotPlugin/include/rhythm_game_utilities.cpp

@@ -10,20 +10,15 @@ void rhythm_game_utilities::_bind_methods()
 {
     // Common
 
-    ClassDB::bind_static_method("rhythm_game_utilities",
-                                D_METHOD("lerp", "a", "b", "t"),
-                                &rhythm_game_utilities::lerp);
-
     ClassDB::bind_static_method("rhythm_game_utilities",
                                 D_METHOD("inverse_lerp", "a", "b", "v"),
                                 &rhythm_game_utilities::inverse_lerp);
 
-    // Parsers
+    ClassDB::bind_static_method("rhythm_game_utilities",
+                                D_METHOD("lerp", "a", "b", "t"),
+                                &rhythm_game_utilities::lerp);
 
-    ClassDB::bind_static_method(
-        "rhythm_game_utilities",
-        D_METHOD("parse_sections_from_chart", "contents"),
-        &rhythm_game_utilities::parse_sections_from_chart);
+    // Parsers
 
     ClassDB::bind_static_method(
         "rhythm_game_utilities",
@@ -45,13 +40,30 @@ void rhythm_game_utilities::_bind_methods()
         D_METHOD("parse_notes_from_chart_section", "section"),
         &rhythm_game_utilities::parse_notes_from_chart_section);
 
+    ClassDB::bind_static_method(
+        "rhythm_game_utilities",
+        D_METHOD("parse_sections_from_chart", "contents"),
+        &rhythm_game_utilities::parse_sections_from_chart);
+
     ClassDB::bind_static_method(
         "rhythm_game_utilities",
         D_METHOD("parse_time_signatures_from_chart_section", "section"),
         &rhythm_game_utilities::parse_time_signatures_from_chart_section);
 
     // Utilities
 
+    ClassDB::bind_static_method(
+        "rhythm_game_utilities",
+        D_METHOD("calculate_accuracy_ratio", "position", "current_position",
+                 "delta"),
+        &rhythm_game_utilities::calculate_accuracy_ratio);
+
+    ClassDB::bind_static_method("rhythm_game_utilities",
+                                D_METHOD("calculate_beat_bars", "bpm_changes",
+                                         "resolution", "ts",
+                                         "include_half_notes"),
+                                &rhythm_game_utilities::calculate_beat_bars);
+
     ClassDB::bind_static_method(
         "rhythm_game_utilities",
         D_METHOD("convert_seconds_to_ticks", "seconds", "resolution",
@@ -63,6 +75,11 @@ void rhythm_game_utilities::_bind_methods()
         D_METHOD("convert_tick_to_position", "tick", "resolution"),
         &rhythm_game_utilities::convert_tick_to_position);
 
+    ClassDB::bind_static_method(
+        "rhythm_game_utilities",
+        D_METHOD("find_position_near_given_tick", "notes", "tick", "delta"),
+        &rhythm_game_utilities::find_position_near_given_tick);
+
     ClassDB::bind_static_method(
         "rhythm_game_utilities",
         D_METHOD("is_on_the_beat", "bpm", "current_time", "delta"),
@@ -72,74 +89,22 @@ void rhythm_game_utilities::_bind_methods()
         "rhythm_game_utilities",
         D_METHOD("round_up_to_the_nearest_multiplier", "value", "multiplier"),
         &rhythm_game_utilities::round_up_to_the_nearest_multiplier);
-
-    ClassDB::bind_static_method(
-        "rhythm_game_utilities",
-        D_METHOD("calculate_accuracy_ratio", "position", "current_position",
-                 "delta"),
-        &rhythm_game_utilities::calculate_accuracy_ratio);
-
-    ClassDB::bind_static_method("rhythm_game_utilities",
-                                D_METHOD("calculate_beat_bars", "bpm_changes",
-                                         "resolution", "ts",
-                                         "include_half_notes"),
-                                &rhythm_game_utilities::calculate_beat_bars);
 }
 
 // Common
 
-float rhythm_game_utilities::lerp(float a, float b, float t)
-{
-    return RhythmGameUtilities::Lerp(a, b, t);
-}
-
 float rhythm_game_utilities::inverse_lerp(float a, float b, float v)
 {
     return RhythmGameUtilities::InverseLerp(a, b, v);
 }
 
-// Parsers
-
-Dictionary rhythm_game_utilities::parse_sections_from_chart(String contents)
+float rhythm_game_utilities::lerp(float a, float b, float t)
 {
-    Dictionary sections;
-
-    auto sections_internal =
-        RhythmGameUtilities::ParseSectionsFromChart(contents.utf8().get_data());
-
-    for (auto section_internal = sections_internal.begin();
-         section_internal != sections_internal.end(); section_internal++)
-    {
-        auto section_key = godot::String(section_internal->first.c_str());
-
-        Array section_items;
-
-        for (auto i = 0; i < section_internal->second.size(); i += 1)
-        {
-            Dictionary section_item;
-
-            auto temp = section_internal->second[i];
-
-            auto key = godot::Variant(temp.first.c_str());
-
-            Array values;
-
-            for (auto j = 0; j < temp.second.size(); j += 1)
-            {
-                values.append(godot::Variant(temp.second[j].c_str()));
-            }
-
-            section_item[key] = values;
-
-            section_items.append(section_item);
-        }
-
-        sections[section_key] = section_items;
-    }
-
-    return sections;
+    return RhythmGameUtilities::Lerp(a, b, t);
 }
 
+// Parsers
+
 Array rhythm_game_utilities::parse_bpm_from_chart_section(Array section)
 {
     auto bpm_changes_internal = RhythmGameUtilities::ParseBpmFromChartSection(
@@ -214,6 +179,46 @@ Array rhythm_game_utilities::parse_notes_from_chart_section(Array section)
     return notes;
 }
 
+Dictionary rhythm_game_utilities::parse_sections_from_chart(String contents)
+{
+    Dictionary sections;
+
+    auto sections_internal =
+        RhythmGameUtilities::ParseSectionsFromChart(contents.utf8().get_data());
+
+    for (auto section_internal = sections_internal.begin();
+         section_internal != sections_internal.end(); section_internal++)
+    {
+        auto section_key = godot::String(section_internal->first.c_str());
+
+        Array section_items;
+
+        for (auto i = 0; i < section_internal->second.size(); i += 1)
+        {
+            Dictionary section_item;
+
+            auto temp = section_internal->second[i];
+
+            auto key = godot::Variant(temp.first.c_str());
+
+            Array values;
+
+            for (auto j = 0; j < temp.second.size(); j += 1)
+            {
+                values.append(godot::Variant(temp.second[j].c_str()));
+            }
+
+            section_item[key] = values;
+
+            section_items.append(section_item);
+        }
+
+        sections[section_key] = section_items;
+    }
+
+    return sections;
+}
+
 Array rhythm_game_utilities::parse_time_signatures_from_chart_section(
     Array section)
 {
@@ -239,6 +244,54 @@ Array rhythm_game_utilities::parse_time_signatures_from_chart_section(
 
 // Utilities
 
+float rhythm_game_utilities::calculate_accuracy_ratio(int position,
+                                                      int current_position,
+                                                      int delta)
+{
+    return RhythmGameUtilities::CalculateAccuracyRatio(position,
+                                                       current_position, delta);
+}
+
+Array rhythm_game_utilities::calculate_beat_bars(Array bpm_changes,
+                                                 int resolution, int ts,
+                                                 bool 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_internal : beat_bars_internal)
+    {
+        Dictionary beat_bar_dictionary;
+
+        beat_bar_dictionary["position"] = beat_bar_internal.Position;
+        beat_bar_dictionary["bpm"] = beat_bar_internal.BPM;
+
+        beat_bars_dictionary_array.append(beat_bar_dictionary);
+    }
+
+    return beat_bars_dictionary_array;
+}
+
 int rhythm_game_utilities::convert_seconds_to_ticks(
     float seconds, int resolution, Array bpm_changes,
     Array time_signature_changes)
@@ -291,63 +344,53 @@ float rhythm_game_utilities::convert_tick_to_position(int tick, int resolution)
     return RhythmGameUtilities::ConvertTickToPosition(tick, resolution);
 }
 
-bool rhythm_game_utilities::is_on_the_beat(int bpm, float current_time,
-                                           float delta)
-{
-    return RhythmGameUtilities::IsOnTheBeat(bpm, current_time, delta);
-}
-
-int rhythm_game_utilities::round_up_to_the_nearest_multiplier(int value,
-                                                              int multiplier)
-{
-    return RhythmGameUtilities::RoundUpToTheNearestMultiplier(value,
-                                                              multiplier);
-}
-
-float rhythm_game_utilities::calculate_accuracy_ratio(int position,
-                                                      int current_position,
-                                                      int delta)
+Dictionary rhythm_game_utilities::find_position_near_given_tick(Array notes,
+                                                                int tick,
+                                                                int delta)
 {
-    return RhythmGameUtilities::CalculateAccuracyRatio(position,
-                                                       current_position, delta);
-}
-
-Array rhythm_game_utilities::calculate_beat_bars(Array bpm_changes,
-                                                 int resolution, int ts,
-                                                 bool include_half_notes)
-{
-    std::vector<RhythmGameUtilities::Tempo> bpm_changes_internal;
-    bpm_changes_internal.reserve(bpm_changes.size());
+    std::vector<RhythmGameUtilities::Note> notes_internal;
+    notes_internal.reserve(notes.size());
 
-    for (auto i = 0; i < bpm_changes.size(); i += 1)
+    for (auto i = 0; i < notes.size(); i += 1)
     {
-        RhythmGameUtilities::Tempo bpm_change_internal;
+        RhythmGameUtilities::Note note_internal;
 
-        if (bpm_changes[i].get_type() == Variant::DICTIONARY)
+        if (notes[i].get_type() == Variant::DICTIONARY)
         {
-            Dictionary variant = bpm_changes[i];
+            Dictionary variant = notes[i];
 
-            bpm_change_internal.Position = variant["position"];
-            bpm_change_internal.BPM = variant["bpm"];
+            note_internal.Position = variant["position"];
+            note_internal.HandPosition = variant["hand_position"];
+            note_internal.Length = variant["length"];
         }
 
-        bpm_changes_internal.push_back(bpm_change_internal);
+        notes_internal.push_back(note_internal);
     }
 
-    auto beat_bars_internal = RhythmGameUtilities::CalculateBeatBars(
-        bpm_changes_internal, resolution, ts, include_half_notes);
+    auto note_internal = RhythmGameUtilities::FindPositionNearGivenTick(
+        notes_internal, tick, delta);
 
-    Array beat_bars_dictionary_array;
+    Dictionary note;
 
-    for (auto &beat_bar_internal : beat_bars_internal)
+    if (note_internal)
     {
-        Dictionary beat_bar_dictionary;
+        note["position"] = note_internal->Position;
+        note["hand_position"] = note_internal->HandPosition;
+        note["length"] = note_internal->Length;
+    }
 
-        beat_bar_dictionary["position"] = beat_bar_internal.Position;
-        beat_bar_dictionary["bpm"] = beat_bar_internal.BPM;
+    return note;
+}
 
-        beat_bars_dictionary_array.append(beat_bar_dictionary);
-    }
+bool rhythm_game_utilities::is_on_the_beat(int bpm, float current_time,
+                                           float delta)
+{
+    return RhythmGameUtilities::IsOnTheBeat(bpm, current_time, delta);
+}
 
-    return beat_bars_dictionary_array;
+int rhythm_game_utilities::round_up_to_the_nearest_multiplier(int value,
+                                                              int multiplier)
+{
+    return RhythmGameUtilities::RoundUpToTheNearestMultiplier(value,
+                                                              multiplier);
 }