Actual multithreading shit in-game

gistfile1.hx

private function generateSong(name:String, diff:String):Void
{
	var timeStamp:Float = haxe.Timer.stamp();

	// Worker #1

	var worker = new BackgroundWorker();
	worker.doWork.add((code:Int) ->
	{
		var lock = new Mutex();

		trace('Parsing chart data from song json...');

		try
		{
			lock.acquire();

			// 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);

			lock.release();
		}
		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.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;

		// Setup stage (not threaded cause they simply don't need to be)

		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
			};
		}

		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;

		if (!noCharacters)
		{
			DisplayStage.loadStage(curStage);
		}

		var totalCount = 0;
		var check = () ->
		{
			trace(totalCount); // For testing
			if (totalCount == 5)
			{
				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;
				startCountdown();
			}
		}

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

		// Worker #2

		worker2.doWork.add((code:Int) ->
		{
			var lock = new Mutex();
			lock.acquire();

			gf = new Character(0, 0, SONG.info.spectator);
			worker2.sendComplete(gf);

			lock.release();
		});

		worker2.onComplete.add((gf:Character) ->
		{
			startCharacterPos(gf, false);
			gfGroup.add(gf);
			totalCount++;
			check();
		});

		// Worker #3

		worker3.doWork.add((code:Int) ->
		{
			var lock = new Mutex();
			lock.acquire();

			dad = new Character(0, 0, SONG.info.player2);
			worker3.sendComplete(dad);

			lock.release();
		});

		worker3.onComplete.add((dad:Character) ->
		{
			startCharacterPos(dad, true);
			dadGroup.add(dad);
			totalCount++;
			check();
		});

		// Worker #4

		worker4.doWork.add((code:Int) ->
		{
			var lock = new Mutex();
			lock.acquire();

			bf = new Character(0, 0, SONG.info.player1);
			worker3.sendComplete(bf);

			lock.release();
		});

		worker4.onComplete.add((bf:Character) ->
		{
			startCharacterPos(bf, false);
			bfGroup.add(bf);
			totalCount++;
			check();
		});

		// Worker #5

		worker5.doWork.add((code:Int) ->
		{
			trace('Loading instrumental audio file...');

			var lock = new Mutex();
			lock.acquire();

			inst = new FlxSound().loadEmbedded(Paths.inst(SONG.song));
			worker5.sendComplete(inst);

			lock.release();

			totalCount++;
			check();
		});

		worker5.onComplete.add((inst:FlxSound) ->
		{
			inst.onComplete = endSong;
			FlxG.sound.list.add(inst);
			inst.looped = false;
			totalCount++;
			check();
		});

		// Worker #6

		worker6.doWork.add((code:Int) ->
		{
			if (SONG.info.needsVoices)
			{
				trace('Loading voices audio file...');

				var lock = new Mutex();
				lock.acquire();

				voices = new FlxSound().loadEmbedded(Paths.voices(SONG.song));

				lock.release();
			}
			worker6.sendComplete(voices);
		});

		worker6.onComplete.add((voices:FlxSound) ->
		{
			if (null != voices)
			{
				voices.onComplete = endSong;
				FlxG.sound.list.add(voices);
				voices.looped = false;
			}
			totalCount++;
			check();
		});

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