@energy8platform/game-engine 0.36.0 → 0.37.0

package/dist/host.esm.js

@@ -2623,6 +2623,7 @@ async function createSlotGame(opts) {
     };
     const { runRound } = await Promise.resolve().then(function () { return runRound$1; });
     const { createBalanceGate } = await Promise.resolve().then(function () { return balanceGate; });
+    const { attachSettingsStore } = await Promise.resolve().then(function () { return settingsStore; });
     const { createFreeSpinsCounter } = await Promise.resolve().then(function () { return freeSpinsCounter; });
     const { resolvePlayError } = await Promise.resolve().then(function () { return playError; });
     // slotPlay references shell via closure — define it after shell is assigned below.
@@ -2737,6 +2738,18 @@ async function createSlotGame(opts) {
         // The game may swap in its own shell (a custom renderer over the same core) via shellFactory;
         // default is the built-in Pixi shell. The host drives whichever it gets through the Shell contract.
         shell = (opts.shellFactory ?? createPixiShell)(pixiShellCfg);
+        // Opt-in, per game, and BEFORE `currentTurbo` is seeded from `shell.state.turbo` below — the
+        // restored level has to be in place by the time the host reads it, or the first spin would run
+        // at the default speed while the bar shows the remembered one. `features.turbo` is passed as the
+        // ceiling so a jurisdiction that capped turbo still wins over whatever is in storage.
+        if (opts.persistSettings) {
+            const p = opts.persistSettings === true ? {} : opts.persistSettings;
+            attachSettingsStore(shell, {
+                key: p.key ?? opts.model.spec.id,
+                storage: p.storage,
+                maxTurbo: pixiShellCfg.features.turbo,
+            });
+        }
         // Scope the bar to the slot scene: show only when a SlotSceneController scene is current
         // (hidden over the intro / non-slot scenes). Applies in BOTH base and replay modes.
         shell.setVisible(!!gameScene());
@@ -3712,6 +3725,137 @@ var sceneStart = /*#__PURE__*/Object.freeze({
     resolveStartScene: resolveStartScene
 });
 
+function settingsKey(gameId) {
+    return `e8:${gameId}:settings`;
+}
+/**
+ * `localStorage` is not reliably there and not reliably usable: Safari's private mode, a browser
+ * configured to block storage, and a full quota can all make even a READ throw. A saved turbo level
+ * is never worth failing a game boot over, so every access degrades to "no persistence".
+ */
+function resolveStorage(explicit) {
+    if (explicit !== undefined)
+        return explicit;
+    try {
+        return typeof localStorage === 'undefined' ? null : localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+/** A menu value is a boolean or a finite number — nothing else may reach the shell. */
+function isMenuValue(v) {
+    return typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v));
+}
+/**
+ * Read and VALIDATE. Whatever is in `localStorage` is player-writable — anyone can open devtools
+ * and put a string, an object, or `turbo: 99` in there. It is parsed as untrusted input: a bad
+ * field is dropped, not coerced, and a bad blob yields nothing at all.
+ */
+function readSettings(storage, key) {
+    if (!storage)
+        return {};
+    let raw;
+    try {
+        raw = storage.getItem(key);
+    }
+    catch {
+        return {};
+    }
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return {};
+    const src = parsed;
+    const out = {};
+    if (typeof src.turbo === 'number' && Number.isInteger(src.turbo) && src.turbo >= 0) {
+        out.turbo = src.turbo;
+    }
+    if (src.menu && typeof src.menu === 'object' && !Array.isArray(src.menu)) {
+        const menu = {};
+        for (const [id, value] of Object.entries(src.menu)) {
+            if (isMenuValue(value))
+                menu[id] = value;
+        }
+        if (Object.keys(menu).length)
+            out.menu = menu;
+    }
+    return out;
+}
+function writeSettings(storage, key, value) {
+    if (!storage)
+        return;
+    try {
+        storage.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        // Quota, private mode, or storage disabled mid-session. The player keeps playing; only the
+        // memory of their preference is lost, and that is not worth an error in their face.
+    }
+}
+/**
+ * Restore the stored preferences onto a freshly created shell, then keep them in step.
+ *
+ * Returns an unsubscribe function.
+ *
+ * Two things are deliberate here:
+ *
+ *  - **`maxTurbo` clamps the restored level.** `features.turbo` is the CEILING the shell offers
+ *    (`applyJurisdiction` lowers it where super-turbo or turbo is forbidden), while `state.turbo`
+ *    is what the player currently has. Restoring a saved 3 into a jurisdiction capped at 1 would
+ *    hand back exactly what the restriction took away, so the stored value is clamped, never
+ *    trusted.
+ *  - **Subscription happens AFTER restoring.** `setMenuValue` emits `settingChange`, so subscribing
+ *    first would have the restore write back what it just read. (`setTurbo` is quiet — only the
+ *    bar tap emits `turboChange` — which is why restoring the level can't echo. Do not "fix" that
+ *    asymmetry without moving this subscription.)
+ */
+function attachSettingsStore(shell, opts) {
+    const storage = resolveStorage(opts.storage);
+    const key = settingsKey(opts.key);
+    const stored = readSettings(storage, key);
+    if (stored.turbo !== undefined) {
+        shell.setTurbo(Math.min(stored.turbo, opts.maxTurbo ?? stored.turbo));
+    }
+    for (const [id, value] of Object.entries(stored.menu ?? {})) {
+        // `setMenuValue` routes presets to their own homes (sound → setSound, music/sfx → setVolume)
+        // and clamps custom ranges, so one loop covers every row and the shell owns the bounds.
+        shell.setMenuValue(id, value);
+    }
+    const live = { ...stored };
+    const flush = () => writeSettings(storage, key, live);
+    const onTurbo = (level) => {
+        live.turbo = level;
+        flush();
+    };
+    const onSetting = ({ key: id, value }) => {
+        if (!isMenuValue(value))
+            return;
+        live.menu = { ...live.menu, [id]: value };
+        flush();
+    };
+    shell.on('turboChange', onTurbo);
+    shell.on('settingChange', onSetting);
+    return () => {
+        shell.off('turboChange', onTurbo);
+        shell.off('settingChange', onSetting);
+    };
+}
+
+var settingsStore = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    attachSettingsStore: attachSettingsStore,
+    readSettings: readSettings,
+    settingsKey: settingsKey
+});
+
 function createWinReporter(paint) {
     let accepting = false;
     return {
@@ -4144,5 +4288,5 @@ var autoplay = /*#__PURE__*/Object.freeze({
     createAutoplayLoop: createAutoplayLoop
 });
 
-export { buildShellConfig, createSlotGame, createWinReporter, resolveReplayBonusId, resolveStartScene, stakeForAction };
+export { attachSettingsStore, buildShellConfig, createSlotGame, createWinReporter, readSettings, resolveReplayBonusId, resolveStartScene, settingsKey, stakeForAction };
 //# sourceMappingURL=host.esm.js.map