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>
This commit is contained in:
2026-11-12 05:35:32 -05:00
co-authored by Claude Opus 5.5
parent 8cf164d562
commit 1d6a24ab64
38 changed files with 1633 additions and 15 deletions
+2
View File
@@ -26,6 +26,8 @@ continuity.
| `tools/capture.sh <scene-or-scenario> <out.png>` | Renders the real client offscreen in a throwaway `tidewall-capture-*` Docker container (Xvfb, Mesa software rendering) and saves a PNG. Fails on a blank frame or a renderer fallback. | | `tools/capture.sh <scene-or-scenario> <out.png>` | Renders the real client offscreen in a throwaway `tidewall-capture-*` Docker container (Xvfb, Mesa software rendering) and saves a PNG. Fails on a blank frame or a renderer fallback. |
| `tools/godot.sh --script res://tools/island_map.gd -- --seed=N --out=res://captures/island.png` | Draws a top-down map of a seed's island, with a contour at each tide level. | | `tools/godot.sh --script res://tools/island_map.gd -- --seed=N --out=res://captures/island.png` | Draws a top-down map of a seed's island, with a contour at each tide level. |
| `make bot-matches` | Plays 20 bot-only matches (several minutes, under `nice`) and checks every one has a winner, under a tenth of deaths are drownings, easy bots place worst and hard bots take the most eliminations. `BOT_MATCH_SEEDS=5 BOT_MATCH_FIRST=40` changes the seeds. | | `make bot-matches` | Plays 20 bot-only matches (several minutes, under `nice`) and checks every one has a winner, under a tenth of deaths are drownings, easy bots place worst and hard bots take the most eliminations. `BOT_MATCH_SEEDS=5 BOT_MATCH_FIRST=40` changes the seeds. |
| `make match` | Plays one whole offline match, lobby to results: a scripted player and 23 bots on a local server (about 25 s). Saves the command log to `build/match/match.tclog`, replays it and checks the replay ends on the same state hash. `MATCH_SEED=N` changes the seed; the default, 2, is one where the scripted player also builds. |
| `make match-captures` | Renders eight stages of that match from its command log (`captures/match_<stage>.png`), about 3 minutes. Needs Docker. Look at them. |
| `make terrain-capture` | Renders the terrain crack check and a skirtless control in the capture container. The control must crack and the real terrain must not. Needs Docker. | | `make terrain-capture` | Renders the terrain crack check and a skirtless control in the capture container. The control must crack and the real terrain must not. Needs Docker. |
| `make capture-test` | Proves the capture harness works and rejects a blank frame. Needs Docker, so it isn't part of `make check`. | | `make capture-test` | Proves the capture harness works and rejects a blank frame. Needs Docker, so it isn't part of `make check`. |
+11 -1
View File
@@ -1,7 +1,7 @@
# Tidewall build entry points. Everything runs headless with the repo-local engine. # Tidewall build entry points. Everything runs headless with the repo-local engine.
GODOT := tools/godot.sh GODOT := tools/godot.sh
.PHONY: check import parse test test-selfcheck smoke capture-test terrain-capture binaries verify-engine bot-matches .PHONY: check import parse test test-selfcheck smoke capture-test terrain-capture binaries verify-engine bot-matches match match-captures
## Everything that must pass before a push. ## Everything that must pass before a push.
check: verify-engine binaries parse test test-selfcheck smoke check: verify-engine binaries parse test test-selfcheck smoke
@@ -36,6 +36,16 @@ smoke: import
bot-matches: import bot-matches: import
@tools/bot_matches.sh @tools/bot_matches.sh
## Plays one whole offline match, lobby to results, with a scripted player and 23 bots,
## then replays its command log and checks the replay ends in the same state.
## MATCH_SEED picks the seed.
match: import
@tools/match.sh
## Renders each stage of the match `make match` last played. Needs Docker.
match-captures: import
@tools/match_captures.sh
## Renders the capture test scenes in the offscreen container. Needs Docker. ## Renders the capture test scenes in the offscreen container. Needs Docker.
capture-test: import capture-test: import
@tools/capture_selfcheck.sh @tools/capture_selfcheck.sh
+33 -1
View File
@@ -77,8 +77,10 @@ deterministic.
- A match has one `u64` seed, always logged. - A match has one `u64` seed, always logged.
- Gameplay randomness comes only from named streams, created from the match seed and a - Gameplay randomness comes only from named streams, created from the match seed and a
stable name: `rng.stream("loot")`, `"weapons"`, `"bots"`, `"worldgen"`, and so on, on one `SimRng`. stable name: `rng.stream("loot")`, `"weapons"`, `"drop"`, `"worldgen"`, and so on, on one `SimRng`.
One system's extra rolls can't disturb another's. One system's extra rolls can't disturb another's.
- Bots don't draw from those streams. Each bot has its own generator, seeded from the
match seed and its player ID, so nothing a bot thinks changes the simulation's state.
- Simulation code **never** calls `randf`, `randi`, `Time`, or anything else that varies - Simulation code **never** calls `randf`, `randi`, `Time`, or anything else that varies
between runs. Presentation can use whatever randomness it likes, for effects. between runs. Presentation can use whatever randomness it likes, for effects.
- The same seed and the same command log produce the same state hash, on the same engine - The same seed and the same command log produce the same state hash, on the same engine
@@ -91,6 +93,27 @@ to millimetres.
Determinism is for tests, replays and worldgen. Clients don't rely on bit-exact matches Determinism is for tests, replays and worldgen. Clients don't rely on bit-exact matches
with the server. Reconciliation corrects any difference. with the server. Reconciliation corrects any difference.
## Command log and replay
`CommandLog` (`src/server/`) holds a match's seed, its rules and every command the
server was given: the simulation tick it arrived on, the handle it came from and the
command's 14 bytes. `ServerLoop.submit()` is the one way commands get in, for people,
scripts and bots alike, so a recording server logs them all, accepted or not. On disk
it is a JSON header and the records compressed with Zstandard, about 0.6 MB for a
24-player match.
`MatchReplay` plays a log again: the same seed and rules, the same commands on the same
ticks, and nobody thinking. It ends on the same state hash as the recording, which
`make match` checks after every run. A replay can stop at any tick, which is how the
match captures draw a moment of a real match. Replays are exact only on the same engine
build, like everything else that relies on determinism.
`ScriptedPlayer` (`src/bots/`) is a stand-in for a person at the controls. It plays a
human seat as a bot would, and also cuts driftwood and builds a breakwater and a wall,
so a scripted match covers the drop, loot, combat, harvesting, building and the tide
from a player's seat. `ServerLoop.play_humans_by_script()` turns it on; no shipped mode
uses it.
## Snapshot format ## Snapshot format
A snapshot is a binary, little-endian packet: A snapshot is a binary, little-endian packet:
@@ -178,6 +201,15 @@ full-resolution heightfield at every level, so lighting doesn't change across a
The terrain shader blends procedural sand, marsh, grass and rock layers using splat The terrain shader blends procedural sand, marsh, grass and rock layers using splat
weights from the island's elevation bands, with rock on steep ground. weights from the island's elevation bands, with rock on steep ground.
## The match view
`MatchView` (`src/client/`) is the client's picture of one match: sky, sun, terrain,
sea, points of interest, props, built pieces and `EntityView`, which draws players, the
barge, items and chests. All of it reads one `Simulation` and never writes to it, and a
new match gets a new view. The camera sits on a player's shoulder through `CameraRig`.
Until snapshots arrive, the simulation it reads is a local server's or a replay's; the
figures, barge and items are stand-in shapes for the art pass to replace.
## Performance budgets ## Performance budgets
| Budget | Target | | Budget | Target |
+4 -4
View File
@@ -229,7 +229,7 @@ func _stop() -> void:
func _drop(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand: func _drop(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
state = "drop" state = "drop"
if _landing < 0 and not world.markers.is_empty() and sim.drop != null: if _landing < 0 and not world.markers.is_empty() and sim.drop != null:
var rng: RandomNumberGenerator = sim.rng.stream("bots") var rng: RandomNumberGenerator = nav.stream(sim)
var a: Vector2 = Vector2(sim.drop.start.x, sim.drop.start.z) var a: Vector2 = Vector2(sim.drop.start.x, sim.drop.start.z)
var b: Vector2 = Vector2(sim.drop.finish.x, sim.drop.finish.z) var b: Vector2 = Vector2(sim.drop.finish.x, sim.drop.finish.z)
var near: Array[int] = [] var near: Array[int] = []
@@ -365,7 +365,7 @@ static func _weapon_score(me: SimEntity, slot: int, distance: float) -> float:
func _update_aim_error(sim: Simulation) -> void: func _update_aim_error(sim: Simulation) -> void:
if (sim.tick + player_id) % Tuning.BOT_AIM_WANDER_TICKS == 0: if (sim.tick + player_id) % Tuning.BOT_AIM_WANDER_TICKS == 0:
var rng: RandomNumberGenerator = sim.rng.stream("bots") var rng: RandomNumberGenerator = nav.stream(sim)
_aim_error_goal = Vector2(rng.randf_range(-1.0, 1.0), rng.randf_range(-0.5, 0.5)) * _aim_error_degrees _aim_error_goal = Vector2(rng.randf_range(-1.0, 1.0), rng.randf_range(-0.5, 0.5)) * _aim_error_degrees
_aim_error = _aim_error.lerp(_aim_error_goal, 0.25) _aim_error = _aim_error.lerp(_aim_error_goal, 0.25)
@@ -400,7 +400,7 @@ func _combat_move(sim: Simulation, grid: NavGrid, me: SimEntity, target: SimEnti
to /= gap to /= gap
var wanted: float = minf(clampf(def.range_full * 0.8, 5.0, 30.0), _fire_range(def) * 0.8) var wanted: float = minf(clampf(def.range_full * 0.8, 5.0, 30.0), _fire_range(def) * 0.8)
if sim.tick >= _strafe_until: if sim.tick >= _strafe_until:
var rng: RandomNumberGenerator = sim.rng.stream("bots") var rng: RandomNumberGenerator = nav.stream(sim)
_strafe = -_strafe _strafe = -_strafe
_strafe_until = sim.tick + rng.randi_range(TICKS / 2, TICKS * 2) _strafe_until = sim.tick + rng.randi_range(TICKS / 2, TICKS * 2)
var side: Vector2 = Vector2(-to.y, to.x) * _strafe var side: Vector2 = Vector2(-to.y, to.x) * _strafe
@@ -758,7 +758,7 @@ func _hunt(sim: Simulation, world: BotWorld) -> void:
var arrived: bool = _goal_set and nav.status != NavBot.MOVING var arrived: bool = _goal_set and nav.status != NavBot.MOVING
if not _goal_set or arrived or sim.tick >= _hunt_until: if not _goal_set or arrived or sim.tick >= _hunt_until:
var phase: int = sim.tide.phase_at(sim.tick) if sim.tide != null else 0 var phase: int = sim.tide.phase_at(sim.tick) if sim.tide != null else 0
_hunt_goal = world.random_safe(sim.rng.stream("bots"), phase) _hunt_goal = world.random_safe(nav.stream(sim), phase)
_hunt_until = sim.tick + 40 * TICKS _hunt_until = sim.tick + 40 * TICKS
_go(_hunt_goal, 4.0) _go(_hunt_goal, 4.0)
else: else:
+16 -2
View File
@@ -36,6 +36,20 @@ var _stuck_ticks: int = 0
var _stuck_tries: int = 0 var _stuck_tries: int = 0
var _jump_next: bool = false var _jump_next: bool = false
var _leap_tick: int = -1 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: func _init(id: int) -> void:
@@ -172,12 +186,12 @@ func _ride(sim: Simulation, player: SimEntity) -> PlayerCommand:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0, buttons) 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 "bots" ## 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. ## 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: func _pick_roam_goal(sim: Simulation, grid: NavGrid, player: SimEntity) -> void:
if not grid.can_plan(): if not grid.can_plan():
return return
var rng: RandomNumberGenerator = sim.rng.stream("bots") var rng: RandomNumberGenerator = stream(sim)
var centre: Vector3 = player.position var centre: Vector3 = player.position
if player.drop_state == Drop.ABOARD: if player.drop_state == Drop.ABOARD:
centre = Vector3(Tuning.WORLD_SIZE_METRES * 0.5, 0.0, Tuning.WORLD_SIZE_METRES * 0.5) centre = Vector3(Tuning.WORLD_SIZE_METRES * 0.5, 0.0, Tuning.WORLD_SIZE_METRES * 0.5)
+177
View File
@@ -0,0 +1,177 @@
## A stand-in for a person at the controls, for whole-match runs with no network and
## nobody watching. It plays a human seat through the same door as everyone else: one
## PlayerCommand a tick.
##
## It drops, loots, fights and keeps ahead of the tide as a normal bot does, and adds
## what bots don't do yet: once it has a weapon and nothing more pressing, it cuts
## driftwood with the boathook and builds a breakwater and a wall where it stands. So
## one scripted match exercises the drop, loot, combat, harvesting, building and the
## tide from a player's seat.
class_name ScriptedPlayer
extends BotBrain
const WAIT: int = 0
const HARVEST: int = 1
const BUILD: int = 2
const DONE: int = 3
const STEP_NAMES: Array[String] = ["wait", "harvest", "build", "done"]
## Driftwood to gather before building: a breakwater and a wall, and a swing to spare.
const WANTED_DRIFTWOOD: int = 45
## How far to look for something to cut, in metres.
const SEARCH_RADIUS: float = 45.0
## Starts the script this long after landing even with no weapon found.
const UNARMED_WAIT_SECONDS: float = 45.0
## Gives up on one prop, and on the whole script, after this long.
const PROP_TIMEOUT_SECONDS: float = 25.0
const SCRIPT_TIMEOUT_SECONDS: float = 150.0
## Inside this distance the script walks straight at the prop instead of path-finding.
const DIRECT_METRES: float = 6.0
var step: int = WAIT
## Driftwood gained and pieces placed by the script so far.
var harvested: int = 0
var built: int = 0
var _landed_tick: int = -1
var _script_since: int = 0
var _driving: bool = false
var _prop: int = -1
var _prop_since: int = 0
var _skipped_props: Dictionary = {}
var _to_build: Array[int] = [StructureSet.BREAKWATER, StructureSet.WALL]
var _build_yaw: float = 0.0
var _build_tries: int = 0
var _stock_before: int = -1
var _wood_seen: int = 0
func _init(id: int, level: int = NORMAL) -> void:
super(id, level)
func step_name() -> String:
return STEP_NAMES[step]
func think(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
var me: SimEntity = sim.entities.find(player_id)
if me == null or me.eliminated or me.drop_state != Drop.NONE or step == DONE:
return super(sim, grid, world)
if _landed_tick < 0:
_landed_tick = sim.tick
var wood: int = me.materials[Materials.DRIFTWOOD]
if wood > _wood_seen:
harvested += wood - _wood_seen
_wood_seen = wood
var busy: bool = _fleeing or target_id != 0 or _stage != OUTSIDE or me.swimming or not me.on_ground or _heal_slot(me) >= 0
if step == WAIT and not busy:
if _weapon_slot >= 0 or sim.tick - _landed_tick >= roundi(UNARMED_WAIT_SECONDS * TICKS):
step = HARVEST
_script_since = sim.tick
if step != WAIT and sim.tick - _script_since > roundi(SCRIPT_TIMEOUT_SECONDS * TICKS):
step = DONE
if busy or step == WAIT or step == DONE:
_release()
return super(sim, grid, world)
# The script has the controls this tick. Keep the senses going, and hand back to
# the brain on the next tick if they turn anything up.
_driving = true
_sense(sim, world, me)
_check_tide(sim, world, me)
if target_id != 0 or _fleeing:
return _hold(sim, me)
if step == HARVEST:
state = "harvest"
return _harvest(sim, grid, me)
state = "build"
return _build(sim, me)
## Gives the path follower back to the brain with no goal of the script's left in it.
func _release() -> void:
if _driving:
_stop()
_driving = false
_stock_before = -1
func _hold(sim: Simulation, me: SimEntity) -> PlayerCommand:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, float(me.yaw) / PlayerCommand.YAW_STEPS * TAU, 0.0)
## Walks to the nearest driftwood prop and swings at it until there's enough to build.
func _harvest(sim: Simulation, grid: NavGrid, me: SimEntity) -> PlayerCommand:
if me.materials[Materials.DRIFTWOOD] >= WANTED_DRIFTWOOD:
step = BUILD
_stop()
_build_yaw = float(me.yaw) / PlayerCommand.YAW_STEPS * TAU
return _hold(sim, me)
var standing: bool = _prop >= 0 and sim.props.is_standing(_prop)
if not standing or sim.tick - _prop_since > roundi(PROP_TIMEOUT_SECONDS * TICKS):
if standing:
_skipped_props[_prop] = true
_prop = _find_prop(sim, me)
_prop_since = sim.tick
if _prop < 0:
step = DONE
return _hold(sim, me)
var box: AABB = sim.props.boxes[_prop]
var eye: Vector3 = Harvest.eye(me)
var centre: Vector3 = box.get_center()
var aim: Vector3 = Vector3(centre.x, clampf(eye.y, box.position.y + 0.2, box.end.y - 0.1), centre.z)
var to: Vector3 = aim - eye
var flat: float = Vector2(to.x, to.z).length()
var yaw: float = atan2(to.x, to.z)
if PropSet._distance_to_box(box, eye) <= Harvest.reach() - 0.6:
_stop()
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, yaw, atan2(to.y, flat), PlayerCommand.BUTTON_FIRE, Simulation.BOATHOOK_SLOT)
if flat <= DIRECT_METRES:
_stop()
var buttons: int = PlayerCommand.BUTTON_JUMP if (sim.tick - _prop_since) % (2 * TICKS) == 2 * TICKS - 1 else 0
return PlayerCommand.from_input(sim.tick, Vector2(0.0, 1.0), yaw, 0.0, buttons)
_go(Vector3(centre.x, box.position.y, centre.z), DIRECT_METRES - 1.0)
var walk: PlayerCommand = nav.think(sim, grid)
if nav.status == NavBot.UNREACHABLE:
_skipped_props[_prop] = true
_prop = -1
return walk
## The nearest standing driftwood prop on dry ground that hasn't been given up on.
func _find_prop(sim: Simulation, me: SimEntity) -> int:
for prop: int in sim.props.near(me.position, SEARCH_RADIUS):
if _skipped_props.has(prop) or sim.props.material_of(prop) != Materials.NAMES[Materials.DRIFTWOOD]:
continue
var box: AABB = sim.props.boxes[prop]
if box.position.y > sim.sea_level + 0.5 and absf(box.position.y - me.position.y) < 8.0:
return prop
return -1
## Places each piece on the list where the player stands, trying each quarter turn.
func _build(sim: Simulation, me: SimEntity) -> PlayerCommand:
var stock: int = me.materials[Materials.DRIFTWOOD]
if _stock_before >= 0:
if stock < _stock_before:
built += 1
_to_build.pop_front()
_build_tries = 0
else:
_build_tries += 1
_build_yaw += PI * 0.5
if _build_tries >= 4:
_to_build.pop_front()
_build_tries = 0
_stock_before = -1
while not _to_build.is_empty() and stock < StructureSet.cost_of(_to_build[0]):
_to_build.pop_front()
if _to_build.is_empty():
step = DONE
return _hold(sim, me)
if me.action_cooldown > 0:
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, _build_yaw, 0.0)
_stock_before = stock
return PlayerCommand.from_input(
sim.tick, Vector2.ZERO, _build_yaw, 0.0,
PlayerCommand.BUTTON_BUILD | PlayerCommand.BUTTON_FIRE, _to_build[0], Materials.DRIFTWOOD)
+1
View File
@@ -0,0 +1 @@
uid://n65m74kr6a20
+213
View File
@@ -0,0 +1,213 @@
## Draws what moves in a match: players, the sky barge while it crosses, items lying
## in the world and sea chests. `sync()` matches everything to the simulation as it is
## now. These are stand-in shapes built in code, in the weathered seafaring palette of
## docs/ORIGINALITY.md: an oilskin coat, a sou'wester and a canvas wing-sail. The art
## pass replaces them. Nothing here is ever used for collision.
class_name EntityView
extends Node3D
## Oilskin colours. A player's is picked by entity ID; the local player wears the first.
const OILSKINS: Array[Color] = [
Color(0.86, 0.66, 0.16), Color(0.56, 0.27, 0.20), Color(0.33, 0.55, 0.56), Color(0.36, 0.40, 0.30),
Color(0.48, 0.46, 0.44), Color(0.30, 0.36, 0.48), Color(0.62, 0.44, 0.28),
]
const SKIN: Color = Color(0.74, 0.58, 0.46)
const CANVAS: Color = Color(0.84, 0.80, 0.68)
const TAR: Color = Color(0.19, 0.16, 0.13)
const PLANK: Color = Color(0.50, 0.45, 0.37)
const CHEST_SHUT: Color = Color(0.33, 0.55, 0.56)
const CHEST_OPEN: Color = Color(0.22, 0.20, 0.18)
const ITEM: Color = Color(0.93, 0.80, 0.42)
## How far apart passengers stand on the barge's deck, in metres. The simulation
## carries them all at one point; this only spreads them out to be seen.
const DECK_SPACING: float = 1.3
const DECK_ROWS: int = 4
## The entity drawn in the brightest oilskin, or 0.
var local_id: int = 0
var _sim: Simulation
## Entity ID -> the figure's root node.
var _figures: Dictionary = {}
var _barge: Node3D
var _pickups: MultiMeshInstance3D
var _chests: MultiMeshInstance3D
func setup(sim: Simulation) -> void:
_sim = sim
_barge = _build_barge()
_barge.visible = false
add_child(_barge)
_pickups = _box_field("Pickups", Vector3(0.34, 0.34, 0.34), true)
add_child(_pickups)
_chests = _box_field("Chests", Vector3(0.9, 0.55, 0.6), false)
add_child(_chests)
sync()
func figure_count() -> int:
return _figures.size()
## The figure drawn for a player, or null.
func figure_of(entity_id: int) -> Node3D:
return _figures.get(entity_id)
func barge() -> Node3D:
return _barge
func sync() -> void:
if _sim == null:
return
var drop: Drop = _sim.drop
var crossing: bool = drop != null and not drop.finished
var heading: float = 0.0
if drop != null:
var along: Vector3 = drop.finish - drop.start
heading = atan2(along.x, along.z)
_barge.visible = crossing
if crossing:
_barge.position = drop.barge_position(_sim.tick)
_barge.rotation.y = heading
var seen: Dictionary = {}
var aboard: int = 0
for entity: SimEntity in _sim.entities.entities():
if entity.archetype != SimEntity.ARCHETYPE_PLAYER:
continue
seen[entity.id] = true
var figure: Node3D = _figures.get(entity.id)
if figure == null:
figure = _build_figure(entity.id)
_figures[entity.id] = figure
add_child(figure)
figure.visible = not entity.eliminated
figure.position = entity.position
figure.rotation.y = float(entity.yaw) / PlayerCommand.YAW_STEPS * TAU
if entity.drop_state == Drop.ABOARD:
var column: int = aboard / DECK_ROWS
var row: int = aboard % DECK_ROWS
var offset: Vector3 = Vector3((row - (DECK_ROWS - 1) * 0.5) * DECK_SPACING, 0.0, (2.5 - column) * DECK_SPACING)
figure.position += offset.rotated(Vector3.UP, heading)
figure.rotation.y = heading
aboard += 1
figure.scale.y = Tuning.CROUCH_HEIGHT / Tuning.PLAYER_HEIGHT if entity.crouching else 1.0
(figure.get_node("Sail") as Node3D).visible = entity.drop_state == Drop.GLIDING
for entity_id: int in _figures.keys():
if not seen.has(entity_id):
_figures[entity_id].queue_free()
_figures.erase(entity_id)
var items: MultiMesh = _pickups.multimesh
items.instance_count = _sim.pickups.size()
for index: int in _sim.pickups.size():
var pickup: SimEntity = _sim.entities.find(_sim.pickups[index])
var at: Vector3 = pickup.position + Vector3(0.0, 0.3, 0.0) if pickup != null else Vector3(0.0, -1000.0, 0.0)
items.set_instance_transform(index, Transform3D(Basis(Vector3.UP, 0.6 * index), at))
items.set_instance_color(index, ITEM)
var chests: MultiMesh = _chests.multimesh
chests.instance_count = _sim.loot.chest_positions.size()
for index: int in _sim.loot.chest_positions.size():
chests.set_instance_transform(index, Transform3D(Basis.IDENTITY, _sim.loot.chest_positions[index] + Vector3(0.0, 0.28, 0.0)))
chests.set_instance_color(index, CHEST_OPEN if _sim.loot.chest_opened[index] != 0 else CHEST_SHUT)
func _process(_delta: float) -> void:
sync()
func _build_figure(entity_id: int) -> Node3D:
var coat: Color = OILSKINS[0] if entity_id == local_id else OILSKINS[1 + entity_id % (OILSKINS.size() - 1)]
var figure: Node3D = Node3D.new()
figure.name = "player_%d" % entity_id
var legs: BoxMesh = BoxMesh.new()
legs.size = Vector3(0.42, 0.8, 0.26)
figure.add_child(_part(legs, TAR, Vector3(0.0, 0.4, 0.0)))
var body: CapsuleMesh = CapsuleMesh.new()
body.radius = 0.3
body.height = 0.95
figure.add_child(_part(body, coat, Vector3(0.0, 1.05, 0.0)))
var head: SphereMesh = SphereMesh.new()
head.radius = 0.16
head.height = 0.32
figure.add_child(_part(head, SKIN, Vector3(0.0, 1.6, 0.0)))
var brim: CylinderMesh = CylinderMesh.new()
brim.top_radius = 0.17
brim.bottom_radius = 0.33
brim.height = 0.16
# The sou'wester's brim runs long at the back.
figure.add_child(_part(brim, coat.darkened(0.25), Vector3(0.0, 1.76, -0.05)))
var sail_mesh: BoxMesh = BoxMesh.new()
sail_mesh.size = Vector3(2.6, 0.04, 0.9)
var sail: MeshInstance3D = _part(sail_mesh, CANVAS, Vector3(0.0, 2.15, -0.1))
sail.name = "Sail"
sail.rotation.x = deg_to_rad(-8.0)
sail.visible = false
figure.add_child(sail)
return figure
## A flat-bottomed hull hung under a canvas envelope. Its deck is at the origin, where
## the simulation carries the passengers.
func _build_barge() -> Node3D:
var barge: Node3D = Node3D.new()
barge.name = "Barge"
var deck: BoxMesh = BoxMesh.new()
deck.size = Vector3(7.5, 0.3, 11.0)
barge.add_child(_part(deck, PLANK, Vector3(0.0, -0.15, 0.0)))
var hull: BoxMesh = BoxMesh.new()
hull.size = Vector3(6.4, 1.3, 9.6)
barge.add_child(_part(hull, TAR, Vector3(0.0, -0.95, 0.0)))
for side: float in [-1.0, 1.0]:
var rail: BoxMesh = BoxMesh.new()
rail.size = Vector3(0.15, 0.7, 11.0)
barge.add_child(_part(rail, TAR, Vector3(side * 3.68, 0.35, 0.0)))
for end: float in [-1.0, 1.0]:
var rope: CylinderMesh = CylinderMesh.new()
rope.top_radius = 0.05
rope.bottom_radius = 0.05
rope.height = 7.0
barge.add_child(_part(rope, PLANK.darkened(0.3), Vector3(side * 3.4, 3.5, end * 4.6)))
var envelope: SphereMesh = SphereMesh.new()
envelope.radius = 1.0
envelope.height = 2.0
var bag: MeshInstance3D = _part(envelope, CANVAS, Vector3(0.0, 10.5, 0.0))
bag.scale = Vector3(5.2, 3.8, 9.0)
barge.add_child(bag)
return barge
func _part(mesh: PrimitiveMesh, colour: Color, at: Vector3) -> MeshInstance3D:
var material: StandardMaterial3D = StandardMaterial3D.new()
material.albedo_color = colour
material.roughness = 0.85
mesh.material = material
var instance: MeshInstance3D = MeshInstance3D.new()
instance.mesh = mesh
instance.position = at
return instance
func _box_field(node_name: String, size: Vector3, glow: bool) -> MultiMeshInstance3D:
var material: StandardMaterial3D = StandardMaterial3D.new()
material.vertex_color_use_as_albedo = true
material.roughness = 0.7
if glow:
material.emission_enabled = true
material.emission = ITEM
material.emission_energy_multiplier = 0.5
var mesh: BoxMesh = BoxMesh.new()
mesh.size = size
mesh.material = material
var multimesh: MultiMesh = MultiMesh.new()
multimesh.transform_format = MultiMesh.TRANSFORM_3D
multimesh.use_colors = true
multimesh.mesh = mesh
var instance: MultiMeshInstance3D = MultiMeshInstance3D.new()
instance.name = node_name
instance.multimesh = multimesh
instance.cast_shadow = GeometryInstance3D.SHADOW_CASTING_SETTING_OFF
return instance
+1
View File
@@ -0,0 +1 @@
uid://cx6ttunmd4ng4
+148
View File
@@ -0,0 +1,148 @@
## The client's picture of one match: sky, sun, terrain, sea, points of interest, props,
## built pieces and everything that moves, all drawn from one Simulation, with the
## third-person camera on a player's shoulder. It only reads the simulation.
##
## A match gets a new Simulation, so it gets a new MatchView. Until snapshots arrive
## (v0.5) the simulation it reads is the local server's or a replay's.
class_name MatchView
extends Node3D
var sim: Simulation
var terrain: TerrainView
var water: WaterView
var pois: PoiView
var props: PropView
var structures: StructureView
var entities: EntityView
var camera: Camera3D
var rig: CameraRig = CameraRig.new()
## Builds the scene for `simulation`. `local_id` is the player this client plays, or 0.
func setup(simulation: Simulation, local_id: int = 0) -> void:
sim = simulation
var sky_material: ProceduralSkyMaterial = ProceduralSkyMaterial.new()
sky_material.sky_top_color = Color(0.32, 0.5, 0.68)
sky_material.sky_horizon_color = Color(0.82, 0.78, 0.68)
sky_material.ground_bottom_color = Color(0.18, 0.2, 0.2)
sky_material.ground_horizon_color = Color(0.82, 0.78, 0.68)
var sky: Sky = Sky.new()
sky.sky_material = sky_material
var environment: Environment = Environment.new()
environment.background_mode = Environment.BG_SKY
environment.sky = sky
environment.ambient_light_source = Environment.AMBIENT_SOURCE_SKY
environment.ambient_light_energy = 0.45
environment.tonemap_mode = Environment.TONE_MAPPER_FILMIC
environment.fog_enabled = true
environment.fog_light_color = Color(0.78, 0.78, 0.74)
environment.fog_density = 0.0005
environment.fog_aerial_perspective = 0.4
var world: WorldEnvironment = WorldEnvironment.new()
world.environment = environment
add_child(world)
var sun: DirectionalLight3D = DirectionalLight3D.new()
sun.rotation_degrees = Vector3(-35.0, -130.0, 0.0)
sun.light_energy = 0.95
sun.shadow_enabled = true
sun.directional_shadow_max_distance = 400.0
add_child(sun)
camera = Camera3D.new()
camera.near = CameraRig.NEAR
camera.far = 2500.0
camera.fov = CameraRig.FOV
add_child(camera)
camera.make_current()
if sim.island != null:
terrain = TerrainView.new()
terrain.setup(sim.island)
add_child(terrain)
water = WaterView.new()
add_child(water)
pois = PoiView.new()
pois.setup(sim.pois)
add_child(pois)
props = PropView.new()
props.setup(sim.props)
add_child(props)
structures = StructureView.new()
structures.setup(sim.structures)
add_child(structures)
entities = EntityView.new()
entities.local_id = local_id
entities.setup(sim)
add_child(entities)
sync()
## Matches everything drawn to the simulation as it is now.
func sync() -> void:
water.follow(sim)
props.sync()
structures.sync()
entities.sync()
## Puts the camera on a player's shoulder, looking where they look. `pitch` replaces
## their own pitch when given, in radians, for views such as looking down from a glide.
func follow(entity_id: int, pitch: float = NAN) -> bool:
var player: SimEntity = sim.entities.find(entity_id)
if player == null:
return false
var yaw: float = float(player.yaw) / PlayerCommand.YAW_STEPS * TAU
var look_pitch: float = pitch if not is_nan(pitch) else float(player.pitch) / PlayerCommand.PITCH_MAX * (PI * 0.5)
camera.transform = rig.solve(player.position, yaw, look_pitch, player.crouching, sim.ground)
camera.fov = rig.fov()
_focus()
return true
## Frames a player from outside: the camera stands `distance` metres off at `height`
## above their feet and looks at them, from the first of eight directions that has a
## clear line and no prop around the lens. With `beyond` given, it starts on the far
## side of the player from that point, so the point is in the picture behind them.
func frame(entity_id: int, distance: float = 6.0, height: float = 2.6, beyond: Vector3 = Vector3.INF) -> bool:
var player: SimEntity = sim.entities.find(entity_id)
if player == null:
return false
var chest: Vector3 = player.position + Vector3(0.0, 1.2, 0.0)
var first: float = float(player.yaw) / PlayerCommand.YAW_STEPS * TAU + PI
if beyond != Vector3.INF:
first = atan2(player.position.x - beyond.x, player.position.z - beyond.z)
var eye: Vector3 = chest
for turn: int in 8:
# Straight on first, then alternately to each side.
var angle: float = first + (turn + 1) / 2 * (PI / 4.0) * (1.0 if turn % 2 == 1 else -1.0)
eye = player.position + Vector3(sin(angle) * distance, height, cos(angle) * distance)
eye.y = maxf(eye.y, sim.ground.terrain_height(eye.x, eye.z) + 1.0)
var feet: Vector3 = Vector3(eye.x, sim.ground.terrain_height(eye.x, eye.z), eye.z)
if sim.ground.raycast(chest, eye) >= 1.0 and sim.props.near(feet, 5.0).is_empty():
break
look_from(eye, chest if beyond == Vector3.INF else chest.lerp(beyond, 0.35))
return true
## Puts the camera at `eye`, looking at `target`.
func look_from(eye: Vector3, target: Vector3) -> void:
camera.transform = Transform3D(Basis.IDENTITY, eye).looking_at(target, Vector3.UP)
camera.fov = CameraRig.FOV
_focus()
## The whole island from high over its south-west, as the lobby shows it.
func overview() -> void:
var size: float = Tuning.WORLD_SIZE_METRES
look_from(Vector3(size * 0.2, 300.0, size * 0.92), Vector3(size * 0.5, 0.0, size * 0.47))
## Builds every terrain chunk for the current camera at once. For loading and captures.
func settle() -> void:
if terrain != null:
terrain.build_all_now()
func _focus() -> void:
if terrain != null:
terrain.focus = camera.position
+1
View File
@@ -0,0 +1 @@
uid://ctcbsm7hld1dc
+178
View File
@@ -0,0 +1,178 @@
## A match's seed, rules and every command the server was given, in the order it got
## them. With the same engine build that is enough to play the match again exactly:
## the simulation takes nothing else in. See MatchReplay.
##
## Each record is the simulation tick the command arrived on, the handle it came from
## and the command's own 14 bytes. Commands are logged whether or not the simulation
## accepted them, so a replay turns the same ones down.
##
## On disk: "TWCL", a u32 header length, the header as JSON, a u32 length of the raw
## records, then the records compressed with Zstandard. The seed is a string in the
## header, because JSON numbers can't hold 63 bits.
class_name CommandLog
extends RefCounted
const MAGIC: String = "TWCL"
const VERSION: int = 1
## at-tick u32, handle s32, then the command.
const RECORD_SIZE: int = 8 + PlayerCommand.ENCODED_SIZE
## Refuse files that claim more than this many raw bytes: about four full matches.
const MAX_RAW_BYTES: int = 64 * 1024 * 1024
const RULE_KEYS: Array[String] = [
"max_players", "min_players", "team_size", "lobby_ticks", "countdown_ticks", "results_ticks", "fill_with_bots",
]
var session_seed: int = 0
## Human participants, who join with handles 1 and up before the first tick.
var humans: int = 0
var rules: MatchRules = MatchRules.new()
## What the recording ended with: the simulation tick, its state hash and the winning
## handles. `final_hash` is empty for a recording that was never finished.
var final_tick: int = 0
var final_hash: String = ""
var winners: Array[int] = []
## Free-form notes for whoever reads the file: bot count, difficulty and so on. Not
## needed to replay.
var notes: Dictionary = {}
var _records: StreamPeerBuffer = StreamPeerBuffer.new()
func _init(seed_value: int = 0, human_players: int = 0, match_rules: MatchRules = null) -> void:
session_seed = seed_value
humans = human_players
if match_rules != null:
rules = match_rules
_records.big_endian = false
func count() -> int:
return _records.get_size() / RECORD_SIZE
## Adds a command that arrived from `handle` while the simulation was at `at_tick`.
func record(at_tick: int, handle: int, command: PlayerCommand) -> void:
_records.seek(_records.get_size())
_records.put_u32(at_tick)
_records.put_32(handle)
_records.put_data(command.encode())
func at_tick_of(index: int) -> int:
return _records.data_array.decode_u32(index * RECORD_SIZE)
func handle_of(index: int) -> int:
return _records.data_array.decode_s32(index * RECORD_SIZE + 4)
func command_of(index: int) -> PlayerCommand:
return PlayerCommand.decode(_records.data_array, index * RECORD_SIZE + 8)
## Marks the recording finished with the state it reached.
func finish(flow: Match) -> void:
final_tick = flow.sim.tick
final_hash = flow.sim.state_hash()
winners = flow.winners.duplicate()
func header() -> Dictionary:
var rule_values: Dictionary = {}
for key: String in RULE_KEYS:
rule_values[key] = rules.get(key)
return {
"version": VERSION,
"engine": Engine.get_version_info()["string"],
"seed": str(session_seed),
"humans": humans,
"rules": rule_values,
"records": count(),
"final_tick": final_tick,
"final_hash": final_hash,
"winners": winners,
"notes": notes,
}
func to_bytes() -> PackedByteArray:
var head: PackedByteArray = JSON.stringify(header()).to_utf8_buffer()
var raw: PackedByteArray = _records.data_array
var out: StreamPeerBuffer = StreamPeerBuffer.new()
out.big_endian = false
out.put_data(MAGIC.to_ascii_buffer())
out.put_u32(head.size())
out.put_data(head)
out.put_u32(raw.size())
if raw.size() > 0:
out.put_data(raw.compress(FileAccess.COMPRESSION_ZSTD))
return out.data_array
## Reads a log back, or returns null if the bytes aren't a usable log. Nothing in a bad
## file can raise an error: every length is checked before it is used.
static func from_bytes(bytes: PackedByteArray) -> CommandLog:
if bytes.size() < 12 or bytes.slice(0, 4).get_string_from_ascii() != MAGIC:
return null
var head_size: int = bytes.decode_u32(4)
if head_size <= 0 or 8 + head_size + 4 > bytes.size():
return null
var parser: JSON = JSON.new()
if parser.parse(bytes.slice(8, 8 + head_size).get_string_from_utf8()) != OK or not parser.data is Dictionary:
return null
var head: Dictionary = parser.data
if int(head.get("version", 0)) != VERSION or not head.get("rules") is Dictionary or not str(head.get("seed", "")).is_valid_int():
return null
var raw_size: int = bytes.decode_u32(8 + head_size)
if raw_size < 0 or raw_size > MAX_RAW_BYTES or raw_size % RECORD_SIZE != 0:
return null
var raw: PackedByteArray = PackedByteArray()
if raw_size > 0:
var packed: PackedByteArray = bytes.slice(12 + head_size)
if packed.is_empty():
return null
raw = packed.decompress(raw_size, FileAccess.COMPRESSION_ZSTD)
if raw.size() != raw_size:
return null
var result: CommandLog = CommandLog.new(str(head["seed"]).to_int(), clampi(int(head.get("humans", 0)), 0, Tuning.SOLO_PLAYERS))
var rule_values: Dictionary = head["rules"]
for key: String in RULE_KEYS:
if not rule_values.has(key):
return null
if key == "fill_with_bots":
result.rules.fill_with_bots = bool(rule_values[key])
else:
result.rules.set(key, int(rule_values[key]))
result.rules.max_players = clampi(result.rules.max_players, 1, Tuning.SOLO_PLAYERS)
result.rules.team_size = maxi(result.rules.team_size, 1)
result.final_tick = int(head.get("final_tick", 0))
result.final_hash = str(head.get("final_hash", ""))
if head.get("winners") is Array:
for winner: Variant in head["winners"]:
result.winners.append(int(winner))
if head.get("notes") is Dictionary:
result.notes = head["notes"]
result._records.data_array = raw
return result
## Writes the log to `path`, creating its folder. Returns OK or the error.
func save(path: String) -> Error:
var folder: String = path.get_base_dir()
if not DirAccess.dir_exists_absolute(folder):
var made: Error = DirAccess.make_dir_recursive_absolute(folder)
if made != OK:
return made
var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
if file == null:
return FileAccess.get_open_error()
file.store_buffer(to_bytes())
file.close()
return OK
## Reads the log at `path`, or returns null if it is missing or unusable.
static func load_from(path: String) -> CommandLog:
if not FileAccess.file_exists(path):
return null
return from_bytes(FileAccess.get_file_as_bytes(path))
+1
View File
@@ -0,0 +1 @@
uid://b0f8jbsbyhwiu
+85
View File
@@ -0,0 +1,85 @@
## Plays a recorded match again from its CommandLog: the same seed, the same rules, the
## same commands on the same ticks, and nobody thinking. Bots and scripted players
## aren't run; their commands are in the log like everyone else's.
##
## The replay covers the log's first match, from the lobby to its results.
class_name MatchReplay
extends RefCounted
var commands: CommandLog
var flow: Match
var sim: Simulation:
get:
return flow.sim
## Server ticks run, lobby and countdown included.
var ticks: int = 0
var _cursor: int = 0
func _init(command_log: CommandLog) -> void:
commands = command_log
flow = Match.new(commands.session_seed, commands.rules)
for handle: int in range(1, commands.humans + 1):
flow.join(handle)
## True once the match's results are in, or the match can't go on.
func finished() -> bool:
return flow.phase == Match.RESULTS
## Runs one server tick. Returns false, doing nothing, once the match has finished.
func step() -> bool:
if finished():
return false
if flow.in_match():
var tick: int = sim.tick
while _cursor < commands.count() and commands.at_tick_of(_cursor) <= tick:
if commands.at_tick_of(_cursor) == tick:
flow.submit_command(commands.handle_of(_cursor), commands.command_of(_cursor))
_cursor += 1
flow.step()
ticks += 1
return true
## Steps until `done` returns true (it is asked before each tick), the match finishes,
## or `limit` server ticks have run. Returns true if `done` was satisfied.
func run_until(done: Callable, limit: int = default_limit()) -> bool:
while ticks < limit:
if done.call():
return true
if not step():
return bool(done.call())
return bool(done.call())
## Steps to the match's results. Returns true if it got there within `limit` ticks.
func run_to_end(limit: int = default_limit()) -> bool:
while ticks < limit and step():
pass
return finished()
## The longest a logged match can take in server ticks: lobby, countdown, the tide's
## whole schedule, and slack.
func default_limit() -> int:
return commands.rules.lobby_ticks + commands.rules.countdown_ticks + Tide.new(0).time_limit_offset() + 60 * Tuning.TICK_RATE_HZ
## Compares where the replay is with what the recording ended on. Call after
## run_to_end(). Returns {"ok", "tick", "expected_tick", "hash", "expected_hash",
## "winners", "expected_winners"}.
func verify() -> Dictionary:
var digest: String = sim.state_hash()
return {
"ok": finished() and not commands.final_hash.is_empty() and digest == commands.final_hash
and sim.tick == commands.final_tick and flow.winners == commands.winners,
"tick": sim.tick,
"expected_tick": commands.final_tick,
"hash": digest,
"expected_hash": commands.final_hash,
"winners": flow.winners.duplicate(),
"expected_winners": commands.winners.duplicate(),
}
+1
View File
@@ -0,0 +1 @@
uid://bbybxusl4dakt
+57 -7
View File
@@ -15,6 +15,10 @@ var sim: Simulation:
## Entity IDs of everyone in the current match, humans first. ## Entity IDs of everyone in the current match, humans first.
var player_ids: Array[int] = [] var player_ids: Array[int] = []
var bots: Array[BotBrain] = [] var bots: Array[BotBrain] = []
## Human seats played by script, when play_humans_by_script() was called.
var scripted: Array[ScriptedPlayer] = []
## When set, every command the server is given during the first match goes in it.
var recorder: CommandLog = null
## The current or next match's navigation grid and bot map, built while the lobby waits. ## The current or next match's navigation grid and bot map, built while the lobby waits.
var nav: NavGrid = null var nav: NavGrid = null
var world: BotWorld = null var world: BotWorld = null
@@ -25,6 +29,8 @@ var tick_usec: PackedInt64Array = PackedInt64Array()
## Server ticks run, across every match. ## Server ticks run, across every match.
var ticks: int = 0 var ticks: int = 0
var _script_humans: bool = false
## `human_players` join as idle participants with handles 1 and up; `bot_count` bots ## `human_players` join as idle participants with handles 1 and up; `bot_count` bots
## fill the rest of every match. With `rules` null the match starts at once, and the ## fill the rest of every match. With `rules` null the match starts at once, and the
@@ -32,11 +38,7 @@ var ticks: int = 0
func _init(match_seed: int, human_players: int, bot_count: int, rules: MatchRules = null, difficulty: int = -1) -> void: func _init(match_seed: int, human_players: int, bot_count: int, rules: MatchRules = null, difficulty: int = -1) -> void:
bot_difficulty = difficulty bot_difficulty = difficulty
if rules == null: if rules == null:
rules = MatchRules.immediate() rules = immediate_rules(human_players, bot_count)
rules.max_players = maxi(human_players + bot_count, 1)
rules.fill_with_bots = bot_count > 0
# With only bots there's nobody to wait for, so the lobby starts with no one in it.
rules.min_players = 0 if human_players == 0 and bot_count > 0 else 1
match_flow = Match.new(match_seed, rules) match_flow = Match.new(match_seed, rules)
nav = NavGrid.build(match_flow.sim) nav = NavGrid.build(match_flow.sim)
world = BotWorld.build(match_flow.sim, nav) world = BotWorld.build(match_flow.sim, nav)
@@ -47,14 +49,55 @@ func _init(match_seed: int, human_players: int, bot_count: int, rules: MatchRule
_advance() _advance()
## Rules for a server that skips the lobby and fills the match with `bot_count` bots.
static func immediate_rules(human_players: int, bot_count: int) -> MatchRules:
var rules: MatchRules = MatchRules.immediate()
rules.max_players = maxi(human_players + bot_count, 1)
rules.fill_with_bots = bot_count > 0
# With only bots there's nobody to wait for, so the lobby starts with no one in it.
rules.min_players = 0 if human_players == 0 and bot_count > 0 else 1
return rules
## Starts recording every command into a new log, which is returned. Call before the
## first tick; the log covers the first match.
func record_commands() -> CommandLog:
var humans: int = 0
for handle: int in match_flow.participants:
if not match_flow.bot_handles.has(handle):
humans += 1
recorder = CommandLog.new(match_flow.session_seed, humans, match_flow.rules)
recorder.notes = {"bot_difficulty": bot_difficulty}
return recorder
## From now on, every human seat is played by a ScriptedPlayer: a stand-in for a
## person at the controls, for whole-match tests before and without the network.
func play_humans_by_script() -> void:
_script_humans = true
if match_flow.in_match():
_track_players()
## Gives the simulation a participant's command for the current match. Returns false
## if it was turned down. This is the one way commands get in, for people, scripts and
## bots alike, so the recorder sees them all.
func submit(handle: int, command: PlayerCommand) -> bool:
if recorder != null and match_flow.matches_started == 1 and match_flow.in_match():
recorder.record(sim.tick, handle, command)
return match_flow.submit_command(handle, command)
## Runs one tick and records how long it took. ## Runs one tick and records how long it took.
func run_tick() -> void: func run_tick() -> void:
var started: int = Time.get_ticks_usec() var started: int = Time.get_ticks_usec()
if match_flow.in_match(): if match_flow.in_match():
nav.sync(sim) nav.sync(sim)
world.observe(sim) world.observe(sim)
for player: ScriptedPlayer in scripted:
submit(match_flow.handle_of[player.player_id], player.think(sim, nav, world))
for bot: BotBrain in bots: for bot: BotBrain in bots:
sim.submit_command(bot.player_id, bot.think(sim, nav, world)) submit(match_flow.handle_of[bot.player_id], bot.think(sim, nav, world))
_advance() _advance()
ticks += 1 ticks += 1
tick_usec.append(Time.get_ticks_usec() - started) tick_usec.append(Time.get_ticks_usec() - started)
@@ -65,9 +108,12 @@ func _advance() -> void:
for event: Dictionary in match_flow.events: for event: Dictionary in match_flow.events:
if event["type"] == "match_started": if event["type"] == "match_started":
_track_players() _track_players()
elif event["type"] == "match_ended" and recorder != null and match_flow.matches_started == 1 and recorder.final_hash.is_empty():
recorder.finish(match_flow)
elif event["type"] == "phase" and event["to"] == "lobby": elif event["type"] == "phase" and event["to"] == "lobby":
player_ids.clear() player_ids.clear()
bots.clear() bots.clear()
scripted.clear()
if event["from"] == "results": if event["from"] == "results":
nav = NavGrid.build(match_flow.sim) nav = NavGrid.build(match_flow.sim)
world = BotWorld.build(match_flow.sim, nav) world = BotWorld.build(match_flow.sim, nav)
@@ -76,10 +122,14 @@ func _advance() -> void:
func _track_players() -> void: func _track_players() -> void:
player_ids.clear() player_ids.clear()
bots.clear() bots.clear()
scripted.clear()
for handle: int in match_flow.participants: for handle: int in match_flow.participants:
var entity_id: int = match_flow.entity_of[handle] var entity_id: int = match_flow.entity_of[handle]
player_ids.append(entity_id) player_ids.append(entity_id)
if match_flow.bot_handles.has(handle): if not match_flow.bot_handles.has(handle):
if _script_humans:
scripted.append(ScriptedPlayer.new(entity_id))
else:
var level: int = bot_difficulty if bot_difficulty >= 0 else bots.size() % Tuning.BOT_DIFFICULTIES.size() var level: int = bot_difficulty if bot_difficulty >= 0 else bots.size() % Tuning.BOT_DIFFICULTIES.size()
bots.append(BotBrain.new(entity_id, level)) bots.append(BotBrain.new(entity_id, level))
world.player_ids = player_ids.duplicate() world.player_ids = player_ids.duplicate()
+44
View File
@@ -0,0 +1,44 @@
extends TestCase
## The scripted player from issue M8: a stand-in for a person, which also harvests and
## builds, things bots don't do yet.
func test_a_scripted_seat_sends_commands_like_anyone_else() -> void:
var loop: ServerLoop = ServerLoop.new(99, 1, 1)
loop.play_humans_by_script()
assert_eq(loop.scripted.size(), 1)
assert_eq(loop.scripted[0].player_id, 1)
assert_eq(loop.bots.size(), 1)
for _index: int in Tuning.TICK_RATE_HZ * 24:
loop.run_tick()
assert_ne(loop.sim.entities.find(1).drop_state, Drop.ABOARD, "the scripted player leapt from the barge")
func test_harvests_driftwood_and_builds_with_it() -> void:
# Seed 2 is the match `make match` plays: the player lands, finds a weapon, cuts
# driftwood and puts up a breakwater and a wall about a minute in.
var loop: ServerLoop = ServerLoop.new(2, 1, 23)
loop.play_humans_by_script()
var player: ScriptedPlayer = loop.scripted[0]
var placed: int = 0
var harvests: int = 0
while loop.ticks < 2400 and player.step != ScriptedPlayer.DONE:
loop.run_tick()
for event: Dictionary in loop.sim.events:
if event["type"] == "piece_placed" and event["player"] == player.player_id:
placed += 1
elif event["type"] == "harvest" and event["player"] == player.player_id:
harvests += 1
assert_eq(player.step, ScriptedPlayer.DONE)
assert_true(harvests >= 3, "swung at props %d times" % harvests)
assert_true(player.harvested >= ScriptedPlayer.WANTED_DRIFTWOOD, "harvested %d" % player.harvested)
assert_eq(player.built, 2)
assert_eq(placed, 2)
var kinds: Array[int] = []
for piece: StructureSet.Piece in loop.sim.structures.pieces.values():
if piece.owner == player.player_id:
kinds.append(piece.kind)
kinds.sort()
assert_eq(kinds, [StructureSet.WALL, StructureSet.BREAKWATER] as Array[int])
assert_false(loop.sim.entities.find(player.player_id).eliminated)
+1
View File
@@ -0,0 +1 @@
uid://cci7ssoaiiyt8
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "barge"
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "built"
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "final"
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "glide"
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "landed"
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "lobby"
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "results"
+149
View File
@@ -0,0 +1,149 @@
## Capture scenario for a whole match. It replays the command log `make match` saved
## to the moment `stage` names, draws that moment with the client's MatchView, and
## prints what it shows as a caption (Godot's default font; this is a test caption,
## not the game's HUD).
##
## Stages: lobby, barge, glide, landed, built, final, tide (the island just before the
## end, from where the lobby saw it), results.
extends Node3D
const TICKS: int = Tuning.TICK_RATE_HZ
## The scripted player's handle.
const PLAYER: int = 1
@export var log_path: String = "res://build/match/match.tclog"
@export var stage: String = "lobby"
var _replay: MatchReplay
var _view: MatchView
func _ready() -> void:
var commands: CommandLog = CommandLog.load_from(log_path)
if commands == null:
push_error("match capture: no usable command log at %s; run `make match` first" % log_path)
return
_replay = MatchReplay.new(commands)
var flow: Match = _replay.flow
var last: int = commands.final_tick
match stage:
"lobby":
pass
"barge":
_replay.run_until(func() -> bool: return flow.in_match() and flow.sim.tick >= 2 * TICKS)
"glide":
_replay.run_until(func() -> bool: return _player() != null and _player().drop_state == Drop.GLIDING)
_run_ticks(TICKS)
"landed":
_replay.run_until(func() -> bool: return _player() != null and _player().drop_state == Drop.NONE and flow.in_match())
_run_ticks(4 * TICKS)
"built":
_replay.run_until(func() -> bool: return flow.sim.structures.count() >= 2)
_run_ticks(3 * TICKS)
"tide":
_replay.run_until(func() -> bool: return flow.in_match() and flow.sim.tick >= last - 2 * TICKS)
"final":
_replay.run_until(func() -> bool: return flow.in_match() and flow.sim.tick > 10 * TICKS and flow.alive().size() <= 3)
"results":
_replay.run_to_end()
_:
push_error("match capture: unknown stage '%s'" % stage)
return
var sim: Simulation = flow.sim
var player_id: int = int(flow.entity_of.get(PLAYER, 0))
_view = MatchView.new()
_view.setup(sim, player_id)
add_child(_view)
var watched: int = _watched()
var who: String = "nobody"
if stage == "lobby" or stage == "tide":
_view.overview()
who = "the island"
elif stage == "barge":
var along: Vector3 = (sim.drop.finish - sim.drop.start).normalized()
var at: Vector3 = sim.drop.barge_position(sim.tick)
_view.look_from(at - along * 22.0 + Vector3(0.0, 9.0, 0.0) + along.cross(Vector3.UP) * 9.0, at + along * 40.0 - Vector3(0.0, 22.0, 0.0))
who = "the barge"
elif watched != 0:
var entity: SimEntity = sim.entities.find(flow.entity_of[watched])
var airborne: bool = entity.drop_state != Drop.NONE
if stage == "built" and sim.structures.count() > 0:
var piece: StructureSet.Piece = sim.structures.pieces.values()[0]
_view.frame(entity.id, 7.0, 2.8, piece.boxes[0].get_center())
elif stage == "results":
_view.frame(entity.id)
else:
_view.follow(entity.id, deg_to_rad(-22.0) if airborne else deg_to_rad(-9.0))
who = "the player" if watched == PLAYER else "bot %d" % -watched
else:
_view.overview()
_view.settle()
_caption(_describe(who))
func _player() -> SimEntity:
var flow: Match = _replay.flow
if not flow.entity_of.has(PLAYER):
return null
return flow.sim.entities.find(flow.entity_of[PLAYER])
func _run_ticks(count: int) -> void:
for _index: int in count:
if not _replay.step():
return
## The handle the camera follows: the player while they stand, then whoever they're
## spectating, then a winner, then anyone still standing. 0 for nobody.
func _watched() -> int:
var flow: Match = _replay.flow
var living: Array[int] = flow.alive()
if living.has(PLAYER):
return PLAYER
var target: int = flow.spectate_target(PLAYER)
if target != 0 and flow.entity_of.has(target):
return target
if not flow.winners.is_empty():
return flow.winners[0]
return living[0] if not living.is_empty() else 0
func _describe(who: String) -> String:
var flow: Match = _replay.flow
var sim: Simulation = flow.sim
var lines: Array[String] = []
lines.append("%s · %s · seed %d" % [stage.to_upper(), flow.phase_name(), _replay.commands.session_seed])
if flow.phase == Match.LOBBY or flow.phase == Match.COUNTDOWN:
lines.append("%d waiting · the match starts in %d s" % [flow.participants.size(), (flow.rules.lobby_ticks + flow.rules.countdown_ticks) / TICKS])
return "\n".join(lines)
lines.append("%d:%02d · %d of %d standing · sea %.1f m · tide phase %d" % [
sim.tick / TICKS / 60, sim.tick / TICKS % 60, flow.alive().size(), flow.summary().size(), sim.sea_level,
sim.tide.phase_at(sim.tick) + 1 if sim.tide != null else 0])
var me: SimEntity = _player()
if me != null:
lines.append("player: health %d · driftwood %d · %d pieces built · watching %s" % [
me.health, me.materials[Materials.DRIFTWOOD], sim.structures.count(), who])
if flow.phase == Match.RESULTS:
for row: Dictionary in flow.summary():
if row["place"] <= 3 or row["handle"] == PLAYER:
lines.append("#%d %s · %d eliminations · %d damage · %d s" % [
row["place"], "player" if row["handle"] == PLAYER else "bot %d" % -int(row["handle"]),
row["eliminations"], row["damage_dealt"], roundi(row["survival_seconds"])])
return "\n".join(lines)
func _caption(text: String) -> void:
var settings: LabelSettings = LabelSettings.new()
settings.font_size = 20
settings.font_color = Color(0.96, 0.94, 0.88)
settings.outline_size = 6
settings.outline_color = Color(0.08, 0.09, 0.1)
var label: Label = Label.new()
label.label_settings = settings
label.text = text
label.position = Vector2(18.0, 14.0)
var layer: CanvasLayer = CanvasLayer.new()
layer.add_child(label)
add_child(layer)
+1
View File
@@ -0,0 +1 @@
uid://ix887lku6smh
+7
View File
@@ -0,0 +1,7 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/match_scene.gd" id="1"]
[node name="CaptureMatch" type="Node3D"]
script = ExtResource("1")
stage = "tide"
+81
View File
@@ -0,0 +1,81 @@
extends TestCase
## The client's picture of a match (issue M8): one view over a simulation, with every
## player, the barge, items and chests drawn from it.
func _match(bots: int = 3) -> ServerLoop:
return ServerLoop.new(2, 1, bots)
func test_draws_every_player_and_the_barge() -> void:
var loop: ServerLoop = _match()
var view: MatchView = MatchView.new()
view.setup(loop.sim, 1)
assert_eq(view.entities.figure_count(), 4)
assert_true(view.entities.barge().visible)
assert_true(view.entities.barge().position.distance_to(loop.sim.drop.barge_position(loop.sim.tick)) < 0.001)
# Passengers are spread over the deck, not stacked on one spot.
assert_true(view.entities.figure_of(1).position.distance_to(view.entities.figure_of(2).position) > 1.0)
assert_eq(view.entities.get_node("Pickups").multimesh.instance_count, loop.sim.pickups.size())
assert_eq(view.entities.get_node("Chests").multimesh.instance_count, loop.sim.loot.chest_positions.size())
assert_not_null(view.terrain)
view.free()
func test_follows_the_simulation() -> void:
var loop: ServerLoop = _match()
var view: MatchView = MatchView.new()
view.setup(loop.sim, 1)
while not loop.sim.drop.finished:
loop.run_tick()
loop.sim.entities.find(3).health = 0
loop.run_tick()
loop.sim.set_sea_level(6.5)
view.sync()
assert_false(view.entities.barge().visible, "the barge is gone once the drop is over")
assert_false(view.entities.figure_of(3).visible, "an eliminated player isn't drawn")
var bot: SimEntity = loop.sim.entities.find(2)
if not bot.eliminated:
assert_true(view.entities.figure_of(2).position.distance_to(bot.position) < 0.001)
assert_near(view.water.level, 6.5, 0.001)
assert_eq(view.entities.get_node("Pickups").multimesh.instance_count, loop.sim.pickups.size())
view.free()
func test_gliding_players_show_a_wing_sail() -> void:
var loop: ServerLoop = _match(1)
var view: MatchView = MatchView.new()
view.setup(loop.sim, 1)
var bot: SimEntity = loop.sim.entities.find(2)
assert_false((view.entities.figure_of(2).get_node("Sail") as Node3D).visible)
var guard: int = 0
while bot.drop_state != Drop.GLIDING and guard < 3000:
loop.run_tick()
guard += 1
view.sync()
assert_eq(bot.drop_state, Drop.GLIDING)
assert_true((view.entities.figure_of(2).get_node("Sail") as Node3D).visible)
view.free()
func test_the_camera_follows_a_player_and_frames_one() -> void:
var loop: ServerLoop = _match()
var view: MatchView = MatchView.new()
view.setup(loop.sim, 1)
while not loop.sim.drop.finished:
loop.run_tick()
view.sync()
var bot: SimEntity = loop.sim.entities.find(2)
assert_true(view.follow(2))
var gap: float = view.camera.position.distance_to(bot.position)
assert_true(gap > 0.5 and gap < 6.0, "the camera is %f m from the player" % gap)
assert_eq(view.terrain.focus, view.camera.position)
assert_true(view.frame(2))
var to_player: Vector3 = (bot.position + Vector3(0.0, 1.2, 0.0) - view.camera.position).normalized()
assert_true(to_player.dot(-view.camera.transform.basis.z) > 0.98, "the camera looks at the player")
assert_false(view.follow(999))
assert_false(view.frame(999))
view.overview()
assert_true(view.camera.position.y > 200.0)
view.free()
+1
View File
@@ -0,0 +1 @@
uid://0vi50i7uptfw
+105
View File
@@ -0,0 +1,105 @@
extends TestCase
## The command log from issue M8: what a match was given, kept so it can be replayed.
func _command(tick: int, buttons: int) -> PlayerCommand:
return PlayerCommand.from_input(tick, Vector2(0.5, -1.0), 1.25, -0.3, buttons, 2, 1)
func _log() -> CommandLog:
var rules: MatchRules = MatchRules.new()
rules.max_players = 6
rules.lobby_ticks = 12
rules.fill_with_bots = false
# A seed too large for a JSON number to hold exactly.
var commands: CommandLog = CommandLog.new(0x7FFFFFFFFFFFFFF1, 2, rules)
commands.record(0, 1, _command(0, PlayerCommand.BUTTON_JUMP))
commands.record(0, -3, _command(0, 0))
commands.record(7, 2, _command(9, PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_BUILD))
commands.final_tick = 8
commands.final_hash = "abc123"
commands.winners = [-3] as Array[int]
commands.notes = {"bots": 4}
return commands
func test_records_keep_their_tick_handle_and_command() -> void:
var commands: CommandLog = _log()
assert_eq(commands.count(), 3)
assert_eq(commands.at_tick_of(2), 7)
assert_eq(commands.handle_of(1), -3)
assert_eq(commands.handle_of(2), 2)
assert_eq(commands.command_of(2).encode(), _command(9, PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_BUILD).encode())
func test_round_trips_through_bytes() -> void:
var commands: CommandLog = _log()
var back: CommandLog = CommandLog.from_bytes(commands.to_bytes())
assert_not_null(back)
assert_eq(back.session_seed, 0x7FFFFFFFFFFFFFF1, "the whole 63-bit seed survives")
assert_eq(back.humans, 2)
assert_eq(back.rules.max_players, 6)
assert_eq(back.rules.lobby_ticks, 12)
assert_false(back.rules.fill_with_bots)
assert_eq(back.rules.countdown_ticks, commands.rules.countdown_ticks)
assert_eq(back.count(), 3)
for index: int in 3:
assert_eq(back.at_tick_of(index), commands.at_tick_of(index))
assert_eq(back.handle_of(index), commands.handle_of(index))
assert_eq(back.command_of(index).encode(), commands.command_of(index).encode())
assert_eq(back.final_tick, 8)
assert_eq(back.final_hash, "abc123")
assert_eq(back.winners, [-3] as Array[int])
assert_eq(int(back.notes["bots"]), 4)
func test_an_empty_log_round_trips() -> void:
var back: CommandLog = CommandLog.from_bytes(CommandLog.new(5, 0).to_bytes())
assert_not_null(back)
assert_eq(back.count(), 0)
assert_eq(back.session_seed, 5)
func test_saves_and_loads_a_file() -> void:
var path: String = "user://test_command_log/roundtrip.tclog"
assert_eq(_log().save(path), OK)
var back: CommandLog = CommandLog.load_from(path)
assert_not_null(back)
assert_eq(back.count(), 3)
DirAccess.remove_absolute(path)
assert_null(CommandLog.load_from(path), "a missing file is no log")
func test_bad_bytes_are_refused_without_errors() -> void:
var good: PackedByteArray = _log().to_bytes()
assert_null(CommandLog.from_bytes(PackedByteArray()))
assert_null(CommandLog.from_bytes("TWCL".to_ascii_buffer()))
var wrong_magic: PackedByteArray = good.duplicate()
wrong_magic[0] = 0x58
assert_null(CommandLog.from_bytes(wrong_magic))
# Cut short anywhere: never a log with records missing, never an engine error.
for size: int in range(0, good.size(), 7):
var cut: CommandLog = CommandLog.from_bytes(good.slice(0, size))
assert_true(cut == null or cut.count() == 3, "cut at %d bytes" % size)
# A header length that points past the end.
var long_header: PackedByteArray = good.duplicate()
long_header.encode_u32(4, 0x7FFFFFFF)
assert_null(CommandLog.from_bytes(long_header))
# A header that isn't JSON.
var head_size: int = good.decode_u32(4)
var not_json: PackedByteArray = good.duplicate()
for index: int in range(8, 8 + head_size):
not_json[index] = 0x7B
assert_null(CommandLog.from_bytes(not_json))
# A raw length that is huge, or not a whole number of records.
var huge: PackedByteArray = good.duplicate()
huge.encode_u32(8 + head_size, 0x7FFFFFF0)
assert_null(CommandLog.from_bytes(huge))
var ragged: PackedByteArray = good.duplicate()
ragged.encode_u32(8 + head_size, CommandLog.RECORD_SIZE * 3 + 1)
assert_null(CommandLog.from_bytes(ragged))
# Records that don't decompress to the promised length.
var short: PackedByteArray = good.duplicate()
short.encode_u32(8 + head_size, CommandLog.RECORD_SIZE * 40)
assert_null(CommandLog.from_bytes(short))
+1
View File
@@ -0,0 +1 @@
uid://clgykma7ju4if
+93
View File
@@ -0,0 +1,93 @@
extends TestCase
## Issue M8: a seed and a command log reproduce a match.
## Plays a small match to its end with one scripted player, recording it.
func _recorded(seed_value: int, bots: int, rules: MatchRules = null) -> ServerLoop:
var loop: ServerLoop = ServerLoop.new(seed_value, 1, bots, rules)
loop.play_humans_by_script()
loop.record_commands()
var limit: int = BotBatch.tick_limit() + 2000
while loop.ticks < limit and loop.recorder.final_hash.is_empty():
loop.run_tick()
return loop
func test_a_replay_ends_in_the_same_state() -> void:
var loop: ServerLoop = _recorded(41, 5)
var commands: CommandLog = loop.recorder
assert_false(commands.final_hash.is_empty(), "the match ended")
assert_eq(commands.winners.size(), 1)
assert_true(commands.count() >= commands.final_tick * 6, "every seat's command is logged every tick")
# Through bytes, as a saved file would be.
var replay: MatchReplay = MatchReplay.new(CommandLog.from_bytes(commands.to_bytes()))
assert_true(replay.run_to_end())
var verdict: Dictionary = replay.verify()
assert_true(verdict["ok"], "replay %s" % verdict)
assert_eq(replay.sim.tick, commands.final_tick)
assert_eq(replay.flow.winners, commands.winners)
assert_false(replay.step(), "a finished replay doesn't step")
func test_a_replay_runs_the_lobby_and_countdown_too() -> void:
var rules: MatchRules = MatchRules.new()
rules.max_players = 4
rules.lobby_ticks = 20
rules.countdown_ticks = 10
var loop: ServerLoop = _recorded(42, 3, rules)
var replay: MatchReplay = MatchReplay.new(loop.recorder)
assert_eq(replay.flow.phase, Match.LOBBY)
assert_true(replay.run_until(func() -> bool: return replay.flow.in_match()))
assert_eq(replay.ticks, 30)
assert_eq(replay.sim.tick, 0)
assert_true(replay.run_to_end())
assert_true(replay.verify()["ok"])
func test_a_replay_can_stop_partway() -> void:
var loop: ServerLoop = _recorded(41, 5)
var again: ServerLoop = ServerLoop.new(41, 1, 5)
again.play_humans_by_script()
for _index: int in 400:
again.run_tick()
var replay: MatchReplay = MatchReplay.new(loop.recorder)
assert_true(replay.run_until(func() -> bool: return replay.sim.tick >= 400))
assert_eq(replay.sim.tick, 400)
assert_eq(replay.sim.state_hash(), again.sim.state_hash(), "the replay passes through the same states")
func test_different_commands_give_a_different_match() -> void:
var loop: ServerLoop = _recorded(41, 5)
var silent: CommandLog = CommandLog.new(41, 1, loop.recorder.rules)
silent.final_tick = loop.recorder.final_tick
silent.final_hash = loop.recorder.final_hash
silent.winners = loop.recorder.winners
var replay: MatchReplay = MatchReplay.new(silent)
replay.run_to_end()
assert_false(replay.verify()["ok"], "nobody moving isn't the same match")
func test_bots_leave_the_simulations_random_streams_alone() -> void:
# A bot is a player: thinking must not change the simulation, or a replay with no
# bots thinking could never reach the same state.
var loop: ServerLoop = ServerLoop.new(9, 0, 8)
for _index: int in 900:
loop.run_tick()
assert_false(loop.sim.rng.stream_names().has("bots"))
func test_only_the_first_match_is_recorded() -> void:
var rules: MatchRules = ServerLoop.immediate_rules(0, 3)
rules.results_ticks = 2
var loop: ServerLoop = ServerLoop.new(5, 0, 3, rules)
var commands: CommandLog = loop.record_commands()
for bot: BotBrain in loop.bots.slice(1):
loop.sim.entities.find(bot.player_id).health = 0
loop.run_tick()
assert_false(commands.final_hash.is_empty())
var count: int = commands.count()
for _index: int in 30:
loop.run_tick()
assert_eq(loop.match_flow.matches_started, 2)
assert_eq(commands.count(), count, "the second match isn't added to the log")
+1
View File
@@ -0,0 +1 @@
uid://dt28p01xtfa12
+129
View File
@@ -0,0 +1,129 @@
## Plays one whole offline match, from the lobby to the results and back to the lobby:
## one scripted player and bots on a local server. Then saves the command log, reads it
## back, replays it with nobody thinking and checks the replay ends in the same state.
##
## tools/godot.sh --script res://tools/match.gd -- [--seed=N] [--bots=23]
## [--out=res://build/match/match.tclog]
##
## Prints one JSON object per line. Exits 1 on any script or engine error, if the match
## doesn't finish with a winner, or if the replay differs.
extends SceneTree
func _init() -> void:
var seed_value: int = 20261112
var bots: int = Tuning.SOLO_PLAYERS - 1
var out: String = "res://build/match/match.tclog"
for arg: String in OS.get_cmdline_user_args():
if arg.begins_with("--seed=") and arg.trim_prefix("--seed=").is_valid_int():
seed_value = arg.trim_prefix("--seed=").to_int()
elif arg.begins_with("--bots=") and arg.trim_prefix("--bots=").is_valid_int():
bots = clampi(arg.trim_prefix("--bots=").to_int(), 1, Tuning.SOLO_PLAYERS - 1)
elif arg.begins_with("--out="):
out = arg.trim_prefix("--out=")
else:
print("match FAIL: unknown argument '%s'" % arg)
quit(2)
return
var errors: ErrorCounter = ErrorCounter.new()
OS.add_logger(errors)
var problems: Array[String] = _play(seed_value, bots, out)
OS.remove_logger(errors)
if errors.count() > 0:
problems.append("%d script or engine errors, first: %s" % [errors.count(), errors.first()])
for problem: String in problems:
print("match FAIL: %s" % problem)
if problems.is_empty():
print("match: ok (lobby to results with no errors; the saved command log replays to the same state)")
quit(0 if problems.is_empty() else 1)
func _play(seed_value: int, bots: int, out: String) -> Array[String]:
var problems: Array[String] = []
var rules: MatchRules = MatchRules.new()
rules.max_players = 1 + bots
rules.min_players = 1
var loop: ServerLoop = ServerLoop.new(seed_value, 1, bots, rules)
loop.play_humans_by_script()
var commands: CommandLog = loop.record_commands()
commands.notes["bots"] = bots
var flow: Match = loop.match_flow
_log("start", seed_value, {"players": 1, "bots": bots, "phase": flow.phase_name(), "engine": Engine.get_version_info()["string"]})
var limit: int = rules.lobby_ticks + rules.countdown_ticks + rules.results_ticks + BotBatch.tick_limit()
var summary: Array[Dictionary] = []
var phases: Array[String] = [flow.phase_name()]
var player: ScriptedPlayer = null
var player_step: String = ""
var landed: bool = false
var back_in_lobby: bool = false
var sim: Simulation = loop.sim
while loop.ticks < limit and not back_in_lobby:
loop.run_tick()
for event: Dictionary in flow.events:
match event["type"]:
"phase":
phases.append(event["to"])
_log("phase", seed_value, {"tick": loop.ticks, "from": event["from"], "to": event["to"]})
back_in_lobby = event["from"] == "results"
"match_started":
player = loop.scripted[0] if not loop.scripted.is_empty() else null
sim = loop.sim
"placed":
if event["handle"] == 1:
_log("player_out", seed_value, {"sim_tick": event["tick"], "place": event["place"], "cause": event["cause"], "by": event["by"]})
"match_ended":
summary = flow.summary()
_log("ended", seed_value, {"sim_tick": sim.tick, "winners": event["winners"], "timed_out": event["timed_out"]})
if player != null and flow.in_match():
var me: SimEntity = sim.entities.find(player.player_id)
if me != null and not landed and me.drop_state == Drop.NONE:
landed = true
_log("player_landed", seed_value, {"sim_tick": sim.tick, "at": [snappedf(me.position.x, 0.1), snappedf(me.position.y, 0.1), snappedf(me.position.z, 0.1)]})
if player.step_name() != player_step:
player_step = player.step_name()
_log("player_script", seed_value, {"sim_tick": sim.tick, "step": player_step, "harvested": player.harvested, "built": player.built})
if not back_in_lobby:
problems.append("the match didn't get back to the lobby in %d ticks (phases: %s)" % [limit, phases])
for wanted: String in Match.PHASE_NAMES:
if not phases.has(wanted):
problems.append("the match never reached the %s phase" % wanted)
if commands.final_hash.is_empty():
problems.append("the match never ended")
return problems
if commands.winners.is_empty():
problems.append("the match ended with no winner")
for row: Dictionary in summary:
if row["place"] <= 3 or row["handle"] == 1:
_log("result", seed_value, row)
var stats: Dictionary = loop.timing_stats()
_log("timing", seed_value, stats)
if player != null:
_log("player", seed_value, {"harvested": player.harvested, "built": player.built, "script": player.step_name()})
var saved: Error = commands.save(out)
if saved != OK:
problems.append("couldn't save the command log to %s (error %d)" % [out, saved])
return problems
var loaded: CommandLog = CommandLog.load_from(out)
if loaded == null:
problems.append("the saved command log at %s can't be read back" % out)
return problems
var replay: MatchReplay = MatchReplay.new(loaded)
replay.run_to_end()
var verdict: Dictionary = replay.verify()
verdict["records"] = loaded.count()
verdict["file"] = out
verdict["bytes"] = FileAccess.get_file_as_bytes(out).size()
_log("replay", seed_value, verdict)
if not verdict["ok"]:
problems.append("the replay ended at tick %d with hash %s, the match at tick %d with %s" % [
verdict["tick"], verdict["hash"], verdict["expected_tick"], verdict["expected_hash"]])
return problems
func _log(event: String, seed_value: int, fields: Dictionary) -> void:
var record: Dictionary = {"event": event, "seed": seed_value}
record.merge(fields, false)
print(JSON.stringify(record))
+1
View File
@@ -0,0 +1 @@
uid://w4tmw68id3hg
Executable
+21
View File
@@ -0,0 +1,21 @@
#!/usr/bin/env bash
# Plays one whole offline match, lobby to results: one scripted player and 23 bots on
# a local server. Saves the command log to build/match/match.tclog, replays it and
# checks the replay ends in the same state. Prints one JSON line per event and the
# verdict. See tools/match.gd.
#
# tools/match.sh seed 2, where the scripted player also builds
# MATCH_SEED=7 tools/match.sh
set -uo pipefail
cd "$(dirname "${BASH_SOURCE[0]}")/.."
seed="${MATCH_SEED:-2}"
[[ "$seed" =~ ^[0-9]+$ ]] || { echo "match FAIL: bad MATCH_SEED '$seed'"; exit 2; }
raw="$(timeout --signal=KILL 900 nice -n 15 tools/godot.sh --script res://tools/match.gd -- --seed="$seed" 2>&1)"
code=$?
grep -E '^\{|^match' <<<"$raw"
if [[ "$code" -ne 0 ]] && ! grep -q '^match' <<<"$raw"; then
echo "match FAIL: the run exited $code"
tail -n 15 <<<"$raw"
fi
exit "$code"
+20
View File
@@ -0,0 +1,20 @@
#!/usr/bin/env bash
# Renders each stage of the match `make match` last played, from its command log, in
# the capture container: captures/match_<stage>.png. Needs Docker and
# build/match/match.tclog. Open the images and look at them.
set -uo pipefail
cd "$(dirname "${BASH_SOURCE[0]}")/.."
if [[ ! -f build/match/match.tclog ]]; then
echo "match-captures FAIL: no build/match/match.tclog; run 'make match' first"
exit 1
fi
status=0
for stage in lobby barge glide landed built final tide results; do
if ! tools/capture.sh "match_$stage" "captures/match_$stage.png"; then
echo "match-captures FAIL: stage $stage"
status=1
fi
done
[[ "$status" -eq 0 ]] && echo "match-captures: ok (8 stages in captures/match_*.png)"
exit "$status"