WIP: feat(coop): add consent-based player presence and isolated save playtests #355

Closed
mooki wants to merge 199 commits from mooki/Longshot:coop-playtest-r9 into main
Member

Type: feat · Risk: high · Tested on: Linux, RTX 4090 (two games on one PC); Windows 11, Intel Arc, with a Linux PC on one home network · Needs: Windows with other GPUs; a path through a real router or across the internet; a plain home network without a VPN; frame times with co-op off; a 30-minute session on this head; the outfit, Go to friend and the sword-practice kit in games on this head

Why

Friends who play together should be able to see one another in the game, agree on what their room shares, and try co-op on a copy of their save instead of risking their real one. This pull request is the whole experimental playtest line above pull request 68 (#68), which supplies the rooms and the relay. It is kept together so testers can use one matching build. This round shows what the other player wears on their body, and fixes the problems that testing of the last head found: Go to friend, the sword-practice kit, rooms after a relay restart, direct paths that read as silent, save backups, and a body that froze on a poor link. Direct connections between two players, added in the round before, keep the relay as the fallback.

The tracker was searched again on 15 November 2026 for co-op, multiplayer, relay, direct connection, NAT, port mapping, STUN, outfit, jitter and Go to friend. Two issues fit, and neither is closed by this pull request: #463 (co-op from playtest to merge) and #42 (one path for randomizers, restoration mods and co-op).

Work in progress. The head to test is 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (local branch name coop-playtest-r17-rc1, game version v3.0.0-rc.3-301-g257463464 when built from it). It sits directly on pull request 68's head 3320a841036f02484ae68c72f02b6f34928f776e, which sits on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c, with 171 commits above it: the last head, 5137c513ab1467df42d2ab8688ff25a850fe753c, had 116, and this one adds 55. Pull request 68's own 28 commits also show in this pull request's file list while 68 is not merged; its work is a dependency, not new work to review twice. Main has moved since: it is 1c91dafbd627026e59130d5c58290eb028a52348, 23 commits after 6c9edffe5da1f5b5383977aeab3f544c0de25d4c, when this was written, and a trial merge of this head into it gives 6 textual conflicts (gpu/vk/menu_i18n.h, gpu/vk/vk_api.h, host/hos_main.c, host/rx_backend.c, nx2/build.py, tests/test_prompt_skip.py), so this is not current main.

What changed

Pull request 68 supplies the relay, rooms, signed progress sync, backups and the Co-op tab. This line adds what lets friends see and agree: signed room rules and consent, the other players' bodies, temporary save copies and signed checkpoint transfer, chat, Go to friend and a sword-practice kit, and direct connections. All of it is opt-in: co-op is off until a player switches it on, and nothing a player has not accepted reaches their game.

  • Rules and consent: numbered signed room rules, a preview of the maker's terms and identities before a two-press Accept, and one owner for every change a room may make to a game. host/coop_state.c, host/coop_proto.c, host/coop_gameplay.h, host/oot_coop.c, host/coop_menu.c.
  • Bodies: the other players' child and adult bodies, with names, health, place and arrows towards friends, each separately permitted; positions go only to accepted members. New in this round: a body also wears the tunic, boots and mask its player wears (position message version 4; the receiving game asks its own game for each piece, at most four times). host/oot_coop_players.c, host/coop_players.c, host/coop_proto.c, nx2/coop_players_assets.py. Bodies and animations are built from each player's own game; none is distributed or sent.
  • Save safety: a temporary save copy (restart onto a working copy; Return never copies progress back) and signed checkpoint transfer to one consenting recipient (verified and stored, never loaded). host/coop_profile.c, host/nn_fs.c, host/coop_save.c, host/coop_save_runtime.c.
  • Playing together: room chat and notices (host/coop_chat.c, host/coop_chat_runtime.c), Go to friend (Kokiri Forest and Hyrule Field, same age; host/oot_coop_warp.c), a sword-practice kit on temporary copies only (host/oot_coop_kit.c).
  • Observation only: native hit and health observations, arena readiness and a duel ledger. Fighting stays disabled. host/oot_coop_hits.c, host/coop_duel.c, host/coop_arena.c.
  • The relay: a per-network budget for its answers and a bound on the removals a room keeps; both relays answer STUN on their own port. scripts/coop_relay.py, host/coop_relay.c.
  • Direct connections: libjuice 1.7.4 vendored unmodified (third_party/libjuice, MPL-2.0, with its PROVENANCE.md); the PATH message kind that carries addresses (host/coop_proto.c); the path layer that looks for a UDP path to each accepted member and watches it (host/coop_path.c: coop_paths_step, coop_paths_route; the libjuice side is host/coop_ice_juice.c). With coop_direct=on the session sends over a proven path and through the relay otherwise, waits 2 ms instead of 8 between steps while a pair is direct, and finds a path that is broken one way within the suspect time (host/coop.c). The Co-op tab gets a Direct connections row and a path word after each player's name (host/coop_menu.c, gpu/vk/vk_menu.cpp). A path is suspect after 1.5 seconds of silence and down after 4; the game then retries after 10, 30, 60 and 120 seconds, and a pair that has been direct for 60 seconds forgets its failed attempts.
  • Router port mapping (opt-in): the game asks the router's gateway for a 300-second lease for the hosted relay's port, and, new in this round, for the direct paths' UDP port, offering the answer to accepted friends as a candidate address. host/coop_portmap.c, host/coop.c.
  • Defaults moved: coop_players is on, so the other players are shown once co-op is on and the room permits it, and the body assets are indexed at start only when co-op is on. host/oot_coop_players.c, host/mods.c.
  • Interface and docs: gpu/vk/vk_api.h MKWVK_API_VERSION 23 to 30; docs/coop.md is the reference, with docs/development.md, README.md and CONTRIBUTING.md updated. 40 test files are new over pull request 68, among them eight fuzz harnesses for the network input (tests/fuzz/) with 150 small seed files.

New in this head over the last one (5137c513ab1467df42d2ab8688ff25a850fe753c), 55 commits:

  • A body wears the tunic, boots and mask its player wears; HOS_COOP_PLAYERS_OUTFIT=0 draws none.
  • Go to friend passes its safety check in a game with the debug options off (the normal setting), and after a map change it waits for the new map's own arrival before placing the player beside the friend.
  • The sword-practice kit waits for room in the game's flag queues instead of for empty ones, which the game never has.
  • A direct pair that has just been answered is no longer called silent (an unsigned time difference wrapped), and a pair that has been direct for a minute forgets its failed attempts.
  • A room made on the Co-op tab comes back after a relay restart, and a removal the relay would ignore is refused where it is asked instead of reported as done.
  • A save copy killed while the oldest backup is removed leaves only a .partial- folder, the restore command refuses a half-made copy, a temporary copy that is refused says why on the Co-op tab, and the Windows path check refuses a file with a second name, as Linux does.
  • With coop_portmap on, the router is also asked to map the direct paths' UDP port, and the answer is offered as a candidate address.
  • The other player's body follows the jitter of a link: its display delay moves between 100 and 250 ms, and a body is carried on for a moment when its poses run dry. HOS_COOP_POSE_TRACE writes a trace for measuring this.
  • The log says why another player's body is hidden: this game left the room, or the room's permission was withdrawn.
  • Eight fuzz harnesses for the network input, with their seed files; they found one latent fault in the product (a refused chat text left the caller's buffer unset), now fixed.
  • The co-op test programs that failed on Windows only now run there (direct paths, router mapping, the temporary-copy checks with a junction and a second name of a file).
  • third_party/libjuice/PROVENANCE.md now says the game links the library.

Measurements

Verdict: the functional checks pass on this head with the exceptions named under Testing: six two-game proofs, three direct-connection runs, and two sessions between a Linux PC and a Windows PC. The game-free suite on this exact head fails the same 12 tests as main and nothing else. The game runs were done on builds of 607c6384da2f7408414b2761da9ece16e3c4f653, the commit just before this head. The only difference between the two is one commit that changes one test file (tests/oot_coop_players_test.c); the game's source fingerprint is the same (5d118e2e), so the game built from either is the same game, but no build of this head itself was run. Nothing here measures speed: no frame rate or frame time was taken on this head, with co-op on or off.

Hardware: Linux 7.2.15, RTX 4090 with NVIDIA's driver, Core i9-13900K, 96 GB RAM (the proofs and direct runs); a Windows 11 laptop with Intel Arc graphics (the two-PC sessions)
Scene: Kokiri Forest and Link's house, child, from copies of test saves; two windowless games at 1280x720, frame generation off
Method: one whole game-free suite run on this head; six two-game proofs, each its own run with direct connections off (the default); three direct-connection runs on one PC; two sessions of 12.5 minutes on two PCs; every game's exit code, the kernel log, both complete game logs and every cited picture were checked
How to reproduce: build commit 2574634645ea0d7380171dd53c7ca6e410a9f7d8 from each player's own supported game, copy one test save per player, Make and Join a room and accept with the two-press confirmation; each proof's steps are in the results comment posted with this update

Before: main @ 6c9edffe5d After: this PR @ 2574634645
whole game-free suite (passed / failed / skipped) 552 / 12 / 16 603 / 12 / 16 (the same 12 fail)
six two-game proofs not run: co-op is not on main all six pass at the first attempt, on builds of 607c6384da2f7408414b2761da9ece16e3c4f653 (the transfer and the temporary-copy proofs had picture pauses of 1.0 to 5.6 seconds in their first runs and none in a second run of each)
direct-connection runs, one PC not run: no direct connections on main as written beforehand, except one clause (the second game's path kind was host/prflx, not host/host) and a blocked-path run that needed a second attempt after the PC itself stalled for seconds
two sessions, Linux PC and Windows PC not run each passed 31 of 32 written expectations; the other is the runner's own detector reading the new log line "direct for 60 s: the failed attempts before are forgotten" as an error because it contains "failed"
603 passed, 12 failed, 16 skipped in 253 s (linux, 6 at once)
FAIL  tests/test_lift_cleanup_error.py
FAIL  tests/test_make_game_cache.py
FAIL  tests/test_appimage_player_build.py
FAIL  tests/test_cpm_discovery.py
FAIL  tests/test_crash_dialog.py
FAIL  tests/test_env_on.py
FAIL  tests/test_linux_preflight.py
FAIL  tests/test_pipeline_tour.py
FAIL  tests/test_readback_late.py
FAIL  tests/test_vk_pgo.py
FAIL  tests/test_vram_budget_row.py
FAIL  tests/test_walk_key.py

After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (game runs on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, the same game source): two games before consent, after both accepted, and after Leave
After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (game runs on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, the same game source): standing, each player walking as the other game sees it, and presence turned off
After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (game runs on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, the same game source): the Linux game's Co-op tab with Direct connections on and a Windows laptop as the room's maker; the other player's line reads (maker, relay) while the direct path is down after a 5 second stop of the game, and (maker, direct) once it is back

Flags and settings

This PR adds the switches below, changes one (coop_portmap now also maps the direct paths' port), and sums up the others of its co-op line in the last row. Everything co-op stays off until a player switches it on. The jitter-following display delay has no switch. The full list with defaults is in docs/coop.md; the test switches are in docs/development.md, except the HOS_COOP_DIRECT* and HOS_COOP_STUN ones, which are in docs/coop.md only.

Flag What it is Before this PR After this PR Effect Helps / doesn't help / untested Recommendation
coop_direct / HOS_COOP_DIRECT, the Co-op tab's Direct connections row off, probe (look for a path and report it; every message still goes through the relay) or on (send over a proven path, the relay as the fallback). The row sets it in a running game; a set HOS_COOP_DIRECT holds it for the run absent off While it is not off, accepted friends are told this PC's addresses (LAN, VPN and the public one); the tab says so Helps: two games on one PC; two PCs on one home network (in the two sessions the data of five of the six direct paths ran over a VPN both PCs run, one over the home network). Untested: through a real router, across the internet, a plain home network with the VPN off, Windows with other GPUs off for now; on only for a test with a friend
coop_stun / HOS_COOP_STUN the STUN server the direct paths ask for this game's public address absent empty: the relay's own address read only when direct is not off Tested with a simulated router and the product's own STUN answer; untested with a real NAT leave empty
coop_direct_port / HOS_COOP_DIRECT_PORT the first of ten local UDP ports the direct paths use absent 24690 a firewall has to allow UDP 24690 to 24699 for a path over a plain home network A Windows rule for these ports was added for the two-PC sessions (one rule for each build's program); in the second session of this head the first direct path ran over the home network, so the rule carried traffic once; no other firewall was tried leave at the default
coop_direct_lan=0 / HOS_COOP_DIRECT_LAN=0 keep this PC's own addresses out of what accepted friends are told absent 1 (they are told) only the public address the STUN server reports is shared Used in the simulated-router run only leave at the default unless home addresses must stay private
HOS_COOP_DIRECT_DROP test only: throw away a share of the datagrams arriving over a direct path absent 0 none not for play leave unset
coop_portmap / HOS_COOP_PORTMAP (and test-only HOS_COOP_PORTMAP_TEST_GATEWAY) the player's opt-in to ask the router's gateway (PCP, then NAT-PMP) for a 300-second UDP lease: for the hosted relay's port while hosting, and, new in this round, with coop_direct on probe or on, for the direct paths' port while a pair is looked for; renewed while open and removed when the last path closes, on Leave or at exit absent off changes the router's state while it is on Relay port: tested against a made-up gateway on one PC, in three real-game runs on 12 November 2026 (rows in docs/tested/). Direct paths' port: game-free runs against a made-up gateway only (12 runs, including the game's own session and libjuice); no game was run with it on, and no real router off; on only for a player whose router speaks PCP or NAT-PMP
HOS_COOP_RELAY_STUN=0 the relay a maker hosts in the game answers STUN by default; this turns it off absent on needed for direct paths through the hosted relay Tested game-free and with libjuice's own client over loopback; no real NAT leave unset
the relay script's --network-replies and --room-removals (the in-game relay has the same limits at fixed values) answers a network may get from the relay, and removals a room keeps absent 20 answers a second after a burst of 100; 4096 removals a flood of CONNECTs is not answered; a room stops taking new members when its removal list is full Game-free tests on both relays and a flood over real sockets; no flood from a second PC to a running relay leave at the defaults
coop_players / HOS_COOP_PLAYERS=0 show the other players absent in pull request 68 on bodies appear only once co-op is on, the maker's signed presence rules allow them and the player accepted Six proofs with child bodies on this head; adult bodies were not shown in a game on this head on
HOS_COOP_PLAYERS_OUTFIT local development override: unset draws the tunic, boots and mask other players wear (once the equipment permission is signed); 0, off or false draws none, for before and after pictures absent on (unset) the other body wears what its player wears On the branch that made it (before it was merged here): the Zora tunic and cap seen on the other body in two pictures, boots and a mask asked for and live on the body in the logs but never legible in a picture, removal never run in a game. None of it in a game on this head leave unset
HOS_COOP_EQUIP_PROBE and HOS_COOP_POSE_TRACE diagnostics, unset: the first logs what a game's Link and each body's equipment hold (with HOS_COOP_TRACE=1); the second writes a bounded binary trace (48 MiB at most) of Link, the poses sent and received and where each body was drawn, for measuring jank absent unset none while unset (the pose trace costs one flag test) the equipment probe ran in games on the branch that made it; the pose trace ran in two live games on its branch and a game with it set draws the same bodies as one without (game-free test, to the bit) leave unset
the other settings of this line: coop_presence_permissions, coop_names, coop_labels, coop_warp, coop_social_permissions, coop_notices, coop_hit_events, coop_loadout_*, coop_pvp_*, coop_duel_*, coop_arena*, coop_room_mode, the chat key, and the test-only HOS_COOP_ACCEPT, HOS_COOP_ARENA_FILE, HOS_COOP_AUTO, HOS_COOP_HITS_TRACE, HOS_COOP_PLAYERS_ACTOR, HOS_COOP_PLAYERS_ANIM, HOS_COOP_PLAYERS_TEST, HOS_COOP_PROFILE_TICKET and HOS_COOP_TRACE the permissions, display choices and test aids of the rules, bodies, chat, travel, kit and observation pieces absent off, except names on, labels on (Names), notices on (everything) and the chat key T none until a room's maker signs the matching permission The proofs use child bodies only; adult bodies and gear, arrows, the kit and fighting were not run on this head leave at the defaults

Pull request 68's own switches (HOS_COOP_HOST, HOS_COOP_SERVER, HOS_COOP_NAME, HOS_COOP_PROGRESS, HOS_COOP_ITEMS, HOS_COOP_KEYS, HOS_COOP_RUPEES, HOS_COOP_AMMO, HOS_COOP_SONGS, HOS_COOP_QUEST, HOS_COOP_ROOM, HOS_COOP_DROP, HOS_COOP_DEMO, HOS_COOP_PROBE and HOS_COOP_TEST_SET) are not repeated here. Existing development switches this line touches: HOS_OOT_TELEPORT_EVENT and HOS_OOT_TELEPORT_STARTER (Go to friend refuses while either is set) and RX_VK_MENU_SCRIPT (a diagnostic entry into the chat field).

Testing

Tested:

  • The whole game-free suite, once, on the exact head: 603 passed, 12 failed, 16 skipped. The same 12 fail on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c (552 / 12 / 16) and on pull request 68's head 3320a841036f02484ae68c72f02b6f34928f776e (563 / 12 / 16); none touches co-op. No test that passes there fails here, and 40 more test files pass than on 68's head. On the commit before this head the same suite gave 602 / 13 / 16: the extra failure was tests/test_coop_players.py at one check of the outfit receiver, a step that waited a fixed 232 ms while the body's display delay can reach 250 ms. That is a fault of the test (a regular stream at the product's rate keeps the delay at 100 ms, which the link test shows); this head's one new commit makes the step wait for the condition, and the test passes with GCC and Clang with all 19 of its mutations failing as they must.
  • The commit before this head (same game source) built for Linux (the title screen was reached after 270.5 seconds of shader preparation) and cross-built for Windows (697 compile commands, none failed, linked); the Windows build started to its title screen and ran in the two-PC sessions. A Windows-target syntax check of the changed test files found 0 failures; Windows execution of the tests was not part of it.
  • Six two-game proofs on one Linux PC (RTX 4090), direct connections off: signed checkpoint transfer with a partial cancel, consent and Leave, temporary copy with autosave and Return, signed terms with a stale confirmation, standing and walking bodies, and five sword swings with the damage counters. All six passed at the first attempt, and every result line equals the last head's (the maker's key and the five swing counts apart); only the log's text for the reason a body is hidden changed, on purpose. Both complete logs of every game were read for unexpected body removal. The transfer and temporary-copy proofs showed picture pauses of 1.0 to 5.6 seconds in their first runs (for the transfer proof in the same 14 seconds in which another job on the PC was copying the game's 187,000 files; for the copy proof no cause was found); a second run of each passed with no pause. The details are in the results comment posted with this update.
  • Three direct-connection runs of two games on one PC: coop_direct=on (a pair proved at once, the relay then forwarding nothing and receiving only its keep-alives); a path blocked in the middle of a session, both ways and then one way, through a program that pretends to be a router (down within 4 seconds, the relay carrying the game again, direct again after 10 and 30 seconds, no body hidden; timings within 0.4 seconds of the last head's); and probe mode, where the one expectation that failed on the last head, a flap at 200 seconds, did not occur in 265 seconds. One clean run does not show that a flap seen once is gone.
  • Two sessions of 12.5 minutes each between a Linux PC and a Windows 11 laptop on one home network, direct on, a relay on a third PC: direct at once, a 5 second stop of the Linux game, the Direct connections row set Off and On from the tab, chat each way in every phase (seven lines, all delivered), one body per player, both exits 0, saves unchanged. The short "not answered for 1.5 seconds, then direct again" lines that the last head's session had (7 in 12 minutes) did not occur (0 in either session); two sessions do not show that the unsigned wrap fixed here was their only cause. The path word after the other player's name was pictured in every phase in the second session (direct, relay after the stop, direct, no word while the row is Off, relay until the retry, direct). The direct data ran over the VPN both PCs run in the first session; in the second, the first path ran over the home network and the next two over the VPN. A new Windows firewall rule was needed for the new Windows folder.
  • Each fix of this round has game-free tests written first that failed before it (red runs kept in the reports): a room after a relay restart, a refused removal, a save copy killed at each of 92 kill points and at 480 random moments (0 left a half copy under a numbered name; the last head left one at 40 of 90 points and 22 of 480 kills), the restore command's refusal of a half-made copy, the kit's queue gate (10 mutations of its test caught), the direct pair's wrap and failure count, the Windows second-name check, the position message version 4, and Go to friend's arrival wait (15 mutations of its test caught). The pose delay was run on a recording of a real two-game session and in two live games through a link simulator (on the Wi-Fi-like link the share of moving frames in which the body stood still fell from 15.4 to 0.1 percent, on the bad link from 50.1 to 0.1; on a clean link the delay stayed at 100 ms in every frame; 4 and 1 one-frame jumps remained); one session per link, not a real network.
  • On the branches that made the fixes, in builds of those branches before they were merged here: Go to friend passed its safety check in every ask in two real games; the arrival after a map change landed 1.21 to 1.25 m from the friend in four real games (Hyrule Field and Kokiri Forest, adult and child), where the game's own arrival had left the player 74 to 195 m away; the other body wore the Zora tunic and cap in a picture (the same body bare with HOS_COOP_PLAYERS_OUTFIT=0); boots and a mask were asked for once and live on the body in the logs, never legible in a picture. The same fixes are in this head, whose game-free tests for them pass; none was repeated in a game on this head.
  • Eight fuzz harnesses for the network input (wire, session, events, sync state, path layer, relay, checkpoint transfer, chat) under address and undefined-behaviour checkers: they found one latent fault in the product while they were built (a refused chat text left the caller's buffer unset), fixed with a regression test; the two failures of the first 1,000 second campaign and three more in later 20-minute runs were in the harnesses' own checks, fixed with a minimised input kept for each. The last 20-minute runs of the session, events and state harnesses on the final fuzz head were clean; the path, relay and save harnesses were not rerun after the harness fixes (their sources did not change), and the wire and chat harnesses were not in the long runs.
  • The co-op and networking test programs ran natively on the Windows laptop: 11 of 13 passed at the last head. After their fixes, at later commits, the router-mapping and temporary-copy programs pass there (the temporary-copy one now refuses a file with a second name: before the fix a write through such a name changed the other file, as the test program showed), and 10 of 12 direct-path runs passed, the two others being a relay lost under 30 percent datagram loss and a relay that did not start. This head's Windows build was not used for them.
  • On the last head, in Windows games: a Windows joiner and a Linux maker exchanged signed checkpoints both ways (72 checks, none failed); a Windows game alone made a temporary copy, saved a change only in the copy and returned to its normal saves with Return (45 checks passed, 1 failed: the designed check that found the second-name leftover, fixed since). Not repeated on this head.
  • Earlier heads, kept with their heads (game code before direct connections): a 30-minute two-game session passed every rule written beforehand at 9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca (#355 (comment)) and, with co-op off, the frame time against its base was inside the noise in one scene (#355 (comment)). Two earlier long sessions each failed one rule (#355 (comment) and #355 (comment)); those stay failures. A Windows tester's two-GPU session and a two-PC session at that head: #355 (comment) and #355 (comment).
  • One test was flaky: tests/test_coop_direct.py failed 3 of 10 solo runs on the integration branch that held the last head plus the first fixes, with other work running on the PC. Four causes were found: bounds that failed by chance on correct code (computed: about 1 percent of runs for one bound, 12 percent for another), timings that made a pair rejoin under 30 percent loss, the unsigned wrap above, and a pair that had failed five times never trying again. It has passed the whole suite on this head and on the commit before it; on an earlier integration it passed 5 of 5 solo runs and the focused lists with GCC and Clang. Five runs do not prove the flake gone.

Not tested: a 30-minute session on this head and the frame time with co-op off or on (the last runs are at the earlier head above); a build of this exact head in a game (the commit before it, with the same game source, was the one run); direct connections through a real router, across the internet or on a plain home network with the VPN off; router port mapping with a real router, and any game run with the mapping of the direct paths' port on (game-free runs against a made-up gateway only); the relays' STUN answers against a real NAT (the home relay used in the two-PC sessions answers STUN since the morning of the runs, with its own limits on open rooms; the answers were not checked against a real NAT); the path word for a joiner in the maker's list, which no picture reached (the maker's list is below the last visible row of the menu at 1280x720 and a windowless picture does not scroll; the menu was not changed); Windows with a GPU other than Intel Arc; AMD GPUs and the Steam Deck; a physical controller and typing; on this head in a game: the outfit, Go to friend, the sword-practice kit (its new queue gate has not been shown in any game), a room coming back after a relay restart and the delay that follows jitter on a real network; Copy and Return in a Windows game on this head's build and UTF-8 paths on Windows (a file with a non-ASCII name inside a save was copied correctly in a Windows game of the last head, but not a non-ASCII install or user folder); adult bodies and gear, health, place and arrows, more than two players, sword contact and fighting. A game frozen for more than about 10 seconds still loses the other player's body until it recovers (stop cases at #355 (comment), taken on an earlier head, not repeated). The problems found in the last head and where they stand in this one are in the comment posted with this update.

Must be tested:

  • Two PCs with a router between them (Windows 11 and Linux, any GPU): the maker hosts with the port forwarded or with coop_portmap on, both set the Direct connections row to Direct, accept, walk and chat, expecting a direct (...) line in each game's log or, if no path is found, the path word reading relay with play unaffected, and no body removed (by hand: the two players, with both logs)
  • A plain home network, VPN off (Windows 11 and Linux, UDP 24690 to 24699 allowed on the firewall): the same steps, expecting direct (host/host) and the relay's traffic falling to its keep-alives (by hand: a person, with the log and the network counters)
  • Two games for 30 minutes, once with direct on and once off (Linux, one PC or two): stand, walk and chat, expecting no unexpected body removal, no retries and unchanged saves, as in #355 (comment) (by hand: a person reads both complete logs)
  • Frame time with co-op off, main against this head (Linux, any GPU): four interleaved runs of the same walk, expecting a difference inside the noise, as in #355 (comment) (by hand: the method of that comment)
  • Two games on one Linux PC with the debug options off, a friend in another map: ask Go to friend from Kokiri Forest and from Hyrule Field, expecting "Arrived near your friend." about 1 to 2 m from the friend and no "did not keep the arrival position" line (by hand: a person looks at both screens and reads the log)
  • Linux, two games on one PC, equipment permission signed: one player wears a different tunic, boots or mask (a child's mask for a child), expecting the other game's body to wear them, nothing asked for more than four times, and the pieces gone when the player takes them off (by hand: pictures of the body from the front, and the log's request: taken lines)
  • Two temporary copies with the sword-practice kit on (Linux, one PC): expecting "sword practice ready" with the Master Sword and Hylian Shield worn on both, and no refusal (by hand: a person reads the log; this is the first run of the new queue gate in a game)
  • Windows 11 with another GPU and a physical controller: Make, Join, Accept, bodies, chat, then a temporary copy and Return, expecting what the Linux proofs show (by hand: pictures and logs). The earlier test requests for this pull request (T-ADK4, T-QF6F and T-KQUM) were pinned to an earlier head and would need pinning to this one

Risks

What could break: a large change across save handling, permissions, networking, input, generated presentation and the host and renderer interface. A permission or path mistake could affect a save; a wrong body lifetime could leave a wrong actor; stale input could turn a chat key into a game action; network loss or the host leaving ends the room. With direct connections on, the friends a player accepted are told this PC's addresses (the tab says so); a router port mapping changes the router's state, now also for the direct paths' port; the relays answer STUN. A direct path that breaks falls back to the relay, as tested on one PC and between two. New in this round: a body asks its own game for each piece of the other player's outfit (at most four times a piece, then it gives up) and a wrong piece number could draw a wrong item; the display delay of the other body follows the jitter of a link, so on a poor link it is drawn later (on the simulated bad link its median moved from 186 to 268 ms behind the real moment; a clean link stays at 100 ms) and a body is carried on for a moment when its poses run dry, which caused 4 and 1 one-frame jumps of 0.34 to 0.54 m in the live runs; the sword-practice kit's changed queue gate has not been shown in a game and the kit changes live equipment on a temporary copy; a room made on the Co-op tab is made again by its maker after a relay restart and waited for two minutes by the others. Whoever holds a room's secret can lie about poses or chat; this is not an anti-cheat system. A verified checkpoint hash proves its bytes, not that an untrusted save is safe for the game's parser. The game writes its own saves in place, so a game killed in the middle of its own autosave can leave a torn save (shown once, by killing a game at its first write; not co-op code, and no fix is in this head); the copy made when a room is accepted is what lets a player go back.

Turning it off: leave the room or set coop=0 (HOS_COOP=0); the Direct connections row at Off (coop_direct=off) keeps every message on the relay; coop_portmap=0 stops the router request; coop_players=0 removes the bodies; HOS_COOP_PLAYERS_OUTFIT=0 draws no outfit; coop_host=0 stops hosting; reverting the pull request removes all of it (the jitter-following delay has no switch). Turning co-op off cannot undo progress already merged into an ordinary save, so use a separate --user root from the first launch with a copy of your own saves, and never copy a test save back into the usual folder.

Compatibility: nothing changes for a player who never switches co-op on, except that coop_players now defaults to on and does nothing without a room. Both players need the same build: the position message is version 4 in this head, so a game of an earlier head does not show a body of this one or get one shown, and other messages changed between heads, so two builds may fail to join or not show each other. MKWVK_API_VERSION goes from 23 to 30, so a game and a renderer built from different commits will not match. Saves are not changed unless a room is accepted after a backup, and a temporary copy never copies progress back.

Issues

See #68 for the co-op base and the earlier proof discussion.
See #463 for co-op from playtest to merge.
See #42 for the unresolved core and module direction.

Checklist

Everyone

  • One topic.
    164 of the 171 commits are scoped to co-op; the other seven are a fixture, a translation-order fix, a build label, a menu test, a docs line, the libjuice provenance line and the restore script's refusal of a half-made copy, all of which the line needed.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched).
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
    This head sits on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c through pull request 68; main is now at 1c91dafbd627026e59130d5c58290eb028a52348, and a trial merge gives 6 textual conflicts (listed under Why).
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named).
    On this head: 603 passed, 12 failed, 16 skipped. The 12 failures are listed under Measurements and fail the same way on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c.
  • No game files, dumps, build output or generated files.
    Checked by file list against main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c: 414 files; the added files are C and C++ sources and headers, Python, Markdown, one text file of test vectors and 150 small binary seed files (11,823 bytes in all) of the fuzz tests under tests/fuzz/corpus. The seeds are written by tests/fuzz/make_seeds.py from the test vectors and a few hand-made inputs, and the fuzz test checks that they equal what it writes; they hold no game data and are committed because the test fails in a clean checkout without them.
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
    Against main, 51 files under third_party/ are added and none changed or deleted: monocypher (4 files, from pull request 68) and libjuice (47, with its PROVENANCE.md, whose text this round corrects to say the game links the library).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled.
    libjuice is MPL-2.0 and unmodified; its notices carry no "Incompatible With Secondary Licenses" marker, so it can be combined with this GPL-3.0-or-later program (third_party/libjuice/PROVENANCE.md). The review of the line's own source was done at an earlier head and not repeated for the 171 commits above pull request 68's head.

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
    All 171 commits above pull request 68's head carry both.
  • Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value.
    The HOS_COOP_PLAYERS_OUTFIT, HOS_COOP_EQUIP_PROBE, HOS_COOP_POSE_TRACE, HOS_COOP_RELAY_STUN, HOS_COOP_PORTMAP and HOS_COOP_PLAYERS rows are in docs/development.md; the HOS_COOP_DIRECT, HOS_COOP_DIRECT_LAN, HOS_COOP_DIRECT_PORT, HOS_COOP_DIRECT_DROP and HOS_COOP_STUN rows are in docs/coop.md only.
  • Screenshots of the same spot, captioned like the Measurements columns, for a change that shows on screen.
    Three pictures under Measurements, each captioned with this head's commit and saying that the game runs were on the build of the commit before it.
  • MKWVK_API_VERSION bumped (gpu/vk/vk_api.h's MkwVkHost or MkwVkRenderer changed).
    22 on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c, 23 on pull request 68's head and on current main, 30 here; the number will need renumbering when this is carried onto current main.
  • A game-free test added for the fix, failing on main and passing here.
    The new tests were written first and failed before their code (the path layer, the direct runs, the relay limits and STUN, the players default and the asset index, and in this round the soak and room recovery, the save copy kill points, the restore refusal, the kit gate, the pair's wrap and failure count, the Windows second-name check, position message version 4, the arrival wait and the jitter delay); the whole suite passes them here.
  • A check under tests/ that reads changed source updated in this PR, not weakened.
    The checks of this round were changed together with the code they read (position message version 4, the display delay, the arrival wait, the kit gate, the removal rule), but the direct test's fixed bounds on loss counts were loosened on purpose to bounds computed from the binomial law, because the old ones failed by chance on correct code (about 1 percent of runs for one bound, 12 percent for another, computed in the reports); the mutation runs written to show that the direct test still fails when the code is wrong are not part of a finished report. A reviewer should read the diff of tests/coop_direct_test.c.
  • Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths.
    The commit before this head (same game source) built on Linux and cross-built for Windows without a failure and ran on both; this exact head was not built, and UTF-8 runtime paths on Windows were not exercised on this head.
  • Docs updated.
    docs/coop.md, docs/development.md, docs/control.md, README.md and CONTRIBUTING.md.

New on this forge; not opened on GitHub.

**Type:** feat · **Risk:** high · **Tested on:** Linux, RTX 4090 (two games on one PC); Windows 11, Intel Arc, with a Linux PC on one home network · **Needs:** Windows with other GPUs; a path through a real router or across the internet; a plain home network without a VPN; frame times with co-op off; a 30-minute session on this head; the outfit, Go to friend and the sword-practice kit in games on this head ## Why Friends who play together should be able to see one another in the game, agree on what their room shares, and try co-op on a copy of their save instead of risking their real one. This pull request is the whole experimental playtest line above pull request 68 (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/68), which supplies the rooms and the relay. It is kept together so testers can use one matching build. This round shows what the other player wears on their body, and fixes the problems that testing of the last head found: Go to friend, the sword-practice kit, rooms after a relay restart, direct paths that read as silent, save backups, and a body that froze on a poor link. Direct connections between two players, added in the round before, keep the relay as the fallback. The tracker was searched again on 15 November 2026 for co-op, multiplayer, relay, direct connection, NAT, port mapping, STUN, outfit, jitter and Go to friend. Two issues fit, and neither is closed by this pull request: https://git.magicbean.dev/MagicBeanDev/Longshot/issues/463 (co-op from playtest to merge) and https://git.magicbean.dev/MagicBeanDev/Longshot/issues/42 (one path for randomizers, restoration mods and co-op). **Work in progress.** The head to test is `2574634645ea0d7380171dd53c7ca6e410a9f7d8` (local branch name `coop-playtest-r17-rc1`, game version `v3.0.0-rc.3-301-g257463464` when built from it). It sits directly on pull request 68's head `3320a841036f02484ae68c72f02b6f34928f776e`, which sits on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c`, with 171 commits above it: the last head, `5137c513ab1467df42d2ab8688ff25a850fe753c`, had 116, and this one adds 55. Pull request 68's own 28 commits also show in this pull request's file list while 68 is not merged; its work is a dependency, not new work to review twice. Main has moved since: it is `1c91dafbd627026e59130d5c58290eb028a52348`, 23 commits after `6c9edffe5da1f5b5383977aeab3f544c0de25d4c`, when this was written, and a trial merge of this head into it gives 6 textual conflicts (`gpu/vk/menu_i18n.h`, `gpu/vk/vk_api.h`, `host/hos_main.c`, `host/rx_backend.c`, `nx2/build.py`, `tests/test_prompt_skip.py`), so this is not current main. ## What changed Pull request 68 supplies the relay, rooms, signed progress sync, backups and the Co-op tab. This line adds what lets friends see and agree: signed room rules and consent, the other players' bodies, temporary save copies and signed checkpoint transfer, chat, Go to friend and a sword-practice kit, and direct connections. All of it is opt-in: co-op is off until a player switches it on, and nothing a player has not accepted reaches their game. - Rules and consent: numbered signed room rules, a preview of the maker's terms and identities before a two-press Accept, and one owner for every change a room may make to a game. `host/coop_state.c`, `host/coop_proto.c`, `host/coop_gameplay.h`, `host/oot_coop.c`, `host/coop_menu.c`. - Bodies: the other players' child and adult bodies, with names, health, place and arrows towards friends, each separately permitted; positions go only to accepted members. New in this round: a body also wears the tunic, boots and mask its player wears (position message version 4; the receiving game asks its own game for each piece, at most four times). `host/oot_coop_players.c`, `host/coop_players.c`, `host/coop_proto.c`, `nx2/coop_players_assets.py`. Bodies and animations are built from each player's own game; none is distributed or sent. - Save safety: a temporary save copy (restart onto a working copy; Return never copies progress back) and signed checkpoint transfer to one consenting recipient (verified and stored, never loaded). `host/coop_profile.c`, `host/nn_fs.c`, `host/coop_save.c`, `host/coop_save_runtime.c`. - Playing together: room chat and notices (`host/coop_chat.c`, `host/coop_chat_runtime.c`), Go to friend (Kokiri Forest and Hyrule Field, same age; `host/oot_coop_warp.c`), a sword-practice kit on temporary copies only (`host/oot_coop_kit.c`). - Observation only: native hit and health observations, arena readiness and a duel ledger. Fighting stays disabled. `host/oot_coop_hits.c`, `host/coop_duel.c`, `host/coop_arena.c`. - The relay: a per-network budget for its answers and a bound on the removals a room keeps; both relays answer STUN on their own port. `scripts/coop_relay.py`, `host/coop_relay.c`. - Direct connections: libjuice 1.7.4 vendored unmodified (`third_party/libjuice`, MPL-2.0, with its `PROVENANCE.md`); the PATH message kind that carries addresses (`host/coop_proto.c`); the path layer that looks for a UDP path to each accepted member and watches it (`host/coop_path.c`: `coop_paths_step`, `coop_paths_route`; the libjuice side is `host/coop_ice_juice.c`). With `coop_direct=on` the session sends over a proven path and through the relay otherwise, waits 2 ms instead of 8 between steps while a pair is direct, and finds a path that is broken one way within the suspect time (`host/coop.c`). The Co-op tab gets a Direct connections row and a path word after each player's name (`host/coop_menu.c`, `gpu/vk/vk_menu.cpp`). A path is suspect after 1.5 seconds of silence and down after 4; the game then retries after 10, 30, 60 and 120 seconds, and a pair that has been direct for 60 seconds forgets its failed attempts. - Router port mapping (opt-in): the game asks the router's gateway for a 300-second lease for the hosted relay's port, and, new in this round, for the direct paths' UDP port, offering the answer to accepted friends as a candidate address. `host/coop_portmap.c`, `host/coop.c`. - Defaults moved: `coop_players` is on, so the other players are shown once co-op is on and the room permits it, and the body assets are indexed at start only when co-op is on. `host/oot_coop_players.c`, `host/mods.c`. - Interface and docs: `gpu/vk/vk_api.h` `MKWVK_API_VERSION` 23 to 30; `docs/coop.md` is the reference, with `docs/development.md`, `README.md` and `CONTRIBUTING.md` updated. 40 test files are new over pull request 68, among them eight fuzz harnesses for the network input (`tests/fuzz/`) with 150 small seed files. New in this head over the last one (`5137c513ab1467df42d2ab8688ff25a850fe753c`), 55 commits: - A body wears the tunic, boots and mask its player wears; `HOS_COOP_PLAYERS_OUTFIT=0` draws none. - Go to friend passes its safety check in a game with the debug options off (the normal setting), and after a map change it waits for the new map's own arrival before placing the player beside the friend. - The sword-practice kit waits for room in the game's flag queues instead of for empty ones, which the game never has. - A direct pair that has just been answered is no longer called silent (an unsigned time difference wrapped), and a pair that has been direct for a minute forgets its failed attempts. - A room made on the Co-op tab comes back after a relay restart, and a removal the relay would ignore is refused where it is asked instead of reported as done. - A save copy killed while the oldest backup is removed leaves only a `.partial-` folder, the restore command refuses a half-made copy, a temporary copy that is refused says why on the Co-op tab, and the Windows path check refuses a file with a second name, as Linux does. - With `coop_portmap` on, the router is also asked to map the direct paths' UDP port, and the answer is offered as a candidate address. - The other player's body follows the jitter of a link: its display delay moves between 100 and 250 ms, and a body is carried on for a moment when its poses run dry. `HOS_COOP_POSE_TRACE` writes a trace for measuring this. - The log says why another player's body is hidden: this game left the room, or the room's permission was withdrawn. - Eight fuzz harnesses for the network input, with their seed files; they found one latent fault in the product (a refused chat text left the caller's buffer unset), now fixed. - The co-op test programs that failed on Windows only now run there (direct paths, router mapping, the temporary-copy checks with a junction and a second name of a file). - `third_party/libjuice/PROVENANCE.md` now says the game links the library. ## Measurements **Verdict:** the functional checks pass on this head with the exceptions named under Testing: six two-game proofs, three direct-connection runs, and two sessions between a Linux PC and a Windows PC. The game-free suite on this exact head fails the same 12 tests as main and nothing else. The game runs were done on builds of `607c6384da2f7408414b2761da9ece16e3c4f653`, the commit just before this head. The only difference between the two is one commit that changes one test file (`tests/oot_coop_players_test.c`); the game's source fingerprint is the same (`5d118e2e`), so the game built from either is the same game, but no build of this head itself was run. Nothing here measures speed: no frame rate or frame time was taken on this head, with co-op on or off. Hardware: Linux 7.2.15, RTX 4090 with NVIDIA's driver, Core i9-13900K, 96 GB RAM (the proofs and direct runs); a Windows 11 laptop with Intel Arc graphics (the two-PC sessions) Scene: Kokiri Forest and Link's house, child, from copies of test saves; two windowless games at 1280x720, frame generation off Method: one whole game-free suite run on this head; six two-game proofs, each its own run with direct connections off (the default); three direct-connection runs on one PC; two sessions of 12.5 minutes on two PCs; every game's exit code, the kernel log, both complete game logs and every cited picture were checked How to reproduce: build commit `2574634645ea0d7380171dd53c7ca6e410a9f7d8` from each player's own supported game, copy one test save per player, Make and Join a room and accept with the two-press confirmation; each proof's steps are in the results comment posted with this update | | Before: main @ 6c9edffe5da1f5b5383977aeab3f544c0de25d4c | After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 | |---|---|---| | whole game-free suite (passed / failed / skipped) | 552 / 12 / 16 | 603 / 12 / 16 (the same 12 fail) | | six two-game proofs | not run: co-op is not on main | all six pass at the first attempt, on builds of `607c6384da2f7408414b2761da9ece16e3c4f653` (the transfer and the temporary-copy proofs had picture pauses of 1.0 to 5.6 seconds in their first runs and none in a second run of each) | | direct-connection runs, one PC | not run: no direct connections on main | as written beforehand, except one clause (the second game's path kind was `host/prflx`, not `host/host`) and a blocked-path run that needed a second attempt after the PC itself stalled for seconds | | two sessions, Linux PC and Windows PC | not run | each passed 31 of 32 written expectations; the other is the runner's own detector reading the new log line "direct for 60 s: the failed attempts before are forgotten" as an error because it contains "failed" | ``` 603 passed, 12 failed, 16 skipped in 253 s (linux, 6 at once) FAIL tests/test_lift_cleanup_error.py FAIL tests/test_make_game_cache.py FAIL tests/test_appimage_player_build.py FAIL tests/test_cpm_discovery.py FAIL tests/test_crash_dialog.py FAIL tests/test_env_on.py FAIL tests/test_linux_preflight.py FAIL tests/test_pipeline_tour.py FAIL tests/test_readback_late.py FAIL tests/test_vk_pgo.py FAIL tests/test_vram_budget_row.py FAIL tests/test_walk_key.py ``` ![After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (game runs on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, the same game source): two games before consent, after both accepted, and after Leave](https://git.magicbean.dev/attachments/a1cd3213-1cd0-4ea5-ac0a-9d5c9e480807) ![After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (game runs on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, the same game source): standing, each player walking as the other game sees it, and presence turned off](https://git.magicbean.dev/attachments/94ff21a7-265a-4506-9393-450db7d7d538) ![After: this PR @ 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (game runs on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, the same game source): the Linux game's Co-op tab with Direct connections on and a Windows laptop as the room's maker; the other player's line reads (maker, relay) while the direct path is down after a 5 second stop of the game, and (maker, direct) once it is back](https://git.magicbean.dev/attachments/a5800b79-15eb-4758-a30e-5ad1d9bb9e61) ### Flags and settings This PR adds the switches below, changes one (`coop_portmap` now also maps the direct paths' port), and sums up the others of its co-op line in the last row. Everything co-op stays off until a player switches it on. The jitter-following display delay has no switch. The full list with defaults is in `docs/coop.md`; the test switches are in `docs/development.md`, except the `HOS_COOP_DIRECT*` and `HOS_COOP_STUN` ones, which are in `docs/coop.md` only. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `coop_direct` / `HOS_COOP_DIRECT`, the Co-op tab's Direct connections row | `off`, `probe` (look for a path and report it; every message still goes through the relay) or `on` (send over a proven path, the relay as the fallback). The row sets it in a running game; a set `HOS_COOP_DIRECT` holds it for the run | absent | off | While it is not off, accepted friends are told this PC's addresses (LAN, VPN and the public one); the tab says so | Helps: two games on one PC; two PCs on one home network (in the two sessions the data of five of the six direct paths ran over a VPN both PCs run, one over the home network). Untested: through a real router, across the internet, a plain home network with the VPN off, Windows with other GPUs | off for now; on only for a test with a friend | | `coop_stun` / `HOS_COOP_STUN` | the STUN server the direct paths ask for this game's public address | absent | empty: the relay's own address | read only when direct is not off | Tested with a simulated router and the product's own STUN answer; untested with a real NAT | leave empty | | `coop_direct_port` / `HOS_COOP_DIRECT_PORT` | the first of ten local UDP ports the direct paths use | absent | 24690 | a firewall has to allow UDP 24690 to 24699 for a path over a plain home network | A Windows rule for these ports was added for the two-PC sessions (one rule for each build's program); in the second session of this head the first direct path ran over the home network, so the rule carried traffic once; no other firewall was tried | leave at the default | | `coop_direct_lan=0` / `HOS_COOP_DIRECT_LAN=0` | keep this PC's own addresses out of what accepted friends are told | absent | 1 (they are told) | only the public address the STUN server reports is shared | Used in the simulated-router run only | leave at the default unless home addresses must stay private | | `HOS_COOP_DIRECT_DROP` | test only: throw away a share of the datagrams arriving over a direct path | absent | 0 | none | not for play | leave unset | | `coop_portmap` / `HOS_COOP_PORTMAP` (and test-only `HOS_COOP_PORTMAP_TEST_GATEWAY`) | the player's opt-in to ask the router's gateway (PCP, then NAT-PMP) for a 300-second UDP lease: for the hosted relay's port while hosting, and, new in this round, with `coop_direct` on probe or on, for the direct paths' port while a pair is looked for; renewed while open and removed when the last path closes, on Leave or at exit | absent | off | changes the router's state while it is on | Relay port: tested against a made-up gateway on one PC, in three real-game runs on 12 November 2026 (rows in `docs/tested/`). Direct paths' port: game-free runs against a made-up gateway only (12 runs, including the game's own session and libjuice); no game was run with it on, and no real router | off; on only for a player whose router speaks PCP or NAT-PMP | | `HOS_COOP_RELAY_STUN=0` | the relay a maker hosts in the game answers STUN by default; this turns it off | absent | on | needed for direct paths through the hosted relay | Tested game-free and with libjuice's own client over loopback; no real NAT | leave unset | | the relay script's `--network-replies` and `--room-removals` (the in-game relay has the same limits at fixed values) | answers a network may get from the relay, and removals a room keeps | absent | 20 answers a second after a burst of 100; 4096 removals | a flood of CONNECTs is not answered; a room stops taking new members when its removal list is full | Game-free tests on both relays and a flood over real sockets; no flood from a second PC to a running relay | leave at the defaults | | `coop_players` / `HOS_COOP_PLAYERS=0` | show the other players | absent in pull request 68 | on | bodies appear only once co-op is on, the maker's signed presence rules allow them and the player accepted | Six proofs with child bodies on this head; adult bodies were not shown in a game on this head | on | | `HOS_COOP_PLAYERS_OUTFIT` | local development override: unset draws the tunic, boots and mask other players wear (once the equipment permission is signed); `0`, `off` or `false` draws none, for before and after pictures | absent | on (unset) | the other body wears what its player wears | On the branch that made it (before it was merged here): the Zora tunic and cap seen on the other body in two pictures, boots and a mask asked for and live on the body in the logs but never legible in a picture, removal never run in a game. None of it in a game on this head | leave unset | | `HOS_COOP_EQUIP_PROBE` and `HOS_COOP_POSE_TRACE` | diagnostics, unset: the first logs what a game's Link and each body's equipment hold (with `HOS_COOP_TRACE=1`); the second writes a bounded binary trace (48 MiB at most) of Link, the poses sent and received and where each body was drawn, for measuring jank | absent | unset | none while unset (the pose trace costs one flag test) | the equipment probe ran in games on the branch that made it; the pose trace ran in two live games on its branch and a game with it set draws the same bodies as one without (game-free test, to the bit) | leave unset | | the other settings of this line: `coop_presence_permissions`, `coop_names`, `coop_labels`, `coop_warp`, `coop_social_permissions`, `coop_notices`, `coop_hit_events`, `coop_loadout_*`, `coop_pvp_*`, `coop_duel_*`, `coop_arena*`, `coop_room_mode`, the chat key, and the test-only `HOS_COOP_ACCEPT`, `HOS_COOP_ARENA_FILE`, `HOS_COOP_AUTO`, `HOS_COOP_HITS_TRACE`, `HOS_COOP_PLAYERS_ACTOR`, `HOS_COOP_PLAYERS_ANIM`, `HOS_COOP_PLAYERS_TEST`, `HOS_COOP_PROFILE_TICKET` and `HOS_COOP_TRACE` | the permissions, display choices and test aids of the rules, bodies, chat, travel, kit and observation pieces | absent | off, except names on, labels on (Names), notices on (everything) and the chat key T | none until a room's maker signs the matching permission | The proofs use child bodies only; adult bodies and gear, arrows, the kit and fighting were not run on this head | leave at the defaults | Pull request 68's own switches (`HOS_COOP_HOST`, `HOS_COOP_SERVER`, `HOS_COOP_NAME`, `HOS_COOP_PROGRESS`, `HOS_COOP_ITEMS`, `HOS_COOP_KEYS`, `HOS_COOP_RUPEES`, `HOS_COOP_AMMO`, `HOS_COOP_SONGS`, `HOS_COOP_QUEST`, `HOS_COOP_ROOM`, `HOS_COOP_DROP`, `HOS_COOP_DEMO`, `HOS_COOP_PROBE` and `HOS_COOP_TEST_SET`) are not repeated here. Existing development switches this line touches: `HOS_OOT_TELEPORT_EVENT` and `HOS_OOT_TELEPORT_STARTER` (Go to friend refuses while either is set) and `RX_VK_MENU_SCRIPT` (a diagnostic entry into the chat field). ## Testing **Tested:** - The whole game-free suite, once, on the exact head: 603 passed, 12 failed, 16 skipped. The same 12 fail on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c` (552 / 12 / 16) and on pull request 68's head `3320a841036f02484ae68c72f02b6f34928f776e` (563 / 12 / 16); none touches co-op. No test that passes there fails here, and 40 more test files pass than on 68's head. On the commit before this head the same suite gave 602 / 13 / 16: the extra failure was `tests/test_coop_players.py` at one check of the outfit receiver, a step that waited a fixed 232 ms while the body's display delay can reach 250 ms. That is a fault of the test (a regular stream at the product's rate keeps the delay at 100 ms, which the link test shows); this head's one new commit makes the step wait for the condition, and the test passes with GCC and Clang with all 19 of its mutations failing as they must. - The commit before this head (same game source) built for Linux (the title screen was reached after 270.5 seconds of shader preparation) and cross-built for Windows (697 compile commands, none failed, linked); the Windows build started to its title screen and ran in the two-PC sessions. A Windows-target syntax check of the changed test files found 0 failures; Windows execution of the tests was not part of it. - Six two-game proofs on one Linux PC (RTX 4090), direct connections off: signed checkpoint transfer with a partial cancel, consent and Leave, temporary copy with autosave and Return, signed terms with a stale confirmation, standing and walking bodies, and five sword swings with the damage counters. All six passed at the first attempt, and every result line equals the last head's (the maker's key and the five swing counts apart); only the log's text for the reason a body is hidden changed, on purpose. Both complete logs of every game were read for unexpected body removal. The transfer and temporary-copy proofs showed picture pauses of 1.0 to 5.6 seconds in their first runs (for the transfer proof in the same 14 seconds in which another job on the PC was copying the game's 187,000 files; for the copy proof no cause was found); a second run of each passed with no pause. The details are in the results comment posted with this update. - Three direct-connection runs of two games on one PC: `coop_direct=on` (a pair proved at once, the relay then forwarding nothing and receiving only its keep-alives); a path blocked in the middle of a session, both ways and then one way, through a program that pretends to be a router (down within 4 seconds, the relay carrying the game again, direct again after 10 and 30 seconds, no body hidden; timings within 0.4 seconds of the last head's); and probe mode, where the one expectation that failed on the last head, a flap at 200 seconds, did not occur in 265 seconds. One clean run does not show that a flap seen once is gone. - Two sessions of 12.5 minutes each between a Linux PC and a Windows 11 laptop on one home network, direct on, a relay on a third PC: direct at once, a 5 second stop of the Linux game, the Direct connections row set Off and On from the tab, chat each way in every phase (seven lines, all delivered), one body per player, both exits 0, saves unchanged. The short "not answered for 1.5 seconds, then direct again" lines that the last head's session had (7 in 12 minutes) did not occur (0 in either session); two sessions do not show that the unsigned wrap fixed here was their only cause. The path word after the other player's name was pictured in every phase in the second session (`direct`, `relay` after the stop, `direct`, no word while the row is Off, `relay` until the retry, `direct`). The direct data ran over the VPN both PCs run in the first session; in the second, the first path ran over the home network and the next two over the VPN. A new Windows firewall rule was needed for the new Windows folder. - Each fix of this round has game-free tests written first that failed before it (red runs kept in the reports): a room after a relay restart, a refused removal, a save copy killed at each of 92 kill points and at 480 random moments (0 left a half copy under a numbered name; the last head left one at 40 of 90 points and 22 of 480 kills), the restore command's refusal of a half-made copy, the kit's queue gate (10 mutations of its test caught), the direct pair's wrap and failure count, the Windows second-name check, the position message version 4, and Go to friend's arrival wait (15 mutations of its test caught). The pose delay was run on a recording of a real two-game session and in two live games through a link simulator (on the Wi-Fi-like link the share of moving frames in which the body stood still fell from 15.4 to 0.1 percent, on the bad link from 50.1 to 0.1; on a clean link the delay stayed at 100 ms in every frame; 4 and 1 one-frame jumps remained); one session per link, not a real network. - On the branches that made the fixes, in builds of those branches before they were merged here: Go to friend passed its safety check in every ask in two real games; the arrival after a map change landed 1.21 to 1.25 m from the friend in four real games (Hyrule Field and Kokiri Forest, adult and child), where the game's own arrival had left the player 74 to 195 m away; the other body wore the Zora tunic and cap in a picture (the same body bare with `HOS_COOP_PLAYERS_OUTFIT=0`); boots and a mask were asked for once and live on the body in the logs, never legible in a picture. The same fixes are in this head, whose game-free tests for them pass; none was repeated in a game on this head. - Eight fuzz harnesses for the network input (wire, session, events, sync state, path layer, relay, checkpoint transfer, chat) under address and undefined-behaviour checkers: they found one latent fault in the product while they were built (a refused chat text left the caller's buffer unset), fixed with a regression test; the two failures of the first 1,000 second campaign and three more in later 20-minute runs were in the harnesses' own checks, fixed with a minimised input kept for each. The last 20-minute runs of the session, events and state harnesses on the final fuzz head were clean; the path, relay and save harnesses were not rerun after the harness fixes (their sources did not change), and the wire and chat harnesses were not in the long runs. - The co-op and networking test programs ran natively on the Windows laptop: 11 of 13 passed at the last head. After their fixes, at later commits, the router-mapping and temporary-copy programs pass there (the temporary-copy one now refuses a file with a second name: before the fix a write through such a name changed the other file, as the test program showed), and 10 of 12 direct-path runs passed, the two others being a relay lost under 30 percent datagram loss and a relay that did not start. This head's Windows build was not used for them. - On the last head, in Windows games: a Windows joiner and a Linux maker exchanged signed checkpoints both ways (72 checks, none failed); a Windows game alone made a temporary copy, saved a change only in the copy and returned to its normal saves with Return (45 checks passed, 1 failed: the designed check that found the second-name leftover, fixed since). Not repeated on this head. - Earlier heads, kept with their heads (game code before direct connections): a 30-minute two-game session passed every rule written beforehand at `9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca` (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-21299) and, with co-op off, the frame time against its base was inside the noise in one scene (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-21300). Two earlier long sessions each failed one rule (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17694 and https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17887); those stay failures. A Windows tester's two-GPU session and a two-PC session at that head: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-20835 and https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-21344. - One test was flaky: `tests/test_coop_direct.py` failed 3 of 10 solo runs on the integration branch that held the last head plus the first fixes, with other work running on the PC. Four causes were found: bounds that failed by chance on correct code (computed: about 1 percent of runs for one bound, 12 percent for another), timings that made a pair rejoin under 30 percent loss, the unsigned wrap above, and a pair that had failed five times never trying again. It has passed the whole suite on this head and on the commit before it; on an earlier integration it passed 5 of 5 solo runs and the focused lists with GCC and Clang. Five runs do not prove the flake gone. **Not tested:** a 30-minute session on this head and the frame time with co-op off or on (the last runs are at the earlier head above); a build of this exact head in a game (the commit before it, with the same game source, was the one run); direct connections through a real router, across the internet or on a plain home network with the VPN off; router port mapping with a real router, and any game run with the mapping of the direct paths' port on (game-free runs against a made-up gateway only); the relays' STUN answers against a real NAT (the home relay used in the two-PC sessions answers STUN since the morning of the runs, with its own limits on open rooms; the answers were not checked against a real NAT); the path word for a joiner in the maker's list, which no picture reached (the maker's list is below the last visible row of the menu at 1280x720 and a windowless picture does not scroll; the menu was not changed); Windows with a GPU other than Intel Arc; AMD GPUs and the Steam Deck; a physical controller and typing; on this head in a game: the outfit, Go to friend, the sword-practice kit (its new queue gate has not been shown in any game), a room coming back after a relay restart and the delay that follows jitter on a real network; Copy and Return in a Windows game on this head's build and UTF-8 paths on Windows (a file with a non-ASCII name inside a save was copied correctly in a Windows game of the last head, but not a non-ASCII install or user folder); adult bodies and gear, health, place and arrows, more than two players, sword contact and fighting. A game frozen for more than about 10 seconds still loses the other player's body until it recovers (stop cases at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-20697, taken on an earlier head, not repeated). The problems found in the last head and where they stand in this one are in the comment posted with this update. **Must be tested:** - Two PCs with a router between them (Windows 11 and Linux, any GPU): the maker hosts with the port forwarded or with `coop_portmap` on, both set the Direct connections row to Direct, accept, walk and chat, expecting a `direct (...)` line in each game's log or, if no path is found, the path word reading relay with play unaffected, and no body removed (by hand: the two players, with both logs) - A plain home network, VPN off (Windows 11 and Linux, UDP 24690 to 24699 allowed on the firewall): the same steps, expecting `direct (host/host)` and the relay's traffic falling to its keep-alives (by hand: a person, with the log and the network counters) - Two games for 30 minutes, once with direct on and once off (Linux, one PC or two): stand, walk and chat, expecting no unexpected body removal, no retries and unchanged saves, as in https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-21299 (by hand: a person reads both complete logs) - Frame time with co-op off, main against this head (Linux, any GPU): four interleaved runs of the same walk, expecting a difference inside the noise, as in https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-21300 (by hand: the method of that comment) - Two games on one Linux PC with the debug options off, a friend in another map: ask Go to friend from Kokiri Forest and from Hyrule Field, expecting "Arrived near your friend." about 1 to 2 m from the friend and no "did not keep the arrival position" line (by hand: a person looks at both screens and reads the log) - Linux, two games on one PC, equipment permission signed: one player wears a different tunic, boots or mask (a child's mask for a child), expecting the other game's body to wear them, nothing asked for more than four times, and the pieces gone when the player takes them off (by hand: pictures of the body from the front, and the log's `request: taken` lines) - Two temporary copies with the sword-practice kit on (Linux, one PC): expecting "sword practice ready" with the Master Sword and Hylian Shield worn on both, and no refusal (by hand: a person reads the log; this is the first run of the new queue gate in a game) - Windows 11 with another GPU and a physical controller: Make, Join, Accept, bodies, chat, then a temporary copy and Return, expecting what the Linux proofs show (by hand: pictures and logs). The earlier test requests for this pull request (T-ADK4, T-QF6F and T-KQUM) were pinned to an earlier head and would need pinning to this one ## Risks **What could break:** a large change across save handling, permissions, networking, input, generated presentation and the host and renderer interface. A permission or path mistake could affect a save; a wrong body lifetime could leave a wrong actor; stale input could turn a chat key into a game action; network loss or the host leaving ends the room. With direct connections on, the friends a player accepted are told this PC's addresses (the tab says so); a router port mapping changes the router's state, now also for the direct paths' port; the relays answer STUN. A direct path that breaks falls back to the relay, as tested on one PC and between two. New in this round: a body asks its own game for each piece of the other player's outfit (at most four times a piece, then it gives up) and a wrong piece number could draw a wrong item; the display delay of the other body follows the jitter of a link, so on a poor link it is drawn later (on the simulated bad link its median moved from 186 to 268 ms behind the real moment; a clean link stays at 100 ms) and a body is carried on for a moment when its poses run dry, which caused 4 and 1 one-frame jumps of 0.34 to 0.54 m in the live runs; the sword-practice kit's changed queue gate has not been shown in a game and the kit changes live equipment on a temporary copy; a room made on the Co-op tab is made again by its maker after a relay restart and waited for two minutes by the others. Whoever holds a room's secret can lie about poses or chat; this is not an anti-cheat system. A verified checkpoint hash proves its bytes, not that an untrusted save is safe for the game's parser. The game writes its own saves in place, so a game killed in the middle of its own autosave can leave a torn save (shown once, by killing a game at its first write; not co-op code, and no fix is in this head); the copy made when a room is accepted is what lets a player go back. **Turning it off:** leave the room or set `coop=0` (`HOS_COOP=0`); the Direct connections row at Off (`coop_direct=off`) keeps every message on the relay; `coop_portmap=0` stops the router request; `coop_players=0` removes the bodies; `HOS_COOP_PLAYERS_OUTFIT=0` draws no outfit; `coop_host=0` stops hosting; reverting the pull request removes all of it (the jitter-following delay has no switch). Turning co-op off cannot undo progress already merged into an ordinary save, so use a separate `--user` root from the first launch with a copy of your own saves, and never copy a test save back into the usual folder. **Compatibility:** nothing changes for a player who never switches co-op on, except that `coop_players` now defaults to on and does nothing without a room. Both players need the same build: the position message is version 4 in this head, so a game of an earlier head does not show a body of this one or get one shown, and other messages changed between heads, so two builds may fail to join or not show each other. `MKWVK_API_VERSION` goes from 23 to 30, so a game and a renderer built from different commits will not match. Saves are not changed unless a room is accepted after a backup, and a temporary copy never copies progress back. ## Issues See https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/68 for the co-op base and the earlier proof discussion. See https://git.magicbean.dev/MagicBeanDev/Longshot/issues/463 for co-op from playtest to merge. See https://git.magicbean.dev/MagicBeanDev/Longshot/issues/42 for the unresolved core and module direction. ## Checklist ### Everyone - [x] One topic. 164 of the 171 commits are scoped to co-op; the other seven are a fixture, a translation-order fix, a build label, a menu test, a docs line, the libjuice provenance line and the restore script's refusal of a half-made copy, all of which the line needed. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [ ] Rebased on current `main`. This head sits on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c` through pull request 68; main is now at `1c91dafbd627026e59130d5c58290eb028a52348`, and a trial merge gives 6 textual conflicts (listed under Why). - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). On this head: 603 passed, 12 failed, 16 skipped. The 12 failures are listed under Measurements and fail the same way on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c`. - [x] No game files, dumps, build output or generated files. Checked by file list against main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c`: 414 files; the added files are C and C++ sources and headers, Python, Markdown, one text file of test vectors and 150 small binary seed files (11,823 bytes in all) of the fuzz tests under `tests/fuzz/corpus`. The seeds are written by `tests/fuzz/make_seeds.py` from the test vectors and a few hand-made inputs, and the fuzz test checks that they equal what it writes; they hold no game data and are committed because the test fails in a clean checkout without them. - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). Against main, 51 files under `third_party/` are added and none changed or deleted: `monocypher` (4 files, from pull request 68) and `libjuice` (47, with its `PROVENANCE.md`, whose text this round corrects to say the game links the library). - [ ] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. libjuice is MPL-2.0 and unmodified; its notices carry no "Incompatible With Secondary Licenses" marker, so it can be combined with this GPL-3.0-or-later program (`third_party/libjuice/PROVENANCE.md`). The review of the line's own source was done at an earlier head and not repeated for the 171 commits above pull request 68's head. ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. All 171 commits above pull request 68's head carry both. - [ ] Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value. The `HOS_COOP_PLAYERS_OUTFIT`, `HOS_COOP_EQUIP_PROBE`, `HOS_COOP_POSE_TRACE`, `HOS_COOP_RELAY_STUN`, `HOS_COOP_PORTMAP` and `HOS_COOP_PLAYERS` rows are in `docs/development.md`; the `HOS_COOP_DIRECT`, `HOS_COOP_DIRECT_LAN`, `HOS_COOP_DIRECT_PORT`, `HOS_COOP_DIRECT_DROP` and `HOS_COOP_STUN` rows are in `docs/coop.md` only. - [x] Screenshots of the same spot, captioned like the Measurements columns, for a change that shows on screen. Three pictures under Measurements, each captioned with this head's commit and saying that the game runs were on the build of the commit before it. - [x] `MKWVK_API_VERSION` bumped (`gpu/vk/vk_api.h`'s `MkwVkHost` or `MkwVkRenderer` changed). 22 on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c`, 23 on pull request 68's head and on current main, 30 here; the number will need renumbering when this is carried onto current main. - [x] A game-free test added for the fix, failing on `main` and passing here. The new tests were written first and failed before their code (the path layer, the direct runs, the relay limits and STUN, the players default and the asset index, and in this round the soak and room recovery, the save copy kill points, the restore refusal, the kit gate, the pair's wrap and failure count, the Windows second-name check, position message version 4, the arrival wait and the jitter delay); the whole suite passes them here. - [ ] A check under `tests/` that reads changed source updated in this PR, not weakened. The checks of this round were changed together with the code they read (position message version 4, the display delay, the arrival wait, the kit gate, the removal rule), but the direct test's fixed bounds on loss counts were loosened on purpose to bounds computed from the binomial law, because the old ones failed by chance on correct code (about 1 percent of runs for one bound, 12 percent for another, computed in the reports); the mutation runs written to show that the direct test still fails when the code is wrong are not part of a finished report. A reviewer should read the diff of `tests/coop_direct_test.c`. - [ ] Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. The commit before this head (same game source) built on Linux and cross-built for Windows without a failure and ran on both; this exact head was not built, and UTF-8 runtime paths on Windows were not exercised on this head. - [x] Docs updated. `docs/coop.md`, `docs/development.md`, `docs/control.md`, `README.md` and `CONTRIBUTING.md`. --- New on this forge; not opened on GitHub.
mooki added 111 commits 2026-11-14 04:15:44 +00:00
The Insert menu could not take typed text: a setting held as text, such as an
output size of the player's own, could only be set by editing
longshot_options.ini.

A text field is a row whose value is typed. Characters come from the window
(WM_CHAR on Windows, SDL's text input on Linux, turned on only while a field
has the keyboard) through a new MkwVkHost member, take_text, appended last
(MKWVK_API_VERSION 20, from 18; 19 is claimed by an open pull request). Left,
Right, Home, End, Backspace and Delete edit,
Ctrl+V and Shift+Insert paste the clipboard's first line, Enter sets the
text, Esc puts it back; a controller's confirm and back are Enter and Esc,
its D-pad moves the caret, a free face button pastes. A field holds printable
ASCII, as the menu's glyphs are baked; other characters are left out. While a
field has the keyboard no key does anything else, and the game gets none, as
for the whole menu. RX_VK_MENU_SCRIPT gains TYPE:<text> and the editing keys.

The first field is Custom output size on the Graphics tab: the Output
resolution of the player's own (output_res=), typed and checked by the same
rules, with the reason shown when a size is refused. As the row itself, it
leaves the Quality preset alone, and a size typed is the player's own from
then on, also in a run whose HOS_OUTPUT_RES holds the row (env_release).

Main's prompts_live (version 17) stays before take_text in both the interface
and the host table. tests/test_menu_text_field.py compiles the editor and the
host's queue cut from the source, and checks the wiring in the source: the
interface's take_text in its place in the host's table, WM_CHAR and SDL's text
input, the menu telling the host whether a field has the keyboard, TYPE.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Windows clang with Microsoft headers rejected getenv from hos_wide_size.h and sscanf from the extracted output parser as deprecated under -Werror. Put _CRT_SECURE_NO_WARNINGS on the first line of both generated C and C++ sources, matching the existing capture fixture convention. The screensaver fixture also needs the guard: its injected window procedure calls getenv twice. Runtime code, warning flags and every behavioral check stay unchanged.

Linux g++ and clang++ execute all three text-field checks; GCC and Clang pass all 18 mocked-window-procedure cases. Native LLVM-MinGW 23.1.5 Windows-target syntax with -Wall -Wextra -Werror -Wdeprecated-declarations and Microsoft-style getenv/sscanf annotations fails before and passes after. The three generated co-op tab fixtures pass that audit unchanged; restart-slot checks generate no C or C++. This is not a Windows runtime test. Refs #2594.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Main took version 20 for screen_size and version 21 for nvn_program_created while this rebase was being prepared. Append take_text after screen_size at version 22 and keep its fixture version check in step. Preserve both merged callbacks and their history comments. Reuse the SDL2 SDL_free lookup now supplied by the merged controller diagnostics instead of loading the same callback twice.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Record the two windowless runs built at 4914fdec on main 8cf9a524. The native build reused a completed lift only after both actual source-tree lift keys matched the recorded donor key. Keep the tested commit named explicitly: the later clean rebase onto main 15d4ae8c is checked game-free, not represented as another game run.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
fix(menu): complete custom output size controls and translations
Some checks failed
PR description / Description follows the template (pull_request_target) Successful in 4s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
Website / Website on Cloudflare (pull_request) Has been cancelled
891631dfba
Keep monitor-following for typed 16:9 sizes. Allow pad-only character entry and removal, translate the field and its prompts, ignore repeated paste shortcuts, fold full-width size input and hold the list still during editing. Keep the host API append check extensible without weakening positional wiring.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Co-op needs a way for the games of several players to find each other and talk without anyone on the path, the relay
included, reading or forging what they send. This is the game-free first part: the relay and the wire format both
ends speak. The game does not use it yet.

- scripts/coop_relay.py: a UDP relay, standard library only. Rooms of up to 8 players named by a locator derived from
  a secret the relay never sees; a cookie challenge before it answers anything larger than it got; rejoin tokens;
  limits per member, per network, per room and in all.
- host/coop_proto.c/.h: the same format in C: room secrets (18 characters, 85 bits), keys derived with keyed BLAKE2b,
  datagram tags (keyed BLAKE2b-64), the client and relay messages, and the players' messages sealed with
  XChaCha20-Poly1305; EdDSA for what only one player may make; the POS message for showing other players later.
- third_party/monocypher: Monocypher 4.0.2, unmodified (BSD-2-Clause / CC0), compiled with the runtime by
  nx2/build.py and shipped in the AppImage's sources.
- docs/coop.md: running a relay, rooms and secrets, the wire.

Tests: tests/test_coop_relay.py (60 cases: the codec, the relay's rooms and limits on a fake clock, hostile clients,
real UDP); tests/test_coop_proto.py (the C codec against every vector of tests/coop_vectors.txt, which the Python is
checked against too, known answers, sealing, signatures, 400000 fuzzed datagrams under ASan/UBSan, the POS counter).

Carried from the author's own co-op for another port of this game (files he wrote; nothing of that port's code), with
the domain strings renamed and the datagram tag changed from HMAC-SHA256 to keyed BLAKE2b, so that Monocypher is the
only cryptography.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Progress sync needs one rule for how the players' states combine that holds under lost, repeated and reordered
messages and against a player who sends what they should not. This is that engine, game-free; the game does not use
it yet.

- host/coop_state.c/.h: flags as (category, 32-bit hash, value) registers merged by keeping the highest value; small
  keys, rupees and ammunition as signed per-player records in shared pools; digests and sections between the players;
  identities, acceptance by key, the room maker's signed charter (rules, admissions, removals, pool resets). Every
  value is checked against the game's own table before it is stored, passed on or applied.
- tests/coop_sync_test.c with tests/test_coop_sync.py: the engine between simulated games on a simulated network
  (merging in any order, 30 % loss, late joiners, rules, pools, carry-over between rooms and saves, hostile members and
  an attacker with the room's secret, a randomised run against a ledger), under ASan (leaks too) and UBSan on Linux.
  The sanitizers found the engine's apply queue never freed; coop_sync_free frees it now.

Carried from the author's own co-op for another port of this game (files he wrote, no code of that port), with the
signing roles renamed to hookshot-coop and the test's old-engine shim removed.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Co-op needs the game itself to reach a relay and stay in a room: this adds the
session layer, one UDP socket on one host thread, off unless switched on, that
the menu's Co-op tab and progress sync build on. It never touches game memory.

- host/coop.c, host/coop.h: the session (the relay's cookie exchange, CONNECT
  bursts with backoff, keep-alive PINGs, rejoin after the relay goes silent or
  restarts, the roster, sealed player messages with replay windows, removal by
  the room's maker, BYE and LEAVE when leaving) and the process's session:
  longshot_options.ini's coop, coop_name, coop_server and coop_port, with
  HOS_COOP, HOS_COOP_NAME, HOS_COOP_SERVER and HOS_COOP_PORT over them;
  HOS_COOP_AUTO=create|join with HOS_COOP_ROOM, HOS_COOP_DROP and
  HOS_COOP_TRACE for tests (HOS_COOP and HOS_COOP_TRACE are on/off switches by
  env_on's rule: =0 is off); coop_configure for the menu. The thread exists
  only while co-op is on: switching it off, or the game closing, asks it to
  end and waits for it at most 0.4 s, with the socket closed; switching it on
  starts it again. The room's secret and the relay's address stay out of the
  log. A sender that has used up its 32-bit message counter leaves the room
  rather than reuse a nonce; a new join draws a new session.
- host/coop_net.c, host/coop_net.h: the operating system's part: a dual-stack
  UDP socket, the name lookup, random bytes (BCryptGenRandom, getrandom), a
  lock, an event, a once and a thread that is waited for, on Winsock and on
  BSD sockets.
- host/hos_main.c: coop_init() beside hos_discord_start() on Windows and
  Linux; no name that begins HOS_COOP is taken from longshot_env.txt, a file
  players pass around.
- host/hos_relaunch.c, host/control.c: BYE and LEAVE when the window closes,
  and when the control bridge's quit ends the game. Co-op installs no
  signal handler: a game that is killed says nothing, and the relay drops it
  after 15 s of silence (docs/coop.md says what the others see).
- host/nn_applet.c: hos_ini_text, the options file's text values; its line
  buffer is 256 bytes, for a relay address of up to 159.
- nx2/build.py: -lws2_32 -lbcrypt in the Windows host libraries.
- tests/coop_session_test.c, tests/test_coop_session.py: the sockets on
  loopback, coop_server_parse, co-op off (no thread, no socket), the menu
  switching it on and off (off, on, off cycles with a socket open: no thread
  and no socket left), and two sessions in one process through a hostile
  relay of the test's own and through scripts/coop_relay.py (restarted
  midway), at 0 % and 30 % loss, with the process's session and, on Linux, a
  child ended by SIGTERM that the relay drops for its silence; ASan and UBSan
  on Linux, the two unit runs also under ThreadSanitizer; send_sealed cut
  from the source and run with the real sealing at the counter's end; and the
  wiring in the source (the start beside the Discord status, both ways out,
  the Windows libraries, hos_ini_text).
- tests/test_coop_env_file.py: longshot_env.txt sets no HOS_COOP name.
- tests/test_coop_options_text.py: a long coop_server= line is read whole.
- tests/display_startup_failure_test.cpp: an inert coop_init beside the
  inert hos_discord_start (its fixture compiles main()).
- docs/coop.md: the settings, the log lines, a game that ends without a
  goodbye, the tests; docs/development.md: the options file's co-op keys.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Players in a co-op room should share a chest, a boss, a song or an item one of them gets, in their own games with their
own saves. This is the game side of that, on the merge engine of the commit before: the game's flags read between frames,
the room's values given to the game through its own set routines, and the save copied before anything of a room reaches
it.

- host/oot_coop.c/.h: at the end of each present (host/nvn_native.c, one call, on the presenting game thread with its
  core held), the game's flag database (GameDataMgr) read in quarters and its shared flags classified at run time from
  each entry's reset kinds and save file and the game's own groups (item counts, first-get markers, dungeon keys,
  capacities), with a few dozen hashes for what the groups cannot tell; no list of the game's flags in the source. The
  table is checked against the game's own getter before anything is shared. Values are applied through SetBool and
  SetInt (never a write of the table), only raised, within the game's own table, and only after the player accepted the
  room and its save was copied. Nothing is read or set on the title screen, while a save loads, a scene changes or the
  play clock stands. With co-op off the call reads one value and returns. Sync is on whenever co-op is: from the start
  with HOS_COOP=1 or coop=1 in the options file, or from the session's first callback when co-op is switched on later
  (the session's hooks are registered either way). The offer, acceptance and the maker's remedies for the Co-op tab:
  hos_oot_coop_offer/accept/is_maker/reset_pools/remove_key/contributors. HOS_COOP, HOS_COOP_PROBE and
  HOS_COOP_TRACE are on/off switches by env_on's rule (=0 is off).
- host/nn_fs.c: hos_save_copy, the save folder copied to <user>/coop-backup/ (first-<time> kept, the newest eight
  others), under a lock that the save mount's changes take, only when no save file is open for writing and nothing
  changed for half a second; a save waits for a copy under way. The save folder's path is kept once, by the
  save mounts under that lock, and the control bridge's hos_fs_save_root reads it there.
- tests/test_env_file.py: HOS_COOP_ACCEPT, HOS_COOP_TEST_SET and HOS_COOP_NAME in longshot_env.txt set nothing
  (host/hos_main.c is not changed here: the commit before refuses every HOS_COOP name from that file).
- Tests: tests/test_oot_coop.py (the reader, classification, apply rules, guest calls, table check and gate on a made-up
  flag database, and the switch), tests/test_save_copy.py (a writer racing the copies, ThreadSanitizer; the bridge's save root).
- docs/coop.md: what joining a room means for your save, going back, progress sync, what is shared, the room's rules.

Carried from the author's own co-op for another port of this game (his coop_game.c: the logic; every call into that
port's runtime rewritten against Hookshot's).

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Co-op could only be started from the environment (HOS_COOP_AUTO and HOS_COOP_ROOM) or the options file, and a room
could only be accepted from a test switch; a player needs to make or join a room, see who is in it and accept it from
the game.

The Insert menu gets a Co-op tab, the strip's last. Your name and Relay are text fields saved as longshot_options.ini's
coop_name= and coop_server= (which host/coop.c reads at the start); Make a room and Join a room (the secret typed or
pasted) switch co-op on for this run with them (coop_configure, then coop_command). In a room the tab shows its secret
(masked until Enter), a status box with the state, the player count, the relay's round trip and the session's own
words, and a line per member: number, name, you, maker, away, and its identity key's fingerprint. Accept the room
(press twice) takes progress sync's offer (hos_oot_coop_accept: the save is copied first); the game holding the
maker's key also gets Remove a player (Left and Right choose) and Reset the pools (hos_oot_coop_remove_key,
hos_oot_coop_reset_pools). Leave the room, press twice. Rows come and go with the room's state and the selection stays
on its row. While the room waits to be accepted the remedies and Room rules stand back, and the members' lines move
closer together when the room is full, so that every key being accepted shows above the prompts where it can.

Room rules opens a page of its own, as Motion does on Controls: what a room this game makes shares. Progress, Items,
Songs, Quest items (Shared or Per player), Small keys, Rupees, Ammunition (One pool or Per player) are the options
file's coop_progress .. coop_ammo, which host/oot_coop.c reads when the room's maker signs its rules, with the
engine's values (0 per player, 1 shared, 2 one pool) and defaults; under a row the page says what a room cannot have
(with progress shared, items, songs and quest items are shared; with progress per player, small keys are). Co-op at
start is the file's coop=, which host/coop.c reads at the start. The rows' keys are not their names, so they are read
and written through coop_options beside ini_key. The rows take no numeric option id (rx_option): the runtime reads
them by their keys, so they need none of the ids main and other pull requests use.

The interface: vk_api.h version 21, MkwVkCoopView and MkwVkHost.coop_view and coop_command after take_text (version 20).
host/coop_menu.c is the host's side: the session's view and progress sync's offer (keys, token, acceptance) and pool
list (the player's own key) in the tab's terms, the tab's commands into the session's and progress sync's calls. Make
a room uses HOS_COOP_ROOM's secret when the environment has one (test sessions whose second game types it).
HOS_COOP_DEMO=1 runs the tab on a made-up room that walks through every state (members with and without keys, an
offer, accepted, a member away, removed, left) without starting the session.

RX_VK_MENU_SCRIPT gains ROW:<name>: the shown tab's or page's row of that name is selected, if it shows. The tab's
rows come and go with the room's state (and the Graphics tab's with the GPU), so a scripted run that counted DOWN
presses pressed the wrong row; a session driven from the tab chooses Accept the room by name.

The control bridge (host/control.c) lists and sets the Room rules rows like the other settings, under their
coop_ keys (row_key), and names the Co-op tab's and the Room rules page's rows' tabs (co-op, room rules).

save() writes the Room rules rows under their keys with saved_value, as every row, so a run's environment does
not stay in the file; HOS_COOP_DEMO is an on/off switch (env_on). tests/test_menu_env_overrides.py, which compiles
save() cut from the source, gets the tab's part of it as stand-ins; so does tests/test_menu_keys.py for the tab's
parts of menu_tick's Esc block and of menu_init's reading of the options file.

tests/test_menu_coop_tab.py drives the tab's code cut from vk_menu.cpp (rows per state, presses, fields, selection,
the remedies, what the rules page says under a row), compiles host/coop_menu.c against the real secret code with the
session and progress sync stubbed (and the made-up room on a made-up clock), checks the rules page's rows against
host/coop_state.c itself (keys, modes, defaults), and checks the wiring.

docs/coop.md says what the tab does (a section of its own; the lines that said the tab was to come), the readme's menu
table has its rows, docs/development.md has ROW:<name>, HOS_COOP_DEMO and the options file's co-op keys.

Assisted-by: Claude Opus 5.5
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Adopt Kuba’s bind_tables rename from his Windows build/play report on #2274, avoiding the bind declaration imported by winsock2.h. Rename the internal IN macro to COOP_FLAG_IN as well, because minwindef.h defines IN. Migrate the existing fixture callers and extraction markers without removing a check. Document the reported Windows read-only hard-link and headless forced-stop behavior.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>

Co-authored-by: Kuba <[email protected]>
A pthread join can finish before the joined Linux TID disappears from /proc/self/task, especially with ThreadSanitizer. The warm-up helper then inflates the baseline from two tasks to three and every exact menu-thread check uses the wrong baseline. Retain each fixture helper’s TID until its join, wait at most five seconds for that specific task to disappear, and only then let the baseline be counted. Keep every existing exact thread/socket-count check and all production code unchanged.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
MinGW GCC checks the session logger’s format(printf) attribute against Microsoft’s format dialect, which rejects %zu even when the fixture requests MinGW ANSI stdio. Print the three wire byte counts with %u and explicit unsigned casts; all are bounded by COOP_MAX_DGRAM. Apply the same portable format to the protocol fixture’s maximum-payload diagnostic. Keep format attributes and -Werror intact, with no build-wide stdio override or runtime behavior change.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
This is a progress-sync fix found by warp, independent of the warp and feature-rule changes. It is intended to be cherry-picked onto the six-commit stack by itself.

Use the save total-play-time counter rather than seconds spent in the current area. The old counter resets in the common area-change completion path, so ordinary doors and loading zones that change area spuriously re-offer an accepted room and require another backup on reacceptance. The Players s2 field-and-back session and Warp s1 silently reaccepted under HOS_COOP_ACCEPT=always; the manual-menu stack proof and other stationary proofs did not exercise that boundary.

Keep all existing load detection unchanged. Independent area and total counters now exercise each transition flag through the real merge engine: area changes preserve the accepted offer and existing copy; another slot, the same slot loaded again with unchanged time, and a new game each invalidate the old offer and require a new acceptance and copy before application. No existing checks removed or weakened. GCC and Clang pass; the extended fixture fails against the prior binding with both compilers. No new GPU run.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Raise the default member limits to 480 forwarded copies and 256 KiB per second, with double bursts and command-line options. Charge every broadcast copy to both budgets.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Reseal missing event fragments until receipt, bind them to accepted sender and recipient sessions, and dispatch each whole event once in per-sender FIFO order. Keep state datagrams independent.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Publish the progress engine consent decision to the session without a game dependency. Refresh it after identity, removal, roster and save changes, and reject bindings for another member session.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
List allocated and reserved kinds, state and event calls, traffic limits, receiver checks, and a ten-line integration example.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Run the single-room relay on its own socket and thread. Make connects the local session over loopback; friends use the maker’s reachable UDP address. Keep cookie proof, sealed forwarding, bounded budgets, and joined shutdown.

Exercise the shared relay cases, session scenarios, settings and lifecycle without the game. Document the single-room limits and the port-forwarding requirement.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Replace a cached refusal after a charged change of reason, as the Python relay does. A request that changes back must pay again. The new test fails before this change and passes against both relays.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Treat each sent event id as the oldest live id for its recipient, so a cancelled partial cannot block later events. Bind acknowledgement masks to the receiver assembly epoch and retain consent transitions between socket steps. Keep completed receipts and reject delayed older-epoch acknowledgements.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
The settings fixture sets HOS_COOP_HOST to an empty value and expects
"off". A Windows process cannot hold an empty variable: _putenv_s(name,
"") removes it, so the game reads the ini value there, as it should,
and the Windows checks failed on "host switch environment precedence"
and "off override does not host" for that one mode. On Windows the
fixture now expects the unset behaviour for the empty mode; elsewhere
the empty value is still set and still means off.

Tested: Linux, GCC 16.2.1 and Clang 23.1.3: tests/test_coop_host_relay.py
passes as before. The fixture compiled for the Windows target (clang
--target=x86_64-w64-mingw32, syntax only): no error, no warning.
Not tested: run on Windows (the project's Windows job does that; it is
the job that showed the failure).

Assisted-by: Claude Fable 5.2
Co-Authored-By: Claude Fable 5.2 <[email protected]>
The fixture's helper was named accept. On Windows the host's network
header brings in winsock2.h, which declares accept(), so the Windows
checks could not compile the fixture ("conflicting types for 'accept'")
and the event tests never ran there. The helper is named grant.

Tested: all eight C fixtures this branch adds or changes compiled for
the Windows target (clang --target=x86_64-w64-mingw32, -Wall -Wextra,
syntax only): this fixture had 15 errors before and has none now; the
four other co-op fixtures show none (three fixtures that take their
sources or defines from their Python drivers cannot be judged by that
pass). Linux, GCC 16.2.1 and Clang 23.1.3: tests/test_coop_events.py
passes as before.
Not tested: run on Windows (the project's Windows job does that).

Assisted-by: Claude Fable 5.2
Co-Authored-By: Claude Fable 5.2 <[email protected]>
"Adding a layer" told layer authors to heal damage state with one
running total merged by highest-wins. That loses a hit when two players
strike at once: totals of 2 and 2 merge to 2, not 4. The rule that
works is a running total per player and enemy, each merged by the
highest value seen, then the players' totals added together. The
sentence says so now.

Docs only.

Assisted-by: Claude Fable 5.2
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Windows permits a same-user specific-address bind beside a default wildcard
bind, including the IPv4 half of a dual-stack socket. Another program could
receive datagrams meant for the game's session or hosted relay, or send from
an overlapping local endpoint and disturb the room. It cannot decrypt sealed
player messages without the room secret; relay-control metadata is not sealed.
The Windows session CI failure exposed this as cross-test Alice/Bob traffic,
not a reason to serialize the fixture or relax its roster/message checks.

Set SO_EXCLUSIVEADDRUSE before binding native Windows co-op sockets and the
Python relay. Close the socket and fail when exclusivity cannot be obtained.
A relay bound to a specific address owns that requested address, not unrelated
interfaces. Linux enables neither SO_REUSEADDR nor SO_REUSEPORT and already
rejects overlapping binds; no reuse option is added there.

Keep all concurrent session cases. Add real wildcard/specific IPv4 bind probes
in both orders, including a competing reuse request, on Windows and Linux.
Compile the actual Windows open function against a call recorder to check
option ordering and failure cleanup without a Windows machine. The recorder
and Python option check fail on the old source and pass on the fix; real
Windows kernel execution remains required in the fork workflow. Preserve
-Werror and add the fixture's secure-CRT guards before includes.

Binding rules: https://learn.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
The local Windows preflight found that several co-op drivers declared the
CRT policy in only their fixture, or not until after an included header.
Their separately compiled game sources and the forced environment header
therefore still produced secure-CRT deprecation diagnostics.

Set the existing project policy before those headers, use compile-wide
Windows flags for multi-unit fixtures, and let existing fixture
prefixes coexist with that flag. Cover all three Co-op menu compilations,
not just the first one reached before the capture stops at execution.
Keep the existing compiler warnings, assertions, and concurrent modes.
No game or protocol behavior changes here.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Keep the existing Longshot domains and pin their exact bytes against future branding changes. Regenerate sealed payloads with the C reference fixture and the vector file with test_coop_relay.py --write-vectors. Document the Hookshot/Longshot interoperability boundary.

The same reference with only the old domain inputs reproduces the original vector file byte-for-byte; the original port commits are unchanged.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
The shared predicate continues with the co-op keys instead of ending at auto_steps. Keep every Auto persistence key assertion.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
main's third-party check now requires a tree-sha256 line in each part's PROVENANCE.md; written by 'python -I scripts/check_third_party.py --update monocypher'. No file of the library changes.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
fix(coop): integrate the reviewed text-field controls and fixtures
Some checks failed
PR description / Description follows the template (pull_request_target) Successful in 4s
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
Website / Website on Cloudflare (pull_request) Has been cancelled
f841f54400
Keep the parent text-field implementation and its appendable API checks. Show character-picker prompts only where a field supplies that picker; Co-op text fields retain caret, removal, paste and confirmation controls. Exercise both prompt sets from the real menu block.

Update the Co-op fixture key definitions, extract the actual edit helpers without pulling in unrelated room actions, and give the upscaler save/load fixture the same inert Co-op stand-ins as the existing menu fixtures. Keep all parent pad/full-width/paste/shape and upscaler checks.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Port the reviewed parked rule and menu changes onto the Longshot relay foundation. Keep Longshot signature domains, format 5 and one API24 metadata callback; retain the existing EVENT helper and current output-size and Auto persistence behavior.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep all wire-domain assertions. Only the charter signing role advanced with numbered features; the protocol fixture must pin Longshot format5 for both engine and authored signed fixture.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The rebased menu parser records whether output_res is present. Supply that existing startup-local flag in the extracted feature-rules fixture; all registry and persistence assertions remain unchanged.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep received terms separate from local defaults, pin both confirmation presses, refuse unsupported modes and format4, and keep PvP setup incapable of starting gameplay.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Named settings consult the current room even while the menu is closed. The mode leads both local drafts and received read-only terms; local defaults remain separate.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The real menu tick cleared the pending Accept as soon as its preview selected a Rules row. Preserve that pending action only while reading the signed terms; the existing stale-offer, changed-selection and closed-menu paths still disarm it.

The fixture now executes the actual tick cancellation block and Back transition between presses. It fails on a9cc1bea before this correction.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep the no-focus wiring assertion and require its narrowly scoped reading-terms exception. The compiled GCC and Clang behavior already passed; this updates the additional old-expression source assertion.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Execute the actual tab-navigation and closed-menu cleanup blocks after arming Accept. Returning and reopening must require a new first press, never complete the cancelled one. Production code is unchanged.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep exact-offer cancellation while distinguishing signed membership revisions from rule and pool changes. Show PvP-only acceptance help and logs, and omit Change on read-only Rules. Add source-backed signed admission fixtures and catalogue coverage; reserve API 27 for the expanded received view.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Retain the opaque-change assertion while making its authored roster match the host view contract; duplicate zero IDs had falsely resembled changed membership.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Separate presentation, temporary and durable writers. Exact version and size checks fail closed; queued tickets bind current context and accepted sessions. Route progress through its sole writer under the existing lock, and make switching co-op off stop guest reads.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Port the existing private body generator and bounded pose adapter onto Longshot. Require signed presence permission and current accepted tickets before native effects, defer request storage until permitted, refuse adult body poses in this family, and preserve native actor-generation guards. No outside multiplayer code, tables or assets are imported.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
A new presentation grant starts a fresh pose history while retaining the session replay floor. Publish only validated capabilities and keep the child-only contract explicit.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Remove the unused adult native actor path from this first body family while retaining explicit adult-pose refusal and codec coverage.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
An authored timestamp can place the receiver offset at INT32_MAX. Keep the next same-offset sample bounded, and retain recovery when a smaller offset arrives. The game-free fixture exercises both cases.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Preserve startup allocation refusal after deferred storage, normalize received rotations, clamp interpolation weights and avoid overflowing finite animation endpoints. Authored fixtures cover each boundary.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Require the generated actor pack and exact source-version actor/resource tables by one extensible list instead of the obsolete child-plus-adult file count. Preserve user-mod precedence and disable animation on replacements; exercise the real loader against authored generator output.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The acceptance-log extraction now includes the child visibility helpers used by publish. Supply the existing default-option host stub in the neighboring real mod-routing fixture.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Read the same per-slot phase as the native current-frame query. Keep the duration binding in the game-free fixture as a distinct value so a mistaken function address cannot pass again.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Generate a separately named local AS graph whose primary slot uses the source full-body mask. Keep other partials and overlays, do not import the real player controller, and require the generated graph through the shared asset contract. Authored fixtures check the binding, dynamic mask lookup, unchanged source and fail-closed output.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Use the Windows CRT environment calls in the synthetic native adapter fixture; retain the same POSIX behavior and every pose assertion.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
The S03 finish-stage actor generator was accidentally routed through the prompt fixture drawing stub, causing 46 false cache failures. Keep the complete production prompt branch and every existing assertion; reject any unrelated generator in the stub. Production prompt code is unchanged.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Copy under the native save barrier, select the private root only at restart, and return by selecting the unchanged normal root. Keep interrupted copies and refuse incomplete or altered restart tickets.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep automatic room consent off across copy/return restarts, preserve read-only RomFS paths, and guard temporary backup paths. Exercise the native write fence and temporary progress gate.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Refuse linked temporary backup paths, keep the read overlay away from native user mounts, and exercise writable/read-only saves, existence and cache enumeration through their real mount functions. Use wide Windows copy paths.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Update the existing startup/relaunch wiring checks without dropping their shutdown, environment or ordering requirements. The native mount fixture keeps UTF-8 filename coverage without relying on a Windows UTF-8 argv manifest.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The expanded native mount fixture uses the real cache-storage refusal path; supply its filesystem result constant without changing any guard or assertion.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The mount helper receives native backslash-separated subpaths. Keep the two-entry enumeration assertion and construct the first cache with that same contract.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Use API 26 for the combined received-terms and temporary-save view, retaining rule-change command 9 and copy/return command 10. Refuse durable writer capability for a temporary profile even when called directly, with a recording boundary regression.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep the two-press copy/return action on the same host command and Linux close/relaunch path when no SDL window exists. Poll close requests while the game thread runs, retaining the preparation worker wait. Exercise windowless request delivery, idle waits, and the actual menu action with authored fixtures.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The full build found that the temporary-save action used a no-argument fixture stand-in instead of the renderer API. Use force=true as ordinary Restart does. Extract the actual vk_draw.h declaration into the behavioral fixture and pin its function type so future signature drift fails before a game build.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Exercise the real menu pending-action cleanup between first and second presses, including changed selection and refused copy. This action stays on its own row; no additional renderer defect was found.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep the save-domain note on its own line so it cannot hide a refusal. Exercise the extracted header rendering and box bounds at three scales.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Separate download consent from progress acceptance, bind offers and receipts to identities and sessions, and stream two fixed file kinds through the existing reliable-event helper. Keep partials unmountable, retain signed manifests, and cancel only the transfer scope on deadlines, revocation or disk failure.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep the complete versioned signature domain, preserve the verified manifest on disk, recheck permission and clocks after filesystem work, and bound terminal control retries. Add independent disk-hash and publication-revocation coverage.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
A valid opposite-direction offer can choose the same transfer ID. Match its manifest as well so its signed cancellation cannot be hidden by the outgoing offer. Show the received charter terms in the local download preview, and retain the before-fix behavioral regression.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep warnings as errors while explicitly discarding the parameter made unused by the mutation. Its failure must come from the behavioral scope assertion, not compilation.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Carry every numbered received feature and the room admission reason into the download preview. Exercise missing/off/unknown/old-format and stale-token refusal at the actual download consent boundary, separately from native progress acceptance.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Exercise a real simulated network/update interval after accepting the exact download preview, before checking the independent member mask and closed progress gates. Unlike menu Accept this path has no pending renderer confirmation.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Port the original committed-hit observer onto the signed-rule foundation of pull request 68. Observe native setup, instance renewal and sensor-off operations without applying any remote damage. Retain pre-clamp aggregate and original requested life through Protect hearts, count successful atomic writes only, and drain bounded scalar observations outside native workers. Reuse EVENT rather than a separate retry loop.

Game-free behavioral fixtures cover native hooks, protected overkill, receiver admission and bounded delivery; execution is recorded separately. No game runtime or playable-duel claim.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
The synthetic sensor-off body must use its context argument even when the old lift patch adds no observer. Keep strict compiler warnings and let missing native observation fail behavioral assertions, not compilation. This fixture-only annotation does not change production code; negative execution remains pending quiet-window admission.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Restore the frozen line ordering while keeping the reviewed parent text-field prompts and Damage taken policy.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Keep native loss requests and every setup/renewal header independent of optional diagnostic detail and the room mutex. Report cumulative accounting, pending publication and sticky overflow with explicit no-drain bounds; preserve observation-only semantics.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Snapshot accepted recipients as unicasts and recheck consent under the send lock. A revoke/reaccept cannot revive queued positions. Receiver admission is unchanged.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Use age-specific local actor packs and the existing sole body writer. Carry bounded cosmetic equipment in POS v3, resolve only local supported pieces, and read lasting native hand state. Generated animation follows the local display switch unless explicitly overridden.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Extend the shared generator/loader contract to both actor and animation pairs. Exercise both ages in authored full-body and missing-mask checks while retaining passive equipment and fail-closed loader coverage. Adult runtime remains unproven.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Reuse submitted-camera name projection with bounded offscreen arrows, independently permissioned map and heart disclosure, fresh accepted snapshots and a live local display setting. No health authority or game run.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Retain all existing room action checks and separately assert the local label row. Match the production C++ static-assert spelling and prerequisite header order.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assert Names defaults, names-and-arrows reload and Off save without duplicate keys. Keep explicit CRT policy before fixture headers for Windows syntax checks.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Normalize direction before the bounded square root instead of deprecated MinGW hypot. Supply native fixture environment helpers on Windows and remove the unused inherited helper from the rule-persistence fixture.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
HudNames added viewport publication and its off-path query inside the extracted present block. Supply both fixture boundaries and exercise labels off, full viewport and crop coordinates without removing the geometry and bounded-log checks.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Preserve the keyboard footer fixture context and run the actual Damage taken implementation through both observed life-write paths.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Reuse the native map request and character-controller placement, with explicit signed permission, accepted pose freshness and cancellation at the native map boundary. Keep unreviewed entrances closed.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Use a fixed-size copy between disjoint name buffers; keep all old menu checks alongside the new rows.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Share strict UTF-8 decoding with scripted text; keep persistence fixture callbacks aligned with API 27.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Reuse the existing row scroller with space reserved for the member list; show unavailable chat explicitly.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Use signed semantic kit masks, native pouch giving and worn-equipment selection with capacity and live-slot readback. Refuse unsupported families and normal mounts; retain one-shot setup across cancellation without progress export.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep native combat fail-closed until receiver contact, damage and private arena surveys are proven. Implement the game-free Ready/countdown, descriptor and round contracts without game health or save writes.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Keep ordinary acceptance, progress, pools and save-download consent isolated from copy-only see-and-talk permission. Bind presentation to the exact signed offer and sessions, retire it on lifecycle changes, and retain native owner tickets and the off-path early return.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Run the new copy-presence menu case alongside the other independent cases instead of before the existing off-room baseline. Keep every original refusal assertion.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Use the fixture compiler flag required by the Windows-target checker before all headers, retaining strict diagnostics and every behavioral assertion.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Unify the presentation mask, preserve per-session pose send fences, and keep kit effects behind a separate exact-copy two-press command. Use menu API29 for every added view and callback. Explain refused position versions instead of silently omitting a body.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Keep retry attempts and unresolved recipient retirements in the session stats line without changing retry policy. Cover no-loss completion, lost ACKs, revoke, deadline, cancellation and reset, including full-width counter formatting.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
The combined translation unit already has an incoming event_discard helper. Give the stats-aware outgoing retirement path its own name and retain the cancellation mutation anchor.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Keep recorder include ordering, distinct controller-picker and Unicode fields, local notice preset exemption, remote-only duel consent and exact kit/menu/version checks.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Exercise the combined overlays, dynamic menu rows, complete damage hook and unified scrolling while preserving the reviewed parent assertions.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Keep the real-engine no-durable/download boundaries, independent presence and kit admission, combined privacy-mask and native off-path checks.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Use the existing C-assert spelling bridge for C++ fixtures, start received-term extraction after its forward declaration, and retain all seven categories after removing both local preferences.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Exercise the shared engine, host tick/publication and save runtime with an actual temporary profile and authored checkpoints. Retain isolated normal-save behavior and catch restored missing-offer, identity, terms, manifest, signature and presentation-boundary defects.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Document the existing engine-owned offer used by both the menu and save bridge, independent download and presentation consent, and the regression that restores the old empty-offer gate.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
Retain a verified maker/owner charter while a third member remains unidentified past the wait interval. Require a real nonzero offer, then refuse consent and export; removing the unidentified guard must fail under both compilers.

Assisted-by: GPT-6 Astra

Co-Authored-By: GPT-6 Astra <[email protected]>
fix(coop): normalize native save roots before profile I/O
All checks were successful
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 14s
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 3s
CI / Workflow lint (actionlint) (pull_request) Successful in 6s
Third-party parts / As their notes say (pull_request) Successful in 8s
0ec9d0b024
Normalize external user and export roots at the profile boundary before POSIX I/O, reusing the same separator rule for path validation. Reject parent components before following them. Exercise actual save-mount and export functions with their native separators, exact signed manifests and filesystem refusals.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Author
Member

Two-player co-op playtest: r12

This is an experimental test, not a finished multiplayer release. Use commit 2f01e1b4bdb6e1629c54a998f0403519fe4e5c74 (r12) on both PCs, Linux source 05329d46. The pull request's branch is still named coop-playtest-r9 for historical reasons; pin the commit, not the branch suffix. All six short proofs passed on this r12 head with two games on one Linux PC. Windows runtime, two-machine and 30-minute results already posted on the pull request belong to earlier heads, not r12. No Windows runtime, two-machine session or 30-minute result is claimed for this head.

Plan for 10 to 15 minutes of play after building and initial shader preparation. Loading and preparation are not part of that estimate. Start with child saves. One tester hosts on Linux, the other joins on Windows; the Windows/network part is what this test is meant to find out.

What each tester needs

  • Their own supported Switch 2 game dump and their own save. Do not exchange a built game, save, generated body assets, game files or keys.
  • A PC that can run Longshot, with enough memory and a supported Vulkan driver. Record Windows/Linux version, GPU and driver, CPU and RAM. Allow about 60 GB for building, as the source guide specifies.
  • The same source commit, built separately for each platform. A current release or pull request 68 alone is not this line.
  • A keyboard for entering names, the relay address and chat. The controller has confirm/back/paste controls, but this line adds no controller character picker.
  • A private way to exchange the host address, room secret and displayed identity fingerprints. Do not put the room secret in a public report or screenshot.

Obtain the playtest branch and pin it:

git clone --branch coop-playtest-r9 --single-branch https://git.magicbean.dev/mooki/Longshot.git coop-playtest-source
git -C coop-playtest-source checkout 2f01e1b4bdb6e1629c54a998f0403519fe4e5c74

Follow that checkout's CONTRIBUTING.md, Development setup and Building. Windows uses Python and llvm-mingw, with LONGSHOT_MINGW pointing to it and the documented Builder prerequisites. Linux needs the documented compiler, headers and Python dependencies; its packaged build instructions use Ubuntu 22.04 or the provided container route. Do not update an ordinary playing installation to test this branch.

From the prepared source checkout, build into a new game folder using your own dump, for example:

python -I nx2/make_game.py --nup "your-game.nup" --out "../coop-playtest-r12-game" --work "work/coop-r12"

Replace your-game.nup with your own file. This is the normal full build, including locally generated co-op bodies. Keep its executable and renderer together; do not mix products from different commits. The reference instructions are https://git.magicbean.dev/mooki/Longshot/src/branch/coop-playtest-r9/CONTRIBUTING.md and https://git.magicbean.dev/mooki/Longshot/src/branch/coop-playtest-r9/docs/coop.md.

Keep the normal save out of the test

  1. Close your ordinary game. Make an offline backup of your own saves.
  2. Inside the new test game folder, create a new folder named coop-playtest-user. Copy only your own save directory, retaining its numbered subfolders, into it. Do not copy someone else's user folder or the coop-keys directory. Each player must have a separate test root and identity. A new disposable game is also fine, but is not a quick substitute for a prepared checkpoint.
  3. Always start the actual game executable with --user "./coop-playtest-user". A source build normally has longshot.exe or longshot directly in its output folder. Packaged builds put the real executable in bin; the outer launcher does not forward --user.
  4. Check the startup fs: mounted lines and the chosen save before accepting a room. They must refer to this test root, never the usual save directory. If they do not, stop without accepting.
  5. The test then uses Temporary save as a second layer of isolation. Its restart creates a working copy below this test root's coop-sessions, and Return to normal saves returns to this test root, not the original installation. Normal and copy acceptance do not carry across those restarts.

For a source-built game, run from its new game folder:

.\longshot.exe --user ".\coop-playtest-user"
./longshot --user "./coop-playtest-user"

For a packaged game use bin\longshot.exe or bin/longshot instead. Keep this explicit --user argument on every manual restart, especially after a crash. An ordinary restart does not automatically resume an interrupted native temporary copy. Do not import the test's progress back into the usual save folder.

Windows Copy/Return still needs a real game window. Do not use HOS_HEADLESS=1 for this route. A restart creates a new Windows process; the first process ending is not proof of a completed Return. Wait for the replacement window and check its new fs: mounted lines before continuing. Never create or copy a restart ticket by hand.

R12 keeps runtime program/pipeline/preparation caches under cache/, Vulkan pipeline files as cache/longshot_vk_pipelines*, and generated prompt files under cache/prompts/. Use a new writable r12 game folder; do not copy Linux driver caches into Windows or move files out of a running r9 folder. Initial preparation is still needed for the target PC. The game's shipped data and longshot_options.ini stay at their documented locations.

Settings before starting

Edit only the test game's longshot_options.ini, with that game closed. Set these on both PCs:

coop=0
coop_players=1
coop_room_mode=0
coop_progress=0
coop_items=0
coop_songs=0
coop_quest=0
coop_keys=0
coop_rupees=0
coop_ammo=0
coop_presence_permissions=1
coop_names=1
coop_labels=1
coop_social_permissions=1
coop_notices=1
coop_warp=0
coop_hit_events=0
coop_combat_mode=0
coop_loadout_version=0

Here category value 0 means Own. Presence value 1 permits child bodies only; it does not enable fighting, gear, health, place or arrows. Chat is enabled here for an explicitly agreed trial, not because it was already proven on r12. coop=0 prevents automatic connection; Make or Join turns it on for the current run. The maker's signed rules, not the joiner's local draft, govern the room.

The Linux host additionally sets coop_host=1; the Windows joiner sets coop_host=0. Remove any inherited co-op environment overrides, automatic joining/acceptance, diagnostic feeds or loss simulation from the test launch. Do not use HOS_COOP_ACCEPT=always. HOS_COOP* values written in longshot_env.txt are ignored; these settings belong in the options file or the process's own environment.

On Windows Intel Arc, keep the newer base's intel_shader_compiles=0, which admits one compiler thread at a time. Leave RX_VK_NO_INTEL_SERIAL unset; do not use it to bypass that safety default. The inherited hold-to-toggle controls default to off and Mono output to Auto; neither needs changing for this route. If a follow-up asks for diagnostic commands, use scripts/longshot_ctl.py from this exact r12 checkout: it now reports sampled game state, which can remain old at the title, during a pause or while loading. An advancing reply counter alone does not establish fresh play state.

Host and join using the game itself

No separate relay program is needed. The firewall example below is retained from the previous head 0ec9d0b0; it does not claim a two-machine r12 session. A new executable path on Windows can require a fresh firewall decision for the intended private network.

  • Host: leave Relay empty for the default UDP port 24680, then use Make a room. The log says hosting on this PC and prints hosting: players on this network can try .... The host's own client connects over loopback.
  • Joiner on the same LAN: put the host's printed LAN address and port in Relay. Do not use 127.0.0.1 on the second PC. Choose Join a room and enter the secret shared privately by the host.
  • The host's firewall, also on a home network: the host's PC has to allow incoming UDP 24680 from the joiner's PC. On Windows the first hosting brings up Windows' own firewall prompt; allowing it for private networks is enough. On Linux with a firewall that blocks incoming traffic, allow that one port for the other PC. If the port is blocked the joiner only sees Connecting: no answer from the relay, and the host sits alone in its room; nothing else is wrong. The host's log can print more than one address: use the home-network one. Tried between a Linux PC and a Windows 11 PC: #355 (comment)
  • Across the internet: the host needs that one UDP port reachable through the router and the intended firewall network; the joiner uses the public address and port. The game does not open ports, discover the public address or bypass carrier-grade NAT. If it is unreachable, report that rather than disabling the firewall or changing unrelated security settings. A separately arranged reachable relay is a different test.
  • Use the ordinary LAN or internet path, not a VPN/tailnet, for this test. Record which was used. The first LAN session does not prove internet/NAT behavior.
  • When the host leaves or closes the game, its hosted room ends. The other player can keep playing locally, but the room cannot exchange data until hosted again.

The 10-to-15-minute route

Use menu labels, not a remembered row number: rows appear, disappear and scroll with room state. Insert opens the menu, and the Co-op tab is at the end. Follow the displayed keyboard/controller prompts.

Play time What both testers do Expected result; what to report
0 to 3 minutes With no room open, load the copied child checkpoint, save normally and wait until Saving ends. Select Temporary save and confirm twice. Wait for restart, load the checkpoint again and check the copy reminder. The game is now on a native temporary copy. Keep the fs: mounted lines showing the new copy root. A failed copy must not be bypassed by accepting on the ordinary save.
3 to 6 minutes Host makes a room; joiner enters its address and secret. Set distinct test names. Compare both displayed fingerprints privately. Host selects Accept to see and talk, reads Room rules, goes Back and confirms. Once the membership/terms settle, the joiner does the same. Before acceptance there should be no remote body or chat. Both should see the same signed maker and terms. A changed offer cancels a pending press; read it again, do not repeatedly confirm blindly. Copy-only presence is itself a new live test.
6 to 8 minutes Meet in the same child area, stay on clear ground and take turns standing, turning and walking a short distance while the other watches. Look for both complete bodies, normal colours, arms-down standing and visible steps rather than sliding. Note missing bodies, wrong age, stuck poses or labels covering the screen. Remote sword/shield display is not enabled in this minimal configuration.
8 to 10 minutes Try one short chat message each with T or Chat. Cancel another with Esc. Optionally mute, send one more line, then unmute. If both agree, the maker can change Friend information from 1 to 77 and both freshly accept; select Names and arrows, then walk briefly out of one another's view in the same map. Chat should reach only accepted peers and typing/cancelling should not move or attack with Link. Mute is local. Value 77 is child + health + arrows + place; these extra displays are tests, not existing runtime guarantees. Changed signed terms must require a new acceptance. A maker on a copy must first accept see-and-talk before editing rules.
10 to 12 minutes Make one ordinary local change in A's copy, such as an available chest pickup, and let it autosave while B watches its own world. Do not use the practice kit for this check. A's copy may change; B must not receive progress from copy-only consent. The normal saves must not change. A missing available pickup is not a failure: record that this step was not tried.
12 to 13 minutes Joiner selects Leave the room and confirms twice. Watch both views before making any new room. Remote bodies should disappear and chat should stop. Rejoining is optional; it needs current identity/terms and fresh acceptance where offered. Do not treat a reconnect as automatically accepted.
13 to 15 minutes Both use Return to normal saves through the Temporary save row and confirm twice. After restart, check the test-root mount and the original copied checkpoint, then quit normally. Return must select the disposable normal root without importing copy progress. Keep the changed temporary copy for diagnosis. The original installation's save is outside the test throughout. Save the logs before later launches rotate them away.

If anything unexpected changes the save, the game crashes, or either player cannot tell which save domain is active, stop that session and preserve the logs. Do not delete the copy or try to repair it by importing another save.

What is not part of this short test

  • Fighting is disabled. Ready and sword swings do not prove a hit or a block. The six proofs observed no committed player health loss during one bounded five-swing interval; that is not playable PvP.
  • Progress is not shared unless ordinary-save room terms explicitly allow it and both players accept with a completed backup. Native temporary copies never share ordinary progress, even if their signed Rules page displays Shared. This guide uses Own categories and copies deliberately.
  • Go to friend is unavailable on native temporary copies. A later, separately agreed test can use disposable normal roots with coop_warp=1; only Kokiri Forest and Hyrule Field are supported. Safe actual arrivals are not proven by the six proofs. Do not return to the real save just to make the row available.
  • Adult bodies, cosmetic sword/shield display and the separately confirmed practice kit need their own tests. The kit supports only the documented child or adult sword/shield pair, not a full item palette; it grants no permission to fight.
  • No shared enemies/bosses, shared time, save-owner picker, loading a downloaded checkpoint, or returning progress from a temporary copy. The signed-transfer proof used separate local control-API approvals; there is no ordinary save-transfer menu to look for.
  • The room can describe up to 8 members, but only two simultaneous games were proven here. The short tests do not settle long sessions, packet loss, relay restart, internet reachability or performance.
  • Some diagnostic prose is shortened or misleading: pending PvP can mention progress; a body-retirement line can call Leave a map change. Use the actual signed Rules page and observed state, and include the suspect line in the report.

What to send back

Send a short result from each tester: exact commit/source line, OS, GPU/driver, CPU/RAM, host or joiner, LAN or internet, duration, which route steps worked/failed/not tried, and the first unexpected action. Say whether the normal save stayed unchanged and how you checked. A picture or short video of both views is useful; mask the room secret and unrelated private information.

The documented default game log is now logs/longshot_log.txt in the game folder. The four preceding runs are logs/longshot_log.1.txt through logs/longshot_log.4.txt. Copy/Return restart the process, so retain the rotated files too. A game started from a terminal prints there instead; an explicitly redirected launch keeps its chosen output file and may leave logs/ empty. Retain that actual output, rather than assuming a missing default file means nothing happened. Preserve output from every restarted process. The README documents these names at https://git.magicbean.dev/mooki/Longshot/src/branch/coop-playtest-r9/README.md.

Keep the complete relevant logs, plus these lines around the failure:

  • The first version/source line and vk: device identifying the GPU and driver.
  • fs: mounted lines before Copy, on the temporary copy and after Return. Redact personal path prefixes when posting, but keep enough to distinguish the save domains.
  • coop: hosting / hosting: players on this network can try ..., coop: connecting to the relay, the relay answered, created, joined room, and any no room: refusal. Share network addresses privately when needed, not in a public screenshot.
  • coop: sync: acceptance and changed-offer lines; coop: players: creation, hiding/deletion or asset/matching-build refusals.
  • Every coop: stats: line, especially reliable retries, events given up, outbox full and round trip. Given-up events include intentional cancellations, so do not label that total packet loss.
  • coop: relay lost; rejoining, is away, is back, left room, and the final shutdown or error lines.
  • coop: kit: only if a separate kit test was explicitly agreed. Chat text is not logged: describe a failed message without expecting to find its contents in the log.

HOS_COOP_TRACE=1 can add packet and body details when a focused follow-up asks for them; it also logs relay addresses and can make a large log. It is not needed for the first attempt. Do not send saves, identity keys, room secrets, game files, generated assets or a whole user folder. Return the report to the WIP line or #68 while that remains the collection point.

# Two-player co-op playtest: r12 This is an experimental test, not a finished multiplayer release. Use **commit `2f01e1b4bdb6e1629c54a998f0403519fe4e5c74` (r12)** on both PCs, Linux source **`05329d46`**. The pull request's branch is still named **`coop-playtest-r9`** for historical reasons; pin the commit, not the branch suffix. All six short proofs passed on this r12 head with two games on one Linux PC. Windows runtime, two-machine and 30-minute results already posted on the pull request belong to earlier heads, not r12. No Windows runtime, two-machine session or 30-minute result is claimed for this head. Plan for **10 to 15 minutes of play after building and initial shader preparation**. Loading and preparation are not part of that estimate. Start with child saves. One tester hosts on Linux, the other joins on Windows; the Windows/network part is what this test is meant to find out. ## What each tester needs - Their own supported Switch 2 game dump and their own save. Do not exchange a built game, save, generated body assets, game files or keys. - A PC that can run Longshot, with enough memory and a supported Vulkan driver. Record Windows/Linux version, GPU and driver, CPU and RAM. Allow about 60 GB for building, as the source guide specifies. - The same source commit, built separately for each platform. A current release or pull request 68 alone is not this line. - A keyboard for entering names, the relay address and chat. The controller has confirm/back/paste controls, but this line adds no controller character picker. - A private way to exchange the host address, room secret and displayed identity fingerprints. Do not put the room secret in a public report or screenshot. Obtain the playtest branch and pin it: ```text git clone --branch coop-playtest-r9 --single-branch https://git.magicbean.dev/mooki/Longshot.git coop-playtest-source git -C coop-playtest-source checkout 2f01e1b4bdb6e1629c54a998f0403519fe4e5c74 ``` Follow that checkout's `CONTRIBUTING.md`, Development setup and Building. Windows uses Python and llvm-mingw, with `LONGSHOT_MINGW` pointing to it and the documented Builder prerequisites. Linux needs the documented compiler, headers and Python dependencies; its packaged build instructions use Ubuntu 22.04 or the provided container route. Do not update an ordinary playing installation to test this branch. From the prepared source checkout, build into a **new** game folder using your own dump, for example: ```text python -I nx2/make_game.py --nup "your-game.nup" --out "../coop-playtest-r12-game" --work "work/coop-r12" ``` Replace `your-game.nup` with your own file. This is the normal full build, including locally generated co-op bodies. Keep its executable and renderer together; do not mix products from different commits. The reference instructions are https://git.magicbean.dev/mooki/Longshot/src/branch/coop-playtest-r9/CONTRIBUTING.md and https://git.magicbean.dev/mooki/Longshot/src/branch/coop-playtest-r9/docs/coop.md. ## Keep the normal save out of the test 1. Close your ordinary game. Make an offline backup of your own saves. 2. Inside the new test game folder, create a new folder named `coop-playtest-user`. Copy **only your own `save` directory**, retaining its numbered subfolders, into it. Do not copy someone else's user folder or the `coop-keys` directory. Each player must have a separate test root and identity. A new disposable game is also fine, but is not a quick substitute for a prepared checkpoint. 3. Always start the **actual game executable** with `--user "./coop-playtest-user"`. A source build normally has `longshot.exe` or `longshot` directly in its output folder. Packaged builds put the real executable in `bin`; the outer launcher does not forward `--user`. 4. Check the startup `fs: mounted` lines and the chosen save before accepting a room. They must refer to this test root, never the usual save directory. If they do not, stop without accepting. 5. The test then uses **Temporary save** as a second layer of isolation. Its restart creates a working copy below this test root's `coop-sessions`, and **Return to normal saves** returns to this test root, not the original installation. Normal and copy acceptance do not carry across those restarts. For a source-built game, run from its new game folder: ```powershell .\longshot.exe --user ".\coop-playtest-user" ``` ```sh ./longshot --user "./coop-playtest-user" ``` For a packaged game use `bin\longshot.exe` or `bin/longshot` instead. Keep this explicit `--user` argument on every manual restart, especially after a crash. An ordinary restart does not automatically resume an interrupted native temporary copy. Do not import the test's progress back into the usual save folder. **Windows Copy/Return still needs a real game window.** Do not use `HOS_HEADLESS=1` for this route. A restart creates a new Windows process; the first process ending is not proof of a completed Return. Wait for the replacement window and check its new `fs: mounted` lines before continuing. Never create or copy a restart ticket by hand. R12 keeps runtime program/pipeline/preparation caches under `cache/`, Vulkan pipeline files as `cache/longshot_vk_pipelines*`, and generated prompt files under `cache/prompts/`. Use a new writable r12 game folder; do not copy Linux driver caches into Windows or move files out of a running r9 folder. Initial preparation is still needed for the target PC. The game's shipped data and `longshot_options.ini` stay at their documented locations. ## Settings before starting Edit only the test game's `longshot_options.ini`, with that game closed. Set these on **both** PCs: ```ini coop=0 coop_players=1 coop_room_mode=0 coop_progress=0 coop_items=0 coop_songs=0 coop_quest=0 coop_keys=0 coop_rupees=0 coop_ammo=0 coop_presence_permissions=1 coop_names=1 coop_labels=1 coop_social_permissions=1 coop_notices=1 coop_warp=0 coop_hit_events=0 coop_combat_mode=0 coop_loadout_version=0 ``` Here category value 0 means **Own**. Presence value 1 permits **child bodies only**; it does not enable fighting, gear, health, place or arrows. Chat is enabled here for an explicitly agreed trial, not because it was already proven on r12. `coop=0` prevents automatic connection; Make or Join turns it on for the current run. The maker's signed rules, not the joiner's local draft, govern the room. The **Linux host** additionally sets `coop_host=1`; the Windows joiner sets `coop_host=0`. Remove any inherited co-op environment overrides, automatic joining/acceptance, diagnostic feeds or loss simulation from the test launch. Do not use `HOS_COOP_ACCEPT=always`. `HOS_COOP*` values written in `longshot_env.txt` are ignored; these settings belong in the options file or the process's own environment. On **Windows Intel Arc**, keep the newer base's `intel_shader_compiles=0`, which admits one compiler thread at a time. Leave `RX_VK_NO_INTEL_SERIAL` unset; do not use it to bypass that safety default. The inherited hold-to-toggle controls default to off and Mono output to Auto; neither needs changing for this route. If a follow-up asks for diagnostic commands, use `scripts/longshot_ctl.py` from this exact r12 checkout: it now reports sampled game state, which can remain old at the title, during a pause or while loading. An advancing reply counter alone does not establish fresh play state. ## Host and join using the game itself No separate relay program is needed. The firewall example below is retained from the previous head `0ec9d0b0`; it does not claim a two-machine r12 session. A new executable path on Windows can require a fresh firewall decision for the intended private network. - **Host:** leave **Relay** empty for the default UDP port **24680**, then use **Make a room**. The log says `hosting on this PC` and prints `hosting: players on this network can try ...`. The host's own client connects over loopback. - **Joiner on the same LAN:** put the host's printed LAN address and port in **Relay**. Do not use `127.0.0.1` on the second PC. Choose **Join a room** and enter the secret shared privately by the host. - **The host's firewall, also on a home network:** the host's PC has to allow incoming UDP 24680 from the joiner's PC. On Windows the first hosting brings up Windows' own firewall prompt; allowing it for private networks is enough. On Linux with a firewall that blocks incoming traffic, allow that one port for the other PC. If the port is blocked the joiner only sees `Connecting: no answer from the relay`, and the host sits alone in its room; nothing else is wrong. The host's log can print more than one address: use the home-network one. Tried between a Linux PC and a Windows 11 PC: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17499 - **Across the internet:** the host needs that one UDP port reachable through the router and the intended firewall network; the joiner uses the public address and port. The game does not open ports, discover the public address or bypass carrier-grade NAT. If it is unreachable, report that rather than disabling the firewall or changing unrelated security settings. A separately arranged reachable relay is a different test. - Use the ordinary LAN or internet path, not a VPN/tailnet, for this test. Record which was used. The first LAN session does not prove internet/NAT behavior. - When the host leaves or closes the game, its hosted room ends. The other player can keep playing locally, but the room cannot exchange data until hosted again. ## The 10-to-15-minute route Use menu labels, not a remembered row number: rows appear, disappear and scroll with room state. **Insert** opens the menu, and the Co-op tab is at the end. Follow the displayed keyboard/controller prompts. | Play time | What both testers do | Expected result; what to report | |---|---|---| | 0 to 3 minutes | With no room open, load the copied child checkpoint, save normally and wait until Saving ends. Select **Temporary save** and confirm twice. Wait for restart, load the checkpoint again and check the copy reminder. | The game is now on a native temporary copy. Keep the `fs: mounted` lines showing the new copy root. A failed copy must not be bypassed by accepting on the ordinary save. | | 3 to 6 minutes | Host makes a room; joiner enters its address and secret. Set distinct test names. Compare both displayed fingerprints privately. Host selects **Accept to see and talk**, reads Room rules, goes Back and confirms. Once the membership/terms settle, the joiner does the same. | Before acceptance there should be no remote body or chat. Both should see the same signed maker and terms. A changed offer cancels a pending press; read it again, do not repeatedly confirm blindly. Copy-only presence is itself a new live test. | | 6 to 8 minutes | Meet in the same child area, stay on clear ground and take turns standing, turning and walking a short distance while the other watches. | Look for both complete bodies, normal colours, arms-down standing and visible steps rather than sliding. Note missing bodies, wrong age, stuck poses or labels covering the screen. Remote sword/shield display is not enabled in this minimal configuration. | | 8 to 10 minutes | Try one short chat message each with **T** or **Chat**. Cancel another with Esc. Optionally mute, send one more line, then unmute. If both agree, the maker can change **Friend information** from 1 to **77** and both freshly accept; select **Names and arrows**, then walk briefly out of one another's view in the same map. | Chat should reach only accepted peers and typing/cancelling should not move or attack with Link. Mute is local. Value 77 is child + health + arrows + place; these extra displays are tests, not existing runtime guarantees. Changed signed terms must require a new acceptance. A maker on a copy must first accept see-and-talk before editing rules. | | 10 to 12 minutes | Make one ordinary local change in A's copy, such as an available chest pickup, and let it autosave while B watches its own world. Do not use the practice kit for this check. | A's copy may change; B must not receive progress from copy-only consent. The normal saves must not change. A missing available pickup is not a failure: record that this step was not tried. | | 12 to 13 minutes | Joiner selects **Leave the room** and confirms twice. Watch both views before making any new room. | Remote bodies should disappear and chat should stop. Rejoining is optional; it needs current identity/terms and fresh acceptance where offered. Do not treat a reconnect as automatically accepted. | | 13 to 15 minutes | Both use **Return to normal saves** through the Temporary save row and confirm twice. After restart, check the test-root mount and the original copied checkpoint, then quit normally. | Return must select the disposable normal root without importing copy progress. Keep the changed temporary copy for diagnosis. The original installation's save is outside the test throughout. Save the logs before later launches rotate them away. | If anything unexpected changes the save, the game crashes, or either player cannot tell which save domain is active, stop that session and preserve the logs. Do not delete the copy or try to repair it by importing another save. ## What is not part of this short test - **Fighting is disabled.** Ready and sword swings do not prove a hit or a block. The six proofs observed no committed player health loss during one bounded five-swing interval; that is not playable PvP. - **Progress is not shared unless ordinary-save room terms explicitly allow it and both players accept with a completed backup.** Native temporary copies never share ordinary progress, even if their signed Rules page displays Shared. This guide uses Own categories and copies deliberately. - **Go to friend is unavailable on native temporary copies.** A later, separately agreed test can use disposable normal roots with `coop_warp=1`; only Kokiri Forest and Hyrule Field are supported. Safe actual arrivals are not proven by the six proofs. Do not return to the real save just to make the row available. - Adult bodies, cosmetic sword/shield display and the separately confirmed practice kit need their own tests. The kit supports only the documented child or adult sword/shield pair, not a full item palette; it grants no permission to fight. - No shared enemies/bosses, shared time, save-owner picker, loading a downloaded checkpoint, or returning progress from a temporary copy. The signed-transfer proof used separate local control-API approvals; there is no ordinary save-transfer menu to look for. - The room can describe up to 8 members, but only two simultaneous games were proven here. The short tests do not settle long sessions, packet loss, relay restart, internet reachability or performance. - Some diagnostic prose is shortened or misleading: pending PvP can mention progress; a body-retirement line can call Leave a map change. Use the actual signed Rules page and observed state, and include the suspect line in the report. ## What to send back Send a short result from **each** tester: exact commit/source line, OS, GPU/driver, CPU/RAM, host or joiner, LAN or internet, duration, which route steps worked/failed/not tried, and the first unexpected action. Say whether the normal save stayed unchanged and how you checked. A picture or short video of both views is useful; mask the room secret and unrelated private information. The documented default game log is now **`logs/longshot_log.txt` in the game folder**. The four preceding runs are **`logs/longshot_log.1.txt` through `logs/longshot_log.4.txt`**. Copy/Return restart the process, so retain the rotated files too. A game started from a terminal prints there instead; an explicitly redirected launch keeps its chosen output file and may leave `logs/` empty. Retain that actual output, rather than assuming a missing default file means nothing happened. Preserve output from every restarted process. The README documents these names at https://git.magicbean.dev/mooki/Longshot/src/branch/coop-playtest-r9/README.md. Keep the complete relevant logs, plus these lines around the failure: - The first version/source line and `vk: device` identifying the GPU and driver. - `fs: mounted` lines before Copy, on the temporary copy and after Return. Redact personal path prefixes when posting, but keep enough to distinguish the save domains. - `coop: hosting` / `hosting: players on this network can try ...`, `coop: connecting to the relay`, `the relay answered`, `created`, `joined room`, and any `no room:` refusal. Share network addresses privately when needed, not in a public screenshot. - `coop: sync:` acceptance and changed-offer lines; `coop: players:` creation, hiding/deletion or asset/matching-build refusals. - Every `coop: stats:` line, especially `reliable retries`, `events given up`, `outbox full` and `round trip`. Given-up events include intentional cancellations, so do not label that total packet loss. - `coop: relay lost; rejoining`, `is away`, `is back`, `left room`, and the final shutdown or error lines. - `coop: kit:` only if a separate kit test was explicitly agreed. Chat text is not logged: describe a failed message without expecting to find its contents in the log. `HOS_COOP_TRACE=1` can add packet and body details when a focused follow-up asks for them; it also logs relay addresses and can make a large log. It is not needed for the first attempt. Do not send saves, identity keys, room secrets, game files, generated assets or a whole user folder. Return the report to the WIP line or https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/68 while that remains the collection point.
Author
Member

One continuous 30-minute two-game session on this branch's build (0ec9d0b0), two windowless games on one Linux PC (RTX 4090, NVIDIA 615.78.08), hosted by the game itself, one acceptance each, then standing, short walks towards and away from each other, a chat line every five minutes and idle stretches.

What held for the whole 1,803 seconds:

Check Result
Connection One create, one join, one acceptance per game; no disconnect, rejoin or room change until the planned shutdown
Bodies Both full bodies in both views in every inspected state, from the first picture to the last
Chat All seven lines (minutes 1, 5, 10, 15, 20, 25, 29) visibly delivered in both games, with the friend's name above the body
Counters 32 statistics lines per game, all increasing; 0 retried fragments, 0 given up, 0 refused, 0 outbox-full
Memory Growth from minute 2 to the end: 63.8 MiB and 36.7 MiB (limit set beforehand: 512 MiB); no swap
Frames No interval above one second in either game's frame record (121,856 and 118,215 frames)
Saves Both normal saves and the original test save byte-identical afterwards
Exits Both games exit 0; no driver line in the kernel log
Minute A sent / accepted B sent / accepted Retries A / B RSS MiB A / B
0 1291 / 395 649 / 1584 0 / 0 9577.3 / 9553.0
10 10811 / 10055 10190 / 11222 0 / 0 9589.3 / 9594.7
20 20323 / 19679 19692 / 20851 0 / 0 9599.8 / 9624.8
30 29830 / 29298 29196 / 30477 0 / 0 9629.6 / 9625.5

What the run did not meet: the plan, written before the run, wanted each game's presence read every five seconds. The reader managed 265 paired readings at a median of 6.6 s, with gaps up to 18.9 s while pictures were being taken. That is the test's own shortfall, not something the games did (their frame records kept advancing through those gaps), but it means presence was not observed at the planned rate. By the plan's rule the soak is therefore not an unqualified pass, and it was not run a second time.

Minute 15: A types a line, it appears in both games, both bodies and both names stay in view.
Minute 30: both games still show both bodies.

Not covered by this run: two machines, Windows, a map change, items or shared progress, the save copy and return (shown separately in the six proofs), adult bodies and equipment. It is an ordinary functional run, not a speed or smoothness measurement. The traffic was on one PC over the loopback address.

One continuous 30-minute two-game session on this branch's build (`0ec9d0b0`), two windowless games on one Linux PC (RTX 4090, NVIDIA 615.78.08), hosted by the game itself, one acceptance each, then standing, short walks towards and away from each other, a chat line every five minutes and idle stretches. **What held for the whole 1,803 seconds:** | Check | Result | |---|---| | Connection | One create, one join, one acceptance per game; no disconnect, rejoin or room change until the planned shutdown | | Bodies | Both full bodies in both views in every inspected state, from the first picture to the last | | Chat | All seven lines (minutes 1, 5, 10, 15, 20, 25, 29) visibly delivered in both games, with the friend's name above the body | | Counters | 32 statistics lines per game, all increasing; 0 retried fragments, 0 given up, 0 refused, 0 outbox-full | | Memory | Growth from minute 2 to the end: 63.8 MiB and 36.7 MiB (limit set beforehand: 512 MiB); no swap | | Frames | No interval above one second in either game's frame record (121,856 and 118,215 frames) | | Saves | Both normal saves and the original test save byte-identical afterwards | | Exits | Both games exit 0; no driver line in the kernel log | | Minute | A sent / accepted | B sent / accepted | Retries A / B | RSS MiB A / B | |---:|---:|---:|---:|---:| | 0 | 1291 / 395 | 649 / 1584 | 0 / 0 | 9577.3 / 9553.0 | | 10 | 10811 / 10055 | 10190 / 11222 | 0 / 0 | 9589.3 / 9594.7 | | 20 | 20323 / 19679 | 19692 / 20851 | 0 / 0 | 9599.8 / 9624.8 | | 30 | 29830 / 29298 | 29196 / 30477 | 0 / 0 | 9629.6 / 9625.5 | **What the run did not meet:** the plan, written before the run, wanted each game's presence read every five seconds. The reader managed 265 paired readings at a median of 6.6 s, with gaps up to 18.9 s while pictures were being taken. That is the test's own shortfall, not something the games did (their frame records kept advancing through those gaps), but it means presence was not observed at the planned rate. By the plan's rule the soak is therefore not an unqualified pass, and it was not run a second time. ![Minute 15: A types a line, it appears in both games, both bodies and both names stay in view.](https://git.magicbean.dev/attachments/486a0f15-dbc8-489a-b06f-10be4e8d2dab) ![Minute 30: both games still show both bodies.](https://git.magicbean.dev/attachments/df1c9274-1976-494d-801e-3d6756da4079) **Not covered by this run:** two machines, Windows, a map change, items or shared progress, the save copy and return (shown separately in the six proofs), adult bodies and equipment. It is an ordinary functional run, not a speed or smoothness measurement. The traffic was on one PC over the loopback address.
Author
Member

Two machines: a Linux PC and a Windows 11 PC on a home network. Until now every proof here ran two games on one PC over the loopback address. This is the first session across a real network and across operating systems, on head 0ec9d0b0 on both.

Linux PC Windows 11 PC
Hardware i9-13900K, RTX 4090, NVIDIA 615.78.08 Core Ultra 9 185H, Intel Arc, driver 32.0.101.9175
Build Linux build of 0ec9d0b0 Windows build of 0ec9d0b0, cross-built
Save and identity its own disposable copy of a test save, its own identity its own disposable copy, its own identity

Settings: Co-op mode, every progress category per player, child bodies on, chat on; nothing shared, no fighting, no transfer. The game's own hosting on UDP 24680, home-network addresses. Joining was scripted with a private room secret; consent and Leave went through the real menu rows on each machine.

Windows hosts, Linux joins: works

Step Linux (joiner) Windows (host)
Connection the relay answers at the Windows PC's home-network address, joined hosting on UDP 24680, joined
Signed terms maker fingerprint 1a52-512e-5836-45fd, same rules the same fingerprint and rules
Acceptance once, through the menu once, through the menu
The other's body the Windows player's child body shown, then six walking moves played the Linux player's child body shown, then six walking moves played
Chat its line sent, the Windows line shown the Linux line shown, its line sent
Leave body hidden and removed, 0 failed body hidden and removed, 0 failed, notice "CrossLinux left"
Exit and saves exit 0, all 14 save files unchanged exit 0 after 391 s, all 14 save files unchanged

Last counters of each game:

Linux:   coop: stats: sent 2395, accepted 2368, thrown away 0 (tag 0, sender 0, not co-op 0, replay 0), dropped by the test 0, outbox full 0, reliable retries 0, events given up 0, round trip 1 ms
Windows: coop: stats: sent 2296, accepted 2459, thrown away 0 (tag 0, sender 0, not co-op 0, replay 0), dropped by the test 0, outbox full 0, reliable retries 0, events given up 0, round trip 1 ms

The Linux game logged a round trip of 1 to 4 ms to the Windows host over the session.

The signed, read-only rules on both machines: the same maker fingerprint and the same per-player categories. Left Linux, right the Windows window.

After both accepted: each machine shows the other player as a complete, normally coloured child body.

Walking crosses the wire both ways: the Windows player mid-step on Linux, the Linux player mid-step on Windows (different moments, from an earlier run of the same session).

One chat line each way, shown on the sender and on the receiver.

After Leave: only the local player remains on each machine; Windows shows the notice that the other left.

Linux hosts, Windows joins: blocked by the host PC's firewall, not by the game

The Linux game hosted and sat in its room alone; the Windows game sent its join packets to the Linux PC's home-network address and showed "Connecting: no answer from the relay; trying again in 15 s". The Linux PC's firewall logged those exact packets as blocked (incoming UDP 24680). Three attempts, the same each time; no firewall was changed for this test. So a host has to allow incoming UDP 24680 from the other player's PC. On Windows the first hosting brings up Windows' own firewall prompt, and allowing it for private networks was enough here.

What each side shows when the host's firewall drops the port: the host alone in its room, the joiner with "no answer from the relay", both playing on locally.

One thing a player cannot tell from that message is which side is at fault; a hint about the host's firewall in that text would save a search.

What this does not cover

  • Short sessions of about six minutes on normal disposable saves. The save-copy route (play on a copy, autosave, Return), the save transfer, kits, fighting and Go to friend were not run on Windows; the six proofs above are Linux only.
  • A scripted join with a private secret, not a person typing the address and the secret.
  • One Windows PC with one GPU, a home network only: no connection across the internet, no other Windows or GPU setup.
  • No claim about speed or smoothness, and nothing about Intel rendering beyond these pictures.
  • The Windows test build shows "Longshot unknown" in the menu's corner because it was cross-built without a version stamp; it is the same commit.
**Two machines: a Linux PC and a Windows 11 PC on a home network.** Until now every proof here ran two games on one PC over the loopback address. This is the first session across a real network and across operating systems, on head `0ec9d0b0` on both. | | Linux PC | Windows 11 PC | |---|---|---| | Hardware | i9-13900K, RTX 4090, NVIDIA 615.78.08 | Core Ultra 9 185H, Intel Arc, driver 32.0.101.9175 | | Build | Linux build of `0ec9d0b0` | Windows build of `0ec9d0b0`, cross-built | | Save and identity | its own disposable copy of a test save, its own identity | its own disposable copy, its own identity | Settings: Co-op mode, every progress category per player, child bodies on, chat on; nothing shared, no fighting, no transfer. The game's own hosting on UDP 24680, home-network addresses. Joining was scripted with a private room secret; consent and Leave went through the real menu rows on each machine. ### Windows hosts, Linux joins: works | Step | Linux (joiner) | Windows (host) | |---|---|---| | Connection | the relay answers at the Windows PC's home-network address, joined | hosting on UDP 24680, joined | | Signed terms | maker fingerprint `1a52-512e-5836-45fd`, same rules | the same fingerprint and rules | | Acceptance | once, through the menu | once, through the menu | | The other's body | the Windows player's child body shown, then six walking moves played | the Linux player's child body shown, then six walking moves played | | Chat | its line sent, the Windows line shown | the Linux line shown, its line sent | | Leave | body hidden and removed, 0 failed | body hidden and removed, 0 failed, notice "CrossLinux left" | | Exit and saves | exit 0, all 14 save files unchanged | exit 0 after 391 s, all 14 save files unchanged | Last counters of each game: ```text Linux: coop: stats: sent 2395, accepted 2368, thrown away 0 (tag 0, sender 0, not co-op 0, replay 0), dropped by the test 0, outbox full 0, reliable retries 0, events given up 0, round trip 1 ms Windows: coop: stats: sent 2296, accepted 2459, thrown away 0 (tag 0, sender 0, not co-op 0, replay 0), dropped by the test 0, outbox full 0, reliable retries 0, events given up 0, round trip 1 ms ``` The Linux game logged a round trip of 1 to 4 ms to the Windows host over the session. ![The signed, read-only rules on both machines: the same maker fingerprint and the same per-player categories. Left Linux, right the Windows window.](https://git.magicbean.dev/attachments/08f0649c-c606-4dbc-b22b-16a2e131144d) ![After both accepted: each machine shows the other player as a complete, normally coloured child body.](https://git.magicbean.dev/attachments/97ad6594-9f1e-4965-ad44-562c0e70ba78) ![Walking crosses the wire both ways: the Windows player mid-step on Linux, the Linux player mid-step on Windows (different moments, from an earlier run of the same session).](https://git.magicbean.dev/attachments/1ca742bc-e252-4362-88cc-6cf746cad3a9) ![One chat line each way, shown on the sender and on the receiver.](https://git.magicbean.dev/attachments/298d7068-297d-4252-b0bd-1ba1530d159e) ![After Leave: only the local player remains on each machine; Windows shows the notice that the other left.](https://git.magicbean.dev/attachments/e95c29f8-7164-40c9-9548-5f7bdfbea568) ### Linux hosts, Windows joins: blocked by the host PC's firewall, not by the game The Linux game hosted and sat in its room alone; the Windows game sent its join packets to the Linux PC's home-network address and showed "Connecting: no answer from the relay; trying again in 15 s". The Linux PC's firewall logged those exact packets as blocked (incoming UDP 24680). Three attempts, the same each time; no firewall was changed for this test. So a host has to allow incoming UDP 24680 from the other player's PC. On Windows the first hosting brings up Windows' own firewall prompt, and allowing it for private networks was enough here. ![What each side shows when the host's firewall drops the port: the host alone in its room, the joiner with "no answer from the relay", both playing on locally.](https://git.magicbean.dev/attachments/6deebf94-4070-4535-90f2-27aba7165d6c) One thing a player cannot tell from that message is which side is at fault; a hint about the host's firewall in that text would save a search. ### What this does not cover - Short sessions of about six minutes on normal disposable saves. The save-copy route (play on a copy, autosave, Return), the save transfer, kits, fighting and Go to friend were not run on Windows; the six proofs above are Linux only. - A scripted join with a private secret, not a person typing the address and the secret. - One Windows PC with one GPU, a home network only: no connection across the internet, no other Windows or GPU setup. - No claim about speed or smoothness, and nothing about Intel rendering beyond these pictures. - The Windows test build shows "Longshot unknown" in the menu's corner because it was cross-built without a version stamp; it is the same commit.
mooki force-pushed coop-playtest-r9 from 0ec9d0b024
All checks were successful
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 14s
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 3s
CI / Workflow lint (actionlint) (pull_request) Successful in 6s
Third-party parts / As their notes say (pull_request) Successful in 8s
to 1ed75e61b5
All checks were successful
CI / Workflow lint (actionlint) (pull_request) Successful in 5s
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
Third-party parts / As their notes say (pull_request) Successful in 9s
CI / Conventional Commit title (pull_request) Successful in 4s
PR description / Description follows the template (pull_request_target) Successful in 13s
2026-11-14 06:35:21 +00:00
Compare
Author
Member

Updated to 1ed75e61b5bc083247950a262b1a48230f44909a (r10), source c058db8c, replayed onto pull request 68's current head 4a9b9606: #68. The branch name coop-playtest-r9 is historical; both testers should pin the new commit. Its base is main cf605c85b, not today's 0caf06184, which is three commits later.

All 80 line commits remain, and the co-op core is unchanged. Three separate fixture fixes follow the replay:

  • test_menu_feature_rules.py: supply the newer parser's Plus/Minus exclusions.
  • test_menu_text_field.py: combine pad/text callbacks and retain the correct input sections beside chat.
  • test_oot_coop_hits.py: use the newer damage-policy interface and check overkill on both native update paths.

The new head was rebuilt from a fresh game-code translation. The whole suite reports 578 passed, 3 failed, 16 skipped; the failures are the pinned main's test_framegen_resources.py, test_module_ids.py and test_pad_layout.py. All 26 added drivers pass within the 52 added-or-modified drivers, all of which pass. No check was weakened or removed.

All six two-game proofs pass on r10: signed terms and fresh consent; bodies appearing and leaving; reciprocal child standing/walking; native save copy, autosave and Return; signed checkpoint transfer and partial cancellation; five visible sword swings with complete health records and no committed player loss through that observed path. The description now has eight pictures from this build.

The first S03 attempt remains a failed visual proof: other compilation was running, and the same 72-frame walks lasted 1.85 and 2.03 seconds instead of about 1.20 seconds, moving the bodies outside the cameras. With other compilation kept out, the unchanged route passed; no game code, input length or camera was changed, and this is not a controlled performance comparison.

The r10 Windows build links and has reached the title, but has not shown Windows gameplay. The two-machine LAN result and the qualified 30-minute session remain evidence for the previous head 0ec9d0b0 only: #355 (comment) and #355 (comment). No result from the new r10 30-minute session is claimed. This stays WIP; fighting remains disabled, and the updated guide names the new commit, logs/ and cache/ locations and Windows startup limits.

Updated to `1ed75e61b5bc083247950a262b1a48230f44909a` (r10), source `c058db8c`, replayed onto pull request 68's current head `4a9b9606`: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/68. The branch name `coop-playtest-r9` is historical; both testers should pin the new commit. Its base is main `cf605c85b`, not today's `0caf06184`, which is three commits later. All 80 line commits remain, and the co-op core is unchanged. Three separate fixture fixes follow the replay: - `test_menu_feature_rules.py`: supply the newer parser's Plus/Minus exclusions. - `test_menu_text_field.py`: combine pad/text callbacks and retain the correct input sections beside chat. - `test_oot_coop_hits.py`: use the newer damage-policy interface and check overkill on both native update paths. The new head was rebuilt from a fresh game-code translation. The whole suite reports **578 passed, 3 failed, 16 skipped**; the failures are the pinned main's `test_framegen_resources.py`, `test_module_ids.py` and `test_pad_layout.py`. All 26 added drivers pass within the 52 added-or-modified drivers, all of which pass. No check was weakened or removed. **All six two-game proofs pass on r10:** signed terms and fresh consent; bodies appearing and leaving; reciprocal child standing/walking; native save copy, autosave and Return; signed checkpoint transfer and partial cancellation; five visible sword swings with complete health records and no committed player loss through that observed path. The description now has eight pictures from this build. The first S03 attempt remains a failed visual proof: other compilation was running, and the same 72-frame walks lasted 1.85 and 2.03 seconds instead of about 1.20 seconds, moving the bodies outside the cameras. With other compilation kept out, the unchanged route passed; no game code, input length or camera was changed, and this is not a controlled performance comparison. The r10 Windows build links and has reached the title, but has not shown Windows gameplay. The two-machine LAN result and the qualified 30-minute session remain evidence for **the previous head `0ec9d0b0` only**: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17499 and https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17281. No result from the new r10 30-minute session is claimed. This stays WIP; fighting remains disabled, and the updated guide names the new commit, `logs/` and `cache/` locations and Windows startup limits.
Author
Member

R10: thirty minutes completed, but body continuity failed

Tested commit 1ed75e61b5bc083247950a262b1a48230f44909a, source c058db8c, with two windowless games on one Linux PC, RTX 4090 and NVIDIA 615.78.08. The game hosted the room over loopback. Each player accepted once, then took short walks, stood idle and sent the seven planned chat lines. Other compilation was kept out.

The completed session is not a pass. Around 18 minutes 14 to 19 seconds, game A logged hiding and deleting B's body, followed by creating it again. B has no corresponding body removal. The room stayed connected and accepted, and no load, travel or Leave was requested.

A's native log says:

coop: puppet: member 2 is hidden (this game stopped being played: a map change or a load)
coop: players: this game stopped being played: a map change or a load: made 1, deleted 1 (1 by this game, 0 gone with their map), 0 still shown, 0 requests failed
coop: players: nobody is shown now: made 1, deleted 1 (1 by this game, 0 gone with their map), 0 still shown, 0 requests failed

It then reports the child body shown again. Both changes fall within one five-second native-clock bracket; the exact missing duration is unknown. Nearby fresh readings still show the same place with no event or loading. The surrounding pictures show both bodies before and after, not the missing instant. The reason for that brief change is not established. The live check missed the actual hide line; reviewing the whole log caught it, so normal exits are not being counted as a pass.

Both attempts remain on record

The first attempt stopped at minute 4 when its combined same-process/zero-swap check failed. The failing value was not saved before the check, so it cannot be recovered. The logs show one native start and one socket generation per game, with no evidence of a process change. Its cause remains undetermined.

I chose the single restart on that undetermined stop, not on a proven test-only failure. Before restarting, I also changed the zero-swap criterion openly: this PC already held about 12 GiB of other programs' pages in compressed zram, with swappiness 150. Swap became a recorded observation rather than a stop by itself, and memory growth became resident plus swapped memory, keeping the predeclared 512 MiB final-growth limit. Process identity remained a separate hard check. All measurements were written before checking them, with the PC's memory and paging counters alongside them.

The restarted games happened to report zero swapped memory in all 31 samples each. That does not explain the first attempt's lost value. No third attempt was made.

Results beside the previous head

The earlier result remains #355 (comment).

Check Previous head 0ec9d0b0 R10 completed restart 1ed75e61
Continuous accepted interval 1,803.5 s 1,800.1 s
Disconnects or rejoins 0 0
Reliable retries / events given up 0 / 0 in both games 0 / 0 in both games
Logged relay round trip 1 ms 1 ms
Growth from minute 2, A / B 63.8 / 36.7 MiB; swap 0 25.9 / 27.3 MiB including reported swap; swap 0
Game-present gaps above one second 0 0
State and room readings 265 pairs; median 6.6 s, maximum 18.9 s 361 pairs; median 5.000000 s, maximum 5.000186 s
Native body continuity No in-session removal in either game's log One A-side hide/delete/recreate; fails the rule
Chat All seven lines shown in both games All seven lines shown in both games
Normal saves and original test save Byte-identical afterward Byte-identical afterward
Exits / kernel driver lines Both 0 / none Both 0 / none

The first r10 attempt separately had four gaps above one second during startup/entry, none in its reached accepted interval. It must not be confused with the completed restart's zero gaps. The different memory values are observations from individual runs, not a controlled claim that r10 is faster or uses less memory.

The five-second schedule is now met, including during walking and pictures. Its local-state and room readings cannot, by themselves, prove the remote body exists between them; the native lifetime records remain necessary.

Not covered: two PCs, Windows, internet traffic, physical input, map changes, items or shared progress, save copy/Return, transfers, adult equipment or fighting. Copy/Return belongs to the separate six-proof result. This remains an ordinary functional test, not a speed, smoothness or general leak-free claim.

The cause of that one hide and recreate is being looked for in the code that decides a game has stopped being played; the result follows here.

## R10: thirty minutes completed, but body continuity failed Tested commit `1ed75e61b5bc083247950a262b1a48230f44909a`, source `c058db8c`, with two windowless games on one Linux PC, RTX 4090 and NVIDIA 615.78.08. The game hosted the room over loopback. Each player accepted once, then took short walks, stood idle and sent the seven planned chat lines. Other compilation was kept out. **The completed session is not a pass.** Around 18 minutes 14 to 19 seconds, game A logged hiding and deleting B's body, followed by creating it again. B has no corresponding body removal. The room stayed connected and accepted, and no load, travel or Leave was requested. A's native log says: ```text coop: puppet: member 2 is hidden (this game stopped being played: a map change or a load) coop: players: this game stopped being played: a map change or a load: made 1, deleted 1 (1 by this game, 0 gone with their map), 0 still shown, 0 requests failed coop: players: nobody is shown now: made 1, deleted 1 (1 by this game, 0 gone with their map), 0 still shown, 0 requests failed ``` It then reports the child body shown again. Both changes fall within one five-second native-clock bracket; the exact missing duration is unknown. Nearby fresh readings still show the same place with no event or loading. The surrounding pictures show both bodies before and after, not the missing instant. The reason for that brief change is not established. The live check missed the actual hide line; reviewing the whole log caught it, so normal exits are not being counted as a pass. ### Both attempts remain on record The first attempt stopped at minute 4 when its combined same-process/zero-swap check failed. The failing value was not saved before the check, so it cannot be recovered. The logs show one native start and one socket generation per game, with no evidence of a process change. Its cause remains undetermined. **I chose the single restart on that undetermined stop, not on a proven test-only failure.** Before restarting, I also changed the zero-swap criterion openly: this PC already held about 12 GiB of other programs' pages in compressed zram, with swappiness 150. Swap became a recorded observation rather than a stop by itself, and memory growth became **resident plus swapped memory**, keeping the predeclared 512 MiB final-growth limit. Process identity remained a separate hard check. All measurements were written before checking them, with the PC's memory and paging counters alongside them. The restarted games happened to report **zero swapped memory in all 31 samples each**. That does not explain the first attempt's lost value. No third attempt was made. ### Results beside the previous head The earlier result remains https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17281. | Check | Previous head `0ec9d0b0` | R10 completed restart `1ed75e61` | |---|---|---| | Continuous accepted interval | 1,803.5 s | 1,800.1 s | | Disconnects or rejoins | 0 | 0 | | Reliable retries / events given up | 0 / 0 in both games | 0 / 0 in both games | | Logged relay round trip | 1 ms | 1 ms | | Growth from minute 2, A / B | 63.8 / 36.7 MiB; swap 0 | 25.9 / 27.3 MiB including reported swap; swap 0 | | Game-present gaps above one second | 0 | 0 | | State and room readings | 265 pairs; median 6.6 s, maximum 18.9 s | 361 pairs; median 5.000000 s, maximum 5.000186 s | | Native body continuity | No in-session removal in either game's log | One A-side hide/delete/recreate; fails the rule | | Chat | All seven lines shown in both games | All seven lines shown in both games | | Normal saves and original test save | Byte-identical afterward | Byte-identical afterward | | Exits / kernel driver lines | Both 0 / none | Both 0 / none | The first r10 attempt separately had four gaps above one second during startup/entry, none in its reached accepted interval. It must not be confused with the completed restart's zero gaps. The different memory values are observations from individual runs, not a controlled claim that r10 is faster or uses less memory. The five-second schedule is now met, including during walking and pictures. Its local-state and room readings cannot, by themselves, prove the remote body exists between them; the native lifetime records remain necessary. **Not covered:** two PCs, Windows, internet traffic, physical input, map changes, items or shared progress, save copy/Return, transfers, adult equipment or fighting. Copy/Return belongs to the separate six-proof result. This remains an ordinary functional test, not a speed, smoothness or general leak-free claim. The cause of that one hide and recreate is being looked for in the code that decides a game has stopped being played; the result follows here.
Contributor

Windows results at r10 1ed75e61 (source as checked out, not a cross-build), for the "Windows" lines under Needs other testers. One PC, so no two-PC session from here.

Hardware: Windows 11 Pro 26300, i9-12900K, 64 GB, RTX 3080 10 GB (NVIDIA 621.14). Toolchain: llvm-mingw from the Longshot Builder's tools, Python 3.12.

1. The game-free suite, run natively on Windows (python -I -B tests/run_all.py, 24 at once): 556 passed, 6 failed, 35 skipped. Main 0caf0618 on the same PC, same run: 521 passed, 6 failed, 34 skipped. The 6 failures are the same tests on both, so this line adds none, and the 35 extra tests it brings all pass on Windows, including the co-op fixtures that compile and run here:

fails on both why (on main too)
test_pad_layout.py HoldToggle undeclared in the fixture since #137 (#331 fixes it)
test_release.py openssl not on the PATH (#144 has run_all find Git's); passes with it on the PATH
test_tested_configurations.py \r\n from the CLI's ASCII pipe on Windows
test_oot_state_tap.py no game listens on longshot-oot-test-<n> (Invalid argument)
test_module_ids.py, test_framegen_resources.py fail on main 0caf0618 on Windows too; not looked into

2. A native Windows build: nx2/lift.py --standalone --write and nx2/build.py --standalone at 1ed75e61, exit 0 in 610 s, no build error.

3. Two games on one Windows PC, each in a window that never took focus, with their own game folder (B a full copy of A's) and their own user folder. Each user folder had a copy of one played save (adult Link, Desert Colossus). Relay: scripts/coop_relay.py --host 127.0.0.1 --port 0, loopback only, so Windows Firewall's prompt and the game's own hosting were not tested. A: HOS_COOP_AUTO=create, coop_presence_permissions=3 in its longshot_options.ini; B: HOS_COOP_AUTO=join; both HOS_COOP_PLAYERS=1, HOS_COOP_ACCEPT=always, the same 18-character secret. The script loaded both saves, walked B forward 90 frames, then A, waited, quit B, then quit A.

  • Room: A room RSY… created (member 1), B joined room RSY… as member 2. Relay: WinA joined as member 1, WinB joined as member 2, then WinB (member 2) left (1/8) and WinA (member 1) left (0/8). A logged WinB (member 2) left the room, and both logged left room (the game is closing).
  • Consent and the save: each logged room accepted (HOS_COOP_ACCEPT=always); the save is copied first, then made coop-backup\first-20261114-0846xxZ before applying anything. the flag table reads as the game's getter does (28 flags checked). A kept its signing key under userA\coop-keys.
  • Normal saves unchanged: SHA-256 of all 14 files in each save\ before and after: identical for A and for B. The user folders gained only coop-backup, coop-keys (A) and temp.
  • Bodies: each game showed the other as PouchPlayer_Adult at the other's position (member 2 is shown as PouchPlayer_Adult at -4.01 100.13 0.06 (made in 104 ms)). A person watching both windows says each could see the other's Link. B was attacked by the Colossus enemies, which A doesn't show (expected: only players are shared), but A did show B being knocked back by the hits.
  • Counters: thrown away 0, reliable retries 0, events given up 0, round trip 1 ms, on both. No CRASH, no device loss; both exited on quit.
  • Animation: players: locally built animation assets missing or incomplete → standing models, in this dev build (no Builder asset step); so no walk animation was checked.

One thing to look at: the other body was shown and hidden repeatedly while both games stayed in Desert Colossus and in play (no control: state change at those points). In about 2.5 minutes, A logged 7 pairs of member 2 is shown as PouchPlayer_Adult ... / member 2 is hidden (this game stopped being played: a map change or a load). B logged member 1 is hidden (in no map) in step with them, made 7 times. So each game seems to decide every so often that it isn't being played, and tells the other "no map". Each body was re-made each time (34-1285 ms). I couldn't tie it to a cause from the logs. It might be the enemy hits and knockback (B was being attacked), or the windows being clicked by the person watching, since the log shows the foreground switching between them. But there's no line that says so.

Not done here: native Copy/Return (Temporary save) and the junction refusal on a real NTFS junction in the game. Both need the Co-op tab's two presses, which I can drive only by timed menu keys, so I'd do that as a separate run if it's still wanted. Also not done: hosting through the game, the firewall prompt, more than two players, and two PCs. Shots stay on this PC (game imagery), so none are attached.

Windows results at r10 **1ed75e61** (source as checked out, not a cross-build), for the "Windows" lines under Needs other testers. One PC, so no two-PC session from here. Hardware: Windows 11 Pro 26300, i9-12900K, 64 GB, RTX 3080 10 GB (NVIDIA 621.14). Toolchain: llvm-mingw from the Longshot Builder's tools, Python 3.12. **1. The game-free suite, run natively on Windows** (`python -I -B tests/run_all.py`, 24 at once): **556 passed, 6 failed, 35 skipped**. Main 0caf0618 on the same PC, same run: 521 passed, 6 failed, 34 skipped. The 6 failures are the same tests on both, so this line adds none, and the 35 extra tests it brings all pass on Windows, including the co-op fixtures that compile and run here: | fails on both | why (on main too) | |---|---| | `test_pad_layout.py` | `HoldToggle` undeclared in the fixture since #137 (#331 fixes it) | | `test_release.py` | `openssl` not on the PATH (#144 has run_all find Git's); passes with it on the PATH | | `test_tested_configurations.py` | `\r\n` from the CLI's ASCII pipe on Windows | | `test_oot_state_tap.py` | `no game listens on longshot-oot-test-<n> (Invalid argument)` | | `test_module_ids.py`, `test_framegen_resources.py` | fail on main 0caf0618 on Windows too; not looked into | **2. A native Windows build:** `nx2/lift.py --standalone --write` and `nx2/build.py --standalone` at 1ed75e61, exit 0 in 610 s, no build error. **3. Two games on one Windows PC**, each in a window that never took focus, with their own game folder (B a full copy of A's) and their own user folder. Each user folder had a copy of one played save (adult Link, Desert Colossus). Relay: `scripts/coop_relay.py --host 127.0.0.1 --port 0`, loopback only, so Windows Firewall's prompt and the game's own hosting were **not** tested. A: `HOS_COOP_AUTO=create`, `coop_presence_permissions=3` in its `longshot_options.ini`; B: `HOS_COOP_AUTO=join`; both `HOS_COOP_PLAYERS=1`, `HOS_COOP_ACCEPT=always`, the same 18-character secret. The script loaded both saves, walked B forward 90 frames, then A, waited, quit B, then quit A. - **Room:** A `room RSY… created (member 1)`, B `joined room RSY… as member 2`. Relay: `WinA joined as member 1`, `WinB joined as member 2`, then `WinB (member 2) left (1/8)` and `WinA (member 1) left (0/8)`. A logged `WinB (member 2) left the room`, and both logged `left room (the game is closing)`. - **Consent and the save:** each logged `room accepted (HOS_COOP_ACCEPT=always); the save is copied first`, then made `coop-backup\first-20261114-0846xxZ` before applying anything. `the flag table reads as the game's getter does (28 flags checked)`. A kept its signing key under `userA\coop-keys`. - **Normal saves unchanged:** SHA-256 of all 14 files in each `save\` before and after: identical for A and for B. The user folders gained only `coop-backup`, `coop-keys` (A) and `temp`. - **Bodies:** each game showed the other as `PouchPlayer_Adult` at the other's position (`member 2 is shown as PouchPlayer_Adult at -4.01 100.13 0.06 (made in 104 ms)`). A person watching both windows says each could see the other's Link. B was attacked by the Colossus enemies, which A doesn't show (expected: only players are shared), but A did show B being knocked back by the hits. - **Counters:** `thrown away 0`, `reliable retries 0`, `events given up 0`, round trip 1 ms, on both. No `CRASH`, no device loss; both exited on `quit`. - **Animation:** `players: locally built animation assets missing or incomplete` → standing models, in this dev build (no Builder asset step); so no walk animation was checked. **One thing to look at: the other body was shown and hidden repeatedly** while both games stayed in Desert Colossus and in play (no `control: state` change at those points). In about 2.5 minutes, A logged 7 pairs of `member 2 is shown as PouchPlayer_Adult ...` / `member 2 is hidden (this game stopped being played: a map change or a load)`. B logged `member 1 is hidden (in no map)` in step with them, made 7 times. So each game seems to decide every so often that it isn't being played, and tells the other "no map". Each body was re-made each time (34-1285 ms). I couldn't tie it to a cause from the logs. It might be the enemy hits and knockback (B was being attacked), or the windows being clicked by the person watching, since the log shows the foreground switching between them. But there's no line that says so. Not done here: native Copy/Return (Temporary save) and the junction refusal on a real NTFS junction in the game. Both need the Co-op tab's two presses, which I can drive only by timed menu keys, so I'd do that as a separate run if it's still wanted. Also not done: hosting through the game, the firewall prompt, more than two players, and two PCs. Shots stay on this PC (game imagery), so none are attached.
Author
Member

Thank you, this is exactly what the Windows lines were missing: the suite natively on Windows with the line's fixtures compiling and running there, a native build, and two games sharing a room with saves unchanged.

On the body being shown and hidden repeatedly: that needs explaining, and it is not what the guide or the proofs lead anyone to expect.

  • A 30-minute session here on the same head had one such hide and recreate (#355 (comment)). Its cause is a race in this line: a periodic roster update could briefly look like revoked permission. A fix for that is built and being proven now; the head will move when it passes.
  • Yours looks different in one way that matters. In that session only the viewing game logged a hide and the other game logged nothing. In yours B logs member 1 is hidden (in no map) in step with A, so game A itself reported that it was not in play, seven times in two and a half minutes. Two games in windows on one PC, one of them always in the background, and one player being hit, are both things the Linux proofs never had.

The code that makes that decision is being read against your description now. Three things from your run would narrow it, if the logs are still there:

  1. From A's log, the lines from two seconds before to two seconds after one member 2 is hidden line, and the same stretch of B's log.
  2. Whether the hide times line up with clicking from one window to the other, or with B being hit.
  3. Whether the game in the background kept its frame rate (the FPS counter in its corner) or dropped or froze while the other was in front.

Copy/Return and the junction refusal on Windows are still wanted, but they can wait for the next head so they are not spent on a commit that is about to be replaced. Your suite and build results stand for 1ed75e61 as posted.

Thank you, this is exactly what the Windows lines were missing: the suite natively on Windows with the line's fixtures compiling and running there, a native build, and two games sharing a room with saves unchanged. **On the body being shown and hidden repeatedly:** that needs explaining, and it is not what the guide or the proofs lead anyone to expect. - A 30-minute session here on the same head had one such hide and recreate (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17694). Its cause is a race in this line: a periodic roster update could briefly look like revoked permission. A fix for that is built and being proven now; the head will move when it passes. - Yours looks different in one way that matters. In that session only the viewing game logged a hide and the other game logged nothing. In yours B logs `member 1 is hidden (in no map)` in step with A, so game A itself reported that it was not in play, seven times in two and a half minutes. Two games in windows on one PC, one of them always in the background, and one player being hit, are both things the Linux proofs never had. The code that makes that decision is being read against your description now. Three things from your run would narrow it, if the logs are still there: 1. From A's log, the lines from two seconds before to two seconds after one `member 2 is hidden` line, and the same stretch of B's log. 2. Whether the hide times line up with clicking from one window to the other, or with B being hit. 3. Whether the game in the background kept its frame rate (the FPS counter in its corner) or dropped or froze while the other was in front. Copy/Return and the junction refusal on Windows are still wanted, but they can wait for the next head so they are not spent on a commit that is about to be replaced. Your suite and build results stand for `1ed75e61` as posted.
Contributor

The logs are still here. Short version: every hide came during a frame-rate collapse, which two games sharing one 10 GB RTX 3080 caused. They were over the driver's video-memory allowance. Window switching doesn't line up.

3. Frame rate. A's vi: ... fps over the last 5 s lines against its hides (log line numbers):

2565  52.3 fps
2578  vk: over the driver's video-memory allowance (4.5 of 4.4 GB)
2672   9.9 fps      2722  17.7 fps      2743   8.2 fps
2745  member 2 is hidden (this game stopped being played: a map change or a load)
2748  vk: over the driver's video-memory allowance (4.3 of 4.1 GB)
2760   2.4 fps over 6.4 s
2768  hidden        2772   3.1 fps
2782  hidden        2786   4.4 fps      2805   1.2 fps over 6.5 s      2810   1.6 fps
2820  hidden        2847   5.4 fps
2942  37.0 fps
2951  hidden        2954  vk: over the driver's video-memory allowance (4.3 of 3.8 GB)
2970   4.8 fps
2981  hidden        2988   6.4 fps      3003   8.0 fps      3053  20.6     3099  21.3
3119  vk: over the driver's video-memory allowance (4.3 of 4.3 GB)
3149  22.6 fps
3153  hidden

There's no hide in A's stretches at 37-52 fps. B ran at 17-60 fps. Its own single member 1 is hidden (this game stopped being played ...) (line 2662) came as it fell from 16.4 to 9.1 fps. Its member 1 is hidden (in no map) lines are A's reports arriving. Around A's first hide, the capture path was stalling too: vk: a capture's wait for write-back 24013 timed out repeated, nvn: GPU waits in 5 s: 33 sync waits (1447 ms).

So my reading: A's game thread went seconds between frames, the "being played" check took that for a load, and B was told "in no map". It's an artefact of this test setup, two games on one GPU over its memory budget. But it would also show for a real player whose game stalls for a second or two (a slow PC, a shader compile, a hitch), so the check may want a longer grace before it reports a load.

1. The stretch around the first hide. The above is A's, with the renderer's own lines left out. Untrimmed, A from 4 lines before to 4 after:

[hos Presentation Thread] vi: 3418 frames presented (8.2 fps over the last 5.1 s, interval 1)
[hos Presentation Thread] vi: present intervals: <15.5 ms 0, 15.5-17.8 0, 17.8-22 1, 22-30 3, 30-40 4, over 40 34
[hos BaseProcExecutor0] coop: puppet: member 2 is hidden (this game stopped being played: a map change or a load)
[hos BaseProcExecutor0] coop: players: this game stopped being played: a map change or a load: made 1, deleted 1 (1 by this game, 0 gone with their map), 0 still shown, 0 requests failed
[hos Presentation Thread] vk: over the driver's video-memory allowance (4.3 of 4.1 GB)
...
[hos sead::MainThread] vk: a capture's wait for write-back 24013 timed out (done 24009)
[hos sead::MainThread] nvn: GPU waits in 5 s: 10 sync waits (1298 ms), 0 polls timed out (0 ms), 0 queue finishes (0 ms)
[hos Presentation Thread] vi: 3433 frames presented (2.4 fps over the last 6.4 s, interval 1)

B at the same time logged member 1 is hidden (in no map) next to vi: ... 47.4 fps.

2. Window switches and hits. Window switches don't line up: A's foreground changes are at lines 1156, 1750, 1910, 1979, 2824 and 2938, and only the last is near a hide (2951, 13 lines later). B was being hit in that stretch, but the log has no line for a hit (heart protection was on), so I can't say which hits were when.

I'll do Copy/Return and the junction refusal on your next head. For the bodies I'll run it with one game on the RTX 3080 and the other on the iGPU, so neither runs out of video memory.

The logs are still here. Short version: **every hide came during a frame-rate collapse**, which two games sharing one 10 GB RTX 3080 caused. They were over the driver's video-memory allowance. Window switching doesn't line up. **3. Frame rate.** A's `vi: ... fps over the last 5 s` lines against its hides (log line numbers): ``` 2565 52.3 fps 2578 vk: over the driver's video-memory allowance (4.5 of 4.4 GB) 2672 9.9 fps 2722 17.7 fps 2743 8.2 fps 2745 member 2 is hidden (this game stopped being played: a map change or a load) 2748 vk: over the driver's video-memory allowance (4.3 of 4.1 GB) 2760 2.4 fps over 6.4 s 2768 hidden 2772 3.1 fps 2782 hidden 2786 4.4 fps 2805 1.2 fps over 6.5 s 2810 1.6 fps 2820 hidden 2847 5.4 fps 2942 37.0 fps 2951 hidden 2954 vk: over the driver's video-memory allowance (4.3 of 3.8 GB) 2970 4.8 fps 2981 hidden 2988 6.4 fps 3003 8.0 fps 3053 20.6 3099 21.3 3119 vk: over the driver's video-memory allowance (4.3 of 4.3 GB) 3149 22.6 fps 3153 hidden ``` There's no hide in A's stretches at 37-52 fps. B ran at 17-60 fps. Its own single `member 1 is hidden (this game stopped being played ...)` (line 2662) came as it fell from 16.4 to 9.1 fps. Its `member 1 is hidden (in no map)` lines are A's reports arriving. Around A's first hide, the capture path was stalling too: `vk: a capture's wait for write-back 24013 timed out` repeated, `nvn: GPU waits in 5 s: 33 sync waits (1447 ms)`. So my reading: A's game thread went seconds between frames, the "being played" check took that for a load, and B was told "in no map". It's an artefact of this test setup, two games on one GPU over its memory budget. But it would also show for a real player whose game stalls for a second or two (a slow PC, a shader compile, a hitch), so the check may want a longer grace before it reports a load. **1. The stretch around the first hide.** The above is A's, with the renderer's own lines left out. Untrimmed, A from 4 lines before to 4 after: ``` [hos Presentation Thread] vi: 3418 frames presented (8.2 fps over the last 5.1 s, interval 1) [hos Presentation Thread] vi: present intervals: <15.5 ms 0, 15.5-17.8 0, 17.8-22 1, 22-30 3, 30-40 4, over 40 34 [hos BaseProcExecutor0] coop: puppet: member 2 is hidden (this game stopped being played: a map change or a load) [hos BaseProcExecutor0] coop: players: this game stopped being played: a map change or a load: made 1, deleted 1 (1 by this game, 0 gone with their map), 0 still shown, 0 requests failed [hos Presentation Thread] vk: over the driver's video-memory allowance (4.3 of 4.1 GB) ... [hos sead::MainThread] vk: a capture's wait for write-back 24013 timed out (done 24009) [hos sead::MainThread] nvn: GPU waits in 5 s: 10 sync waits (1298 ms), 0 polls timed out (0 ms), 0 queue finishes (0 ms) [hos Presentation Thread] vi: 3433 frames presented (2.4 fps over the last 6.4 s, interval 1) ``` B at the same time logged `member 1 is hidden (in no map)` next to `vi: ... 47.4 fps`. **2. Window switches and hits.** Window switches don't line up: A's foreground changes are at lines 1156, 1750, 1910, 1979, 2824 and 2938, and only the last is near a hide (2951, 13 lines later). B was being hit in that stretch, but the log has no line for a hit (heart protection was on), so I can't say which hits were when. I'll do Copy/Return and the junction refusal on your next head. For the bodies I'll run it with one game on the RTX 3080 and the other on the iGPU, so neither runs out of video memory.
Author
Member

Follow-up on the repeated show and hide, after reading the code against your description.

What decides it. A game stops counting as played, removes the bodies it shows and tells the others it is in no map, when one of these fails: a save is loaded, the player object is valid and in the world, no load or transition flag is set, and the game's own play-time counter has ticked normally within the last 2.5 seconds. A change of that counter other than a small step forward is taken for another save having been loaded. Separately, a game that has not managed to read its own player's pose for 2.5 seconds also reports itself as not in the world. After a removal there is a 2-second wait before the body is asked for again. Being hit has no branch of its own in any of this, and neither does window focus: the game is always told it is in focus, and losing focus only resets input.

What that suggests, not established: anything that holds one game still for a moment could trip the counter rule or the 2.5-second rule. On Windows, pressing on a window's title bar or border blocks that window's thread until the button is released, and a covered window can be held back by the compositor. That would fit clicking between two windows; it is a candidate, not a finding. The fix that is being proven now is for a different fault and does not touch these rules.

For comparison: in the two-PC session on the earlier head, the Windows game ran in its own real window for about three minutes and each game's complete log has exactly one show and one hide (the Leave). That was one game per PC, never covered or clicked.

If you run it again, HOS_COOP_TRACE=1 on both games makes the reason visible. The lines to look for around the first hide and the recovery:

coop: sync: game paused ... / coop: sync: game running ...
coop: sync: Link ... the world
hid: game window in front / not in front

and whether each hide follows a click on a title bar or a switch of the front window. A minute with nobody touching either window, then a minute of deliberate switching, would separate the two.

Here, the same is being tried on Linux by stopping one game for a fraction of a second, one second and three seconds with the trace on; the result follows.

Follow-up on the repeated show and hide, after reading the code against your description. **What decides it.** A game stops counting as played, removes the bodies it shows and tells the others it is in no map, when one of these fails: a save is loaded, the player object is valid and in the world, no load or transition flag is set, and the game's own play-time counter has ticked normally within the last 2.5 seconds. A change of that counter other than a small step forward is taken for another save having been loaded. Separately, a game that has not managed to read its own player's pose for 2.5 seconds also reports itself as not in the world. After a removal there is a 2-second wait before the body is asked for again. Being hit has no branch of its own in any of this, and neither does window focus: the game is always told it is in focus, and losing focus only resets input. **What that suggests, not established:** anything that holds one game still for a moment could trip the counter rule or the 2.5-second rule. On Windows, pressing on a window's title bar or border blocks that window's thread until the button is released, and a covered window can be held back by the compositor. That would fit clicking between two windows; it is a candidate, not a finding. The fix that is being proven now is for a different fault and does not touch these rules. **For comparison:** in the two-PC session on the earlier head, the Windows game ran in its own real window for about three minutes and each game's complete log has exactly one show and one hide (the Leave). That was one game per PC, never covered or clicked. **If you run it again,** `HOS_COOP_TRACE=1` on both games makes the reason visible. The lines to look for around the first hide and the recovery: ```text coop: sync: game paused ... / coop: sync: game running ... coop: sync: Link ... the world hid: game window in front / not in front ``` and whether each hide follows a click on a title bar or a switch of the front window. A minute with nobody touching either window, then a minute of deliberate switching, would separate the two. Here, the same is being tried on Linux by stopping one game for a fraction of a second, one second and three seconds with the trace on; the result follows.
Contributor

That fits the 2.5-second rule: in my comment above (frame rates against the hides), game A ran at 1.2-8 fps over 5-6.5 s windows at every hide, with present intervals almost all over 40 ms (34 of 42 in the window before the first hide), on one RTX 3080 shared by both games over the driver's video-memory allowance. So a counter stalled for over 2.5 s explains all seven, with no window clicks needed. A real player with a hitch that long would see the same, so a longer grace or a frame-count-based rule might be worth a look. I'll redo the bodies with one game on the iGPU so neither starves.

That fits the 2.5-second rule: in my comment above (frame rates against the hides), game A ran at 1.2-8 fps over 5-6.5 s windows at every hide, with present intervals almost all over 40 ms (34 of 42 in the window before the first hide), on one RTX 3080 shared by both games over the driver's video-memory allowance. So a counter stalled for over 2.5 s explains all seven, with no window clicks needed. A real player with a hitch that long would see the same, so a longer grace or a frame-count-based rule might be worth a look. I'll redo the bodies with one game on the iGPU so neither starves.
Author
Member

That settles it better than anything here could: every hide sits in a stretch at 1 to 8 frames a second, none in the stretches at 37 to 52, and the window switching does not line up. Thank you for going back through the logs.

So this is the rule working as written on a game that was starved, and you are right that the rule is too quick for a real hitch: a slow PC, a long shader compile or a memory squeeze would make the other player vanish, and after a removal the body is not asked for again for two seconds. It is being tried here directly, by stopping one game for 0.3, 1 and 3 seconds with the trace on, to see which lengths remove a body and by which of the two rules (the 2.5-second one, or a jump of the play counter being taken for a load). What to do about it (a longer grace before a body is removed, or judging by frames instead of seconds as you suggest, and not treating a jump after a stall as another save) will be proposed here with that result. It is not in the head that is about to be pushed: that one, 2f01e1b4, fixes the race from the 30-minute session and has passed the six proofs.

One game on the iGPU so neither starves is a good next run; the bodies with walking animation would need the animation assets built, which your development build did not have.

That settles it better than anything here could: every hide sits in a stretch at 1 to 8 frames a second, none in the stretches at 37 to 52, and the window switching does not line up. Thank you for going back through the logs. So this is the rule working as written on a game that was starved, and you are right that the rule is too quick for a real hitch: a slow PC, a long shader compile or a memory squeeze would make the other player vanish, and after a removal the body is not asked for again for two seconds. It is being tried here directly, by stopping one game for 0.3, 1 and 3 seconds with the trace on, to see which lengths remove a body and by which of the two rules (the 2.5-second one, or a jump of the play counter being taken for a load). What to do about it (a longer grace before a body is removed, or judging by frames instead of seconds as you suggest, and not treating a jump after a stall as another save) will be proposed here with that result. It is not in the head that is about to be pushed: that one, `2f01e1b4`, fixes the race from the 30-minute session and has passed the six proofs. One game on the iGPU so neither starves is a good next run; the bodies with walking animation would need the animation assets built, which your development build did not have.
Author
Member

Updated to 2f01e1b4bdb6e1629c54a998f0403519fe4e5c74 (r12), Linux source 05329d46. The fork branch still has its historical name coop-playtest-r9. The base remains pull request 68 at 4a9b9606, on main cf605c85b, three commits behind 0caf06184.

The failed 30-minute session on r10 led to two presence fixes and the completed switch reference:

  • 2be4e9233: an unchanged roster heartbeat no longer looks like a changed room view that briefly withdraws permission to show the other player.
  • 15a68a5eb: the missing switch-reference entries, defaults and test/development limits are documented.
  • 2f01e1b4b: a joined room view stays pending until the native engine exists and actually receives it.

The intermediate head 15a68a5e failed its first two-game proof before signed-room readiness and was never pushed. Removing the repeated heartbeat exposed a second fault: the first room view had been marked handled before the native engine existed, and the old heartbeat had been retrying it by accident.

Both new regressions pass with GCC and Clang; the real join-to-accepted-room test fails on that intermediate head. On r12 the whole suite reports 580 passed, 3 failed, 16 skipped: the failures remain the pinned main's test_framegen_resources.py, test_module_ids.py and test_pad_layout.py.

All six short two-game proofs pass at the first attempt on r12: signed terms/consent, body consent and Leave, reciprocal child poses, native Copy/autosave/Return, signed transfer/partial cancellation, and the bounded five-swing health-observer test. Both complete logs were also scanned in every proof for unexpected body hiding, deletion or recreation; none occurred. The eight existing pictures remain labelled r10 illustrations; fresh r12 captures showed the same views.

Linux builds and runs. The exact r12 Windows executable and renderer cross-build and link, but have not run on Windows; no r12 two-machine or 30-minute result is claimed. The qualified 30-minute session and LAN result remain at 0ec9d0b0; the failed later 30-minute session and native Windows tester's results remain at 1ed75e61. The repeated show and hide the Windows tester found is a separate matter and is not repaired here: the tester's logs show every hide during a frame-rate collapse (#355 (comment)), which is the play check's 2.5-second rule working as written and being too quick for a real hitch. What to change there is still to be decided.

Testers: pin 2f01e1b4; results already posted for 1ed75e61 stand for that commit. This stays WIP and fighting remains disabled.

Updated to **`2f01e1b4bdb6e1629c54a998f0403519fe4e5c74` (r12)**, Linux source `05329d46`. The fork branch still has its historical name `coop-playtest-r9`. The base remains pull request 68 at `4a9b9606`, on main `cf605c85b`, three commits behind `0caf06184`. The failed 30-minute session on r10 led to two presence fixes and the completed switch reference: - `2be4e9233`: an unchanged roster heartbeat no longer looks like a changed room view that briefly withdraws permission to show the other player. - `15a68a5eb`: the missing switch-reference entries, defaults and test/development limits are documented. - `2f01e1b4b`: a joined room view stays pending until the native engine exists and actually receives it. The intermediate head `15a68a5e` failed its first two-game proof before signed-room readiness and was never pushed. Removing the repeated heartbeat exposed a second fault: the first room view had been marked handled before the native engine existed, and the old heartbeat had been retrying it by accident. Both new regressions pass with GCC and Clang; the real join-to-accepted-room test fails on that intermediate head. On r12 the whole suite reports **580 passed, 3 failed, 16 skipped**: the failures remain the pinned main's `test_framegen_resources.py`, `test_module_ids.py` and `test_pad_layout.py`. **All six short two-game proofs pass at the first attempt on r12:** signed terms/consent, body consent and Leave, reciprocal child poses, native Copy/autosave/Return, signed transfer/partial cancellation, and the bounded five-swing health-observer test. Both complete logs were also scanned in every proof for unexpected body hiding, deletion or recreation; none occurred. The eight existing pictures remain labelled r10 illustrations; fresh r12 captures showed the same views. Linux builds and runs. The exact r12 Windows executable and renderer cross-build and link, but have not run on Windows; no r12 two-machine or 30-minute result is claimed. The qualified 30-minute session and LAN result remain at `0ec9d0b0`; the failed later 30-minute session and native Windows tester's results remain at `1ed75e61`. The repeated show and hide the Windows tester found is a separate matter and is not repaired here: the tester's logs show every hide during a frame-rate collapse (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17764), which is the play check's 2.5-second rule working as written and being too quick for a real hitch. What to change there is still to be decided. **Testers:** pin `2f01e1b4`; results already posted for `1ed75e61` stand for that commit. This stays WIP and fighting remains disabled.
Only publish a new session view when the roster fields actually change. Repeated heartbeat publication exposed a newer view version before the consent callback could consume it, allowing the game thread to revoke an unchanged presentation context.

Exercise that exact interleaving with the real session publication and native context code. Both compiler families fail on r9 and r10 and pass with the fix; real roster changes retain the stale-view fence.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Document co-op connection, signed-rule, test and development switches with their defaults and consent limits. Clarify internal restart state and the debug Teleport overrides without changing runtime behavior.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
fix(coop): apply joined views after the native engine starts
All checks were successful
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 4s
CI / Workflow lint (actionlint) (pull_request) Successful in 6s
Third-party parts / As their notes say (pull_request) Successful in 7s
PR description / Description follows the template (pull_request_target) Successful in 4s
Website / Website on Cloudflare (pull_request_target) Has been skipped
2f01e1b4bd
A view arriving before engine creation was marked consumed without initializing the signed room. Keep it pending until view_changed applies it under the engine lock, so the next session tick recovers it without republishing unchanged roster heartbeats.

Drive real JOINED and ROSTER parsing, queued encrypted loopback messages, signed identity and charter delivery, and explicit two-member acceptance in three startup orders. The new integration fixture fails on r11 and passes here with GCC and Clang; the existing presence-race fixture still passes with both.

Assisted-by: GPT-6 Astra
Co-Authored-By: GPT-6 Astra <[email protected]>
Author
Member

The freeze experiment promised above, on head 2f01e1b4 (two windowless games on one Linux PC, RTX 4090, both accepted, standing in sight of each other, trace on). One game's whole process was stopped and released again three times, with more than 42 seconds of untouched play between; nothing else was changed and no input was sent.

Game A stopped for What happened to the bodies
0.300 s nothing: no pause line, no hide, no re-creation on either game
1.000 s nothing
3.000 s both removed once and shown again without any input

In the 3-second case there are two separate reactions, as the code read suggested:

  • The other game, B, hid A as not heard shortly before A was released: it had received nothing from A for 3 seconds.
  • The stopped game, A, on its first frame afterwards logged game paused (its play counter had not ticked for more than 2.5 seconds), removed B's body, logged game running one counter step later, and asked for the body again.
  • Both bodies were back about 2.06 seconds after that, which is the 2-second wait before a removed body is requested again plus building it.
  • Neither log has an in no map line or another save was loaded. So on this PC a clean 3-second stop shows as not heard on the peer; the Windows report's in no map is the same check seen from a game that kept sending while starved.

Before the 3-second stop both games show both bodies; after it each game shows only its own player; a little later both show both again, with no input.

What this means for a player: a hitch of up to a second does nothing. One of about 2.5 to 3 seconds or more makes the other player disappear on both sides and come back roughly two seconds after the game recovers. Nothing is lost and no consent has to be given again, but it looks like the other person left.

Possible changes, to be decided, none made: keep a body through a short not-in-play reading and remove it only if the reading lasts (for example ten seconds), or freeze it in place with a mark instead of removing it; ask for a removed body again at once when play resumes rather than after the 2-second wait; judge liveness by frames as well as seconds, so a game that is slow but still running is not taken for one that stopped. Each of these touches when another player's body may be shown, so it needs the same care as the consent rules.

One observation session, not a proof with a pass or fail; exits 0 on both games; the stop was applied to the game process only.

The freeze experiment promised above, on head `2f01e1b4` (two windowless games on one Linux PC, RTX 4090, both accepted, standing in sight of each other, trace on). One game's whole process was stopped and released again three times, with more than 42 seconds of untouched play between; nothing else was changed and no input was sent. | Game A stopped for | What happened to the bodies | |---|---| | 0.300 s | nothing: no pause line, no hide, no re-creation on either game | | 1.000 s | nothing | | 3.000 s | both removed once and shown again without any input | In the 3-second case there are two separate reactions, as the code read suggested: - **The other game, B,** hid A as `not heard` shortly before A was released: it had received nothing from A for 3 seconds. - **The stopped game, A,** on its first frame afterwards logged `game paused` (its play counter had not ticked for more than 2.5 seconds), removed B's body, logged `game running` one counter step later, and asked for the body again. - Both bodies were back about 2.06 seconds after that, which is the 2-second wait before a removed body is requested again plus building it. - Neither log has an `in no map` line or `another save was loaded`. So on this PC a clean 3-second stop shows as `not heard` on the peer; the Windows report's `in no map` is the same check seen from a game that kept sending while starved. ![Before the 3-second stop both games show both bodies; after it each game shows only its own player; a little later both show both again, with no input.](https://git.magicbean.dev/attachments/3d833bac-b22c-4926-980c-e3d8511e96f1) **What this means for a player:** a hitch of up to a second does nothing. One of about 2.5 to 3 seconds or more makes the other player disappear on both sides and come back roughly two seconds after the game recovers. Nothing is lost and no consent has to be given again, but it looks like the other person left. **Possible changes, to be decided, none made:** keep a body through a short not-in-play reading and remove it only if the reading lasts (for example ten seconds), or freeze it in place with a mark instead of removing it; ask for a removed body again at once when play resumes rather than after the 2-second wait; judge liveness by frames as well as seconds, so a game that is slow but still running is not taken for one that stopped. Each of these touches when another player's body may be shown, so it needs the same care as the consent rules. One observation session, not a proof with a pass or fail; exits 0 on both games; the stop was applied to the game process only.
Author
Member

R12: thirty minutes of body continuity passed, but the save-byte rule failed

Tested commit 2f01e1b4bdb6e1629c54a998f0403519fe4e5c74, source 05329d46, with two windowless games on one Linux PC, RTX 4090 and NVIDIA 615.78.08. The game hosted the room over loopback. Each player accepted once, then stood, took short walks and sent the seven planned chat lines.

The accepted session lasted 1,800.129 seconds with no disconnect, rejoin or unexpected body removal. It is nevertheless not an overall pass: the rule written beforehand required every normal-save file to remain byte-identical, and each disposable test copy's option.sav changed.

What passed

  • Both complete logs contain exactly one initial request and creation per game. Neither body was hidden, deleted or recreated during the 30 minutes. After the interval, B deliberately left through the menu; each game then removed its one remote body, with no revival.
  • All 361 paired checks arrived on the five-second schedule. The largest gap between either game's checks was 5.000668 seconds. Both games kept their original process and room identities.
  • Both bodies remained visible in the inspected standing and walking phases. All seven chat lines appeared in both games with the friend's name. The initial join notice and final Leave notice were visible, and Notices remained Everything.
  • All 32 statistics lines per game kept reliable retries, given-up events, refused packets, test drops and full outboxes at 0. The logged loopback round trip was 1 ms.
  • Resident plus reported swapped memory grew by 28.0 MiB and 23.4 MiB from minute 2, below the predeclared 512 MiB final limit. Maximum sampled growth was 46.6 MiB and 36.1 MiB, below the 1,024 MiB peak limit. Both games reported zero swapped memory in all 31 samples each.
  • Both games exited 0. The kernel record contains no driver fault or other driver line.

There were four game-present intervals longer than one second during startup, two per game. None occurred during the accepted interval or shutdown. Those startup intervals remain part of the result; this was not a speed or smoothness measurement.

What failed

Each normal save tree contained 14 files. Only option.sav changed, by 99 bytes on each side. All 13 other files per game and all files in the original test-save source remained byte-identical. These were disposable copies, not the ordinary playing installation.

The retained file times are 05:00:00.732 and 05:00:01.053 local, on 14 November 2026, around minute 14 of the accepted session. Both games were idle then, well before the planned final Leave. Both files kept the same size and layout; one changed value equals the timestamp of 05:00:00. The log does not identify the writer, and some changed values have not been given meanings.

So the byte check genuinely failed, but the evidence does not yet establish whether this was expected native bookkeeping or a multiplayer defect. It does not establish corruption. A clock-related update is a possibility, not a demonstrated cause. The failed requirement is not being changed afterward to ignore the options file, and no second r12 soak was run.

Beside the earlier sessions

Check Previous 0ec9d0b0 Completed r10 restart 1ed75e61 R12 2f01e1b4
Accepted interval 1,803.5 s 1,800.1 s 1,800.1 s
Five-second schedule Missed: 265 pairs Met: 361 pairs Met: 361 pairs
Unexpected native body lifetime None in either complete log One A-side hide/delete/recreate None in either complete log
Disconnect or rejoin None None None
Normal-save bytes after exit Unchanged Unchanged Only option.sav changed on each side
Original source / native exits Unchanged / both 0 Unchanged / both 0 Unchanged / both 0
Overall Sampling rule failed Body-continuity rule failed Save-byte rule failed

The earlier r10 first attempt stopped at minute 4 on an undetermined same-process/zero-swap check whose failing value was not recorded. I chose its single restart on that undetermined stop, not a proven test-only trigger. Before restarting, I changed zero-swap to recorded swap with resident-plus-swap growth because this PC already used compressed zram at swappiness 150. R12 used that openly amended memory rule from the outset, without a restart. The earlier records remain:

#355 (comment)

#355 (comment)

Not covered by this session: Windows, two PCs, internet traffic, other GPUs, physical input, map changes, save copy/Return, transfers, progress-changing actions, adult equipment, fighting or deliberately stalled games. In particular, this does not resolve the separate Windows starvation and 2.5-second play-clock problem described at #355 (comment). The line stays WIP.

Whether a single game with co-op off writes the same file at the same clock time is being checked next; the answer follows here.

## R12: thirty minutes of body continuity passed, but the save-byte rule failed Tested commit `2f01e1b4bdb6e1629c54a998f0403519fe4e5c74`, source `05329d46`, with two windowless games on one Linux PC, RTX 4090 and NVIDIA 615.78.08. The game hosted the room over loopback. Each player accepted once, then stood, took short walks and sent the seven planned chat lines. **The accepted session lasted 1,800.129 seconds with no disconnect, rejoin or unexpected body removal. It is nevertheless not an overall pass:** the rule written beforehand required every normal-save file to remain byte-identical, and each disposable test copy's `option.sav` changed. ### What passed - Both complete logs contain exactly one initial request and creation per game. Neither body was hidden, deleted or recreated during the 30 minutes. After the interval, B deliberately left through the menu; each game then removed its one remote body, with no revival. - All 361 paired checks arrived on the five-second schedule. The largest gap between either game's checks was 5.000668 seconds. Both games kept their original process and room identities. - Both bodies remained visible in the inspected standing and walking phases. All seven chat lines appeared in both games with the friend's name. The initial join notice and final Leave notice were visible, and Notices remained Everything. - All 32 statistics lines per game kept reliable retries, given-up events, refused packets, test drops and full outboxes at 0. The logged loopback round trip was 1 ms. - Resident plus reported swapped memory grew by **28.0 MiB and 23.4 MiB** from minute 2, below the predeclared 512 MiB final limit. Maximum sampled growth was 46.6 MiB and 36.1 MiB, below the 1,024 MiB peak limit. Both games reported zero swapped memory in all 31 samples each. - Both games exited 0. The kernel record contains no driver fault or other driver line. There were four game-present intervals longer than one second during startup, two per game. None occurred during the accepted interval or shutdown. Those startup intervals remain part of the result; this was not a speed or smoothness measurement. ### What failed Each normal save tree contained 14 files. **Only `option.sav` changed, by 99 bytes on each side.** All 13 other files per game and all files in the original test-save source remained byte-identical. These were disposable copies, not the ordinary playing installation. The retained file times are **05:00:00.732 and 05:00:01.053 local, on 14 November 2026**, around minute 14 of the accepted session. Both games were idle then, well before the planned final Leave. Both files kept the same size and layout; one changed value equals the timestamp of 05:00:00. The log does not identify the writer, and some changed values have not been given meanings. So the byte check genuinely failed, but **the evidence does not yet establish whether this was expected native bookkeeping or a multiplayer defect**. It does not establish corruption. A clock-related update is a possibility, not a demonstrated cause. The failed requirement is not being changed afterward to ignore the options file, and no second r12 soak was run. ### Beside the earlier sessions | Check | Previous `0ec9d0b0` | Completed r10 restart `1ed75e61` | R12 `2f01e1b4` | |---|---|---|---| | Accepted interval | 1,803.5 s | 1,800.1 s | 1,800.1 s | | Five-second schedule | Missed: 265 pairs | Met: 361 pairs | Met: 361 pairs | | Unexpected native body lifetime | None in either complete log | One A-side hide/delete/recreate | None in either complete log | | Disconnect or rejoin | None | None | None | | Normal-save bytes after exit | Unchanged | Unchanged | Only `option.sav` changed on each side | | Original source / native exits | Unchanged / both 0 | Unchanged / both 0 | Unchanged / both 0 | | Overall | Sampling rule failed | Body-continuity rule failed | Save-byte rule failed | The earlier r10 first attempt stopped at minute 4 on an undetermined same-process/zero-swap check whose failing value was not recorded. **I chose its single restart on that undetermined stop, not a proven test-only trigger.** Before restarting, I changed zero-swap to recorded swap with resident-plus-swap growth because this PC already used compressed zram at swappiness 150. R12 used that openly amended memory rule from the outset, without a restart. The earlier records remain: https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17281 https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17694 **Not covered by this session:** Windows, two PCs, internet traffic, other GPUs, physical input, map changes, save copy/Return, transfers, progress-changing actions, adult equipment, fighting or deliberately stalled games. In particular, this does not resolve the separate Windows starvation and 2.5-second play-clock problem described at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17764. The line stays WIP. Whether a single game with co-op off writes the same file at the same clock time is being checked next; the answer follows here.
Author
Member

Answer to the open point of the 30-minute session above (#355 (comment)).

The options-save change is the game's own daily bookkeeping, not something that requires co-op.

I ran one game at a time on Linux/RTX 4090, using disposable copies of the same checkpoint and the existing guest-clock override. The PC's clock and time zone were not changed. Each successful test had loaded the save and reached quiet play more than three minutes before the boundary, then received no gameplay input.

Build, co-op off Local guest-clock crossing option.sav result
r12 2f01e1b4 05:00 Rewritten; 85 bytes changed
Plain main 0caf06184 05:00 Rewritten; the same 85 offsets changed
Plain main 0caf06184 06:00 Byte-identical throughout

The native code uses a day boundary at 05:00 local, not every full hour. It saves a rollover timestamp, buffered event and position history, and their four counters. The relevant native functions are unchanged between these builds.

That also accounts for the original 99 bytes: the stationary tests have one new position record; the soak has two, accounting for the extra 14 changed bytes. All eight new event records have the same non-time contents in main, r12-off and both soak games. It was not merely one harmless timestamp that the byte check noticed.

All three tests exited normally; every other save file and the original checkpoint stayed unchanged, with no driver faults. One earlier attempt never passed startup preparation and is retained as unexercised, not a negative result.

The original soak still failed its predeclared byte-invariance rule. For future sessions, keep the whole-file hashes and compare these identified bookkeeping fields separately, checking the rollover time, counters and appended records while requiring every other byte to stay unchanged. Do not ignore option.sav. No game code or soak criterion was changed here. Windows and other clock boundaries remain untested.

So for the session on 2f01e1b4: what it was run for held (30 minutes with both bodies continuously present, no retries, saves' progress untouched), and the one rule it failed was the test's own assumption that an idle game never writes its options save. The session crossed 05:00; the two earlier ones did not.

Answer to the open point of the 30-minute session above (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17887). The options-save change is the game's own daily bookkeeping, not something that requires co-op. I ran one game at a time on Linux/RTX 4090, using disposable copies of the same checkpoint and the existing guest-clock override. The PC's clock and time zone were not changed. Each successful test had loaded the save and reached quiet play more than three minutes before the boundary, then received no gameplay input. | Build, co-op off | Local guest-clock crossing | `option.sav` result | |---|---|---| | r12 `2f01e1b4` | 05:00 | Rewritten; 85 bytes changed | | Plain main `0caf06184` | 05:00 | Rewritten; the same 85 offsets changed | | Plain main `0caf06184` | 06:00 | Byte-identical throughout | The native code uses a day boundary at **05:00 local**, not every full hour. It saves a rollover timestamp, buffered event and position history, and their four counters. The relevant native functions are unchanged between these builds. That also accounts for the original **99 bytes**: the stationary tests have one new position record; the soak has two, accounting for the extra 14 changed bytes. All eight new event records have the same non-time contents in main, r12-off and both soak games. It was not merely one harmless timestamp that the byte check noticed. All three tests exited normally; every other save file and the original checkpoint stayed unchanged, with no driver faults. One earlier attempt never passed startup preparation and is retained as unexercised, not a negative result. The original soak still failed its predeclared byte-invariance rule. For future sessions, keep the whole-file hashes and compare these identified bookkeeping fields separately, checking the rollover time, counters and appended records while requiring every other byte to stay unchanged. **Do not ignore `option.sav`.** No game code or soak criterion was changed here. Windows and other clock boundaries remain untested. **So for the session on `2f01e1b4`:** what it was run for held (30 minutes with both bodies continuously present, no retries, saves' progress untouched), and the one rule it failed was the test's own assumption that an idle game never writes its options save. The session crossed 05:00; the two earlier ones did not.
Author
Member

Push to this pull request: head 9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca (branch coop-playtest-r15). The six proofs below ran on 02bedee717978ccc13dde9029dd5ff9d086b5516 (branch coop-playtest-r14b). They carry to the head pushed here, which is the same co-op line on the current head of pull request 68 (d12e854c4e3a532ea0f40c8f7f552086f7e8a54b, on main 1be60eae813865b0845fb8bb05b1d7cb9b39e51f), for these reasons, all checked on the commits themselves:

  • git range-diff of the 92 co-op commits of 02bedee71797 against the 92 replayed commits of 9dfdd0c6c1a0: 92 identical, 0 different. No commit differs, not even in its surrounding lines; authors, dates and messages are unchanged and there were no conflicts.
  • The 104 tracked files with "coop" in their name, plus host/oot_state_tap.c, host/nn_applet.c and host/nn_vi.c: all 107 are byte for byte the same on the two commits.
  • The two trees differ only in the two files of main's own change 1be60eae813865b0845fb8bb05b1d7cb9b39e51f that pull request 68's head now includes: host/hos_thread.c and tests/test_reserved_core.py.
  • Focused game-free runs of test_upscaler_round_trip and test_vcore_fs_open (the two files a plain merge of the line with the new head conflicts in, only because it uses main as the common point) pass with GCC and Clang on pull request 68's head, on r14b and on r15: 12 of 12.

Not rerun on r15: the six proofs themselves, and the game build. The whole game-free suite on the pushed head: 594 passed, 1 failed, 16 skipped; its one failure, tests/test_walk_key.py, fails on main 1be60eae8 and on pull request 68's head d12e854c4 the same way (fixed by #497).


Results of the six two-game proofs on the next head of this pull request, 02bedee717978ccc13dde9029dd5ff9d086b5516 (branch coop-playtest-r14b, game version v3.0.0-rc.3-197-g02bedee71). It is newer than 2f01e1b4bdb6e1629c54a998f0403519fe4e5c74, the head the earlier results in this thread were taken on. What is new on it: a body that is already shown stays for up to 10 seconds in total through a stall (it is never created or moved during the stall), the Co-op tab is marked Experimental, and the line sits on a newer main. The same co-op line was tested before on the candidate head 96b846278fc148eaae7e4158b91497f757a8dc15 (branch coop-playtest-r13); this head is that line carried onto a newer main. The results below belong to this exact commit, except the freeze cases, which are carried from that earlier candidate and say so.

What changed between those two candidate heads. I compared the two commits file by file. Of the 104 tracked files with "coop" in their name, 102 are byte for byte the same. The two that differ are test files, one line each, and both follow changes made on main: the chat test gained an empty stand-in for the new Skip title screen input, and the Co-op tab test now checks the key numbers with the new Walk key in place. The code that asks for, shows, keeps and removes the other player's body, the code that sends poses, the progress and travel gate, and the relay are byte for byte the same. Five other files that co-op passes through differ, and I read every changed line: they are main's own changes (crash and clean-exit records, GPU wait statistics in the frame log, Linux helper-thread placement, the Walk key and its options, the Skip title screen option). None of them touches a co-op call.

Every run below used two windowless games on one Linux PC with an RTX 4090 and NVIDIA's driver, talking through a relay on the same PC, at 1280x720, from copies of test saves. Each game exited with code 0, nothing was left running, and the kernel log showed no driver fault. Each proof passed on its first attempt, and its steps and checks came out the same as on the earlier candidate head (apart from the random maker key text in the signed terms proof and the per-swing counts in the swings proof, see below). Once a game was playing, none stopped drawing for as long as one second. The only intervals over one second were the last picture of each game before the restart that Copy makes on purpose in the transfer proof (1.4 seconds). Each game's log was read from the first line to the last for every body that was asked for, shown or removed.

The six proofs

Proof What the two games did Result
Signed transfer of a checkpoint Both games on temporary copies of the save. The owner approved one download, nothing was sent before the exact approval, a wrong manifest was refused with 0 bytes, and the two files arrived and matched their digests. A second transfer was cancelled after 8,192 of 160,019 bytes. Passed. After the cancel no usable save, no restart ticket and no change to either game's saves.
Consent, bodies and Leave No body of the other player before anyone agreed. After both agreed, each game showed exactly one body of the other player. The maker then left. Passed. One body created per game, both removed by the Leave, none came back in the next 10 seconds.
Temporary copy, autosave and Return Both games switched to a temporary copy of their save. In one game a chest was opened, which saved the copy; the other game's copy stayed unchanged. Both then returned to their normal saves. Passed. Only the working copy changed (3 files in one game, among them the progress file, none in the other), the original saves and normal saves were identical before and after, and Return mounted the normal saves again.
Signed terms, stale confirmation and fresh consent Both games showed the same signed room terms before anyone agreed. Switching tab or closing the menu cancelled an earlier confirmation, a change of the room's terms made an old confirmation useless, and only a fresh two-step confirmation of the new terms was accepted. Passed. The changed terms applied no progress to either game and the joiner's own defaults stayed as they were.
Standing, walking and turning presence off Two bodies standing apart, then each game's player in turn walked four short legs while the other game watched, then one player switched presence off. Passed. Both bodies stayed fully in view with arms down, the walking steps were visible on the receiving game, presence off removed both bodies, and each game created exactly one body and removed it once.
Five sword swings and the damage counters One player swung five times next to the other, while the game's own damage and swing counters ran on both games. Passed. Five swings were seen, the loss counters closed complete with 0 missing on both games, and no health was lost on either side through that counted path; all hearts stayed full in all 14 pictures.

For example, game A's sword activity counter read 2,614 before the swings and 3,438 after, and game B's read 60 and 835 (these count the game's own sword activity records, not hits), with 0 losses offered or recorded on both games. That only shows that nothing was lost through the path the counters watch. It is not a test of sword contact, shields or fighting. The new records per swing were lower than on the earlier candidate head (114, 113, 106, 121 and 125, against 146, 127, 131, 137 and 130). Most likely this is because the PC was busy with unrelated work during this run and game A drew fewer frames in the same time (5,581 in 132 seconds, against 6,731 in 131 seconds); I did not isolate that with a second run. The checks do not depend on the exact count: each swing produced new records, the loss counters stayed at 0 and every lane closed complete.

The signed terms, walking and swings proofs ran while other, unrelated test jobs were using the same PC, so their load averages were high and the kernel log of those runs also shows crashes of other test programs (tests that crash on purpose). None of them is a game process and none is a driver fault.

In the signed terms proof I also looked at the game's own automatic menu captures. They show the Co-op tab with the signed room terms and the maker's key before anyone agrees, the changed-terms notice ("Room rules changed. Read the new Room rules before accepting.") with the confirm button back at its first step, and the final PvP setup state ("This build cannot start a fight. Ready is unavailable; no progress is shared.").

The five freeze cases (carried from the earlier candidate head, not rerun here)

These were run on 96b846278fc148eaae7e4158b91497f757a8dc15 (branch coop-playtest-r13) and are not rerun on this head. I carry them because the files that decide them are byte for byte the same on this head: the code that keeps, shows and removes the other player's body, the progress and travel gate, and the relay (see the comparison above). The results are the ones from that run.

Game A's whole process was stopped for the time in the first column and then released, with about 38 seconds of undisturbed play between one stop and the next, then 15 seconds at the end. Game B kept running. Only A's own process was stopped; nothing was sent to either game during the stop except a picture request to B. The times below are the real lengths of the stops.

Stop of game A What happened to the bodies Result
0.3 s (held 0.300 s) Nothing: no body removed or created on either game, no pause message. As expected.
1 s (held 1.000 s) Nothing, the same. As expected.
3 s (held 3.000 s) Both bodies stayed on both games. Game A logged that its play counter had paused and then that play was running again less than a second after it came back. As expected. On the head before the earlier candidate (2f01e1b4bdb6e1629c54a998f0403519fe4e5c74) this stop removed both bodies for about 2 seconds.
9 s (held 9.000 s) Both bodies stayed on both games, including in the picture taken from game B 8.5 seconds into the stop. The relay marked game A as away for a moment and as back again, which did not change anything shown. As expected.
12 s (held 12.000 s) Game B removed game A's body about 10 seconds into the stop, while A was still stopped (its picture 9 seconds in still shows both, its picture 11.5 seconds in shows only its own player). When A came back it removed B's body at once because its own grace had run out. Each game then asked for the other body again without a new agreement: B within a twentieth of a second of A coming back, A about a third of a second after. As expected. No new consent was needed, and the earlier 2-second wait before asking again did not apply.

Over all five stops neither game logged in no map or another save was loaded, and game A's play counter moved by exactly one at each pause. The pause message appears at 3, 9 and 12 seconds and not at 0.3 or 1 second, so the strict check used for progress and travel still closes during a stop of 3 seconds or more; the 10-second stay only applies to keeping a body that is already shown.

A first attempt at the freeze cases on that earlier candidate head was thrown away because my stop timer released the game early (the stops lasted 0.001, 0.001, 2.8, 8.6 and 11.6 seconds); it was repeated in full with the timer fixed and only that repeat is counted here. The first attempt's own result matched the table where its stops were long enough (2.8 and 8.6 seconds kept both bodies, 11.6 seconds removed and restored them).

The Experimental label

The Co-op tab carries the word Experimental above its status box. The single picture of the tab with co-op off and the Gameplay tab's Menu size set to Small was taken on the earlier candidate head, by the game's own automatic menu capture (not a screenshot request) at 1280x720, and it was not retaken on this head: the whole tab strip (Graphics, Audio, Gameplay, Controls, Debug, Co-op) fits, Experimental stands in gold directly above the status box, the box reads "Co-op is off" with "Make a room or join one: co-op starts for this run.", and the rows Your name, Relay, Make a room, Join a room, Room rules, Temporary save, Friend labels and Notices are all visible. On this head, the automatic captures of the signed terms proof that show the tab's main page (with a room made and joined, 1280x720) also show Experimental above the room status box; the Room rules sub page has no status box and no label. Only those states and the one Small-size picture were captured.

Not tested

  • Windows: nothing here ran on Windows.
  • A real network: both games and the relay were on one PC, so there was no distance, no lost packets and no slow link. The relay's own rule that marks a silent player as away after 8 seconds was crossed in the carried freeze cases (see the 9 and 12 second rows), but its drop after 15 seconds was never reached.
  • More than two players.
  • Any GPU or driver other than an RTX 4090 with NVIDIA's driver; real controllers; a real window on a desktop (the pictures are the game's own offscreen captures, and a stop of the whole process is not the same as a window being dragged or covered, or a game starved of memory or frame rate).
  • A long session on this head: no run here lasted longer than about six minutes.
  • Sword contact, shields, fighting, adult player bodies and equipment, and what travel or saving do during a stall; for the stalls only the pause and resume messages of the strict check were read.
  • The freeze cases and the co-op-off picture of the Co-op tab on this exact head: both are carried from the earlier candidate head.
  • Speed: nothing here is a measurement of frame rate or frame time, and three of the runs shared the PC with other work.

The six proofs ran once each on this head, and the five freeze cases once on the earlier candidate head; a different run could differ.

**Push to this pull request: head `9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca` (branch `coop-playtest-r15`).** The six proofs below ran on `02bedee717978ccc13dde9029dd5ff9d086b5516` (branch `coop-playtest-r14b`). They carry to the head pushed here, which is the same co-op line on the current head of pull request 68 (`d12e854c4e3a532ea0f40c8f7f552086f7e8a54b`, on main `1be60eae813865b0845fb8bb05b1d7cb9b39e51f`), for these reasons, all checked on the commits themselves: - `git range-diff` of the 92 co-op commits of `02bedee71797` against the 92 replayed commits of `9dfdd0c6c1a0`: **92 identical, 0 different**. No commit differs, not even in its surrounding lines; authors, dates and messages are unchanged and there were no conflicts. - The 104 tracked files with "coop" in their name, plus `host/oot_state_tap.c`, `host/nn_applet.c` and `host/nn_vi.c`: **all 107 are byte for byte the same** on the two commits. - The two trees differ only in the two files of main's own change `1be60eae813865b0845fb8bb05b1d7cb9b39e51f` that pull request 68's head now includes: `host/hos_thread.c` and `tests/test_reserved_core.py`. - Focused game-free runs of `test_upscaler_round_trip` and `test_vcore_fs_open` (the two files a plain merge of the line with the new head conflicts in, only because it uses main as the common point) pass with GCC and Clang on pull request 68's head, on r14b and on r15: 12 of 12. Not rerun on r15: the six proofs themselves, and the game build. The whole game-free suite on the pushed head: `594 passed, 1 failed, 16 skipped`; its one failure, `tests/test_walk_key.py`, fails on main 1be60eae8 and on pull request 68's head d12e854c4 the same way (fixed by https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/497). --- Results of the six two-game proofs on the next head of this pull request, `02bedee717978ccc13dde9029dd5ff9d086b5516` (branch `coop-playtest-r14b`, game version `v3.0.0-rc.3-197-g02bedee71`). It is newer than `2f01e1b4bdb6e1629c54a998f0403519fe4e5c74`, the head the earlier results in this thread were taken on. What is new on it: a body that is already shown stays for up to 10 seconds in total through a stall (it is never created or moved during the stall), the Co-op tab is marked Experimental, and the line sits on a newer main. The same co-op line was tested before on the candidate head `96b846278fc148eaae7e4158b91497f757a8dc15` (branch `coop-playtest-r13`); this head is that line carried onto a newer main. The results below belong to this exact commit, except the freeze cases, which are carried from that earlier candidate and say so. **What changed between those two candidate heads.** I compared the two commits file by file. Of the 104 tracked files with "coop" in their name, 102 are byte for byte the same. The two that differ are test files, one line each, and both follow changes made on main: the chat test gained an empty stand-in for the new Skip title screen input, and the Co-op tab test now checks the key numbers with the new Walk key in place. The code that asks for, shows, keeps and removes the other player's body, the code that sends poses, the progress and travel gate, and the relay are byte for byte the same. Five other files that co-op passes through differ, and I read every changed line: they are main's own changes (crash and clean-exit records, GPU wait statistics in the frame log, Linux helper-thread placement, the Walk key and its options, the Skip title screen option). None of them touches a co-op call. Every run below used two windowless games on one Linux PC with an RTX 4090 and NVIDIA's driver, talking through a relay on the same PC, at 1280x720, from copies of test saves. Each game exited with code 0, nothing was left running, and the kernel log showed no driver fault. Each proof passed on its first attempt, and its steps and checks came out the same as on the earlier candidate head (apart from the random maker key text in the signed terms proof and the per-swing counts in the swings proof, see below). Once a game was playing, none stopped drawing for as long as one second. The only intervals over one second were the last picture of each game before the restart that Copy makes on purpose in the transfer proof (1.4 seconds). Each game's log was read from the first line to the last for every body that was asked for, shown or removed. **The six proofs** | Proof | What the two games did | Result | |---|---|---| | Signed transfer of a checkpoint | Both games on temporary copies of the save. The owner approved one download, nothing was sent before the exact approval, a wrong manifest was refused with 0 bytes, and the two files arrived and matched their digests. A second transfer was cancelled after 8,192 of 160,019 bytes. | Passed. After the cancel no usable save, no restart ticket and no change to either game's saves. | | Consent, bodies and Leave | No body of the other player before anyone agreed. After both agreed, each game showed exactly one body of the other player. The maker then left. | Passed. One body created per game, both removed by the Leave, none came back in the next 10 seconds. | | Temporary copy, autosave and Return | Both games switched to a temporary copy of their save. In one game a chest was opened, which saved the copy; the other game's copy stayed unchanged. Both then returned to their normal saves. | Passed. Only the working copy changed (3 files in one game, among them the progress file, none in the other), the original saves and normal saves were identical before and after, and Return mounted the normal saves again. | | Signed terms, stale confirmation and fresh consent | Both games showed the same signed room terms before anyone agreed. Switching tab or closing the menu cancelled an earlier confirmation, a change of the room's terms made an old confirmation useless, and only a fresh two-step confirmation of the new terms was accepted. | Passed. The changed terms applied no progress to either game and the joiner's own defaults stayed as they were. | | Standing, walking and turning presence off | Two bodies standing apart, then each game's player in turn walked four short legs while the other game watched, then one player switched presence off. | Passed. Both bodies stayed fully in view with arms down, the walking steps were visible on the receiving game, presence off removed both bodies, and each game created exactly one body and removed it once. | | Five sword swings and the damage counters | One player swung five times next to the other, while the game's own damage and swing counters ran on both games. | Passed. Five swings were seen, the loss counters closed complete with 0 missing on both games, and no health was lost on either side through that counted path; all hearts stayed full in all 14 pictures. | For example, game A's sword activity counter read 2,614 before the swings and 3,438 after, and game B's read 60 and 835 (these count the game's own sword activity records, not hits), with 0 losses offered or recorded on both games. That only shows that nothing was lost through the path the counters watch. It is not a test of sword contact, shields or fighting. The new records per swing were lower than on the earlier candidate head (114, 113, 106, 121 and 125, against 146, 127, 131, 137 and 130). Most likely this is because the PC was busy with unrelated work during this run and game A drew fewer frames in the same time (5,581 in 132 seconds, against 6,731 in 131 seconds); I did not isolate that with a second run. The checks do not depend on the exact count: each swing produced new records, the loss counters stayed at 0 and every lane closed complete. The signed terms, walking and swings proofs ran while other, unrelated test jobs were using the same PC, so their load averages were high and the kernel log of those runs also shows crashes of other test programs (tests that crash on purpose). None of them is a game process and none is a driver fault. In the signed terms proof I also looked at the game's own automatic menu captures. They show the Co-op tab with the signed room terms and the maker's key before anyone agrees, the changed-terms notice ("Room rules changed. Read the new Room rules before accepting.") with the confirm button back at its first step, and the final PvP setup state ("This build cannot start a fight. Ready is unavailable; no progress is shared."). **The five freeze cases (carried from the earlier candidate head, not rerun here)** These were run on `96b846278fc148eaae7e4158b91497f757a8dc15` (branch `coop-playtest-r13`) and are not rerun on this head. I carry them because the files that decide them are byte for byte the same on this head: the code that keeps, shows and removes the other player's body, the progress and travel gate, and the relay (see the comparison above). The results are the ones from that run. Game A's whole process was stopped for the time in the first column and then released, with about 38 seconds of undisturbed play between one stop and the next, then 15 seconds at the end. Game B kept running. Only A's own process was stopped; nothing was sent to either game during the stop except a picture request to B. The times below are the real lengths of the stops. | Stop of game A | What happened to the bodies | Result | |---|---|---| | 0.3 s (held 0.300 s) | Nothing: no body removed or created on either game, no pause message. | As expected. | | 1 s (held 1.000 s) | Nothing, the same. | As expected. | | 3 s (held 3.000 s) | Both bodies stayed on both games. Game A logged that its play counter had paused and then that play was running again less than a second after it came back. | As expected. On the head before the earlier candidate (`2f01e1b4bdb6e1629c54a998f0403519fe4e5c74`) this stop removed both bodies for about 2 seconds. | | 9 s (held 9.000 s) | Both bodies stayed on both games, including in the picture taken from game B 8.5 seconds into the stop. The relay marked game A as away for a moment and as back again, which did not change anything shown. | As expected. | | 12 s (held 12.000 s) | Game B removed game A's body about 10 seconds into the stop, while A was still stopped (its picture 9 seconds in still shows both, its picture 11.5 seconds in shows only its own player). When A came back it removed B's body at once because its own grace had run out. Each game then asked for the other body again without a new agreement: B within a twentieth of a second of A coming back, A about a third of a second after. | As expected. No new consent was needed, and the earlier 2-second wait before asking again did not apply. | Over all five stops neither game logged `in no map` or `another save was loaded`, and game A's play counter moved by exactly one at each pause. The pause message appears at 3, 9 and 12 seconds and not at 0.3 or 1 second, so the strict check used for progress and travel still closes during a stop of 3 seconds or more; the 10-second stay only applies to keeping a body that is already shown. A first attempt at the freeze cases on that earlier candidate head was thrown away because my stop timer released the game early (the stops lasted 0.001, 0.001, 2.8, 8.6 and 11.6 seconds); it was repeated in full with the timer fixed and only that repeat is counted here. The first attempt's own result matched the table where its stops were long enough (2.8 and 8.6 seconds kept both bodies, 11.6 seconds removed and restored them). **The Experimental label** The Co-op tab carries the word Experimental above its status box. The single picture of the tab with co-op off and the Gameplay tab's Menu size set to Small was taken on the earlier candidate head, by the game's own automatic menu capture (not a screenshot request) at 1280x720, and it was not retaken on this head: the whole tab strip (Graphics, Audio, Gameplay, Controls, Debug, Co-op) fits, Experimental stands in gold directly above the status box, the box reads "Co-op is off" with "Make a room or join one: co-op starts for this run.", and the rows Your name, Relay, Make a room, Join a room, Room rules, Temporary save, Friend labels and Notices are all visible. On this head, the automatic captures of the signed terms proof that show the tab's main page (with a room made and joined, 1280x720) also show Experimental above the room status box; the Room rules sub page has no status box and no label. Only those states and the one Small-size picture were captured. **Not tested** - Windows: nothing here ran on Windows. - A real network: both games and the relay were on one PC, so there was no distance, no lost packets and no slow link. The relay's own rule that marks a silent player as away after 8 seconds was crossed in the carried freeze cases (see the 9 and 12 second rows), but its drop after 15 seconds was never reached. - More than two players. - Any GPU or driver other than an RTX 4090 with NVIDIA's driver; real controllers; a real window on a desktop (the pictures are the game's own offscreen captures, and a stop of the whole process is not the same as a window being dragged or covered, or a game starved of memory or frame rate). - A long session on this head: no run here lasted longer than about six minutes. - Sword contact, shields, fighting, adult player bodies and equipment, and what travel or saving do during a stall; for the stalls only the pause and resume messages of the strict check were read. - The freeze cases and the co-op-off picture of the Co-op tab on this exact head: both are carried from the earlier candidate head. - Speed: nothing here is a measurement of frame rate or frame time, and three of the runs shared the PC with other work. The six proofs ran once each on this head, and the five freeze cases once on the earlier candidate head; a different run could differ.
mooki force-pushed coop-playtest-r9 from 2f01e1b4bd
All checks were successful
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 4s
CI / Workflow lint (actionlint) (pull_request) Successful in 6s
Third-party parts / As their notes say (pull_request) Successful in 7s
PR description / Description follows the template (pull_request_target) Successful in 4s
Website / Website on Cloudflare (pull_request_target) Has been skipped
to 9dfdd0c6c1
Some checks are pending
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
beanstalk/approval awaiting maintainer approval
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 18s
CI / Conventional Commit title (pull_request) Successful in 13s
CI / Workflow lint (actionlint) (pull_request) Successful in 21s
Third-party parts / As their notes say (pull_request) Successful in 33s
2026-11-14 21:08:06 +00:00
Compare
Contributor

r15 9dfdd0c6 on Windows: two games in one room, on two GPUs this time, so neither ran short of video memory. Game A ran on the RTX 3080 (NVIDIA 621.14) at a median of 60 fps. Game B ran on the Intel UHD 770 (101.7088, RX_VK_DEVICE=1) at about 8 fps, with first-visit compile freezes. The setup was otherwise as before: native llvm-mingw build of 9dfdd0c6, each game with its own game folder and user folder holding a copy of one save (adult, Death Mountain Trail), scripts/coop_relay.py on 127.0.0.1, A create with coop_presence_permissions=3, B join, both HOS_COOP_PLAYERS=1 and HOS_COOP_ACCEPT=always. Windows that never took focus, input kept out. B walked, then A walked, then both stood for 2.5 min, then B quit, then A.

Bodies: each game made the other's adult body 4 times in about 5 minutes in the room:

game hides when
B (iGPU) 3 × this game's body liveness grace expired each one inside a freeze of B itself: vi: ... 1.0 fps over 20.1 s, 1.4 fps over 13.9 s, 1.7 fps over 16.3 s (the iGPU compiling on its first visit); A's body was back 0.1-0.2 s later each time (made in 120-167 ms)
A (3080, 60 fps) 3 × not heard B's freezes seen from A (B sends no pose while frozen); then WinB (member 2) left the room at the quit

Through B's 2.5 minutes of steady play at 7-9 fps (25 windows of 5 s) there was no hide on either side. So on this head a game that is slow but keeps running keeps its body shown. Only a game frozen for many seconds loses it, and it gets it back at once. That matches what you found with the 0.3/1/3 s stops.

Save and session:

  • Saves: both normal saves were hash-identical before and after (14 files each). The user folders gained only coop-backup, coop-keys (A) and temp.
  • Room: made, joined, WinB (member 2) left (1/8), WinA (member 1) left (0/8) on the relay.
  • Health: no CRASH, no device loss, both exited on quit.

Still not done here: Copy/Return and the junction refusal on Windows, and the game's own hosting. Shots stay on this PC.

r15 **9dfdd0c6** on Windows: two games in one room, on two GPUs this time, so neither ran short of video memory. Game A ran on the RTX 3080 (NVIDIA 621.14) at a median of 60 fps. Game B ran on the Intel UHD 770 (101.7088, `RX_VK_DEVICE=1`) at about 8 fps, with first-visit compile freezes. The setup was otherwise as before: native llvm-mingw build of 9dfdd0c6, each game with its own game folder and user folder holding a copy of one save (adult, Death Mountain Trail), `scripts/coop_relay.py` on 127.0.0.1, A `create` with `coop_presence_permissions=3`, B `join`, both `HOS_COOP_PLAYERS=1` and `HOS_COOP_ACCEPT=always`. Windows that never took focus, input kept out. B walked, then A walked, then both stood for 2.5 min, then B quit, then A. **Bodies:** each game made the other's adult body 4 times in about 5 minutes in the room: | game | hides | when | |---|---|---| | B (iGPU) | 3 × `this game's body liveness grace expired` | each one inside a freeze of B itself: `vi: ... 1.0 fps over 20.1 s`, `1.4 fps over 13.9 s`, `1.7 fps over 16.3 s` (the iGPU compiling on its first visit); A's body was back 0.1-0.2 s later each time (`made in 120-167 ms`) | | A (3080, 60 fps) | 3 × `not heard` | B's freezes seen from A (B sends no pose while frozen); then `WinB (member 2) left the room` at the quit | Through B's 2.5 minutes of steady play at 7-9 fps (25 windows of 5 s) there was **no hide on either side**. So on this head a game that is slow but keeps running keeps its body shown. Only a game frozen for many seconds loses it, and it gets it back at once. That matches what you found with the 0.3/1/3 s stops. **Save and session:** - **Saves:** both normal saves were hash-identical before and after (14 files each). The user folders gained only `coop-backup`, `coop-keys` (A) and `temp`. - **Room:** made, joined, `WinB (member 2) left (1/8)`, `WinA (member 1) left (0/8)` on the relay. - **Health:** no `CRASH`, no device loss, both exited on `quit`. Still not done here: Copy/Return and the junction refusal on Windows, and the game's own hosting. Shots stay on this PC.
The relay answers a CONNECT from a sender that has shown its address (a bad tag, a
member's own CONNECT again, a refused attempt again, a join over the network's budget)
without charging anything for the answer, and a room keeps every player its maker
removed for as long as the room lasts. These tests describe the two limits that close
that: a budget of answers for each network, and a bound on the removals of a room.

Floods of each kind of answer from one network get the burst and a steady rate while
other networks, and the room's own traffic, are untouched. The traffic of the
two-game proofs (a join with its answers lost, body updates, pings, a rename, a
removal, a leave) and eight games behind one address never meet either limit. A room
whose list is full removes no more and takes no newcomer, and forgets no one. Also
over real sockets, and the command-line options.

These tests fail until the limits are added.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
fix(coop): limit the relay's answers per network and the removals a room keeps
All checks were successful
PR description / Description follows the template (pull_request_target) Successful in 6s
430e5dae7b
A sender that has shown its address can make the relay answer each CONNECT it sends,
and nothing else paid for those answers: an error for a bad tag, an error for a
refusal it has had already, the joined answer again, an error for a join over the
network's budget. A hostile client could spend the relay's CPU and bandwidth on them.
Each network (an IPv4 /24, an IPv6 /48) now has a budget of answers, 20 a second after
a burst of 100 (--network-replies), and a CONNECT over it is not answered at all. The
budget is taken before the tag is checked, and its table counts with the other
network budgets toward the 4096 the relay tracks and is forgotten when it is full
again. The network of an address is kept for the last 4096 hosts, because every
datagram the budget check sees asks for it and the two address parses cost more than
the answer the check saves.

A room also kept every player its maker removed, a client id and an address each, for
as long as the room lasted, so one network could make it grow without end. A room now
keeps 4096 removals at most (--room-removals); after that it ignores further
removals and takes no new member (a member of the room still comes back, and no
removed player is forgotten), as the hosted relay's fixed table already does.

Both limits write a log line (at most every 10 s when they turn something away) and
count in the relay's stats (replies_limited, removals_limited). The hosted relay in
host/ is unchanged.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Author
Member

The two relay limits promised in part 3 of #463 are written. They are in scripts/coop_relay.py, with the options and the numbers in docs/coop.md.

Answers. A sender that has shown its address (it answered a challenge) could still make the relay answer every CONNECT it sent, and nothing paid for the answer: an error for a bad tag, a refusal it had already been given, the joined answer again, a refused join. Each network (an IPv4 /24, an IPv6 /48) now has a budget of answers: 20 a second after a burst of 100, and --network-replies changes the rate. A CONNECT over the budget is not answered at all, and that is checked before the tag, so a flood costs the relay little. Five thousand such CONNECTs over ten seconds used to get 5,000 answers (205 to 370 KB, depending on the kind); they now get 299 (12 to 22 KB). Other networks, and the members of the room the flood came from, are not slowed.

Removals. A room remembered every player its maker had removed for as long as the room lasted, so one network that joined a player and removed it every 3 seconds could make that list grow without end. A room now keeps 4096 removals at most (--room-removals). When it is full, the maker's further removals are ignored and the room takes no new member. Players already in it still come back, and nobody who was removed is forgotten. The in-game relay already does the same with its fixed table.

Both limits write a log line (at most one every 10 seconds when they turn something away) and are counted in the relay's statistics.

What was checked. New game-free tests cover floods of each kind of answer, a flood from many networks, a room's list filling up, and a flood over real sockets. They also replay the traffic of the two-game proofs (a join with its answers lost, body updates, a ping, a rename, a removal, a leave) and eight games behind one address joining together: none of that reaches either limit. The new tests fail on the relay without the change and pass with it, and the game session test through the relay passes at 0 and 30 percent loss. The game-free suite on the same head gives 594 passed, 1 failed, 16 skipped. The one failure is the Walk key test, a missing link dependency, and it fails the same way on the co-op branch without this change.

Not covered.

  • The in-game relay (the host button in Make a room) has the removal bound already but not the budget of answers. Adding it changes game code, so it needs its own change and a new build.
  • Both limits are per network, so someone who shares a network with an attacker shares its budget, as with the existing challenge and join limits.
  • A flood from many networks at once, and a firewall list of the testers' addresses for the playtest relay, are outside what these two limits do.
The two relay limits promised in part 3 of https://git.magicbean.dev/MagicBeanDev/Longshot/issues/463 are written. They are in `scripts/coop_relay.py`, with the options and the numbers in `docs/coop.md`. **Answers.** A sender that has shown its address (it answered a challenge) could still make the relay answer every CONNECT it sent, and nothing paid for the answer: an error for a bad tag, a refusal it had already been given, the joined answer again, a refused join. Each network (an IPv4 /24, an IPv6 /48) now has a budget of answers: 20 a second after a burst of 100, and `--network-replies` changes the rate. A CONNECT over the budget is not answered at all, and that is checked before the tag, so a flood costs the relay little. Five thousand such CONNECTs over ten seconds used to get 5,000 answers (205 to 370 KB, depending on the kind); they now get 299 (12 to 22 KB). Other networks, and the members of the room the flood came from, are not slowed. **Removals.** A room remembered every player its maker had removed for as long as the room lasted, so one network that joined a player and removed it every 3 seconds could make that list grow without end. A room now keeps 4096 removals at most (`--room-removals`). When it is full, the maker's further removals are ignored and the room takes no new member. Players already in it still come back, and nobody who was removed is forgotten. The in-game relay already does the same with its fixed table. Both limits write a log line (at most one every 10 seconds when they turn something away) and are counted in the relay's statistics. **What was checked.** New game-free tests cover floods of each kind of answer, a flood from many networks, a room's list filling up, and a flood over real sockets. They also replay the traffic of the two-game proofs (a join with its answers lost, body updates, a ping, a rename, a removal, a leave) and eight games behind one address joining together: none of that reaches either limit. The new tests fail on the relay without the change and pass with it, and the game session test through the relay passes at 0 and 30 percent loss. The game-free suite on the same head gives 594 passed, 1 failed, 16 skipped. The one failure is the Walk key test, a missing link dependency, and it fails the same way on the co-op branch without this change. **Not covered.** - The in-game relay (the host button in Make a room) has the removal bound already but not the budget of answers. Adding it changes game code, so it needs its own change and a new build. - Both limits are per network, so someone who shares a network with an attacker shares its budget, as with the existing challenge and join limits. - A flood from many networks at once, and a firewall list of the testers' addresses for the playtest relay, are outside what these two limits do.
Author
Member

R15: thirty minutes of two-game play passed every rule written beforehand

Tested commit 9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca (the co-op line replayed onto the published head of pull request 68), source d29365fd, with two windowless games on one Linux PC, RTX 4090 and NVIDIA 615.78.08. The game hosted the room over loopback. Each player accepted once, then stood, took short walks and sent the seven planned chat lines. This is one session on one machine, not a performance test, and the six two-game proofs it builds on were run on the commit before the replay (02bedee71797), not repeated here.

The accepted session lasted 1,800.108 seconds with no disconnect, rejoin or unexpected body removal. Every predeclared rule passed, including the two that earlier sessions failed.

What passed

  • Bodies stayed for the whole 30 minutes. In both complete logs there is exactly one request and one creation per game, at the start. The only removal in each game is the planned one: after the 30 minutes B left through the menu, and each game then hid its one remote body, with no revival. No hide, cancel, failed request or recreation appears before that.
  • The five-second check ran on schedule: all 361 paired checks, median gap 5.000000 seconds, largest 5.000148 seconds, no skipped or repeated check. Both games kept their original process and room identities.
  • Network counters: reliable retries 0 and 0, given-up events 0, refused packets 0, test drops 0, full outboxes 0 in both games. The logged round trip was 1 ms (loopback).
  • Memory: resident plus swapped memory grew by 43.7 MiB and 28.7 MiB from minute 2, below the 512 MiB final limit; the largest sampled growth was 51.4 and 41.7 MiB, below the 1,024 MiB limit. Both games reported zero swapped memory in every sample.
  • Saves: every file of each disposable normal save (14 per game) was byte-identical afterwards, including option.sav, and so was the original test save. The rule now compares that file by named fields, because the game rewrites a few of them by itself at 05:00 local time; this session did not span 05:00, so nothing changed. The comparison was also checked against the earlier session's real files: its 99 changed bytes all belong to those named fields.
  • Pictures: both bodies were visible in the inspected baseline, walking, chat and final views. The chat lines showed the friend's name and the message in both games, and after B left each game showed only its own child.
  • Both games exited 0. The kernel record contains no driver line of any kind.

There was no game-present interval longer than one second anywhere in either game, including startup (the earlier session had four at startup; this one started from fully warmed caches). This was not a speed or smoothness measurement.

Beside the earlier sessions

Check 0ec9d0b0 1ed75e61 restart 2f01e1b4 9dfdd0c6 (this one)
Accepted interval 1,803.5 s 1,800.1 s 1,800.1 s 1,800.1 s
Five-second schedule Missed Met Met Met (361 of 361)
Native body lifetime No unexpected removal One hide and recreate None None
Reliable retries 0 0 0 0
Memory growth from minute 2 63.8 and 36.7 MiB 25.9 and 27.3 MiB 28.0 and 23.4 MiB 43.7 and 28.7 MiB
Normal-save bytes Unchanged Unchanged option.sav changed at 05:00 Unchanged (named-field rule)
Overall Sampling rule failed Body rule failed Save rule failed Passed

The earlier sessions are described in #355 (comment) and the comments it links. The two pictures below show the minute-15 chat in both games and both bodies at minute 30, then each game after B left.

Minute 15 in both games: each sees the other's Link; the chat line typed in A appears in both

Minute 30 in both games, then each game after B left: only its own Link

Not covered: Windows, two PCs, internet traffic, other GPUs, physical input, map changes, save copy and Return, transfers, progress-changing actions, adult equipment, fighting or deliberately stalled games. This does not resolve the Windows starvation and 2.5-second play-clock question. The line stays WIP.

The pull request's head is now 430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8, which adds only the relay script's two limits on top of this commit; the game code is the same.

## R15: thirty minutes of two-game play passed every rule written beforehand Tested commit `9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca` (the co-op line replayed onto the published head of pull request 68), source `d29365fd`, with two windowless games on one Linux PC, RTX 4090 and NVIDIA 615.78.08. The game hosted the room over loopback. Each player accepted once, then stood, took short walks and sent the seven planned chat lines. This is one session on one machine, not a performance test, and the six two-game proofs it builds on were run on the commit before the replay (`02bedee71797`), not repeated here. **The accepted session lasted 1,800.108 seconds with no disconnect, rejoin or unexpected body removal. Every predeclared rule passed, including the two that earlier sessions failed.** ### What passed - **Bodies stayed for the whole 30 minutes.** In both complete logs there is exactly one request and one creation per game, at the start. The only removal in each game is the planned one: after the 30 minutes B left through the menu, and each game then hid its one remote body, with no revival. No hide, cancel, failed request or recreation appears before that. - **The five-second check ran on schedule:** all 361 paired checks, median gap 5.000000 seconds, largest 5.000148 seconds, no skipped or repeated check. Both games kept their original process and room identities. - **Network counters:** reliable retries 0 and 0, given-up events 0, refused packets 0, test drops 0, full outboxes 0 in both games. The logged round trip was 1 ms (loopback). - **Memory:** resident plus swapped memory grew by **43.7 MiB and 28.7 MiB** from minute 2, below the 512 MiB final limit; the largest sampled growth was 51.4 and 41.7 MiB, below the 1,024 MiB limit. Both games reported zero swapped memory in every sample. - **Saves:** every file of each disposable normal save (14 per game) was byte-identical afterwards, including `option.sav`, and so was the original test save. The rule now compares that file by named fields, because the game rewrites a few of them by itself at 05:00 local time; this session did not span 05:00, so nothing changed. The comparison was also checked against the earlier session's real files: its 99 changed bytes all belong to those named fields. - **Pictures:** both bodies were visible in the inspected baseline, walking, chat and final views. The chat lines showed the friend's name and the message in both games, and after B left each game showed only its own child. - Both games exited 0. The kernel record contains no driver line of any kind. There was no game-present interval longer than one second anywhere in either game, including startup (the earlier session had four at startup; this one started from fully warmed caches). This was not a speed or smoothness measurement. ### Beside the earlier sessions | Check | `0ec9d0b0` | `1ed75e61` restart | `2f01e1b4` | `9dfdd0c6` (this one) | |---|---|---|---|---| | Accepted interval | 1,803.5 s | 1,800.1 s | 1,800.1 s | 1,800.1 s | | Five-second schedule | Missed | Met | Met | Met (361 of 361) | | Native body lifetime | No unexpected removal | One hide and recreate | None | None | | Reliable retries | 0 | 0 | 0 | 0 | | Memory growth from minute 2 | 63.8 and 36.7 MiB | 25.9 and 27.3 MiB | 28.0 and 23.4 MiB | 43.7 and 28.7 MiB | | Normal-save bytes | Unchanged | Unchanged | `option.sav` changed at 05:00 | Unchanged (named-field rule) | | Overall | Sampling rule failed | Body rule failed | Save rule failed | Passed | The earlier sessions are described in https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-17887 and the comments it links. The two pictures below show the minute-15 chat in both games and both bodies at minute 30, then each game after B left. ![Minute 15 in both games: each sees the other's Link; the chat line typed in A appears in both](https://git.magicbean.dev/attachments/f27c7a9e-2793-40ce-aa98-cc0b289384b7) ![Minute 30 in both games, then each game after B left: only its own Link](https://git.magicbean.dev/attachments/1063dec8-ec67-40af-8849-b5317bd670c1) **Not covered:** Windows, two PCs, internet traffic, other GPUs, physical input, map changes, save copy and Return, transfers, progress-changing actions, adult equipment, fighting or deliberately stalled games. This does not resolve the Windows starvation and 2.5-second play-clock question. The line stays WIP. The pull request's head is now `430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8`, which adds only the relay script's two limits on top of this commit; the game code is the same.
Author
Member

R15 with co-op off: no frame-time difference from its base that this test can tell apart from noise

Question: with co-op off (no room, no co-op settings, default options), does the co-op line cost frame time against the pull request it sits on? Compared on one Linux PC (RTX 4090, NVIDIA 615.78.08, windowless, offscreen timing):

  • base: pull request 68's published head d12e854c4e3a532ea0f40c8f7f552086f7e8a54b
  • candidate: the co-op line 9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca

Both were built the same way (same recipe and flags, each from its own lift, since the co-op line changes one lift input), copied with the same native caches, and run with no options file and no mods. Scene: the Kokiri Forest map from the project's new-game test save, Continue pressed by script, then a 35 second walk (stick forward, camera turning right) from Link's doorway onto the village path beside his house. Output requested at 1280 by 720, frame generation and dynamic resolution off, uncapped. Measured: the game's present-return intervals of the 35 second walk. One exclusive hold, base / candidate / base / candidate, 90 seconds each.

Run Build Mean ms Median ms p99 ms Other work (mean / peak cores)
1 base 11.120 10.835 16.123 0.50 / 0.66
2 candidate 11.181 10.871 16.012 0.71 / 0.92
3 base 11.052 10.729 15.985 0.61 / 0.70
4 candidate 11.038 10.782 15.383 0.41 / 0.56

The last view of each of the four timed runs: the same spot on the village path

All four runs were valid and quiet, none had a kernel driver line, and all four ended in the same view. The two arms reported identical effective options (the candidate adds its own co-op options at their defaults).

Result: the median of the means is 11.086 ms for the base and 11.110 ms for the candidate, a gap of +0.21 percent. The two pairs disagree in sign (+0.55 and -0.13 percent). The runs of the same build differ from each other by 0.61 percent (base) and 1.30 percent (candidate), more than the gap between the builds. Bands were set before the runs: neutral up to 2 percent, a cost from 5 percent. The result is inside the neutral band and not distinguishable from the same-build spread. I am not claiming zero overhead: two runs per build cannot resolve a fraction of a percent.

Not measured: other scenes (this is one small area of the forest, not the open village or a field), co-op on, a second player, Windows, other GPUs, swapchain or display timing, frame generation. The co-op measurement box on the description stays for the maintainers to judge against this single scene.

The session this ran beside is described in the other comment from this round. The commit the line sits on is described at #355 (comment).

The pull request's head is now 430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8, which adds only the relay script's two limits on top of this commit; the game code is the same.

## R15 with co-op off: no frame-time difference from its base that this test can tell apart from noise Question: with co-op **off** (no room, no co-op settings, default options), does the co-op line cost frame time against the pull request it sits on? Compared on one Linux PC (RTX 4090, NVIDIA 615.78.08, windowless, offscreen timing): - base: pull request 68's published head `d12e854c4e3a532ea0f40c8f7f552086f7e8a54b` - candidate: the co-op line `9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca` Both were built the same way (same recipe and flags, each from its own lift, since the co-op line changes one lift input), copied with the same native caches, and run with no options file and no mods. Scene: the Kokiri Forest map from the project's new-game test save, Continue pressed by script, then a 35 second walk (stick forward, camera turning right) from Link's doorway onto the village path beside his house. Output requested at 1280 by 720, frame generation and dynamic resolution off, uncapped. Measured: the game's present-return intervals of the 35 second walk. One exclusive hold, base / candidate / base / candidate, 90 seconds each. | Run | Build | Mean ms | Median ms | p99 ms | Other work (mean / peak cores) | |---|---|---:|---:|---:|---| | 1 | base | 11.120 | 10.835 | 16.123 | 0.50 / 0.66 | | 2 | candidate | 11.181 | 10.871 | 16.012 | 0.71 / 0.92 | | 3 | base | 11.052 | 10.729 | 15.985 | 0.61 / 0.70 | | 4 | candidate | 11.038 | 10.782 | 15.383 | 0.41 / 0.56 | ![The last view of each of the four timed runs: the same spot on the village path](https://git.magicbean.dev/attachments/0a530327-9404-44cf-b6e4-ecffc9d8299e) All four runs were valid and quiet, none had a kernel driver line, and all four ended in the same view. The two arms reported identical effective options (the candidate adds its own co-op options at their defaults). **Result:** the median of the means is 11.086 ms for the base and 11.110 ms for the candidate, a gap of **+0.21 percent**. The two pairs disagree in sign (+0.55 and -0.13 percent). The runs of the same build differ from each other by 0.61 percent (base) and 1.30 percent (candidate), more than the gap between the builds. Bands were set before the runs: neutral up to 2 percent, a cost from 5 percent. The result is inside the neutral band and not distinguishable from the same-build spread. I am not claiming zero overhead: two runs per build cannot resolve a fraction of a percent. **Not measured:** other scenes (this is one small area of the forest, not the open village or a field), co-op on, a second player, Windows, other GPUs, swapchain or display timing, frame generation. The co-op measurement box on the description stays for the maintainers to judge against this single scene. The session this ran beside is described in the other comment from this round. The commit the line sits on is described at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-20697. The pull request's head is now `430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8`, which adds only the relay script's two limits on top of this commit; the game code is the same.
Author
Member

Co-op between a Linux PC and a Windows PC on coop-playtest-r15 (9dfdd0c6c1a0)

This is a functional test of the current head of this pull request on two real machines on one home network: a Linux PC (RTX 4090) and a Windows 11 PC (Intel Arc). Both ran the exact same commit, 9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca, built from the same sources (version line v3.0.0-rc.3-198-g9dfdd0c6c (source d29365fd) on both). Each side used a copy of the same small test save and its own identity; nothing was copied between the PCs. It is not a performance or smoothness test.

What was run

Two sessions, one for each hosting direction, each about 15 minutes with both games running and played through the game's remote control interface:

  1. The Windows PC hosts and the Linux PC joins its address.
  2. The Linux PC hosts and the Windows PC joins its address.

In each session: the game's own hosting and joining (no helper standing in for the relay), the signed room terms read and accepted by each side with the real two-press confirmation, both child bodies shown on both screens, each player walking while the other screen is captured, two chat lines each way, one of the Linux game stopped for 5 seconds and then resumed, and the joining player leaving.

Results

Windows hosts, Linux joins Linux hosts, Windows joins
Result pass pass
Both games exit 0 and 0 0 and 0
Time with both bodies in the room 628 s of a 888 s run 625 s of a 892 s run
Signed terms and consent same epoch, same maker key and same rules on both PCs; each side accepted exactly once same
Bodies one made on each side at the start, none made or removed again until the Leave same
5 s stop of the Linux game both bodies stayed on both screens, no new consent, walking and chat carried on both bodies stayed on both screens, no new consent, walking carried on
Chat the first line each way shown on both screens; the second line each way also shown on the Windows screen the first line each way shown on both screens (the second lines were sent but not looked at in this session)
Leave the leaving player's game and the other game both removed the other body; the other screen showed a "left" notice the other body was removed on both sides
Network counters in the game's own statistics 0 retries, 0 events given up, nothing dropped or thrown away same
Save files every file of both players' save folders and of the test saves they were copied from is byte for byte unchanged same

The first attempt of the Linux-hosts session stopped by itself after 3 minutes, on a wrong timing assumption in my test script (it checked for the host's acceptance two seconds before the game had finished its second press). The game did accept; no game fault. The session above is the second attempt, with the check made to wait for the line.

Pictures

Both bodies on both screens, in both directions

Walking: the Windows host's screen while the Linux player walks, and the Linux joiner's screen while the Windows player walks

Chat both ways: typed and sent on one PC, shown on the other

The 5 s stop of the Linux game, then the Leave

What this does not show

Only the child bodies, one test save and one scene. Not tried: more than two players, adult bodies or gear, the temporary save and Return route on Windows, a connection across the internet, a Mac, or a controller. The stills show moments, not every frame, and the Linux captures through the remote control interface have no menu or chat overlay, so Linux chat evidence comes from the game's own overlay frames. A 5 s stop is shorter than the grace the game gives before it removes a body; longer stops were tried earlier on the Linux PC only.

To reproduce

Both PCs need this exact commit. For the Windows host: allow inbound UDP port 24680 for the game on the private network only, and give the Linux player the Windows PC's home-network address with that port, not a tailnet or other address. For the Linux host: allow inbound UDP 24680 from the Windows PC's address. A second player must read and accept the signed terms themselves; joining alone does not turn on bodies or chat.

The pull request's head is now 430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8, which adds only the relay script's two limits on top of the tested commit; the game code is the same.

## Co-op between a Linux PC and a Windows PC on `coop-playtest-r15` (`9dfdd0c6c1a0`) This is a functional test of the current head of this pull request on two real machines on one home network: a Linux PC (RTX 4090) and a Windows 11 PC (Intel Arc). Both ran the exact same commit, `9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca`, built from the same sources (version line `v3.0.0-rc.3-198-g9dfdd0c6c (source d29365fd)` on both). Each side used a copy of the same small test save and its own identity; nothing was copied between the PCs. It is not a performance or smoothness test. ### What was run Two sessions, one for each hosting direction, each about 15 minutes with both games running and played through the game's remote control interface: 1. The Windows PC hosts and the Linux PC joins its address. 2. The Linux PC hosts and the Windows PC joins its address. In each session: the game's own hosting and joining (no helper standing in for the relay), the signed room terms read and accepted by each side with the real two-press confirmation, both child bodies shown on both screens, each player walking while the other screen is captured, two chat lines each way, one of the Linux game stopped for 5 seconds and then resumed, and the joining player leaving. ### Results | | Windows hosts, Linux joins | Linux hosts, Windows joins | |---|---|---| | Result | pass | pass | | Both games exit | 0 and 0 | 0 and 0 | | Time with both bodies in the room | 628 s of a 888 s run | 625 s of a 892 s run | | Signed terms and consent | same epoch, same maker key and same rules on both PCs; each side accepted exactly once | same | | Bodies | one made on each side at the start, none made or removed again until the Leave | same | | 5 s stop of the Linux game | both bodies stayed on both screens, no new consent, walking and chat carried on | both bodies stayed on both screens, no new consent, walking carried on | | Chat | the first line each way shown on both screens; the second line each way also shown on the Windows screen | the first line each way shown on both screens (the second lines were sent but not looked at in this session) | | Leave | the leaving player's game and the other game both removed the other body; the other screen showed a "left" notice | the other body was removed on both sides | | Network counters in the game's own statistics | 0 retries, 0 events given up, nothing dropped or thrown away | same | | Save files | every file of both players' save folders and of the test saves they were copied from is byte for byte unchanged | same | The first attempt of the Linux-hosts session stopped by itself after 3 minutes, on a wrong timing assumption in my test script (it checked for the host's acceptance two seconds before the game had finished its second press). The game did accept; no game fault. The session above is the second attempt, with the check made to wait for the line. ### Pictures ![Both bodies on both screens, in both directions](https://git.magicbean.dev/attachments/78fcb3d2-eb16-4953-ad10-e63db0c87bd3) ![Walking: the Windows host's screen while the Linux player walks, and the Linux joiner's screen while the Windows player walks](https://git.magicbean.dev/attachments/23a497f8-f235-418c-8ab8-0dae2f892a15) ![Chat both ways: typed and sent on one PC, shown on the other](https://git.magicbean.dev/attachments/ccb753b1-5d83-4ceb-a2e5-539699cdb74c) ![The 5 s stop of the Linux game, then the Leave](https://git.magicbean.dev/attachments/a105aad3-a6e4-4d2e-8ee5-cb45d5a22a83) ### What this does not show Only the child bodies, one test save and one scene. Not tried: more than two players, adult bodies or gear, the temporary save and Return route on Windows, a connection across the internet, a Mac, or a controller. The stills show moments, not every frame, and the Linux captures through the remote control interface have no menu or chat overlay, so Linux chat evidence comes from the game's own overlay frames. A 5 s stop is shorter than the grace the game gives before it removes a body; longer stops were tried earlier on the Linux PC only. ### To reproduce Both PCs need this exact commit. For the Windows host: allow inbound UDP port 24680 for the game on the private network only, and give the Linux player the Windows PC's home-network address with that port, not a tailnet or other address. For the Linux host: allow inbound UDP 24680 from the Windows PC's address. A second player must read and accept the signed terms themselves; joining alone does not turn on bodies or chat. The pull request's head is now `430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8`, which adds only the relay script's two limits on top of the tested commit; the game code is the same.
mooki force-pushed coop-playtest-r9 from 430e5dae7b
All checks were successful
PR description / Description follows the template (pull_request_target) Successful in 6s
to 5137c513ab
All checks were successful
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 14s
CI / Workflow lint (actionlint) (pull_request) Successful in 21s
Third-party parts / As their notes say (pull_request) Successful in 30s
PR description / Description follows the template (pull_request_target) Successful in 17s
2026-11-15 10:57:20 +00:00
Compare
Author
Member

Results on the new head of this pull request, 5137c513ab1467df42d2ab8688ff25a850fe753c (branch coop-playtest-r16, game version v3.0.0-rc.3-246-g5137c513a). It sits on the head of pull request 68, 3320a841036f02484ae68c72f02b6f34928f776e, on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c. What is new on it since the last head of this pull request (430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8, r15 plus the relay's two limits): the whole line carried onto the new head of pull request 68; coop_players on by default (the room's signed rules and each player's acceptance still decide whether a body is shown), with the body assets indexed at start only when co-op is on; the direct connection between two players (the game can look for a path that does not go through the relay and, with coop_direct=on, send its messages over it, with the relay as the fallback); the Co-op tab's Direct connections row with a per-player path word; the relays answering STUN so no other server has to be asked; an opt-in request to the router for a port mapping while hosting; and libjuice 1.7.4 (https://github.com/paullouisageneau/libjuice) added unmodified. Direct connections are off by default.

This comment gives the results for this exact commit: the game-free test suite, the build, all six two-game proofs (five passed on the first attempt, one on the second) and three direct-connection runs. Nothing here is carried over from an earlier head. Below, "the earlier head" is 02bedee717978ccc13dde9029dd5ff9d086b5516 (r14b), the head the six proofs last ran on; the push of r15 carried them over without running them again.

The game-free test suite

One run of the whole suite on this head: 597 passed, 12 failed, 16 skipped (219 seconds). The same 12 files fail on main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c and on the pull request 68 head, none of them touches co-op, and nothing that passes there fails here.

Head Passed / failed / skipped
main 6c9edffe5da1f5b5383977aeab3f544c0de25d4c 552 / 12 / 16
pull request 68's head 3320a841036f02484ae68c72f02b6f34928f776e 563 / 12 / 16
a local candidate that was not pushed, da38c28614fb8f31f1efbdd875d4db86cebb57bf (the first with libjuice) 595 / 12 / 16
this head 5137c513ab1467df42d2ab8688ff25a850fe753c 597 / 12 / 16

Compared with that candidate there are two more passing files (the test that runs the direct paths through simulated routers, and the port mapping test), none missing and none changed.

The build

The game was built for Linux from this exact commit. The code lifted from the original game did not need to be lifted again: this head changes none of the 37 files that go into the lift since that candidate, so the lift made for the candidate was checked file by file (and the lift key and generated code fingerprint) and reused. The native compile took 17 seconds (111 new units, 427 reused). Every one of the 186,628 asset files equals the build of r15 (9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca) except one: the list of pipelines prepared before the title is larger (35.3 MB, against 23.2 MB), because main's change that added 22,987 pipelines from a tour of every map is in this head's base. The first start, with that larger list, prepared shaders for 288 seconds and then reached the title screen; I looked at that screen. The seven generated co-op body files pass the game's own loader check.

The six proofs

Every run is two windowless games on one Linux PC with an RTX 4090 and NVIDIA's driver, through a relay on the same PC, at 1280x720, from copies of test saves, with direct connections off (the default).

Proof What the two games did Result
Signed transfer of a checkpoint Both games on temporary copies of the save. The owner approved one download, nothing was sent before the exact approval, a wrong manifest received 0 bytes, and the two files arrived and matched their digests. A second transfer was cancelled after 8,192 of 160,019 bytes. Passed on the first attempt. After the cancel no usable save, no restart ticket and no change to either game's saves. All 54 result lines are the same as on the earlier head.
Consent, bodies and Leave Before anyone agreed each game showed only its own player. After both agreed, each game showed the other player's body once. The maker then left. Passed on the second attempt (the first stopped while loading, before any co-op step, and is not counted). One body created, shown and removed in each game; none shown again after Leave. All 14 result lines are the same as on the earlier head.
Temporary copy, autosave and Return Both games restarted onto a temporary copy of the save (each game's log shows it mounting the temporary folder). In the first game the player opened a chest and took the item, and the game's own autosave wrote the change into the temporary copy. Both games then returned to the original save. Passed on the first attempt. The first game's temporary copy had 3 changed files (the second game's had none); both original saves were byte for byte the same before and after, the changed temporary copy was kept, and both games mounted the normal save again. All 36 result lines are the same as on the earlier head.
Signed terms, stale confirmation and fresh consent Both games showed the room's signed terms before anyone accepted. Switching tabs and closing the menu cancelled the maker's earlier confirmation; the maker accepted only after a fresh two-press confirmation. The room's rules then changed to a signed PvP setup, and the second game's old confirming press did not accept it; a fresh confirmation did. Passed on the first attempt. All 13 checks pass, no progress was applied to either save, and no body of the other player appeared at any point. 22 result lines are the same as on the earlier head (the maker's key is a new random value every run, by design).
Standing, walking and turning presence off After both games agreed, each showed one body of the other player standing apart. Each player then walked four short legs while the other game showed the walking pose, and the maker then turned presence off. Passed on the first attempt. Each game created, showed and removed the other player's body exactly once; each received 6 walking and 7 standing requests, all played, none failed; after the change each game showed only its own player. All 41 result lines are the same as on the earlier head.
Five sword swings and the damage counters The first player swung the sword five times next to the second player while both games counted the game's own damage records. Passed on the first attempt. New sword-activity records in each of the five swings (158, 144, 147, 157 and 152); the second player did not move; no committed health loss in either game through the game's own life path; every counter lane complete with no missing record. All 18 result lines are the same as on the earlier head except the five counts.

Signed transfer and partial cancel: passed on the first attempt

Both games exited with code 0, nothing was left running, and the kernel log showed no driver fault. In the first game three intervals between pictures were over one second early in its start, before the menu was reached (2.4, 2.4 and 4.0 seconds, while the PC's load average was about 22 because of other work); I did not find the cause. After that, the only intervals over one second were the last picture of each game before the restart that Copy makes on purpose (1.4 seconds each). The pictures show only each game's own player, as they should before anyone has joined (I looked at all six).

Consent, bodies and Leave: passed on the second attempt

The first attempt stopped while game A was loading its save, before any co-op step: the game stalled for 9 and 12 seconds inside a present call and the scripted input of the test timed out, at a time when the PC was busy with other work. That says nothing about co-op, and it is not counted. The second attempt, on a quiet PC, passed: no body of the other player before anyone agreed; after both agreed, each game showed exactly one body of the other player (created once, in 33 milliseconds, after the consent); the maker then left, and each game removed that body once and never showed it again. All 14 result lines are the same as on the earlier head. I read both complete logs for every request, show and removal, and looked at all six pictures: one player before consent, two separated players in each game after both agreed, one player again after Leave. Both games exited with code 0, the kernel log showed no driver fault, and no direct-connection line appears in either log (it is off by default).

Temporary copy, autosave and Return: passed on the first attempt

Both games exited with code 0, nothing was left running, the kernel log showed no driver fault, and there was no interval over one second between pictures in any of the three runs of each game (the last picture before each restart that Copy makes on purpose took 0.38 seconds). I looked at the six-view panel, the full-size autosave picture and the four action pictures: both players start at a closed chest with the Open prompt; the first game shows the chest being opened and then the sword raised; its autosave picture shows the open chest, the player in front of it, "Saving..." and the Swing Sword prompt; the second game's chest stays shut in every picture; both returned pictures are the title screen with Continue selected.

Signed terms, stale confirmation and fresh consent: passed on the first attempt

Both games exited with code 0, the kernel log showed no driver fault (it also holds lines from a test program of another job on the PC that crashes on purpose; none of them is the game), and there was no interval over one second between pictures in either game. I read both complete logs: no body was requested, shown or removed. The gameplay pictures show only each game's own player, as they should. The signed terms are in the game's own menu pictures, which I looked at as contact sheets of every capture around the menu and at full size: the Mode row reads "Signed terms, read only. Maker: 2aec-93bd-73fb-16c4. CO-OP. Accept pins these exact terms."; the second game then shows "PvP room setup, 2 players: Room rules changed. Read the new Room rules before accepting." with the Accept row reset to Accept, and its Mode row reads "PvP setup (no fighting) ... This build cannot start a fight. Ready is unavailable."

Standing, walking and turning presence off: passed on the first attempt

Both games exited with code 0, the kernel log showed no driver fault, and there was no interval over one second between pictures in either game. I read both complete logs and looked at the six-view panel and all 42 captures: both complete bodies are framed in every view in ordinary colours with arms down while standing; in the other game's view the walking player's leg is lifted with a bent knee while it walks, standing is restored after the walk, and after presence is turned off each game shows only its own player. The pictures are taken one game at a time, not at the same instant.

Five sword swings and the damage counters: passed on the first attempt

Both games exited with code 0, nothing was left running, the kernel log showed no driver fault, and there was no interval over one second between pictures in either game. I read both complete logs: one request and one show of the other player's body per game; the first game removed its copy once when the second game closed, and the second game logged no removal before it exited. The counters of both games were complete and exact before and after the swings, with 0 committed losses on both sides (first game 0 to 0, second game 0 to 0). That is a statement about the game's native life path in that interval: it is not a test of sword contact, shields, range or every way health can change, and the activation counts are not calibrated sword hits. The counts are higher than on the earlier head (114, 113, 106, 121 and 125 there), probably because the count follows how many frames ran in each swing (this run's first game drew 55.6 frames a second, the earlier head's run 42.3); I did not isolate that with a second run, and it does not change what the check is for. I looked at all 14 pictures, a crop of the hearts in each (three full hearts in all 14) and the six-view panel: in the first game's pictures its own player swings the blade five times (blade and arc visible) while the other player stands still; in the second game's pictures its own player does not move and the other player is in motion at the edge of the picture.

Taken together

All six proofs ran on this exact head with every game exiting 0, no process left running, a complete kernel log with no driver fault, and every result line equal to the earlier head's except the maker's random key (signed terms) and the five swing counts. Whole logs were read for every body request, show and removal. Every picture cited was looked at.

Direct connections, three runs with two real games

Each run used two windowless games on one PC, a relay on the same PC, the first game making the room and the second joining, both with coop_direct set the same way through the environment. What I expected was written down before each run. The relay was counted by a small wrapper around the project's own relay code.

  • Direct on. Both games found a direct path (host/host) within a second of both being ready, and neither logged a fallback. After that the relay forwarded 0 datagrams a second over a 136 second steady window and received 1 a second (the keep-alive pings). All four chat lines arrived, and no body was removed before the end. The Co-op tab shows the Direct connections row as Direct (on) (fixed, with no arrows, because the environment holds it) with the warning line under it, and the second game's list of players reads (maker, direct). One expectation failed as I wrote it: I expected at least 500 datagrams on the path at the first stats line, but that line came 14 to 16 seconds after the pair formed (269 and 309); growth per minute (about 1,165 each) was as expected.
  • A blocked path in the middle of a session. No root is available, so each game's direct traffic went through a small program that pretends to be a router and can stop forwarding on command. With the path blocked both ways, each game logged that the path had gone quiet about 1.1 seconds later (messages then go both ways), the path was declared down 4.0 seconds after the block, and the relay carried the whole game again (about 31.6 datagrams a second forwarded, against 0 when direct). The first retry came 10.0 seconds after it went down, and the pair was direct again 7.5 seconds after the block was lifted. A second block in one direction only (first game to second) made both games suspect after 1.4 seconds, the second game closed the path at 4.0 seconds, the retry came 30.0 seconds after that (the documented wait), and the pair was direct 0.05 seconds later. All ten chat lines arrived and no body was hidden at any point. One expectation failed as written: the last stats line of each game was printed during the 30 second wait, so it read waiting instead of direct.
  • Probe mode. The path was found and reported as direct, while the relay kept forwarding about 30.9 datagrams a second, with no drop when the path was proven; the path itself carried only probes (236 to 238 a minute). One expectation failed: the second game logged one suspect line and direct again half a second later, and the first game logged nothing; no frame over 200 milliseconds shows in either game's picture trace, and I did not find the cause.

Both games of every run exited with code 0 and the kernel log showed no driver fault. In every Co-op tab picture the first game's list of players is below the visible part of the menu, so the word the first game shows for the second player was never pictured.

Not tested

  • Windows and any other GPU or driver than an RTX 4090 with NVIDIA's driver.
  • A real network: all runs are on one PC, so there is no real router, no distance and no lost packets other than the ones a test makes.
  • More than two players, long sessions, sword contact and fighting, adult bodies and equipment.
  • Speed: nothing here is a measurement of frame rate or frame time.
Results on the new head of this pull request, `5137c513ab1467df42d2ab8688ff25a850fe753c` (branch `coop-playtest-r16`, game version `v3.0.0-rc.3-246-g5137c513a`). It sits on the head of pull request 68, `3320a841036f02484ae68c72f02b6f34928f776e`, on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c`. What is new on it since the last head of this pull request (`430e5dae7b04ad0d7fc8115bfd79b61908fbb6c8`, r15 plus the relay's two limits): the whole line carried onto the new head of pull request 68; `coop_players` on by default (the room's signed rules and each player's acceptance still decide whether a body is shown), with the body assets indexed at start only when co-op is on; the direct connection between two players (the game can look for a path that does not go through the relay and, with `coop_direct=on`, send its messages over it, with the relay as the fallback); the Co-op tab's Direct connections row with a per-player path word; the relays answering STUN so no other server has to be asked; an opt-in request to the router for a port mapping while hosting; and libjuice 1.7.4 (https://github.com/paullouisageneau/libjuice) added unmodified. Direct connections are off by default. This comment gives the results for this exact commit: the game-free test suite, the build, all six two-game proofs (five passed on the first attempt, one on the second) and three direct-connection runs. Nothing here is carried over from an earlier head. Below, "the earlier head" is `02bedee717978ccc13dde9029dd5ff9d086b5516` (r14b), the head the six proofs last ran on; the push of r15 carried them over without running them again. **The game-free test suite** One run of the whole suite on this head: 597 passed, 12 failed, 16 skipped (219 seconds). The same 12 files fail on main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c` and on the pull request 68 head, none of them touches co-op, and nothing that passes there fails here. | Head | Passed / failed / skipped | |---|---| | main `6c9edffe5da1f5b5383977aeab3f544c0de25d4c` | 552 / 12 / 16 | | pull request 68's head `3320a841036f02484ae68c72f02b6f34928f776e` | 563 / 12 / 16 | | a local candidate that was not pushed, `da38c28614fb8f31f1efbdd875d4db86cebb57bf` (the first with libjuice) | 595 / 12 / 16 | | this head `5137c513ab1467df42d2ab8688ff25a850fe753c` | 597 / 12 / 16 | Compared with that candidate there are two more passing files (the test that runs the direct paths through simulated routers, and the port mapping test), none missing and none changed. **The build** The game was built for Linux from this exact commit. The code lifted from the original game did not need to be lifted again: this head changes none of the 37 files that go into the lift since that candidate, so the lift made for the candidate was checked file by file (and the lift key and generated code fingerprint) and reused. The native compile took 17 seconds (111 new units, 427 reused). Every one of the 186,628 asset files equals the build of r15 (`9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca`) except one: the list of pipelines prepared before the title is larger (35.3 MB, against 23.2 MB), because main's change that added 22,987 pipelines from a tour of every map is in this head's base. The first start, with that larger list, prepared shaders for 288 seconds and then reached the title screen; I looked at that screen. The seven generated co-op body files pass the game's own loader check. **The six proofs** Every run is two windowless games on one Linux PC with an RTX 4090 and NVIDIA's driver, through a relay on the same PC, at 1280x720, from copies of test saves, with direct connections off (the default). | Proof | What the two games did | Result | |---|---|---| | Signed transfer of a checkpoint | Both games on temporary copies of the save. The owner approved one download, nothing was sent before the exact approval, a wrong manifest received 0 bytes, and the two files arrived and matched their digests. A second transfer was cancelled after 8,192 of 160,019 bytes. | Passed on the first attempt. After the cancel no usable save, no restart ticket and no change to either game's saves. All 54 result lines are the same as on the earlier head. | | Consent, bodies and Leave | Before anyone agreed each game showed only its own player. After both agreed, each game showed the other player's body once. The maker then left. | Passed on the second attempt (the first stopped while loading, before any co-op step, and is not counted). One body created, shown and removed in each game; none shown again after Leave. All 14 result lines are the same as on the earlier head. | | Temporary copy, autosave and Return | Both games restarted onto a temporary copy of the save (each game's log shows it mounting the temporary folder). In the first game the player opened a chest and took the item, and the game's own autosave wrote the change into the temporary copy. Both games then returned to the original save. | Passed on the first attempt. The first game's temporary copy had 3 changed files (the second game's had none); both original saves were byte for byte the same before and after, the changed temporary copy was kept, and both games mounted the normal save again. All 36 result lines are the same as on the earlier head. | | Signed terms, stale confirmation and fresh consent | Both games showed the room's signed terms before anyone accepted. Switching tabs and closing the menu cancelled the maker's earlier confirmation; the maker accepted only after a fresh two-press confirmation. The room's rules then changed to a signed PvP setup, and the second game's old confirming press did not accept it; a fresh confirmation did. | Passed on the first attempt. All 13 checks pass, no progress was applied to either save, and no body of the other player appeared at any point. 22 result lines are the same as on the earlier head (the maker's key is a new random value every run, by design). | | Standing, walking and turning presence off | After both games agreed, each showed one body of the other player standing apart. Each player then walked four short legs while the other game showed the walking pose, and the maker then turned presence off. | Passed on the first attempt. Each game created, showed and removed the other player's body exactly once; each received 6 walking and 7 standing requests, all played, none failed; after the change each game showed only its own player. All 41 result lines are the same as on the earlier head. | | Five sword swings and the damage counters | The first player swung the sword five times next to the second player while both games counted the game's own damage records. | Passed on the first attempt. New sword-activity records in each of the five swings (158, 144, 147, 157 and 152); the second player did not move; no committed health loss in either game through the game's own life path; every counter lane complete with no missing record. All 18 result lines are the same as on the earlier head except the five counts. | **Signed transfer and partial cancel: passed on the first attempt** Both games exited with code 0, nothing was left running, and the kernel log showed no driver fault. In the first game three intervals between pictures were over one second early in its start, before the menu was reached (2.4, 2.4 and 4.0 seconds, while the PC's load average was about 22 because of other work); I did not find the cause. After that, the only intervals over one second were the last picture of each game before the restart that Copy makes on purpose (1.4 seconds each). The pictures show only each game's own player, as they should before anyone has joined (I looked at all six). **Consent, bodies and Leave: passed on the second attempt** The first attempt stopped while game A was loading its save, before any co-op step: the game stalled for 9 and 12 seconds inside a present call and the scripted input of the test timed out, at a time when the PC was busy with other work. That says nothing about co-op, and it is not counted. The second attempt, on a quiet PC, passed: no body of the other player before anyone agreed; after both agreed, each game showed exactly one body of the other player (created once, in 33 milliseconds, after the consent); the maker then left, and each game removed that body once and never showed it again. All 14 result lines are the same as on the earlier head. I read both complete logs for every request, show and removal, and looked at all six pictures: one player before consent, two separated players in each game after both agreed, one player again after Leave. Both games exited with code 0, the kernel log showed no driver fault, and no direct-connection line appears in either log (it is off by default). **Temporary copy, autosave and Return: passed on the first attempt** Both games exited with code 0, nothing was left running, the kernel log showed no driver fault, and there was no interval over one second between pictures in any of the three runs of each game (the last picture before each restart that Copy makes on purpose took 0.38 seconds). I looked at the six-view panel, the full-size autosave picture and the four action pictures: both players start at a closed chest with the Open prompt; the first game shows the chest being opened and then the sword raised; its autosave picture shows the open chest, the player in front of it, "Saving..." and the Swing Sword prompt; the second game's chest stays shut in every picture; both returned pictures are the title screen with Continue selected. **Signed terms, stale confirmation and fresh consent: passed on the first attempt** Both games exited with code 0, the kernel log showed no driver fault (it also holds lines from a test program of another job on the PC that crashes on purpose; none of them is the game), and there was no interval over one second between pictures in either game. I read both complete logs: no body was requested, shown or removed. The gameplay pictures show only each game's own player, as they should. The signed terms are in the game's own menu pictures, which I looked at as contact sheets of every capture around the menu and at full size: the Mode row reads "Signed terms, read only. Maker: 2aec-93bd-73fb-16c4. CO-OP. Accept pins these exact terms."; the second game then shows "PvP room setup, 2 players: Room rules changed. Read the new Room rules before accepting." with the Accept row reset to Accept, and its Mode row reads "PvP setup (no fighting) ... This build cannot start a fight. Ready is unavailable." **Standing, walking and turning presence off: passed on the first attempt** Both games exited with code 0, the kernel log showed no driver fault, and there was no interval over one second between pictures in either game. I read both complete logs and looked at the six-view panel and all 42 captures: both complete bodies are framed in every view in ordinary colours with arms down while standing; in the other game's view the walking player's leg is lifted with a bent knee while it walks, standing is restored after the walk, and after presence is turned off each game shows only its own player. The pictures are taken one game at a time, not at the same instant. **Five sword swings and the damage counters: passed on the first attempt** Both games exited with code 0, nothing was left running, the kernel log showed no driver fault, and there was no interval over one second between pictures in either game. I read both complete logs: one request and one show of the other player's body per game; the first game removed its copy once when the second game closed, and the second game logged no removal before it exited. The counters of both games were complete and exact before and after the swings, with 0 committed losses on both sides (first game 0 to 0, second game 0 to 0). That is a statement about the game's native life path in that interval: it is not a test of sword contact, shields, range or every way health can change, and the activation counts are not calibrated sword hits. The counts are higher than on the earlier head (114, 113, 106, 121 and 125 there), probably because the count follows how many frames ran in each swing (this run's first game drew 55.6 frames a second, the earlier head's run 42.3); I did not isolate that with a second run, and it does not change what the check is for. I looked at all 14 pictures, a crop of the hearts in each (three full hearts in all 14) and the six-view panel: in the first game's pictures its own player swings the blade five times (blade and arc visible) while the other player stands still; in the second game's pictures its own player does not move and the other player is in motion at the edge of the picture. **Taken together** All six proofs ran on this exact head with every game exiting 0, no process left running, a complete kernel log with no driver fault, and every result line equal to the earlier head's except the maker's random key (signed terms) and the five swing counts. Whole logs were read for every body request, show and removal. Every picture cited was looked at. **Direct connections, three runs with two real games** Each run used two windowless games on one PC, a relay on the same PC, the first game making the room and the second joining, both with `coop_direct` set the same way through the environment. What I expected was written down before each run. The relay was counted by a small wrapper around the project's own relay code. - **Direct on.** Both games found a direct path (`host/host`) within a second of both being ready, and neither logged a fallback. After that the relay forwarded 0 datagrams a second over a 136 second steady window and received 1 a second (the keep-alive pings). All four chat lines arrived, and no body was removed before the end. The Co-op tab shows the Direct connections row as `Direct (on)` (fixed, with no arrows, because the environment holds it) with the warning line under it, and the second game's list of players reads `(maker, direct)`. One expectation failed as I wrote it: I expected at least 500 datagrams on the path at the first stats line, but that line came 14 to 16 seconds after the pair formed (269 and 309); growth per minute (about 1,165 each) was as expected. - **A blocked path in the middle of a session.** No root is available, so each game's direct traffic went through a small program that pretends to be a router and can stop forwarding on command. With the path blocked both ways, each game logged that the path had gone quiet about 1.1 seconds later (messages then go both ways), the path was declared down 4.0 seconds after the block, and the relay carried the whole game again (about 31.6 datagrams a second forwarded, against 0 when direct). The first retry came 10.0 seconds after it went down, and the pair was direct again 7.5 seconds after the block was lifted. A second block in one direction only (first game to second) made both games suspect after 1.4 seconds, the second game closed the path at 4.0 seconds, the retry came 30.0 seconds after that (the documented wait), and the pair was direct 0.05 seconds later. All ten chat lines arrived and no body was hidden at any point. One expectation failed as written: the last stats line of each game was printed during the 30 second wait, so it read `waiting` instead of `direct`. - **Probe mode.** The path was found and reported as `direct`, while the relay kept forwarding about 30.9 datagrams a second, with no drop when the path was proven; the path itself carried only probes (236 to 238 a minute). One expectation failed: the second game logged one suspect line and `direct again` half a second later, and the first game logged nothing; no frame over 200 milliseconds shows in either game's picture trace, and I did not find the cause. Both games of every run exited with code 0 and the kernel log showed no driver fault. In every Co-op tab picture the first game's list of players is below the visible part of the menu, so the word the first game shows for the second player was never pictured. **Not tested** - Windows and any other GPU or driver than an RTX 4090 with NVIDIA's driver. - A real network: all runs are on one PC, so there is no real router, no distance and no lost packets other than the ones a test makes. - More than two players, long sessions, sword contact and fighting, adult bodies and equipment. - Speed: nothing here is a measurement of frame rate or frame time.
Author
Member

Direct connections between a Linux PC and a Windows PC on coop-playtest-r16 (5137c513ab14)

This is a functional test of the current head of this pull request on two real machines on one home network: a Linux PC (RTX 4090) and a Windows 11 PC (Intel Arc). Both ran the exact same commit, 5137c513ab1467df42d2ab8688ff25a850fe753c (version line v3.0.0-rc.3-246-g5137c513a (source e4be3142) on both). Each side used a copy of the same small test save and its own identity. It is not a performance or smoothness test.

What was run

Two sessions with both games running and played through the game's remote control interface, "Direct (on)" set in both options files, and the signed terms read and accepted with the real two-press confirmation on both sides (an earlier session with direct connections off is described after the results):

  1. The Windows player hosts the relay in its own game, the Linux player joins. By design a room whose relay runs on the maker's PC makes no direct pair with the maker.
  2. The relay runs on a third machine at home (the relay script with the new limits; it answers no STUN, so the games could only offer their own addresses). The Windows player made the room and the Linux player joined. The pair should find a direct path with the relay carrying only its keep-alives; the Linux game was then stopped for 5 seconds; then the Linux game's "Direct connections" row was set to Off in the running game and back to On.

Results

Session 1 (the maker hosts the relay): the Linux game logged its relay runs on its PC; no direct path is needed right after the accept; neither game proved a direct path; nothing at all passed on the direct ports (87 five-second counts on the Windows PC); one body each, chat each way delivered and acknowledged; both games exit 0; saves byte for byte unchanged.

Session 2 (relay on a third machine, about 12 minutes):

Step What the games logged Result
Accept both games: direct (host/host) in 0.1 s direct path proven at once, on both sides
Relay while direct the relay's traffic on the Windows PC fell to its 2 second keep-alives (about 0.7 packets a second in, 0.5 to 1 out); the relay process stayed at its idle wake-up rate game messages went over the direct path
5 s stop of the Linux game the Windows game logged the silent pair, closed it as silent and tried again after its retry wait; the Linux game logged no direct path (the other player gave up) and then the new attempt a new direct path 11 s after the stop ended; no body hidden or made again
Row set to Off Linux: coop_direct=off (from the Co-op tab); the Windows game saw the silent pair go suspect, then closed it both games carried on through the relay: chat each way delivered, no body removed; the relay's traffic rose to about 17 packets a second in and 10 out
Row set back to On Linux: coop_direct=on (from the Co-op tab); the Windows game found the path at its next retry, 28 s later direct again; the relay went back to keep-alives only
Chat one line each way in every phase (direct, relay after Off, direct again) all six delivered and acknowledged
Both games exit 0 and 0 save files byte for byte unchanged
Errors no co-op error in either log; 0 retries, 0 events given up, nothing thrown away none

Short "not answered for 1.5 s ... direct again" episodes also appeared now and then (7 across both games in about 12 minutes, each over within a second or two); nothing was hidden or lost in them.

An earlier session, with direct connections off, not in the table. The Linux player hosted the relay in its game and the Windows player joined. None of its Windows pictures were taken: the picture request aimed at the wrong one of the two processes the Windows game starts (the second one shows a message after a crash and owns no window). That was shown on the Windows PC with two short title-screen runs, with and without the second process, and the setup was changed; the session itself was not repeated. Its logs and network counts show what direct off should: nothing at all on the direct ports (one flow between the two PCs, on the relay's port), one body each, chat each way delivered, both games exit 0 and saves byte for byte unchanged. One chat line first looked unacknowledged, only because the Windows log's time stamps are the time the log was read, up to 2 seconds late.

Pictures

The Linux game (left) and the Windows player's Co-op tab (right) with the Linux player in the room and Direct connections set to Direct (on)
The Linux player's Co-op tab 48 s after the row was set to Off (left), and the Windows player's line arriving over the relay (right)
Chat over the relay while the Linux row was Off: the Windows screen (right) with the Linux player's line and the Linux player's label over the child
Chat after the row was set back to On: the Windows screen (right) with the Linux player's line

What this does not show

  • That the direct path ran over the home network. Both PCs also run a VPN, the games offer every address they have, and the log says only host/host. The Windows PC saw no traffic on the direct ports on its home network interface in the direct phases, so the path most likely ran over the VPN. I could not tell which, so a firewall note for the plain home network case is not covered by these sessions.
  • The "direct" or "relay" word after a player's name on the Co-op tab: it is drawn in the list below the rows, and none of my pictures reached the second player's line.
  • The Windows game's own view of the 1.5 s and 4 s timings: its log lines carry only the time they were read, up to 2 seconds late, so only the order and the rough spacing are shown.
  • A connection across the internet, a router with a different NAT, more than two players, and anything about speed or smoothness.
## Direct connections between a Linux PC and a Windows PC on `coop-playtest-r16` (`5137c513ab14`) This is a functional test of the current head of this pull request on two real machines on one home network: a Linux PC (RTX 4090) and a Windows 11 PC (Intel Arc). Both ran the exact same commit, `5137c513ab1467df42d2ab8688ff25a850fe753c` (version line `v3.0.0-rc.3-246-g5137c513a (source e4be3142)` on both). Each side used a copy of the same small test save and its own identity. It is not a performance or smoothness test. ### What was run Two sessions with both games running and played through the game's remote control interface, "Direct (on)" set in both options files, and the signed terms read and accepted with the real two-press confirmation on both sides (an earlier session with direct connections off is described after the results): 1. **The Windows player hosts the relay in its own game, the Linux player joins.** By design a room whose relay runs on the maker's PC makes no direct pair with the maker. 2. **The relay runs on a third machine at home** (the relay script with the new limits; it answers no STUN, so the games could only offer their own addresses). The Windows player made the room and the Linux player joined. The pair should find a direct path with the relay carrying only its keep-alives; the Linux game was then stopped for 5 seconds; then the Linux game's "Direct connections" row was set to Off in the running game and back to On. ### Results Session 1 (the maker hosts the relay): the Linux game logged `its relay runs on its PC; no direct path is needed` right after the accept; neither game proved a direct path; nothing at all passed on the direct ports (87 five-second counts on the Windows PC); one body each, chat each way delivered and acknowledged; both games exit 0; saves byte for byte unchanged. Session 2 (relay on a third machine, about 12 minutes): | Step | What the games logged | Result | |---|---|---| | Accept | both games: `direct (host/host) in 0.1 s` | direct path proven at once, on both sides | | Relay while direct | the relay's traffic on the Windows PC fell to its 2 second keep-alives (about 0.7 packets a second in, 0.5 to 1 out); the relay process stayed at its idle wake-up rate | game messages went over the direct path | | 5 s stop of the Linux game | the Windows game logged the silent pair, closed it as silent and tried again after its retry wait; the Linux game logged `no direct path (the other player gave up)` and then the new attempt | a new direct path 11 s after the stop ended; no body hidden or made again | | Row set to Off | Linux: `coop_direct=off (from the Co-op tab)`; the Windows game saw the silent pair go suspect, then closed it | both games carried on through the relay: chat each way delivered, no body removed; the relay's traffic rose to about 17 packets a second in and 10 out | | Row set back to On | Linux: `coop_direct=on (from the Co-op tab)`; the Windows game found the path at its next retry, 28 s later | direct again; the relay went back to keep-alives only | | Chat | one line each way in every phase (direct, relay after Off, direct again) | all six delivered and acknowledged | | Both games exit | 0 and 0 | save files byte for byte unchanged | | Errors | no co-op error in either log; 0 retries, 0 events given up, nothing thrown away | none | Short "not answered for 1.5 s ... direct again" episodes also appeared now and then (7 across both games in about 12 minutes, each over within a second or two); nothing was hidden or lost in them. **An earlier session, with direct connections off, not in the table.** The Linux player hosted the relay in its game and the Windows player joined. None of its Windows pictures were taken: the picture request aimed at the wrong one of the two processes the Windows game starts (the second one shows a message after a crash and owns no window). That was shown on the Windows PC with two short title-screen runs, with and without the second process, and the setup was changed; the session itself was not repeated. Its logs and network counts show what direct off should: nothing at all on the direct ports (one flow between the two PCs, on the relay's port), one body each, chat each way delivered, both games exit 0 and saves byte for byte unchanged. One chat line first looked unacknowledged, only because the Windows log's time stamps are the time the log was read, up to 2 seconds late. ### Pictures ![The Linux game (left) and the Windows player's Co-op tab (right) with the Linux player in the room and Direct connections set to Direct (on)](https://git.magicbean.dev/attachments/95547dfb-73be-4ddc-b548-a638a7da67ee) ![The Linux player's Co-op tab 48 s after the row was set to Off (left), and the Windows player's line arriving over the relay (right)](https://git.magicbean.dev/attachments/bd3c1be3-1366-4ee7-9685-e323453aeadf) ![Chat over the relay while the Linux row was Off: the Windows screen (right) with the Linux player's line and the Linux player's label over the child](https://git.magicbean.dev/attachments/7b36ee76-b2f7-4ef5-b87f-c78919de564e) ![Chat after the row was set back to On: the Windows screen (right) with the Linux player's line](https://git.magicbean.dev/attachments/49470943-f239-4f2b-8762-1ef4b68e0e82) ### What this does not show - **That the direct path ran over the home network.** Both PCs also run a VPN, the games offer every address they have, and the log says only `host/host`. The Windows PC saw no traffic on the direct ports on its home network interface in the direct phases, so the path most likely ran over the VPN. I could not tell which, so a firewall note for the plain home network case is not covered by these sessions. - The "direct" or "relay" word after a player's name on the Co-op tab: it is drawn in the list below the rows, and none of my pictures reached the second player's line. - The Windows game's own view of the 1.5 s and 4 s timings: its log lines carry only the time they were read, up to 2 seconds late, so only the order and the rough spacing are shown. - A connection across the internet, a router with a different NAT, more than two players, and anything about speed or smoothness.
Author
Member

Problems found in this head, 5137c513ab1467df42d2ab8688ff25a850fe753c, after the results posted with it were taken. Every fix below is on a later branch that comes with the next round. None of them is in this head, so each problem is still in the head to test.

  • Go to friend never passed its safety check in a game with the debug options off (the normal setting), so it always answered "You cannot be moved safely right now". Fixed on a later branch, and shown working in two real games there.
  • Go to friend from another map put the player at the new map's entrance, because the game's own arrival scene moved Link back after he was placed. Fixed on a later branch, and shown in two real games there (the player landed 1.25 m from the friend, against 195 m).
  • A room made on the Co-op tab did not come back after the relay restarted, and a removal that the relay would ignore was reported as done. Fixed on a later branch, with game-free tests that failed before the fix.
  • The sword-practice kit never finished in a real game: it waited for the game's flag queues to be empty, and the game never empties them. Fixed on a later branch, with a game-free test that failed before the fix; not yet shown in a real game.
  • A healthy direct pair could briefly read as silent (an unsigned time difference wrapped), and after five failed attempts in one session a pair never tried direct again until the room's players changed. Fixed on a later branch, with game-free tests that failed before the fix. The short "not answered for 1.5 s ... direct again" lines in the direct-connection comments are probably the first of these; that has not been checked on two PCs.
  • A temporary copy on Windows could write into the normal save through a hard link: the copy's path check refused a second name of a file on Linux but not on Windows. Someone would have had to make the link by hand. Fixed on a later branch, and shown on a Windows PC with a test program.
  • A game stopped while its oldest save backup was being removed could leave a numbered backup folder with save slots missing, under a name the docs tell players to restore from, and the restore command copied a half-made backup in without a warning. Fixed on a later branch, with game-free tests that failed before the fix.
  • The other player's body froze for a moment on a link with jitter, because it was drawn a fixed 100 ms behind and the next position often arrived later. Fixed on a later branch (the delay follows the link's jitter, between 100 and 250 ms); shown on a replay of a recorded session, not yet in two live games.
Problems found in this head, `5137c513ab1467df42d2ab8688ff25a850fe753c`, after the results posted with it were taken. Every fix below is on a later branch that comes with the next round. None of them is in this head, so each problem is still in the head to test. - Go to friend never passed its safety check in a game with the debug options off (the normal setting), so it always answered "You cannot be moved safely right now". Fixed on a later branch, and shown working in two real games there. - Go to friend from another map put the player at the new map's entrance, because the game's own arrival scene moved Link back after he was placed. Fixed on a later branch, and shown in two real games there (the player landed 1.25 m from the friend, against 195 m). - A room made on the Co-op tab did not come back after the relay restarted, and a removal that the relay would ignore was reported as done. Fixed on a later branch, with game-free tests that failed before the fix. - The sword-practice kit never finished in a real game: it waited for the game's flag queues to be empty, and the game never empties them. Fixed on a later branch, with a game-free test that failed before the fix; not yet shown in a real game. - A healthy direct pair could briefly read as silent (an unsigned time difference wrapped), and after five failed attempts in one session a pair never tried direct again until the room's players changed. Fixed on a later branch, with game-free tests that failed before the fix. The short "not answered for 1.5 s ... direct again" lines in the direct-connection comments are probably the first of these; that has not been checked on two PCs. - A temporary copy on Windows could write into the normal save through a hard link: the copy's path check refused a second name of a file on Linux but not on Windows. Someone would have had to make the link by hand. Fixed on a later branch, and shown on a Windows PC with a test program. - A game stopped while its oldest save backup was being removed could leave a numbered backup folder with save slots missing, under a name the docs tell players to restore from, and the restore command copied a half-made backup in without a warning. Fixed on a later branch, with game-free tests that failed before the fix. - The other player's body froze for a moment on a link with jitter, because it was drawn a fixed 100 ms behind and the next position often arrived later. Fixed on a later branch (the delay follows the link's jitter, between 100 and 250 ms); shown on a replay of a recorded session, not yet in two live games.
A body hidden because the room is not accepted now (a new or not yet identified player, changed rules, a withdrawn acceptance) was logged
as "this game stopped being played: a map change or a load". The closed game, the withdrawn permission and the liveness timeout each
say their own reason now; hide_cause() in the players fixture pins the three.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
tests/coop_soak_test.c, soak_coop.py and soak_relay.py run real sessions against scripts/coop_relay.py or host/coop_relay.c for hundreds of
joins, accepts, messages and leaves, killed and restarted relays, members that end without a goodbye, a full room of eight restarting,
names and direct pairs, counting threads, files, sockets, heap and the relay's tables; tests/test_coop_soak.py is the short version in run_all.
The relay's refusal for too many open rooms was shown as too many joins with a minute to wait; the session now says rooms.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
S4: a relay that restarted closed the Co-op tab's rooms (both sides said "the room is closed" and the players had to Make and
Join again), and a joiner that asked before the maker had made the room again waited 10 s for its next ask. Every session now
gets its room back by itself, whether it came from the tab or from HOS_COOP_AUTO: the game whose own CREATE made the room makes it
again under the same secret, the others ask for it again after 1, 2 and 4 times the first backoff and then every 10 s. A session
that did not start with HOS_COOP_AUTO stops waiting after two minutes ("the room is closed"); one that did goes on. The same
attempt asked again costs the relay none of the network's joins, so a room that is really gone is a few datagrams, not a storm.
Acceptance is untouched: a rejoin is a new session at this layer, and the engine decides, as before, whether it is a new offer.

S5: after the maker's game ended and a new game of the same player made the room again, the relay marks no maker and ignores a KICK
from anyone else, yet coop_sess_remove reported the removal as taken. The session now checks its own roster line (the relay's mark,
not this game's own CREATE) and refuses where it is asked, with the reason in the status for 15 s ("the relay has no maker for this
room, so it cannot remove players; make a new room", or the maker's name).

Tests first (the red runs are in reports/SoakMismatch-files/red-green): tests/test_coop_soak.py restart (both orders, both relays,
tab and automatic, the time back to the room), gone (no storm, a tab session gives up and says so) and nomaker (the removal is
refused with a text, the maker's own removal is taken); tests/coop_session_test.c (a non-maker's removal is refused, with a text).
docs/coop.md: "A relay that restarts", the log lines, the tab's Remove a player, the testing paragraph.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The Co-op tab's session shows no room while it reaches the relay again after a restart (the room's secret is kept), then makes or joins
the same room in new sessions. The engine keeps the acceptance for the same room code, so the same players with the same keys and the same
rules are no new offer, as they are when the session never showed no room.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Run natively on a Windows PC, 11 of the 13 co-op and networking drivers passed and two failed; both failures were in the
test programs, not in the game:

- tests/coop_portmap_test.c talks to its Python driver over a pipe and relied on setvbuf(stdout, NULL, _IOLBF, 0) for
  line buffering. The Windows C runtime treats a line-buffered stream as fully buffered, so no reply ever reached the
  driver and every case waited its 5 seconds and failed (41 errors, 209 s). Each reply is now flushed.
- tests/coop_direct_test.c floods a pair with 3000 frames, 30 at a time with a 5 ms sleep between, and expects the
  member's budget (480 a second, a burst of twice that) to let at most 1500 through. A Windows process that has not raised
  its timer resolution (the game does, the fixture did not) sleeps 15.6 ms for 5, so the flood lasted 1.6 s instead of
  0.5 s and the budget correctly let 1708 through. The flood is now paced by the clock (a long sleep is made up for by
  the next batches) and the bound follows the time the flood really took.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
tests/coop_direct_test.c --cpu checks that the session thread's step is 8 ms (2 ms with a direct pair) and that it is no busy loop, but
it read /proc/self/task/<id>/stat, so on Windows the run ("cpu, a direct pair") passed in 0.0 s having measured nothing.

On Windows it now reads the stepping thread's time with GetThreadTimes, after asking for a 1 ms timer as the game does
(host/hos_main.c: timeBeginPeriod(1)); a process that has not asked gets the system's 15.6 ms and its select() and Sleep() wake no
sooner. COOP_TEST_NO_TIMER_RAISE=1 leaves the request out to see that. The driver links winmm for it. The process's thread and handle
counts of the other leak checks stay Linux-only, with the reason in a comment. Linux behaviour is unchanged.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
tests/test_coop_profile.py proves that a link which leaves the profile is refused, but only with a symbolic link, which the Windows
branch of the test skipped; docs/coop.md says links, junctions, reparse points and multiply-linked files are refused and that
"junction behavior still need[s] Windows execution". On Windows the test now makes a junction (no privilege needed) inside the save
slot and a second name (hard link) of a save file, and requires the copy and the path check to refuse each, and the copy to work
again once they are gone. Linux behaviour is unchanged.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The hard-link case was Windows-only and checked only the copy. It now runs everywhere, and requires the
path check (what the game's writes in a temporary copy are held to) to refuse the file under both of its
names, and the copy to refuse an empty one too, which it never opens to read.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
kind() in host/coop_profile.c refused a link only by its reparse attribute on Windows and never looked at the
link count (Linux's lstat does: st_nlink != 1 is refused). A hard link is no reparse point, so
coop_profile_path_safe() called a second name of a file safe, and so did the copy's inventory; only an
open for reading (io) checked the count afterwards, which a copy never does for an empty file. The path
check is what host_path in nn_fs.c holds the game's writes in a temporary copy to.

kind() now opens the file for attribute access only and requires one link. The profile test has a
hardlinks mutation that removes every link-count check on both systems; it must fail.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A console process that has not asked for a 1 ms timer gets the system's 15.6 ms, and every Sleep and the session
thread's 2 and 8 ms waits last 16 ms. Run natively on Windows without the raise, the "on" runs failed on the
timings they check, in the flood's pace (fixed before) and in the one-way block, where Alice's and Bob's agents were
made again during the 2.7 s block in 2 of 3 runs. The game asks for 1 ms at its start (host/hos_main.c), so the
fixture now does too (the --cpu run did it alone); COOP_TEST_NO_TIMER_RAISE=1 leaves it out to see what that does.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
With 30 % of the relay's datagrams dropped, the late probes of a one-way block (13 or so) are lost with probability 0.3 each, so
"at most half were lost" failed 6 % of the time in each of the run's two one-way checks, on correct code: it failed the "on, 30 % lost"
run on Linux on the commit before the flood bound was touched, and again later on Linux and on Windows. At most three quarters fails
0.07 % of the time and still fails a sender that does not use the relay at all (every probe lost).

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
hos_save_copy removed the copies beyond the newest eight with delete_tree, so a game killed in the middle of that left a
numbered folder with some of its files gone under a name a player is told to pick from (docs/coop.md, going back to your save).
The copy to remove is now renamed .partial-removing-<name> first, and the next copy clears every .partial- folder as before.

tests/test_save_copy_kill.py kills the copy and its pruning at each file-system call (a kill point before and after each, over the
posix layer, one run per point, for a numbered copy and for a first- copy) and checks that every folder not named .partial- is a
whole copy and that the next copy clears what was left. Before the change it failed at 16 of 42 points of a numbered copy.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
docs/coop.md tells a player to go back with python -I scripts/longshot_saves.py import --from <backup folder>. A game closed in
the middle of its backup leaves .partial-<name> in coop-backup, and a copy that lost files has slots without progress.sav; the
script copied such a folder in with Done. and no word that slots were missing. A folder named .partial-... or holding a slot without
progress.sav is now refused before anything is copied, with the folders to pick from named.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A game closed in the middle of its backup leaves a .partial-<name> folder in coop-backup that the next copy removes; every start of
the game makes its own first- copy, so only the oldest holds the save from before the room once the game took values and saved in
between; and the restore script refuses a copy that is not whole and takes --longshot for a user folder that is not the default one.
Checked live (a game killed at the start of its backup, then started again) and on Windows (the restore by hand and with the script).

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
coop_portmap_new_direct(port) is the same mapper (PCP, then NAT-PMP, one 300-second UDP lease,
renewed halfway, deleted with the creation's nonce and port) for the one port libjuice binds,
stepped by the session's thread instead of the relay's. Its lines say "direct paths:", never
advise manual forwarding (the relay carries the game) and never carry an address: the status
and the log name the router's returned port and the lease only; a private, shared or non-public
answer is logged and not offered. coop_portmap_external gives the held public lease's address
and port to the caller that offers it to the members it accepted; coop_portmap_release asks
removal and returns, coop_portmap_step reads the answer until it matches or 100 ms have passed,
and coop_portmap_done says so, so a thread that carries a game's messages is never held for a
gateway that does not answer. The relay's own lines, statuses and blocking finish are unchanged
byte for byte (the existing 14 tests pass unchanged); a mapper freed without either closes its
socket.

tests/test_coop_portmap.py (tests/coop_portmap_test.c's new "ice" mode): PCP and NAT-PMP with the
returned address offered and written down nowhere, private answers not offered, refusals and a
timeout worded for the direct paths, a release that costs the thread under 60 ms with a silent
gateway and is over at the 100 ms mark, one confirmed by the gateway, one of an unanswered
creation, an expired lease withdrawn, and the switch off making no mapper.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A game with coop_direct probe or on and a pair being looked for has one ICE socket (libjuice's
MUX mode: every agent of the game shares it), on a port libjuice picks from the ten of
coop_direct_port, so a friend's router cannot be told in advance what to forward. With the switch
the relay's mapping already has (coop_portmap=1 or HOS_COOP_PORTMAP=1, off by default) the session
now asks the router (PCP, then NAT-PMP, 300 s, renewed halfway, the same mapper) for that port:
once the first agent has told its port (the path layer takes it from the first host candidate,
before any filter), kept while any agent is open, asked removed with the last and again for
the port the next agents bind. A public answer reaches the other player as one more
server-reflexive candidate in the PATH message (libjuice has no call for a local candidate and
needs none: the other side's agent takes it as a remote one), once even when the STUN server says
the same address, in place of the last host candidate when the list of eight is full, and taken
back when the mapping goes. A private, shared or non-public answer is logged and not offered; a
refusal or no answer leaves the pair to the relay. No line has an address: the lines say
"direct paths:" and the router's returned port.

Never both mappings in one game: a maker that hosts the relay opens no agent and maps the relay's
port only (the session also refuses to start one beside a hosted relay). The removal does not hold
the session's thread, which carries the game's messages: coop_portmap_release and the step of the
session, with the coop thread kept alive for its 100 ms when co-op is switched off; the end of a
session waits for it as the relay's stop does.

host/coop_path.c/.h: coop_paths_local_port and coop_paths_offer (CoopPathOps gains both); host/coop.c:
the mapping beside paths_sync; docs/coop.md (Ports, the log table, the settings row, tests) and
docs/development.md.

Tests: tests/test_coop_portmap_ice.py with tests/coop_direct_test.c --portmap and the gateway of
tests/test_coop_portmap.py on loopback (11 runs: the fake backend with coop_direct probe, on and
under ThreadSanitizer, a NAT-PMP gateway, a refusing one, the switch unset or 0 or coop_direct off,
a hosting maker, the game's own session switched off, libjuice with three players and its one
socket for each); tests/coop_path_test.c section 10 for the port and the offer; tests/coop_ice_fake.c
never sends to an address that is not loopback (an offered mapped address is counted) and reports
each agent's port and the remote candidates it was given. Mutations of the production code
(no removal, no offer, no port reset, the thread ending early, ...) each fail them.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Eight harnesses (tests/fuzz/), each driving the real source from bytes under AddressSanitizer and UBSan, with a fake clock,
sockets and ICE library so that a run depends on its input alone: the codec (coop_proto.c), the session's receive checks with a
fixed room key between two real sessions and a fake relay (coop.c), the reliable events against a model of what they promise,
the engine's DIGEST and SECTION decoding and signature checks (coop_state.c, its signature check redirected so a fuzzer can
pass it), the path layer (coop_path.c), the in-game relay and its STUN answers (coop_relay.c), the checkpoint transfer's
decoders (coop_save.c) and chat. Seeds come from tests/coop_vectors.txt and by hand (tests/fuzz/make_seeds.py).

tests/test_coop_fuzz.py builds them with clang's libFuzzer, replays each corpus and mutates for a few seconds (skipped without
libFuzzer); --driver uses a deterministic coverage-guided mutation loop instead, --campaign runs them long in parallel.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
coop_text_clean refused an input of cap bytes or more before it wrote the output's first byte, so a caller that read the buffer
after a refusal read what it held before (found by the chat fuzz harness). Every refusal now leaves "". The test has the red run:
without the change "!out[0]" fails after the oversized refusal.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The session asks the router to map the direct paths' port (coop_portmap_new_direct, coop_portmap_step, ...). The session and events harnesses
compile host/coop.c and stub the in-game relay, which was the only thing that had linked host/coop_portmap.c for them, so with the mapping in
the session they no longer linked. They link coop_portmap.c as the relay harness does; with coop_portmap off, as in every harness, it allocates
nothing and opens nothing.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
.gitignore's *.bin kept tests/fuzz/corpus out of the commit that added the harnesses, so a clean checkout had no seeds and
tests/test_coop_fuzz.py failed at `make_seeds.py --check` ("seeds that differ from what make_seeds.py writes"); it passed only in the worktree
that had made them. The 136 files are what `python -I -B tests/fuzz/make_seeds.py` writes (made-up protocol messages, not the game; 11 KB in
all), and the folder has an exception in .gitignore so that an input that once crashed a harness, kept there by hand, is not lost the same way.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Three more bytes close the pose message: tunic (Kokiri, Goron, Zora), boots (iron, hover) and child mask, as numbers that a
build which does not know one draws nothing for. Versions 3 and 4 refuse each other. The independent Python codec and the byte
vectors were changed first (the C codec failed all 95 vectors, kept in the report's red run); the version test now freezes the
v2 and v3 parsers against the v4 one.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The sender reads PlayerStatus.EquipArmor, EquipBoot and EquipHeadArmor from the game data (the same String64 read as the map),
maps the pouch names to the wire numbers, fits them to the age and sends them only under the equipment permission. The receiver
does not draw them yet: the native equipment kind of a tunic, boots or mask is not in the game's code, so HOS_COOP_EQUIP_PROBE=1
(with HOS_COOP_TRACE=1) logs what an equipment user holds per kind and hand slot, to settle it in a run.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The receiver asks the body's equipment user for the piece of the pose's tunic (kind 8, ArmorUpper), boots (9, ArmorLower)
and child mask (7, ArmorHead), the kinds read from the game's own kind-name table. A piece that changes or goes is removed
through the game's armour-link removal first (the Kokiri tunic is the body's own: no piece); only the adapter's own pieces are
ever removed; each part is fitted to the age and within the equipment permission; a request is retried no sooner than the
backoff. HOS_COOP_PLAYERS_OUTFIT=0 draws none (a diagnostic). The equipment probe now lists all 13 armour links.

Tests first: the players fixture on synthetic memory (a compile failure before the receiver existed), six mutations that each
make it fail.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A piece asked for and never seen worn is asked for at most four times; a different piece wanted, a removal or a new body starts
afresh. A new body no longer keeps the old body's note of what was asked.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
hos_oot_coop_warp_local took `!rx_option(HOS_OPT_CHEAT_FLIGHT, 0)` for "not flying", but the menu's flight option reads -1 while the
debug tools are off (menu_player_flight), which is every ordinary game: `safe` was always false and every ask ended "You cannot be
moved safely right now." (seen in a real two-game session: no ask, in any map, before or after the bodies were shown, got further).
Only a positive value is flight, as the cheat code itself reads it.

Tests first: the real function on the fixture's fake with the option at -1 (the fixture aborted before the fix).

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
In a game the child's mask (kind 7) is the piece in armour link 0 (the player's own probe: link 0 Armor_Child_Mask_Bunny; the body's: link 0 Armor_Child_Mask_Keaton, live), not in links 5 or 6 as the game's slot table read from the image suggested. The receiver looked in the wrong links, never saw the live mask worn, asked four times and gave up. The mask is now found and removed in link 0; the fixture's fake follows what the game did.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Across maps the placement was submitted the moment the new map was current. In
every observed change the game then plays its arrival event 0.14 to 0.6 s later,
which puts Link back at the entrance (about 190 m from the friend in Hyrule Field)
and runs about 0.6 s, so the journey ended with "The game did not keep the arrival
position". The journey now waits for that event to start (up to 4 s, for a map that
has none) and end, then 0.75 s of quiet, before it asks for a fresh position and
places Link; a second load restarts the wait. A placement the game undoes is
repeated from a fresh position, at most three in all.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Only a load or another map forgets that the new map was current; a play clock that
is stopped for a moment (the game's own playing flag) holds the wait and the
placement, so the bound on an arrival event that never starts is not stretched.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
In the first real game run of the kit's native path (HOS_COOP_PVP_TRACE, two games, a temporary copy) the game-data manager's rings
read, for 90 seconds on both sides: Bool 0 of 1024 pending, Int 2 of 512, String64 3 of 96, the same two numbers in every sample. The
kit's gate required every ring to be empty, so it never opened and both items were refused after 300 updates ("native setup did
not complete"), which is what every earlier real run showed. The gate now requires 16 free slots in each of the three rings (the
room the kit's own sets need) and a pending count that does not exceed the capacity; an uncertain give is still never repeated and
the ownership readback still waits for the give.

Test first (PvpNative-files/red-run-kitfix-1.txt): a constant residue of 2 and 3 pending lets both items be given and worn; 8 free
slots of 128 or more pending than the capacity still block. Not proven in a game: that the game applies the kit's queued sets while
those two rings keep their residue.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The session reads its own clock again for each datagram of a pair that it takes (path_deliver), and takes them while the path layer drains its
queue, inside a step whose `now` was read before. An ECHO taken in that step therefore has a last_echo a millisecond or more later than the
step's now, and step_pair's unsigned `now - last_echo` wraps: the pair that has just been answered goes suspect (the log says "has not
answered over the direct path for 1.5 s", which is the limit and not what was measured) until the member's next datagram brings it back. In on
mode that makes messages go both routes for up to a probe interval. since() gives 0 for a time that is later than now; heard() and
flap_say() use it too.

tests/coop_path_test.c: the host's deliver hands an ECHO to coop_paths_message with a clock 1 ms after the step's, as path_deliver does, for 30
steps of a pair that is answered every time. Red on the old coop_path.c (the pair is suspect in the first step), green with the change.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
It failed 3 of 10 solo runs on r17-pre, each a different sub-run (Integrate17 4.4):
* fake, 30 % lost: "at least 20 of 40" is P(Binomial(40, 0.7) <= 19) = 0.24 % a count, four counts a run. Every count of messages that the
  relay's loss leaves is now binom_at_least(n, p, parts): the largest m with P(X < m) <= 1e-6 / parts (formula in the code, checked against exact
  arithmetic by check_bounds); the one-way check sends bursts so that it has about 50 late probes, the withdrawn-consent check 20 messages.
* on, 30 % lost: the fixture's relay silence time of 1.5 s with a PONG every 200 ms is seven thrown-away PONGs in a row, 0.3^7 per datagram, about
  one run in seven: "relay lost; rejoining", a new session nobody accepted, 398 s of waits. The runs with loss take the silence time that makes
  it at most 1e-9 a run (5.4 s); the product's rule is right and unchanged.
* fake, ThreadSanitizer, "and it still works" / "and changes nothing else": the product's unsigned `now - last_echo` (previous commit); the
  checks now wait (bounded) for the pair and require that it was not lost or made again; the flood is bounded by the clock (300 ms).
The driver starts at most cores / 4 runs at once (--jobs, COOP_DIRECT_JOBS), the longest first, and looks for the ports of a "real" run when
it starts.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
fail() counted failures for the life of the pair and gave up for good at MAX_FAILURES (5): the next attempt waits 10, 30, 60, 120 and 120 s, then
none until the roster changes. So a long session with five separate blips of the network, each followed by a healthy direct path, lost the
direct path for good, and a test that fails a pair on purpose in several places could end it by one more failure from a slow machine.

A pair that has been direct and not suspect for healthy_ms (CoopPathParams, default D_HEALTHY = 60 s: the longest wait of the schedule is 120 s
and the flap log's window is 60 s) now has its failures set back to 0 (log line "direct for 60 s: the failed attempts before are forgotten");
direct_at is the time since which it has been direct and not suspect (heard() sets it when a suspect pair is direct again). Five failures in a row
(each before the pair has been healthy for that long) still stop the attempts until the roster changes.

tests/coop_path_test.c: eight failures over a session, each after 2.3 s of a healthy pair with healthy_ms 2 s, all retry and the count never passes
1 (red on the previous coop_path.c: retried 4, the count reaches 5); five failures in a row stop, no sixth attempt in 30 s; a new session of the
member starts again. docs/coop.md has the rule.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A fourth way for tests/test_coop_direct.py to fail by chance (1 of 16 `fake, 30 %` runs under load): `the setting on again, the pair comes back (Alice 0,
Bob 4)`. The run fails Bob's pair on purpose in three places (the blocked wire, withdrawn consent, the setting off); one more failure, from a slow
machine or a lost HELLO, reached MAX_FAILURES and the product does not try again until the roster changes. The fake run now takes healthy_ms 2 s
(a minute by default) and waits, between the three places, for the failures to be forgotten.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
coop-travel-fidelity changed tests/coop_vectors.txt (a POS is version 4 and carries the tunic, boots and mask: a new version byte in
all of the changed vectors, three bytes more in 21 of them), and the proto harness's seeds are made from that file, so git saw no
conflict and tests/fuzz/make_seeds.py --check failed on 31 files: 24 seeds whose vector changed and 7 that the branch's vectors add
(pos goron-iron, zora-hover, child-mask, unknown-outfit; reject pos version-3, version-3-length, cut-outfit). The seeds are rewritten
by running make_seeds.py; nothing else of the corpus changed and no seed was removed.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The note still said "Nothing in the runtime links it yet". Since the path layer's direct connections it is linked: nx2/build.py compiles
libjuice into the game, and host/coop_ice_juice.c, the ICE backend that hos_main.c hands to the path layer with coop_set_direct, is the
one host file that includes its header. The library runs only with coop_direct probe or on. No file of the part changed, so its tree
hash is the same (scripts/check_third_party.py: 13 parts as their notes say).

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The overnight campaign's two invariant aborts, minimised (the campaign's crash inputs were 725 and 23 bytes):

- session/crash-sender-session-after-rejoin-1.bin (51 bytes): a forged ROSTER lists another session for A, A joins the room again
  under a new session (docs/coop.md: a session is drawn for every join), and its next DATA datagram names that session. The harness
  compares it to the session A had when the fixture was made.
- state/crash-flag-forgotten-with-room-1.bin (8 bytes): the game of L reports a flag in the room "FUZZ02", and the room becomes
  "FUZZ01". coop_sync_room drops everything merged when the code changes (documented), the harness forgot its record of the merged
  flags only on the way to "FUZZ02".

Both abort the harnesses as they are; the next commit corrects what they check.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Both aborts of the first campaign were the harnesses' invariants, not the product (the two inputs are the previous commit's seeds):

- fuzz_session/fuzz_events: "DATA names the sender's session" compared against the session each node had when the fixture was
  made. Every join draws a new session (docs/coop.md, "The room's secret and the wire"; begin_episode), and the session joins again
  whenever the relay lists another one for it, so after a rejoin it seals, correctly, under the new one. The fixture now takes a
  node's session from the CONNECT it sends (what the relay knows it by), lists those sessions in its heartbeat as a relay does,
  and the invariant is unchanged: DATA and PATH messages name that session. Forged event parts for "the recipient's session"
  now use the current one too.
- fuzz_state: "a merged flag never goes down while the room stays" forgot its record only on the way to room 1, not on the way
  back to room 0; coop_sync_room drops everything merged whenever the room's code changes, in either direction (documented in
  coop_state.h, tested by coop_sync_test's check_carry_over). The record is now forgotten when the code is another, and not when
  the same room is announced again.

Both invariants still fire: a CONNECT whose session differs from the one its sender seals under, and a flag lost while the same
room is announced again, were each tried as a mutation of the product and aborted the harness.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The second campaign's only new failure: AddressSanitizer reports a stack-buffer-overflow in fuzz_state.c's build_section, not in the
engine. The input asks for eleven pool records (122 bytes each): 1,420 bytes into a buffer of COOP_MAX_MESSAGE + 64 = 1,210.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
fuzz_state.c's build_section wrote up to eleven records of up to 122 bytes into a buffer of COOP_MAX_MESSAGE + 64 bytes: 1,420 bytes
for eleven pool records, which AddressSanitizer reported as a stack-buffer-overflow in the harness (not in coop_state.c: on_section
refuses n > COOP_MAX_MESSAGE before it reads a byte, and the engine's own sections stop at that size). The builder now stops adding
records when the next one and the section's tail would not fit COOP_MAX_MESSAGE, says the number it made (or one more, as before),
and checks its own size. Eight pool records are the most that fit, so a section of eight or fewer pool records (and any eleven
flags) is built as it was. The digest builder's largest message is 562 bytes, within the buffer.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The second campaign (the harnesses of the previous commits) aborted two harnesses again, minimised here:

- session/crash-counter-after-rejoin-1.bin (38 bytes): "counters rise (1 after 5)". A rejoin draws a new session and its counter starts at 1
  again (begin_episode; docs/coop.md: "A session is drawn for every join and the counter starts at 1"); the fixture kept one record of
  counters for the whole life of a node.
- state/crash-local-flag-over-limit-1.bin (21 bytes): "the game was handed 4 for a flag with limit 1". The harness's own game reports
  4 for a flag the table limits to 1 (coop_sync_local), then 0, and the engine hands back the 4 it merged from that report.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The two seeds of the previous commit, and what they showed:

- fuzz_sess.h kept one record of the counters a node sent for its whole life. A counter rises within a session and starts at 1 again
  with the next one (docs/coop.md: "A session is drawn for every join and the counter starts at 1"; begin_episode sets out_counter 0
  with the new session), so the record starts again when a CONNECT names another session. A counter that repeats or falls within a
  session is still caught (tried as a mutation of seal_to).
- fuzz_state.c's op_local gave L's own game values of 0 to 5 for any flag, a Bool included, against what coop_sync_local says it takes
  (1 for a flag, a count for an item) and what coop_sync_limits says is the most the game can show; the engine then handed the game
  its own 4 back once it had lowered the flag to 0, which is what the merge does with a flag the game reported. The game under test
  now reports within the table's limit (values over it wrap), while R's game, another member's, keeps reporting any value: what
  such a member sends over the limit is for the engine's checks of what it receives.

Clamping L's game took away the only way the fuzzer had found of making the engine hand the game a value over its limit, so the
requirement is now reached by seed: the two new seeds (made by make_seeds.py) run the whole exchange with real signatures in a room
of two, R's game reports item 1 as 1 (crosses, handed) and as 5 (over the limit of 4: refused, stats.rejected), and an engine whose
limit check was changed to allow eight times as much (tried as a mutation of coop_state.c) aborts on the second with "the game was
handed 5 for a flag with limit 4". The existing seeds accepted-section and digest-fields never get further than a refused charter
("Unsupported room rules": their charter's category count is one short); they are left as they are.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
tests/test_coop_profile.py now asks coop_profile_note() (what the Co-op tab shows under the room status) after a copy that is refused and
requires a line that starts "Copy refused: ", names the reason and fits the tab's line (72 characters): a link or junction in the save, a
file with two names, 16 kept copies (15 still copy), a save that with its two copies would pass the 64 MiB the kept copies may use, a single
file over 64 MiB, more than 4096 files, a coop-sessions that is not a folder. A refused copy tells the player nothing today: prepare_copy
returns 0 before it sets its note, so after the two presses the tab shows no line at all. The fixture has a "note" action; --mutation notes
removes the one line that writes the refusal.

Red on the base (32c5c28f0): AssertionError: ('note-link', 0, '', ('link', 'junction')).

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
prepare_copy (host/coop_profile.c) returned 0 without touching its note when the save tree held a link or junction, a file with two names,
more than 4096 files or more than 64 MiB, when 16 copies were already kept, or when coop-sessions could not be used, so the Co-op tab
showed nothing after the two presses: nothing said whether the press had not registered or the copy had been refused. The inventory now
keeps the first reason it found (Inventory.why), quota() returns its reason instead of a flag, and refuse() writes "Copy refused: <reason>."
into the note the tab already shows. The note is one line that the tab cuts at about 73 characters (the Windows game's Co-op tab, window
capture of "Temporary copy active. Your normal saves are untouched; no progress is re..."), so each reason is short and comes first. A save
folder that does not exist yet says so. Copy failures after the copy has started keep their existing note. The transfer staging path
(stage_copy) only changes to the new return convention of quota().

docs/coop.md says a refusal is shown and which refusals there are (the 64 MiB counts the copies already kept). tests/test_coop_profile.py
(previous commit) is green with it on gcc and clang; its --mutation notes, links, hardlinks, ticket and mount runs still fail as they must.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The join/leave soak (SoakJudge, 15 November) found the leaver's log saying the other
player's body was hidden because 'this game stopped being played: a map change or a
load' after its own Leave on the Co-op tab. hide_cause() now has a fourth cause, the
player leaving the room, and says what must not be said for it. It fails on the code as
it is.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Leaving the room on the Co-op tab closes the game's presence, so the hide cause fell to
the first branch of update(): 'this game stopped being played: a map change or a load',
in the leaver's log, for a Link standing still in one map. The players layer now keeps
whether the session's view has this player in a room (joined, or joining it again) and
says 'this game is not in a room (it left the room, or co-op is off)' when it is not.
A map change or a load in a room, a withdrawn permission and an expired grace keep
their texts.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Red on purpose: the trace module and its adapter wiring come in the next commit.

tests/test_coop_pose_trace.py reads the writer's files back with an independent reader (every record kind
field by field, the 48 MiB bound and its closing records, an unwritable path, more names than the table holds, a
file cut at every byte). tests/oot_coop_players_test.c checks the adapter on its fake guest memory: unset, nothing
is armed or made; set with co-op off or no save played, still no file and no guest read; in play each update of
Link, each pose sent, each message received (the refused ones too) and each body placed is written exactly as the
game saw it, held updates as held. Three mutations of the adapter must fail the fixture.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A test switch, off by default (one flag test, nothing else): per update of Link in play it writes this game's Link, each
position message sent and received (refused ones too) and, for every shown body, the place it was drawn at with the two
received poses that place was interpolated between, the time shown, the clock offset the receiver tracked and where the
actor stood before the placement. The file is made at the first update in play with co-op on (never with co-op off or at the
title screen), is bounded to 48 MiB with closing records, and says once in the log when it cannot be written.

coop_players_show_info reports which poses a place was worked out from; coop_players_show is unchanged for its callers.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Hashes every game call, every placed matrix and what was sent over 90 updates (a refused message and an update the
co-op thread held included) with HOS_COOP_POSE_TRACE unset and set: equal, and the set run's file has one LOCAL per
update and one DRAWN per placement.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Red on purpose: the delay that follows the jitter and the short carrying on come in the next commit.

tests/coop_players_link_test.c runs host/coop_players.c on made-up links: a body walking at 6 m/s, 15 poses a second, delivered with a
delay, uniform jitter (so they overtake each other and an overtaken one is refused) and loss. A home Wi-Fi (80 ms +- 40, 2 percent lost)
must leave no frame standing still, and a bad link (150 ms +- 80, 5 percent) must keep the body on the sender's path with a delay of
100 to 250 ms that never jumps (300 ms a second up, 20 down) and comes back; a clean link keeps the 100 ms and the first version's place;
one sender hitch does not move it; a new session, a silence or a change of age starts it anew; stamps that make no sense stay in bounds.
The carrying on past the newest pose is checked for its length, its map and age and the distance between the two poses it comes from.
tests/test_coop_players_link.py compiles it with the code under test, replays 40 random streams (jitter, loss, overtaking, hitches,
silences, map and age changes, a sender whose clock jumps) through the real code and through an independent model of the rule written
from the rule alone, and compares every message taken and every placement; thirteen mutations of the rule must each fail it.
tests/oot_coop_players_test.c: three expectations that held a body at its newest pose now say where it is carried on to.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
A body was drawn a fixed 100 ms behind its player. On a link with jitter the next pose often came in after the time shown, and the
body stood still until it did, and then jumped.

Measured two ways, which agree. The recorded session of two games on a clean link, replayed through a model of a link (delay, uniform
jitter, independent loss, an overtaken pose refused as the game refuses an older counter), left the body standing at the newest pose in
16 percent of the moving frames on an 80 ms +- 40 ms link with 2 percent loss (3 snaps of over 0.3 m per run) and in 50 percent on a
150 ms +- 80 ms link with 5 percent loss (34 snaps). A live session of two games on the previous version, with the link set to those two
conditions, confirmed it: 15 to 16 percent of the frames of a walking player held on the first link (2 to 5 snaps), 49 to 51 percent on
the second (41 to 45 snaps).

Two changes, in host/coop_players.c, both inside the receiver:

- the delay follows what the arrivals ask for. After each pose the receiver notes how old the newest one got just before it came in
  (the gap between their stamps plus how much later it arrived than the earliest of the last ones) and keeps the third largest of the last
  32. The delay moves toward that less 30 ms, between 100 and 250 ms, at most 300 ms a second up and 20 down, so the body never jumps or
  visibly changes speed. A clean link keeps 100 ms and the first version's place to the bit; a new session, a silence of three
  seconds or a change of age starts it anew.
- when the time shown is past the newest pose anyway, the body carries on at the speed of its last two for at most 100 ms and holds
  there: only in one map and age, only from two poses at most 200 ms apart. The pose trace says so (place kind 4).

coop_players_show_info also reports the delay (behind_ms). docs/coop.md says what a link with jitter and loss does.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
The Windows-target syntax check of the link fixture failed under -Werror: the CRT marks memcpy, memmove, fopen and sscanf deprecated unless
_CRT_SECURE_NO_WARNINGS is defined, which the sibling fixtures do (in the source and on the compile line). The fixture now does the same.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
test(coop): the outfit receiver's steps wait for the piece, not a fixed 232 ms
All checks were successful
PR description / Description follows the template (pull_request_target) Successful in 10s
Website / Website on Cloudflare (pull_request_target) Has been skipped
2574634645
A body's outfit follows the pose drawn, which is the display delay behind the newest one: 100 ms for a clean link, up to 250 ms for one that
delivers sparsely, as the jitter-following rule says. The receiver test's poses come 200 ms and 2 s apart, so the delay rises to the most, and the
"a different piece wanted starts afresh" step (frame(200), frame(16), frame(16) = 232 ms) ended before the piece was live: red on the head that
has both travel-fidelity's test and the pose trace's rule.

Each step now waits, a frame at a time and for a bounded time (the longest delay and the frames a removal and the asking take), for the call it
expects; a step that expects nothing waits that long and two frames more. The test holds for any delay from 100 to 250 ms.

Assisted-by: Claude Sonnet 5.5
Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Author
Member

The eight problems listed for the last head, 5137c513ab1467df42d2ab8688ff25a850fe753c, in #355 (comment) are all fixed in the new head, 2574634645ea0d7380171dd53c7ca6e410a9f7d8. Each line says which commit holds the fix and how it was shown. The game-free suite passes the tests for all of them on this head (603 passed, the same 12 failed as on main, 16 skipped). The game runs of this round were done on a build of 607c6384da2f7408414b2761da9ece16e3c4f653, which has the same game source as the new head; where a line says "in a game on a branch", that was a build of the branch that made the fix, before it was merged here.

  • Go to friend never passed its safety check in a game with the debug options off. Fixed in f0a08cf53a90bd1403267cbbf2b26ef557cd4544. Shown in two real games on the branch: every ask got past the safety check.
  • Go to friend from another map left the player at the new map's entrance. Fixed in ba74cae2749a20bc65ecf8a81fe03d6a9244a842 and 12697da22edbb45dbe282b41b64516cfbef51846. Shown in four real games on the branch: the player landed 1.21 to 1.25 m from the friend, where the game's own arrival had left him 74 to 195 m away (Hyrule Field and Kokiri Forest, adult and child).
  • A room made on the Co-op tab did not come back after a relay restart, and a removal the relay would ignore was reported as done. Fixed in 181784a4569f7f1c361c3abd7af494e28336f8cc. Shown by game-free tests that failed on the old code (the room never came back) and pass now (back 1.5 to 1.9 seconds after the relay returns, at the tests' timings); not tried in a real game with the fix.
  • The sword-practice kit never finished in a real game. Fixed in 6914b1756ca51eb96d3f57effa17204456c8a196: it now waits for 16 free places in each of the game's three flag queues instead of empty queues, which the game never has. Shown by a game-free test that failed before (10 changes to the code that the test catches); still not shown in a real game.
  • A healthy direct pair could briefly read as silent, and after five failed attempts a pair never tried direct again. Fixed in 9f3853fe36c07c89b164fa5452c94be26391a829 (the wrapped time difference) and 4a5a83636fc307c74c676da2e6f4f768247df42b (a pair that has been direct for a minute forgets its failed attempts). Shown by game-free tests that failed on the old code, and in games on this build: probe mode had no flap in 265 seconds (the last head had one at 200 seconds), and two 12.5 minute sessions between a Linux PC and a Windows laptop had none of the short "not answered for 1.5 s ... direct again" lines (the last head's session had 7 in 12 minutes). Two sessions do not show that the wrap was the only cause of those lines.
  • A temporary copy on Windows could write into the normal save through a hard link. Fixed in 603d1510e55a6f78b03863f193c678c4f4a6ddc4. Shown on a Windows PC with a test program: before the fix a write through a second name of a file changed the other file, after it the path is refused. Not shown in a Windows game on this head.
  • A game stopped while its oldest save backup was being removed could leave a numbered backup folder with slots missing, and the restore command took a half-made backup without a warning. Fixed in 9b5444719ec7b294bd02b258c1c84157448e04fc and 3ce7f325d4e9542f34860be17fcb25676bcab29f. Shown by game-free kill tests: a save copy killed at each of 92 points and at 480 random moments left no half-made copy under a numbered name (the last head left one at 40 of 90 points and 22 of 480 kills), and the restore command refuses a half-made copy. No real game was killed with the fix in it.
  • The other player's body froze for a moment on a link with jitter. Fixed in 9907fdb95444026a6583dad3c284de09c7f05ab6: the display delay follows the link's jitter between 100 and 250 ms. Shown in two live games through a link simulator on the branch: the share of moving frames in which the body stood still fell from 15.4 to 0.1 percent on a Wi-Fi-like link and from 50.1 to 0.1 percent on a bad one, and on a clean link the delay stayed at 100 ms. On the bad link the body is drawn later (its median moved from 186 to 268 ms behind the real moment) and 4 and 1 one-frame jumps remained. Not shown on a real network.
The eight problems listed for the last head, `5137c513ab1467df42d2ab8688ff25a850fe753c`, in https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-24104 are all fixed in the new head, `2574634645ea0d7380171dd53c7ca6e410a9f7d8`. Each line says which commit holds the fix and how it was shown. The game-free suite passes the tests for all of them on this head (603 passed, the same 12 failed as on main, 16 skipped). The game runs of this round were done on a build of `607c6384da2f7408414b2761da9ece16e3c4f653`, which has the same game source as the new head; where a line says "in a game on a branch", that was a build of the branch that made the fix, before it was merged here. - Go to friend never passed its safety check in a game with the debug options off. Fixed in `f0a08cf53a90bd1403267cbbf2b26ef557cd4544`. Shown in two real games on the branch: every ask got past the safety check. - Go to friend from another map left the player at the new map's entrance. Fixed in `ba74cae2749a20bc65ecf8a81fe03d6a9244a842` and `12697da22edbb45dbe282b41b64516cfbef51846`. Shown in four real games on the branch: the player landed 1.21 to 1.25 m from the friend, where the game's own arrival had left him 74 to 195 m away (Hyrule Field and Kokiri Forest, adult and child). - A room made on the Co-op tab did not come back after a relay restart, and a removal the relay would ignore was reported as done. Fixed in `181784a4569f7f1c361c3abd7af494e28336f8cc`. Shown by game-free tests that failed on the old code (the room never came back) and pass now (back 1.5 to 1.9 seconds after the relay returns, at the tests' timings); not tried in a real game with the fix. - The sword-practice kit never finished in a real game. Fixed in `6914b1756ca51eb96d3f57effa17204456c8a196`: it now waits for 16 free places in each of the game's three flag queues instead of empty queues, which the game never has. Shown by a game-free test that failed before (10 changes to the code that the test catches); still not shown in a real game. - A healthy direct pair could briefly read as silent, and after five failed attempts a pair never tried direct again. Fixed in `9f3853fe36c07c89b164fa5452c94be26391a829` (the wrapped time difference) and `4a5a83636fc307c74c676da2e6f4f768247df42b` (a pair that has been direct for a minute forgets its failed attempts). Shown by game-free tests that failed on the old code, and in games on this build: probe mode had no flap in 265 seconds (the last head had one at 200 seconds), and two 12.5 minute sessions between a Linux PC and a Windows laptop had none of the short "not answered for 1.5 s ... direct again" lines (the last head's session had 7 in 12 minutes). Two sessions do not show that the wrap was the only cause of those lines. - A temporary copy on Windows could write into the normal save through a hard link. Fixed in `603d1510e55a6f78b03863f193c678c4f4a6ddc4`. Shown on a Windows PC with a test program: before the fix a write through a second name of a file changed the other file, after it the path is refused. Not shown in a Windows game on this head. - A game stopped while its oldest save backup was being removed could leave a numbered backup folder with slots missing, and the restore command took a half-made backup without a warning. Fixed in `9b5444719ec7b294bd02b258c1c84157448e04fc` and `3ce7f325d4e9542f34860be17fcb25676bcab29f`. Shown by game-free kill tests: a save copy killed at each of 92 points and at 480 random moments left no half-made copy under a numbered name (the last head left one at 40 of 90 points and 22 of 480 kills), and the restore command refuses a half-made copy. No real game was killed with the fix in it. - The other player's body froze for a moment on a link with jitter. Fixed in `9907fdb95444026a6583dad3c284de09c7f05ab6`: the display delay follows the link's jitter between 100 and 250 ms. Shown in two live games through a link simulator on the branch: the share of moving frames in which the body stood still fell from 15.4 to 0.1 percent on a Wi-Fi-like link and from 50.1 to 0.1 percent on a bad one, and on a clean link the delay stayed at 100 ms. On the bad link the body is drawn later (its median moved from 186 to 268 ms behind the real moment) and 4 and 1 one-frame jumps remained. Not shown on a real network.
Author
Member

These are the results for the new head of this pull request, 2574634645ea0d7380171dd53c7ca6e410a9f7d8 (local branch name coop-playtest-r17-rc1). Every game run below was done on a build of the commit just before it, 607c6384da2f7408414b2761da9ece16e3c4f653 (game version v3.0.0-rc.3-300-g607c6384d). The only difference between the two commits is one commit that changes one test file (tests/oot_coop_players_test.c), and both have the same source fingerprint (5d118e2e), so the game built from either is the same game; no build of the new head itself was run. The new head sits on the last pushed head of this pull request, 5137c513ab1467df42d2ab8688ff25a850fe753c (r16), with 55 commits on top: the outfit of the other player's body (tunic, boots and mask), fixes to Go to friend, the sword practice kit, direct connections, save backups and a room made on the Co-op tab after a relay restart, router port mapping for the direct paths, corrected texts for why a body is hidden, fuzz and soak tests, an opt-in trace of the poses, and a display delay that follows the jitter of a link. Nothing here is carried over from an earlier head. "The earlier head" below is r16, the head the same six proofs ran on last time.

The game-free suite on the new head gave 603 passed, 12 failed (the same 12 as main) and 16 skipped. On the commit before it the suite gave 602 passed, 13 failed and 16 skipped: the same 12 plus the co-op test that checks how a received outfit is drawn, which failed at one check. The cause is in the test: a step waited a fixed 232 ms while the body's display delay can reach 250 ms. The head's one test-only commit makes the step wait for the piece, and the test passes with both compilers. This comment gives the results of six two-game proofs, three direct-connection runs and two sessions between a Linux PC and a Windows laptop.

The six proofs

Every run is two windowless games on one Linux PC with an RTX 4090 and NVIDIA's driver, through a relay on the same PC, at 1280x720, from copies of test saves, with direct connections off (the default). Each proof was run once on its first attempt, and two of them a second time (see below). Every result line was compared with the earlier head's.

Proof What the two games did Result
Signed transfer of a checkpoint Both games on temporary copies of the save. The owner approved one download, nothing was sent before the exact approval, a wrong manifest received 0 bytes, and the two files arrived and matched their digests. A second transfer was cancelled after 8,192 of 160,019 bytes. Passed. After the cancel no usable save, no restart ticket and no change to either game's saves. All 55 result lines are the same as on the earlier head.
Consent, bodies and Leave Before anyone agreed each game showed only its own player. After both agreed, each game showed the other player's body once. The maker then left. Passed. One body created, shown and removed in each game; none shown again after Leave. All 14 result lines are the same.
Temporary copy, autosave and Return Both games restarted onto a temporary copy of the save. In the first game the player opened a chest and took the item, and the game's own autosave wrote the change into the temporary copy. Both games then returned to the original save. Passed. The first game's temporary copy had 3 changed files (the second game's had none); both original saves were byte for byte the same before and after, the changed copy was kept, and both games mounted the normal save again. All 36 result lines are the same.
Signed terms, stale confirmation and fresh consent Both games showed the room's signed terms before anyone accepted. Switching tabs and closing the menu cancelled the maker's earlier confirmation; the maker accepted only after a fresh two-press confirmation. The rules then changed to a signed PvP setup, and the second game's old confirming press did not accept it; a fresh confirmation did. Passed. All 13 checks pass, no progress was applied to either save, and no body of the other player appeared. 22 result lines are the same (the maker's key is a new random value every run, by design).
Standing, walking and turning presence off After both games agreed, each showed one body of the other player standing apart. Each player then walked four short legs while the other game showed the walking pose, and the maker then turned presence off. Passed. Each game created, showed and removed the other player's body exactly once; each received 6 walking and 7 standing requests, all played, none failed; after the change each game showed only its own player. All 41 result lines are the same.
Five sword swings and the damage counters The first player swung the sword five times next to the second player while both games counted the game's own damage records. Passed. New sword-activity records in each swing (159, 145, 148, 154 and 157; the earlier head had 158, 144, 147, 157 and 152); the second player did not move; no committed health loss in either game through the game's own life path; every counter lane complete. All 18 result lines are the same except the five counts.

Both games of every proof exited with code 0, nothing was left running, and the kernel log was complete with no driver fault, no mapping or allocation refusal and no unknown line. (One kernel log also holds lines from test programs of another job on the PC that crash on purpose; none of them is the game.)

The transfer proof, six views: download-only consent, checkpoint stored in the first game and exported by the second, and the second transfer cancelled. Only each game's own player is in view, with three hearts and the fairy.
The consent proof: before consent one player in each game, after both accepted two complete players in each game, after Leave one again.
The temporary copy proof: each game's player at a closed chest, the first game's autosave ("Saving..." with the chest open), the second game's chest still shut, and both games back at the title screen after Return.
The terms proof, from the games' own menus: the first game's Mode row help text "Signed terms, read only. Maker: ... Accept pins these exact terms.", and the second game's "Room rules changed. Read the new Room rules before accepting." with the Accept the room row.
The walking proof: both players standing apart, each walking in the other game's view (leg lifted, knee bent), standing again, and after presence is turned off only the player's own body.
The swing proof: the first player's swings 1, 3 and 5 (the blade and its arc) next to the second player, who stands put; three full hearts in every view.

What differs from the earlier head

  • The reason the log gives for hiding another player's body. The counts and every result line are the same; only the text changed, as the fixes intended. When the maker leaves on the Co-op tab, the leaver's own log now says this game is not in a room (it left the room, or co-op is off) where it used to say this game stopped being played: a map change or a load. When the maker turns presence off, both games now say the room is not accepted now (a new or unidentified player, changed rules or a withdrawn acceptance). One thing to look at: when the other player leaves, the player who stays now first logs that same the room is not accepted now ... text for the hide and then a separate left the room line, where the earlier head logged left the room for the hide. The body is still removed once. The code path was not read; from the log order the room's permission seems to lapse a moment before the leaving player's entry is removed.
  • Pauses in the picture in some starts. In the first run of two proofs there were intervals over one second between pictures that the earlier head's runs did not have, all in starts after a restart or a Return: the third start of both games in the temporary copy proof (eight each, up to 5.6 seconds, around the moment the title screen comes up), and the first start of both games in the transfer proof (four and five, 1.0 to 2.6 seconds; the earlier head had three in the first game). The game's log shows the main thread stuck in a memory synchronisation for up to 3.9 seconds, and a game logged threads that waited more than 2 seconds for a core (in the copy proof the PC's load average rose from 5.9 to 13.3). Both proofs were run once more: both passed again with the same result lines, with no interval over one second in any start of either game and no waiting thread. For the transfer proof the pauses of both games fall in the same 14 seconds in which other work on the same PC was copying the game's 187,000 files; that is a correlation, not an instrumented proof. For the temporary copy proof no cause was found. They changed no result.
  • Numbers that moved. The five swing counts (98 to 103 percent of the earlier head's; they count the game's own records in a real-time interval); the time to make a body in the walking proof's second game (183 milliseconds once, the earlier head 32).

Direct connections, three runs with two real games (one of them twice)

Each run used two windowless games on one PC, a relay on the same PC, the first game making the room and the second joining, both with coop_direct set the same way through the environment. What was expected was written down before each run, with the corrections learned from the same three runs on the earlier head. The relay was counted by a small wrapper around the project's own relay code. The three runs together took 887 seconds.

  • Direct on. Both games found a direct path within a second of both being ready and neither logged a fallback. The first game's path was host/host and the second game's was host/prflx (learnt from the first game's check before it had the first game's address; the earlier head had host/host in both; the expectation allowed only host/host, so that clause failed, though the path is direct on the same network and was found in 0.1 seconds). After that the relay forwarded 0 datagrams a second over a 135 second steady window and received 1 a second (the keep-alive pings). All four chat lines arrived, one body each, none removed. The Co-op tab shows Direct (on) (fixed, with no arrows, because the environment holds it) with the warning line under it, and the second game's list of players reads (maker, direct).
  • A blocked path in the middle of a session (a small program that pretends to be a router and can stop forwarding on command). With the path blocked both ways, each game logged that the path had gone quiet 1.1 seconds later, the path was declared down 4.0 seconds after the block, and the relay carried the whole game again (31.7 datagrams a second forwarded, against 0 when direct). The first retry came 10.0 seconds after it went down, and the pair was direct again 7.3 seconds after the block was lifted. A second block in one direction only made both games suspect after 1.0 second, both closed the path 4.0 seconds after the block, the second retry came 30.0 seconds after it went down and the pair was direct again 0.06 seconds later. All ten chat lines arrived, the two typed during the first block included, and no body was removed. In the second game's list the word followed the path: direct, relay, direct, relay, direct. These timings are within 0.4 seconds of the earlier head's. This run needed two attempts. In the first, the last 40 seconds had three to five extra "has not answered" lines in each game, each followed at once by direct again; both games' picture intervals and the relay wrapper and router stand-in (small programs that run no game code) show gaps of 1 to 3.7 seconds at the same moments, eight times in 38 seconds, the seconds in which other work on the same PC made two copies of the game's 187,000 files. The games were correctly seeing that their own process had not run for 1.5 seconds. That attempt was kept and the case run once more on its own: the second attempt had no gap over 0.8 seconds and exactly two such lines in each game.
  • Probe mode. The path was found and reported as direct in both games, while the relay kept forwarding 30.6 datagrams a second (the earlier head: 30.9), with no drop when the path was proven; the path itself carried only probes (237 to 238 a minute). The one expectation that failed on the earlier head passes: neither game logged a suspect line or direct again in 265 seconds (the earlier head's second game logged one half a second apart at 200 seconds). That fits the fix to the "silent for 584 million years" bug, but one clean run does not prove a flap that happened once on the earlier head is gone.

The blocked-path run, first attempt, the second game's Co-op tab four times: (maker, relay) while the path was down in the first block, (maker, direct) after it came back, (maker, relay) in the second block, (maker, direct) after the third attempt.

Both games of every run exited with code 0 and the kernel log showed no driver fault. The first game's list of players with the word it shows for the second player is still not in any picture: with the maker's thirteen rows the Small menu at 1280x720 fits twelve, the second player's line is 41 pixels below the last visible one, and in a windowless picture the menu's scroll does not move at all. The mouse wheel in a real window would scroll further. This is read from the menu's source and the pictures; the code was not changed to test it.

A Windows laptop and a relay on the home network

Two sessions of one case (12.5 minutes each), run on this build, between this Linux PC (joining the room) and a Windows laptop (the room's maker, running a Windows build of the same commit) through a relay on a third PC on the home network, with coop_direct set to on in both games. A firewall rule for the new Windows folder was needed (the rule from the earlier head is bound to that head's program; same ports, home network only). What was expected was written down before the run.

  • It worked as expected. The direct path formed on both sides within a fraction of a second of the accept, again after a 5 second freeze of the Linux game (the laptop saw the path go quiet and then down as it should; the Linux game logged that the other player gave up the moment it resumed), and again 28.2 seconds after Direct connections was switched back on from the Co-op tab (the earlier head: 28.0 seconds); with the row set to Off, every message went through the relay (the relay's traffic rose from about 1 to about 10 to 16 packets a second and fell back when the path came back). Chat each way in every phase arrived and was acknowledged (seven lines; pictured on both PCs, except the one typed during the freeze, which only the laptop's own screen shows). One body per player, hidden at the leave; both games exited with code 0, the saves were byte for byte the same and the kernel log showed no driver fault.
  • The short "not answered for 1.5 seconds, then direct again" episodes of the earlier head are gone in these sessions. The earlier head's session of the same case had 7 of them in 12 minutes (4 in the laptop's log, 3 in the Linux game's); each of these had 0 in 12.5 minutes in either game. The only 1.5 second lines are the two that were caused (the freeze and the Off). Two sessions of one pair of PCs do not show that the one bug fixed was their only cause. The new line direct for 60 s: the failed attempts before are forgotten appeared in the laptop's log 60 seconds after its direct path formed, as predicted. (The runner's own detector marked each session as failed only because it reads that line as an error: it contains the word "failed". 31 of 32 written expectations passed in each.)
  • The direct data went over the VPN, not over the plain home network, in the first session. Both PCs run a VPN; the games offer every address they have, and the log says only host/host. While the pair was direct the Linux PC's VPN counters for the laptop rose by about 31 KB in and 45 KB out every 10 seconds, and stayed at 0 while the row was Off; over the session they read 1.0 MB in and 1.5 MB out (the earlier head: 1.06 MB and 1.52 MB). The laptop's Wi-Fi saw no packets on the games' direct ports while the pair was direct (8 in and 9 out at the three moments the pair formed: the home network pair was tried and not used). The VPN's own path between the PCs is direct over the home network, not through the VPN's relay. So direct says nothing about LAN or VPN.
  • In the second session the first direct path ran over the home network (the laptop's Wi-Fi counted 2,637 and 1,867 packets on the direct ports while the VPN counters stayed idle), and its second and third over the VPN, so the route is decided each time the pair forms and host/host does not say which. That is the first time the new firewall rule carried traffic; it was not tested with the rule removed. A plain home network test needs the VPN off on one PC (not done).
  • The word after the maker's name, pictured. In the first session the Linux game ran at the default menu size, where the list of players is below the visible rows, so the case was run a second time with the Linux game at the smaller menu size. The Linux player's Co-op tab then shows 1 PlayWin (maker, direct) while the path is direct, (maker, relay) while it is down after the freeze, (maker, direct) on the new path, no word at all while the row is set to Off (the documented behaviour: nothing is shown while direct connections are off), (maker, relay) after the row is set back to On until the laptop's retry 28 seconds later, and (maker, direct) again. Each word matched what was written down before the run. The word for a joiner in the maker's list is still not pictured anywhere (see above).
  • The relay on the third PC changed that morning (it now answers the address-discovery request and keeps at most two open rooms per network for 10 minutes after the last player left); that stopped the first attempt at room setup, before any game fault, so the case was run again with a check that waits for a free place.

Two PCs, the Linux game's Co-op tab, Direct connections on: the other player's line reads (maker, relay) at 378.9 to 384.9 seconds while the path is down after the 5 second freeze, and (maker, direct) from 386.9 seconds.
Two PCs, the same tab with Direct connections set to Off: the line reads 1 PlayWin (maker) with no word after it, from 411.0 to 466.8 seconds.
Two PCs, the first session: two children in the Linux game and in the Windows laptop's window (with the label PlayLinux over the other child), then one child in each after the leave.

Not tested

  • Any other GPU or driver than an RTX 4090 with NVIDIA's driver.
  • A connection across the internet, a router with a different NAT, more than two players, long sessions, sword contact and fighting, adult bodies and equipment.
  • The outfit, Go to friend and the sword-practice kit in a game on this head, and the router port mapping with coop_portmap on (the proofs did not use them).
  • Speed: nothing here is a measurement of frame rate or frame time. Every run was an ordinary functional run on a PC that was never idle (load averages 4 to 14 from other jobs).
These are the results for the new head of this pull request, `2574634645ea0d7380171dd53c7ca6e410a9f7d8` (local branch name `coop-playtest-r17-rc1`). Every game run below was done on a build of the commit just before it, `607c6384da2f7408414b2761da9ece16e3c4f653` (game version `v3.0.0-rc.3-300-g607c6384d`). The only difference between the two commits is one commit that changes one test file (`tests/oot_coop_players_test.c`), and both have the same source fingerprint (`5d118e2e`), so the game built from either is the same game; no build of the new head itself was run. The new head sits on the last pushed head of this pull request, `5137c513ab1467df42d2ab8688ff25a850fe753c` (r16), with 55 commits on top: the outfit of the other player's body (tunic, boots and mask), fixes to Go to friend, the sword practice kit, direct connections, save backups and a room made on the Co-op tab after a relay restart, router port mapping for the direct paths, corrected texts for why a body is hidden, fuzz and soak tests, an opt-in trace of the poses, and a display delay that follows the jitter of a link. Nothing here is carried over from an earlier head. "The earlier head" below is r16, the head the same six proofs ran on last time. The game-free suite on the new head gave 603 passed, 12 failed (the same 12 as main) and 16 skipped. On the commit before it the suite gave 602 passed, 13 failed and 16 skipped: the same 12 plus the co-op test that checks how a received outfit is drawn, which failed at one check. The cause is in the test: a step waited a fixed 232 ms while the body's display delay can reach 250 ms. The head's one test-only commit makes the step wait for the piece, and the test passes with both compilers. This comment gives the results of six two-game proofs, three direct-connection runs and two sessions between a Linux PC and a Windows laptop. **The six proofs** Every run is two windowless games on one Linux PC with an RTX 4090 and NVIDIA's driver, through a relay on the same PC, at 1280x720, from copies of test saves, with direct connections off (the default). Each proof was run once on its first attempt, and two of them a second time (see below). Every result line was compared with the earlier head's. | Proof | What the two games did | Result | |---|---|---| | Signed transfer of a checkpoint | Both games on temporary copies of the save. The owner approved one download, nothing was sent before the exact approval, a wrong manifest received 0 bytes, and the two files arrived and matched their digests. A second transfer was cancelled after 8,192 of 160,019 bytes. | Passed. After the cancel no usable save, no restart ticket and no change to either game's saves. All 55 result lines are the same as on the earlier head. | | Consent, bodies and Leave | Before anyone agreed each game showed only its own player. After both agreed, each game showed the other player's body once. The maker then left. | Passed. One body created, shown and removed in each game; none shown again after Leave. All 14 result lines are the same. | | Temporary copy, autosave and Return | Both games restarted onto a temporary copy of the save. In the first game the player opened a chest and took the item, and the game's own autosave wrote the change into the temporary copy. Both games then returned to the original save. | Passed. The first game's temporary copy had 3 changed files (the second game's had none); both original saves were byte for byte the same before and after, the changed copy was kept, and both games mounted the normal save again. All 36 result lines are the same. | | Signed terms, stale confirmation and fresh consent | Both games showed the room's signed terms before anyone accepted. Switching tabs and closing the menu cancelled the maker's earlier confirmation; the maker accepted only after a fresh two-press confirmation. The rules then changed to a signed PvP setup, and the second game's old confirming press did not accept it; a fresh confirmation did. | Passed. All 13 checks pass, no progress was applied to either save, and no body of the other player appeared. 22 result lines are the same (the maker's key is a new random value every run, by design). | | Standing, walking and turning presence off | After both games agreed, each showed one body of the other player standing apart. Each player then walked four short legs while the other game showed the walking pose, and the maker then turned presence off. | Passed. Each game created, showed and removed the other player's body exactly once; each received 6 walking and 7 standing requests, all played, none failed; after the change each game showed only its own player. All 41 result lines are the same. | | Five sword swings and the damage counters | The first player swung the sword five times next to the second player while both games counted the game's own damage records. | Passed. New sword-activity records in each swing (159, 145, 148, 154 and 157; the earlier head had 158, 144, 147, 157 and 152); the second player did not move; no committed health loss in either game through the game's own life path; every counter lane complete. All 18 result lines are the same except the five counts. | Both games of every proof exited with code 0, nothing was left running, and the kernel log was complete with no driver fault, no mapping or allocation refusal and no unknown line. (One kernel log also holds lines from test programs of another job on the PC that crash on purpose; none of them is the game.) ![The transfer proof, six views: download-only consent, checkpoint stored in the first game and exported by the second, and the second transfer cancelled. Only each game's own player is in view, with three hearts and the fairy.](https://git.magicbean.dev/attachments/79c18594-ce8a-4918-bd62-12bce136efa1) ![The consent proof: before consent one player in each game, after both accepted two complete players in each game, after Leave one again.](https://git.magicbean.dev/attachments/545857bd-8a87-4662-95d2-e2ccdbe1e73e) ![The temporary copy proof: each game's player at a closed chest, the first game's autosave ("Saving..." with the chest open), the second game's chest still shut, and both games back at the title screen after Return.](https://git.magicbean.dev/attachments/37cf038b-b1ef-4cbe-9f7c-785f90d4f56a) ![The terms proof, from the games' own menus: the first game's Mode row help text "Signed terms, read only. Maker: ... Accept pins these exact terms.", and the second game's "Room rules changed. Read the new Room rules before accepting." with the Accept the room row.](https://git.magicbean.dev/attachments/02a9639e-17f8-4d58-baae-e5d80f7c3e92) ![The walking proof: both players standing apart, each walking in the other game's view (leg lifted, knee bent), standing again, and after presence is turned off only the player's own body.](https://git.magicbean.dev/attachments/f31b7052-5c65-41d0-a6ae-05ba518c47ff) ![The swing proof: the first player's swings 1, 3 and 5 (the blade and its arc) next to the second player, who stands put; three full hearts in every view.](https://git.magicbean.dev/attachments/3e2e86fe-bf19-48df-a729-b252ee261fa4) **What differs from the earlier head** - **The reason the log gives for hiding another player's body.** The counts and every result line are the same; only the text changed, as the fixes intended. When the maker leaves on the Co-op tab, the leaver's own log now says `this game is not in a room (it left the room, or co-op is off)` where it used to say `this game stopped being played: a map change or a load`. When the maker turns presence off, both games now say `the room is not accepted now (a new or unidentified player, changed rules or a withdrawn acceptance)`. One thing to look at: when the other player leaves, the player who stays now first logs that same `the room is not accepted now ...` text for the hide and then a separate `left the room` line, where the earlier head logged `left the room` for the hide. The body is still removed once. The code path was not read; from the log order the room's permission seems to lapse a moment before the leaving player's entry is removed. - **Pauses in the picture in some starts.** In the first run of two proofs there were intervals over one second between pictures that the earlier head's runs did not have, all in starts after a restart or a Return: the third start of both games in the temporary copy proof (eight each, up to 5.6 seconds, around the moment the title screen comes up), and the first start of both games in the transfer proof (four and five, 1.0 to 2.6 seconds; the earlier head had three in the first game). The game's log shows the main thread stuck in a memory synchronisation for up to 3.9 seconds, and a game logged threads that waited more than 2 seconds for a core (in the copy proof the PC's load average rose from 5.9 to 13.3). Both proofs were run once more: both passed again with the same result lines, with no interval over one second in any start of either game and no waiting thread. For the transfer proof the pauses of both games fall in the same 14 seconds in which other work on the same PC was copying the game's 187,000 files; that is a correlation, not an instrumented proof. For the temporary copy proof no cause was found. They changed no result. - **Numbers that moved.** The five swing counts (98 to 103 percent of the earlier head's; they count the game's own records in a real-time interval); the time to make a body in the walking proof's second game (183 milliseconds once, the earlier head 32). **Direct connections, three runs with two real games (one of them twice)** Each run used two windowless games on one PC, a relay on the same PC, the first game making the room and the second joining, both with `coop_direct` set the same way through the environment. What was expected was written down before each run, with the corrections learned from the same three runs on the earlier head. The relay was counted by a small wrapper around the project's own relay code. The three runs together took 887 seconds. - **Direct on.** Both games found a direct path within a second of both being ready and neither logged a fallback. The first game's path was `host/host` and the second game's was `host/prflx` (learnt from the first game's check before it had the first game's address; the earlier head had `host/host` in both; the expectation allowed only `host/host`, so that clause failed, though the path is direct on the same network and was found in 0.1 seconds). After that the relay forwarded 0 datagrams a second over a 135 second steady window and received 1 a second (the keep-alive pings). All four chat lines arrived, one body each, none removed. The Co-op tab shows `Direct (on)` (fixed, with no arrows, because the environment holds it) with the warning line under it, and the second game's list of players reads `(maker, direct)`. - **A blocked path in the middle of a session** (a small program that pretends to be a router and can stop forwarding on command). With the path blocked both ways, each game logged that the path had gone quiet 1.1 seconds later, the path was declared down 4.0 seconds after the block, and the relay carried the whole game again (31.7 datagrams a second forwarded, against 0 when direct). The first retry came 10.0 seconds after it went down, and the pair was direct again 7.3 seconds after the block was lifted. A second block in one direction only made both games suspect after 1.0 second, both closed the path 4.0 seconds after the block, the second retry came 30.0 seconds after it went down and the pair was direct again 0.06 seconds later. All ten chat lines arrived, the two typed during the first block included, and no body was removed. In the second game's list the word followed the path: `direct`, `relay`, `direct`, `relay`, `direct`. These timings are within 0.4 seconds of the earlier head's. **This run needed two attempts.** In the first, the last 40 seconds had three to five extra "has not answered" lines in each game, each followed at once by `direct again`; both games' picture intervals and the relay wrapper and router stand-in (small programs that run no game code) show gaps of 1 to 3.7 seconds at the same moments, eight times in 38 seconds, the seconds in which other work on the same PC made two copies of the game's 187,000 files. The games were correctly seeing that their own process had not run for 1.5 seconds. That attempt was kept and the case run once more on its own: the second attempt had no gap over 0.8 seconds and exactly two such lines in each game. - **Probe mode.** The path was found and reported as `direct` in both games, while the relay kept forwarding 30.6 datagrams a second (the earlier head: 30.9), with no drop when the path was proven; the path itself carried only probes (237 to 238 a minute). **The one expectation that failed on the earlier head passes: neither game logged a suspect line or `direct again` in 265 seconds** (the earlier head's second game logged one half a second apart at 200 seconds). That fits the fix to the "silent for 584 million years" bug, but one clean run does not prove a flap that happened once on the earlier head is gone. ![The blocked-path run, first attempt, the second game's Co-op tab four times: (maker, relay) while the path was down in the first block, (maker, direct) after it came back, (maker, relay) in the second block, (maker, direct) after the third attempt.](https://git.magicbean.dev/attachments/a4a1e3e5-0ddb-4a84-b4cf-f3bf2e35daa9) Both games of every run exited with code 0 and the kernel log showed no driver fault. **The first game's list of players with the word it shows for the second player is still not in any picture**: with the maker's thirteen rows the Small menu at 1280x720 fits twelve, the second player's line is 41 pixels below the last visible one, and in a windowless picture the menu's scroll does not move at all. The mouse wheel in a real window would scroll further. This is read from the menu's source and the pictures; the code was not changed to test it. **A Windows laptop and a relay on the home network** Two sessions of one case (12.5 minutes each), run on this build, between this Linux PC (joining the room) and a Windows laptop (the room's maker, running a Windows build of the same commit) through a relay on a third PC on the home network, with `coop_direct` set to on in both games. A firewall rule for the new Windows folder was needed (the rule from the earlier head is bound to that head's program; same ports, home network only). What was expected was written down before the run. - **It worked as expected.** The direct path formed on both sides within a fraction of a second of the accept, again after a 5 second freeze of the Linux game (the laptop saw the path go quiet and then down as it should; the Linux game logged that the other player gave up the moment it resumed), and again 28.2 seconds after Direct connections was switched back on from the Co-op tab (the earlier head: 28.0 seconds); with the row set to Off, every message went through the relay (the relay's traffic rose from about 1 to about 10 to 16 packets a second and fell back when the path came back). Chat each way in every phase arrived and was acknowledged (seven lines; pictured on both PCs, except the one typed during the freeze, which only the laptop's own screen shows). One body per player, hidden at the leave; both games exited with code 0, the saves were byte for byte the same and the kernel log showed no driver fault. - **The short "not answered for 1.5 seconds, then direct again" episodes of the earlier head are gone in these sessions.** The earlier head's session of the same case had 7 of them in 12 minutes (4 in the laptop's log, 3 in the Linux game's); each of these had 0 in 12.5 minutes in either game. The only 1.5 second lines are the two that were caused (the freeze and the Off). Two sessions of one pair of PCs do not show that the one bug fixed was their only cause. The new line `direct for 60 s: the failed attempts before are forgotten` appeared in the laptop's log 60 seconds after its direct path formed, as predicted. (The runner's own detector marked each session as failed only because it reads that line as an error: it contains the word "failed". 31 of 32 written expectations passed in each.) - **The direct data went over the VPN, not over the plain home network, in the first session.** Both PCs run a VPN; the games offer every address they have, and the log says only `host/host`. While the pair was direct the Linux PC's VPN counters for the laptop rose by about 31 KB in and 45 KB out every 10 seconds, and stayed at 0 while the row was Off; over the session they read 1.0 MB in and 1.5 MB out (the earlier head: 1.06 MB and 1.52 MB). The laptop's Wi-Fi saw no packets on the games' direct ports while the pair was direct (8 in and 9 out at the three moments the pair formed: the home network pair was tried and not used). The VPN's own path between the PCs is direct over the home network, not through the VPN's relay. So `direct` says nothing about LAN or VPN. - **In the second session the first direct path ran over the home network** (the laptop's Wi-Fi counted 2,637 and 1,867 packets on the direct ports while the VPN counters stayed idle), and its second and third over the VPN, so the route is decided each time the pair forms and `host/host` does not say which. That is the first time the new firewall rule carried traffic; it was not tested with the rule removed. A plain home network test needs the VPN off on one PC (not done). - **The word after the maker's name, pictured.** In the first session the Linux game ran at the default menu size, where the list of players is below the visible rows, so the case was run a second time with the Linux game at the smaller menu size. The Linux player's Co-op tab then shows `1 PlayWin (maker, direct)` while the path is direct, `(maker, relay)` while it is down after the freeze, `(maker, direct)` on the new path, **no word at all while the row is set to Off** (the documented behaviour: nothing is shown while direct connections are off), `(maker, relay)` after the row is set back to On until the laptop's retry 28 seconds later, and `(maker, direct)` again. Each word matched what was written down before the run. The word for a joiner in the *maker's* list is still not pictured anywhere (see above). - The relay on the third PC changed that morning (it now answers the address-discovery request and keeps at most two open rooms per network for 10 minutes after the last player left); that stopped the first attempt at room setup, before any game fault, so the case was run again with a check that waits for a free place. ![Two PCs, the Linux game's Co-op tab, Direct connections on: the other player's line reads (maker, relay) at 378.9 to 384.9 seconds while the path is down after the 5 second freeze, and (maker, direct) from 386.9 seconds.](https://git.magicbean.dev/attachments/c88bb8ef-36fe-40e9-911c-5e9d96d8d5f2) ![Two PCs, the same tab with Direct connections set to Off: the line reads 1 PlayWin (maker) with no word after it, from 411.0 to 466.8 seconds.](https://git.magicbean.dev/attachments/3241ccbe-0928-46ca-9b16-7792b7eb1c83) ![Two PCs, the first session: two children in the Linux game and in the Windows laptop's window (with the label PlayLinux over the other child), then one child in each after the leave.](https://git.magicbean.dev/attachments/7e08c2c1-e956-4f2e-88f4-b0439e281e35) **Not tested** - Any other GPU or driver than an RTX 4090 with NVIDIA's driver. - A connection across the internet, a router with a different NAT, more than two players, long sessions, sword contact and fighting, adult bodies and equipment. - The outfit, Go to friend and the sword-practice kit in a game on this head, and the router port mapping with `coop_portmap` on (the proofs did not use them). - Speed: nothing here is a measurement of frame rate or frame time. Every run was an ordinary functional run on a PC that was never idle (load averages 4 to 14 from other jobs).
Owner

This is stacked on #68 (its commits include 68's), and 68 conflicts with main too, so it can only be rebased once 68 is rebased or has landed. Please rebase onto current main after that. Thank you.

This is stacked on https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/68 (its commits include 68's), and 68 conflicts with `main` too, so it can only be rebased once 68 is rebased or has landed. Please rebase onto current `main` after that. Thank you.
Author
Member

Closing this pull request into #68, which now carries the whole co-op line as one "add multiplayer" change, off by default, as planned in #463.

What carries over: every one of this pull request's 171 commits on its last head, 2574634645ea0d7380171dd53c7ca6e410a9f7d8, is in the new head of 68, 79c9d411f2406a4cdafa9a3458df0236a7b78b4d, with its author, date and message unchanged, replayed together with one more commit for the switches' documentation (172 commits). Where main's own changes touched the same lines, the commit that met them keeps both sides. On top of them 68 now has the version gate, the change that keeps already accepted friends shown while a newcomer waits, the native sword duel behind its test switch, the pre-merge fixes, the bandwidth changes and the repairs of test fixtures for main's newer tests. The list is in the description of 68 and in the comment posted with its update.

This also answers the request above to rebase this pull request once 68 was rebased (#355 (comment)): there is nothing left to rebase here.

Where the evidence is: the results comments stay here as history and stay true for the heads they name: the results for the head before the last one, 5137c513ab1467df42d2ab8688ff25a850fe753c, at #355 (comment); its direct connections between a Linux PC and a Windows PC at #355 (comment); the problems found in that head at #355 (comment) and their fixes at #355 (comment); and the results for the last head at #355 (comment). The results for the new head are in the description of 68, under Testing, and in its comment for this update. The test requests that were open on this pull request (T-ADK4, T-QF6F and T-KQUM) were for its earlier heads; what still has to be tested on the new head is listed under Must be tested in the description of 68.

Nothing is lost by closing: the branch stays on the fork under its old name and can be reopened if 68 is sent back for a split.

Closing this pull request into https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/68, which now carries the whole co-op line as one "add multiplayer" change, off by default, as planned in https://git.magicbean.dev/MagicBeanDev/Longshot/issues/463. What carries over: every one of this pull request's 171 commits on its last head, `2574634645ea0d7380171dd53c7ca6e410a9f7d8`, is in the new head of 68, `79c9d411f2406a4cdafa9a3458df0236a7b78b4d`, with its author, date and message unchanged, replayed together with one more commit for the switches' documentation (172 commits). Where main's own changes touched the same lines, the commit that met them keeps both sides. On top of them 68 now has the version gate, the change that keeps already accepted friends shown while a newcomer waits, the native sword duel behind its test switch, the pre-merge fixes, the bandwidth changes and the repairs of test fixtures for main's newer tests. The list is in the description of 68 and in the comment posted with its update. This also answers the request above to rebase this pull request once 68 was rebased (https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-28080): there is nothing left to rebase here. Where the evidence is: the results comments stay here as history and stay true for the heads they name: the results for the head before the last one, `5137c513ab1467df42d2ab8688ff25a850fe753c`, at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-24067; its direct connections between a Linux PC and a Windows PC at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-24101; the problems found in that head at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-24104 and their fixes at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-26770; and the results for the last head at https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/355#issuecomment-26772. The results for the new head are in the description of 68, under Testing, and in its comment for this update. The test requests that were open on this pull request (T-ADK4, T-QF6F and T-KQUM) were for its earlier heads; what still has to be tested on the new head is listed under Must be tested in the description of 68. Nothing is lost by closing: the branch stays on the fork under its old name and can be reopened if 68 is sent back for a split.
mooki closed this pull request 2026-11-16 05:42:51 +00:00
All checks were successful
PR description / Description follows the template (pull_request_target) Successful in 10s
Website / Website on Cloudflare (pull_request_target) Has been skipped

Pull request closed

Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
3 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!355
No description provided.