Files
tidewall/test/sim/test_simulation.gd
T
claudeandClaude Opus 5.5 27e08db51d F5: Simulation core and player command stream
Add the fixed-tick Simulation, the EntityRegistry with never-reused IDs, SimRng's named
seeded streams, and the 14-byte PlayerCommand used by humans, bots and the network.
state_hash is a SHA-256 over a canonical encoding of the state. Movement is a flat
placeholder until the v0.2 character controller. Tests replay a 24-player command log
over 10,000 ticks and scan src/sim for unseeded randomness and presentation code.

Closes #5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 17:16:03 -05:00

153 lines
5.8 KiB
GDScript

extends TestCase
const SEED: int = 123456789
const PLAYERS: int = Tuning.SOLO_PLAYERS
const TICKS: int = 10_000
func test_same_seed_and_log_produce_the_same_hash_over_ten_thousand_ticks() -> void:
var log_bytes: PackedByteArray = _build_command_log(SEED, PLAYERS, TICKS)
var first: String = _replay(SEED, log_bytes)
var second: String = _replay(SEED, log_bytes)
assert_eq(first, second)
assert_eq(first.length(), 64, "expected a SHA-256 hex digest")
func test_a_different_seed_changes_the_hash() -> void:
var log_bytes: PackedByteArray = _build_command_log(SEED, 4, 200)
assert_ne(_replay(SEED, log_bytes, 4), _replay(SEED + 1, log_bytes, 4))
func test_a_single_changed_command_changes_the_hash() -> void:
var log_bytes: PackedByteArray = _build_command_log(SEED, 4, 200)
var changed: PackedByteArray = log_bytes.duplicate()
# Flip one bit of move_x in the middle of the log.
changed[changed.size() / 2 / PlayerCommand.ENCODED_SIZE * PlayerCommand.ENCODED_SIZE + 4] ^= 1
assert_ne(_replay(SEED, log_bytes, 4), _replay(SEED, changed, 4))
func test_submission_order_across_players_does_not_matter() -> void:
var a: Simulation = _simulation(SEED, 2)
var b: Simulation = _simulation(SEED, 2)
var cmd_one: PlayerCommand = PlayerCommand.from_input(0, Vector2.RIGHT, 0.5, 0.0)
var cmd_two: PlayerCommand = PlayerCommand.from_input(0, Vector2.UP, 1.5, 0.0)
a.submit_command(1, cmd_one)
a.submit_command(2, cmd_two)
b.submit_command(2, cmd_two)
b.submit_command(1, cmd_one)
a.step()
b.step()
assert_eq(a.state_hash(), b.state_hash())
func test_missing_command_keeps_the_last_look_and_stops_moving() -> void:
var sim: Simulation = _simulation(SEED, 1)
sim.submit_command(1, PlayerCommand.from_input(0, Vector2(0.0, 1.0), 1.0, 0.25))
sim.step()
var player: SimEntity = sim.entities.find(1)
var yaw: int = player.yaw
var position: Vector3 = player.position
assert_ne(yaw, 0)
sim.step()
assert_eq(player.yaw, yaw)
assert_eq(player.position, position)
func test_movement_speed_matches_tuning() -> void:
var sim: Simulation = _simulation(SEED, 1)
var player: SimEntity = sim.entities.find(1)
# Start from the middle of the world so clamping can't interfere.
player.position = Vector3.ONE * 500.0
player.position.y = 0.0
var start: Vector3 = player.position
sim.submit_command(1, PlayerCommand.from_input(0, Vector2(0.0, 1.0), 0.0, 0.0))
sim.step()
assert_near(start.distance_to(player.position), Tuning.WALK_SPEED / Tuning.TICK_RATE_HZ, 0.001)
func test_stale_and_far_future_commands_are_rejected() -> void:
var sim: Simulation = _simulation(SEED, 1)
sim.step()
assert_false(sim.submit_command(1, PlayerCommand.from_input(0, Vector2.ZERO, 0.0, 0.0)))
var too_far: int = sim.tick + Tuning.MAX_COMMAND_LEAD_TICKS + 1
assert_false(sim.submit_command(1, PlayerCommand.from_input(too_far, Vector2.ZERO, 0.0, 0.0)))
assert_true(sim.submit_command(1, PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0)))
func test_commands_for_unknown_players_are_rejected() -> void:
var sim: Simulation = _simulation(SEED, 1)
assert_false(sim.submit_command(99, PlayerCommand.from_input(0, Vector2.ZERO, 0.0, 0.0)))
func test_removed_player_is_gone_and_id_is_not_reused() -> void:
var sim: Simulation = _simulation(SEED, 2)
sim.remove_player(1)
assert_false(sim.entities.contains(1))
assert_false(sim.submit_command(1, PlayerCommand.from_input(0, Vector2.ZERO, 0.0, 0.0)))
assert_eq(sim.add_player(), 3)
sim.step()
func test_positions_stay_inside_the_world() -> void:
var sim: Simulation = _simulation(SEED, 1)
var player: SimEntity = sim.entities.find(1)
player.position = Vector3(Tuning.WORLD_SIZE_METRES, 0.0, Tuning.WORLD_SIZE_METRES)
for at_tick: int in 30:
sim.submit_command(1, PlayerCommand.from_input(at_tick, Vector2(1.0, 1.0), 0.8, 0.0))
sim.step()
assert_true(player.position.x <= Tuning.WORLD_SIZE_METRES)
assert_true(player.position.z <= Tuning.WORLD_SIZE_METRES)
assert_true(player.position.x >= 0.0 and player.position.z >= 0.0)
func test_simulation_needs_no_scene_tree() -> void:
# Simulation is a plain object: it steps with no Node and no tree involved.
var sim: Variant = Simulation.new(SEED)
assert_false(sim is Node)
(sim as Simulation).add_player()
(sim as Simulation).step()
assert_eq((sim as Simulation).tick, 1)
func _simulation(match_seed: int, players: int) -> Simulation:
var sim: Simulation = Simulation.new(match_seed)
for _index: int in players:
sim.add_player()
return sim
## Builds a log of ticks * players encoded commands, in a compact byte array.
func _build_command_log(log_seed: int, players: int, ticks: int) -> PackedByteArray:
var random: RandomNumberGenerator = RandomNumberGenerator.new()
random.seed = log_seed
var bytes: PackedByteArray = PackedByteArray()
bytes.resize(players * ticks * PlayerCommand.ENCODED_SIZE)
var offset: int = 0
for at_tick: int in ticks:
for _player: int in players:
var command: PlayerCommand = PlayerCommand.new()
command.tick = at_tick
command.move_x = random.randi_range(-127, 127)
command.move_y = random.randi_range(-127, 127)
command.yaw = random.randi_range(0, 65535)
command.pitch = random.randi_range(-32767, 32767)
command.buttons = random.randi_range(0, 255)
var encoded: PackedByteArray = command.encode()
for index: int in encoded.size():
bytes[offset + index] = encoded[index]
offset += PlayerCommand.ENCODED_SIZE
return bytes
func _replay(match_seed: int, log_bytes: PackedByteArray, players: int = PLAYERS) -> String:
var sim: Simulation = _simulation(match_seed, players)
var per_tick: int = players * PlayerCommand.ENCODED_SIZE
var ticks: int = log_bytes.size() / per_tick
for at_tick: int in ticks:
for player: int in players:
var offset: int = at_tick * per_tick + player * PlayerCommand.ENCODED_SIZE
var command: PlayerCommand = PlayerCommand.decode(log_bytes, offset)
sim.submit_command(player + 1, command)
sim.step()
return sim.state_hash()