Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
54 commits
Select commit Hold shift + click to select a range
20f04e7
feat(examples): real_score_goal.py --calibrate measures one robot alone
isaac0804 Oct 27, 2026
1f3d972
feat: pixi run calibrate measures one real robot
isaac0804 Oct 27, 2026
6ce56ba
chore(examples): real_score_goal.py robot is yellow 0, radio 0
isaac0804 Oct 27, 2026
fc46879
chore(examples): real_score_goal.py robot is yellow 1 (its pattern), …
isaac0804 Oct 27, 2026
75674c6
fix(referee): restarts that work on real robots
isaac0804 Oct 28, 2026
78561bc
fix(skills): shot gate on the heading, keeper on the shot bisector, l…
isaac0804 Oct 28, 2026
eb706a4
fix(real): ball-sensor grace, feedback timeout, loop-stall tolerance,…
isaac0804 Oct 28, 2026
793ee9e
feat(examples): pixi run calibrate CLI, pass-receive and keeper-feed …
isaac0804 Oct 28, 2026
9232e3f
docs: field log replay design, calibration to-dos, field-day bug rows
isaac0804 Oct 28, 2026
af9f7a2
fix(tactics): move for a better shot when the gap is too narrow to ai…
isaac0804 Oct 28, 2026
e251fac
feat(dashboard): show who drives each robot and its step, live and in…
isaac0804 Oct 28, 2026
5ab80b4
chore(run): quieter start: no vision stream by default, one-line visi…
isaac0804 Oct 28, 2026
732c629
feat(examples): save_and_counter 1v1; drop the real_ prefix
isaac0804 Oct 28, 2026
c544af4
feat(examples): passing_rally: two robots pass up the field and shoot
isaac0804 Oct 28, 2026
bd23154
feat(motion): plan real robots from where they will be when the comma…
isaac0804 Oct 28, 2026
382e6ec
feat(motion): trajsample plans with the robot's weaker sideways accel…
isaac0804 Oct 28, 2026
645ce30
docs(motion): calibrated-robot planner results over every scenario, s…
isaac0804 Oct 28, 2026
4df81a1
fix(tactics): fetch the ball before moving for a shot, and carry it g…
isaac0804 Oct 28, 2026
0293441
fix(real): hold a robot with the ball to 0.3 m/s and 1 rad/s; pivot t…
isaac0804 Oct 28, 2026
f02af25
fix(real): accept 0.06 rad of aim error before passing (was 0.05)
isaac0804 Oct 28, 2026
603a1ff
fix(motion): drop a touchline the robot already stands within clearan…
isaac0804 Oct 28, 2026
3866d7d
fix(motion): ramp from the command move() sent, not the faster one it…
isaac0804 Oct 28, 2026
d9b0465
feat(real): aim passes and shots against each robot's kick bend
isaac0804 Oct 28, 2026
b4689a3
fix(real): accept 0.07 rad of aim error before passing (was 0.06)
isaac0804 Oct 28, 2026
891389a
fix(calibrate): fire the kicker once with no ball before the measured…
isaac0804 Oct 28, 2026
04bfc96
fix(examples): save_and_counter pivots to the goal before carrying th…
isaac0804 Oct 28, 2026
7efd175
fix(motion): never push a robot inside the ball keep-out off the field
isaac0804 Oct 28, 2026
d1437e5
fix(tactics): pivot to the goal only with the ball on the sensor
isaac0804 Oct 28, 2026
e866088
fix(vision): robot filter tracks its own velocity, not the one differ…
isaac0804 Oct 28, 2026
da85ca5
fix(real): turn at least 0.3 rad/s; aim tolerance back to 0.05; yello…
isaac0804 Oct 28, 2026
0c0af26
feat(calibrate): calibrate-tag finds where a robot's vision tag sits …
isaac0804 Oct 28, 2026
8788c98
chore(examples): test-day sides: the rally attacks the left goal, sco…
isaac0804 Oct 28, 2026
36bb4c3
fix(real): 1.5 m/s and 6 rad/s, stiffer turn PID, field check tolerat…
isaac0804 Oct 29, 2026
5fd56f1
feat(examples): passing_rally goes back and forth for ever; pass_rece…
isaac0804 Oct 29, 2026
82589a6
feat(vision): correct each real robot's vision by where its tag sits …
isaac0804 Oct 29, 2026
1f2ab91
feat(calibrate): the robot fetches the ball itself: carry ladder and …
isaac0804 Oct 29, 2026
b663488
feat(motion): planner A/B field drill and a close-call scan of field …
isaac0804 Oct 29, 2026
dc9452e
feat(calibrate): one command writes each robot's profile file; --chec…
isaac0804 Oct 29, 2026
7b440cb
feat(real): find-robots pairs each radio with the lid it wears; examp…
isaac0804 Oct 29, 2026
bdc86a8
feat(real): kickers kept charged, lids checked on start, field-check,…
isaac0804 Oct 29, 2026
e980654
feat(dashboard): pixi run demos switches demo from the Live tab
isaac0804 Oct 29, 2026
1c42053
feat(dashboard): field check, settings, teleop and radio reply rate i…
isaac0804 Oct 29, 2026
ed43f0b
chore(real): slower caps and 0.1 s vision-loss halt for today's testing
isaac0804 Oct 29, 2026
995636b
fix(real): field fence slows a robot from where it will be, keeps its…
isaac0804 Oct 29, 2026
0cd20d1
feat(real): keep-out zones robots may not enter; the examples keep ou…
isaac0804 Oct 29, 2026
bf042e0
fix(real): radio 1's ball sensor is stuck on; its profile judges has_…
isaac0804 Oct 29, 2026
5df5457
fix(real): vision-loss halt back to 0.5 s; at 0.1 s today's feed halt…
isaac0804 Oct 29, 2026
238bed2
fix(calibrate): resume a field-check HALT once the check passes; visi…
isaac0804 Oct 29, 2026
c26a1e5
fix(calibrate): a pause drives the robot back to where the pair began…
isaac0804 Oct 29, 2026
8e98f17
feat(drill): the shooting drill attacks the left goal on the full fie…
isaac0804 Oct 29, 2026
8b51dbb
fix(real): carry turn cap 1.0 -> 0.6 rad/s; drills lost the ball off …
isaac0804 Oct 29, 2026
ca2efa3
chore(real): no keep-out zone in the examples
isaac0804 Oct 29, 2026
1920695
chore(drill): the shooting drill attacks the left goal
isaac0804 Oct 29, 2026
e228cc4
feat(field,replay): add log packaging, dead-time trimming, and field …
isaac0804 Nov 2, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion AGENTS.md
Original file line number Diff line number Diff line change
Expand Up @@ -127,7 +127,7 @@ declarations) — check there before reintroducing one of them.
those parameters today, so both levels run the same tests. CI runs `--level quick` on
PRs, `--level full` on push to a branch, both with `--ignore-glob "**/*grsim*"` (grsim
tests need an external grsim process CI can't provide).
- The root `conftest.py` turns off `StrategyRunner`'s browser vision stream for every test.
- `StrategyRunner`'s browser vision stream is off unless `enable_vision_stream=True`.
In rsim, `run_test`'s `episode_timeout` is game time (rsim runs several times faster than
real time), so a test's budget doesn't depend on machine load.
- A known defect is a `strict=True` xfail on exactly the cases that hit it (see
Expand Down
13 changes: 2 additions & 11 deletions conftest.py
Original file line number Diff line number Diff line change
Expand Up @@ -86,17 +86,8 @@ def headless(pytestconfig):


@pytest.fixture(autouse=True)
def _no_vision_stream(monkeypatch):
"""Every StrategyRunner starts a browser vision stream by default: a frame rendered
each step and about 0.4 s to shut its HTTP server down. No test watches it, and it was
a third of the suite's time."""
from utama_core.run.strategy_runner import StrategyRunner
def _reset_picker_state():
"""Pickers keep module-level state between calls; each test starts without it."""
from utama_core.strategy.pickers import reset_closer_to_ball_state

reset_closer_to_ball_state()

def _skip(self, http_port): # noqa: ARG001
self.vision_stream = None
self._vision_stream_renderer = None

monkeypatch.setattr(StrategyRunner, "_start_vision_stream", _skip)
2 changes: 2 additions & 0 deletions docs/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f
- [visual_guide.md](visual_guide.md): the game drawn on the pitch from real replays (how each strategy plays, one match over time, a restart, the motion planner), what each picture has shown us, and how to draw it.
- [setup_external.md](setup_external.md): grSim, the official GameController and AutoReferee.
- [real_robot_setup.md](real_robot_setup.md): a test day with real robots: ssl-vision on its own laptop, WSL networking and USB, the radio, and the checks before a robot moves.
- [field_logs.md](field_logs.md): real robot game logs: format, record types, calibration analysis, dead-time trimming, and release packaging.
- [contributing.md](contributing.md): editor setup, commits, pull requests and releases.

## Design rationale
Expand All @@ -36,6 +37,7 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f
- [roadmap.md](roadmap.md): larger open workstreams, and one-line pointers to finished ones.
- [sim_realism.md](sim_realism.md): how far rsim is from real matches, the realism scorecard, and the plan to close the gap with measured, randomized physics.
- [in_house_vision.md](in_house_vision.md): our own vision stack for lab days (per-session tag calibration, tags on robots), the experiments that decide it, and the 2026-10-22 test day's vision findings.
- [field_log_replay.md](field_log_replay.md): design for finding a moment in a field log and rerunning the decision code on its recorded inputs, and the physical setup's own errors (tag yaw and offset, kicker offset, cameras) as per-robot profiles.
- [testing_gaps.md](testing_gaps.md): kinds of testing gap that let bugs through, numbered (code cites them by number).
- [investigation_default_vs_lowblock_stalemate.md](investigation_default_vs_lowblock_stalemate.md): why `default` vs `low_block` stays 0-0; partly fixed.
- [investigation_ball_contact_orientation_divergence.md](investigation_ball_contact_orientation_divergence.md): a robot pinned against the ball rotates away from contact; localized, not fixed.
8 changes: 7 additions & 1 deletion docs/STRATEGY_DEVELOPMENT.md
Original file line number Diff line number Diff line change
Expand Up @@ -367,7 +367,11 @@ whoever runs it.
value)` yourself from a `Tactic` or skill (guard with `if ctx.match_log is not None:`; it's
`None` on tournament/CI runs, so traces can stay in). Examples: `skills/src/go_to_ball.py`,
`tactics/give_and_go.py`. Enable with `match_log_path=` or `match.run_match(...,
run_dir=...)`; read back with `load_jsonl(path)`.
run_dir=...)`; read back with `load_jsonl(path)`. A run with a dashboard or a game log keeps one
in memory too: a plain value traced under a key naming a robot (`ctx.trace(game, f"shoot[{rid}]",
"turning to shoot")`) shows under that robot in the Live tab's Tactics panel and is noted in the
game log, so name the step a robot is on in words a tester reads (`AbstractStrategy.debug_status`).
While a restart or HALT drives a robot, the panel shows `referee · <its job>` instead of its tactic.
- **`render_window()` / `render_around_event()`** (`analysis/render_window.py`) — PNG of
robot/ball trails over a window, optionally anchored on a `MatchLog` event. **Default to this
over `load_frames_in_range()`**: a coordinate dump is expensive in context and easy to misread
Expand Down Expand Up @@ -513,6 +517,8 @@ state to edit. Moments are not a gate on strategies: they pin shared-code bugs.
| Same moment still failing after the fix | robot driving in | `keeps_clear` counted the ball placed onto a robot standing still | `20ca1974` | `test_moments.py` |
| keep_out foul on their free kick | robot driving in | referee: the kicker moved the ball 0.75 m in the preparation stage; it was in play | `12b46412` | `test_free_kick_taken.py` |
| Our placement times out (hand-made moment) | slow placer | placer drove through the ball toward a point behind it (planner ignores the ball in our placement) | `78685f79` (goes round it) | `test_referee_unit.py` (TestBallPlacementOursApproachAroundBall) |
| Real placer brushes the ball going round it; chases a ball rolling out with its back to it (field day 2026-10-27) | clumsy placer | detour kept only robot plus ball radius (~1 cm); faced the spot from the start; aimed behind a rolling ball | field-day-20261027 branch: 5 cm clearance (`_BALL_DETOUR_RADIUS_M`, also free kicks and penalties), faces the ball, meets a rolling ball on its path | `test_referee_unit.py` (TestBallPlacementOursApproachAroundBall) |
| STOP with the ball just out over the goal line: our robot drives into their keeper (field day 2026-10-27) | robot ignoring a robot | the clear-of-the-ball target, clamped back onto the pitch, was 0.23 m from the keeper standing on its line | field-day-20261027 branch: clearing targets keep `_ROBOT_SPACING_M` (2 robot radii + 10 cm) from every robot, moving on round the ball | `test_referee_unit.py` (TestClearingTargetsKeepOffRobots) |

The last row matters on real robots only: in sim matches `StrategyRunner` teleports a placed ball
to its target (`docs/custom_referee_design_decisions.md`, Ball placement), so our placer never
Expand Down
2 changes: 1 addition & 1 deletion docs/custom_referee.md
Original file line number Diff line number Diff line change
Expand Up @@ -45,7 +45,7 @@ Built in `_build_active_rules` (`custom_referee.py`), in this priority order; de
| `OutOfBoundsRule` | live play | Free kick to the team that didn't touch last, placed 0.25m infield; over a goal line, a corner or goal kick in the corner, or, for a ball last touched in the kicker's own half that crossed the opponent's goal line untouched, a free kick from where it was touched (aimless kick, §6.2.3, Division B; `out_of_bounds.aimless_kick`, on in both profiles). Last touch: `rules/last_touch.py`'s colour-blind `infer_last_touch_team` (both teams' contact data; closest robot only when there is no prior attribution; unresolved rather than a default colour). |
| `BallSpeedRule` | live play | Ground speed > 6.5 m/s, edge-detected; same last-touch attribution. Non-stopping (§8.4.2). |
| `DoubleTouchRule` | `NORMAL_START` after a restart | Only the restart kicker (first toucher after arming) is barred; disarms when any other robot touches. Open-play release-and-reacquire dribbling is legal. Keeps `_prev_command` across `reset()` because `reset()` runs on the very transition it must observe. |
| `DefenseAreaRule` | live play | An extra defender (> `max_defenders`) touching the ball in its own area: penalty. An attacker touching the ball while at least partly in ours: non-stopping, 2 s re-raise (§8.4.2). |
| `DefenseAreaRule` | live play | An extra defender (> `max_defenders`) touching the ball in its own area: penalty. An attacker touching the ball while at least partly in ours: non-stopping, 2 s re-raise (§8.4.2). With `defense_area.enabled: false` (`human`, and the real examples' profiles) our robots also stop keeping out of the boxes: `StrategyRunner` sets `Field.defense_area_rules` from it, for the planners, tactics and restart positioning; a ball resting in our own box stays the keeper's. |
| `KeepOutRule` | `DIRECT_FREE_*`, `PREPARE_KICKOFF_*` | Defending team within 0.5m for 30 consecutive frames: non-stopping, 2 s re-raise, restarts the free kick's 10 s clock (§8.4.3). Not during bare `STOP` or penalties, nor once a free kick is taken (stage 3 of the state machine: the ball moved 0.05m, so it is live). |
| `PenaltyTimeLimitRule` | `NORMAL_START`/`FORCE_START` after `PREPARE_PENALTY_*` | Penalty still in play 10 s after its normal start: goal kick for the defenders (§5.3.5). |
| `NoProgressRule` | live play | Ball hasn't moved 0.05 m in 10 s: `STOP` then `FORCE_START` where it lies, moved out of the opponent's defense area if it is inside it (`legal_restart_position`, §8.1). The clock waits for the ball to be in play (a `NORMAL_START` restart: 0.05 m of movement or the 10 s auto-in-play) and is held while the ball is inside either defense area. Last in the list, so a real foul on the same tick wins. |
Expand Down
2 changes: 1 addition & 1 deletion docs/custom_referee_gui.md
Original file line number Diff line number Diff line change
Expand Up @@ -60,7 +60,7 @@ strategy_view.attach(server, runner,

The Live tab then lists the choices per side with a Run button; Run on the one running restarts
it. `StrategyRunner.replace_strategy` takes the new strategy at the next tick and only while
halted, so the page refuses otherwise. `examples/real_attacker_defender.py` offers its attacker
halted, so the page refuses otherwise. `examples/shooting_drill.py` offers its attacker
and defender tactics this way.

## Commands and what robots do
Expand Down
144 changes: 144 additions & 0 deletions docs/field_log_replay.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,144 @@
# Field logs: finding a moment and replaying it offline (design)

Status: design, 2026-10-28. Nothing here is built yet except what "Today" lists.

## Why

On the 2026-10-27 field day every bug was found the same way: a symptom someone saw ("it drives
sideways and back", "blue misses passes", "placement throws the ball away"), then a throwaway
script to find the moment in the log, then another to rebuild what the robot saw and decided at
that moment. The second step found every cause. Running the recorded camera packets through the
same refiners and tactic offline showed blue's receive point clamped to x 0.43, and the
attacker's hold point at (0.43, +0.07) wherever the ball was. Each script took 10-30 minutes
to write, and all of them were lost when `/tmp` was cleared. This doc designs one tool for the
whole loop, so a field symptom becomes a cause, and then a regression test, in minutes.

## Today

- Every real run records `replays/field/<time>_<mode>_<name>.log`, an SSL game log
(`replay/game_log_writer.py`) with these records:
- every camera packet, raw and per camera;
- the radio both ways: commands (`RADIO_OUT`) and feedback, the ball sensor (`RADIO_IN`);
- referee messages;
- operator notes (`NOTE`, from the dashboard's Note box);
- the run info: code version, the vision-to-radio mapping, the field.
- Beside the log is a `.npz` replay of the world the strategy saw.
- `analysis/robot_calibration.py` reads the log for one robot's numbers. `tools/plan_snapshot.py`
draws one planner decision from an `.npz`, and `tools/moments.py` turns an `.npz` tick into a
regression moment.

Missing:
- a timeline of what happened, to find the moment;
- a per-tick view that sets the raw camera, the refined world and the command side by side;
- rerunning the decision code on the recorded inputs.

## The tool: `tools/field_replay.py`

Three subcommands, each one step of the loop.

### 1. `index LOG`: find the moment

A timeline of the run, one line per event:
- notes;
- referee commands;
- each kick sent, with the ball's speed and direction after it;
- ball-sensor on/off edges per robot, with dropouts shorter than 0.5 s marked as such;
- possession changes, and the ball leaving the field;
- robots or the ball lost by vision for more than 0.2 s, and per-camera frame gaps;
- control-loop stalls: gaps in `RADIO_OUT` longer than 50 ms.

`--around T` prints only ±5 s. This replaces `ir.py`, `tl.py`, `passes.py` and `kicks.py` from that
night.

### 2. `window LOG --from A --to B [--robot yellow:1]`: look at it

Per tick:
- each camera's raw detection of the robot and the ball;
- the refined position, velocity and heading;
- the command sent, turned back into the world frame;
- the ball sensor, and the ball in the robot's frame (forward and left of its centre, which shows
when the ball is on the dribbler);
- the referee command.

`--png` draws the window on the pitch: trails, command arrows, the ball, and each camera's
detections in its own colour, so a jump at the camera overlap is visible. These are pitch
pictures in the same style as `plan_snapshot`, not plots against time.

### 3. `rerun LOG --from A --to B --side yellow [--tactic module:Class]`: rerun the decision

1. Feed the window's recorded camera packets, at their recorded times, through a fresh refiner
pipeline: position (with the fusion and Kalman filter), velocity, and robot info with the
recorded ball-sensor feedback. Each refiner starts a few seconds before `A` to settle.
2. Tick the tactic, or the side's whole strategy from the run info, on each refined world, with
the same control scheme.
3. **Fidelity check.** Compare the rerun's commands with the logged `RADIO_OUT`, tick by tick.
They must agree, within float16 rounding, while the code is the version that ran (the log
records which). If they don't, something the decision depends on wasn't recorded, which is a
bug in the log or the tool, and the rerun says so before showing anything else.
4. **Counterfactual.** Run the same window with the working tree's code. It prints where its
commands first differ from the recorded ones, and by how much. This is open loop: the robots
still move as they really did. So it says what the fixed code would have decided at the
moment it went wrong, not what would have happened next. That is exactly the check a fix
needs, and why the result is a test and not a claim.
5. `--moment` writes the first diverging tick as a regression moment (`tools/moments.py`'s format)
or a unit-test fixture: robot, ball and referee state, and the command it should have given.
The fix's regression test then starts from the real field state.

What it needs from the code: every refiner and controller must read time from the frame, not the
wall clock. That holds for the refiners today. The real controller's dribbler bucket and the
kicker cooldown use their own timers, which the rerun replays from the log's timestamps. The
`sim_tac.py` / `bluew.py` prototypes from 2026-10-27 already do steps 1 and 2 for one tactic.

## The physical setup's own errors

A rerun reproduces what the robot believed, and that includes the setup's errors. Each error
below has one way to measure it. All of them become per-robot or per-camera numbers that the
live code and the rerun apply the same way.

| Error | What it does | How to measure it | Where the correction goes |
|---|---|---|---|
| Tag turned on the robot (yaw) | Vision's heading differs from the chassis's: the robot drives off its heading, and kicks go off by the same angle | A straight-forward command: the direction of travel against vision's heading. Calibration already drives forward and back, so this needs analysis only | Position refiner, per robot, before the Kalman filter |
| Tag off the robot's centre | The position is wrong by a fixed offset in the robot's frame. Turning on the spot looks like driving a small circle | The spin steps: fit a circle to the positions, whose radius and phase give the offset (already in the script) | Position refiner, per robot |
| Kicker turned on the robot | The ball leaves at an angle to the true heading. That night, yellow's kicks were about 7° off | Kick direction minus tag yaw (calibration's `direction_offset_deg`, new) | Kick aim: turn by the offset before kicking |
| Tag not flat, or the wrong height in ssl-vision | Position bias that grows away from the camera's centre, and differs between cameras | One robot at known marks (`vision_check --guided`); the two cameras' disagreement on the same robot in the overlap | The camera calibration first. What remains goes in a per-camera correction |
| Cameras disagree | A jump crossing the overlap; ball tracks that break | Disagreement map from every log with a robot in the overlap | Camera calibration; the fusion's weights |
| Latency per camera | Fused positions lag differently per camera | `t_capture` against receive time, per camera | Fusion |
| Robot dynamics | Overshoot sideways, turning 9% faster than commanded | Calibration (sideways about 1.8 m/s² against the 4 assumed; turn gain 1.09) | Controller limits and gains per robot; the sim |
| Ball sensor | Drops out with the ball still on | Calibration's dribble steps (`sensor_on`) | `RobotInfoRefiner`'s `contact_grace_s` (since 2026-10-28) |

These rows meet in one **robot profile**:
- one JSON per robot, written by `pixi run calibrate` and kept in the repo under
`config/robot_profiles/`;
- it holds tag yaw and centre offset, kicker offset, kick speed, dribbler hold point, sensor
reliability, turn gain and acceleration per axis;
- it is read by the position refiner, the controller, the kick aim, the sim (per-robot physics for
realistic evaluation) and the rerun;
- a robot without a profile runs as today.

The calibration to-do list that fills it (driving per axis and diagonally, kicking, dribbling,
receiving, all robots at once, and where each number is used) is `roadmap.md` item 10.

The profile is what makes two robots of the same design behave the same in the code. Tonight's
"only one robot misses" was partly geometry, but robot-to-robot differences such as yellow's kick
offset will keep showing up the same way.

## Focused logs

The tool is quicker when the logs are short and labelled.
- One run per test, named for it: `--name pass_receive`. Today that is per example.
- A note at each change of set-up. With no dashboard, the calibration CLI writes its step names as
notes itself: proposed, one line.
- Keep everything. A field log is small (2-3 MB a minute) and can't be re-recorded.

## Order of work

Each step is useful on its own and small enough for one session:

1. `index` and `window`, from the 2026-10-27 scripts. Gives back the speed of that night.
2. `rerun` with the fidelity check, for the examples' tactics, then for whole strategies.
3. Tag yaw and centre offset in `robot_calibration` (analysis only; the moves are already in
the script), and the per-robot profile, applied in the position refiner.
4. Kick aim from the profile's kicker offset.
5. Camera disagreement map from logs.
6. The sim reads robot profiles. That changes evaluation results, so ask first, and batch it with
the next forced rerun.
Loading
Loading