Release 0.2.0

Author: cardillan

mod.hjson

@@ -16,7 +16,7 @@ main: "cardillan.mlogassertions.Main"
 description: "Provides custom mlog instructions for enhanced runtime checks in Mindustry Logic."
 
 #the mod version
-version: 0.1
+version: 0.2.0
 
 #the minimum game build required to run this mod
 minGameVersion: 146

src/cardillan/mlogassertions/logic/AssertLStatements.java

@@ -11,6 +11,6 @@ public class AssertLogic {
     public static void init(){
         assertsCategory = new LCategory(AssertVars.assertionsCategory, Color.slate, Icon.warningSmall);
 
-        AssertLStatements.register();
+        LogicStatements.register();
     }
 }

src/cardillan/mlogassertions/logic/AssertLogic.java

@@ -1,27 +1,24 @@
 package cardillan.mlogassertions.logic;
 
-import mindustry.logic.ConditionOp;
-
 import java.util.Objects;
 
-public enum TypeAssertion {
+public enum AssertionType {
     any(num -> true, obj -> true),
     notNull(num -> true, Objects::nonNull),
     decimal(num -> true),
     integer(num -> num == (long) num),
-    even(num -> num == (long) num && num % 2 == 0),
-    odd(num -> num == (long) num && num % 2 != 0),
+    multiple(num -> num == (long) num),
     ;
 
-    public static final TypeAssertion[] all = values();
+    public static final AssertionType[] all = values();
     public final TypeAssertionObjLambda objFunction;
     public final TypeAssertionLambda function;
 
-    TypeAssertion(TypeAssertionLambda function) {
+    AssertionType(TypeAssertionLambda function) {
         this(function, obj -> false);
     }
 
-    TypeAssertion(TypeAssertionLambda function, TypeAssertionObjLambda objFunction) {
+    AssertionType(TypeAssertionLambda function, TypeAssertionObjLambda objFunction) {
         this.function = function;
         this.objFunction = objFunction;
     }

src/cardillan/mlogassertions/logic/TypeAssertion.java renamed to src/cardillan/mlogassertions/logic/AssertionType.java

@@ -6,19 +6,21 @@
 import mindustry.logic.LExecutor.Var;
 import mindustry.world.blocks.logic.LogicBlock;
 
-public class AssertsLInstructions {
+public class LogicInstructions {
 
     public static class AssertI implements LExecutor.LInstruction {
-        public TypeAssertion type = TypeAssertion.any;
+        public AssertionType type = AssertionType.any;
+        public int multiple = 1;
         public int min;
         public AssertOp opMin = AssertOp.lessThanEq;
         public int value;
         public AssertOp opMax = AssertOp.lessThanEq;
         public int max;
         public int message;
 
-        public AssertI(TypeAssertion type, int min, AssertOp opMin, int value, AssertOp opMax, int max, int message) {
+        public AssertI(AssertionType type, int multiple, int min, AssertOp opMin, int value, AssertOp opMax, int max, int message) {
             this.type = type;
+            this.multiple = multiple;
             this.min = min;
             this.opMin = opMin;
             this.value = value;
@@ -35,19 +37,18 @@ public final void run(LExecutor exec) {
             Building building = exec.building( LExecutor.varThis);
 
             Var vaVal = var(exec, value);
-            boolean typeAssert = vaVal.isobj ? type.objFunction.get(vaVal.objval) : type.function.get(vaVal.numval);
-            boolean minAssert = opMin.function.get(num(exec,min), num(exec,value));
-            boolean maxAssert = opMax.function.get(num(exec,value), num(exec,max));
-
-            if (!typeAssert || !minAssert || !maxAssert) {
+            if ((vaVal.isobj ? type.objFunction.get(vaVal.objval) : type.function.get(vaVal.numval))
+                    && (type != AssertionType.multiple || (vaVal.numval % var(exec, multiple).numval == 0))
+                    && (opMin.function.get(num(exec,min), num(exec,value)))
+                    && (opMax.function.get(num(exec,value), num(exec,max)))) {
+                Assertions.remove((LogicBlock.LogicBuild) building);
+            } else {
                 Var message = var(exec, this.message);
                 Assertions.add((LogicBlock.LogicBuild) building, LExecutor.PrintI.toString(message.objval));
 
                 //skip back to self.
                 exec.counter.numval--;
                 //exec.yield = true;
-            } else {
-                Assertions.remove((LogicBlock.LogicBuild) building);
             }
         }
 

src/cardillan/mlogassertions/logic/AssertsLInstructions.java renamed to src/cardillan/mlogassertions/logic/LogicInstructions.java

@@ -1,6 +1,6 @@
 package cardillan.mlogassertions.logic;
 
-public class AssertLStatementWriter {
+public class LogicStatementWriter {
     public static final String SEPARATOR = " ";
 
     private StringBuilder builder;
@@ -14,66 +14,66 @@ public void end(){
         builder.deleteCharAt(builder.length() - 1);
     }
 
-    public AssertLStatementWriter write(Object obj) {
+    public LogicStatementWriter write(Object obj) {
         return write(String.valueOf(obj)).write(SEPARATOR);
     }
 
-    public AssertLStatementWriter write(String str) {
+    public LogicStatementWriter write(String str) {
         builder.append(str).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(StringBuffer sb) {
+    public LogicStatementWriter write(StringBuffer sb) {
         builder.append(sb).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(CharSequence s) {
+    public LogicStatementWriter write(CharSequence s) {
         builder.append(s).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(CharSequence s, int start, int end) {
+    public LogicStatementWriter write(CharSequence s, int start, int end) {
         builder.append(s, start, end).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(char[] str) {
+    public LogicStatementWriter write(char[] str) {
         builder.append(str).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(char[] str, int offset, int len) {
+    public LogicStatementWriter write(char[] str, int offset, int len) {
         builder.append(str, offset, len).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(boolean b) {
+    public LogicStatementWriter write(boolean b) {
         builder.append(b).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(char c) {
+    public LogicStatementWriter write(char c) {
         builder.append(c).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(int i) {
+    public LogicStatementWriter write(int i) {
         builder.append(i).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(long lng) {
+    public LogicStatementWriter write(long lng) {
         builder.append(lng).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(float f) {
+    public LogicStatementWriter write(float f) {
         builder.append(f).append(SEPARATOR);
         return this;
     }
 
-    public AssertLStatementWriter write(double d) {
+    public LogicStatementWriter write(double d) {
         builder.append(d).append(SEPARATOR);
         return this;
     }