Island.generate(seed) builds a 513 x 513 heightfield (2 m spacing, the whole 1,024 m world) from the match seed's "worldgen" stream: a warped coastline, a coastal shelf and interior dome, two to four summits joined by ridges, rolling and rocky detail, and flattened marsh in wet lowland. Land is scaled so the tallest summit lands between ISLAND_PEAK_MIN and ISLAND_PEAK_MAX, under the last tide. Each sample gets an elevation band (sea, beach, marsh, forest, highland, summit) for terrain materials. - Simulation generates the island unless a test supplies its own ground, and spawns players on dry land until the drop arrives. - The headless server logs world_hash in its start line. - Island.heightmap_hash() is SHA-256 over millimetre heights and bands. - tools/island_map.gd draws a top-down map with tide contours. - New island constants in tuning.gd; GDD gains an island section. Tests: a 100-seed sweep checks generation time (slowest 617 ms against 5 s), land area, at least two distinct high points, walkable land, bands, and that no more than 3% of dry land is cut off at sea levels 0 and 8 m (worst seen 0.87%). A separate server process given only the seed must log the same heightmap hash. Closes #9 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
154 lines
6.0 KiB
GDScript
154 lines
6.0 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 a high bit of move_x in the middle of the log. The lowest bit is a 1/127 nudge
|
|
# of the stick, which moves an airborne player less than the hash's millimetre.
|
|
changed[changed.size() / 2 / PlayerCommand.ENCODED_SIZE * PlayerCommand.ENCODED_SIZE + 4] ^= 0x40
|
|
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, SimGround.flat())
|
|
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()
|