Fix hot reloading hanging

Co-Authored-By: ACrazyTown <47027981+ACrazyTown@users.noreply.github.com>
Co-Authored-By: Kolo <67389779+KoloInDaCrib@users.noreply.github.com>
Co-Authored-By: Mihai Alexandru <77043862+MAJigsaw77@users.noreply.github.com>

Author: 4 people

source/funkin/data/character/CharacterData.hx

@@ -279,8 +279,8 @@ class CharacterDataParser
       {entryId:String, error:Any, ?entryCls:String}> = new SynchronizedArray();
 
     var charIdList:Array<String> = funkin.modding.compat.RegistryData.listEntryIds(DATA_FILE_PATH, true);
-    var previousScriptedEntryClasses:Array<String> = [];
-    var scriptedEntryClassNames:Array<String> = [];
+    var previousScriptedEntryClasses:SynchronizedArray<String> = new SynchronizedArray<String>();
+    var scriptedEntryClassNames:SynchronizedArray<String> = new SynchronizedArray<String>();
     var entryCount:Int = 0;
 
     // Used to track the state we're in while loading the characters. This can either be us loading all character data, or loading each scripted character types.
@@ -507,7 +507,7 @@ class CharacterDataParser
     {
       var loadScriptedEntriesFuture = TaskHandler.performSimpleTask(() ->
       {
-        scriptedEntryClassNames = switch (entryLoadingState)
+        var scriptedClsNames:Array<String> = switch (entryLoadingState)
         {
           case 'sparrow':
             SparrowCharacter.listScriptClasses();
@@ -529,12 +529,14 @@ class CharacterDataParser
           default:
             [];
         }
+        scriptedEntryClassNames.clear();
+        scriptedEntryClassNames.addAll(scriptedClsNames);
 
         // We concatenate this list so we can use this when checking for BaseCharacter entries.
-        previousScriptedEntryClasses = previousScriptedEntryClasses.concat(scriptedEntryClassNames);
+        previousScriptedEntryClasses.addAll(scriptedClsNames);
 
-        log('Queuing loading for ${scriptedEntryClassNames.length} $entryLoadingState character scripted entries...');
-        entryCount += scriptedEntryClassNames.length; // Since this function is called several times, we increment the entry count for each use.
+        log('Queuing loading for ${scriptedClsNames.length} $entryLoadingState character scripted entries...');
+        entryCount += scriptedClsNames.length; // Since this function is called several times, we increment the entry count for each use.
 
         return true;
       });

source/funkin/data/event/SongEventRegistry.hx

@@ -26,10 +26,15 @@ class SongEventRegistry
    * Every built-in event class must be added to this list.
    * Thankfully, with the power of `ClassMacro`, this is done automatically.
    */
-  static final BUILTIN_EVENTS:List<Class<SongEvent>> = ClassMacro.listSubclassesOf(SongEvent).filter((cls:Class<SongEvent>) -> ![
-    'funkin.play.event.SongEvent'
-  ].contains(Type.getClassName(cls)));
-
+  #if FEATURE_MULTITHREADING
+  static final BUILTIN_EVENTS:SynchronizedArray<Class<SongEvent>> = new SynchronizedArray<Class<SongEvent>>(
+    ClassMacro.listSubclassesOf(SongEvent).filter((cls:Class<SongEvent>) -> !['funkin.play.event.SongEvent'].contains(Type.getClassName(cls)))
+  );
+  #else
+  static final BUILTIN_EVENTS:Array<Class<SongEvent>> = ClassMacro
+    .listSubclassesOf(SongEvent)
+    .filter((cls:Class<SongEvent>) -> !['funkin.play.event.SongEvent'].contains(Type.getClassName(cls)));
+  #end
   /**
    * Map of internal handlers for song events.
    * These may be either `ScriptedSongEvents` or built-in classes extending `SongEvent`.
@@ -94,7 +99,7 @@ class SongEventRegistry
       {eventId:String, error:Any, ?eventCls:String}> = new SynchronizedArray();
 
     var entryCount:Int = 0;
-    var scriptedEventClassNames:Array<String> = [];
+    var scriptedEventClassNames:SynchronizedArray<String> = new SynchronizedArray<String>();
     var loadedBaseEvents:Bool = false;
 
     var loadBaseEventsAsync:Void->Void = () -> {};
@@ -217,7 +222,7 @@ class SongEventRegistry
 
     loadScriptedEventsAsync = () ->
     {
-      scriptedEventClassNames = SongEvent.listScriptClasses();
+      scriptedEventClassNames = new SynchronizedArray<String>(SongEvent.listScriptClasses());
       entryCount = EVENT_CACHE.size() + scriptedEventClassNames.length;
 
       trace('Instantiating ${scriptedEventClassNames.length} scripted song events...');

source/funkin/data/song/SongRegistry.hx

@@ -10,6 +10,9 @@ import funkin.play.song.Song;
 import funkin.util.VersionUtil;
 import funkin.util.tools.ISingleton;
 import funkin.data.DefaultRegistryImpl;
+#if FEATURE_MULTITHREADING
+import hx.concurrent.collection.SynchronizedMap;
+#end
 
 using funkin.data.song.migrator.SongDataMigrator;
 
@@ -22,14 +25,19 @@ class SongRegistry extends BaseRegistry<Song, SongMetadata, SongEntryParams> imp
    * and adding migration to the `migrateStageData()` function.
    */
   public static final SONG_METADATA_VERSION:thx.semver.Version = '2.2.8';
+
   public static final SONG_METADATA_VERSION_RULE:thx.semver.VersionRule = '2.2.x';
   public static final SONG_CHART_DATA_VERSION:thx.semver.Version = '2.0.0';
   public static final SONG_CHART_DATA_VERSION_RULE:thx.semver.VersionRule = '2.0.x';
   public static final SONG_MUSIC_DATA_VERSION:thx.semver.Version = '2.0.0';
   public static final SONG_MUSIC_DATA_VERSION_RULE:thx.semver.VersionRule = '2.0.x';
   public static var DEFAULT_GENERATEDBY(get, never):String;
 
+  #if FEATURE_MULTITHREADING
+  public var scriptedSongVariations:SynchronizedMap<String, Song> = SynchronizedMap.newStringMap(); // Use a thread safe map when needed.
+  #else
   public var scriptedSongVariations:Map<String, Song> = new Map<String, Song>();
+  #end
 
   static function get_DEFAULT_GENERATEDBY():String
   {

source/funkin/modding/module/ModuleHandler.hx

@@ -10,15 +10,24 @@ import funkin.util.tasks.TaskHandler;
 import hx.concurrent.collection.SynchronizedArray;
 import lime.app.Future;
 import lime.app.Promise;
+#if FEATURE_MULTITHREADING
+import hx.concurrent.collection.SynchronizedArray;
+import hx.concurrent.collection.SynchronizedMap;
+#end
 
 /**
  * Utility functions for loading and manipulating active modules.
  */
 @:nullSafety
 class ModuleHandler
 {
+  #if FEATURE_MULTITHREADING
+  static final moduleCache:SynchronizedMap<String, Module> = SynchronizedMap.newStringMap();
+  static var modulePriorityOrder:SynchronizedArray<String> = new SynchronizedArray<String>();
+  #else
   static final moduleCache:Map<String, Module> = new Map<String, Module>();
   static var modulePriorityOrder:Array<String> = [];
+  #end
 
   /**
    * Parses and preloads the game's stage data and scripts when the game starts.
@@ -57,7 +66,7 @@ class ModuleHandler
     // Clear module cache first.
     clearModuleCache();
 
-    var scriptedModuleClassNames:Array<String> = Module.listScriptClasses();
+    var scriptedModuleClassNames:SynchronizedArray<String> = new SynchronizedArray(Module.listScriptClasses());
     var promise:lime.app.Promise<LoadEntriesResult> = new lime.app.Promise<LoadEntriesResult>();
 
     // We don't have any modules to load so we can just immediately complete the promise.
@@ -194,9 +203,14 @@ class ModuleHandler
 
   static function reorderModuleCache():Void
   {
+    #if FEATURE_MULTITHREADING
+    var sortedArray:Array<String> = moduleCache.keys().array();
+    sortedArray.sort(sortByPriority);
+    modulePriorityOrder = new SynchronizedArray(sortedArray);
+    #else
     modulePriorityOrder = moduleCache.keys().array();
-
     modulePriorityOrder.sort(sortByPriority);
+    #end
   }
 
   /**
@@ -259,9 +273,12 @@ class ModuleHandler
       {
         ScriptEventDispatcher.callEvent(value, event);
       }
-
       moduleCache.clear();
+      #if FEATURE_MULTITHREADING
+      modulePriorityOrder.clear();
+      #else
       modulePriorityOrder = [];
+      #end
       event.finish();
     }
   }

source/funkin/play/notes/notekind/NoteKindManager.hx

@@ -24,13 +24,17 @@ class NoteKindManager
    * Every built-in note kind class must be added to this list.
    * Thankfully, with the power of `ClassMacro`, this is done automatically.
    */
-  static final BUILTIN_KINDS:List<Class<NoteKind>> = ClassMacro.listSubclassesOf(NoteKind).filter((cls) ->
+  #if FEATURE_MULTITHREADING
+  static final BUILTIN_KINDS:SynchronizedArray<Class<NoteKind>> = new SynchronizedArray<Class<NoteKind>>(ClassMacro.listSubclassesOf(NoteKind).filter((cls) ->
+  {
+    !['funkin.play.notes.notekind.NoteKind'].contains(Type.getClassName(cls));
+  }));
+  #else
+  static final BUILTIN_KINDS:Array<Class<NoteKind>> = ClassMacro.listSubclassesOf(NoteKind).filter((cls) ->
   {
-    ![
-      'funkin.play.notes.notekind.NoteKind'
-    ].contains(Type.getClassName(cls));
+    !['funkin.play.notes.notekind.NoteKind'].contains(Type.getClassName(cls));
   });
-
+  #end
   /**
    * A map of all note kinds, keyed by their name.
    * This is used to retrieve note kinds by their name.

source/funkin/util/assets/StagedCache.hx

@@ -1,6 +1,9 @@
 package funkin.util.assets;
 
 import flixel.util.FlxSignal.FlxTypedSignal;
+#if FEATURE_MULTITHREADING
+import hx.concurrent.collection.SynchronizedMap;
+#end
 
 /**
  * Represents a three-stage asset cache, which is useful for managing and tracking assets that are in use by the game.
@@ -12,17 +15,27 @@ class StagedCache<T> implements IStagedCache
   /**
    * The permanent cache, containing assets which always stay in memory and are never purged.
    */
+  #if FEATURE_MULTITHREADING
+  final permanent:SynchronizedMap<String, T>;
+  #else
   final permanent:Map<String, T>;
-
+  #end
   /**
    * The currently cached assets. Won't be purged until the next purge cycle.
    */
+  #if FEATURE_MULTITHREADING
+  final current:SynchronizedMap<String, T>;
+  #else
   final current:Map<String, T>;
-
+  #end
   /**
    * The assets that were previously cached. May be re-cached, but if not, they will be purged.
    */
+  #if FEATURE_MULTITHREADING
+  final previous:SynchronizedMap<String, T>;
+  #else
   final previous:Map<String, T>;
+  #end
 
   /**
    * An FlxSignal which is dispatched when an asset is removed. Typically used for cleanup of assets that need to be manually destroyed (e.g. FlxGraphics).
@@ -48,9 +61,15 @@ class StagedCache<T> implements IStagedCache
   {
     // The cache maps are final to prevent them from being overridden,
     // but they are still mutable.
+    #if FEATURE_MULTITHREADING
+    permanent = SynchronizedMap.newStringMap();
+    current = SynchronizedMap.newStringMap();
+    previous = SynchronizedMap.newStringMap();
+    #else
     permanent = [];
     current = [];
     previous = [];
+    #end
   }
 
   /**
@@ -188,9 +207,16 @@ class StagedCache<T> implements IStagedCache
   public function keys():Array<String>
   {
     var keys:Array<String> = [];
+    #if FEATURE_MULTITHREADING
+    // MapTools can't be used for SynchronizedMap.
+    keys.appendUnique([for (k => v in permanent) k]);
+    keys.appendUnique([for (k => v in current) k]);
+    keys.appendUnique([for (k => v in previous) k]);
+    #else
     keys.appendUnique(permanent.keyValues());
     keys.appendUnique(current.keyValues());
     keys.appendUnique(previous.keyValues());
+    #end
     return keys;
   }
 

source/funkin/util/logging/AnsiTrace.hx

@@ -89,6 +89,14 @@ class AnsiTrace
    */
   static function formatOutput(v:Dynamic, ?infos:haxe.PosInfos):String
   {
+    // EReg isn't thread-safe, so we default to the normal function if we're loading asynchronously.
+    if (funkin.util.plugins.ReloadAssetsDebugPlugin.hotReloadInProgress)
+    {
+      if (infos == null) return Std.string(v);
+
+      return haxe.Log.formatOutput(v, infos);
+    }
+
     var str:String = Std.string(v);
     if (infos == null) return str;