BotBrain plays a match with the commands a player sends: it picks a landing marker near the barge's route, loots points of interest (following their own walking routes into huts, lofts and piers), fights opponents it can see, bandages itself, and gets to ground the coming tide will leave dry. BotWorld is the map every bot shares: loot markers, routes, and each tide phase's safe ground, which is the dry land joined to the island's highest walkable ground. Three difficulties (Tuning.BOT_DIFFICULTIES) set reaction time, sight range and aim error. The server mixes them unless --bot-difficulty says otherwise. NavGrid labels connected regions when it is built, so a goal that is cut off is turned down without a search of the whole island (about 70 ms each). make bot-matches plays 20 bot-only matches and checks winners, drownings and difficulty. Seeds 101 to 120: 20 of 20 with a winner, 7 of 460 deaths were drownings (1.5%), easy bots placed worst (13.7 against 11.8 and 12.0) and hard bots took the most eliminations (186 against 137 and 132). Closes #28 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
92 lines
3.5 KiB
GDScript
92 lines
3.5 KiB
GDScript
extends TestCase
|
|
|
|
|
|
func _run(match_seed: int, players: int, bots: int, ticks: int) -> ServerLoop:
|
|
var loop: ServerLoop = ServerLoop.new(match_seed, players, bots)
|
|
for _index: int in ticks:
|
|
loop.run_tick()
|
|
return loop
|
|
|
|
|
|
func test_creates_players_then_bots() -> void:
|
|
var loop: ServerLoop = ServerLoop.new(1, 2, 3)
|
|
var players: int = 0
|
|
for entity: SimEntity in loop.sim.entities.entities():
|
|
if entity.archetype == SimEntity.ARCHETYPE_PLAYER:
|
|
players += 1
|
|
assert_eq(players, 5)
|
|
assert_true(loop.sim.pickups.size() > 0, "the match's floor loot was placed")
|
|
assert_eq(loop.player_ids, [1, 2, 3, 4, 5] as Array[int])
|
|
assert_eq(loop.bots.size(), 3)
|
|
assert_eq(loop.bots[0].player_id, 3)
|
|
|
|
|
|
func test_records_one_timing_sample_per_tick() -> void:
|
|
var loop: ServerLoop = _run(7, 0, 4, 120)
|
|
assert_eq(loop.sim.tick, 120)
|
|
var stats: Dictionary = loop.timing_stats()
|
|
assert_eq(stats["ticks"], 120)
|
|
assert_true(stats["min_us"] <= stats["p50_us"])
|
|
assert_true(stats["p50_us"] <= stats["p95_us"])
|
|
assert_true(stats["p95_us"] <= stats["p99_us"])
|
|
assert_true(stats["p99_us"] <= stats["max_us"])
|
|
assert_eq(stats["budget_us"], ServerLoop.TICK_BUDGET_USEC)
|
|
|
|
|
|
func test_empty_stats() -> void:
|
|
assert_eq(ServerLoop.new(1, 0, 0).timing_stats(), {"ticks": 0})
|
|
|
|
|
|
func test_percentile_uses_nearest_rank() -> void:
|
|
var values: PackedInt64Array = PackedInt64Array(range(1, 101))
|
|
assert_eq(ServerLoop._percentile(values, 0.5), 50)
|
|
assert_eq(ServerLoop._percentile(values, 0.95), 95)
|
|
assert_eq(ServerLoop._percentile(values, 1.0), 100)
|
|
assert_eq(ServerLoop._percentile(PackedInt64Array([9]), 0.99), 9)
|
|
|
|
|
|
func test_bots_leap_and_humans_without_commands_stay_aboard() -> void:
|
|
# Every match starts on the drop carrier. A human who sends nothing rides it; the bot
|
|
# leaps at its own fixed moment and falls away.
|
|
var loop: ServerLoop = ServerLoop.new(99, 1, 1)
|
|
var human: SimEntity = loop.sim.entities.find(1)
|
|
var bot: SimEntity = loop.sim.entities.find(2)
|
|
assert_eq(human.drop_state, Drop.ABOARD)
|
|
assert_eq(bot.drop_state, Drop.ABOARD)
|
|
for _index: int in Tuning.TICK_RATE_HZ * 24:
|
|
loop.run_tick()
|
|
assert_eq(human.drop_state, Drop.ABOARD)
|
|
assert_true(human.position.distance_to(loop.sim.drop.barge_position(loop.sim.tick)) < 0.001)
|
|
assert_ne(bot.drop_state, Drop.ABOARD, "the bot should have leapt")
|
|
assert_true(bot.position.y < Tuning.BARGE_ALTITUDE - 20.0, "the bot should be falling, at %s" % bot.position)
|
|
|
|
|
|
func test_same_seed_gives_the_same_match() -> void:
|
|
var first: String = _run(2026, 2, 22, 300).sim.state_hash()
|
|
var second: String = _run(2026, 2, 22, 300).sim.state_hash()
|
|
assert_eq(first, second)
|
|
assert_ne(first, _run(2027, 2, 22, 300).sim.state_hash())
|
|
|
|
|
|
func test_server_returns_to_the_lobby_and_starts_the_next_match() -> void:
|
|
var rules: MatchRules = MatchRules.immediate()
|
|
rules.max_players = 3
|
|
rules.min_players = 0
|
|
rules.results_ticks = 3
|
|
var loop: ServerLoop = ServerLoop.new(5, 0, 3, rules)
|
|
assert_eq(loop.match_flow.phase, Match.DROP)
|
|
assert_eq(loop.bots.size(), 3)
|
|
var first_seed: int = loop.match_flow.current_seed()
|
|
for bot: BotBrain in loop.bots.slice(1):
|
|
loop.sim.entities.find(bot.player_id).health = 0
|
|
loop.run_tick()
|
|
assert_eq(loop.match_flow.phase, Match.RESULTS)
|
|
for _index: int in 4:
|
|
loop.run_tick()
|
|
assert_eq(loop.match_flow.phase, Match.DROP, "lobby and countdown pass at once")
|
|
assert_eq(loop.match_flow.matches_started, 2)
|
|
assert_ne(loop.match_flow.current_seed(), first_seed)
|
|
assert_eq(loop.bots.size(), 3, "bots are rebuilt for the new match")
|
|
assert_eq(loop.player_ids, [1, 2, 3] as Array[int])
|
|
assert_eq(loop.ticks, 5)
|