1
0
Fork 0
mirror of https://github.com/ninjamuffin99/Funkin.git synced 2024-12-02 19:53:15 +00:00
Funkin/source/funkin/play/character/CharacterData.hx

712 lines
20 KiB
Haxe

package funkin.play.character;
import funkin.data.animation.AnimationData;
import funkin.modding.events.ScriptEvent;
import funkin.modding.events.ScriptEventDispatcher;
import funkin.play.character.ScriptedCharacter.ScriptedAnimateAtlasCharacter;
import funkin.play.character.ScriptedCharacter.ScriptedBaseCharacter;
import funkin.play.character.ScriptedCharacter.ScriptedMultiSparrowCharacter;
import funkin.play.character.ScriptedCharacter.ScriptedPackerCharacter;
import funkin.play.character.ScriptedCharacter.ScriptedSparrowCharacter;
import funkin.util.assets.DataAssets;
import funkin.util.VersionUtil;
import haxe.Json;
import openfl.utils.Assets;
class CharacterDataParser
{
/**
* The current version string for the stage data format.
* Handle breaking changes by incrementing this value
* and adding migration to the `migrateStageData()` function.
*
* - Version 1.0.1 adds `death.cameraOffsets`
*/
public static final CHARACTER_DATA_VERSION:String = '1.0.1';
/**
* The current version rule check for the stage data format.
*/
public static final CHARACTER_DATA_VERSION_RULE:String = '1.0.x';
static final characterCache:Map<String, CharacterData> = new Map<String, CharacterData>();
static final characterScriptedClass:Map<String, String> = new Map<String, String>();
static final DEFAULT_CHAR_ID:String = 'UNKNOWN';
/**
* Parses and preloads the game's stage data and scripts when the game starts.
*
* If you want to force stages to be reloaded, you can just call this function again.
*/
public static function loadCharacterCache():Void
{
// Clear any stages that are cached if there were any.
clearCharacterCache();
trace('Loading character cache...');
//
// UNSCRIPTED CHARACTERS
//
var charIdList:Array<String> = DataAssets.listDataFilesInPath('characters/');
var unscriptedCharIds:Array<String> = charIdList.filter(function(charId:String):Bool {
return !characterCache.exists(charId);
});
trace(' Fetching data for ${unscriptedCharIds.length} characters...');
for (charId in unscriptedCharIds)
{
try
{
var charData:CharacterData = parseCharacterData(charId);
if (charData != null)
{
trace(' Loaded character data: ${charId}');
characterCache.set(charId, charData);
}
}
catch (e)
{
// Assume error was already logged.
continue;
}
}
//
// SCRIPTED CHARACTERS
//
// Fuck I wish scripted classes supported static functions.
var scriptedCharClassNames1:Array<String> = ScriptedSparrowCharacter.listScriptClasses();
if (scriptedCharClassNames1.length > 0)
{
trace(' Instantiating ${scriptedCharClassNames1.length} (Sparrow) scripted characters...');
for (charCls in scriptedCharClassNames1)
{
try
{
var character:SparrowCharacter = ScriptedSparrowCharacter.init(charCls, DEFAULT_CHAR_ID);
trace(' Initialized character ${character.characterName}');
characterScriptedClass.set(character.characterId, charCls);
}
catch (e)
{
trace(' FAILED to instantiate scripted Sparrow character: ${charCls}');
trace(e);
}
}
}
var scriptedCharClassNames2:Array<String> = ScriptedPackerCharacter.listScriptClasses();
if (scriptedCharClassNames2.length > 0)
{
trace(' Instantiating ${scriptedCharClassNames2.length} (Packer) scripted characters...');
for (charCls in scriptedCharClassNames2)
{
try
{
var character:PackerCharacter = ScriptedPackerCharacter.init(charCls, DEFAULT_CHAR_ID);
characterScriptedClass.set(character.characterId, charCls);
}
catch (e)
{
trace(' FAILED to instantiate scripted Packer character: ${charCls}');
trace(e);
}
}
}
var scriptedCharClassNames3:Array<String> = ScriptedMultiSparrowCharacter.listScriptClasses();
if (scriptedCharClassNames3.length > 0)
{
trace(' Instantiating ${scriptedCharClassNames3.length} (Multi-Sparrow) scripted characters...');
for (charCls in scriptedCharClassNames3)
{
try
{
var character:MultiSparrowCharacter = ScriptedMultiSparrowCharacter.init(charCls, DEFAULT_CHAR_ID);
characterScriptedClass.set(character.characterId, charCls);
}
catch (e)
{
trace(' FAILED to instantiate scripted Multi-Sparrow character: ${charCls}');
trace(e);
}
}
}
var scriptedCharClassNames4:Array<String> = ScriptedAnimateAtlasCharacter.listScriptClasses();
if (scriptedCharClassNames4.length > 0)
{
trace(' Instantiating ${scriptedCharClassNames4.length} (Animate Atlas) scripted characters...');
for (charCls in scriptedCharClassNames4)
{
try
{
var character:AnimateAtlasCharacter = ScriptedAnimateAtlasCharacter.init(charCls, DEFAULT_CHAR_ID);
characterScriptedClass.set(character.characterId, charCls);
}
catch (e)
{
trace(' FAILED to instantiate scripted Animate Atlas character: ${charCls}');
trace(e);
}
}
}
// NOTE: Only instantiate the ones not populated above.
// ScriptedBaseCharacter.listScriptClasses() will pick up scripts extending the other classes.
var scriptedCharClassNames:Array<String> = ScriptedBaseCharacter.listScriptClasses();
scriptedCharClassNames = scriptedCharClassNames.filter(function(charCls:String):Bool {
return !(scriptedCharClassNames1.contains(charCls)
|| scriptedCharClassNames2.contains(charCls)
|| scriptedCharClassNames3.contains(charCls)
|| scriptedCharClassNames4.contains(charCls));
});
if (scriptedCharClassNames.length > 0)
{
trace(' Instantiating ${scriptedCharClassNames.length} (Base) scripted characters...');
for (charCls in scriptedCharClassNames)
{
var character:BaseCharacter = ScriptedBaseCharacter.init(charCls, DEFAULT_CHAR_ID, Custom);
if (character == null)
{
trace(' Failed to instantiate scripted character: ${charCls}');
continue;
}
else
{
trace(' Successfully instantiated scripted character: ${charCls}');
characterScriptedClass.set(character.characterId, charCls);
}
}
}
trace(' Successfully loaded ${Lambda.count(characterCache)} stages.');
}
/**
* Fetches data for a character and returns a BaseCharacter instance,
* ready to be added to the scene.
* @param charId The character ID to fetch.
* @return The character instance, or null if the character was not found.
*/
public static function fetchCharacter(charId:String, debug:Bool = false):Null<BaseCharacter>
{
if (charId == null || charId == '' || !characterCache.exists(charId))
{
// Gracefully handle songs that don't use this character,
// or throw an error if the character is missing.
if (charId != null && charId != '') trace('Failed to build character, not found in cache: ${charId}');
return null;
}
var charData:CharacterData = characterCache.get(charId);
var charScriptClass:String = characterScriptedClass.get(charId);
var char:BaseCharacter;
if (charScriptClass != null)
{
switch (charData.renderType)
{
case CharacterRenderType.AnimateAtlas:
char = ScriptedAnimateAtlasCharacter.init(charScriptClass, charId);
case CharacterRenderType.MultiSparrow:
char = ScriptedMultiSparrowCharacter.init(charScriptClass, charId);
case CharacterRenderType.Sparrow:
char = ScriptedSparrowCharacter.init(charScriptClass, charId);
case CharacterRenderType.Packer:
char = ScriptedPackerCharacter.init(charScriptClass, charId);
default:
// We're going to assume that the script class does the rendering.
char = ScriptedBaseCharacter.init(charScriptClass, charId, CharacterRenderType.Custom);
}
}
else
{
switch (charData.renderType)
{
case CharacterRenderType.AnimateAtlas:
char = new AnimateAtlasCharacter(charId);
case CharacterRenderType.MultiSparrow:
char = new MultiSparrowCharacter(charId);
case CharacterRenderType.Sparrow:
char = new SparrowCharacter(charId);
case CharacterRenderType.Packer:
char = new PackerCharacter(charId);
default:
trace('[WARN] Creating character with undefined renderType ${charData.renderType}');
char = new BaseCharacter(charId, CharacterRenderType.Custom);
}
}
if (char == null)
{
trace('Failed to instantiate character: ${charId}');
return null;
}
trace('Successfully instantiated character (${debug ? 'debug' : 'stable'}): ${charId}');
char.debug = debug;
// Call onCreate only in the fetchCharacter() function, not at application initialization.
ScriptEventDispatcher.callEvent(char, new ScriptEvent(ScriptEvent.CREATE));
return char;
}
/**
* Fetches just the character data for a character.
* @param charId The character ID to fetch.
* @return The character data, or null if the character was not found.
*/
public static function fetchCharacterData(charId:String):Null<CharacterData>
{
if (characterCache.exists(charId)) return characterCache.get(charId);
return null;
}
/**
* Lists all the valid character IDs.
* @return An array of character IDs.
*/
public static function listCharacterIds():Array<String>
{
return characterCache.keys().array();
}
/**
* Clears the character data cache.
*/
static function clearCharacterCache():Void
{
if (characterCache != null)
{
characterCache.clear();
}
if (characterScriptedClass != null)
{
characterScriptedClass.clear();
}
}
/**
* Load a character's JSON file and parse its data.
*
* @param charId The character to load.
* @return The character data, or null if validation failed.
*/
public static function parseCharacterData(charId:String):Null<CharacterData>
{
var rawJson:String = loadCharacterFile(charId);
var charData:CharacterData = migrateCharacterData(rawJson, charId);
return validateCharacterData(charId, charData);
}
static function loadCharacterFile(charPath:String):String
{
var charFilePath:String = Paths.json('characters/${charPath}');
var rawJson = Assets.getText(charFilePath).trim();
while (!StringTools.endsWith(rawJson, '}'))
{
rawJson = rawJson.substr(0, rawJson.length - 1);
}
return rawJson;
}
static function migrateCharacterData(rawJson:String, charId:String):Null<CharacterData>
{
// If you update the character data format in a breaking way,
// handle migration here by checking the `version` value.
try
{
var charData:CharacterData = cast Json.parse(rawJson);
return charData;
}
catch (e)
{
trace(' Error parsing data for character: ${charId}');
trace(' ${e}');
return null;
}
}
/**
* The default time the character should sing for, in beats.
* Values that are too low will cause the character to stop singing between notes.
* Originally, this value was set to 1, but it was changed to 2 because that became
* too low after some other code changes.
*/
static final DEFAULT_SINGTIME:Float = 2.0;
static final DEFAULT_DANCEEVERY:Int = 1;
static final DEFAULT_FLIPX:Bool = false;
static final DEFAULT_FLIPY:Bool = false;
static final DEFAULT_FRAMERATE:Int = 24;
static final DEFAULT_ISPIXEL:Bool = false;
static final DEFAULT_LOOP:Bool = false;
static final DEFAULT_NAME:String = 'Untitled Character';
static final DEFAULT_OFFSETS:Array<Float> = [0, 0];
static final DEFAULT_HEALTHICON_OFFSETS:Array<Int> = [0, 25];
static final DEFAULT_RENDERTYPE:CharacterRenderType = CharacterRenderType.Sparrow;
static final DEFAULT_SCALE:Float = 1;
static final DEFAULT_SCROLL:Array<Float> = [0, 0];
static final DEFAULT_STARTINGANIM:String = 'idle';
/**
* Set unspecified parameters to their defaults.
* If the parameter is mandatory, print an error message.
* @param id
* @param input
* @return The validated character data
*/
static function validateCharacterData(id:String, input:CharacterData):Null<CharacterData>
{
if (input == null)
{
trace('ERROR: Could not parse character data for "${id}".');
return null;
}
if (input.version == null)
{
trace('WARN: No semantic version specified for character data file "$id", assuming ${CHARACTER_DATA_VERSION}');
input.version = CHARACTER_DATA_VERSION;
}
if (!VersionUtil.validateVersionStr(input.version, CHARACTER_DATA_VERSION_RULE))
{
trace('ERROR: Could not load character data for "$id": bad version (got ${input.version}, expected ${CHARACTER_DATA_VERSION_RULE})');
return null;
}
if (input.name == null)
{
trace('WARN: Character data for "$id" missing name');
input.name = DEFAULT_NAME;
}
if (input.renderType == null)
{
input.renderType = DEFAULT_RENDERTYPE;
}
if (input.assetPath == null)
{
trace('ERROR: Could not load character data for "$id": missing assetPath');
return null;
}
if (input.offsets == null)
{
input.offsets = DEFAULT_OFFSETS;
}
if (input.cameraOffsets == null)
{
input.cameraOffsets = DEFAULT_OFFSETS;
}
if (input.healthIcon == null)
{
input.healthIcon =
{
id: null,
scale: null,
flipX: null,
isPixel: null,
offsets: null
};
}
if (input.healthIcon.id == null)
{
input.healthIcon.id = id;
}
if (input.healthIcon.scale == null)
{
input.healthIcon.scale = DEFAULT_SCALE;
}
if (input.healthIcon.flipX == null)
{
input.healthIcon.flipX = DEFAULT_FLIPX;
}
if (input.healthIcon.offsets == null)
{
input.healthIcon.offsets = DEFAULT_OFFSETS;
}
if (input.startingAnimation == null)
{
input.startingAnimation = DEFAULT_STARTINGANIM;
}
if (input.scale == null)
{
input.scale = DEFAULT_SCALE;
}
if (input.isPixel == null)
{
input.isPixel = DEFAULT_ISPIXEL;
}
if (input.healthIcon.isPixel == null)
{
input.healthIcon.isPixel = input.isPixel;
}
if (input.danceEvery == null)
{
input.danceEvery = DEFAULT_DANCEEVERY;
}
if (input.singTime == null)
{
input.singTime = DEFAULT_SINGTIME;
}
if (input.animations == null || input.animations.length == 0)
{
trace('ERROR: Could not load character data for "$id": missing animations');
input.animations = [];
}
if (input.flipX == null)
{
input.flipX = DEFAULT_FLIPX;
}
if (input.animations.length == 0 && input.startingAnimation != null)
{
return null;
}
for (inputAnimation in input.animations)
{
if (inputAnimation.name == null)
{
trace('ERROR: Could not load character data for "$id": missing animation name for prop "${input.name}"');
return null;
}
if (inputAnimation.frameRate == null)
{
inputAnimation.frameRate = DEFAULT_FRAMERATE;
}
if (inputAnimation.offsets == null)
{
inputAnimation.offsets = DEFAULT_OFFSETS;
}
if (inputAnimation.looped == null)
{
inputAnimation.looped = DEFAULT_LOOP;
}
if (inputAnimation.flipX == null)
{
inputAnimation.flipX = DEFAULT_FLIPX;
}
if (inputAnimation.flipY == null)
{
inputAnimation.flipY = DEFAULT_FLIPY;
}
}
// All good!
return input;
}
}
/**
* Describes the available rendering types for a character.
*/
enum abstract CharacterRenderType(String) from String to String
{
/**
* Renders the character using a single spritesheet and XML data.
*/
public var Sparrow = 'sparrow';
/**
* Renders the character using a single spritesheet and TXT data.
*/
public var Packer = 'packer';
/**
* Renders the character using multiple spritesheets and XML data.
*/
public var MultiSparrow = 'multisparrow';
/**
* Renders the character using a spritesheet of symbols and JSON data.
*/
public var AnimateAtlas = 'animateatlas';
/**
* Renders the character using a custom method.
*/
public var Custom = 'custom';
}
/**
* The JSON data schema used to define a character.
*/
typedef CharacterData =
{
/**
* The sematic version number of the character data JSON format.
*/
var version:String;
/**
* The readable name of the character.
*/
var name:String;
/**
* The type of rendering system to use for the character.
* @default sparrow
*/
var renderType:CharacterRenderType;
/**
* Behavior varies by render type:
* - SPARROW: Path to retrieve both the spritesheet and the XML data from.
* - PACKER: Path to retrieve both the spritsheet and the TXT data from.
*/
var assetPath:String;
/**
* The scale of the graphic as a float.
* Pro tip: On pixel-art levels, save the sprites small and set this value to 6 or so to save memory.
* @default 1
*/
var scale:Null<Float>;
/**
* Optional data about the health icon for the character.
*/
var healthIcon:Null<HealthIconData>;
var death:Null<DeathData>;
/**
* The global offset to the character's position, in pixels.
* @default [0, 0]
*/
var offsets:Null<Array<Float>>;
/**
* The amount to offset the camera by while focusing on this character.
* Default value focuses on the character directly.
* @default [0, 0]
*/
var cameraOffsets:Array<Float>;
/**
* Setting this to true disables anti-aliasing for the character.
* @default false
*/
var isPixel:Null<Bool>;
/**
* The frequency at which the character will play its idle animation, in beats.
* Increasing this number will make the character dance less often.
*
* @default 1
*/
var danceEvery:Null<Int>;
/**
* The minimum duration that a character will play a note animation for, in beats.
* If this number is too low, you may see the character start playing the idle animation between notes.
* If this number is too high, you may see the the character play the sing animation for too long after the notes are gone.
*
* Examples:
* - Daddy Dearest uses a value of `1.525`.
* @default 1.0
*/
var singTime:Null<Float>;
/**
* An optional array of animations which the character can play.
*/
var animations:Array<AnimationData>;
/**
* If animations are used, this is the name of the animation to play first.
* @default idle
*/
var startingAnimation:Null<String>;
/**
* Whether or not the whole ass sprite is flipped by default.
* Useful for characters that could also be played (Pico)
*
* @default false
*/
var flipX:Null<Bool>;
};
/**
* The JSON data schema used to define the health icon for a character.
*/
typedef HealthIconData =
{
/**
* The ID to use for the health icon.
* @default The character's ID
*/
var id:Null<String>;
/**
* The scale of the health icon.
*/
var scale:Null<Float>;
/**
* Whether to flip the health icon horizontally.
* @default false
*/
var flipX:Null<Bool>;
/**
* Multiply scale by 6 and disable antialiasing
* @default false
*/
var isPixel:Null<Bool>;
/**
* The offset of the health icon, in pixels.
* @default [0, 25]
*/
var offsets:Null<Array<Float>>;
}
typedef DeathData =
{
/**
* The amount to offset the camera by while focusing on this character as they die.
* Default value focuses on the character's graphic midpoint.
* @default [0, 0]
*/
var ?cameraOffsets:Array<Float>;
}