eeee

Author: Yuta12342

source/Main.hx

@@ -930,6 +930,20 @@ class CommandPrompt
 					print("Error: multi-command requires at least one command.");
 				}
 
+			case "testTrapLink":
+				if (archipelago.APEntryState.inArchipelagoMode)
+					if (args.length == 1)
+						archipealgo.APGameState.instance?.doTrapLink({
+							source: "apTest",
+							trap_name: args[0],
+							time: haxe.Timer.stamp()
+						});
+
+						if (!archipelago.APEntryState.inArchipelagoMode)
+						{
+							print("Error: You can only use this command in Archipelago mode.");
+						}
+
 			case "runCode":
 				if (args.length > 0)
 				{

source/archipelago/APYaml.hx

@@ -3,6 +3,110 @@ package archipelago;
 import haxe.format.JsonParser;
 import haxe.ds.StringMap;
 import haxe.ds.Map;
+
+abstract APOption(String) {
+    public inline function new(v:String) {
+        this = v;
+    }
+
+    // Auto-conversion from various types
+    @:from
+    public static inline function fromString(value:String):APOption {
+        return new APOption(value);
+    }
+
+    @:from
+    public static inline function fromBool(value:Bool):APOption {
+        return new APOption(value ? "true" : "false");
+    }
+
+    @:from
+    public static inline function fromFloat(value:Float):APOption {
+        return new APOption(Std.string(value));
+    }
+
+    @:from
+    public static inline function fromInt(value:Int):APOption {
+        return new APOption(Std.string(value));
+    }
+
+    @:from
+    public static inline function fromArray(value:Array<String>):APOption {
+        return new APOption("[" + value.join(", ") + "]");
+    }
+
+    // Auto-conversion to various types
+    @:to
+    public inline function toString():String {
+        return this;
+    }
+
+    @:to
+    public function toBool():Bool {
+        return this == "true";
+    }
+
+    @:to
+    public function toFloat():Float {
+        var parsed = Std.parseFloat(this);
+        return Math.isNaN(parsed) ? 0.0 : parsed;
+    }
+
+    @:to
+    public function toInt():Int {
+        return Std.int(toFloat());
+    }
+
+    @:to
+    public function toArray():Array<String> {
+        if (this.startsWith("[") && this.endsWith("]")) {
+            var content = this.substr(1, this.length - 2);
+            return content.split(",").map(function(item) return item.trim());
+        }
+        return [this];
+    }
+
+    // Smart parsing function that attempts to determine and convert to the appropriate type
+    public function parseValue():Dynamic {
+        // Check for array format
+        if (this.startsWith("[") && this.endsWith("]")) {
+            return toArray();
+        }
+        
+        // Check for boolean
+        if (this == "true" || this == "false") {
+            return toBool();
+        }
+        
+        // Check for numeric (float/int)
+        var floatValue = Std.parseFloat(this);
+        if (!Math.isNaN(floatValue)) {
+            // Check if it's an integer
+            if (floatValue == Std.int(floatValue)) {
+                return toInt();
+            }
+            return toFloat();
+        }
+        
+        // Default to string
+        return toString();
+    }
+
+    // Check if the value represents a specific type
+    public function isArray():Bool {
+        return this.startsWith("[") && this.endsWith("]");
+    }
+
+    public function isBool():Bool {
+        return this == "true" || this == "false";
+    }
+
+    public function isNumeric():Bool {
+        return !Math.isNaN(Std.parseFloat(this));
+    }
+}
+
+
 class APYaml {
     public var game:String;
     public var name:String;
@@ -44,22 +148,13 @@ class APYaml {
                     var value = keyValue[1].trim();
 
                     if (key == "game")
-                        this.game = value;
+                        this.game = new APOption(value);
                     else if (key == "name")
-                        this.name = value;
+                        this.name = new APOtion(value);
                     else if (key == "description")
-                        this.description = value;
-
-                    if (value.startsWith("[") && value.endsWith("]")) {
-                        value = value.substr(1, value.length - 2);
-                        sectionData.set(key, value.split(",").map(function(item) return item.trim()));
-                    } else if (value == "true" || value == "false") {
-                        sectionData.set(key, value == "true");
-                    } else if (cast(Std.parseFloat(value), Null<Float>) != null || Math.isNaN(Std.parseFloat(value))) {
-                        sectionData.set(key, Std.parseFloat(value));
-                    } else {
-                        sectionData.set(key, value);
-                    }
+                        this.description = new APOption(value);
+
+                    sectionData.set(key, new APOption(value));
                 }
             }
         }

source/objects/Strum.hx

@@ -0,0 +1,53 @@
+package source.objects;
+
+package objects;
+
+abstract Strum(Dynamic) from Dynamic to Dynamic {
+    public inline function new(value:Dynamic) {
+        this = value;
+    }
+
+    public inline function toStrumNote():StrumNote {
+        return cast this;
+    }
+
+    public inline function toString():String {
+        return Std.string(this);
+    }
+    
+    @:from
+    public static function fromStrumNote(note:StrumNote):Strum {
+        return cast note;
+    }
+
+    @:from
+    public static function fromChartingStrumNote(note:objects.charting.ChartingStrumNote):Strum {
+        return cast note;
+    }
+
+    @:to
+    public static function toStrumNote(strum:Strum):StrumNote {
+        return cast strum;
+    }
+
+    @:to
+    public static function toChartingStrumNote(strum:Strum):objects.charting.ChartingStrumNote {
+        return cast strum;
+    }
+
+    public static function createStrumNote(x:Float, y:Float, leData:Int, ?playField:objects.playfields.PlayField):Strum {
+        return cast new StrumNote(x, y, leData, playField);
+    }
+
+    public static function createChartingStrumNote(x:Float, y:Float, leData:Int, player:Int):Strum {
+        return cast new objects.charting.ChartingStrumNote(x, y, leData, player);
+    }
+
+    public static function createStrum(x:Float, y:Float, leData:Int, player:Int):Strum {
+        return cast new StrumNote(x, y, leData, player);
+    }
+
+    public inline function toChartingStrumNote():objects.charting.ChartingStrumNote {
+        return cast this;
+    }
+}