Funkin/source/funkin/play/song/Song.hx

package funkin.play.song;

import funkin.VoicesGroup;
import funkin.play.event.SongEvent;
import funkin.play.song.SongData.SongChartData;
import funkin.play.song.SongData.SongDataParser;
import funkin.play.song.SongData.SongEventData;
import funkin.play.song.SongData.SongMetadata;
import funkin.play.song.SongData.SongNoteData;
import funkin.play.song.SongData.SongPlayableChar;
import funkin.play.song.SongData.SongTimeChange;
import funkin.play.song.SongData.SongTimeFormat;

/**
 * This is a data structure managing information about the current song.
 * This structure is created when the game starts, and includes all the data
 * from the `metadata.json` file.
 * It also includes the chart data, but only when this is the currently loaded song.
 *
 * It also receives script events; scripted classes which extend this class
 * can be used to perform custom gameplay behaviors only on specific songs.
 */
class Song // implements IPlayStateScriptedClass
{
	public final songId:String;

	final _metadata:Array<SongMetadata>;

	final variations:Array<String>;
	final difficulties:Map<String, SongDifficulty>;

	public function new(id:String)
	{
		this.songId = id;

		variations = [];
		difficulties = new Map<String, SongDifficulty>();

		_metadata = SongDataParser.parseSongMetadata(songId);
		if (_metadata == null || _metadata.length == 0)
		{
			throw 'Could not find song data for songId: $songId';
		}

		populateFromMetadata();
	}

	public function getRawMetadata():Array<SongMetadata>
	{
		return _metadata;
	}

	/**
	 * Populate the song data from the provided metadata,
	 * including data from individual difficulties. Does not load chart data.
	 */
	function populateFromMetadata():Void
	{
		// Variations may have different artist, time format, generatedBy, etc.
		for (metadata in _metadata)
		{
			for (diffId in metadata.playData.difficulties)
			{
				var difficulty:SongDifficulty = new SongDifficulty(this, diffId, metadata.variation);

				variations.push(metadata.variation);

				difficulty.songName = metadata.songName;
				difficulty.songArtist = metadata.artist;
				difficulty.timeFormat = metadata.timeFormat;
				difficulty.divisions = metadata.divisions;
				difficulty.timeChanges = metadata.timeChanges;
				difficulty.loop = metadata.loop;
				difficulty.generatedBy = metadata.generatedBy;

				difficulty.stage = metadata.playData.stage;
				// difficulty.noteSkin = metadata.playData.noteSkin;

				difficulty.chars = new Map<String, SongPlayableChar>();
				for (charId in metadata.playData.playableChars.keys())
				{
					var char = metadata.playData.playableChars.get(charId);

					difficulty.chars.set(charId, char);
				}

				difficulties.set(diffId, difficulty);
			}
		}
	}

	/**
	 * Parse and cache the chart for all difficulties of this song.
	 */
	public function cacheCharts(?force:Bool = false):Void
	{
		if (force)
		{
			clearCharts();
		}

		trace('Caching ${variations.length} chart files for song $songId');
		for (variation in variations)
		{
			var chartData:SongChartData = SongDataParser.parseSongChartData(songId, variation);
			var chartNotes = chartData.notes;

			for (diffId in chartNotes.keys())
			{
				// Retrieve the cached difficulty data.
				var difficulty:Null<SongDifficulty> = difficulties.get(diffId);
				if (difficulty == null)
				{
					trace('Could not find difficulty $diffId for song $songId');
					continue;
				}
				// Add the chart data to the difficulty.
				difficulty.notes = chartData.notes.get(diffId);
				difficulty.scrollSpeed = chartData.getScrollSpeed(diffId);

				difficulty.events = chartData.events;
			}
		}
		trace('Done caching charts.');
	}

	/**
	 * Retrieve the metadata for a specific difficulty, including the chart if it is loaded.
	 */
	public inline function getDifficulty(?diffId:String):SongDifficulty
	{
		if (diffId == null)
			diffId = difficulties.keys().array()[0];

		return difficulties.get(diffId);
	}

	/**
	 * Purge the cached chart data for each difficulty of this song.
	 */
	public function clearCharts():Void
	{
		for (diff in difficulties)
		{
			diff.clearChart();
		}
	}

	public function toString():String
	{
		return 'Song($songId)';
	}
}

class SongDifficulty
{
	/**
	 * The parent song for this difficulty.
	 */
	public final song:Song;

	/**
	 * The difficulty ID, such as `easy` or `hard`.
	 */
	public final difficulty:String;

	/**
	 * The metadata file that contains this difficulty.
	 */
	public final variation:String;

	/**
	 * The note chart for this difficulty.
	 */
	public var notes:Array<SongNoteData>;

	/**
	 * The event chart for this difficulty.
	 */
	public var events:Array<SongEventData>;

	public var songName:String = SongValidator.DEFAULT_SONGNAME;
	public var songArtist:String = SongValidator.DEFAULT_ARTIST;
	public var timeFormat:SongTimeFormat = SongValidator.DEFAULT_TIMEFORMAT;
	public var divisions:Int = SongValidator.DEFAULT_DIVISIONS;
	public var loop:Bool = SongValidator.DEFAULT_LOOP;
	public var generatedBy:String = SongValidator.DEFAULT_GENERATEDBY;

	public var timeChanges:Array<SongTimeChange> = [];

	public var stage:String = SongValidator.DEFAULT_STAGE;
	public var chars:Map<String, SongPlayableChar> = null;

	public var scrollSpeed:Float = SongValidator.DEFAULT_SCROLLSPEED;

	public function new(song:Song, diffId:String, variation:String)
	{
		this.song = song;
		this.difficulty = diffId;
		this.variation = variation;
	}

	public function clearChart():Void
	{
		notes = null;
	}

	public function getStartingBPM():Float
	{
		if (timeChanges.length == 0)
		{
			return 0;
		}

		return timeChanges[0].bpm;
	}

	public function getPlayableChar(id:String):SongPlayableChar
	{
		return chars.get(id);
	}

	public function getPlayableChars():Array<String>
	{
		return chars.keys().array();
	}

	public function getEvents():Array<SongEvent>
	{
		return cast events;
	}

	public inline function cacheInst()
	{
		FlxG.sound.cache(Paths.inst(this.song.songId));
	}

	public inline function playInst(volume:Float = 1.0, looped:Bool = false)
	{
		FlxG.sound.playMusic(Paths.inst(this.song.songId), volume, looped);
	}

	public inline function cacheVocals()
	{
		FlxG.sound.cache(Paths.voices(this.song.songId));
	}

	public function buildVoiceList():Array<String>
	{
		// TODO: Implement.

		return [""];
	}

	public function buildVocals(charId:String = "bf"):VoicesGroup
	{
		var result:VoicesGroup = VoicesGroup.build(this.song.songId, this.buildVoiceList());
		return result;
	}
}