N6: Joining games: direct connect, LAN and server list

- LAN discovery: a listening server answers QUERY packets on its game port
  plus one (ServerBeacon, off with --no-lan). ServerBrowser scans eight game
  ports from 24650 by broadcast.
- A self-hostable list server: --list-server [--port=N] (ListServer,
  default UDP 24660). Game servers register with --list=HOST[:PORT] and
  --name=NAME; they are listed under their source address only after
  echoing a CHALLENGE token. Entries expire after 45 s, 8 per address,
  256 in all; every source is rate-limited (SourceLimiter).
- NetDiscovery messages: every QUERY is padded to 512 bytes and no answer
  is bigger, so neither service amplifies spoofed requests.
- tidewall --browse [--list=...] [--lan-target=IP] [--lan-port=N] prints
  the servers found as JSON until menus (A10) show them.
- People who connect mid-match or during results watch a living player
  (Match.watch) and take places ahead of bots in the next lobby, instead
  of being told the server is full. Bots fill only the places left when
  the match starts.
- Tests: codec round trips, size limits and a 40,000-message fuzz; list
  server with fake servers (challenge, stolen and wrong tokens, renewal,
  expiry, caps, flood); LAN scan over loopback; watchers over UDP; lobby
  backfill. make discovery-check runs it all as real processes.

Closes #37

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-12 17:33:32 -05:00
co-authored by Claude Opus 5.5
parent 53e81bebe1
commit f795ee3fa5
31 changed files with 1524 additions and 17 deletions
+13
View File
@@ -226,3 +226,16 @@ func test_restored_entities_keep_their_ids_and_their_order() -> void:
assert_eq(ids, [3, 5, 7, 12] as Array[int])
assert_eq(registry.find(3).archetype, SimEntity.ARCHETYPE_PICKUP)
assert_eq(registry.create(SimEntity.ARCHETYPE_PLAYER).id, 13, "new IDs carry on past the highest")
func test_browse_options() -> void:
var browse: ClientConfig = ClientConfig.parse(PackedStringArray(["--browse", "--list=192.0.2.4", "--lan-target=127.0.0.1", "--lan-port=30000", "--client-seconds=1"]))
assert_true(browse.is_valid(), str(browse.errors))
assert_true(browse.browse)
assert_true(browse.asked)
assert_eq(browse.lists, [{"host": "192.0.2.4", "port": NetDiscovery.DEFAULT_LIST_PORT}] as Array[Dictionary])
assert_eq(browse.lan_targets, ["127.0.0.1"] as Array[String])
assert_eq(browse.lan_port, 30000)
assert_eq(ClientConfig.parse(PackedStringArray(["--browse"])).lan_port, ServerConfig.DEFAULT_PORT)
assert_false(ClientConfig.parse(PackedStringArray(["--browse", "--lan-target=somewhere"])).is_valid())
assert_false(ClientConfig.parse(PackedStringArray(["--browse", "--connect=192.0.2.7"])).is_valid())
+140
View File
@@ -0,0 +1,140 @@
extends TestCase
## Issue N6: the discovery messages. Round trips, the rule that no answer is bigger
## than the query that asked for it, and malformed input refused without errors.
func _server(port: int = 24650, name: String = "Harbour Light") -> Dictionary:
return NetDiscovery.info(port, 3, 24, Match.PLAY, name)
func test_query_round_trip_and_padding() -> void:
var bytes: PackedByteArray = NetDiscovery.encode_query(7)
assert_eq(bytes.size(), NetDiscovery.QUERY_BYTES)
assert_eq(NetDiscovery.decode_query(bytes), {"version": NetProtocol.VERSION, "page": 7})
assert_eq(NetDiscovery.decode_query(bytes.slice(0, 64)), {}, "an unpadded query is refused")
func test_info_round_trip() -> void:
var server: Dictionary = _server()
var decoded: Dictionary = NetDiscovery.decode_info(NetDiscovery.encode_info(server))
assert_eq(decoded, server)
func test_register_and_challenge_round_trip() -> void:
var server: Dictionary = _server(24652)
var decoded: Dictionary = NetDiscovery.decode_register(NetDiscovery.encode_register(0xDEADBEEF, server))
assert_eq(decoded["token"], 0xDEADBEEF)
decoded.erase("token")
assert_eq(decoded, server)
assert_eq(NetDiscovery.decode_challenge(NetDiscovery.encode_challenge(42)), {"token": 42})
func test_list_round_trip() -> void:
var entries: Array[Dictionary] = []
for index: int in NetDiscovery.ENTRIES_PER_PAGE:
var entry: Dictionary = _server(24650 + index * 2, "Server %d" % index)
entry["address"] = "2001:db8::%d" % index if index % 2 == 0 else "192.0.2.%d" % (index + 1)
entries.append(entry)
var decoded: Dictionary = NetDiscovery.decode_list(NetDiscovery.encode_list(1, 3, entries))
assert_eq(decoded["page"], 1)
assert_eq(decoded["pages"], 3)
assert_eq(decoded["servers"], entries)
func test_no_answer_is_bigger_than_a_query() -> void:
# The longest possible names and addresses.
var long_name: String = "W".repeat(200)
var entries: Array[Dictionary] = []
for index: int in NetDiscovery.ENTRIES_PER_PAGE + 3:
var entry: Dictionary = NetDiscovery.info(65535, 255, 255, 255, long_name)
entry["address"] = "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"
entries.append(entry)
var list: PackedByteArray = NetDiscovery.encode_list(255, 255, entries)
assert_true(list.size() <= NetDiscovery.QUERY_BYTES, "a full page is %d bytes" % list.size())
# That longest address isn't one an IP check accepts; a full-length plain one is.
for entry: Dictionary in entries:
entry["address"] = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"
var decoded: Dictionary = NetDiscovery.decode_list(NetDiscovery.encode_list(255, 255, entries))
assert_eq((decoded.get("servers", []) as Array).size(), NetDiscovery.ENTRIES_PER_PAGE)
var info: PackedByteArray = NetDiscovery.encode_info(entries[0])
assert_true(info.size() <= NetDiscovery.QUERY_BYTES)
assert_true(NetDiscovery.encode_challenge(1).size() < NetDiscovery.encode_register(0, entries[0]).size(), "a challenge is smaller than what prompted it")
# Multi-byte names are cut on the byte limit too.
var wide: Dictionary = NetDiscovery.info(1, 0, 1, 0, "浪".repeat(40))
assert_true(String(wide["name"]).to_utf8_buffer().size() <= NetDiscovery.SERVER_NAME_MAX_BYTES)
func test_server_names_are_cleaned() -> void:
assert_eq(NetDiscovery.clean_server_name(" Harbour\u202E Light\t "), "Harbour Light")
assert_eq(NetDiscovery.clean_server_name(""), NetDiscovery.DEFAULT_SERVER_NAME)
assert_eq(NetDiscovery.clean_server_name("\u200B\u0007"), NetDiscovery.DEFAULT_SERVER_NAME)
assert_eq(NetDiscovery.clean_server_name("A".repeat(60)).length(), NetDiscovery.SERVER_NAME_MAX_CHARS)
func test_list_entries_with_bad_addresses_or_fields_are_refused() -> void:
var entry: Dictionary = _server()
entry["address"] = "192.0.2.1"
var good: PackedByteArray = NetDiscovery.encode_list(0, 1, [entry])
assert_false(NetDiscovery.decode_list(good).is_empty())
var bad_address: PackedByteArray = good.duplicate()
bad_address[9] = 0x2F # "/" in the address
assert_eq(NetDiscovery.decode_list(bad_address), {})
var trailing: PackedByteArray = good.duplicate()
trailing.append(0)
assert_eq(NetDiscovery.decode_list(trailing), {})
var crowded: Dictionary = NetDiscovery.info(24650, 30, 24, 0, "x")
assert_eq(NetDiscovery.decode_info(NetDiscovery.encode_info(crowded)).get("players", -1), 24, "clamped when made")
var raw: PackedByteArray = NetDiscovery.encode_info(_server())
raw[9] = 30 # more people than places
assert_eq(NetDiscovery.decode_info(raw), {})
raw = NetDiscovery.encode_info(_server())
raw.encode_u16(7, 0) # no game port
assert_eq(NetDiscovery.decode_info(raw), {})
## Random and mutated messages: every decoder and the list server's handler take them
## all without an engine error or growing without bound.
func test_fuzzed_messages_are_refused_quietly() -> void:
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
rng.seed = 612
var seeds: Array[PackedByteArray] = [
NetDiscovery.encode_query(), NetDiscovery.encode_info(_server()),
NetDiscovery.encode_register(9, _server()), NetDiscovery.encode_challenge(9),
]
var entry: Dictionary = _server()
entry["address"] = "198.51.100.4"
seeds.append(NetDiscovery.encode_list(0, 1, [entry, entry]))
var list: ListServer = ListServer.new()
list.limiter = SourceLimiter.new(1 << 30)
var accepted: int = 0
for round_index: int in 40000:
var bytes: PackedByteArray
if round_index % 4 == 0:
bytes = PackedByteArray()
bytes.resize(rng.randi_range(0, 600))
for index: int in bytes.size():
bytes[index] = rng.randi_range(0, 255)
else:
bytes = seeds[rng.randi_range(0, seeds.size() - 1)].duplicate()
for _flip: int in rng.randi_range(1, 4):
if bytes.is_empty():
break
match rng.randi_range(0, 2):
0:
bytes[rng.randi_range(0, bytes.size() - 1)] = rng.randi_range(0, 255)
1:
bytes.resize(rng.randi_range(0, bytes.size()))
2:
bytes.append(rng.randi_range(0, 255))
for decoded: Dictionary in [
NetDiscovery.decode_query(bytes), NetDiscovery.decode_info(bytes), NetDiscovery.decode_register(bytes),
NetDiscovery.decode_challenge(bytes), NetDiscovery.decode_list(bytes),
]:
if not decoded.is_empty():
accepted += 1
list.handle(bytes, "203.0.113.%d" % (round_index % 200), 40000 + round_index % 7, 0)
assert_true(accepted > 0, "some mutations are still valid messages")
assert_true(list.entry_count() <= ListServer.MAX_ENTRIES)
# Nothing registered without the token: a fuzzer can't guess it.
assert_eq(list.entry_count(), 0)
+1
View File
@@ -0,0 +1 @@
uid://cj6ax5huaigav
+185
View File
@@ -0,0 +1,185 @@
extends TestCase
## Issue N6: the list server, LAN discovery and the client's browser, over loopback
## UDP. The game servers here are fake: ServerBeacons, or raw sockets that misbehave.
const HOST: String = "127.0.0.1"
var list: ListServer
var browser: ServerBrowser
var beacons: Array[ServerBeacon] = []
var sockets: Array[PacketPeerUDP] = []
var clock: int = 1000
func before_each() -> void:
list = ListServer.new()
assert_eq(list.listen(0, HOST), OK)
browser = ServerBrowser.new()
assert_eq(browser.open(), OK)
beacons.clear()
sockets.clear()
clock = 1000
func after_each() -> void:
list.close()
browser.close()
for beacon: ServerBeacon in beacons:
beacon.close()
for socket: PacketPeerUDP in sockets:
socket.close()
func _beacon(name: String, game_port: int, players: int = 0, lan_port: int = 0) -> ServerBeacon:
var beacon: ServerBeacon = ServerBeacon.new()
beacon.server_name = name
beacon.game_port = game_port
beacon.players = players
assert_eq(beacon.open(lan_port if lan_port > 0 else ServerBeacon.ANY_PORT, HOST), OK)
beacons.append(beacon)
return beacon
## Polls everything until `done`, or real time runs out. The list server and beacons
## run on `clock`, which only moves when a test says so.
func _pump(done: Callable, limit_msec: int = 3000) -> bool:
var started: int = Time.get_ticks_msec()
while Time.get_ticks_msec() - started < limit_msec:
for beacon: ServerBeacon in beacons:
beacon.poll(clock)
list.poll(clock)
browser.poll()
if done.call():
return true
OS.delay_msec(2)
return bool(done.call())
func test_fake_servers_register_after_a_challenge_and_are_listed() -> void:
var names: Array[String] = []
# All from one address, so at most MAX_PER_ADDRESS of them.
var count: int = ListServer.MAX_PER_ADDRESS
for index: int in count + 1:
var beacon: ServerBeacon = _beacon("Fake %02d" % index, 30000 + index, index)
beacon.add_list(HOST, list.port())
if index < count:
names.append("Fake %02d" % index)
assert_true(_pump(func() -> bool: return list.entry_count() == index + 1), "%d listed" % list.entry_count())
_pump(func() -> bool: return false, 300)
assert_eq(list.entry_count(), count, "one more from the same address is refused")
browser.ask_list(HOST, list.port())
assert_true(_pump(func() -> bool: return browser.servers.size() == count), "%d found" % browser.servers.size())
var found: Array[String] = []
for server: Dictionary in browser.sorted():
found.append(String(server["name"]))
assert_eq(server["address"], HOST)
assert_eq(server["source"], "list")
assert_true(server["compatible"])
assert_eq(found[0], "Fake %02d" % (count - 1), "the busiest first")
found.sort()
assert_eq(found, names)
assert_true(list.queries_answered >= 2, "two pages of four")
func test_registrations_renew_and_silent_servers_expire() -> void:
var staying: ServerBeacon = _beacon("Staying", 30100)
staying.add_list(HOST, list.port())
var going: ServerBeacon = _beacon("Going", 30102)
going.add_list(HOST, list.port())
assert_true(_pump(func() -> bool: return list.entry_count() == 2))
going.close()
beacons.erase(going)
# Heartbeats keep the one still running listed well past the time limit.
staying.players = 5
for step: int in 4:
clock += ServerBeacon.HEARTBEAT_MSEC
var expected: int = staying.registrations + 1
assert_true(_pump(func() -> bool: return staying.registrations >= expected))
assert_true(_pump(func() -> bool:
var listed: Array[Dictionary] = list.servers()
return listed.size() >= 1 and int(listed[0]["players"]) == 5))
list.expire(clock)
assert_eq(list.entry_count(), 1)
assert_eq(String(list.servers()[0]["name"]), "Staying", "updates replace the entry")
func test_a_wrong_or_missing_token_is_never_listed() -> void:
var socket: PacketPeerUDP = PacketPeerUDP.new()
assert_eq(socket.bind(0, HOST), OK)
sockets.append(socket)
socket.set_dest_address(HOST, list.port())
# A server claiming a token it never got, and one ignoring its challenge.
socket.put_packet(NetDiscovery.encode_register(12345, NetDiscovery.info(30200, 0, 24, 0, "Liar")))
socket.put_packet(NetDiscovery.encode_register(0, NetDiscovery.info(30200, 0, 24, 0, "Liar")))
assert_true(_pump(func() -> bool: return socket.get_available_packet_count() >= 2))
assert_eq(list.entry_count(), 0)
var challenge: Dictionary = NetDiscovery.decode_challenge(socket.get_packet())
assert_false(challenge.is_empty())
# A token is bound to the address and port it was sent to.
var other: PacketPeerUDP = PacketPeerUDP.new()
assert_eq(other.bind(0, HOST), OK)
sockets.append(other)
other.set_dest_address(HOST, list.port())
other.put_packet(NetDiscovery.encode_register(int(challenge["token"]), NetDiscovery.info(30200, 0, 24, 0, "Thief")))
assert_true(_pump(func() -> bool: return other.get_available_packet_count() >= 1))
assert_eq(list.entry_count(), 0, "a token stolen by another socket doesn't work")
# The right socket echoing it is listed.
socket.put_packet(NetDiscovery.encode_register(int(challenge["token"]), NetDiscovery.info(30200, 0, 24, 0, "Honest")))
assert_true(_pump(func() -> bool: return list.entry_count() == 1))
assert_eq(String(list.servers()[0]["name"]), "Honest")
func test_limits_per_address_overall_and_per_second() -> void:
# Many fake servers from one address: only MAX_PER_ADDRESS are listed.
for index: int in ListServer.MAX_PER_ADDRESS + 4:
var port: int = 41000 + index
var token: int = list.token_for("192.0.2.9", port)
list.handle(NetDiscovery.encode_register(token, NetDiscovery.info(port, 0, 24, 0, "Crowd")), "192.0.2.9", port, clock + index * 100)
assert_eq(list.entry_count(), ListServer.MAX_PER_ADDRESS)
# Overall cap, from many addresses.
for index: int in ListServer.MAX_ENTRIES + 20:
var address: String = "198.51.%d.%d" % [index / 200, index % 200 + 1]
var token: int = list.token_for(address, 5000)
list.handle(NetDiscovery.encode_register(token, NetDiscovery.info(5000, 0, 24, 0, "Many")), address, 5000, clock + 5000 + index * 100)
assert_eq(list.entry_count(), ListServer.MAX_ENTRIES)
# A flood from one address within a second is mostly ignored. (Loopback, so
# the answers that do go out stay on this machine.)
var before: int = list.queries_answered
for _index: int in 500:
list.handle(NetDiscovery.encode_query(), "127.0.0.50", 9, clock + 100000)
assert_eq(list.queries_answered - before, list.limiter.per_window)
# Everything expires once nothing renews it.
list.expire(clock + 1000000)
assert_eq(list.entry_count(), 0)
func test_lan_scan_finds_servers_on_neighbouring_ports() -> void:
# Two servers on one machine, on the default port and the next one a scan asks.
var first_lan: int = 46001
_beacon("Quay", first_lan - 1, 2, first_lan)
_beacon("Breakwater", first_lan + 1, 7, first_lan + 2)
var targets: Array[String] = [HOST]
browser.scan_lan(targets, first_lan - 1)
assert_true(_pump(func() -> bool: return browser.servers.size() == 2), "%d found" % browser.servers.size())
var found: Array[Dictionary] = browser.sorted()
assert_eq(String(found[0]["name"]), "Breakwater")
assert_eq(found[0]["port"], first_lan + 1, "the game port, not the discovery port")
assert_eq(found[0]["players"], 7)
assert_eq(found[0]["source"], "lan")
assert_eq(String(found[1]["name"]), "Quay")
func test_a_beacon_ignores_challenges_it_did_not_ask_for_and_junk() -> void:
var beacon: ServerBeacon = _beacon("Quiet", 30300)
var socket: PacketPeerUDP = PacketPeerUDP.new()
assert_eq(socket.bind(0, HOST), OK)
sockets.append(socket)
socket.set_dest_address(HOST, beacon.port())
socket.put_packet(NetDiscovery.encode_challenge(77))
socket.put_packet(PackedByteArray([1, 2, 3]))
socket.put_packet(NetDiscovery.encode_query().slice(0, 40))
assert_true(_pump(func() -> bool: return beacon.ignored >= 3))
assert_eq(beacon.answered, 0)
assert_eq(beacon.registrations, 0)
assert_eq(socket.get_available_packet_count(), 0, "nothing was sent back")
+1
View File
@@ -0,0 +1 @@
uid://dhaq0b8hvhdcb
+29 -3
View File
@@ -155,15 +155,41 @@ func test_leaving_takes_the_player_out_of_the_match() -> void:
assert_eq(odo.state, NetClient.JOINED)
func test_a_full_match_turns_the_next_person_away() -> void:
func test_someone_arriving_mid_match_watches_a_living_player() -> void:
_client("Mara")
_client("Odo")
assert_true(_pump(func() -> bool: return loop.match_flow.in_match()))
# Bots filled the other two places, so there is no room until this match ends.
# Bots filled the other two places, so the newcomer watches until the next match.
var late: NetClient = _client("Late")
var late_index: int = clients.size() - 1
assert_true(_pump(func() -> bool: return late.state == NetClient.JOINED and receivers[late_index].own_id != 0), "the newcomer is sent someone to watch")
var flow: Match = loop.match_flow
assert_eq(flow.participants.size(), 4)
assert_true(flow.watchers.has(late.handle))
assert_false(flow.entity_of.has(late.handle), "a watcher has no player of their own")
var watched: int = receivers[late_index].own_id
assert_true(flow.handle_of.has(watched), "the snapshot follows a player in the match")
assert_false(flow.sim.entities.find(watched).eliminated)
assert_true(receivers[late_index].own.is_empty(), "nobody else's inventory is sent")
assert_eq(joined.size(), 3)
assert_true(bool(joined[2]["watching"]))
assert_eq(net.player_count(), 3)
# Leaving while watching is tidy.
late.leave()
assert_true(_pump(func() -> bool: return left.size() == 1))
assert_false(flow.watchers.has(late.handle))
assert_false(flow.spectating.has(late.handle))
assert_false(game.sender.has_client(late.handle))
func test_more_people_than_the_server_holds_are_turned_away() -> void:
net.max_players = 2
_client("Mara")
_client("Odo")
assert_true(_pump(func() -> bool: return net.player_count() == 2))
var late: NetClient = _client("Late")
assert_true(_pump(func() -> bool: return late.state == NetClient.CLOSED))
assert_eq(late.close_reason, NetProtocol.REASON_FULL)
assert_eq(loop.match_flow.participants.size(), 4)
assert_eq(net.player_count(), 2)
+23
View File
@@ -85,3 +85,26 @@ func test_ranges_are_checked() -> void:
assert_false(_parse(["--server", too_many]).is_valid())
var full: Array[String] = ["--server", "--players=4", "--bots=%d" % (Tuning.SOLO_PLAYERS - 4)]
assert_true(_parse(full).is_valid())
func test_discovery_options() -> void:
var config: ServerConfig = _parse([
"--server", "--listen", "--name= Harbour Light ", "--list=lists.example.org",
"--list=192.0.2.4:3000", "--list=[2001:db8::1]:4000", "--no-lan",
])
assert_true(config.is_valid(), str(config.errors))
assert_eq(config.server_name, "Harbour Light")
assert_false(config.lan)
assert_eq(config.lists, [
{"host": "lists.example.org", "port": NetDiscovery.DEFAULT_LIST_PORT},
{"host": "192.0.2.4", "port": 3000},
{"host": "2001:db8::1", "port": 4000},
] as Array[Dictionary])
assert_true(_parse(["--server", "--listen"]).lan, "LAN discovery is on by default")
func test_bad_discovery_options() -> void:
for wrong: String in ["--list=", "--list=host:", "--list=host:0", "--list=host:99999", "--list=[::1", "--list=[::1]x"]:
assert_false(_parse(["--server", "--listen", wrong]).is_valid(), wrong)
assert_false(_parse(["--server", "--list=192.0.2.4"]).is_valid(), "a list server needs --listen")
assert_false(_parse(["--server", "--no-lan"]).is_valid())
+68 -1
View File
@@ -199,17 +199,23 @@ func test_leaving_during_results_and_joining_during_a_match() -> void:
m.join(1)
m.join(2)
_until(m, Match.DROP)
assert_true(m.join(3), "a late joiner waits for the next match")
assert_false(m.join(3), "nobody joins a match under way")
assert_true(m.watch(3), "a late arrival watches and waits for the next match")
assert_false(m.watch(3), "once")
assert_false(m.watch(1), "a participant isn't a watcher")
assert_false(m.entity_of.has(3))
assert_true(m.spectate_target(3) in [1, 2], "they watch someone still standing")
assert_false(m.submit_command(3, PlayerCommand.new()))
_eliminate(m, 2)
m.step()
assert_eq(m.phase, Match.RESULTS)
assert_eq(m.winners, [1] as Array[int], "the late joiner isn't in this match")
assert_eq(m.spectate_target(3), 1, "during results they watch the winner")
m.leave(1)
assert_eq(m.winners, [1] as Array[int], "leaving during results keeps the result")
_until(m, Match.LOBBY)
assert_eq(m.participants, [2, 3] as Array[int])
assert_eq(m.watchers.size(), 0)
_until(m, Match.DROP)
assert_true(m.entity_of.has(3), "the late joiner plays the next match")
@@ -263,3 +269,64 @@ func test_ten_matches_in_a_row_start_clean() -> void:
assert_eq(m.entity_of.size(), 0)
assert_eq(seeds.size(), 10, "every match gets its own island")
assert_eq(m.match_seed(0), SEED, "the first match uses the server's seed")
func test_watch_is_only_for_a_match_under_way() -> void:
var m: Match = Match.new(SEED, _rules())
assert_false(m.watch(5), "in the lobby, people join")
m.join(1)
_until(m, Match.COUNTDOWN)
assert_false(m.watch(5), "the countdown still takes people")
assert_true(m.join(5))
func test_bots_backfill_around_people_joining_and_leaving_in_the_lobby() -> void:
var rules: MatchRules = _rules(6)
rules.min_players = 2
rules.lobby_ticks = 50
var m: Match = Match.new(SEED, rules)
m.join(1)
m.join(2)
m.join(3)
_steps(m, 5)
m.leave(2)
m.join(4)
m.leave(1)
m.join(5)
m.join(6)
assert_eq(m.phase, Match.LOBBY)
assert_eq(m.bot_handles.size(), 0, "no bots are added while people come and go")
_until(m, Match.DROP)
var people: Array[int] = []
for handle: int in m.participants:
if not m.bot_handles.has(handle):
people.append(handle)
people.sort()
assert_eq(people, [3, 4, 5, 6] as Array[int], "everyone still here has a place")
assert_eq(m.bot_handles.size(), 2, "bots fill exactly the places left")
assert_eq(m.participants.size(), 6)
for handle: int in people:
assert_true(m.entity_of.has(handle))
func test_watchers_take_places_ahead_of_bots_in_the_next_match() -> void:
var m: Match = Match.new(SEED, _rules(4))
m.join(1)
_until(m, Match.DROP)
assert_eq(m.bot_handles.size(), 3)
for handle: int in [7, 8, 9]:
assert_true(m.watch(handle))
m.leave(8)
assert_false(m.watchers.has(8))
for handle: int in m.participants.duplicate():
if handle != 1:
_eliminate(m, handle)
m.step()
assert_eq(m.phase, Match.RESULTS)
_until(m, Match.LOBBY)
assert_true(_saw(m, "joined"))
assert_eq(m.participants, [1, 7, 9] as Array[int], "watchers take places, bots are gone")
_until(m, Match.DROP)
assert_eq(m.bot_handles.size(), 1, "one bot fills the one empty place")
for handle: int in [1, 7, 9]:
assert_true(m.entity_of.has(handle))