Merge branch 'main' into public-release

Author: TheApplePieGod

battlecode25/engine/game/game.py

@@ -113,6 +113,9 @@ def mark_location(self, team: Team, loc: MapLocation, secondary: bool):
         markers = self.team_a_markers if team == Team.A else self.team_b_markers
         markers[loc.y * self.width + loc.x] = 2 if secondary else 1
 
+    def get_num_towers(self, team: Team):
+        return [robot.team == team and robot.type.is_tower_type() for robot in self.id_to_robot.values()].count(True)
+
     def get_map_info(self, team, loc): 
         idx = self.loc_to_index(loc)
         paint = self.paint[idx]
@@ -194,8 +197,8 @@ def set_winner_if_more_area(self):
         return True
 
     def set_winner_if_more_allied_towers(self):
-        towers_a = [robot.team == Team.A and robot.type.is_tower_type() for robot in self.id_to_robot.values()].count(True)
-        towers_b = [robot.team == Team.B and robot.type.is_tower_type() for robot in self.id_to_robot.values()].count(True)
+        towers_a = self.get_num_towers(Team.A)
+        towers_b = self.get_num_towers(Team.B)
         if towers_a == towers_b:
             return False
         self.set_winner(Team.A if towers_a > towers_b else Team.B, DominationFactor.MORE_TOWERS_ALIVE)
@@ -490,6 +493,7 @@ def create_methods(self, rc: RobotController):
             'get_paint': (rc.get_paint, 1),
             'get_money': (rc.get_money, 1),
             'get_type': (rc.get_type, 1),
+            'get_num_towers': (rc.get_num_towers, 5),
             'on_the_map': (rc.on_the_map, 5),
             'can_sense_location': (rc.can_sense_location, 5),
             'is_location_occupied': (rc.is_location_occupied, 5),
@@ -536,6 +540,7 @@ def create_methods(self, rc: RobotController):
             'can_upgrade_tower': (rc.can_upgrade_tower, 2),
             'upgrade_tower': rc.upgrade_tower,
             'resign': rc.resign,
+            'disintegrate': rc.disintegrate,
             'set_indicator_string': rc.set_indicator_string,
             'set_indicator_dot': rc.set_indicator_dot,
             'set_indicator_line': rc.set_indicator_line,

battlecode25/engine/game/robot_controller.py

@@ -61,6 +61,9 @@ def get_tower_pattern(self, tower_type: UnitType) -> List[List[bool]]:
         self.assert_is_tower_type(tower_type)
         return self.game.pattern[self.game.shape_from_tower_type(tower_type).value]
 
+    def get_num_towers(self):
+        return self.game.get_num_towers(self.robot.team)
+    
     # ROBOT QUERY FUNCTIONS
 
     def get_id(self) -> int:
@@ -266,6 +269,10 @@ def assert_can_attack(self, loc: MapLocation) -> None:
             self.assert_can_act_location(loc, self.robot.type.action_radius_squared)
             if self.robot.paint < self.robot.type.attack_cost:
                 raise RobotError("Insufficient paint to perform attack.")
+            if self.game.has_wall(loc) and self.robot.type != UnitType.SPLASHER:
+                raise RobotError("Cannot attack a wall.")
+            if self.game.has_ruin(loc) and self.robot.type == UnitType.MOPPER:
+                raise RobotError("Moppers cannot mop towers or ruins.")
         else:
             if loc is not None:
                 self.assert_can_act_location(loc, self.robot.type.action_radius_squared)
@@ -283,9 +290,9 @@ def can_attack(self, loc: MapLocation) -> bool:
 
     def attack(self, loc: MapLocation, use_secondary_color: bool=False) -> None:
         self.assert_can_attack(loc)
-        self.robot.add_action_cooldown()
 
         if self.robot.type == UnitType.SOLDIER:
+            self.robot.add_action_cooldown()
             paint_type = (
                 self.game.get_secondary_paint(self.robot.team) 
                 if use_secondary_color 
@@ -302,6 +309,7 @@ def attack(self, loc: MapLocation, use_secondary_color: bool=False) -> None:
                 self.game.set_paint(loc, paint_type)
 
         elif self.robot.type == UnitType.SPLASHER:
+            self.robot.add_action_cooldown()
             paint_type = (
                 self.game.get_secondary_paint(self.robot.team) 
                 if use_secondary_color 
@@ -324,6 +332,7 @@ def attack(self, loc: MapLocation, use_secondary_color: bool=False) -> None:
             self.game.game_fb.add_splash_action(loc)
 
         elif self.robot.type == UnitType.MOPPER:
+            self.robot.add_action_cooldown()
             if loc is None:
                 self.mop_swing() 
             else:
@@ -504,6 +513,8 @@ def assert_can_complete_tower_pattern(self, tower_type: UnitType, loc: MapLocati
             raise RobotError(f"Cannot complete tower pattern at ({loc.x}, {loc.y}) because there is a robot at the center of the ruin")
         if not self.game.simple_check_pattern(loc, self.game.shape_from_tower_type(tower_type), self.robot.team):
             raise RobotError(f"Cannot complete tower pattern at ({loc.x}, {loc.y}) because the paint pattern is wrong")
+        if self.game.get_num_towers(self.robot.team) >= GameConstants.MAX_NUMBER_OF_TOWERS:
+            raise RobotError(f"Cannot complete tower pattern at ({loc.x}, {loc.y}) because the maximum number of towers was reached.")
 
     def can_complete_tower_pattern(self, tower_type: UnitType, loc: MapLocation) -> bool:
         try:
@@ -700,11 +711,15 @@ def set_indicator_string(self, string: str) -> None:
 
     def set_indicator_dot(self, loc: MapLocation, red: int, green: int, blue: int) -> None:
         self.assert_not_none(loc)
+        if not self.game.on_the_map(loc):
+            raise RobotError("Cannot place an indicator dot outside the map.")
         self.game.game_fb.add_indicator_dot(loc, red, green, blue)
 
     def set_indicator_line(self, start_loc: MapLocation, end_loc: MapLocation, red: int, green: int, blue: int) -> None:
         self.assert_not_none(start_loc)
         self.assert_not_none(end_loc)
+        if not self.game.on_the_map(start_loc) or not self.game.on_the_map(end_loc):
+            raise RobotError("Cannot place indicator line outside the map.")
         self.game.game_fb.add_indicator_line(start_loc, end_loc, red, green, blue)
 
     def set_timeline_marker(self, label: str, red: int, green: int, blue: int) -> None:
@@ -714,7 +729,10 @@ def set_timeline_marker(self, label: str, red: int, green: int, blue: int) -> No
 
     def resign(self) -> None:
         self.game.set_winner(self.robot.team.opponent(), DominationFactor.RESIGNATION)
-    
+
+    def disintegrate(self) -> None:
+        self.game.destroy_robot(self.robot.id)
+     
 class RobotError(Exception):
     """Raised for illegal robot inputs"""
     pass

battlecode25/maps/DefaultLarge.map25

@@ -49,6 +49,12 @@ def get_tower_pattern(tower_type: UnitType) -> List[List[bool]]:
     """
     pass
 
+def get_num_towers(self) -> int:
+    """
+    Returns the current number of allied towers on the map.
+    """
+    pass
+
 # ROBOT QUERY FUNCTIONS
 
 def get_id() -> int:
@@ -232,8 +238,8 @@ def move(direction: Direction) -> None:
 
 def can_attack(loc: MapLocation) -> bool:
     """
-    Tests whether this robot can attack the given location. Types of attacks for specific units determine whether
-    or not towers, other robots, or empty tiles can be attacked. 
+    Tests whether this robot can attack the given location. In most cases, if you are close enough, you can attack a location.
+    Units excluding splashers are not allowed to attack walls, and moppers are not allowed to mop towers or ruins.
     """
     pass
 
@@ -378,8 +384,8 @@ def read_messages(round=-1) -> List[Message]:
 def can_transfer_paint(target_location: MapLocation, amount: int) -> bool:
     """
     Tests whether you can transfer paint to a given robot/tower. You can give paint to an allied robot if you are a mopper
-    and can act at the given location. You can give/take paint from allied towers regardless of type, if you can act at the 
-    location.
+    and can act at the given location. You can take paint from allied towers regardless of type if you can act at the 
+    location. Pass a positive amount to give paint to another robot, and pass a negative amount to take paint.
     """
     pass
 
@@ -436,3 +442,9 @@ def resign() -> None:
     Causes your team to lose the game. It's like typing "gg."
     """
     pass
+
+def disintegrate() -> None:
+    """
+    Destroys this robot.
+    """
+    pass

battlecode25/maps/DefaultMedium.map25

@@ -25,7 +25,7 @@
         out_dir="matches",
         out_name=None,
         show_indicators=True,
-        debug=False,
+        debug=True,
         instrument=True
     )