WIP: feat(coop): add consent-based player presence and isolated save playtests #355
No reviewers
Labels
No labels
area/accessibility
area/audio
area/input
area/install
area/menu
area/renderer
area/saves
area/tooling
area/upscaling
beanstalk: approved
beanstalk: failed
beanstalk: needs approval
beanstalk: running
beanstalk: tested
ci: approved
good first issue
gpu/amd
gpu/igpu
gpu/intel
gpu/nvidia
help wanted
kind
bug
kind
chore
kind
docs
kind
feature
kind
performance
kind
question
needs measurements
platform/linux
platform/macos
platform/steam-deck
platform/windows
preview
priority
critical
priority
high
priority
low
regression
risk
high
risk
low
risk
medium
status
blocked
status
confirmed
status
duplicate
status
invalid
status
needs-info
status
wontfix
ci: approved
No milestone
No project
No assignees
3 participants
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
MagicBeanDev/Longshot!355
Loading…
Reference in a new issue
No description provided.
Delete branch "mooki/Longshot:coop-playtest-r9"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
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 namecoop-playtest-r17-rc1, game versionv3.0.0-rc.3-301-g257463464when built from it). It sits directly on pull request 68's head3320a841036f02484ae68c72f02b6f34928f776e, which sits on main6c9edffe5da1f5b5383977aeab3f544c0de25d4c, 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 is1c91dafbd627026e59130d5c58290eb028a52348, 23 commits after6c9edffe5da1f5b5383977aeab3f544c0de25d4c, 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.
host/coop_state.c,host/coop_proto.c,host/coop_gameplay.h,host/oot_coop.c,host/coop_menu.c.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.host/coop_profile.c,host/nn_fs.c,host/coop_save.c,host/coop_save_runtime.c.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).host/oot_coop_hits.c,host/coop_duel.c,host/coop_arena.c.scripts/coop_relay.py,host/coop_relay.c.third_party/libjuice, MPL-2.0, with itsPROVENANCE.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 ishost/coop_ice_juice.c). Withcoop_direct=onthe 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.host/coop_portmap.c,host/coop.c.coop_playersis 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.gpu/vk/vk_api.hMKWVK_API_VERSION23 to 30;docs/coop.mdis the reference, withdocs/development.md,README.mdandCONTRIBUTING.mdupdated. 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:HOS_COOP_PLAYERS_OUTFIT=0draws none..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.coop_portmapon, the router is also asked to map the direct paths' UDP port, and the answer is offered as a candidate address.HOS_COOP_POSE_TRACEwrites a trace for measuring this.third_party/libjuice/PROVENANCE.mdnow 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
2574634645ea0d7380171dd53c7ca6e410a9f7d8from 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 update6c9edffe5d2574634645607c6384da2f7408414b2761da9ece16e3c4f653(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)host/prflx, nothost/host) and a blocked-path run that needed a second attempt after the PC itself stalled for secondsFlags and settings
This PR adds the switches below, changes one (
coop_portmapnow 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 indocs/coop.md; the test switches are indocs/development.md, except theHOS_COOP_DIRECT*andHOS_COOP_STUNones, which are indocs/coop.mdonly.coop_direct/HOS_COOP_DIRECT, the Co-op tab's Direct connections rowoff,probe(look for a path and report it; every message still goes through the relay) oron(send over a proven path, the relay as the fallback). The row sets it in a running game; a setHOS_COOP_DIRECTholds it for the runcoop_stun/HOS_COOP_STUNcoop_direct_port/HOS_COOP_DIRECT_PORTcoop_direct_lan=0/HOS_COOP_DIRECT_LAN=0HOS_COOP_DIRECT_DROPcoop_portmap/HOS_COOP_PORTMAP(and test-onlyHOS_COOP_PORTMAP_TEST_GATEWAY)coop_directon 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 exitdocs/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 routerHOS_COOP_RELAY_STUN=0--network-repliesand--room-removals(the in-game relay has the same limits at fixed values)coop_players/HOS_COOP_PLAYERS=0HOS_COOP_PLAYERS_OUTFIT0,offorfalsedraws none, for before and after picturesHOS_COOP_EQUIP_PROBEandHOS_COOP_POSE_TRACEHOS_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 jankcoop_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-onlyHOS_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_TICKETandHOS_COOP_TRACEPull 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_PROBEandHOS_COOP_TEST_SET) are not repeated here. Existing development switches this line touches:HOS_OOT_TELEPORT_EVENTandHOS_OOT_TELEPORT_STARTER(Go to friend refuses while either is set) andRX_VK_MENU_SCRIPT(a diagnostic entry into the chat field).Testing
Tested:
6c9edffe5da1f5b5383977aeab3f544c0de25d4c(552 / 12 / 16) and on pull request 68's head3320a841036f02484ae68c72f02b6f34928f776e(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 wastests/test_coop_players.pyat 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.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.direct,relayafter the stop,direct, no word while the row is Off,relayuntil 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.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.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).tests/test_coop_direct.pyfailed 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:
coop_portmapon, both set the Direct connections row to Direct, accept, walk and chat, expecting adirect (...)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)direct (host/host)and the relay's traffic falling to its keep-alives (by hand: a person, with the log and the network counters)request: takenlines)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=0stops the router request;coop_players=0removes the bodies;HOS_COOP_PLAYERS_OUTFIT=0draws no outfit;coop_host=0stops 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--userroot 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_playersnow 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_VERSIONgoes 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
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.
type(scope): description) of the status line's type.main.This head sits on main
6c9edffe5da1f5b5383977aeab3f544c0de25d4cthrough pull request 68; main is now at1c91dafbd627026e59130d5c58290eb028a52348, and a trial merge gives 6 textual conflicts (listed under Why).python -I -B tests/run_all.pypasses (any failure that also fails onmainis 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.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 undertests/fuzz/corpus. The seeds are written bytests/fuzz/make_seeds.pyfrom 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 aPROVENANCE.mdinstead).Against main, 51 files under
third_party/are added and none changed or deleted:monocypher(4 files, from pull request 68) andlibjuice(47, with itsPROVENANCE.md, whose text this round corrects to say the game links the library).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
Assisted-by:/Co-Authored-By:trailers.All 171 commits above pull request 68's head carry both.
The
HOS_COOP_PLAYERS_OUTFIT,HOS_COOP_EQUIP_PROBE,HOS_COOP_POSE_TRACE,HOS_COOP_RELAY_STUN,HOS_COOP_PORTMAPandHOS_COOP_PLAYERSrows are indocs/development.md; theHOS_COOP_DIRECT,HOS_COOP_DIRECT_LAN,HOS_COOP_DIRECT_PORT,HOS_COOP_DIRECT_DROPandHOS_COOP_STUNrows are indocs/coop.mdonly.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_VERSIONbumped (gpu/vk/vk_api.h'sMkwVkHostorMkwVkRendererchanged).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.mainand 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.
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.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/coop.md,docs/development.md,docs/control.md,README.mdandCONTRIBUTING.md.New on this forge; not opened on GitHub.
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]>Two-player co-op playtest: r12
This is an experimental test, not a finished multiplayer release. Use commit
2f01e1b4bdb6e1629c54a998f0403519fe4e5c74(r12) on both PCs, Linux source05329d46. The pull request's branch is still namedcoop-playtest-r9for 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
Obtain the playtest branch and pin it:
Follow that checkout's
CONTRIBUTING.md, Development setup and Building. Windows uses Python and llvm-mingw, withLONGSHOT_MINGWpointing 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:
Replace
your-game.nupwith 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
coop-playtest-user. Copy only your ownsavedirectory, retaining its numbered subfolders, into it. Do not copy someone else's user folder or thecoop-keysdirectory. 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.--user "./coop-playtest-user". A source build normally haslongshot.exeorlongshotdirectly in its output folder. Packaged builds put the real executable inbin; the outer launcher does not forward--user.fs: mountedlines 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.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:
For a packaged game use
bin\longshot.exeorbin/longshotinstead. Keep this explicit--userargument 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=1for 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 newfs: mountedlines before continuing. Never create or copy a restart ticket by hand.R12 keeps runtime program/pipeline/preparation caches under
cache/, Vulkan pipeline files ascache/longshot_vk_pipelines*, and generated prompt files undercache/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 andlongshot_options.inistay 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: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=0prevents 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 setscoop_host=0. Remove any inherited co-op environment overrides, automatic joining/acceptance, diagnostic feeds or loss simulation from the test launch. Do not useHOS_COOP_ACCEPT=always.HOS_COOP*values written inlongshot_env.txtare 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. LeaveRX_VK_NO_INTEL_SERIALunset; 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, usescripts/longshot_ctl.pyfrom 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.hosting on this PCand printshosting: players on this network can try .... The host's own client connects over loopback.127.0.0.1on the second PC. Choose Join a room and enter the secret shared privately by the host.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)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.
fs: mountedlines showing the new copy root. A failed copy must not be bypassed by accepting on the ordinary save.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
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.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.txtin the game folder. The four preceding runs arelogs/longshot_log.1.txtthroughlogs/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 leavelogs/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:
vk: deviceidentifying the GPU and driver.fs: mountedlines 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 anyno 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.coop: stats:line, especiallyreliable retries,events given up,outbox fullandround 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=1can 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.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:
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.
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.
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
0ec9d0b0on both.0ec9d0b00ec9d0b0, cross-builtSettings: 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
1a52-512e-5836-45fd, same rulesLast counters of each game:
The Linux game logged a round trip of 1 to 4 ms to the Windows host over the session.
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.
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
0ec9d0b0241ed75e61b5Updated to
1ed75e61b5bc083247950a262b1a48230f44909a(r10), sourcec058db8c, replayed onto pull request 68's current head4a9b9606: #68. The branch namecoop-playtest-r9is historical; both testers should pin the new commit. Its base is maincf605c85b, not today's0caf06184, 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.pyandtest_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
0ec9d0b0only: #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/andcache/locations and Windows startup limits.R10: thirty minutes completed, but body continuity failed
Tested commit
1ed75e61b5bc083247950a262b1a48230f44909a, sourcec058db8c, 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:
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).
0ec9d0b01ed75e61The 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.
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. Main0caf0618on 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:test_pad_layout.pyHoldToggleundeclared in the fixture since #137 (#331 fixes it)test_release.pyopensslnot on the PATH (#144 has run_all find Git's); passes with it on the PATHtest_tested_configurations.py\r\nfrom the CLI's ASCII pipe on Windowstest_oot_state_tap.pyno game listens on longshot-oot-test-<n> (Invalid argument)test_module_ids.py,test_framegen_resources.py0caf0618on Windows too; not looked into2. A native Windows build:
nx2/lift.py --standalone --writeandnx2/build.py --standaloneat1ed75e61, 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=3in itslongshot_options.ini; B:HOS_COOP_AUTO=join; bothHOS_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 RSY… created (member 1), Bjoined room RSY… as member 2. Relay:WinA joined as member 1,WinB joined as member 2, thenWinB (member 2) left (1/8)andWinA (member 1) left (0/8). A loggedWinB (member 2) left the room, and both loggedleft room (the game is closing).room accepted (HOS_COOP_ACCEPT=always); the save is copied first, then madecoop-backup\first-20261114-0846xxZbefore applying anything.the flag table reads as the game's getter does (28 flags checked). A kept its signing key underuserA\coop-keys.save\before and after: identical for A and for B. The user folders gained onlycoop-backup,coop-keys(A) andtemp.PouchPlayer_Adultat 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.thrown away 0,reliable retries 0,events given up 0, round trip 1 ms, on both. NoCRASH, no device loss; both exited onquit.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: statechange at those points). In about 2.5 minutes, A logged 7 pairs ofmember 2 is shown as PouchPlayer_Adult .../member 2 is hidden (this game stopped being played: a map change or a load). B loggedmember 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.
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.
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:
member 2 is hiddenline, and the same stretch of B's log.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
1ed75e61as posted.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 slines against its hides (log line numbers):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. Itsmember 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 outrepeated,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:
B at the same time logged
member 1 is hidden (in no map)next tovi: ... 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.
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=1on both games makes the reason visible. The lines to look for around the first hide and the recovery: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.
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 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.
Updated to
2f01e1b4bdb6e1629c54a998f0403519fe4e5c74(r12), Linux source05329d46. The fork branch still has its historical namecoop-playtest-r9. The base remains pull request 68 at4a9b9606, on maincf605c85b, three commits behind0caf06184.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
15a68a5efailed 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.pyandtest_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 at1ed75e61. 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 for1ed75e61stand for that commit. This stays WIP and fighting remains disabled.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.In the 3-second case there are two separate reactions, as the code read suggested:
not heardshortly before A was released: it had received nothing from A for 3 seconds.game paused(its play counter had not ticked for more than 2.5 seconds), removed B's body, loggedgame runningone counter step later, and asked for the body again.in no mapline oranother save was loaded. So on this PC a clean 3-second stop shows asnot heardon the peer; the Windows report'sin no mapis the same check seen from a game that kept sending while starved.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.
R12: thirty minutes of body continuity passed, but the save-byte rule failed
Tested commit
2f01e1b4bdb6e1629c54a998f0403519fe4e5c74, source05329d46, 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.savchanged.What passed
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.savchanged, 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
0ec9d0b01ed75e612f01e1b4option.savchanged on each sideThe 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.
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.
option.savresult2f01e1b40caf061840caf06184The 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.Push to this pull request: head
9dfdd0c6c1a010d99418e8a9083ff3f62f8348ca(branchcoop-playtest-r15). The six proofs below ran on02bedee717978ccc13dde9029dd5ff9d086b5516(branchcoop-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 main1be60eae813865b0845fb8bb05b1d7cb9b39e51f), for these reasons, all checked on the commits themselves:git range-diffof the 92 co-op commits of02bedee71797against the 92 replayed commits of9dfdd0c6c1a0: 92 identical, 0 different. No commit differs, not even in its surrounding lines; authors, dates and messages are unchanged and there were no conflicts.host/oot_state_tap.c,host/nn_applet.candhost/nn_vi.c: all 107 are byte for byte the same on the two commits.1be60eae813865b0845fb8bb05b1d7cb9b39e51fthat pull request 68's head now includes:host/hos_thread.candtests/test_reserved_core.py.test_upscaler_round_tripandtest_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 main1be60eae8and on pull request 68's headd12e854c4the same way (fixed by #497).Results of the six two-game proofs on the next head of this pull request,
02bedee717978ccc13dde9029dd5ff9d086b5516(branchcoop-playtest-r14b, game versionv3.0.0-rc.3-197-g02bedee71). It is newer than2f01e1b4bdb6e1629c54a998f0403519fe4e5c74, 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 head96b846278fc148eaae7e4158b91497f757a8dc15(branchcoop-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
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(branchcoop-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.
2f01e1b4bdb6e1629c54a998f0403519fe4e5c74) this stop removed both bodies for about 2 seconds.Over all five stops neither game logged
in no maporanother 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
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.
2f01e1b4bd9dfdd0c6c1r15
9dfdd0c6on 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 of9dfdd0c6, each game with its own game folder and user folder holding a copy of one save (adult, Death Mountain Trail),scripts/coop_relay.pyon 127.0.0.1, Acreatewithcoop_presence_permissions=3, Bjoin, bothHOS_COOP_PLAYERS=1andHOS_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:
this game's body liveness grace expiredvi: ... 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)not heardWinB (member 2) left the roomat the quitThrough 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:
coop-backup,coop-keys(A) andtemp.WinB (member 2) left (1/8),WinA (member 1) left (0/8)on the relay.CRASH, no device loss, both exited onquit.Still not done here: Copy/Return and the junction refusal on Windows, and the game's own hosting. Shots stay on this PC.
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 indocs/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-replieschanges 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.
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), sourced29365fd, 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
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.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
0ec9d0b01ed75e61restart2f01e1b49dfdd0c6(this one)option.savchanged at 05:00The 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.
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 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):
d12e854c4e3a532ea0f40c8f7f552086f7e8a54b9dfdd0c6c1a010d99418e8a9083ff3f62f8348caBoth 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.
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.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 linev3.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:
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
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
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.430e5dae7b5137c513abResults on the new head of this pull request,
5137c513ab1467df42d2ab8688ff25a850fe753c(branchcoop-playtest-r16, game versionv3.0.0-rc.3-246-g5137c513a). It sits on the head of pull request 68,3320a841036f02484ae68c72f02b6f34928f776e, on main6c9edffe5da1f5b5383977aeab3f544c0de25d4c. 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_playerson 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, withcoop_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
6c9edffe5da1f5b5383977aeab3f544c0de25d4cand on the pull request 68 head, none of them touches co-op, and nothing that passes there fails here.6c9edffe5da1f5b5383977aeab3f544c0de25d4c3320a841036f02484ae68c72f02b6f34928f776eda38c28614fb8f31f1efbdd875d4db86cebb57bf(the first with libjuice)5137c513ab1467df42d2ab8688ff25a850fe753cCompared 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).
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_directset 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.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 asDirect (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.waitinginstead ofdirect.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 anddirect againhalf 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
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 linev3.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):
Results
Session 1 (the maker hosts the relay): the Linux game logged
its relay runs on its PC; no direct path is neededright 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):
direct (host/host) in 0.1 sno direct path (the other player gave up)and then the new attemptcoop_direct=off (from the Co-op tab); the Windows game saw the silent pair go suspect, then closed itcoop_direct=on (from the Co-op tab); the Windows game found the path at its next retry, 28 s laterShort "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
What this does not show
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.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.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]>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]>.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]>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 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]>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 of607c6384da2f7408414b2761da9ece16e3c4f653, 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.f0a08cf53a90bd1403267cbbf2b26ef557cd4544. Shown in two real games on the branch: every ask got past the safety check.ba74cae2749a20bc65ecf8a81fe03d6a9244a842and12697da22edbb45dbe282b41b64516cfbef51846. 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).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.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.9f3853fe36c07c89b164fa5452c94be26391a829(the wrapped time difference) and4a5a83636fc307c74c676da2e6f4f768247df42b(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.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.9b5444719ec7b294bd02b258c1c84157448e04fcand3ce7f325d4e9542f34860be17fcb25676bcab29f. 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.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.These are the results for the new head of this pull request,
2574634645ea0d7380171dd53c7ca6e410a9f7d8(local branch namecoop-playtest-r17-rc1). Every game run below was done on a build of the commit just before it,607c6384da2f7408414b2761da9ece16e3c4f653(game versionv3.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.
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.)
What differs from the earlier head
this game is not in a room (it left the room, or co-op is off)where it used to saythis game stopped being played: a map change or a load. When the maker turns presence off, both games now saythe 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 samethe room is not accepted now ...text for the hide and then a separateleft the roomline, where the earlier head loggedleft the roomfor 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.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_directset 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.host/hostand the second game's washost/prflx(learnt from the first game's check before it had the first game's address; the earlier head hadhost/hostin both; the expectation allowed onlyhost/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 showsDirect (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).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 bydirect 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.directin 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 ordirect againin 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.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_directset 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.direct for 60 s: the failed attempts before are forgottenappeared 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.)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. Sodirectsays nothing about LAN or VPN.host/hostdoes 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).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).Not tested
coop_portmapon (the proofs did not use them).This is stacked on #68 (its commits include 68's), and 68 conflicts with
maintoo, so it can only be rebased once 68 is rebased or has landed. Please rebase onto currentmainafter that. Thank you.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.
Pull request closed