crossplay refactor + package

Author: TheApplePieGod

build.gradle

@@ -104,7 +104,14 @@ headlessPy.mustRunAfter crossPlayPy
 // keep the client happy because it references this step
 task unpackClient() {}
 
-task run(dependsOn: ['crossPlayPy', 'headlessPy', 'unpackClient']) {}
+task run(dependsOn: ['unpackClient']) {}
+
+if (project.hasProperty('languageA') && project.property('languageA') == 'python' ||
+    project.hasProperty('languageB') && project.property('languageB') == 'python') {
+  run.dependsOn crossPlayPy, headlessPy
+} else {
+  run.dependsOn headless
+}
 
 task runClient {
   doLast {

engine/build.gradle

@@ -54,8 +54,8 @@ dependencies {
     [group: 'org.hibernate', name: 'hibernate-search', version: '3.1.0.GA'],
 
     [group: 'net.sf.trove4j', name: 'trove4j', version: '2.1.0'],
-
-    [group: 'org.json', name: 'json', version: '20251224'],
+    
+    [group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.15.2'],
   )
   // implementation files('lib/jsi-1.0.jar')
 

engine/src/battlecode.py

@@ -0,0 +1,2 @@
+**/_version.py
+*.egg-info/

engine/src/crossplay_python/.gitignore

@@ -0,0 +1,2 @@
+from .enums import Team, Direction
+from .wrappers import rc, log

engine/src/crossplay_python/battlecode/__init__.py

@@ -0,0 +1,116 @@
+import socket
+import struct
+import json
+import time
+from enum import Enum
+
+# Connection constants
+IPC_HOST = "127.0.0.1"
+IPC_PORT = 27185
+BYTECODE_LIMIT = 20000  # Default, updated by game
+
+
+class CrossPlayException(Exception):
+    def __init__(self, message):
+        super().__init__(
+            message
+            + " (If you are a competitor, please report this to the Battlecode staff.)"
+        )
+
+
+class CrossPlayMethod(Enum):
+    INVALID = 0
+    START_TURN = 1
+    END_TURN = 2
+    RC_GET_ROUND_NUM = 3
+    RC_GET_MAP_WIDTH = 4
+    RC_GET_MAP_HEIGHT = 5
+    LOG = 6
+
+
+class CrossPlayClient:
+    def __init__(self):
+        self.sock = None
+
+    def connect(self):
+        while True:
+            try:
+                self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self.sock.connect((IPC_HOST, IPC_PORT))
+                break
+            except ConnectionRefusedError:
+                time.sleep(0.1)
+            except Exception as e:
+                raise CrossPlayException(f"Failed to connect to Java server: {e}")
+
+    def send_json(self, data):
+        if self.sock is None:
+            raise CrossPlayException("Socket not connected")
+
+        json_bytes = json.dumps(data).encode("utf-8")
+        length = len(json_bytes)
+        try:
+            self.sock.sendall(struct.pack(">I", length))
+            self.sock.sendall(json_bytes)
+        except Exception as e:
+            raise CrossPlayException(f"Failed to send data: {e}")
+
+    def receive_json(self):
+        if self.sock is None:
+            raise CrossPlayException("Socket not connected")
+
+        try:
+            length_bytes = self.recv_exactly(4)
+            length = struct.unpack(">I", length_bytes)[0]
+            data_bytes = self.recv_exactly(length)
+            return json.loads(data_bytes.decode("utf-8"))
+        except Exception as e:
+            raise CrossPlayException(f"Failed to receive data: {e}")
+
+    def recv_exactly(self, n):
+        if self.sock is None:
+            raise CrossPlayException("Socket not connected")
+
+        data = b""
+        while len(data) < n:
+            packet = self.sock.recv(n - len(data))
+            if not packet:
+                raise CrossPlayException("Socket connection closed unexpectedly")
+            data += packet
+        return data
+
+    def close(self):
+        if self.sock:
+            self.sock.close()
+            self.sock = None
+
+
+# Global client instance
+_client = CrossPlayClient()
+
+
+def connect():
+    _client.connect()
+
+
+def close():
+    _client.close()
+
+
+def send(method: CrossPlayMethod, params=None):
+    if params is None:
+        params = []
+
+    message = {"method": method.value, "params": params}
+
+    _client.send_json(message)
+
+
+def send_and_wait(method: CrossPlayMethod, params=None):
+    send(method, params)
+    return _client.receive_json()
+
+
+def receive():
+    return _client.receive_json()
+

engine/src/crossplay_python/battlecode/crossplay.py

@@ -0,0 +1,68 @@
+from enum import Enum as _Enum
+
+class Team(_Enum):
+    A = 0
+    B = 1
+    NEUTRAL = 2
+
+    def opposite(self):
+        match self:
+            case Team.A:
+                return Team.B
+            case Team.B:
+                return Team.A
+            case Team.NEUTRAL:
+                return Team.NEUTRAL
+
+dir_to_index = {
+    (0, 1): 0,
+    (1, 1): 1,
+    (1, 0): 2,
+    (1, -1): 3,
+    (0, -1): 4,
+    (-1, -1): 5,
+    (-1, 0): 6,
+    (-1, 1): 7,
+    (0, 0): 8
+}
+
+# TODO make sure this matches the Java Direction enum, this could cause bugs
+class Direction(_Enum):
+    NORTH = (0, 1)
+    NORTHEAST = (1, 1)
+    EAST = (1, 0)
+    SOUTHEAST = (1, -1)
+    SOUTH = (0, -1)
+    SOUTHWEST = (-1, -1)
+    WEST = (-1, 0)
+    NORTHWEST = (-1, 1)
+    CENTER = (0, 0)
+
+    def opposite(self) -> 'Direction':
+        if self == Direction.CENTER:
+            return self
+        return dir_order[(dir_to_index[self.value] + 4) % 8]
+
+    def rotate_left(self) -> 'Direction':
+        if self == Direction.CENTER:
+            return self
+        return dir_order[(dir_to_index[self.value] - 1) % 8]
+    
+    def rotate_right(self) -> 'Direction':
+        if self == Direction.CENTER:
+            return self
+        return dir_order[(dir_to_index[self.value] + 1) % 8]
+    
+    def all_directions():
+        return Direction.__members__.values()
+    
+    def cardinal_directions():
+        return [Direction.NORTH, Direction.EAST, Direction.SOUTH, Direction.WEST]
+    
+    def get_dx(self):
+        return self.value[0]
+    
+    def get_dy(self):
+        return self.value[1]
+
+dir_order = [Direction.NORTH, Direction.NORTHEAST, Direction.EAST, Direction.SOUTHEAST, Direction.SOUTH, Direction.SOUTHWEST, Direction.WEST, Direction.NORTHWEST, Direction.CENTER]

engine/src/crossplay_python/battlecode/enums.py

@@ -10,7 +10,7 @@
 import dis
 import inspect
 from enum import Enum
-from crossplay_python.wrappers import RobotController
+from .wrappers import RobotController
 
 class GameFinishedException(Exception):
     pass

engine/src/crossplay_python/instrument.py …rossplay_python/battlecode/instrument.pyengine/src/crossplay_python/instrument.py renamed to engine/src/crossplay_python/battlecode/instrument.py engine/src/crossplay_python/instrument.py renamed to engine/src/crossplay_python/battlecode/instrument.py

@@ -0,0 +1,30 @@
+from .crossplay import (
+    CrossPlayMethod as _m,
+    send_and_wait as _wait,
+)
+from .enums import *
+
+class RobotController:
+    def get_round_num():
+        return _wait(_m.RC_GET_ROUND_NUM)
+
+    def get_map_width():
+        return _wait(_m.RC_GET_MAP_WIDTH)
+
+    def get_map_height():
+        return _wait(_m.RC_GET_MAP_HEIGHT)
+
+
+rc = RobotController
+
+
+def log(message):
+    return _wait(_m.LOG, [message])
+
+
+_GAME_METHODS = {
+    "Direction": Direction,
+    "Team": Team,
+    "rc": rc,
+    "log": (log, 1),
+}