add FieldBounds overlay and rendered rsim field based on FieldDimensions

Author: energy-in-joles

main.py

@@ -1,3 +1,4 @@
+from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS
 from utama_core.entities.game.field import FieldBounds
 from utama_core.replay import ReplayWriterConfig
 from utama_core.rsoccer_simulator.src.Utils.gaussian_noise import RsimGaussianNoise
@@ -15,17 +16,18 @@
 def main():
     # Setup for real testing
     # Custom field size based setup in real
-    custom_bounds = FieldBounds(top_left=(-4.5, 1.5), bottom_right=(-2.25, -1.5))
+    custom_bounds = FieldBounds(top_left=(-2, 1.5), bottom_right=(1, -1.5))
 
     runner = StrategyRunner(
         strategy=RandomMovementStrategy(n_robots=2, field_bounds=custom_bounds, endpoint_tolerance=0.1, seed=42),
         my_team_is_yellow=True,
         my_team_is_right=True,
-        mode="grsim",
+        mode="rsim",
         exp_friendly=2,
         exp_enemy=0,
         replay_writer_config=ReplayWriterConfig(replay_name="test_replay", overwrite_existing=True),
         field_bounds=custom_bounds,
+        full_field_dims=GREAT_EXHIBITION_FIELD_DIMS,
         print_real_fps=True,
         profiler_name=None,
     )

utama_core/rsoccer_simulator/src/Render/field.py

@@ -263,6 +263,38 @@ class SSLRenderField(VSSRenderField):
     corner_arc_r = 0.01
     _scale = 100
 
+    def __init__(
+        self,
+        length: float | None = None,
+        width: float | None = None,
+        penalty_length: float | None = None,
+        penalty_width: float | None = None,
+        goal_width: float | None = None,
+        goal_depth: float | None = None,
+        margin: float | None = None,
+        center_circle_r: float | None = None,
+        scale: float | None = None,
+    ):
+        if length is not None:
+            self.length = length
+        if width is not None:
+            self.width = width
+        if penalty_length is not None:
+            self.penalty_length = penalty_length
+        if penalty_width is not None:
+            self.penalty_width = penalty_width
+        if goal_width is not None:
+            self.goal_width = goal_width
+        if goal_depth is not None:
+            self.goal_depth = goal_depth
+        if margin is not None:
+            self.margin = margin
+        if center_circle_r is not None:
+            self.center_circle_r = center_circle_r
+        if scale is not None:
+            self._scale = scale
+        super().__init__()
+
 
 if __name__ == "__main__":
     field = Sim2DRenderField()

utama_core/rsoccer_simulator/src/ssl/envs/standard_ssl.py

@@ -4,7 +4,7 @@
 
 from numpy.random import normal
 
-from utama_core.config.field_params import STANDARD_FIELD_DIMS
+from utama_core.config.field_params import STANDARD_FIELD_DIMS, FieldDimensions
 from utama_core.config.formations import FormationEntry, FormationType, get_formations
 from utama_core.config.robot_params import RSIM_PARAMS
 from utama_core.config.settings import (
@@ -83,16 +83,28 @@ def __init__(
         time_step: float = TIMESTEP,
         blue_starting_formation: Optional[list[FormationEntry]] = None,
         yellow_starting_formation: Optional[list[FormationEntry]] = None,
+        full_field_dims: Optional[FieldDimensions] = None,
         ball_starting_position: Optional[Tuple[float, float]] = None,
         gaussian_noise: RsimGaussianNoise = RsimGaussianNoise(),
         vanishing: float = 0,
     ):
+        render_field_overrides = None
+        if full_field_dims is not None:
+            render_field_overrides = {
+                "length": 2 * full_field_dims.full_field_half_length,
+                "width": 2 * full_field_dims.full_field_half_width,
+                "penalty_length": 2 * full_field_dims.half_defense_area_depth,
+                "penalty_width": 2 * full_field_dims.half_defense_area_width,
+                "goal_width": 2 * full_field_dims.half_goal_width,
+            }
+
         super().__init__(
             field_type=field_type,
             n_robots_blue=n_robots_blue,
             n_robots_yellow=n_robots_yellow,
             time_step=time_step,
             render_mode=render_mode,
+            render_field_overrides=render_field_overrides,
         )
 
         # NOTE: observation_space and action_space removed - not needed for non-RL use

utama_core/rsoccer_simulator/src/ssl/ssl_gym_base.py

@@ -4,7 +4,7 @@
 #    - To create your wrapper from env to communcation, use inherit from this class!
 """
 
-from typing import List
+from typing import List, Optional
 
 import numpy as np
 import pygame
@@ -42,6 +42,7 @@ def __init__(
         n_robots_yellow: int,
         time_step: float,
         render_mode=None,
+        render_field_overrides: Optional[dict[str, float]] = None,
     ):
         # Initialize Simulator
         self.render_mode = render_mode
@@ -73,7 +74,7 @@ def __init__(
         self.overlay: list[OverlayObject] = []
 
         # Render
-        self.field_renderer = SSLRenderField()
+        self.field_renderer = SSLRenderField(**render_field_overrides) if render_field_overrides else SSLRenderField()
         self.window_surface = None
         self.window_size = self.field_renderer.window_size
         self.clock = None

utama_core/run/strategy_runner.py

@@ -376,6 +376,7 @@ def _load_sim(
                 render_mode=None,
                 blue_starting_formation=blue_start,
                 yellow_starting_formation=yellow_start,
+                full_field_dims=self.full_field_dims,
                 ball_starting_position=self.field_bounds.center,
                 gaussian_noise=rsim_noise,
                 vanishing=rsim_vanishing,
@@ -645,12 +646,13 @@ def _stop_robots(self, repeat: int = 1):
         def build_commands(team: SideRuntime) -> dict[int, RobotCommand]:
             return {robot_id: RobotCommand(0, 0, 0, 0, 0, 0) for robot_id in team.game.friendly_robots.keys()}
 
-        my_cmds = build_commands(self.my)
+        my_cmds = build_commands(self.my) if getattr(self.my, "_game", None) is not None else None
         opp_cmds = build_commands(self.opp) if self.opp and getattr(self.opp, "_game", None) is not None else None
 
         for _ in range(repeat):
-            self.my.strategy.robot_controller.add_robot_commands(my_cmds)
-            self.my.strategy.robot_controller.send_robot_commands()
+            if my_cmds:
+                self.my.strategy.robot_controller.add_robot_commands(my_cmds)
+                self.my.strategy.robot_controller.send_robot_commands()
 
             if opp_cmds:
                 self.opp.strategy.robot_controller.add_robot_commands(opp_cmds)
@@ -794,6 +796,8 @@ def _run_step(self):
         No return value; updates internal game state and controllers.
         """
         frame_start = time.perf_counter()
+        self._draw_rsim_field_bounds_overlay()
+
         if self.mode == Mode.RSIM:
             vision_frames = [self.rsim_env._frame_to_observations()[0]]
         else:
@@ -835,6 +839,26 @@ def _run_step(self):
                 self.elapsed_time = 0.0
                 self.num_frames_elapsed = 0
 
+    def _draw_rsim_field_bounds_overlay(self) -> None:
+        """Draw active field bounds overlay in RSIM human render mode."""
+        if self.mode != Mode.RSIM or not self.rsim_env:
+            return
+
+        # Overlays are cleared during render; only enqueue when the frame will be rendered.
+        if self.rsim_env.render_mode != "human":
+            return
+
+        top_left = self.field_bounds.top_left
+        bottom_right = self.field_bounds.bottom_right
+
+        bounds_polygon = [
+            (top_left[0], top_left[1]),
+            (bottom_right[0], top_left[1]),
+            (bottom_right[0], bottom_right[1]),
+            (top_left[0], bottom_right[1]),
+        ]
+        self.rsim_env.draw_polygon(bounds_polygon, color="PINK", width=2)
+
     def _step_game(
         self,
         vision_frames: List[RawVisionData],

utama_core/tests/strategy_runner/test_rsim_formations.py

@@ -3,6 +3,7 @@
 import py_trees
 import pytest
 
+from utama_core.config.field_params import GREAT_EXHIBITION_FIELD_DIMS
 from utama_core.config.formations import FormationType, get_formations
 from utama_core.entities.game.field import FieldBounds
 from utama_core.global_utils.mapping_utils import map_left_right_to_colors
@@ -139,3 +140,34 @@ def test_rsim_spawn_respects_shifted_bounds_and_ball_center():
     assert manager.ball_position is not None
     assert abs(manager.ball_position[0] - expected_x) <= POSITION_TOLERANCE
     assert abs(manager.ball_position[1] - expected_y) <= POSITION_TOLERANCE
+
+
+def test_rsim_renderer_resizes_with_non_standard_field_dimensions():
+    dims = GREAT_EXHIBITION_FIELD_DIMS
+    runner = StrategyRunner(
+        strategy=_IdleStrategy(),
+        my_team_is_yellow=True,
+        my_team_is_right=False,
+        mode="rsim",
+        exp_friendly=1,
+        exp_enemy=0,
+        full_field_dims=dims,
+    )
+
+    renderer = runner.rsim_env.field_renderer
+    scale = renderer.scale
+
+    assert renderer.length == pytest.approx(2 * dims.full_field_half_length * scale)
+    assert renderer.width == pytest.approx(2 * dims.full_field_half_width * scale)
+    assert renderer.penalty_length == pytest.approx(2 * dims.half_defense_area_depth * scale)
+    assert renderer.penalty_width == pytest.approx(2 * dims.half_defense_area_width * scale)
+    assert renderer.goal_width == pytest.approx(2 * dims.half_goal_width * scale)
+
+    # Goal line and boundary should be centered and align with resized geometry.
+    goal_top = (renderer.screen_height - renderer.goal_width) / 2
+    goal_bottom = goal_top + renderer.goal_width
+
+    assert renderer.margin == pytest.approx(renderer.center_x - renderer.length / 2)
+    assert renderer.margin == pytest.approx(renderer.center_y - renderer.width / 2)
+    assert goal_top == pytest.approx(renderer.center_y - dims.half_goal_width * scale)
+    assert goal_bottom == pytest.approx(renderer.center_y + dims.half_goal_width * scale)

utama_core/tests/strategy_runner/test_rsim_render_bounds.py

@@ -0,0 +1,35 @@
+from unittest.mock import MagicMock, patch
+
+from utama_core.config.enums import Mode
+from utama_core.entities.game.field import FieldBounds
+from utama_core.run.strategy_runner import StrategyRunner
+
+
+def _make_runner_for_overlay_tests(render_mode: str | None):
+    with patch.object(StrategyRunner, "__init__", lambda self: None):
+        runner = StrategyRunner()
+        runner.mode = Mode.RSIM
+        runner.field_bounds = FieldBounds(top_left=(-1.0, 2.0), bottom_right=(3.0, -4.0))
+        runner.rsim_env = MagicMock()
+        runner.rsim_env.render_mode = render_mode
+        return runner
+
+
+def test_draw_rsim_field_bounds_overlay_draws_expected_polygon():
+    runner = _make_runner_for_overlay_tests(render_mode="human")
+
+    runner._draw_rsim_field_bounds_overlay()
+
+    runner.rsim_env.draw_polygon.assert_called_once_with(
+        [(-1.0, 2.0), (3.0, 2.0), (3.0, -4.0), (-1.0, -4.0)],
+        color="PINK",
+        width=2,
+    )
+
+
+def test_draw_rsim_field_bounds_overlay_not_drawn_when_not_human():
+    runner = _make_runner_for_overlay_tests(render_mode=None)
+
+    runner._draw_rsim_field_bounds_overlay()
+
+    runner.rsim_env.draw_polygon.assert_not_called()