Variables and Operators Implementation

Author: ryderjt

src/main/java/com/pathmind/PathmindClientMod.java

@@ -6,6 +6,7 @@
 import com.pathmind.screen.PathmindMainMenuIntegration;
 import com.pathmind.screen.PathmindScreens;
 import com.pathmind.ui.overlay.ActiveNodeOverlay;
+import com.pathmind.ui.overlay.VariablesOverlay;
 import com.pathmind.util.BaritoneDependencyChecker;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents;
@@ -25,6 +26,7 @@
 public class PathmindClientMod implements ClientModInitializer {
     private static final Logger LOGGER = LoggerFactory.getLogger("Pathmind/Client");
     private ActiveNodeOverlay activeNodeOverlay;
+    private VariablesOverlay variablesOverlay;
     private volatile boolean worldShutdownHandled;
     private boolean baritoneAvailable;
     private boolean missingWarningShown;
@@ -37,6 +39,7 @@ public void onInitializeClient() {
         baritoneAvailable = BaritoneDependencyChecker.isBaritoneApiPresent();
         if (baritoneAvailable) {
             this.activeNodeOverlay = new ActiveNodeOverlay();
+            this.variablesOverlay = new VariablesOverlay();
         }
 
         // Register keybindings
@@ -70,11 +73,16 @@ public void onInitializeClient() {
         });
 
         // Register HUD render callback for the active node overlay
-        if (activeNodeOverlay != null) {
+        if (activeNodeOverlay != null || variablesOverlay != null) {
             HudRenderCallback.EVENT.register((drawContext, tickDelta) -> {
                 MinecraftClient client = MinecraftClient.getInstance();
                 if (client.player != null && client.textRenderer != null) {
-                    activeNodeOverlay.render(drawContext, client.textRenderer, client.getWindow().getScaledWidth(), client.getWindow().getScaledHeight());
+                    if (activeNodeOverlay != null) {
+                        activeNodeOverlay.render(drawContext, client.textRenderer, client.getWindow().getScaledWidth(), client.getWindow().getScaledHeight());
+                    }
+                    if (variablesOverlay != null) {
+                        variablesOverlay.render(drawContext, client.textRenderer, client.getWindow().getScaledWidth(), client.getWindow().getScaledHeight());
+                    }
                 }
             });
         }

src/main/java/com/pathmind/execution/ExecutionManager.java

@@ -66,10 +66,54 @@ public class ExecutionManager {
     private static class ChainController {
         final Node startNode;
         volatile boolean cancelRequested;
+        final Map<String, RuntimeVariable> runtimeVariables;
 
         ChainController(Node startNode) {
             this.startNode = startNode;
             this.cancelRequested = false;
+            this.runtimeVariables = new ConcurrentHashMap<>();
+        }
+    }
+
+    public static final class RuntimeVariable {
+        private final NodeType type;
+        private final Map<String, String> values;
+
+        public RuntimeVariable(NodeType type, Map<String, String> values) {
+            this.type = type;
+            this.values = values == null ? Collections.emptyMap() : new HashMap<>(values);
+        }
+
+        public NodeType getType() {
+            return type;
+        }
+
+        public Map<String, String> getValues() {
+            return Collections.unmodifiableMap(values);
+        }
+    }
+
+    public static final class RuntimeVariableEntry {
+        private final String startNodeId;
+        private final String name;
+        private final RuntimeVariable variable;
+
+        public RuntimeVariableEntry(String startNodeId, String name, RuntimeVariable variable) {
+            this.startNodeId = startNodeId;
+            this.name = name;
+            this.variable = variable;
+        }
+
+        public String getStartNodeId() {
+            return startNodeId;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public RuntimeVariable getVariable() {
+            return variable;
         }
     }
 
@@ -138,6 +182,49 @@ public static ExecutionManager getInstance() {
         return instance;
     }
 
+    public boolean setRuntimeVariable(Node startNode, String name, RuntimeVariable value) {
+        if (startNode == null || name == null || name.trim().isEmpty() || value == null) {
+            return false;
+        }
+        ChainController controller = activeChains.get(startNode);
+        if (controller == null) {
+            return false;
+        }
+        controller.runtimeVariables.put(name.trim(), value);
+        return true;
+    }
+
+    public RuntimeVariable getRuntimeVariable(Node startNode, String name) {
+        if (startNode == null || name == null || name.trim().isEmpty()) {
+            return null;
+        }
+        ChainController controller = activeChains.get(startNode);
+        if (controller == null) {
+            return null;
+        }
+        return controller.runtimeVariables.get(name.trim());
+    }
+
+    public List<RuntimeVariableEntry> getRuntimeVariableEntries() {
+        if (activeChains.isEmpty()) {
+            return Collections.emptyList();
+        }
+        List<RuntimeVariableEntry> entries = new ArrayList<>();
+        for (ChainController controller : activeChains.values()) {
+            if (controller == null || controller.runtimeVariables.isEmpty()) {
+                continue;
+            }
+            String startId = controller.startNode != null ? controller.startNode.getId() : "";
+            for (Map.Entry<String, RuntimeVariable> entry : controller.runtimeVariables.entrySet()) {
+                if (entry.getKey() == null || entry.getValue() == null) {
+                    continue;
+                }
+                entries.add(new RuntimeVariableEntry(startId, entry.getKey(), entry.getValue()));
+            }
+        }
+        return entries;
+    }
+
     public void executeGraph(List<Node> nodes, List<NodeConnection> connections) {
         executeGraphInternal(nodes, connections, true);
     }