multithreading.hx

// Oh my god I fucking hate this 🤢
private function generateSong(name:String, diff:String):Void
{
	var timeStamp:Float = haxe.Timer.stamp();

	// Worker #1

	var lock = new Mutex();
	var worker = new BackgroundWorker();
	worker.doWork.add((code:Int) ->
	{
		trace('Parsing chart data from song json...');

		try
		{
			// Chart preloader
			var preloadName:String = name + (diff != '' ? '-$diff' : '');
			if (ChartPreloader.container.exists(preloadName))
			{
				trace('Nvm we found the data in ChartPreloader - YIPPEE!!!');
				SONG = ChartPreloader.container.get(preloadName);
			}
			else
				SONG = Song.loadFromJson(name + '/' + name + diff);

			worker.sendComplete(1);
		}
		catch (e)
		{
			trace('Chart file "${name + (diff != '' ? '-$diff' : '')}" doesn\'t exist.');
		}
	});

	worker.onComplete.add((code:Int) ->
	{
		trace('Loaded ${SONG.noteData.length} notes! Now time to load more stuff here...');

		Conductor.mapBPMChanges(SONG);

		// What happens if you load a song with a bpm of under 10? Change to 10 instead.
		SONG.info.bpm = Math.max(SONG.info.bpm, 10.0);

		Conductor.changeBPM(SONG.info.bpm);

		if (null == SONG.info.spectator) // Fix gf (for vanilla charts)
			SONG.info.spectator = 'gf';

		if (null == SONG.info.offset || SONG.info.offset < 0) // Fix offset
			SONG.info.offset = 0;

		strumlines = null == SONG.info.strumlines ? 2 : SONG.info.strumlines;

		curSong = SONG.song;
		songSpeed = SONG.info.speed;

		curStage = SONG.info.stage;

		if (curStage == null || curStage == '') // Fix stage (For vanilla charts)
			curStage = 'stage';

		var worker2 = new BackgroundWorker(),
		worker3 = new BackgroundWorker(),
		worker4 = new BackgroundWorker(),
		worker5 = new BackgroundWorker(),
		worker6 = new BackgroundWorker(),
		worker7 = new BackgroundWorker();

		var totalProcessed = 0;
		var check = () ->
		{
			trace(totalProcessed); // For testing
			if (totalProcessed == 5)
			{
				// Finish off stage creation and add characters finally

				for (script in scriptList.keys())
				{
					try
					{
						if (scriptList.get(script).interp.variables.exists('createStage'))
							(scriptList.get(script).interp.variables.get('createStage'))(name, diff);
					}
					catch (e)
					{
						HScriptSystem.error(e);
					}
				}

				if (!noCharacters && curStage == 'stage')
				{
					var bg:BGSprite = new BGSprite('stageback', -600, -200, 0.9, 0.9);
					add(bg);

					var stageFront:BGSprite = new BGSprite('stagefront', -650, 600, 0.9, 0.9);
					stageFront.setGraphicSize(Std.int(stageFront.width * 1.1));
					stageFront.updateHitbox();
					add(stageFront);

					var stageLight:BGSprite = new BGSprite('stage_light', -125, -100, 0.9, 0.9);
					stageLight.setGraphicSize(Std.int(stageLight.width * 1.1));
					stageLight.updateHitbox();
					add(stageLight);

					var stageLight2:BGSprite = new BGSprite('stage_light', 1225, -100, 0.9, 0.9);
					stageLight2.setGraphicSize(Std.int(stageLight2.width * 1.1));
					stageLight2.updateHitbox();
					stageLight2.flipX = true;
					add(stageLight2);

					var stageCurtains:BGSprite = new BGSprite('stagecurtains', -500, -300, 1.3, 1.3);
					stageCurtains.setGraphicSize(Std.int(stageCurtains.width * 0.9));
					stageCurtains.updateHitbox();
					add(stageCurtains);
				}

				lock.acquire();

				gfGroup = new FlxSpriteGroup(GF_X, GF_Y);
				add(gfGroup);

				dadGroup = new FlxSpriteGroup(DAD_X, DAD_Y);
				add(dadGroup);

				bfGroup = new FlxSpriteGroup(BF_X, BF_Y);
				add(bfGroup);

				gfGroup.add(gf);
				dadGroup.add(dad);
				bfGroup.add(bf);

				startCharacterPos(gf, false);
				startCharacterPos(dad, true);
				startCharacterPos(bf, false);

				lock.release();

				for (script in scriptList.keys())
				{
					try
					{
						if (scriptList.get(script).interp.variables.exists('createStagePost'))
							(scriptList.get(script).interp.variables.get('createStagePost'))(name, diff);
					}
					catch (e)
					{
						HScriptSystem.error(e);
					}
				}

				// Now time to load the UI and shit

				sustains = new FlxTypedGroup<SustainNote>();
				add(sustains);

				strums = new FlxTypedGroup<StrumNote>();
				add(strums);

				for (i in 0...strumlines)
					generateStrumline(i);

				notes = new FlxTypedGroup<Note>();
				add(notes);

				if (!hideHUD)
				{
					hudGroup = new HUDGroup();
					add(hudGroup);

					@:privateAccess hudGroup.reloadHealthBar();
					hudGroup.cameras = [hudCamera];
				}

				sustains.cameras = strums.cameras = notes.cameras = [hudCamera];

				trace('Loading finished! Took ${Utils.formatTime((haxe.Timer.stamp() - timeStamp) * 1000.0, true, true)} to load.');

				if (!noCharacters)
				{
					camFollowPos.setPosition(
						gf.getMidpoint().x + gf.cameraPosition[0] + girlfriendCameraOffset[0],
						gf.getMidpoint().y + gf.cameraPosition[1] + girlfriendCameraOffset[1]
					);

					moveCamera(dad);
				}

				generatedMusic = true;

				for (script in scriptList.keys())
				{
					try
					{
						if (scriptList.get(script).interp.variables.exists('generateSong'))
							(scriptList.get(script).interp.variables.get('generateSong'))(name, diff);
					}
					catch (e)
					{
						HScriptSystem.error(e);
					}
				}

				startCountdown();

				lock.release();
			}
		}

		// Worker #2

		worker2.doWork.add((code:Int) ->
		{
			// Setup stage and character groups

			var stageData:StageData.StageFile = StageData.getStageFile(curStage);

			if (null == stageData) // Stage doesn't exist, create a dummy stage to prevent crashing
			{
				stageData = {
					directory: "",
					defaultZoom: 0.9,
					isPixelStage: false,

					boyfriend: [770, 100],
					girlfriend: [400, 130],
					opponent: [100, 100],
					hide_girlfriend: false,

					camera_boyfriend: [0, 0],
					camera_opponent: [0, 0],
					camera_girlfriend: [0, 0],
					camera_speed: 1
				};
			}

			worker2.sendComplete(stageData);
		});

		worker2.onComplete.add((stageData:StageData.StageFile) ->
		{
			lock.acquire();

			defaultCamZoom = FlxG.camera.zoom = stageData.defaultZoom;

			BF_X = stageData.boyfriend[0];
			BF_Y = stageData.boyfriend[1];
			GF_X = stageData.girlfriend[0];
			GF_Y = stageData.girlfriend[1];
			DAD_X = stageData.opponent[0];
			DAD_Y = stageData.opponent[1];

			if (null != stageData.camera_speed)
				cameraSpeed = stageData.camera_speed;

			if (null != stageData.camera_boyfriend)
				boyfriendCameraOffset = stageData.camera_boyfriend;

			if (null != stageData.camera_opponent)
				opponentCameraOffset = stageData.camera_opponent;

			if (null != stageData.camera_girlfriend)
				girlfriendCameraOffset = stageData.camera_girlfriend;

			totalProcessed++;
			lock.release();

			check();
		});

		// Worker #3

		worker3.doWork.add((code:Int) ->
		{
			//trace('Loading gf...');
			gf = new Character(0, 0, SONG.info.spectator);
			worker3.sendComplete(gf);
		});

		worker3.onComplete.add((gf:Character) ->
		{
			lock.acquire();

			//trace('Done loading gf!');

			totalProcessed++;
			lock.release();

			check();
		});

		// Worker #4

		worker4.doWork.add((code:Int) ->
		{
			//trace('Loading dad...');
			dad = new Character(0, 0, SONG.info.player2);
			worker4.sendComplete(dad);
		});

		worker4.onComplete.add((dad:Character) ->
		{
			lock.acquire();

			//trace('Done loading dad!');

			totalProcessed++;
			lock.release();

			check();
		});

		// Worker #5

		worker5.doWork.add((code:Int) ->
		{
			//trace('Loading bf...');
			bf = new Character(0, 0, SONG.info.player1);
			worker5.sendComplete(bf);
		});

		worker5.onComplete.add((bf:Character) ->
		{
			lock.acquire();

			//trace('Done loading bf!');

			totalProcessed++;
			lock.release();

			check();
		});

		// Worker #6

		worker6.doWork.add((code:Int) ->
		{
			//trace('Loading instrumental audio file...');
			inst = new FlxSound().loadEmbedded(Paths.inst(SONG.song));
			worker6.sendComplete(inst);
		});

		worker6.onComplete.add((inst:FlxSound) ->
		{
			lock.acquire();

			inst.onComplete = endSong;
			FlxG.sound.list.add(inst);
			inst.looped = false;

			totalProcessed++;
			lock.release();

			check();
		});

		// Worker #7

		worker7.doWork.add((code:Int) ->
		{
			if (SONG.info.needsVoices)
			{
				//trace('Loading voices audio file...');
				voices = new FlxSound().loadEmbedded(Paths.voices(SONG.song));
				worker7.sendComplete(voices);
			}
			else
			{
				lock.acquire();

				totalProcessed++;
				lock.release();

				check();
			}
		});

		worker7.onComplete.add((voices:FlxSound) ->
		{
			lock.acquire();

			voices.onComplete = endSong;
			FlxG.sound.list.add(voices);
			voices.looped = false;

			totalProcessed++;
			lock.release();

			check();
		});

		worker2.run();
		worker3.run();
		worker4.run();
		worker5.run();
		worker6.run();
		worker7.run();
	});
	worker.run();
}