mlogjs 0.4.3 → 0.4.5

package/dist/index.mjs

@@ -574,6 +574,12 @@ const itemNames = [
     "sporePod",
     "blastCompound",
     "pyratite",
+    "beryllium",
+    "tungsten",
+    "oxide",
+    "carbide",
+    "fissileMatter",
+    "dormantCyst",
 ];
 /**
  * A more type safe version of `Object.assign`
@@ -1277,11 +1283,14 @@ const ForStatement = (c, parentScope, node) => {
         : [new LiteralValue(1), []];
     const updateLines = node.update ? c.handle(scope, node.update)[1] : [];
     const startLoopAddr = new LiteralValue(null);
+    // continue statements jump here to run the loop update lines
+    const beforeEndAddr = new LiteralValue(null);
     const endLoopAddr = new LiteralValue(null);
-    const startLoopLine = new AddressResolver(startLoopAddr).bindContinue(scope);
+    const startLoopLine = new AddressResolver(startLoopAddr);
     const endLoopLine = new AddressResolver(endLoopAddr).bindBreak(scope);
+    const beforeEndLine = new AddressResolver(beforeEndAddr).bindContinue(scope);
     if (parentScope.label) {
-        startLoopLine.bindContinue(parentScope);
+        beforeEndLine.bindContinue(parentScope);
     }
     return [
         null,
@@ -1291,6 +1300,7 @@ const ForStatement = (c, parentScope, node) => {
             ...testLines,
             new JumpInstruction(endLoopAddr, EJumpKind.Equal, test, new LiteralValue(0)),
             ...withAlwaysRuns(c.handle(scope, node.body), false)[1],
+            beforeEndLine,
             ...updateLines,
             new JumpInstruction(startLoopAddr, EJumpKind.Always),
             endLoopLine,
@@ -1453,6 +1463,14 @@ class FunctionValue extends VoidValue {
 function endsWithReturn(inst) {
     for (let i = inst.length - 1; i >= 0; i--) {
         const instruction = inst[i];
+        // this means that there is an instruction trying to reference
+        // the final function `set @counter` instruction
+        // of course this generates an unecessary
+        // `set @counter` in cases where a control flow
+        // structure contains a fallback return statement
+        // TODO: fix this with static analysis
+        if (instruction instanceof AddressResolver)
+            return false;
         if (instruction.hidden)
             continue;
         return instruction instanceof SetCounterInstruction;
@@ -2070,7 +2088,21 @@ class Control extends ObjectValue {
                 color: { args: ["building", "r", "g", "b"] },
             },
             handler(scope, overload, ...args) {
-                return [null, [new InstructionBase("control", overload, ...args)]];
+                if (overload !== "color")
+                    return [null, [new InstructionBase("control", overload, ...args)]];
+                const temp = new StoreValue(scope);
+                temp.ensureOwned();
+                // this "patch" is here for compatibility reasons
+                // I don't want to add another breaking change
+                // TODO: figure out if this patch should be removed later
+                const [building, ...colors] = args;
+                return [
+                    null,
+                    [
+                        new InstructionBase("packcolor", temp, ...colors),
+                        new InstructionBase("control", overload, building, temp),
+                    ],
+                ];
             },
         }));
     }