summer-engine 3.5.1 → 3.6.0

package/library/skills/multiplayer-project/files.md

@@ -22,7 +22,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -127,7 +127,7 @@ func _ready() -> void:
 	spawner = Game.build_network(self, PlayerArchetype)
 	# Connect signals like state_group_created here, before joining, or values
 	# that arrive during the join go unseen (multiplayer-movement adds them).
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -283,7 +283,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const CMD := &"courtyard.cmd"
 const MAX_PLAYERS := 8

package/library/skills/multiplayer-publish/SKILL.md

@@ -96,6 +96,15 @@ To make the same in the Export dialog:
 Both presets must include the composition; each must include its entry
 scene.
 
+The `summer_authority` custom feature is what makes the server start the
+authority. Summer starts `server.pck` with no scene argument, so the pack's
+own main scene decides what runs: `run/main_scene.summer_authority` from
+`project.godot` (`multiplayer-project`), which applies only to a pack whose
+preset carries that feature. Without it, the server runs the client's main
+scene, usually the title. It never restores the World or reports ready, and
+every online join fails with `world_start_timeout`. Local Play and the upload
+checks name the scene themselves, so they can't catch this; step 4d can.
+
 Textures: iOS and macOS read ETC2/ASTC (`textures/vram_compression/import_etc2_astc=true`
 in `project.godot`), and Windows reads S3TC/BPTC (`import_s3tc_bptc=true`).
 Enable the ones for the platforms you tick. The exporter's **Fix Import**
@@ -126,13 +135,24 @@ summer.games: Publish uploads this one file as a new Build.
 ```
 
 Check that `server.pck` and your `config/` files are listed, and that the
-"Left N server-only files" count covers your `authority/` files. Every
+"Left N server-only files" count covers your `authority/` files. The
+`Server: … mainScene …` line names the scene the Build declares, not the
+scene the pack will start; step 4d checks that. The `Exported by Summer`
+line must name a released Summer: export with the released editor from the
+download page, never a development build, and export again after you update
+Summer. Players' apps run the packs on the released Summer of that version;
+step 4e checks it. The Summer Games apps for iPhone and Android start only
+exports on their own MAJOR.MINOR, so export with the current Summer release
+(`release-readiness` check 9). Every
 result message and every export error, with its fix, is in
 [export-errors.md](export-errors.md).
 
 ## 4. Check before uploading
 
-Do all three. Each catches problems the export doesn't.
+Do all five. Each catches problems the export doesn't. Run them on the
+`.zip` you will upload, not on a pack exported separately with the server
+preset (`--export-pack`): that pack differs from the bundle's `server.pck`,
+for example it keeps `gameId`, and can pass where the upload fails.
 
 **a. Local Play passes** (`multiplayer-testing`): every process has
 `script_errors` 0, there's no `cannot attach`, and your ready lines appear.
@@ -187,12 +207,45 @@ unzip -o build/courtyard.summer.zip client.pck server.pck -d "$P/out"
 Paths must be absolute. Pass: both reports say `"sceneLoaded": true`, and
 their `compositionManifest` objects are identical. On failure the probe
 writes `rejection.json`; its codes are in [export-errors.md](export-errors.md).
+The probe names the scene to load, so it does not show which scene the
+server starts on its own.
+
+**d. The server pack starts the authority scene.** Start the bundle's
+`server.pck` the way Summer does, with no scene argument, and stop it after
+a few seconds:
+
+```sh
+perl -e 'alarm shift; exec @ARGV' 15 <summer> --headless --verbose --main-pack "$P/out/server.pck"
+```
+
+The first `Completed load for: 'res://….tscn'` line must be the authority
+scene (`res://authority/main.tscn` here). If it is the client or title
+scene, add `summer_authority` to the server preset's custom features and
+export again. Later lines may complain that there is no hosted World; that
+is expected locally.
+
+**e. The client compiles on the released Summer.** Run the bundle's
+`client.pck` with the released Summer of the version the export names (see
+`release-readiness` check 7 for how to confirm the stamp), and fail on any
+compile error:
+
+```sh
+perl -e 'alarm shift; exec @ARGV' 60 <released-summer> --headless --verbose --main-pack "$P/out/client.pck" --quit-after 600 > "$P/out/client-run.log" 2>&1
+grep -E 'SCRIPT ERROR|Parse Error|Failed to load script' "$P/out/client-run.log"
+```
+
+The grep must print nothing; the run itself exits normally even when a
+script fails. A failure here, such as `Static function "party_queue()" not
+found`, means the scripts use an API the released version lacks, usually
+because a development build made the export. Every player would see an
+empty window. Re-export with the current Summer release.
 
 ## 5. Upload the Build
 
 1. The game must exist in Summer Studio, and `gameId` in
-   `summer.build.json` and `GAME_ID` in `network/game.gd` must both be its
-   id.
+   `summer.build.json` must be its id. The export leaves `gameId` out of the
+   bundle, and the game code calls `Summer.initialize()` with no ID: a
+   literal or fallback ID fails hosted with `game_identity_mismatch`.
 2. Open the game's Builds page: `summer_open` with target `game`,
    `gameId` and section `builds`, or summerengine.com → Studio → your game →
    Builds.
@@ -209,6 +262,30 @@ writes `rejection.json`; its codes are in [export-errors.md](export-errors.md).
 For a client-only fix to an existing Build, export to a `.pck` path instead
 of `.zip`. That writes `client.pck` alone.
 
+## 6. Join it for real
+
+Right after the Build is released, open the game in a Summer Games app,
+join online and play until you are in the game, before players hear about
+the update. A wrong Game ID only fails under a real hosted launch, so
+nothing before this step catches it. Keep playing, signed in, for at least 3
+minutes: the game must not close and the player must stay signed in
+(`release-readiness` check 10). An agent can't do this; ask the user and
+record the result. The whole list of checks before a release is
+`release-readiness`, and the creator docs have it at
+https://docs.summerengine.com/publishing/release-readiness.
+
+## When online joins fail
+
+Every join ends in `world_start_timeout`, but Local Play works:
+
+1. The server starts the wrong scene: run step 4d.
+2. The game passes a fixed Game ID to `Summer.initialize`: pass none.
+
+Then export, upload and release a new Build, and join again. An empty game
+server log is not proof that the server hung: a release server holds back
+what the game prints until it exits when it isn't attached to a terminal.
+Use step 4d to see which scene runs.
+
 ## Checklist
 
 - [ ] `summer.build.json`: `gameId`, `targetPlatforms`, `server.exportPreset`, every WorldDefinition selected by a queue.
@@ -217,6 +294,10 @@ of `.zip`. That writes `client.pck` alone.
 - [ ] The export ends with `Publish uploads this one file as a new Build.`
 - [ ] The analyzer prints `ok=true` twice.
 - [ ] Both probes load their scene, with identical composition manifests.
+- [ ] The bundle's `server.pck`, run with no scene, loads the authority scene first.
+- [ ] `Exported by Summer` names a released Summer, and the bundle's `client.pck` run on that release prints no `SCRIPT ERROR`, `Parse Error` or `Failed to load script`.
+- [ ] Every `Summer.initialize` call passes no Game ID.
+- [ ] After release: a real online join reaches the game, and a signed-in player keeps playing for 3 minutes (`release-readiness` checks 2 and 10).
 - [ ] Local Play passed with the same project.
 
 ## Common mistakes
@@ -229,5 +310,9 @@ of `.zip`. That writes `client.pck` alone.
 | Ship C#, `.gdextension` or native libraries in the client | GDScript only | Summer Games runs GDScript client packs only |
 | Skip the source graph | Keep `source-domains.json` complete | Without it the server code ships to players (export warns) |
 | Load an `authority/` file from client code | Move shared code into `network/` | The export stops: the client would load a missing file |
-| Upload after only exporting | Run Local Play, the analyzer and both probes first | Each catches what the others miss |
+| Upload after only exporting | Run Local Play, the analyzer, both probes and the server start check first | Each catches what the others miss |
+| Server preset without the `summer_authority` feature | `custom_features="summer_authority"` | The hosted server starts the title and every join times out |
+| Test a server pack exported on its own | Test the `server.pck` inside the `.zip` | The separate pack keeps `gameId` and hides a wrong Game ID |
+| Export with a development build of Summer | Export with the released editor from the download page, again after every update | Players run the pack on the released Summer of the stamped version; newer APIs fail to compile and the game opens to an empty window |
+| Read an empty server log as a hang | Run step 4d | A release server holds back its output until it exits |
 | Export a patch | Export Project, or Export PCK/ZIP without Export As Patch | summer.games takes complete bundles or packs |

package/library/skills/multiplayer-publish/resource.yaml

@@ -22,6 +22,7 @@ related:
     - skill/multiplayer
     - skill/multiplayer-project
     - skill/multiplayer-testing
+    - skill/release-readiness
 source: official
 license: MIT
 status: preview

package/library/skills/multiplayer-state/SKILL.md

@@ -174,7 +174,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return

package/library/skills/multiplayer-state/files.md

@@ -33,7 +33,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -266,7 +266,7 @@ func _ready() -> void:
 	spawner.state_group_created.connect(_on_group_created)
 	spawner.entity_spawned.connect(_on_entity_spawned)
 	spawner.event_received.connect(_on_event)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -528,7 +528,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const MOTION := &"courtyard.motion"
 const CMD := &"courtyard.cmd"

package/library/skills/multiplayer-testing/SKILL.md

@@ -207,9 +207,22 @@ capture, window size) with `DisplayServer.get_name() != "headless"`.
   `Summer.client.leave()` only disconnects. `session_disconnected` fires and
   their seat is held. `session_left` arrives when the World ends; hosted, it
   arrives when Summer ends the Session.
+- **Which scene the hosted server starts.** Local Play starts the authority
+  scene by name. Summer starts the exported `server.pck` with no scene, so a
+  server preset without the `summer_authority` feature still passes here and
+  then runs the title screen hosted, where every join fails with
+  `world_start_timeout`. Run the bundle's `server.pck` with no scene
+  (`multiplayer-publish`, step 4d).
+- **A wrong Game ID.** Local Play has no hosted identity, so
+  `Summer.initialize("some-id")` passes here and fails hosted with
+  `game_identity_mismatch`. Call `Summer.initialize()` with no ID; only a
+  real online join after publishing proves it.
 - **Real devices, real accounts, real distances.** Publish to staging for that
   (`multiplayer-publish`).
 
+Before a version reaches players, run `release-readiness`: it covers these
+gaps on the `.zip` you upload.
+
 ## Checklist for any multiplayer change
 
 - [ ] Ran Local Play with at least 2 players, and once with 100 ms / 10 ms / 1 %.

package/library/skills/multiplayer-testing/resource.yaml

@@ -26,6 +26,7 @@ related:
     - skill/multiplayer-movement
     - skill/multiplayer-state
     - skill/multiplayer-publish
+    - skill/release-readiness
     - skill/summer-friends
     - skill/summer-match-results
     - skill/summer-matchmaking

package/library/skills/publish-your-game/SKILL.md

@@ -18,4 +18,6 @@ Its current text lives on the hosted Summer Engine MCP, the same text the Studio
 2. A host that shows MCP prompts or resources has it as the `publish-your-game` prompt and the resource `summer://skills/publish-your-game`.
 3. Without a store sign-in: https://docs.summerengine.com/llms.txt lists every docs page; fetch any page as .md.
 
+Before the build upload, run `release-readiness` on the exact `.zip` you upload, and report each check to the owner; a hosted game's upload checks can pass while every online join fails.
+
 The one rule to keep even before you load it: Submitting does not publish. `summer_store_submit` returns an approval link; only the owner's click sends the game to review, and review comes before live.