com.robotsquid.squidhub 0.5.7 → 0.5.8

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 0.5.8
+
+**The game fills the frame, and Unity's chrome is gone.**
+
+The portal already does the letterboxing: `game-frame.tsx` measures its box,
+clamps it to the aspect window in `manifest.json` and hands the iframe an
+element of exactly that size. Unity's Default template then rendered a fixed
+960×600 box centred inside that — letterboxing a second time, at the wrong size,
+on a white page, under a Unity logo, a build title and a second fullscreen
+button. Measured in a browser at a 1555×1290 frame: the canvas was 960×600 at
+offset (298, 326), using 29% of the area it was given.
+
+The post-build step now injects a stylesheet that fills the frame and hides
+`#unity-footer`. Verified in Chrome on a real build: the canvas fills the
+viewport exactly, no scrollbars, and the WebGL render target follows at
+3110×2580 for devicePixelRatio 2 — full resolution, not an upscale.
+
+⚠️ **The footer is HIDDEN, never removed.** The stock bootstrap assigns
+`document.querySelector("#unity-fullscreen-button").onclick` inside the promise
+that resolves the instance. Delete the element and that throws, the chain falls
+into `.catch(alert)`, and the player gets a modal dialog instead of a game.
+
+⚠️ **The loading bar stays.** The portal draws no loading UI of its own, so it
+is the only progress a player sees while a 30 MB build downloads.
+
+⚠️ **The engine splash screen is untouched.** "Made with Unity" is a licence
+term of Unity Personal and is not template chrome; this strips the template's
+own logo bar, nothing else.
+
+**Uploading an older build now warns rather than staying quiet** — one warning
+for a build with no bridge at all, another for a bridged build made before frame
+fitting. Neither refuses: both upload and register perfectly, they just play
+badly, and the fix is a rebuild. It cannot be repaired at upload time — writing
+a bridge tag for a file that is not in the folder trades the handshake for a 404.
+
 ## 0.5.7
 
 **The manifest is a form now, and a build can go out in one action.**

package/Editor/SquidHubBuildScan.cs

@@ -29,6 +29,8 @@ namespace SquidHub.Editor
         public readonly List<string> Refusals = new List<string>();
         /// <summary>OS metadata dropped. Reported, never silent.</summary>
         public readonly List<string> Skipped = new List<string>();
+        /// <summary>Things wrong with the build that do not justify refusing it.</summary>
+        public readonly List<string> Warnings = new List<string>();
         public long TotalBytes;
         public bool HasEntryPoint;
     }
@@ -111,9 +113,52 @@ namespace SquidHub.Editor
                     "Point this at the folder Unity built into, not at its parent.");
             }
 
+            InspectEntryPoint(scan);
             return scan;
         }
 
+        /// <summary>
+        /// What the exported index.html says about how it was built.
+        ///
+        /// ⚠️ WARNINGS, NEVER REFUSALS. Both of these describe a build that
+        /// uploads and registers perfectly — one just plays badly, and the other
+        /// is somebody's custom pipeline we have no business overruling from
+        /// here. The refusals above are for builds the SERVER would reject; this
+        /// is for builds the PLAYER would notice.
+        ///
+        /// ⚠️ And it cannot be fixed at upload time, which is why it only warns.
+        /// Injecting the bridge tag here would name a squidhub-bridge.js that is
+        /// not in the folder — a 404 in place of the handshake, which is worse
+        /// than the problem it set out to solve. The fix is a rebuild.
+        /// </summary>
+        private static void InspectEntryPoint(BuildScan scan)
+        {
+            var entry = scan.Files.FirstOrDefault(f => f.Path == "index.html");
+            if (entry == null) return;
+
+            string html;
+            try { html = File.ReadAllText(entry.FullPath); }
+            catch { return; }
+
+            if (html.IndexOf("squidhub-bridge.js", StringComparison.OrdinalIgnoreCase) < 0)
+            {
+                scan.Warnings.Add(
+                    "index.html does not reference squidhub-bridge.js, so this build was not made " +
+                    "with the SquidHub package installed. There is no window.SquidHub and every " +
+                    "handshake will time out. Build again with the package in the project.");
+                return;
+            }
+
+            if (html.IndexOf(SquidHubHtml.FitStyleId, StringComparison.OrdinalIgnoreCase) < 0)
+            {
+                scan.Warnings.Add(
+                    "This build predates frame fitting, so Unity's template chrome is still in it: " +
+                    "the game renders in a fixed 960x600 box centred in whatever frame the portal " +
+                    "gives it, on a white page, under a Unity logo and a second fullscreen button. " +
+                    "Rebuild to fill the frame.");
+            }
+        }
+
         private static string ToHex(byte[] bytes)
         {
             var chars = new char[bytes.Length * 2];

package/Editor/SquidHubHtml.cs

@@ -49,6 +49,66 @@ namespace SquidHub.Editor
                 "text/ecmascript", "application/ecmascript",
             };
 
+        /// <summary>Marks our stylesheet, so a reprocess can recognise its own work.</summary>
+        internal const string FitStyleId = "squidhub-fit";
+
+        /// <summary>
+        /// Makes the game fill the frame the portal gives it, and hides the
+        /// template's own chrome.
+        ///
+        /// ⚠️ THE PORTAL ALREADY DID THE LETTERBOXING. `game-frame.tsx` measures
+        /// its box, clamps it to the aspect window declared in manifest.json and
+        /// hands the iframe an element of exactly that size with black bars
+        /// around it. Unity's Default template then renders a fixed 960×600 box
+        /// centred inside that — letterboxing a second time, at the wrong size,
+        /// so a 4K monitor gets a postage stamp. Filling is not a preference
+        /// here; the frame is already the right shape.
+        ///
+        /// ⚠️ `!important` is doing real work. The template's bootstrap sets
+        /// `fullscreenContainer.style.width = "960px"` as an INLINE style, and
+        /// the Minimal template writes inline px on the canvas itself. A plain
+        /// rule loses to both.
+        ///
+        /// ⚠️ `#unity-footer` is HIDDEN, never removed. The stock bootstrap does
+        /// `document.querySelector("#unity-fullscreen-button").onclick = …`
+        /// inside the promise that resolves the instance; delete the element and
+        /// that throws, the chain falls into `.catch(alert)`, and the player gets
+        /// a modal dialog instead of a game. Hiding leaves every query answerable.
+        ///
+        /// ⚠️ The loading bar STAYS. The portal draws no loading UI of its own,
+        /// so this is the only progress a player sees while a 30 MB build
+        /// downloads — hiding it would trade a Unity logo for a black screen.
+        ///
+        /// ⚠️ An inline &lt;style&gt; is safe where an inline script is not:
+        /// gamehost sends `style-src 'self' 'unsafe-inline'` but no
+        /// `'unsafe-inline'` for scripts. That asymmetry is why this is a style
+        /// block and the bootstrap had to be hoisted to a file.
+        /// </summary>
+        private static readonly string FitStyle =
+            "<style id=\"" + FitStyleId + "\">\n" +
+            "      /* SquidHub: the portal sizes and letterboxes the frame; the game fills it. */\n" +
+            "      html, body { width: 100%; height: 100%; margin: 0; padding: 0; overflow: hidden; }\n" +
+            "      #unity-container,\n" +
+            "      #unity-container.unity-desktop,\n" +
+            "      #unity-container.unity-mobile {\n" +
+            "        position: absolute; left: 0; top: 0;\n" +
+            "        width: 100%; height: 100%; transform: none;\n" +
+            "      }\n" +
+            "      #unity-fullscreen-container {\n" +
+            "        position: absolute; left: 0; top: 0;\n" +
+            "        width: 100% !important; height: 100% !important;\n" +
+            "      }\n" +
+            "      #unity-canvas {\n" +
+            "        display: block; left: 0; top: 0;\n" +
+            "        width: 100% !important; height: 100% !important;\n" +
+            "      }\n" +
+            "      /* Unity\u0027s own logo, build title and fullscreen button. The portal\n" +
+            "         draws its own fullscreen control from display.fullscreen, and two\n" +
+            "         of them fight. Hidden rather than removed — the bootstrap still\n" +
+            "         queries the button and would throw on null. */\n" +
+            "      #unity-footer { display: none !important; }\n" +
+            "    </style>\n";
+
         public static Result Apply(string html, string bridgeFileName)
         {
             var result = new Result { Html = html };
@@ -83,7 +143,7 @@ namespace SquidHub.Editor
             });
 
             var tag = "<script src=\"" + bridgeFileName + "\"></script>";
-            result.Html = InsertBridge(rewritten, tag, result);
+            result.Html = InsertFitStyle(InsertBridge(rewritten, tag, result), result);
             result.Changed = !ReferenceEquals(result.Html, html) && result.Html != html;
             return result;
         }
@@ -98,6 +158,40 @@ namespace SquidHub.Editor
             return ExecutableTypes.Contains(value.Trim());
         }
 
+        /// <summary>
+        /// Puts the stylesheet last in &lt;head&gt;, so it follows the template's own
+        /// `TemplateData/style.css` and wins on order as well as on specificity.
+        /// </summary>
+        private static string InsertFitStyle(string html, Result result)
+        {
+            // Somebody's custom template may already carry it; do not stack a second.
+            if (html.IndexOf(FitStyleId, StringComparison.OrdinalIgnoreCase) >= 0)
+            {
+                result.Notes.Add("fit stylesheet already present — left alone");
+                return html;
+            }
+
+            var at = html.IndexOf("</head>", StringComparison.OrdinalIgnoreCase);
+            if (at >= 0)
+            {
+                result.Notes.Add("canvas set to fill the frame, Unity footer hidden");
+                return html.Substring(0, at) + "    " + FitStyle + html.Substring(at);
+            }
+
+            // ⚠️ A document with no </head> still gets it, before the first tag
+            // that could render. An unstyled page here is a game the player sees
+            // at 960×600 in the middle of a 4K frame, which reads as broken.
+            at = html.IndexOf("<body", StringComparison.OrdinalIgnoreCase);
+            if (at >= 0)
+            {
+                result.Notes.Add("no </head> — fit stylesheet injected before <body>");
+                return html.Substring(0, at) + FitStyle + html.Substring(at);
+            }
+
+            result.Notes.Add("no </head> or <body> — fit stylesheet prepended");
+            return FitStyle + html;
+        }
+
         // ⚠️ Before the FIRST script in the document, not merely before the
         // loader. installBridge() patches AudioContext.destination on the
         // instance, so it only catches contexts created after it runs — land

package/Editor/SquidHubUploader.cs

@@ -98,6 +98,9 @@ namespace SquidHub.Editor
                         : "\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."

package/README.md

@@ -68,6 +68,8 @@ Nothing to configure. On a WebGL build this package:
 2. **Writes `squidhub-bridge.js`** into the output and injects it ahead of the
    Unity loader.
 3. **Hoists every inline `<script>`** out of `index.html` into an external file.
+4. **Makes the game fill the frame** and hides Unity's own logo bar, build title
+   and fullscreen button.
 
 Step 3 is the one that matters. `squidhub-gamehost` serves
 `script-src 'self' 'wasm-unsafe-eval' blob:` with **no `'unsafe-inline'`**, and
@@ -76,6 +78,16 @@ all the markup is there, and nothing runs — the only signal is a CSP violation
 in the console. This is the single most common first-integration failure, and
 you should never see it.
 
+⚠️ **Step 4 is why your game is not a 960×600 box in the corner.** The portal
+already letterboxes — it measures its box, clamps it to the aspect window you
+declared and hands the frame an element of exactly that size. Unity's stock
+template then renders a fixed 960×600 centred inside *that*, on a white page,
+under a Unity logo and a second fullscreen button that fights the portal's own.
+The footer is hidden rather than removed, because the stock bootstrap queries
+the fullscreen button and throws on null — which surfaces as an `alert()` where
+the game should be. Your loading bar is left alone: the portal draws none, so it
+is the only progress a player sees.
+
 Then push the folder:
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.robotsquid.squidhub",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "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",