Holy shit.

Author: Yuta12342

source/Main.hx

@@ -70,6 +70,7 @@ extern "C" HRESULT WINAPI SetCurrentProcessExplicitAppUserModelID(PCWSTR AppID);
 ')
 #end
 // // // // // // // // //
+@:autoBuild(yutautil.StatePick.addToDatabase(Main))
 class Main extends Sprite
 {
 	public static final game = {
@@ -99,6 +100,85 @@ class Main extends Sprite
 			trace("Error: " + e);
 		}
 		trace("Finished testing forceCast.");
+
+		var r:Random<Int> = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+		trace("Random Test: " + r);
+
+		trace("Random Test 2: " + new Random<Int>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
+
+		var r2:Random<Int> = [for (i in 1...11) i];
+		trace("Random Test 3: " + r2);
+
+
+		var temp:Temp<Int> = 23932;
+
+		trace("Temp Test 2: " + temp);
+
+		var temp2:Temp<{value:Int, otherValue:Int}> = {
+			value: 123,
+			otherValue: 456
+		};
+
+		var nonTemp:{value:Int, otherValue:Int} = {
+			value: 123,
+			otherValue: 456
+		};
+
+		var temp2Address = cpp.Native.addressOf(game);
+		trace("Star test 1: " + temp2Address);
+		var randofdsde:Temp<Int> = 123;
+		trace("Temp Test 3: " + randofdsde);
+
+
+
+		var eeee:Int = 123;
+
+		var p = cpp.Pointer.addressOf(eeee)[0];
+		trace("Pointer Test: " + p);
+
+		var funnyDouble = new HaxePointer<Dynamic>(game);
+		trace("Funny Double Test: " + funnyDouble);
+		trace("Funny Double Test: " + new HaxePointer<Dynamic>(game));
+
+		(new Fields(temp2).printFields());
+		(new Fields(nonTemp).printFields());
+
+		trace("TestAcc: " + new FieldAccTest({}).eeeee);
+		trace("TestAcc2: " );
+		var testAcc2 = new FieldAccTest({eeeee: 123}).eeeee = 456;
+
+		var collaped:Collapsed<Int> = [[1], [2], [3], [4], [5]];
+
+		trace("Collaped Test: " + collaped);
+
+		var gaming:GlobalPointer<Dynamic> = game;
+
+		// gaming.startFullscreen = true;
+
+		// Pointer of a pointer test (HaxePointer of HaxePointer, stacked 5 times)
+		var arr:Array<Int> = [1, 2, 3, 4, 5];
+
+		// var ptr1 = new HaxePointer<Array<Int>>(arr);
+		// var ptr2 = new HaxePointer<HaxePointer<Array<Int>>>(ptr1);
+		// var ptr3 = new HaxePointer<HaxePointer<HaxePointer<Array<Int>>>>(ptr2);
+		// var ptr4 = new HaxePointer<HaxePointer<HaxePointer<HaxePointer<Array<Int>>>>>(ptr3);
+		// var ptr5 = new HaxePointer<HaxePointer<HaxePointer<HaxePointer<HaxePointer<Array<Int>>>>>>(ptr4);
+
+		// // Now resolve the pointer all the way down to the array
+		// var ptr = ptr5;
+		// var resolvedArr:Array<Int> = ptr;
+
+
+		// trace("Resolved stacked HaxePointer array: " + resolvedArr);
+
+		// // Let's also put the pointer in another array and resolve it
+		// var pointerArray:Array<Dynamic> = [ptr];
+		// var resolvedFromArray:Array<Int> = pointerArray[0];
+		// trace("Resolved from pointerArray: " + resolvedFromArray);
+
+
+		trace("TypeTools ptrMap: " + TypeTools.ptrMap);
+
 		Lib.current.addChild(new Main());
 		//Stolen from Psych Online. Thanks for making the next hour of my life not hell.
 		Lib.current.addChild(new archipelago.console.SideUI());

source/archipelago/APGameState.hx

@@ -472,12 +472,12 @@ class APGameState
 		}
 	}
 
-	public function getSongLocations(songName:String, modName:String):Array<Int>
+	public function getSongLocations(songName:String, ?modName:String):Array<Int>
 	{
 		return locationData(songName, modName).concat(noteData(songName, modName));
 	}
 
-	public function checkGoal(songName:String, modName:String):Bool
+	public function checkGoal(songName:String, ?modName:String):Bool
 	{ modName = (modName != null && modName != "") ? modName.trim() : "";
 		var info = info();
 		var locations = locationData(songName, modName).concat(noteData(songName, modName));
@@ -496,6 +496,13 @@ class APGameState
 		return false;
 	}
 
+	public function songInMultiworld(songName:String, ?modName:String):Bool
+	{
+		modName = (modName != null && modName != "") ? modName.trim() : "";
+		return locationData(songName, modName).length > 0
+			|| noteData(songName, modName).length > 0;
+	}
+
 	public function setGoal():Void
 	{
 		info().set_goal();

source/archipelago/APPlayState.hx

@@ -1251,7 +1251,7 @@ class APPlayState extends PlayState {
 		shieldSprite.visible = false;
 		add(shieldSprite);
 
-        if (cpuControlled || ClientPrefs.getGameplaySetting('showcase', false))
+        if (cpuControlled || ClientPrefs.getGameplaySetting('showcase', false) && !(Sys.args().contains('-livereload')))
         {
             //set_cpuControlled(false);
             cpuControlled = false;

source/backend/MusicBeatState.hx

@@ -8,6 +8,7 @@ import flixel.FlxState;
 import backend.PsychCamera;
 import archipelago.APEntryState;
 
+@:autoBuild(yutautil.StatePick.addToDatabase(MusicBeatState))
 class MusicBeatState extends FlxState
 {
 	private var curSection:Int = 0;
@@ -63,6 +64,10 @@ class MusicBeatState extends FlxState
 
 		super.create();
 
+		// if (!(this is PlayState) && PlayState.instance != null)
+		// 	yutautil.MemoryHelper.freeMemory(PlayState.instance);
+
+
 		// if (backend.window.CppAPI.getWindowOpacity()!=1)
 		#if windows
 

source/debug/FPSCounter.hx

@@ -207,7 +207,8 @@ class FPSCounter extends TextField
 		#end
 
 				if (ClientPrefs.data.showInitialMemoryUsage && initMemory != null && Sys.args().indexOf('-livereload') != -1)
-			text += '\nInitial Memory: ${flixel.util.FlxStringUtil.formatBytes(initMemory)}';
+			text += '\nInitial Memory: ${flixel.util.FlxStringUtil.formatBytes(initMemory)}' + '\n' +
+				'Current State Address: ${new HaxeAddress(FlxG.state)}';
 	}
 
 	function obtainMemory():Dynamic

source/import.hx

@@ -94,6 +94,8 @@ import flixel.addons.transition.FlxTransitionableState;
 
 import yutautil.ImprovedFileHandling;
 
+import yutautil.ChanceSelector;
+
 using StringTools;
 using yutautil.CollectionUtils;
 using yutautil.MetaData;
@@ -104,5 +106,7 @@ using yutautil.GenericObject;
 using yutautil.PyScript;
 using yutautil.FieldMap;
 using yutautil.Tracked;
-using yutautil.OneOrMany;
+using yutautil.TypeUtils;
+using yutautil.MacroTypeUtils;
+using yutautil.RuntimeTypedef;
 #end

source/stages/PhillyBlazin.hx

@@ -28,7 +28,7 @@ class PhillyBlazin extends BaseStage
 
 	override function create()
 	{
-		StickerSubState.STICKER_PACK = "weekend";
+		substates.StickerSubState.STICKER_PACK = "weekend";
 		FlxTransitionableState.skipNextTransOut = true; //skip the original transition fade
 		function setupScale(spr:BGSprite)
 		{

source/states/PlayState.hx

@@ -7627,7 +7627,7 @@ class PlayState extends MusicBeatState
 
 		NoteSplash.configs.clear();
 		mania = 3;
-		instance = null;
+		// instance = null;
 		super.destroy();
 		endingSong = true;
 		Paths.clearStoredWithoutStickers();

source/states/TitleState.hx

@@ -80,8 +80,15 @@ class TitleState extends MusicBeatState
 		super.create();
 		trace(this.metadata());
 		for (classthing in this.metadata().super_tree.toIterable())
-			trace("Ultimate Super Tree for " + classthing + ": " + classthing.metadata().super_tree);
-		
+			try {
+			trace("Ultimate Super Tree for " + classthing + ": " + Type.createEmptyInstance(Type.resolveClass(classthing)).metadata().super_tree);
+			} catch (e:haxe.Exception) {
+				trace("Error retrieving super tree for " + classthing + ": " + e.message);
+				trace("Details: " + e.details());
+				trace("Stack: " + e.stack);
+				trace("Type: " + Type.getClassName(Type.resolveClass(classthing)));
+			}
+
 		curWacky = FlxG.random.getObject(getIntroTextShit());
 
 		if(!initialized)

source/yutautil/ChanceSelector.hx

@@ -8,7 +8,49 @@ typedef ChanceFunction = {
     func: Void -> Dynamic, // Function to execute
     chance: Float // Chance of execution, assumed to be between 0 and 100
 }
-  class ChanceSelector {
+
+
+/**
+ * Random<T> is an abstract type that allows you to create a random item from an array of items.
+ * It provides methods to get a random item, set a new array of items, and convert between Random<T> and T.
+ */
+abstract Random<T>(OneOrMore<T>) {
+    public inline function new(values:OneOrMore<T>) this = values;
+
+    // Returns a random item from the array
+    @:to public inline function get():T {
+        if (this == null || this.isEmpty()) throw "Random: No items to select from";
+        return ChanceExtensions.chanceArray(this);
+    }
+
+    // Sets the array to a new set of items and returns a random item from the new array
+    @:from
+    static public inline function set<T>(values:Array<T>):Random<T> {
+        return new Random<T>((values));
+    }
+
+    @:to public inline function fromArray<T>():T {
+        return ChanceExtensions.chanceArray(this);
+    }
+    @:to  public inline function fromArrayOrNull<T>():T {
+        if (this == null || this.isEmpty()) return null;
+        return ChanceExtensions.chanceArray(this);
+    }
+
+    @:to public inline function toArray():Array<T> {
+        return new OneOrMore<T>(this).toArray();
+    }
+
+    @:to public inline function oneOrMore():OneOrMore<T> {
+        return new OneOrMore<T>(this).toArray();
+    }
+
+    @:from public static inline function fromOneOrMore<T>(values:OneOrMore<T>):Random<T> {
+        "This is just a constructor for Random<T> from OneOrMore<T>".NativeComment();
+        return new Random<T>(values);
+    }
+}
+class ChanceSelector {
     public static function selectOption(options:Array<Chance>, strict:Bool = false, downsize:Bool = true, allowNull:Bool = false):Dynamic {
         //trace("Entering selectOption function");
         //trace("Input options: " + options);