fix bugs (no bytecode checks yet though)

Author: compiler64

.gitignore

@@ -23,6 +23,9 @@ frontend/build
 ### Matches should be ignored
 /matches/
 
+### Cross-play temp files
+/crossplay_temp/
+
 ### Java
 *.classpath
 *.project

build.gradle

@@ -91,6 +91,10 @@ task headless(type: JavaExec, dependsOn: [':engine:build', ':example-bots:build'
   ]
 }
 
+task crossPlayPy(type: Exec, dependsOn: [':engine:build']) {
+  commandLine 'python', 'engine/src/crossplay_python/main.py', '--teamA', project.property('teamA'), '--teamB', project.property('teamB')
+}
+
 // keep the client happy because it references this step
 task unpackClient() {}
 

engine/src/crossplay_python/crossplay.py

@@ -38,8 +38,8 @@ class CrossPlayObjectType(Enum):
 
 class CrossPlayMethod(Enum):
     INVALID = 0
-    TERMINATE = 1
-    START_TURN = 2 # returns [rc, round, team, id, end]
+    START_TURN = 1 # returns [rc, round, team, id, end]
+    END_TURN = 2 # params: [bytecode_used]
     RC_GET_ROUND_NUM = 3
     RC_GET_MAP_WIDTH = 4
     RC_GET_MAP_HEIGHT = 5
@@ -198,7 +198,8 @@ def from_json(cls, json_data):
         params = [CrossPlayObject.from_json(param) for param in json_data["params"]]
         return CrossPlayMessage(method, params)
 
-def wait(message: CrossPlayMessage, timeout=1000, timestep=0.1, message_dir=MESSAGE_DIR):
+# 0.1 ms timestep, 10 min timeout
+def wait(message: CrossPlayMessage, timeout=600, timestep=0.0001, message_dir=MESSAGE_DIR):
     read_file = os.path.join(message_dir, MESSAGE_FILE_JAVA)
     write_file = os.path.join(message_dir, MESSAGE_FILE_OTHER)
     java_lock_file = os.path.join(message_dir, LOCK_FILE_JAVA)

engine/src/crossplay_python/main.py

@@ -6,7 +6,8 @@
 from collections import OrderedDict
 
 from crossplay_python.runner import RobotRunner
-from crossplay_python.crossplay import BYTECODE_LIMIT, CrossPlayMessage, CrossPlayMethod, wait
+from crossplay_python.crossplay import BYTECODE_LIMIT, CrossPlayLiteral as lit, \
+    CrossPlayMessage as mess, CrossPlayMethod as m, CrossPlayObjectType as ot, wait
 from crossplay_python.wrappers import _GAME_METHODS, Team
 
 CROSSPLAY_PYTHON_DIR = "example-bots/src/crossplay_python"
@@ -18,6 +19,9 @@
 }
 
 def get_code(bot_name):
+    if bot_name is None:
+        return None
+
     path = f"{CROSSPLAY_PYTHON_DIR}/{bot_name}"
 
     # read all files in this directory into a dictionary
@@ -40,22 +44,21 @@ def format_print(*args):
 def play(team_a=None, team_b=None, debug=False):
     print(f"Starting cross-play Python runner with teams {team_a} and {team_b}")
 
-    # TODO comment out these lines when done testing
-    if team_a is None:
-        team_a = "pytest"
-    
-    if team_b is None:
-        team_b = "pytest"
-
     code = {
         Team.A: get_code(team_a),
         Team.B: get_code(team_b),
         Team.NEUTRAL: None
     }
 
     while True:
-        rc, round, team, id, end = wait(CrossPlayMessage(CrossPlayMethod.START_TURN, []))
-        print(f"Starting turn for RobotController: {rc}, round: {round}, team: {TEAM_NAMES[team]}, ID: {id}, end: {end}")
+        rc, round, team, id, end = wait(mess(m.START_TURN, []))
+
+        if end:
+            print("Game ended")
+            break
+
+        if debug:
+            print(f"Starting turn. Round {round}, team {TEAM_NAMES[team]}, ID {id}, end {end}")
 
         runner = RobotRunner(
             code=code[team],
@@ -64,11 +67,11 @@ def play(team_a=None, team_b=None, debug=False):
             bytecode_limit=BYTECODE_LIMIT,
             debug=debug)
 
+        runner.init_robot()
         runner.run()
-
-        if end:
-            print("Game ended")
-            break
+        bytecode = runner.bytecode_limit - runner.bytecode
+        runner.kill()
+        wait(mess(m.END_TURN, [lit(ot.INTEGER, bytecode)]))
 
 if __name__ == "__main__":
     parser = ArgumentParser()

engine/src/main/battlecode/crossplay/CrossPlay.java

@@ -4,9 +4,11 @@
 import org.json.*;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.nio.file.*;
 
 import battlecode.common.*;
+import battlecode.instrumenter.stream.RoboPrintStream;
 
 /**
  * Allows bots written in different languages to be run by the Java engine using a message-passing system.
@@ -21,15 +23,26 @@ public class CrossPlay {
         LOCK_FILE_JAVA = "lock_java.txt", // lock file created by the java engine
         LOCK_FILE_OTHER = "lock_other.txt"; // lock file created by the other language's runner script
 
+    private final boolean finalizer;
+    private boolean initialized;
     private ArrayList<Object> objects;
     private RobotController rc;
+    private CrossPlayReference rcRef;
     private int roundNum;
     private Team team;
     private int id;
-    private CrossPlayReference rcRef;
+    private OutputStream out;
 
     public CrossPlay() {
         this.objects = new ArrayList<>();
+        this.finalizer = false;
+        this.initialized = false;
+    }
+
+    public CrossPlay(boolean finalizer) {
+        this.objects = new ArrayList<>();
+        this.finalizer = finalizer;
+        this.initialized = false;
     }
 
     private void clearObjects() {
@@ -116,7 +129,7 @@ private CrossPlayReference setNextObject(CrossPlayObjectType type, Object value)
         return ref;
     }
 
-    public void runMessagePassing() {
+    public int runMessagePassing() throws GameActionException {
         Path crossPlayDir = Paths.get(CROSS_PLAY_DIR);
         Path javaMessagePath = crossPlayDir.resolve(MESSAGE_FILE_JAVA);
         Path otherMessagePath = crossPlayDir.resolve(MESSAGE_FILE_OTHER);
@@ -127,7 +140,7 @@ public void runMessagePassing() {
         while (true) {
             try {
                 if (!Files.exists(otherMessagePath) || Files.exists(javaMessagePath) || Files.exists(otherLockPath)) {
-                    Thread.sleep(100, 0); // TODO make shorter: sleep for 0.1 s
+                    Thread.sleep(0, 100000); // TODO currently 0.1 ms, maybe make shorter
                     // System.out.println("Still waiting for message Python -> Java...");
                     continue;
                 }
@@ -144,20 +157,22 @@ public void runMessagePassing() {
 
                 // System.out.println("Received message Python -> Java: " + messageJson.toString());
 
-                if (message.method == CrossPlayMethod.TERMINATE) {
-                    Files.delete(otherMessagePath);
-                    Files.delete(javaLockPath);
-                    // System.out.println("Received terminate message, ending cross-play message passing.");
-                    break;
-                }
-
                 CrossPlayObject result = processMessage(message);
                 String resultContent = result.toJson().toString();
                 Files.writeString(javaMessagePath, resultContent);
 
                 Files.delete(otherMessagePath);
                 Files.delete(javaLockPath);
 
+                if (message.method == CrossPlayMethod.END_TURN) {
+                    // System.out.println("Received terminate message, ending cross-play message passing.");
+                    int bytecodeUsed = getLiteralValue(message.params[0]);
+                    return bytecodeUsed;
+                } else if (this.finalizer && message.method == CrossPlayMethod.START_TURN) {
+                    // System.out.println("Finalizer received start turn message, ending cross-play message passing.");
+                    return 0;
+                }
+
                 // System.out.println("Sent response Java -> Python: " + resultContent);
                 // System.out.println("Waiting for message Python -> Java...");
             } catch (InterruptedException e) {
@@ -168,71 +183,61 @@ public void runMessagePassing() {
         }
     }
 
-    // private JSONArray processJsonMessages(JSONArray json) {
-    //     System.out.println("Starting cross-play message processing...");
-    //     int length = json.length();
-    //     JSONObject[] resultsArr = new JSONObject[length];
-
-    //     for (int i = 0; i < length; i++) {
-    //         JSONObject messageJson = json.getJSONObject(i);
-    //         CrossPlayMessage message = CrossPlayMessage.fromJson(messageJson);
-    //         CrossPlayObject result = processMessage(message);
-    //         JSONObject resultJson = result.toJson();
-    //         resultsArr[i] = resultJson;
-    //     }
-
-    //     JSONArray resultsJson = new JSONArray(resultsArr);
-    //     System.out.println("Finished cross-play message processing.");
-    //     return resultsJson;
-    // }
-
     private CrossPlayObject processMessage(CrossPlayMessage message) {
-        CrossPlayObject[] computedParams = new CrossPlayObject[message.params.length];
-
-        for (int i = 0; i < message.params.length; i++) {
-            CrossPlayObject param = message.params[i];
-
-            if (param instanceof CrossPlayMessage mess) {
-                CrossPlayObject innerResult = processMessage(mess);
-                computedParams[i] = getObject(innerResult);
-            } else {
-                computedParams[i] = param;
-            }
-        }
-
         CrossPlayObject result;
         RobotController rc;
 
         // TODO add cases for all methods
         switch (message.method) {
             case INVALID:
                 throw new CrossPlayException("Received invalid cross-play method!");
-            case TERMINATE:
-                throw new CrossPlayException("Terminate messages should be handled outside of processMessage.");
             case START_TURN:
-                result = new CrossPlayLiteral(CrossPlayObjectType.ARRAY, new CrossPlayObject[] {
-                    this.rcRef,
-                    new CrossPlayLiteral(CrossPlayObjectType.INTEGER, this.roundNum),
-                    new CrossPlayLiteral(CrossPlayObjectType.TEAM, this.team),
-                    new CrossPlayLiteral(CrossPlayObjectType.INTEGER, this.id),
-                    new CrossPlayLiteral(CrossPlayObjectType.BOOLEAN, false),
-                });
+                // System.out.println("Processing START_TURN");
+                if (this.finalizer) {
+                    result = new CrossPlayLiteral(CrossPlayObjectType.ARRAY, new CrossPlayObject[] {
+                        CrossPlayLiteral.NULL,
+                        CrossPlayLiteral.NULL,
+                        CrossPlayLiteral.NULL,
+                        CrossPlayLiteral.NULL,
+                        CrossPlayLiteral.TRUE
+                    });
+                } else {
+                    result = new CrossPlayLiteral(CrossPlayObjectType.ARRAY, new CrossPlayObject[] {
+                        this.rcRef,
+                        CrossPlayLiteral.ofInt(this.roundNum),
+                        CrossPlayLiteral.ofTeam(this.team),
+                        CrossPlayLiteral.ofInt(this.id),
+                        CrossPlayLiteral.FALSE
+                    });
+                }
+                break;
+            case END_TURN:
+                // System.out.println("Processing END_TURN");
+                result = new CrossPlayLiteral(CrossPlayObjectType.NULL, null);
                 break;
             case RC_GET_ROUND_NUM:
-                rc = this.<RobotController>getObject(computedParams[0]);
+                // System.out.println("Processing RC_GET_ROUND_NUM");
+                rc = this.<RobotController>getObject(message.params[0]);
                 result = new CrossPlayLiteral(CrossPlayObjectType.INTEGER, rc.getRoundNum());
                 break;
             case RC_GET_MAP_WIDTH:
-                rc = this.<RobotController>getObject(computedParams[0]);
+                // System.out.println("Processing RC_GET_MAP_WIDTH");
+                rc = this.<RobotController>getObject(message.params[0]);
                 result = new CrossPlayLiteral(CrossPlayObjectType.INTEGER, rc.getMapWidth());
                 break;
             case RC_GET_MAP_HEIGHT:
-                rc = this.<RobotController>getObject(computedParams[0]);
+                // System.out.println("Processing RC_GET_MAP_HEIGHT");
+                rc = this.<RobotController>getObject(message.params[0]);
                 result = new CrossPlayLiteral(CrossPlayObjectType.INTEGER, rc.getMapHeight());
                 break;
             case LOG:
-                String msg = getLiteralValue(computedParams[0]);
-                System.out.println(msg);
+                // System.out.println("Processing LOG");
+                String msg = getLiteralValue(message.params[0]);
+
+                if (this.out instanceof RoboPrintStream rps) {
+                    rps.println(msg);
+                }
+
                 result = new CrossPlayLiteral(CrossPlayObjectType.NULL, null);
                 break;
             default:
@@ -242,20 +247,32 @@ private CrossPlayObject processMessage(CrossPlayMessage message) {
         return result;
     }
 
-    public void playTurn(RobotController rc) {
+    public int playTurn(RobotController rc, OutputStream systemOut) throws GameActionException {
+        // System.out.println("playTurn called for CrossPlay instance " + this.hashCode());
+
+        if (this.rc == rc && this.roundNum == rc.getRoundNum()) {
+            // System.out.println("playTurn returned early for CrossPlay instance " + this.hashCode());
+            return 0;
+        }
+
         this.rc = rc;
         this.roundNum = rc.getRoundNum();
         this.team = rc.getTeam();
         this.id = rc.getID();
+        this.out = systemOut;
 
-        if (this.roundNum == 1) {
+        if (this.initialized) {
+            this.rcRef = new CrossPlayReference(CrossPlayObjectType.ROBOT_CONTROLLER, 0);
+        } else {
             clearObjects();
             this.rcRef = setNextObject(CrossPlayObjectType.ROBOT_CONTROLLER, this.rc);
-            System.out.println("Cross-play bot initialized!");
-        } else {
-            this.rcRef = new CrossPlayReference(CrossPlayObjectType.ROBOT_CONTROLLER, 0);
+            this.initialized = true;
+            // System.out.println("Cross-play bot initialized!");
         }
-        
-        runMessagePassing();
+
+        // System.out.println("Running message passing for CrossPlay instance " + this.hashCode());
+        int bytecodeUsed = runMessagePassing();
+        // System.out.println("playTurn finished for CrossPlay instance " + this.hashCode());
+        return bytecodeUsed;
     }
 }

engine/src/main/battlecode/crossplay/CrossPlayLiteral.java

@@ -86,4 +86,53 @@ public static CrossPlayLiteral fromJson(JSONObject json) {
                 throw new CrossPlayException("Cannot decode CrossPlayObject of type " + type + " as a literal.");
         }
     }
-}
+
+    public static CrossPlayLiteral of(Object value) {
+        if (value == null) {
+            return NULL;
+        } else if (value instanceof Boolean) {
+            return ofBoolean((Boolean)value);
+        } else if (value instanceof Integer) {
+            return ofInt((Integer)value);
+        } else if (value instanceof Double) {
+            return ofDouble((Double)value);
+        } else if (value instanceof String) {
+            return ofString((String)value);
+        } else if (value instanceof CrossPlayObject[]) {
+            return ofArray((CrossPlayObject[])value);
+        } else if (value instanceof Team) {
+            return ofTeam((Team)value);
+        } else {
+            throw new CrossPlayException("Cannot create CrossPlayLiteral from value of type " + value.getClass().getName());
+        }
+    }
+
+    public static final CrossPlayLiteral
+        NULL = new CrossPlayLiteral(CrossPlayObjectType.NULL, null),
+        TRUE = new CrossPlayLiteral(CrossPlayObjectType.BOOLEAN, true),
+        FALSE = new CrossPlayLiteral(CrossPlayObjectType.BOOLEAN, false);
+
+    public static CrossPlayLiteral ofBoolean(Boolean value) {
+        return value ? TRUE : FALSE;
+    }
+
+    public static CrossPlayLiteral ofInt(Integer value) {
+        return new CrossPlayLiteral(CrossPlayObjectType.INTEGER, value);
+    }
+
+    public static CrossPlayLiteral ofDouble(Double value) {
+        return new CrossPlayLiteral(CrossPlayObjectType.DOUBLE, value);
+    }
+
+    public static CrossPlayLiteral ofString(String value) {
+        return new CrossPlayLiteral(CrossPlayObjectType.STRING, value);
+    }
+
+    public static CrossPlayLiteral ofArray(CrossPlayObject[] value) {
+        return new CrossPlayLiteral(CrossPlayObjectType.ARRAY, value);
+    }
+
+    public static CrossPlayLiteral ofTeam(Team value) {
+        return new CrossPlayLiteral(CrossPlayObjectType.TEAM, value);
+    }
+}