fix crossplay bugs

Author: compiler64

engine/src/crossplay_python/battlecode/classes.py

@@ -36,7 +36,7 @@ class Team(_Enum):
     B = 1
     NEUTRAL = 2
 
-    def opposite(self):
+    def opponent(self) -> 'Team':
         match self:
             case Team.A:
                 return Team.B
@@ -45,26 +45,16 @@ def opposite(self):
             case Team.NEUTRAL:
                 return Team.NEUTRAL
 
-    def __str__(self):
+    def ordinal(self) -> int:
+        return self.value
+    
+    def __str__(self) -> str:
         return self.name
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Team.{self.name}"
 
 
-_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
-}
-
-
 # make sure this matches the Java Direction enum, this could cause bugs
 class Direction(_Enum):
     NORTH = (0, 1)
@@ -84,38 +74,42 @@ def __init__(self, dx: int, dy: int):
     def opposite(self) -> 'Direction':
         if self == Direction.CENTER:
             return self
-        return _dir_order[(_dir_to_index[self.value] + 4) % 8]
+        return _dir_order[(_dir_to_index[self] + 4) % 8]
 
     def rotate_left(self) -> 'Direction':
         if self == Direction.CENTER:
             return self
-        return _dir_order[(_dir_to_index[self.value] - 1) % 8]
+        return _dir_order[(_dir_to_index[self] - 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()
+        return _dir_order[(_dir_to_index[self] + 1) % 8]
 
-    def cardinal_directions():
+    def all_directions() -> list['Direction']:
+        return list(Direction)
+
+    def cardinal_directions() -> list['Direction']:
         return [Direction.NORTH, Direction.EAST, Direction.SOUTH, Direction.WEST]
 
-    def get_delta_x(self):
+    def get_delta_x(self) -> int:
         return self.dx
 
-    def get_delta_y(self):
+    def get_delta_y(self) -> int:
         return self.dy
 
-    def __str__(self):
+    def ordinal(self) -> int:
+        return _dir_to_index[self]
+    
+    def __str__(self) -> str:
         return self.name
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Direction.{self.name}"
 
 
 _dir_order = list(Direction)
+_dir_to_index = {dir: index for index, dir in enumerate(_dir_order)}
 
 
 class MapLocation:
@@ -132,15 +126,15 @@ def subtract(self, dir: Direction) -> 'MapLocation':
     def translate(self, dx: int, dy: int) -> 'MapLocation':
         return MapLocation(self.x + dx, self.y + dy)
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         if not isinstance(other, MapLocation):
             return False
         return self.x == other.x and self.y == other.y
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"[{self.x}, {self.y}]"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"MapLocation({self.x}, {self.y})"
 
 
@@ -179,13 +173,20 @@ def is_rat_king_type(self) -> bool:
 
     def is_cat_type(self) -> bool:
         return self == UnitType.CAT
+    
+    def ordinal(self) -> int:
+        return _ut_to_index[self]
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"UnitType.{self.name}"
-    
+
+
+_ut_order = list(UnitType)
+_ut_to_index = {ut: index for index, ut in enumerate(_ut_order)}
+
 
 class TrapType(_Enum):
     RAT_TRAP = (30, 50, 20, 25, 15, 0, 25, 2)
@@ -203,17 +204,24 @@ def __init__(self, build_cost: int, damage: int, stun_time: int, trap_limit: int
         self.max_count = max_count
         self.trigger_radius_squared = trigger_radius_squared
 
-    def __str__(self):
+    def ordinal(self) -> int:
+        return _trap_to_index[self]
+    
+    def __str__(self) -> str:
         return self.name
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"TrapType.{self.name}"
 
 
+_trap_order = list(TrapType)
+_trap_to_index = {trap: index for index, trap in enumerate(_trap_order)}
+
+
 class MapInfo:
-    def __init__(self, loc: MapLocation, is_passable: bool, is_wall: bool, is_dirt: bool,
+    def __init__(self, location: MapLocation, is_passable: bool, is_wall: bool, is_dirt: bool,
                  cheese_amount: int, trap: TrapType, has_cheese_mine: bool):
-        self.loc = loc
+        self.location = location
         self.is_passable = is_passable
         self.is_wall = is_wall
         self.is_dirt = is_dirt
@@ -243,11 +251,11 @@ def __init__(self, message_bytes: int, sender_id: int, round: int, source_loc: M
         self.sender_id = sender_id
         self.round = round
         self.source_loc = source_loc
-    
-    def __str__(self):
+
+    def __str__(self) -> str:
         return f"Message with value {self.bytes} sent from robot with ID {self.sender_id} during round {self.round} from location {self.source_loc}."
-    
-    def __repr__(self):
+
+    def __repr__(self) -> str:
         return f"Message({self.bytes}, sender_id={self.sender_id}, round={self.round}, source_loc={self.source_loc})"
 
 
@@ -298,7 +306,6 @@ class GameConstants:
     RAT_BITE_DAMAGE = 10
     CAT_SCRATCH_DAMAGE = 50
     CAT_POUNCE_MAX_DISTANCE_SQUARED = 9
-    CAT_POUNCE_ADJACENT_DAMAGE_PERCENT = 50
     CAT_DIG_ADDITIONAL_COOLDOWN = 5
     HEALTH_GRAB_THRESHOLD = 0
     RAT_KING_UPGRADE_CHEESE_COST = 50

engine/src/crossplay_python/battlecode/crossplay.py

@@ -3,6 +3,7 @@
 import json
 import time
 from enum import Enum
+from collections import deque
 from .classes import *
 
 # Connection constants
@@ -164,7 +165,7 @@ def send_json(self, data):
         try:
             self.sock.sendall(struct.pack(">I", length))
             self.sock.sendall(json_bytes)
-            print("Json bytes sent:", struct.pack(">I", length) + json_bytes)
+            # print("Json bytes sent:", struct.pack(">I", length) + json_bytes)
         except Exception as e:
             raise CrossPlayException(f"Failed to send data: {e}")
 
@@ -200,6 +201,8 @@ def close(self):
 
 # Global client instance
 _client = CrossPlayClient()
+# _spawn_queue: deque[tuple[Team, int]] = deque()
+_destroy_queue: deque[int] = deque()
 
 
 def connect():
@@ -263,53 +266,73 @@ def make_json(obj):
 
 
 def parse(json):
-    if json is None:
-        return None
-    
-    if isinstance(json, dict) and "type" in json:
-        obj_type = object_types[json["type"]]
-    
-        match obj_type:
-            case CrossPlayObjectType.THROWN_GAME_ACTION_EXCEPTION:
-                raise GameActionException(exception_types[json["etype"]], json["msg"])
-            case CrossPlayObjectType.DIRECTION:
-                return directions[json["val"]]
-            case CrossPlayObjectType.TEAM:
-                return teams[json["val"]]
-            case CrossPlayObjectType.MAP_LOCATION:
-                return MapLocation(json["x"], json["y"])
-            case CrossPlayObjectType.UNIT_TYPE:
-                return unit_types[json["val"]]
-            case CrossPlayObjectType.TRAP_TYPE:
-                return trap_types[json["val"]]
-            case CrossPlayObjectType.MESSAGE:
-                return Message(json["bytes"], json["sid"], json["round"], json["loc"])
-            case CrossPlayObjectType.ROBOT_INFO:
-                return RobotInfo(
-                    json["id"],
-                    teams[json["team"]],
-                    unit_types[json["ut"]],
-                    json["hp"],
-                    parse(json["loc"]),
-                    directions[json["dir"]],
-                    json["chir"],
-                    json["ch"],
-                    parse(json["carry"]),
-                )
-            case CrossPlayObjectType.MAP_INFO:
-                return MapInfo(
-                    parse(json["loc"]),
-                    json["pass"],
-                    json["wall"],
-                    json["dirt"],
-                    json["ch"],
-                    trap_types[json["trap"]],
-                    json["cm"],
-                )
-            case _:
-                raise CrossPlayException("Unknown object type received from server: " + str(obj_type))
-    else:
-        return json
+    while True:  # so that as many robots as necessary can be destroyed, but usually return after one iteration
+        if json is None:
+            return None
+        
+        if isinstance(json, dict) and "type" in json:
+            raw_type = json["type"]
+
+            if raw_type == "destroy_bot":
+                _destroy_queue.append(json["id"])
+                send_null()
+                json = _client.receive_json()
+                continue
+            # elif raw_type == "spawn_bot":
+                # _spawn_queue.append((teams[json["team"]], json["id"]))
+                # send_null()
+                # _client.receive_json()  # consume the extra null response
+                # return None
+            elif isinstance(raw_type, int):
+                obj_type = object_types[raw_type]
+        
+                match obj_type:
+                    case CrossPlayObjectType.THROWN_GAME_ACTION_EXCEPTION:
+                        raise GameActionException(exception_types[json["etype"]], json["msg"])
+                    case CrossPlayObjectType.DIRECTION:
+                        return directions[json["val"]]
+                    case CrossPlayObjectType.TEAM:
+                        return teams[json["val"]]
+                    case CrossPlayObjectType.MAP_LOCATION:
+                        return MapLocation(json["x"], json["y"])
+                    case CrossPlayObjectType.UNIT_TYPE:
+                        return unit_types[json["val"]]
+                    case CrossPlayObjectType.TRAP_TYPE:
+                        return trap_types[json["val"]]
+                    case CrossPlayObjectType.MESSAGE:
+                        return Message(json["bytes"], json["sid"], json["round"], json["loc"])
+                    case CrossPlayObjectType.ROBOT_INFO:
+                        return RobotInfo(
+                            json["id"],
+                            parse(json["team"]),
+                            parse(json["ut"]),
+                            json["hp"],
+                            parse(json["loc"]),
+                            parse(json["dir"]),
+                            json["chir"],
+                            json["ch"],
+                            parse(json["carry"]),
+                        )
+                    case CrossPlayObjectType.MAP_INFO:
+                        return MapInfo(
+                            parse(json["loc"]),
+                            json["pass"],
+                            json["wall"],
+                            json["dirt"],
+                            json["ch"],
+                            parse(json["trap"]),
+                            json["cm"],
+                        )
+                    case _:
+                        raise CrossPlayException("Unknown object type received from server: "
+                                                + str(obj_type))
+            else:
+                raise CrossPlayException("Invalid object type received from server: "
+                                        + str(raw_type))
+        elif isinstance(json, list):
+            return [parse(item) for item in json]
+        else:
+            return json
 
 
 def send_wait_and_parse(method: CrossPlayMethod, params=None):

engine/src/crossplay_python/battlecode/runner.py

@@ -236,7 +236,7 @@ def init_robot(self):
         #     self.error_method(traceback.format_exc(limit=5))
 
     def do_turn(self):
-        print("Doing turn")
+        # print("Doing turn")
         if 'turn' in self.locals and isinstance(self.locals['turn'], type(lambda: 1)):
             # try:
             exec(self.locals['turn'].__code__, self.globals, self.locals)

engine/src/crossplay_python/battlecode/wrappers.py

@@ -293,7 +293,7 @@ def sense_nearby_map_infos(center: MapLocation = ..., radius_squared: int = ...)
             return _wait(_m.RC_SENSE_NEARBY_MAP_INFOS__LOC_INT, [center, radius_squared])
 
     @staticmethod
-    def sense_nearby_robots(center: MapLocation = ..., radius_squared: int = ..., team: Team = ...):
+    def sense_nearby_robots(center: MapLocation = ..., radius_squared: int = ..., team: Team = ...) -> list[RobotInfo]:
         """
         Possible parameter combinations:
         - sense_nearby_robots()
@@ -361,8 +361,8 @@ def write_shared_array(index: int, value: int) -> None:
 rc = RobotController
 
 
-def log(message):
-    return _wait(_m.LOG, [message])
+def log(*messages) -> None:
+    return _wait(_m.LOG, [" ".join(map(str, messages))])
 
 
 def bottom_left_distance_squared_to(loc1: MapLocation, loc2: MapLocation) -> int: