How to make Change Character Event but it's work on mobile

[simpleGalaxy75]

I created a Change Character Event because it was needed for modding, but it doesn't work on the mobile version (at least iOS) and causes a crash.
Is there a way to make it work without crashing?
(I used DeepL)
Below is the code I wrote.

import funkin.play.PlayState;
import funkin.modding.module.Module;
import funkin.modding.module.ScriptedModule;
import flixel.text.FlxText;
import funkin.graphics.FunkinSprite;
import funkin.Paths;
import flixel.FlxG;
import funkin.play.character.BaseCharacter;
import funkin.play.character.CharacterDataParser;
import funkin.play.character.CharacterType;
import flixel.tweens.FlxEase;
import flixel.tweens.FlxTween;
import haxe.format.JsonParser;
import funkin.Assets;

class ChangeCharacterAction extends Module
{
	public function new()
	{
		super('ChangeCharacterAction');
	}

	var cached = false;
	var changed = false;
	var bfChanged = false;
	var dadChanged = false;
	var gfChanged = false;

	var characterMap:CharacterMap = ScriptedModule.init('CharacterMap');
  	public function onSongLoaded(event:SongLoadScriptEvent) {
		if (!FlxG.onMobile) {
			for (data in event.events) {
				if (data.eventKind == 'changeCharacter') {
					addCharacterToList(data.getString("char"));
				}
			}
		}

		if (changed) {
			var characterData = PlayState.instance.currentChart.characters;
			if (gfChanged) {
				var gf:Null<BaseCharacter> = CharacterDataParser.fetchCharacter(characterData.girlfriend);
				if (gf != null) {
					PlayState.instance.currentStage.getGirlfriend().destroy();
					PlayState.instance.currentStage.addCharacter(gf,CharacterType.GF);
				}
			}
			if (dadChanged) {
				var dad:Null<BaseCharacter> = CharacterDataParser.fetchCharacter(characterData.opponent);
				if (dad != null) {
					PlayState.instance.currentStage.getDad().destroy();
					PlayState.instance.currentStage.addCharacter(dad,CharacterType.DAD);
				}
			}
			if (bfChanged) {
				var bf:Null<BaseCharacter> = CharacterDataParser.fetchCharacter(characterData.player);
				if (bf != null) {
					PlayState.instance.currentStage.getBoyfriend().destroy();
					PlayState.instance.currentStage.addCharacter(bf,CharacterType.BF);
				}
			}

			PlayState.instance.currentStage.refresh();
		}
		changed = false;
		bfChanged = false;
		dadChanged = false;
		gfChanged = false;
	}

	function addCharacterToList(charId:String) {
		var newChar:Null<BaseCharacter> = CharacterDataParser.fetchCharacter(charId);
		if (newChar != null) characterMap.set(charId,newChar);
	}

  	public function onSongEvent(event:SongEventScriptEvent) {
    	super.onSongEvent(event);
    	if (event.eventData.eventKind == 'changeCharacter') {
			var data = event.eventData;

			trace("dad.zIndex: "+PlayState.instance.currentStage.getDad().zIndex);
			if (!characterMap.exists(data.getString("char"))) {
			addCharacterToList(data.getString("char"));
			}
			var newCharType = CharacterType.DAD;
			if (data.getString('target') == 'dad') {
				newCharType = CharacterType.DAD;
				PlayState.instance.currentStage.getDad().destroy();
			}
			else if (data.getString('target') == 'bf') {
				newCharType = CharacterType.BF;
				PlayState.instance.currentStage.getBoyfriend().destroy();
			}
			else if (data.getString('target') == 'gf') {
				newCharType = CharacterType.GF;
				PlayState.instance.currentStage.getGirlfriend().destroy();
			}
			if (!characterMap.exists(data.getString("char"))) return;
			PlayState.instance.currentStage.addCharacter(characterMap.get(data.getString("char")),newCharType);
			characterMap.get(data.getString("char")).x += data.getFloat('offsetX');
			characterMap.get(data.getString("char")).y += data.getFloat('offsetY');

			PlayState.instance.currentStage.refresh();

			changed = true;
			if (event.eventData.getString('target') == 'dad') {
				dadChanged = true;
			}
			else if (event.eventData.getString('target') == 'bf') {
				bfChanged = true;
			}
			else if (event.eventData.getString('target') == 'gf') {
				gfChanged = true;
			}
    	}
  	}
  	public function onDestroy(event:ScriptEvent) {
		cached = false;
	}
}

[moltenman5]

Here is a script I wrote for you `package ;

import funkin.play.PlayState;
import funkin.modding.module.Module;
import funkin.modding.module.ScriptedModule;
import flixel.text.FlxText;
import funkin.graphics.FunkinSprite;
import funkin.Paths;
import flixel.FlxG;
import funkin.play.character.BaseCharacter;
import funkin.play.character.CharacterDataParser;
import funkin.play.character.CharacterType;
import flixel.tweens.FlxEase;
import flixel.tweens.FlxTween;
import haxe.format.JsonParser;
import funkin.Assets;
import openfl.Assets as OpenFLAssets;

class ChangeCharacterAction extends Module
{
public function new()
{
super('ChangeCharacterAction');
}

var cached = false;
var changed = false;
var bfChanged = false;
var dadChanged = false;
var gfChanged = false;

var characterMap:CharacterMap = ScriptedModule.init('CharacterMap');

// Helper: try to fetch character safely without crashing on mobile if assets are missing.
private function safeFetchCharacter(charId:String):Null<BaseCharacter> {
	try {
		// CharacterDataParser.fetchCharacter will try to parse JSON + load images.
		// On mobile those assets must be packaged in the APK/IPA; otherwise fetchCharacter can throw.
		return CharacterDataParser.fetchCharacter(charId);
	} catch(e:Dynamic) {
		trace('[ChangeCharacterAction] safeFetchCharacter failed for "' + charId + '": ' + Std.string(e));
		return null;
	}
}

// Prefetch characters referenced by events. On mobile we MUST ensure the assets are packaged/preloaded.
// This tries to fetch each character but will silently skip ones that cannot be loaded.
public function onSongLoaded(event:SongLoadScriptEvent) {
	// Always scan events (needed to build the list). Avoid skipping on mobile,
	// but be defensive: use safeFetchCharacter and only add non-null characters to the map.
	for (data in event.events) {
		if (data.eventKind == 'changeCharacter') {
			addCharacterToList(data.getString("char"));
		}
	}

	// If we already swapped during the song (e.g. event-driven), refresh the stage using cached parsed characters.
	if (changed) {
		var characterData = PlayState.instance.currentChart.characters;
		if (gfChanged) {
			var gf:Null<BaseCharacter> = safeFetchCharacter(characterData.girlfriend);
			if (gf != null) {
				try {
					PlayState.instance.currentStage.getGirlfriend().destroy();
					PlayState.instance.currentStage.addCharacter(gf,CharacterType.GF);
				} catch(e:Dynamic) {
					trace('[ChangeCharacterAction] Error replacing GF: ' + Std.string(e));
				}
			}
		}
		if (dadChanged) {
			var dad:Null<BaseCharacter> = safeFetchCharacter(characterData.opponent);
			if (dad != null) {
				try {
					PlayState.instance.currentStage.getDad().destroy();
					PlayState.instance.currentStage.addCharacter(dad,CharacterType.DAD);
				} catch(e:Dynamic) {
					trace('[ChangeCharacterAction] Error replacing DAD: ' + Std.string(e));
				}
			}
		}
		if (bfChanged) {
			var bf:Null<BaseCharacter> = safeFetchCharacter(characterData.player);
			if (bf != null) {
				try {
					PlayState.instance.currentStage.getBoyfriend().destroy();
					PlayState.instance.currentStage.addCharacter(bf,CharacterType.BF);
				} catch(e:Dynamic) {
					trace('[ChangeCharacterAction] Error replacing BF: ' + Std.string(e));
				}
			}
		}

		try {
			PlayState.instance.currentStage.refresh();
		} catch(e:Dynamic) {
			trace('[ChangeCharacterAction] Error refreshing stage: ' + Std.string(e));
		}
	}
	changed = false;
	bfChanged = false;
	dadChanged = false;
	gfChanged = false;
}

// Adds character to our local map if it's available. Uses safeFetchCharacter so we don't crash when assets are missing.
function addCharacterToList(charId:String) {
	if (characterMap.exists(charId)) return;

	var newChar:Null<BaseCharacter> = safeFetchCharacter(charId);
	if (newChar != null) {
		characterMap.set(charId,newChar);
	} else {
		// On mobile this usually means the character files are not packaged in the app.
		trace('[ChangeCharacterAction] Character "' + charId + '" not added: assets not found or failed to parse.');
	}
}

public function onSongEvent(event:SongEventScriptEvent) {
	super.onSongEvent(event);
	if (event.eventData.eventKind == 'changeCharacter') {
		var data = event.eventData;

		// Defensive: ensure the character exists in our map (try to fetch if missing).
		var charId = data.getString("char");
		if (!characterMap.exists(charId)) {
			addCharacterToList(charId);
		}

		// If still missing, bail out (on mobile this prevents a crash).
		if (!characterMap.exists(charId)) {
			trace('[ChangeCharacterAction] Skipping changeCharacter event for "' + charId + '" because the character is not loaded (mobile/assets issue).');
			return;
		}

		var newCharType = CharacterType.DAD;

		// Instead of destroying first (which can cause transient null usage on some platforms),
		// try to add the new character and then destroy the old one only if the add succeeded.
		try {
			if (data.getString('target') == 'dad') {
				newCharType = CharacterType.DAD;
			}
			else if (data.getString('target') == 'bf') {
				newCharType = CharacterType.BF;
			}
			else if (data.getString('target') == 'gf') {
				newCharType = CharacterType.GF;
			}

			// Add the character
			PlayState.instance.currentStage.addCharacter(characterMap.get(charId), newCharType);

			// Apply offsets (defensive index checks)
			var added = characterMap.get(charId);
			if (added != null) {
				added.x += data.getFloat('offsetX');
				added.y += data.getFloat('offsetY');
			}

			// Destroy previous instance (best-effort; wrap in try/catch)
			if (newCharType == CharacterType.DAD) {
				try { PlayState.instance.currentStage.getDad().destroy(); } catch(_) {}
			} else if (newCharType == CharacterType.BF) {
				try { PlayState.instance.currentStage.getBoyfriend().destroy(); } catch(_) {}
			} else if (newCharType == CharacterType.GF) {
				try { PlayState.instance.currentStage.getGirlfriend().destroy(); } catch(_) {}
			}

			PlayState.instance.currentStage.refresh();

			changed = true;
			if (event.eventData.getString('target') == 'dad') {
				dadChanged = true;
			}
			else if (event.eventData.getString('target') == 'bf') {
				bfChanged = true;
			}
			else if (event.eventData.getString('target') == 'gf') {
				gfChanged = true;
			}
		} catch (e:Dynamic) {
			trace('[ChangeCharacterAction] Exception while handling changeCharacter event: ' + Std.string(e));
			// If anything goes wrong on mobile, avoid crashing the whole game. We simply skip this event.
		}
	}
}

public function onDestroy(event:ScriptEvent) {
	cached = false;
}

}`

On mobile, (both iOS and Android) asset packing and loading is different CharacterDataParser.fetchCharacter can fail when character JSON or spritesheets are not packaged the same way as on desktop. The original code also skipped building the character cache on mobile (because of the FlxG.onMobile guard), which left the module trying to dynamically load characters during runtime a source of crashes on mobile if assets aren't present or loading throws.
I made a safeFetchCharacter wrapper that catches exceptions from fetchCharacter and returns null instead of letting the whole game crash.
Always scan events onSongLoaded (even on mobile) but only add characters that can actually be parsed and loaded. This builds a reliable characterMap where available.
In onSongEvent I added guards: if the character isn't available we skip the event (and log). All risky operations (adding/destroying characters and refreshing the stage) are wrapped in try/catch so failures do not crash the app.
Safer replacement order: try to add the new character first, then destroy the old one only after the add succeeded — this avoids leaving the stage with missing references if something fails mid-operation.
Packaging / deployment required on mobile

Dynamic character loading works on desktop because files can be read from the filesystem. On mobile you must ensure every character's assets are included in the app bundle. Make sure the character folder (json, spritesheets, xml/png or image sequences) is added to your project assets so OpenFL can embed them.
Example project.xml entry:

Include each character's png(s), json and any other resource used.
After packaging, test on device. If a character is not included in the bundle, safeFetchCharacter will return null and the event will be skipped (no crash).

[simpleGalaxy75]

Thank you so much!!
I tried it on iOS right away, but it ended up crashing. (Probably because the processing takes too long.)
Also, when I tried it on Mac, the new character didn't appear, and the original character froze.
Come to think of it... was the code actually for Haxe instead of HScript? The code I posted was HScript (.hxc)...
Sorry for the lack of explanation.