Files
tidewall/src/bots/nav_bot.gd
T
claudeandClaude Opus 5.5 1d6a24ab64 M8: Complete offline match
`make match` plays one whole match from the lobby to the results and back to the
lobby: one scripted player and 23 bots on a local server, with no script errors.

- CommandLog records the seed, the rules and every command the server is given.
  MatchReplay plays a log again with nobody thinking and ends on the same state
  hash; `make match` saves the log, reads it back and checks that.
- ServerLoop.submit() is now the one way commands reach the simulation, so a
  recording server sees them all.
- ScriptedPlayer plays a human seat: it drops, loots, fights and flees as a bot
  does, and also cuts driftwood and builds a breakwater and a wall.
- Bots draw randomness from their own per-bot generators, not the simulation's
  streams. A bot thinking no longer changes the simulation's state, which a
  replay without bots needs.
- MatchView and EntityView draw a match from one Simulation: terrain, sea,
  points of interest, props, pieces, players, the barge, items and chests, with
  stand-in shapes for the art pass to replace.
- `make match-captures` renders eight stages of the recorded match.

Closes #31

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 05:35:32 -05:00

207 lines
7.7 KiB
GDScript

## A bot body that walks to a goal: it plans a path on the shared NavGrid and steers
## along it with the same PlayerCommands a human sends. It plans again when its path
## floods or a wall goes up across it, jumps when it's stuck, and gives up on a point it
## can't get through after a few tries. M5's brains choose the goals; on its own, with
## `roam` set, it wanders between random reachable places.
class_name NavBot
extends RefCounted
const IDLE: int = 0
const MOVING: int = 1
const ARRIVED: int = 2
const UNREACHABLE: int = 3
const STATUS_NAMES: Array[String] = ["idle", "moving", "arrived", "unreachable"]
## Roaming goals are this far away at most, in metres.
const ROAM_RANGE: float = 150.0
## Tries at a random roaming goal before waiting for the next tick.
const ROAM_TRIES: int = 8
var player_id: int = 0
var status: int = IDLE
var goal: Vector3 = Vector3.ZERO
## Within this horizontal distance of the goal counts as there.
var arrive_radius: float = 1.5
## Pick a new random goal whenever idle, arrived or stuck for good.
var roam: bool = false
## The planned grid points, and the one being walked to.
var path: Array[Vector2i] = []
var path_index: int = 0
## How many times a path has been planned, for tests and logs.
var plans: int = 0
var _needs_plan: bool = false
var _planned_tick: int = -1
var _best_distance: float = INF
var _stuck_ticks: int = 0
var _stuck_tries: int = 0
var _jump_next: bool = false
var _leap_tick: int = -1
var _rng: RandomNumberGenerator = null
var _rng_seed: int = 0
## This bot's own random stream, seeded from the match seed and its player ID. Bots
## never draw from the simulation's streams: a bot is a player, and nothing a player
## thinks may change the simulation's state, or a replay of the same commands with no
## bots thinking would end up with a different state hash.
func stream(sim: Simulation) -> RandomNumberGenerator:
if _rng == null or _rng_seed != sim.rng.match_seed:
_rng = RandomNumberGenerator.new()
_rng_seed = sim.rng.match_seed
_rng.seed = _rng_seed ^ SimRng._hash_name("bot:%d" % player_id)
return _rng
func _init(id: int) -> void:
player_id = id
func set_goal(target: Vector3) -> void:
goal = target
status = MOVING
path.clear()
path_index = 0
_needs_plan = true
_reset_stuck()
func clear_goal() -> void:
status = IDLE
path.clear()
_needs_plan = false
func status_name() -> String:
return STATUS_NAMES[status]
## Returns this bot's command for `sim.tick`. The grid must be synced for this tick.
func think(sim: Simulation, grid: NavGrid) -> PlayerCommand:
var player: SimEntity = sim.entities.find(player_id)
if player == null or player.eliminated:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0)
if roam and status != MOVING:
_pick_roam_goal(sim, grid, player)
if player.drop_state == Drop.ABOARD:
return _ride(sim, player)
if player.drop_state != Drop.NONE:
# Gliding down: head for the goal.
return _steer(sim, player, goal, 0)
if status != MOVING:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, deg_to_rad(player.yaw * 360.0 / PlayerCommand.YAW_STEPS), 0.0)
if not _needs_plan and (sim.tick + player_id) % Tuning.BOT_PATH_CHECK_TICKS == 0:
if not grid.path_still_valid(path, path_index, _planned_tick):
_needs_plan = true
if _needs_plan and grid.can_plan():
_plan(sim, grid, player)
if status != MOVING:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0)
var horizontal: Vector2 = Vector2(goal.x - player.position.x, goal.z - player.position.z)
if horizontal.length() <= arrive_radius:
status = ARRIVED
path.clear()
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, atan2(horizontal.x, horizontal.y), 0.0)
var target: Vector3 = goal
if not path.is_empty():
_advance_waypoints(grid, player)
target = goal if path_index >= path.size() - 1 else grid.position_of(path[path_index])
_check_stuck(sim, grid, player, target)
var buttons: int = 0
if _jump_next:
buttons |= PlayerCommand.BUTTON_JUMP
_jump_next = false
if not player.swimming and horizontal.length() > 8.0:
buttons |= PlayerCommand.BUTTON_SPRINT
return _steer(sim, player, target, buttons)
func _plan(sim: Simulation, grid: NavGrid, player: SimEntity) -> void:
_needs_plan = false
_planned_tick = sim.tick
plans += 1
path = grid.find_path(player.position, goal)
path_index = 0
_reset_stuck()
if path.is_empty():
status = UNREACHABLE
## Skips waypoints already reached, or that the bot is already nearer the next one than.
func _advance_waypoints(grid: NavGrid, player: SimEntity) -> void:
var feet: Vector2 = Vector2(player.position.x, player.position.z)
while path_index < path.size() - 1:
var here: Vector3 = grid.position_of(path[path_index])
var reached: bool = feet.distance_to(Vector2(here.x, here.z)) <= Tuning.BOT_WAYPOINT_RADIUS
if not reached:
break
path_index += 1
_reset_stuck()
## Watches progress toward the current waypoint: jump when stalled, and after a few
## stalled jumps mark the waypoint blocked and plan around it.
func _check_stuck(sim: Simulation, grid: NavGrid, player: SimEntity, target: Vector3) -> void:
var distance: float = Vector2(target.x - player.position.x, target.z - player.position.z).length()
if distance < _best_distance - Tuning.BOT_STUCK_PROGRESS:
_best_distance = distance
_stuck_ticks = 0
return
_stuck_ticks += 1
if _stuck_ticks < Tuning.BOT_STUCK_TICKS:
return
_stuck_ticks = 0
_stuck_tries += 1
_jump_next = true
if _stuck_tries >= Tuning.BOT_STUCK_REPATHS and not path.is_empty():
var point: Vector2i = path[mini(path_index, path.size() - 1)]
if grid.point_of(player.position) != point:
grid.mark_blocked(point, sim.tick)
_needs_plan = true
_stuck_tries = 0
func _reset_stuck() -> void:
_best_distance = INF
_stuck_ticks = 0
_stuck_tries = 0
func _steer(sim: Simulation, player: SimEntity, target: Vector3, buttons: int) -> PlayerCommand:
var to: Vector2 = Vector2(target.x - player.position.x, target.z - player.position.z)
if to.length_squared() < 0.0001:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0, buttons)
return PlayerCommand.from_input(sim.tick, Vector2(0.0, 1.0), atan2(to.x, to.y), 0.0, buttons)
## Aboard the barge: leap once the goal is within gliding reach, or at a time set by
## the player ID, whichever comes first. The end of the route puts everyone off anyway.
func _ride(sim: Simulation, player: SimEntity) -> PlayerCommand:
if _leap_tick < 0 and sim.drop != null:
_leap_tick = sim.drop.began_tick + Tuning.TICK_RATE_HZ * 2 + (player_id * 53) % (Tuning.TICK_RATE_HZ * 20)
var leap: bool = sim.tick >= _leap_tick
if status == MOVING:
var gap: float = Vector2(goal.x - player.position.x, goal.z - player.position.z).length()
leap = leap or gap < 0.6 * (player.position.y - goal.y)
var buttons: int = PlayerCommand.BUTTON_JUMP if leap else 0
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0, buttons)
## A random open dry point within ROAM_RANGE that a path reaches, from the bot's own
## stream. Plans the path at once, so it uses the tick's planning budget.
func _pick_roam_goal(sim: Simulation, grid: NavGrid, player: SimEntity) -> void:
if not grid.can_plan():
return
var rng: RandomNumberGenerator = stream(sim)
var centre: Vector3 = player.position
if player.drop_state == Drop.ABOARD:
centre = Vector3(Tuning.WORLD_SIZE_METRES * 0.5, 0.0, Tuning.WORLD_SIZE_METRES * 0.5)
for _try: int in ROAM_TRIES:
var angle: float = rng.randf() * TAU
var reach: float = rng.randf_range(20.0, ROAM_RANGE)
var point: Vector2i = grid.point_of(centre + Vector3(cos(angle), 0.0, sin(angle)) * reach)
if grid.is_open(point) and grid.wet[grid.index_of(point)] == 0:
set_goal(grid.position_of(point))
if player.drop_state == Drop.NONE:
_plan(sim, grid, player)
return