Real mapping

demo_dribbler_test.py

@@ -0,0 +1,39 @@
+"""demo_dribbler_test.py — Test the dribbler with one robot on the Exhibition Road field.
+
+Run:
+    pixi run python demo_dribbler_test.py
+
+What this does
+--------------
+- 1 yellow robot, 0 opponents, Exhibition Road field (3 m × 2.25 m)
+- DribblerTestStrategy: robot fetches the ball, carries it forward with the
+  dribbler on, then stops
+- Blue target point drawn in RSim during carry
+"""
+
+from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS
+from utama_core.run import StrategyRunner
+from utama_core.strategy.examples.dribbler_test_strategy import DribblerTestStrategy
+
+N_FRIENDLY = 1
+MY_TEAM_IS_YELLOW = True
+MY_TEAM_IS_RIGHT = True
+
+
+def main() -> None:
+    runner = StrategyRunner(
+        strategy=DribblerTestStrategy(robot_id=0),
+        my_team_is_yellow=MY_TEAM_IS_YELLOW,
+        my_team_is_right=MY_TEAM_IS_RIGHT,
+        mode="rsim",
+        exp_friendly=N_FRIENDLY,
+        exp_enemy=0,
+        full_field_dims=GREAT_EXHIBITION_FIELD_DIMS,
+        show_live_status=True,
+    )
+
+    runner.run()
+
+
+if __name__ == "__main__":
+    main()

demo_dribbler_test2.py

@@ -0,0 +1,34 @@
+"""demo_dribbler_test2.py — Dribbler sequence test: forward → left → right → back → stop.
+
+Run:
+    pixi run python demo_dribbler_test2.py
+"""
+
+from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS
+from utama_core.run import StrategyRunner
+from utama_core.strategy.examples.dribbler_test_strategy2 import (
+    DribblerSequenceStrategy,
+)
+
+N_FRIENDLY = 1
+MY_TEAM_IS_YELLOW = True
+MY_TEAM_IS_RIGHT = True
+
+
+def main() -> None:
+    runner = StrategyRunner(
+        strategy=DribblerSequenceStrategy(robot_id=0),
+        my_team_is_yellow=MY_TEAM_IS_YELLOW,
+        my_team_is_right=MY_TEAM_IS_RIGHT,
+        mode="rsim",
+        exp_friendly=N_FRIENDLY,
+        exp_enemy=0,
+        full_field_dims=GREAT_EXHIBITION_FIELD_DIMS,
+        show_live_status=True,
+    )
+
+    runner.run()
+
+
+if __name__ == "__main__":
+    main()

demo_kicker_test.py

@@ -0,0 +1,48 @@
+"""demo_kicker_test.py — Test the kicker with one robot on the Exhibition Road field.
+
+Run:
+    pixi run python demo_kicker_test.py
+
+What this does
+--------------
+- 1 yellow robot, 0 opponents, Exhibition Road field (3 m × 2.25 m)
+- KickerTestStrategy: robot fetches ball, aligns to face enemy goal, kicks,
+  waits, then repeats
+- Red goal center drawn in RSim
+"""
+
+from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS
+from utama_core.run import StrategyRunner
+from utama_core.strategy.examples.kicker_test_strategy import KickerTestStrategy
+
+N_FRIENDLY = 1
+MY_TEAM_IS_YELLOW = True
+MY_TEAM_IS_RIGHT = True
+
+
+# Vision ID → firmware command ID mapping.
+# Update before running on real hardware: vision ID is the sticker on the robot,
+# command ID is baked into the robot's firmware.
+YELLOW_VISION_TO_CMD = {
+    0: 0,  # vision ID 0 → cmd ID 0  ← update with actual firmware ID
+}
+
+
+def main() -> None:
+    runner = StrategyRunner(
+        strategy=KickerTestStrategy(robot_id=0),
+        my_team_is_yellow=MY_TEAM_IS_YELLOW,
+        my_team_is_right=MY_TEAM_IS_RIGHT,
+        mode="real",
+        exp_friendly=N_FRIENDLY,
+        exp_enemy=0,
+        full_field_dims=GREAT_EXHIBITION_FIELD_DIMS,
+        show_live_status=True,
+        yellow_vision_to_cmd_mapping=YELLOW_VISION_TO_CMD,
+    )
+
+    runner.run()
+
+
+if __name__ == "__main__":
+    main()

demo_one_robot_placement.py

@@ -0,0 +1,47 @@
+"""demo_one_robot_placement.py — Entry point for testing RobotPlacementStrategy with one robot.
+
+Run:
+    pixi run python demo_one_robot_placement.py
+
+What this sets up
+-----------------
+- Exhibition Road field (3 m × 2.25 m, ``GREAT_EXHIBITION_FIELD_DIMS``)
+- 1 yellow robot, 0 opponents
+- RobotPlacementStrategy: robot oscillates vertically around the field center
+  while facing the ball
+"""
+
+from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS
+from utama_core.run import StrategyRunner
+from utama_core.strategy.examples import RobotPlacementStrategy
+
+N_FRIENDLY = 1
+MY_TEAM_IS_YELLOW = True
+MY_TEAM_IS_RIGHT = True
+
+# Vision ID → firmware command ID mapping.
+# Update before running on real hardware: vision ID is the sticker on the robot,
+# command ID is baked into the robot's firmware.
+YELLOW_VISION_TO_CMD = {
+    0: 0,  # vision ID 0 → cmd ID 0  ← update with actual firmware ID
+}
+
+
+def main() -> None:
+    runner = StrategyRunner(
+        strategy=RobotPlacementStrategy(robot_id=0),
+        my_team_is_yellow=MY_TEAM_IS_YELLOW,
+        my_team_is_right=MY_TEAM_IS_RIGHT,
+        mode="real",
+        exp_friendly=N_FRIENDLY,
+        exp_enemy=0,
+        full_field_dims=GREAT_EXHIBITION_FIELD_DIMS,
+        show_live_status=True,
+        yellow_vision_to_cmd_mapping=YELLOW_VISION_TO_CMD,
+    )
+
+    runner.run()
+
+
+if __name__ == "__main__":
+    main()

utama_core/config/field_params.py

@@ -149,10 +149,10 @@ def __post_init__(self):
 )
 
 GREAT_EXHIBITION_FIELD_DIMS = FieldDimensions(
-    full_field_half_length=2.0,
-    full_field_half_width=1.5,
-    half_defense_area_depth=0.4,
-    half_defense_area_width=0.8,
-    half_goal_width=0.5,
+    full_field_half_length=1.5,
+    full_field_half_width=1.125,
+    half_defense_area_depth=0.25,
+    half_defense_area_width=0.5,
+    half_goal_width=0.4,
     center_circle_radius=0.3,
 )

utama_core/config/physical_constants.py

@@ -1,3 +1,4 @@
 ROBOT_RADIUS = 0.09
 MAX_ROBOTS = 6
+MAX_ROBOT_ID = 15  # valid IDs from ssl small ruleset
 BALL_RADIUS = 0.0215

utama_core/config/settings.py

@@ -29,7 +29,7 @@
 
 ### REAL CONTROLLER SETTINGS ###
 BAUD_RATE = 115200
-PORT = "/dev/ttyUSB0"
+PORT = "/dev/ttyACM0"
 TIMEOUT = 0.1
 KICKER_COOLDOWN_TIME = 10  # in seconds to prevent kicker from being actuated too frequently
 KICKER_COOLDOWN_TIMESTEPS = int(KICKER_COOLDOWN_TIME * CONTROL_FREQUENCY)  # in timesteps

utama_core/data_processing/refiners/robot_info.py

@@ -1,26 +1,67 @@
 import warnings
 from dataclasses import replace
-from typing import List
+from typing import FrozenSet, List, Optional
 
+from utama_core.config.physical_constants import ROBOT_RADIUS
 from utama_core.data_processing.refiners.base_refiner import BaseRefiner
 from utama_core.entities.data.command import RobotResponse
 from utama_core.entities.game.game_frame import GameFrame
 
 # TODO: current doesn't handle has_ball for enemy robots. In future, implement using vision data
 
+# Distance threshold for vision-based has_ball inference: robot centre + small buffer.
+_BALL_CAPTURE_DIST = ROBOT_RADIUS + 0.04  # ~0.13 m
+
 
 class RobotInfoRefiner(BaseRefiner):
+    """Merges IR-sensor robot responses into the game frame.
+
+    Args:
+        trusted_ir_robots: Set of robot IDs (vision IDs) whose IR sensor is known to be
+            working.  Robots in this set use the raw sensor reading directly.  Any robot
+            ID **not** in this set has its has_ball inferred from vision proximity
+            (~0.13 m threshold) instead.  Pass ``None`` (default) to trust every
+            robot's IR sensor — this is the normal stable-hardware behaviour and can
+            be restored by simply removing the argument.
+    """
+
+    def __init__(self, trusted_ir_robots: Optional[FrozenSet[int]] = None):
+        self._trusted_ir_robots = trusted_ir_robots
+
     def refine(self, game_frame: GameFrame, robot_responses: List[RobotResponse]):
-        if robot_responses is None or len(robot_responses) == 0:
+        friendly_robots = game_frame.friendly_robots.copy()
+
+        # When an allowlist is active, first infer has_ball for every untrusted
+        # robot from vision proximity.  This covers frames where the robot drops
+        # its serial response entirely — without this pass, has_ball would stay
+        # frozen at the previous frame's value instead of being inferred.
+        if self._trusted_ir_robots is not None:
+            for robot_id, robot in friendly_robots.items():
+                if robot_id not in self._trusted_ir_robots:
+                    friendly_robots[robot_id] = replace(robot, has_ball=self._infer_has_ball(game_frame, robot))
+
+        # Then overlay IR sensor readings for robots that sent a response.
+        if robot_responses:
+            for robot_response in robot_responses:
+                rid = robot_response.id
+                if rid not in friendly_robots:
+                    warnings.warn(f"Robot ID {rid} in robot responses not found in friendly robots. ")
+                    continue
+
+                robot = friendly_robots[rid]
+                if self._trusted_ir_robots is None or rid in self._trusted_ir_robots:
+                    # Trusted (or trust-all mode): use raw IR reading
+                    friendly_robots[rid] = replace(robot, has_ball=robot_response.has_ball)
+                # Untrusted robots were already handled by the vision-proximity pass above
+
+        if friendly_robots == game_frame.friendly_robots:
             return game_frame
+        return replace(game_frame, friendly_robots=friendly_robots)
 
-        friendly_robots = game_frame.friendly_robots.copy()
-        for robot_response in robot_responses:
-            id = robot_response.id
-            if id in friendly_robots:
-                robot = friendly_robots[id]
-                friendly_robots[id] = replace(robot, has_ball=robot_response.has_ball)
-            else:
-                warnings.warn(f"Robot ID {id} in robot responses not found in friendly robots. ")
-        new_game_frame = replace(game_frame, friendly_robots=friendly_robots)
-        return new_game_frame
+    @staticmethod
+    def _infer_has_ball(game_frame: GameFrame, robot) -> bool:
+        """Proximity-based has_ball: True when robot is within capture distance of ball."""
+        if game_frame.ball is None:
+            return False
+        ball_2d = game_frame.ball.p.to_2d()
+        return robot.p.distance_to(ball_2d) < _BALL_CAPTURE_DIST

utama_core/global_utils/mapping_utils.py

@@ -23,6 +23,23 @@ def map_friendly_enemy_to_colors(my_team_is_yellow: bool, friendly_item: T, enem
     return yellow_item, blue_item
 
 
+# NB: actually map_friendly_enemy_to_colors and map_colors_to_friendly_enemy have the same logic
+
+
+def map_colors_to_friendly_enemy(my_team_is_yellow: bool, yellow_item: T, blue_item: T) -> Tuple[T, T]:
+    """Map yellow and blue items to their respective friendly and enemy items based on my team color.
+
+    Args:
+        my_team_is_yellow (bool): True if the team is yellow, False if blue.
+        yellow_item (T): Any item from the yellow team (int, list, etc.)
+        blue_item (T): Any item from the blue team (int, list, etc.)
+
+    Returns:
+        Tuple[T, T]: A tuple of (friendly_item, enemy_item).
+    """
+    return map_friendly_enemy_to_colors(my_team_is_yellow, yellow_item, blue_item)
+
+
 def map_left_right_to_colors(my_team_is_yellow: bool, my_team_is_right: bool, right_item: T, left_item: T):
     """Map left and right items to their respective colors based on my team color and position.