com.robotsquid.squidhub 0.5.8 → 0.5.10

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.5.10
+
+**Fullscreen: the check that makes it actually work.**
+
+`Check WebGL Settings` and every build now warn when **Run In Background** is
+off. Unity WebGL pauses its main loop when the canvas loses focus, and on
+SquidHub every control the player can see — mute, fullscreen, the back link —
+belongs to the PORTAL, in the parent document. Clicking one takes focus off the
+canvas and stops the game.
+
+⚠️ **Fullscreen is where it shows, and the pause is invisible.** The portal
+fullscreens its own container, the frame gets bigger and the canvas CSS box
+grows — but the engine loop is what syncs the WebGL render target to that box.
+A paused game keeps drawing at the old resolution and is upscaled across the
+whole screen. Measured: a 2560x1290 frame still rendering a 1800x1120 target,
+unchanged after 24 seconds, correct within two seconds of a real click into the
+game. A player sees a blurry game that sharpens when they touch it, which nobody
+ever reports as a focus bug.
+
+⚠️ **A warning, not fatal.** The build runs, and a game that is genuinely
+unplayable unfocused is entitled to pause. It is the wrong default here, not an
+impossibility.
+
+**And the button only exists if you declare it.** `display.fullscreen` defaults
+to false, so the portal draws no fullscreen control at all until the manifest
+opts in — tick **Fullscreen button** in `SquidHub → Game Manifest…`. That is
+separate from this check, and both are needed.
+
+## 0.5.9
+
+**Build and Upload just uploads.** The "Upload N files (X MB)?" confirmation is
+gone. Choosing the action IS the decision, and a modal that appears after a long
+WebGL build is worse than redundant — it stops an unattended build from ever
+finishing.
+
+Nothing it said is lost, only moved. The file count, the size, the endpoint, the
+skipped OS metadata, the missing-manifest warning and the build warnings all go
+to the Console, where they can be read *during* the upload and are still there
+afterwards. A dialog is gone the moment it is dismissed, which is exactly when a
+warning stops being read.
+
+⚠️ **Refusals still stop the run.** A precompressed build or one with no
+`index.html` at its top level is a failure, not a confirmation, and the server
+would reject it anyway.
+
 ## 0.5.8
 
 **The game fills the frame, and Unity's chrome is gone.**

package/Editor/SquidHubAudit.cs

@@ -38,6 +38,7 @@ namespace SquidHub.Editor
             CheckJslib(findings);
             CheckThreads(findings);
             CheckCompression(findings);
+            CheckRunInBackground(findings);
 
             return findings;
         }
@@ -106,6 +107,41 @@ namespace SquidHub.Editor
                 "Player Settings > Publishing Settings > Compression Format to Disabled.");
         }
 
+        /// <summary>
+        /// ⚠️ Unity WebGL PAUSES ITS MAIN LOOP when the canvas loses focus, and on
+        /// this platform the canvas loses focus constantly: every control the
+        /// player can see — mute, fullscreen, the back link — belongs to the
+        /// PORTAL, in the parent document, not to the game. Clicking any of them
+        /// takes focus off the canvas and stops the game.
+        ///
+        /// ⚠️ The worst of it is fullscreen, because the pause is invisible. The
+        /// portal fullscreens its own container, the frame gets bigger, and the
+        /// canvas CSS box grows — but the engine loop is what syncs the WebGL
+        /// render target to that box, so a paused game keeps rendering at the old
+        /// resolution and is upscaled across the whole screen. Measured here: a
+        /// 2560x1290 frame still drawing a 1800x1120 target, unchanged after 24
+        /// seconds, and correct within two seconds of a real click into the game.
+        /// The player sees a blurry game that sharpens when they touch it, which
+        /// nobody reports as a focus bug.
+        ///
+        /// ⚠️ A WARNING, not fatal. The build runs, and a game that is genuinely
+        /// unplayable unfocused — a turn-based puzzle, say — is entitled to
+        /// pause. It is the wrong default here, not an impossibility.
+        /// </summary>
+        private static void CheckRunInBackground(List<Finding> findings)
+        {
+            if (PlayerSettings.runInBackground) return;
+
+            Warn(findings,
+                "Run In Background is off (Player Settings > Resolution and Presentation). " +
+                "Unity WebGL pauses when the canvas loses focus, and on SquidHub every visible " +
+                "control belongs to the portal rather than to the game — so the mute and " +
+                "fullscreen buttons stop the game as a side effect of being clicked. " +
+                "Fullscreen is the one that shows: the frame grows, the paused engine never " +
+                "resizes its render target to match, and the game is upscaled and blurry until " +
+                "the player clicks into it. Turn it on.");
+        }
+
         private static bool AllowsThreads()
         {
             var defines = PlayerSettings.GetScriptingDefineSymbols(NamedBuildTarget.WebGL);

package/Editor/SquidHubUploader.cs

@@ -85,32 +85,49 @@ namespace SquidHub.Editor
 
             var publish = SquidHubUploadSettings.PublishAfterUpload;
 
-            if (!EditorUtility.DisplayDialog("SquidHub",
-                    $"Upload {scan.Files.Count} files ({scan.TotalBytes / 1024f / 1024f:F1} MB)?" +
-                    (scan.Skipped.Count > 0
-                        ? $"\n\n{scan.Skipped.Count} OS metadata file(s) will be skipped."
-                        : "") +
-                    // ⚠️ Said before the upload, not after. A build folder with no
-                    // manifest.json declares nothing — save schema 1, no display
-                    // constraints — and the publisher cannot tell from the result.
-                    (scan.Files.Any(f => f.Path == "manifest.json")
-                        ? ""
-                        : "\n\nThere is no manifest.json in this folder, so the build declares " +
-                          "nothing: save schema 1 and no display constraints. Set one up in " +
-                          "SquidHub → Game Manifest… and rebuild.") +
-                    // ⚠️ These describe a build that uploads fine and PLAYS badly,
-                    // which is the kind nobody catches until a player does.
-                    (scan.Warnings.Count > 0 ? "\n\n" + string.Join("\n\n", scan.Warnings) : "") +
-                    (publish
-                        ? "\n\nIt will be published to players if the server allows it — that is " +
-                          "dev only. On prod, promote it in the console."
-                        : ""),
-                    "Upload", "Cancel"))
+            // ⚠️ NO CONFIRMATION. Choosing "Build and Upload" IS the decision;
+            // asking again is a modal between the publisher and the thing they
+            // just asked for, and one that appears after a long WebGL build is
+            // worse than useless — it stops an unattended build from finishing.
+            //
+            // ⚠️ Nothing is lost, only moved. Everything the dialog used to say
+            // goes to the Console, where it can be read during the upload and is
+            // still there afterwards — a dialog is gone the moment it is
+            // dismissed, which is exactly when a warning stops being read.
+            // Refusals above still stop the run; those are failures, not
+            // confirmations.
+            Report(scan, publish);
+
+            Run(Upload(scan, publish));
+        }
+
+        /// <summary>
+        /// What the dialog used to ask, said to the Console instead.
+        ///
+        /// ⚠️ Warnings are LogWarning, not Log. They describe a build that
+        /// uploads perfectly and plays badly, so they have to survive a Console
+        /// that is already full of build spam.
+        /// </summary>
+        private static void Report(BuildScan scan, bool publish)
+        {
+            Debug.Log($"[SquidHub] uploading {scan.Files.Count} file(s), " +
+                      $"{scan.TotalBytes / 1024f / 1024f:F1} MB, to {SquidHubUploadSettings.Endpoint}" +
+                      (scan.Skipped.Count > 0
+                          ? $" ({scan.Skipped.Count} OS metadata file(s) skipped)"
+                          : "") +
+                      (publish ? " — will publish on success where the server allows it (dev only)." : "."));
+
+            // ⚠️ A build folder with no manifest.json declares nothing — save
+            // schema 1, no display constraints — and nothing in the upload
+            // result would ever tell the publisher that.
+            if (!scan.Files.Any(f => f.Path == "manifest.json"))
             {
-                return;
+                Debug.LogWarning(
+                    "[SquidHub] no manifest.json in this build, so it declares nothing: save schema 1 " +
+                    "and no display constraints. Set one up in SquidHub → Game Manifest… and rebuild.");
             }
 
-            Run(Upload(scan, publish));
+            foreach (var warning in scan.Warnings) Debug.LogWarning("[SquidHub] " + warning);
         }
 
         // ⚠️ Driven by EditorApplication.update rather than blocking. Sleeping

package/README.md

@@ -144,6 +144,11 @@ an upload key is not a person — it sits in CI configs and Editor preferences.
 That asymmetry is deliberate: it is what keeps a leaked key from replacing the
 live build for everyone.
 
+⚠️ **It does not ask.** Choosing the action is the decision, so there is no
+"upload N files?" confirmation to dismiss — the file count, size, destination and
+any warnings go to the Console instead, where they survive being read. A build
+that *cannot* upload still stops with a dialog naming the fix.
+
 The upload is refused before a byte moves if the build is precompressed or has
 no `index.html` at its top level, and OS metadata is dropped rather than sent —
 which is also what makes a build pushed from Unity hash identically to the same
@@ -170,6 +175,7 @@ The package checks these for you, but for reference:
 | Setting | Value | Why |
 |---|---|---|
 | Native C/C++ Multithreading | **off** | SquidHub's default tier is not cross-origin isolated, so `SharedArrayBuffer` does not exist. A pthreads build cannot start. Ask about the isolated tier if you genuinely need threads — it carries no ads |
+| Run In Background | **on** | ⚠️ Unity WebGL pauses when the canvas loses focus, and every control on SquidHub — mute, fullscreen, back — belongs to the portal, not the game. Left off, clicking any of them stops the game; fullscreen then keeps rendering at the pre-fullscreen resolution, so the game is blurry until the player clicks into it |
 | Compression Format | **Disabled** | ⚠️ Required, and the build is refused otherwise. SquidHub stores assets uncompressed and Cloudflare compresses them at the edge, per client. A precompressed build cannot be served correctly at all |
 
 ## Things that will otherwise bite
@@ -184,6 +190,14 @@ data:`. A CDN font, a remote texture or a third-party analytics snippet is
 blocked at load and shows up as a console error, not as a missing style.
 Everything must ship inside the build.
 
+⚠️ **Fullscreen needs two things, and neither is the Unity fullscreen button.**
+Tick **Fullscreen button** in `SquidHub → Game Manifest…` — `display.fullscreen`
+defaults to false and the portal draws no control without it — and turn on **Run
+In Background**, or the game pauses the moment the player clicks that control and
+stays at the old resolution while the frame grows. The portal fullscreens its own
+container rather than asking your game to do it, so your build needs no fullscreen
+code at all; Unity's own button is hidden for you.
+
 ⚠️ **Do not write your own rotate prompt or call `screen.orientation.lock()`.**
 Declare the orientations you support in `SquidHub → Game Manifest…` and the
 portal draws the prompt outside your frame. Two prompts fight, and yours is the one the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.robotsquid.squidhub",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "displayName": "SquidHub",
   "description": "Cloud saves, analytics and the coin economy for Unity WebGL games published on SquidHub. Installs the C# wrapper, the .jslib half and the page bridge, and rewrites the exported index.html so it survives the platform's CSP.",
   "unity": "2021.3",