Preparing for something big!

Author: Yuta12342

Project.xml

@@ -23,6 +23,7 @@
 	<define name="MODS_ALLOWED" if="desktop" />
 	<define name="HSCRIPT_ALLOWED" if="desktop" />
 	<define name="LUA_ALLOWED" if="desktop" />
+	<!-- <define name="PYTHON_ALLOWED" if="desktop" /> -->
 	<define name="ACHIEVEMENTS_ALLOWED" />
 	<define name="DISCORD_ALLOWED" />
 	<define name="TRANSLATIONS_ALLOWED" />
@@ -141,6 +142,7 @@
 	<haxelib name="hxvlc" if="VIDEOS_ALLOWED" version="2.0.1"/>
 	<haxelib name="hxdiscord_rpc" version="1.2.4" if="DISCORD_ALLOWED"/>
 	<haxelib name="flxanimate"/>
+	<haxelib name="hxpy" if="PYTHON_ALLOWED" />
 
 	<!-- Archipelago Stuff-->
 	<haxelib name="helder.set" />

haxelib.json

@@ -0,0 +1,7 @@
+{
+	"cpp": {
+		"build_flags": [
+			"-I/C:/Program Files/Python313/include"
+		]
+	}
+}

source/Main.hx

@@ -89,6 +89,20 @@ class Main extends Sprite
 
 	public static function main():Void
 	{
+		trace(18.sum());
+		trace([1, 2, 3].sum());
+		trace([1, 2.3, 3.4].sum());
+
+		function testOneOrMore(o:OneOrMore<Float>):Void {
+			if (o.isSingle()) {
+				trace("Single value: " + o.getSingle());
+			} else {
+				trace("Multiple values: " + o.toArray());
+			}
+		}
+		testOneOrMore(39.asFloat());
+		testOneOrMore([1, 2, 3].asFloat());
+
 		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/backend/Paths.hx

@@ -659,6 +659,12 @@ class Paths
 		return allowNull ? {location: null, modded: false} : null;
 	}
 
+	public static inline function assetInTopMod(key:String, ?parentFolder:String = null, ?pathType:PathType = IMAGES):Bool
+	{
+		var assetLocation = assetLocation(key, parentFolder, pathType, true, true);
+		return assetLocation != null && assetLocation.modded;
+	}
+
 	static public function image(key:String, ?parentFolder:String = null, ?allowGPU:Bool = true):FlxGraphic
 	{
 		key = Language.getFileTranslation('images/$key') + '.png';

source/import.hx

@@ -98,8 +98,11 @@ using StringTools;
 using yutautil.CollectionUtils;
 using yutautil.MetaData;
 using yutautil.PointerTools;
-using yutautil.CUMacroTools; // Careful. Using C++ Lables in Haxe may act strangely.
+using yutautil.CUMacroTools; 
 using yutautil.KonamiTracker;
 using yutautil.GenericObject;
 using yutautil.PyScript;
+using yutautil.FieldMap;
+using yutautil.Tracked;
+using yutautil.OneOrMany;
 #end

source/states/freeplay/CustomFreeplayState.hx

@@ -0,0 +1,71 @@
+package states.freeplay;
+
+import flixel.FlxState;
+import flixel.FlxG;
+import hscript.Parser;
+import hscript.Interp;
+import sys.io.File;
+import managers.FreeplayManager;
+
+    import crowplexus.iris.Iris;
+    import crowplexus.iris.IrisConfig;
+
+class CustomFreeplayState extends MusicBeatState {
+    public var scriptInterp:psychlua.HScript.CustomInterp;
+    public var scriptEnv:Dynamic;
+    public var scriptPath:String;
+    public var themeName:String;
+
+    public function new(scriptPath:String) {
+        super();
+        this.scriptPath = scriptPath;
+        this.themeName = scriptPath.split('/').pop().split('.').shift(); // Extract theme name from script path
+    }
+
+
+    // ...existing code...
+    
+    override public function create():Void {
+        super.create();
+    
+        // Prepare Iris interpreter
+        var scriptCode = File.getContent(scriptPath);
+        var iris = new Iris(scriptCode, new IrisConfig(null, false, false));
+        var customInterp:psychlua.HScript.CustomInterp = new psychlua.HScript.CustomInterp();
+		customInterp.parentInstance = FlxG.state;
+		customInterp.showPosOnLog = false;
+		this.scriptInterp = customInterp;
+
+        // Only expose Freeplay-relevant variables
+        iris.set('FreeplayManager', FreeplayManager);
+        iris.set('FlxG', FlxG);
+        iris.set('FlxState', FlxState);
+        iris.set('FlxSprite', flixel.FlxSprite);
+        iris.set('${Type.getClassName(Type.getClass(FlxG.state))}', this);
+        iris.set('state', this);
+    
+        // Parse and execute the script, expecting it to return an object with lifecycle methods
+        iris.parse(true);
+        scriptEnv = iris.funcAndReturn(iris.execute);
+    
+        // Call script's create if it exists
+        if (scriptEnv != null && Reflect.hasField(scriptEnv, "create")) {
+            Reflect.callMethod(scriptEnv, Reflect.field(scriptEnv, "create"), []);
+        }
+        this.scriptInterp = iris;
+    }
+
+    override public function update(elapsed:Float):Void {
+        super.update(elapsed);
+        if (scriptEnv != null && Reflect.hasField(scriptEnv, "update")) {
+            Reflect.callMethod(scriptEnv, Reflect.field(scriptEnv, "update"), [elapsed]);
+        }
+    }
+
+    override public function destroy():Void {
+        if (scriptEnv != null && Reflect.hasField(scriptEnv, "destroy")) {
+            Reflect.callMethod(scriptEnv, Reflect.field(scriptEnv, "destroy"), []);
+        }
+        super.destroy();
+    }
+}

source/yutautil/BrainFuck.hx

@@ -57,4 +57,41 @@ class BrainFuck {
 
         return output;
     }
+
+    public static function run(code:String, input:String = "", native:Bool = false):String {
+        try {
+            return interpret(code, input, native);
+        } catch (e:Dynamic) {
+            return "Error: " + e;
+        }
+    }
+
+    public static function runFile(filePath:String, input:String = "", native:Bool = false):String {
+        var code:String = haxe.io.File.getContent(filePath);
+        return run(code, input, native);
+    }
+
+    // Generates a Brainfuck program that sets the memory to match the given array.
+    // If native is true, checks that all values are in 0...255.
+    public static function mimicArray(arr:Array<Int>, native:Bool = false):String {
+        var code = "";
+        var last = 0;
+        var memorySize = native ? 256 : 30000;
+
+        // Check validity if native
+        if (native) {
+            for (v in arr) {
+                if (v < 0 || v > 255) throw "All values must be in 0...255 for native mode";
+            }
+        }
+
+        for (i in 0...arr.length) {
+            code += ">";
+            var diff = arr[i] - last;
+            if (diff > 0) code += StringTools.rpad("", "+", diff);
+            else if (diff < 0) code += StringTools.rpad("", "-", -diff);
+            last = arr[i];
+        }
+        return code;
+    }
 }

source/yutautil/CUMacroTools.hx

@@ -644,4 +644,68 @@ class CUMacroTools
     public static macro function checkKeysAnyPressed(keys:Array<Dynamic>):Expr {
         return macro CUMacroTools.generateKeyCheckFunction($a{[for (k in keys) macro $v{k}]}, "anyPressed")();
     }
-}
+}
+
+// Macro + Abstract for strongly-typed, size-limited function argument arrays
+
+@:forward
+abstract FuncArgsArray<T>(Array<Null<T>>) from Array<Null<T>> to Array<Null<T>> {
+    // Only allow creation via macro
+    @:from
+    static macro function fromExprs(exprs:Array<Expr>):Expr {
+        var pos = Context.currentPos();
+        // The macro must be called as FuncArgsArray.make(functionType, [args...])
+        Context.error("FuncArgsArray can only be created via FuncArgsArray.make(functionType, [args...])", pos);
+        return macro null;
+    }
+
+    // Helper to get argument types from a function type
+    public static function getArgTypes(funcType:Type):Array<Type> {
+        switch (funcType) {
+            case TFun(args, _):
+                return [for (a in args) a.t];
+            default:
+                throw "Not a function type";
+        }
+    }
+
+    // Macro to create a FuncArgsArray for a given function type and argument expressions
+    public static macro function make(funcType:Expr, args:Array<Expr>):Expr {
+        var pos = Context.currentPos();
+        var t = Context.typeof(funcType);
+        var argTypes:Array<Type> = [];
+        switch (t) {
+            case TFun(params, _):
+                argTypes = [for (a in params) a.t];
+            default:
+                Context.error("FuncArgsArray.make: funcType must be a function type", pos);
+        }
+        if (args.length > argTypes.length) {
+            Context.error('Too many arguments: expected ${argTypes.length}, got ${args.length}', pos);
+        }
+        // Fill missing args with null
+        var filledArgs = [];
+        for (i in 0...argTypes.length) {
+            if (i < args.length) {
+                filledArgs.push(args[i]);
+            } else {
+                filledArgs.push(macro null);
+            }
+        }
+        // Wrap in abstract
+        return macro new FuncArgsArray<Dynamic>([$a{filledArgs}]);
+    }
+
+    // Get argument at index (null if not provided)
+    public inline function get(i:Int):Null<T> return this[i];
+
+    // Length is fixed to the function's arity
+    public var length(get, never):Int;
+    inline function get_length() return this.length;
+}
+
+// Usage example (not part of the macro/abstract):
+// var args = FuncArgsArray.make(macro myFunc, [macro 1, macro "test"]);
+// args.get(0); // 1
+// args.get(1); // "test"
+// args.get(2); // null (if myFunc has 3 args)