Refactor & overhaul condition system

src/main/java/com/github/manolo8/darkbot/Bot.java

@@ -33,6 +33,20 @@ public static void main(String[] args) throws IOException {
 
         LogUtils.setupLogOutput();
 
+        setupUI();
+
+        LibSetup.setupLibraries();
+        StartupParams params = new StartupParams(args);
+
+        System.out.println("Starting DarkBot " + Main.VERSION);
+        //noinspection ThrowableNotThrown
+        Runtime.getRuntime().addShutdownHook(new Thread(() ->
+                new Throwable("DarkBot shutdown peacefully!").printStackTrace()));
+
+        SwingUtilities.invokeLater(() -> new Main(params));
+    }
+
+    public static void setupUI() {
         try {
             UIManager.put("MenuItem.selectionType", "underline");
             UIManager.getFont("Label.font"); // Prevents a linux crash
@@ -63,16 +77,6 @@ public static void main(String[] args) throws IOException {
         } catch (UnsupportedLookAndFeelException e) {
             e.printStackTrace();
         }
-
-        LibSetup.setupLibraries();
-        StartupParams params = new StartupParams(args);
-
-        System.out.println("Starting DarkBot " + Main.VERSION);
-        //noinspection ThrowableNotThrown
-        Runtime.getRuntime().addShutdownHook(new Thread(() ->
-                new Throwable("DarkBot shutdown peacefully!").printStackTrace()));
-
-        SwingUtilities.invokeLater(() -> new Main(params));
     }
 
     @SuppressWarnings("removal")

src/main/java/com/github/manolo8/darkbot/config/actions/Condition.java

@@ -4,21 +4,18 @@
 import eu.darkbot.api.PluginAPI;
 import org.jetbrains.annotations.NotNull;
 
+@Deprecated
 public interface Condition extends Value<Condition.Result>, eu.darkbot.api.config.types.Condition {
 
-    @Override
-    default @NotNull eu.darkbot.api.config.types.Condition.Result get(PluginAPI pluginAPI) {
-        Result result = get(pluginAPI.requireInstance(Main.class));
-
-        return eu.darkbot.api.config.types.Condition.Result.values()[result.ordinal()];
-    }
-
     /**
      * @deprecated Use {@link #get(PluginAPI)} instead
      */
     @Deprecated
-    @NotNull Result get(Main main);
+    default @NotNull Result get(Main main) {
+        return Result.values()[get(main.pluginAPI).ordinal()];
+    }
 
+    @Deprecated
     enum Result {
         ALLOW, DENY, ABSTAIN;
 

src/main/java/com/github/manolo8/darkbot/config/actions/LegacyCondition.java

@@ -0,0 +1,15 @@
+package com.github.manolo8.darkbot.config.actions;
+
+/**
+ * This class exists PURELY to avoid an import mess.
+ * Condition implementations need to keep implementing darkbot's Condition (interface)
+ * for backwards-compat with older plugins, but if they implement darkbot's Condition directly,
+ * Condition.Result is darkbot's condition instead of the API's. To solve this, they will now
+ * implement LegacyCondition so that ConditionResult is the api's condition.
+ * <br>
+ * This will be all removed in a future release, when legacy plugins stop using legacy conditions and have
+ * fully migrated to the API's condition type.
+ */
+@SuppressWarnings("deprecation")
+public interface LegacyCondition extends Condition {
+}

src/main/java/com/github/manolo8/darkbot/config/actions/Parser.java

@@ -1,5 +1,7 @@
 package com.github.manolo8.darkbot.config.actions;
 
+import com.github.manolo8.darkbot.config.actions.tree.ParsingNode;
+
 public interface Parser {
-    String parse(String str) throws SyntaxException;
+    void parse(ParsingNode node) throws SyntaxException;
 }

src/main/java/com/github/manolo8/darkbot/config/actions/SyntaxException.java

@@ -1,26 +1,73 @@
 package com.github.manolo8.darkbot.config.actions;
 
 import com.github.manolo8.darkbot.config.actions.parser.Values;
+import com.github.manolo8.darkbot.gui.utils.highlight.Locatable;
+import lombok.Getter;
+import lombok.experimental.Delegate;
 import org.jetbrains.annotations.NotNull;
 
+import javax.swing.text.Position;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 
-public class SyntaxException extends Exception {
+public class SyntaxException extends RuntimeException implements Locatable {
 
     private static final String[] EMPTY = new String[]{};
 
-    private final String at;
+    @Delegate
+    private final Locatable loc;
     private final String[] chars;
     private final List<Values.Meta<?>> metadatas;
+    @Getter
     private boolean singleMeta = false;
 
+    public SyntaxException(String message, Locatable loc, String... chars) {
+        super(message);
+        this.loc = loc;
+        this.chars = chars == null ? EMPTY : chars;
+        this.metadatas = Collections.emptyList();
+    }
+
+    public SyntaxException(String message, Locatable loc, Values.Meta<?> meta, String... chars) {
+        this(message, loc, meta == null ? null : Collections.singletonList(meta), chars);
+        singleMeta = true;
+    }
+
+    public SyntaxException(String message, Locatable loc, List<Values.Meta<?>> metas, String... chars) {
+        super(message);
+        this.loc = loc;
+        this.chars = chars == null ? EMPTY : chars;
+        this.metadatas = metas == null ? Collections.emptyList() : metas;
+    }
+
+    public <E extends Enum<E>> SyntaxException(String message, Locatable loc, Class<E> metadatas) {
+        this(message, loc, (List<Values.Meta<?>>) null, Arrays.stream(metadatas.getEnumConstants())
+                .map(Objects::toString).toArray(String[]::new));
+    }
+
     public SyntaxException(String message, String at) {
         this(message, at, (List<Values.Meta<?>>) null, (String[]) null);
     }
 
+    public SyntaxException(String message, int atIdx, String... chars) {
+        super(message);
+        this.loc = new Locatable() {
+            @Override
+            public Position getStart() {
+                return () -> atIdx;
+            }
+
+            @Override
+            public Position getEnd() {
+                return null;
+            }
+        };
+        this.chars = chars == null ? EMPTY : chars;
+        this.metadatas = Collections.emptyList();
+    }
+
     public <E extends Enum<E>> SyntaxException(String message, String at, Class<E> metadatas) {
         this(message, at, (List<Values.Meta<?>>) null, Arrays.stream(metadatas.getEnumConstants())
                 .map(Objects::toString).toArray(String[]::new));
@@ -33,13 +80,13 @@ public SyntaxException(String message, String at, Values.Meta<?> meta, String...
 
     public SyntaxException(String message, String at, List<Values.Meta<?>> metas, String... chars) {
         super(message);
-        this.at = at == null ? "" : at;
+        this.loc = null;
         this.chars = chars == null ? EMPTY : chars;
         this.metadatas = metas == null ? Collections.emptyList() : metas;
     }
 
-    public String getAt() {
-        return at;
+    public int getAt() {
+        return loc.getStart().getOffset();
     }
 
     public @NotNull String[] getExpected() {
@@ -50,8 +97,4 @@ public String getAt() {
         return metadatas;
     }
 
-    public boolean isSingleMeta() {
-        return singleMeta;
-    }
-
 }

src/main/java/com/github/manolo8/darkbot/config/actions/Value.java

@@ -1,20 +1,26 @@
 package com.github.manolo8.darkbot.config.actions;
 
 import com.github.manolo8.darkbot.Main;
+import eu.darkbot.api.PluginAPI;
+import eu.darkbot.api.config.types.Condition;
 import org.jetbrains.annotations.Nullable;
 
 public interface Value<R> {
 
-    @Nullable R get(Main main);
+    @Nullable R get(Main api);
 
     static <T> T get(Value<T> val, Main main) {
         if (val == null) return null;
         return val.get(main);
     }
 
-    static boolean allows(Value<Condition.Result> val, Main main) {
-        Condition.Result res = get(val, main);
+    static boolean allows(Value<Condition.Result> val, PluginAPI api) {
+        Condition.Result res = get(val, api);
         return res != null && res.allows();
     }
 
+    static <T> T get(Value<T> val, PluginAPI api) {
+        return get(val, api.requireInstance(Main.class));
+    }
+
 }

src/main/java/com/github/manolo8/darkbot/config/actions/conditions/AbstractCondition.java

@@ -1,41 +1,43 @@
 package com.github.manolo8.darkbot.config.actions.conditions;
 
-import com.github.manolo8.darkbot.Main;
-import com.github.manolo8.darkbot.config.actions.Condition;
+import com.github.manolo8.darkbot.config.actions.LegacyCondition;
 import com.github.manolo8.darkbot.config.actions.Parser;
 import com.github.manolo8.darkbot.config.actions.SyntaxException;
 import com.github.manolo8.darkbot.config.actions.ValueData;
-import com.github.manolo8.darkbot.config.actions.parser.ParseResult;
-import com.github.manolo8.darkbot.config.actions.parser.ParseUtil;
 import com.github.manolo8.darkbot.config.actions.parser.ValueParser;
-import com.github.manolo8.darkbot.config.actions.parser.Values;
+import com.github.manolo8.darkbot.config.actions.tree.ParsingNode;
+import eu.darkbot.api.PluginAPI;
+import eu.darkbot.api.config.types.Condition;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public abstract class AbstractCondition implements Condition, Parser {
+import static eu.darkbot.api.config.types.Condition.Result.ABSTAIN;
+import static eu.darkbot.api.config.types.Condition.Result.ALLOW;
+import static eu.darkbot.api.config.types.Condition.Result.DENY;
+
+public abstract class AbstractCondition implements LegacyCondition, Parser {
 
-    public int min, max;
     public List<Condition> children;
 
     public AbstractCondition() {
         children = new ArrayList<>();
     }
 
-    public Result getValue(Main main, int min, int max) {
+    public Condition.Result getValue(PluginAPI api, int min, int max) {
         int[] states = new int[]{0, 0, 0};
         for (int i = 0; i < children.size(); i++) {
-            states[children.get(i).get(main).ordinal()]++;
+            states[children.get(i).get(api).ordinal()]++;
             if ((states[1] + states[2] > children.size() - min && states[0] + states[1] > 0) /* Can't reach min anymore */
                     || states[0] > max /* Allow bigger than max */) {
-                return Condition.Result.DENY;
+                return DENY;
             }
             if (states[0] >= min && states[0] + (children.size() - 1 - i) >= max) { /* Won't go bigger than max */
-                return Condition.Result.ALLOW;
+                return ALLOW;
             }
         }
-        return states[0] >= min ? Condition.Result.ALLOW : Condition.Result.ABSTAIN;
+        return states[0] >= min ? ALLOW : ABSTAIN;
     }
 
     protected String name() {
@@ -48,20 +50,10 @@ public String toString() {
     }
 
     @Override
-    public String parse(String str) throws SyntaxException {
-        boolean hasNext;
-        do {
-            ParseResult<Result> pr = ValueParser.parse(str, Result.class);
-            if (!(pr.value instanceof Condition))
-                throw new SyntaxException("Error: Expected boolean condition", str, Values.getMeta(getClass()));
-
-            children.add((Condition) pr.value);
-            str = pr.leftover.trim();
-
-            hasNext = !str.isEmpty() && str.charAt(0) == ',';
-            str = ParseUtil.separate(str, getClass(), ",", ")");
-        } while (hasNext);
-        return str;
+    public void parse(ParsingNode node) throws SyntaxException {
+        for (ParsingNode child : node.getChildren()) {
+            children.add(ValueParser.parseCondition(child));
+        }
     }
 
 }

src/main/java/com/github/manolo8/darkbot/config/actions/conditions/AfterCondition.java

@@ -1,36 +1,31 @@
 package com.github.manolo8.darkbot.config.actions.conditions;
 
-import com.github.manolo8.darkbot.Main;
-import com.github.manolo8.darkbot.config.actions.Condition;
+import com.github.manolo8.darkbot.config.actions.LegacyCondition;
 import com.github.manolo8.darkbot.config.actions.Parser;
 import com.github.manolo8.darkbot.config.actions.SyntaxException;
-import com.github.manolo8.darkbot.config.actions.Value;
 import com.github.manolo8.darkbot.config.actions.ValueData;
-import com.github.manolo8.darkbot.config.actions.parser.ParseResult;
-import com.github.manolo8.darkbot.config.actions.parser.ParseUtil;
 import com.github.manolo8.darkbot.config.actions.parser.ValueParser;
+import com.github.manolo8.darkbot.config.actions.tree.ParsingNode;
 import com.github.manolo8.darkbot.config.actions.values.NumberConstant;
-import com.github.manolo8.darkbot.core.entities.Ship;
+import eu.darkbot.api.PluginAPI;
+import eu.darkbot.api.config.types.Condition;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Locale;
-
 @ValueData(name = "after", description = "Returns true if inner condition is true after the specified time in seconds", example = "after(7.5, condition)")
-public class AfterCondition implements Condition, Parser {
+public class AfterCondition implements LegacyCondition, Parser {
 
     public long time;
-    public Value<Result> condition;
+    public Condition condition;
 
     private transient Long allowTime = null;
 
     @Override
-    public @NotNull Condition.Result get(Main main) {
-        Result res = Value.get(condition, main);
-        if (res == null) return Result.ABSTAIN;
+    public @NotNull Condition.Result get(PluginAPI api) {
+        Condition.Result res = condition.get(api);
 
         allowTime = res.allows() ? allowTime != null ? allowTime : System.currentTimeMillis() + time : null;
 
-        return Result.fromBoolean(allowTime != null && System.currentTimeMillis() > allowTime);
+        return Condition.Result.fromBoolean(allowTime != null && System.currentTimeMillis() > allowTime);
     }
 
 
@@ -40,16 +35,10 @@ public String toString() {
     }
 
     @Override
-    public String parse(String str) throws SyntaxException {
-        String[] params = str.split(" *, *", 2);
-
-        time = (long) (NumberConstant.parseNumber(params[0], str, getClass()).doubleValue() * 1000);
-
-        str = ParseUtil.separate(params, getClass(), ",");
-
-        ParseResult<Result> pr = ValueParser.parse(str, Result.class);
-        condition = pr.value;
+    public void parse(ParsingNode node) throws SyntaxException {
+        node.requireParamSize(2, getClass());
 
-        return ParseUtil.separate(pr.leftover.trim(), getClass(), ")");
+        time = (long) (NumberConstant.parseNumber(node.getParam(0), getClass()).doubleValue() * 1000);
+        condition = ValueParser.parseCondition(node.getParam(1));
     }
 }

src/main/java/com/github/manolo8/darkbot/config/actions/conditions/AllCondition.java

@@ -1,15 +1,16 @@
 package com.github.manolo8.darkbot.config.actions.conditions;
 
-import com.github.manolo8.darkbot.Main;
 import com.github.manolo8.darkbot.config.actions.ValueData;
+import eu.darkbot.api.PluginAPI;
+import eu.darkbot.api.config.types.Condition;
 import org.jetbrains.annotations.NotNull;
 
 @ValueData(name = "all", description = "Returns true if all child conditions return true", example = "all(a, b)")
 public class AllCondition extends AbstractCondition {
 
     @Override
-    public @NotNull Result get(Main main) {
-        return super.getValue(main, children.size(), children.size());
+    public @NotNull Condition.Result get(PluginAPI api) {
+        return super.getValue(api, children.size(), children.size());
     }
 
 }