@nice2dev/game-engine 1.1.6 → 1.1.7

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @nice2dev/game-engine — Changelog
 
+## 1.1.7
+
+### Patch Changes
+
+- Close the three items left open in the 1.1.6 response to OmniVerk.
+
+  **Every value control works without state in the parent.** The `audit-controllable-state` gate
+  counted 87 value props that were required with no `default*`, so the control could not render from a
+  manifest without data. It now reports 0 and gates CI at `--max=0`. 48 controls gained `default*` props
+  through `useControllableState` (existing `value` + handler call sites behave as before); 33 read-only
+  data lists are optional with a stable empty default; 4 props paired with a handler only by name are
+  optional; `NiceWhiteboard` and `NiceMetricsDashboard` render an empty state until a session or
+  dashboard arrives. Additive API only — nothing renamed or removed.
+
+  - `NicePivotGrid.fields`, `NiceScheduler.events` and `NiceGitHooks.hooks` are controlled only together
+    with their change handler, as `NiceScheduler` already documented for `currentDate`/`view`. A bare
+    prop stays an initial value; prop plus handler now always wins (later prop updates used to be
+    ignored). `NiceGitHooks.onHookChange` is now called; `onHooksChange` and
+    `NiceLocaleManager.onTranslationsChange` are new.
+  - `NiceCodeEditor` / `NiceCodeDiffEditor` no longer report a value written from the prop back through
+    `onChange`, and call the latest handler rather than the one captured at mount.
+  - `NiceHtmlEditor` no longer rewrites its content on every render (React 19 compares the
+    `dangerouslySetInnerHTML` object, not its string), which moved the caret; the HTML source and
+    Markdown views can be closed again.
+  - Selections seeded once from the first item (access manager, automation/scene editors, git diff
+    viewer, ribbon, setup wizard) follow data that arrives after mount.
+  - `useControllableState`: new `fallbackValue` seed that never triggers the value/default clash warning;
+    two functional updates in one tick no longer lose the first; `onChange` is called with one argument
+    when there is no meta. `UseControllableStateOptions` is now a union type alias.
+
+  **`--nice-*` is the source of truth for design tokens.** Controls read only `--nice-*` (9,225 reads in
+  339 files). The unprefixed names (`--color-primary`, `--bg-primary`, `--text-muted`, …) stay declared
+  as aliases pointing at the Nice tokens, so reading them works, but setting them no longer repaints Nice
+  controls. Apps that relied on that can import `@nice2dev/ui/css/legacy-bg-text-aliases.css` after
+  `style.css` (removed in 1.2), or set `--nice-color-primary` and friends directly. 13 tokens that were
+  read and never declared (`--color-danger`, `--text-on-primary`, `--color-white`, …) are defined; the
+  dark blocks define the canonical names, so `.nice-dark` on `<body>` no longer leaves them on light
+  values; `--nice-primary-bg` and `--nice-selected-bg` are a primary tint instead of falling through to
+  grey. New gate `audit-token-names`.
+
+  **Node ESM and `require()`.** `@nice2dev/spatial-core` imports from plain Node ESM (51 relative
+  specifiers gained extensions, enforced by `nodenext`), and so does `@nice2dev/ui-buildings`, which
+  failed through it. `require()` works for `ui-3d`, `ui-graphics` and `game-engine`. The package-exports
+  gate now loads every entry in both module systems.
+
+  **Hygiene.** Sources are prettier-formatted and CI gates on it; 640 stale `.d.ts` files were removed
+  from source trees (never published).
+
 ## 1.1.6
 
 No changes in this release.

package/dist/cjs/core/GameConfig.js

@@ -37,13 +37,27 @@ class GameConfig {
     get settings() {
         return this._settings;
     }
-    get width() { return this._settings.width; }
-    get height() { return this._settings.height; }
-    get targetFps() { return this._settings.targetFps; }
-    get maxPlayers() { return this._settings.maxPlayers; }
-    get physics() { return this._settings.physics; }
-    get audio() { return this._settings.audio; }
-    get rendering() { return this._settings.rendering; }
+    get width() {
+        return this._settings.width;
+    }
+    get height() {
+        return this._settings.height;
+    }
+    get targetFps() {
+        return this._settings.targetFps;
+    }
+    get maxPlayers() {
+        return this._settings.maxPlayers;
+    }
+    get physics() {
+        return this._settings.physics;
+    }
+    get audio() {
+        return this._settings.audio;
+    }
+    get rendering() {
+        return this._settings.rendering;
+    }
     update(overrides) {
         this._settings = mergeSettings(this._settings, overrides);
     }

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/release/MobileExport.js

@@ -24,9 +24,24 @@ function generateServiceWorkerConfig(config) {
         strategy: config.cacheStrategy,
         precache: [config.startUrl, '/index.html', '/manifest.json'],
         runtimeCaching: [
-            { urlPattern: /\.(?:png|jpg|jpeg|webp|svg|gif)$/i, handler: 'CacheFirst', options: { cacheName: 'images', expiration: { maxEntries: 100, maxAgeSeconds: 30 * 24 * 60 * 60 } } },
-            { urlPattern: /\.(?:js|css)$/i, handler: 'StaleWhileRevalidate', options: { cacheName: 'static' } },
-            { urlPattern: /\.(?:mp3|ogg|wav)$/i, handler: 'CacheFirst', options: { cacheName: 'audio', expiration: { maxEntries: 50 } } },
+            {
+                urlPattern: /\.(?:png|jpg|jpeg|webp|svg|gif)$/i,
+                handler: 'CacheFirst',
+                options: {
+                    cacheName: 'images',
+                    expiration: { maxEntries: 100, maxAgeSeconds: 30 * 24 * 60 * 60 },
+                },
+            },
+            {
+                urlPattern: /\.(?:js|css)$/i,
+                handler: 'StaleWhileRevalidate',
+                options: { cacheName: 'static' },
+            },
+            {
+                urlPattern: /\.(?:mp3|ogg|wav)$/i,
+                handler: 'CacheFirst',
+                options: { cacheName: 'audio', expiration: { maxEntries: 50 } },
+            },
         ],
         offlineFallback: config.offlineSupport ? '/offline.html' : undefined,
     };
@@ -124,19 +139,37 @@ function createDefaultMobileLayout() {
 }
 const MOBILE_PERF_PROFILES = {
     low: {
-        tier: 'low', maxFPS: 30, renderScale: 0.5, maxParticles: 100,
-        maxAudioSources: 8, shadowQuality: 'off', postProcessing: false,
-        textureQuality: 'low', physicsBroadPhaseSize: 64,
+        tier: 'low',
+        maxFPS: 30,
+        renderScale: 0.5,
+        maxParticles: 100,
+        maxAudioSources: 8,
+        shadowQuality: 'off',
+        postProcessing: false,
+        textureQuality: 'low',
+        physicsBroadPhaseSize: 64,
     },
     medium: {
-        tier: 'medium', maxFPS: 60, renderScale: 0.75, maxParticles: 500,
-        maxAudioSources: 16, shadowQuality: 'low', postProcessing: true,
-        textureQuality: 'medium', physicsBroadPhaseSize: 128,
+        tier: 'medium',
+        maxFPS: 60,
+        renderScale: 0.75,
+        maxParticles: 500,
+        maxAudioSources: 16,
+        shadowQuality: 'low',
+        postProcessing: true,
+        textureQuality: 'medium',
+        physicsBroadPhaseSize: 128,
     },
     high: {
-        tier: 'high', maxFPS: 60, renderScale: 1, maxParticles: 2000,
-        maxAudioSources: 32, shadowQuality: 'high', postProcessing: true,
-        textureQuality: 'high', physicsBroadPhaseSize: 256,
+        tier: 'high',
+        maxFPS: 60,
+        renderScale: 1,
+        maxParticles: 2000,
+        maxAudioSources: 32,
+        shadowQuality: 'high',
+        postProcessing: true,
+        textureQuality: 'high',
+        physicsBroadPhaseSize: 256,
     },
 };
 

package/dist/cjs/tutorials/content/Tutorials_T05_T08.js

@@ -15,12 +15,12 @@ const TUTORIAL_ANIMATIONS = {
     id: 'animations-sprites-tweens',
     title: {
         en: 'Animations: Sprites, Tweens & Easing',
-        pl: 'Animacje: Sprite\'y, Tweeny i Easing',
+        pl: "Animacje: Sprite'y, Tweeny i Easing",
         de: 'Animationen: Sprites, Tweens & Easing',
     },
     description: {
         en: 'Learn to animate game objects using sprite sheets, tweens, easing functions, and state machines.',
-        pl: 'Naucz się animować obiekty za pomocą sprite sheet\'ów, tweenów, easing\'ów i maszyn stanów.',
+        pl: "Naucz się animować obiekty za pomocą sprite sheet'ów, tweenów, easing'ów i maszyn stanów.",
         de: 'Lerne, Spielobjekte mit Spritesheets, Tweens, Easing und Zustandsmaschinen zu animieren.',
     },
     category: 'game-basics',
@@ -41,8 +41,8 @@ const TUTORIAL_ANIMATIONS = {
                 de: 'Willkommen bei Animationen! 🎬',
             },
             content: {
-                en: 'In this tutorial you will learn:\n• Creating animation clips from sprite sheets\n• Using tweens for smooth movement\n• Easing functions (bounce, elastic, cubic)\n• Animation state machines\n\nLet\'s bring your game to life!',
-                pl: 'W tym tutorialu nauczysz się:\n• Tworzenia klipów animacji ze sprite sheet\'ów\n• Używania tweenów do płynnego ruchu\n• Funkcji easing (bounce, elastic, cubic)\n• Maszyn stanów animacji\n\nOżywmy Twoją grę!',
+                en: "In this tutorial you will learn:\n• Creating animation clips from sprite sheets\n• Using tweens for smooth movement\n• Easing functions (bounce, elastic, cubic)\n• Animation state machines\n\nLet's bring your game to life!",
+                pl: "W tym tutorialu nauczysz się:\n• Tworzenia klipów animacji ze sprite sheet'ów\n• Używania tweenów do płynnego ruchu\n• Funkcji easing (bounce, elastic, cubic)\n• Maszyn stanów animacji\n\nOżywmy Twoją grę!",
                 de: 'In diesem Tutorial lernst du:\n• Animationsclips aus Spritesheets erstellen\n• Tweens für flüssige Bewegungen\n• Easing-Funktionen (Bounce, Elastic, Cubic)\n• Animations-Zustandsmaschinen\n\nLass uns dein Spiel zum Leben erwecken!',
             },
             skippable: true,
@@ -59,7 +59,7 @@ const TUTORIAL_ANIMATIONS = {
             },
             content: {
                 en: 'Use `createClipFromSheet` to define an animation clip from a sprite sheet.\nParameters: name, columns in the sheet, start index, frame count, frame size, and duration per frame.',
-                pl: 'Użyj `createClipFromSheet` aby zdefiniować klip animacji ze sprite sheet\'a.\nParametry: nazwa, kolumny w arkuszu, indeks startowy, ilość klatek, rozmiar klatki i czas trwania klatki.',
+                pl: "Użyj `createClipFromSheet` aby zdefiniować klip animacji ze sprite sheet'a.\nParametry: nazwa, kolumny w arkuszu, indeks startowy, ilość klatek, rozmiar klatki i czas trwania klatki.",
                 de: 'Verwende `createClipFromSheet` um einen Animationsclip aus einem Spritesheet zu erstellen.\nParameter: Name, Spalten im Sheet, Startindex, Framezahl, Framegröße und Dauer pro Frame.',
             },
             codeTemplate: '// Create a "walk" animation clip\nconst walkClip = ',
@@ -195,7 +195,7 @@ const TUTORIAL_ANIMATIONS = {
                 de: 'Animations-Checkpoint ✅',
             },
             content: {
-                en: 'Great progress! You\'ve learned the core animation APIs. Your progress is saved.',
+                en: "Great progress! You've learned the core animation APIs. Your progress is saved.",
                 pl: 'Świetne postępy! Opanowałeś podstawowe API animacji. Twoje postępy zostały zapisane.',
                 de: 'Toller Fortschritt! Du hast die Kern-Animations-APIs gelernt. Dein Fortschritt wurde gespeichert.',
             },
@@ -251,7 +251,7 @@ const TUTORIAL_TILEMAPS = {
                 de: 'Welten mit Kacheln bauen! 🗺️',
             },
             content: {
-                en: 'Tilemaps are the foundation of 2D game worlds — platformers, RPGs, strategy games.\n\nYou will learn:\n• Creating a tilemap with layers\n• Placing and filling tiles\n• Auto-tiling (smart borders)\n• Collision detection with tiles\n• Serializing tilemaps (save/load)\n\nLet\'s build a world! 🌍',
+                en: "Tilemaps are the foundation of 2D game worlds — platformers, RPGs, strategy games.\n\nYou will learn:\n• Creating a tilemap with layers\n• Placing and filling tiles\n• Auto-tiling (smart borders)\n• Collision detection with tiles\n• Serializing tilemaps (save/load)\n\nLet's build a world! 🌍",
                 pl: 'Tilemapy to fundament świata gier 2D — platformówek, RPG, strategii.\n\nNauczysz się:\n• Tworzenia tilemapy z warstwami\n• Umieszczania i wypełniania kafelków\n• Auto-tilingu (inteligentne krawędzie)\n• Detekcji kolizji z kafelkami\n• Serializacji tilemap (zapis/odczyt)\n\nZbudujmy świat! 🌍',
                 de: 'Tilemaps sind das Fundament von 2D-Spielwelten — Platformer, RPGs, Strategiespiele.\n\nDu lernst:\n• Erstellen einer Tilemap mit Ebenen\n• Kacheln platzieren und füllen\n• Auto-Tiling (intelligente Ränder)\n• Kollisionserkennung mit Kacheln\n• Tilemaps serialisieren (Speichern/Laden)\n\nBauen wir eine Welt! 🌍',
             },
@@ -497,7 +497,7 @@ const TUTORIAL_VISUAL_SCRIPTING = {
                 de: 'Baue einen Script-Graphen',
             },
             content: {
-                en: 'A `ScriptGraph` has nodes (instances) and connections between their ports.\nLet\'s create a simple graph that moves an entity when a key is pressed.',
+                en: "A `ScriptGraph` has nodes (instances) and connections between their ports.\nLet's create a simple graph that moves an entity when a key is pressed.",
                 pl: '`ScriptGraph` zawiera węzły (instancje) i połączenia między ich portami.\nUtwórzmy prosty graf, który przesuwa encję po naciśnięciu klawisza.',
                 de: 'Ein `ScriptGraph` hat Knoten (Instanzen) und Verbindungen zwischen Ports.\nErstellen wir einen einfachen Graphen, der eine Entity bewegt, wenn eine Taste gedrückt wird.',
             },
@@ -527,9 +527,26 @@ const TUTORIAL_VISUAL_SCRIPTING = {
                 de: 'Was steuert ein "flow"-Port in Visual Scripting?',
             },
             quizOptions: [
-                { id: 'a', text: { en: 'The color of the node', pl: 'Kolor węzła', de: 'Die Farbe des Knotens' } },
-                { id: 'b', text: { en: 'The execution order (which node runs next)', pl: 'Kolejność wykonania (który węzeł uruchomić dalej)', de: 'Die Ausführungsreihenfolge (welcher Knoten als nächstes läuft)' } },
-                { id: 'c', text: { en: 'The animation speed', pl: 'Prędkość animacji', de: 'Die Animationsgeschwindigkeit' } },
+                {
+                    id: 'a',
+                    text: { en: 'The color of the node', pl: 'Kolor węzła', de: 'Die Farbe des Knotens' },
+                },
+                {
+                    id: 'b',
+                    text: {
+                        en: 'The execution order (which node runs next)',
+                        pl: 'Kolejność wykonania (który węzeł uruchomić dalej)',
+                        de: 'Die Ausführungsreihenfolge (welcher Knoten als nächstes läuft)',
+                    },
+                },
+                {
+                    id: 'c',
+                    text: {
+                        en: 'The animation speed',
+                        pl: 'Prędkość animacji',
+                        de: 'Die Animationsgeschwindigkeit',
+                    },
+                },
                 { id: 'd', text: { en: 'The sound volume', pl: 'Głośność dźwięku', de: 'Die Lautstärke' } },
             ],
             quizCorrectId: 'b',
@@ -544,7 +561,7 @@ const TUTORIAL_VISUAL_SCRIPTING = {
                 de: 'Starte den Graphen! 🚀',
             },
             content: {
-                en: 'The `GraphExecutor` takes a node library and a script graph, then executes it each frame.\nConnect it to the engine\'s update loop.',
+                en: "The `GraphExecutor` takes a node library and a script graph, then executes it each frame.\nConnect it to the engine's update loop.",
                 pl: '`GraphExecutor` przyjmuje bibliotekę węzłów i graf, a następnie wykonuje go co klatkę.\nPodłącz go do pętli update silnika.',
                 de: 'Der `GraphExecutor` nimmt eine Knoten-Bibliothek und einen Graphen und führt ihn pro Frame aus.\nVerbinde ihn mit der Update-Schleife der Engine.',
             },
@@ -569,7 +586,7 @@ const TUTORIAL_VISUAL_SCRIPTING = {
                 de: 'Probiere es! Verbinde Knoten',
             },
             content: {
-                en: 'In the editor, try dragging a connection from one node\'s output port to another node\'s input port.\nThe wire turns green when compatible ports are connected!',
+                en: "In the editor, try dragging a connection from one node's output port to another node's input port.\nThe wire turns green when compatible ports are connected!",
                 pl: 'W edytorze spróbuj przeciągnąć połączenie z portu wyjściowego jednego węzła na port wejściowy drugiego.\nPrzewód zmienia kolor na zielony gdy porty są kompatybilne!',
                 de: 'Im Editor: Ziehe eine Verbindung vom Ausgang eines Knotens zum Eingang eines anderen.\nDie Leitung wird grün, wenn kompatible Ports verbunden sind!',
             },
@@ -626,7 +643,7 @@ const TUTORIAL_LOCAL_MULTIPLAYER = {
                 de: 'Zusammen spielen! 🎮🎮',
             },
             content: {
-                en: 'Local multiplayer lets friends play together on the same screen!\n\nYou will learn:\n• `PlayerManager` — managing up to 12 players\n• Gamepad input for each player\n• Split-screen viewports\n• Drop-in / drop-out\n\nGrab some controllers and let\'s go! 🕹️',
+                en: "Local multiplayer lets friends play together on the same screen!\n\nYou will learn:\n• `PlayerManager` — managing up to 12 players\n• Gamepad input for each player\n• Split-screen viewports\n• Drop-in / drop-out\n\nGrab some controllers and let's go! 🕹️",
                 pl: 'Multiplayer lokalny pozwala znajomym grać razem na jednym ekranie!\n\nNauczysz się:\n• `PlayerManager` — zarządzanie do 12 graczy\n• Wejście z gamepada dla każdego gracza\n• Podzielony ekran (split-screen)\n• Dynamiczne dołączanie/odłączanie graczy\n\nWeź kontrolery i zaczynamy! 🕹️',
                 de: 'Lokaler Multiplayer lässt Freunde zusammen auf einem Bildschirm spielen!\n\nDu lernst:\n• `PlayerManager` — bis zu 12 Spieler verwalten\n• Gamepad-Eingabe für jeden Spieler\n• Splitscreen-Ansichten\n• Drop-in / Drop-out\n\nSchnappt euch Controller und los! 🕹️',
             },
@@ -769,8 +786,8 @@ const TUTORIAL_LOCAL_MULTIPLAYER = {
                 pl: 'Spraw, aby gamepady zaczęły wibrować przy zdarzeniach jak obrażenia czy eksplozje, używając metody `vibrate`.',
                 de: 'Lass Gamepads bei Events wie Schaden oder Explosionen vibrieren mit der `vibrate`-Methode.',
             },
-            codeTemplate: '// Vibrate a player\'s gamepad\n',
-            codeSolution: '// Vibrate player 1\'s gamepad for 200ms\nengine.input.vibrate(\n  1,      // player index\n  200,    // duration (ms)\n  0.5,    // weak motor magnitude (0-1)\n  1.0     // strong motor magnitude (0-1)\n);',
+            codeTemplate: "// Vibrate a player's gamepad\n",
+            codeSolution: "// Vibrate player 1's gamepad for 200ms\nengine.input.vibrate(\n  1,      // player index\n  200,    // duration (ms)\n  0.5,    // weak motor magnitude (0-1)\n  1.0     // strong motor magnitude (0-1)\n);",
             codeValidation: {
                 containsAll: ['vibrate'],
             },

package/dist/cjs/tutorials/content/Tutorials_T09_T11.js

@@ -162,7 +162,7 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
                 de: 'Verwende `SnapshotBuffer` zum Speichern von Spielzustand-Snapshots für Interpolation. Der Host sendet Snapshots, Clients interpolieren dazwischen.',
             },
             codeTemplate: '// Create snapshot buffer\nconst snapshots = ',
-            codeSolution: "const snapshots = new SnapshotBuffer(60);\n\n// Host creates and broadcasts snapshots\nconst snapshot = {\n  tick: net.tick,\n  timestamp: performance.now(),\n  states: new Map(),\n};\nsnapshots.push(snapshot);\n\n// Client interpolates\nconst pair = snapshots.getInterpolationPair(serverTime);\nif (pair) {\n  const [a, b] = pair;\n  const t = (serverTime - a.timestamp) / (b.timestamp - a.timestamp);\n  // interpolateState(stateA, stateB, t)\n}",
+            codeSolution: 'const snapshots = new SnapshotBuffer(60);\n\n// Host creates and broadcasts snapshots\nconst snapshot = {\n  tick: net.tick,\n  timestamp: performance.now(),\n  states: new Map(),\n};\nsnapshots.push(snapshot);\n\n// Client interpolates\nconst pair = snapshots.getInterpolationPair(serverTime);\nif (pair) {\n  const [a, b] = pair;\n  const t = (serverTime - a.timestamp) / (b.timestamp - a.timestamp);\n  // interpolateState(stateA, stateB, t)\n}',
             codeValidation: {
                 containsAll: ['SnapshotBuffer', 'push', 'getInterpolationPair'],
             },
@@ -187,7 +187,7 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
                 de: 'Verwende `ClientPrediction` zum Speichern lokaler Eingaben und Abgleich nach Server-Bestätigung. Dies eliminiert Input-Lag für den lokalen Spieler.',
             },
             codeTemplate: '// Set up prediction\nconst prediction = ',
-            codeSolution: "const prediction = new ClientPrediction();\n\n// Every frame: record local input + simulated result\nprediction.addInput({\n  tick: net.tick,\n  inputActions: { moveRight: true, jump: false },\n  resultPosition: { x: player.x + 5, y: player.y },\n});\n\n// When server confirms a tick:\nprediction.acknowledge(serverTick);\n\n// Replay unconfirmed inputs after correction\nconst pending = prediction.getPendingInputs();",
+            codeSolution: 'const prediction = new ClientPrediction();\n\n// Every frame: record local input + simulated result\nprediction.addInput({\n  tick: net.tick,\n  inputActions: { moveRight: true, jump: false },\n  resultPosition: { x: player.x + 5, y: player.y },\n});\n\n// When server confirms a tick:\nprediction.acknowledge(serverTick);\n\n// Replay unconfirmed inputs after correction\nconst pending = prediction.getPendingInputs();',
             codeValidation: {
                 containsAll: ['ClientPrediction', 'addInput', 'acknowledge'],
             },
@@ -212,10 +212,38 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
                 de: 'Warum ist clientseitige Vorhersage in Online-Spielen wichtig?',
             },
             quizOptions: [
-                { id: 'a', text: { en: 'To reduce server load', pl: 'Aby zmniejszyć obciążenie serwera', de: 'Um die Serverlast zu reduzieren' } },
-                { id: 'b', text: { en: 'To eliminate perceived input lag', pl: 'Aby wyeliminować odczuwane opóźnienie inputu', de: 'Um wahrgenommene Eingabeverzögerung zu eliminieren' } },
-                { id: 'c', text: { en: 'To improve graphics', pl: 'Aby poprawić grafikę', de: 'Um die Grafik zu verbessern' } },
-                { id: 'd', text: { en: 'To save bandwidth', pl: 'Aby oszczędzić transfer', de: 'Um Bandbreite zu sparen' } },
+                {
+                    id: 'a',
+                    text: {
+                        en: 'To reduce server load',
+                        pl: 'Aby zmniejszyć obciążenie serwera',
+                        de: 'Um die Serverlast zu reduzieren',
+                    },
+                },
+                {
+                    id: 'b',
+                    text: {
+                        en: 'To eliminate perceived input lag',
+                        pl: 'Aby wyeliminować odczuwane opóźnienie inputu',
+                        de: 'Um wahrgenommene Eingabeverzögerung zu eliminieren',
+                    },
+                },
+                {
+                    id: 'c',
+                    text: {
+                        en: 'To improve graphics',
+                        pl: 'Aby poprawić grafikę',
+                        de: 'Um die Grafik zu verbessern',
+                    },
+                },
+                {
+                    id: 'd',
+                    text: {
+                        en: 'To save bandwidth',
+                        pl: 'Aby oszczędzić transfer',
+                        de: 'Um Bandbreite zu sparen',
+                    },
+                },
             ],
             quizCorrectId: 'b',
         },
@@ -254,7 +282,7 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
                 de: 'Online-Mehrspieler fertig! 🎉',
             },
             content: {
-                en: 'You\'ve learned how to build networked multiplayer games! You can now:\n• Connect peers via WebRTC\n• Create and manage lobby rooms\n• Synchronize game state with snapshots\n• Implement client-side prediction\n• Spawn/destroy entities across the network',
+                en: "You've learned how to build networked multiplayer games! You can now:\n• Connect peers via WebRTC\n• Create and manage lobby rooms\n• Synchronize game state with snapshots\n• Implement client-side prediction\n• Spawn/destroy entities across the network",
                 pl: 'Nauczyłeś się budować gry multiplayer online! Teraz potrafisz:\n• Łączyć peerów przez WebRTC\n• Tworzyć i zarządzać pokojami lobby\n• Synchronizować stan gry snapshotami\n• Implementować predykcję po stronie klienta\n• Tworzyć/niszczyć encje w sieci',
                 de: 'Du hast gelernt, vernetzte Multiplayer-Spiele zu bauen! Du kannst jetzt:\n• Peers über WebRTC verbinden\n• Lobby-Räume erstellen und verwalten\n• Spielzustand mit Snapshots synchronisieren\n• Clientseitige Vorhersage implementieren\n• Entities über das Netzwerk spawnen/zerstören',
             },
@@ -295,7 +323,7 @@ const TUTORIAL_PROCEDURAL_WORLD = {
             },
             content: {
                 en: 'Procedural generation creates content using algorithms instead of manual design.\n\nYou will learn:\n• Seeded random numbers (reproducible worlds)\n• Perlin noise (natural-looking terrain)\n• Enemy wave scaling\n• Loot tables with weighted drops\n• Procedural pixel art sprites',
-                pl: 'Generowanie proceduralne tworzy zawartość za pomocą algorytmów zamiast ręcznego projektowania.\n\nNauczysz się:\n• Losowość z seedem (odtwarzalne światy)\n• Szum Perlina (naturalnie wyglądający teren)\n• Skalowanie fal wrogów\n• Tabele łupów z ważonymi dropami\n• Proceduralne pikselo-artowe sprite\'y',
+                pl: "Generowanie proceduralne tworzy zawartość za pomocą algorytmów zamiast ręcznego projektowania.\n\nNauczysz się:\n• Losowość z seedem (odtwarzalne światy)\n• Szum Perlina (naturalnie wyglądający teren)\n• Skalowanie fal wrogów\n• Tabele łupów z ważonymi dropami\n• Proceduralne pikselo-artowe sprite'y",
                 de: 'Prozedurale Generierung erstellt Inhalte mit Algorithmen statt manueller Gestaltung.\n\nDu lernst:\n• Zufallszahlen mit Seed (reproduzierbare Welten)\n• Perlin-Noise (natürlich aussehende Landschaft)\n• Feindwellen-Skalierung\n• Loot-Tabellen mit gewichteten Drops\n• Prozedurale Pixel-Art-Sprites',
             },
             skippable: true,
@@ -341,7 +369,7 @@ const TUTORIAL_PROCEDURAL_WORLD = {
                 de: '`PerlinNoise` erzeugt glatte, natürlich aussehende Werte. Verwende `noise2D(x, y)` für Heightmaps und `fbm()` für detaillierte Landschaften.',
             },
             codeTemplate: '// Generate a height map\nconst noise = ',
-            codeSolution: "const noise = new PerlinNoise(42);\n\n// Generate a 64x64 terrain\nfor (let y = 0; y < 64; y++) {\n  for (let x = 0; x < 64; x++) {\n    // noise2D returns -1 to 1 — scale to 0-1\n    const height = (noise.noise2D(x * 0.05, y * 0.05) + 1) * 0.5;\n\n    // Use fbm for more detail (4 octaves)\n    const detail = noise.fbm(x * 0.1, y * 0.1, 4);\n\n    // Map to tile type\n    if (height < 0.3) { /* water */ }\n    else if (height < 0.6) { /* grass */ }\n    else { /* mountain */ }\n  }\n}",
+            codeSolution: 'const noise = new PerlinNoise(42);\n\n// Generate a 64x64 terrain\nfor (let y = 0; y < 64; y++) {\n  for (let x = 0; x < 64; x++) {\n    // noise2D returns -1 to 1 — scale to 0-1\n    const height = (noise.noise2D(x * 0.05, y * 0.05) + 1) * 0.5;\n\n    // Use fbm for more detail (4 octaves)\n    const detail = noise.fbm(x * 0.1, y * 0.1, 4);\n\n    // Map to tile type\n    if (height < 0.3) { /* water */ }\n    else if (height < 0.6) { /* grass */ }\n    else { /* mountain */ }\n  }\n}',
             codeValidation: {
                 containsAll: ['PerlinNoise', 'noise2D'],
             },
@@ -407,7 +435,7 @@ const TUTORIAL_PROCEDURAL_WORLD = {
             type: 'code',
             title: {
                 en: 'Generate Pixel Art Sprites',
-                pl: 'Generuj pikselo-artowe sprite\'y',
+                pl: "Generuj pikselo-artowe sprite'y",
                 de: 'Pixel-Art-Sprites generieren',
             },
             content: {
@@ -416,7 +444,7 @@ const TUTORIAL_PROCEDURAL_WORLD = {
                 de: '`ProceduralSprite` generiert symmetrische Pixel-Art aus einer Palette. Jeder Seed ergibt einen einzigartigen Charakter!',
             },
             codeTemplate: '// Generate a procedural sprite\nconst sprite = ',
-            codeSolution: "const sprite = new ProceduralSprite(8, 8, [\n  { r: 0.2, g: 0.5, b: 1, a: 1 },  // blue\n  { r: 0.8, g: 0.2, b: 0.3, a: 1 }, // red\n  { r: 0.9, g: 0.9, b: 0.1, a: 1 }, // yellow\n]);\n\n// Generate with seed\nconst pixels = sprite.generate(42);\n// Each seed = unique character sprite!",
+            codeSolution: 'const sprite = new ProceduralSprite(8, 8, [\n  { r: 0.2, g: 0.5, b: 1, a: 1 },  // blue\n  { r: 0.8, g: 0.2, b: 0.3, a: 1 }, // red\n  { r: 0.9, g: 0.9, b: 0.1, a: 1 }, // yellow\n]);\n\n// Generate with seed\nconst pixels = sprite.generate(42);\n// Each seed = unique character sprite!',
             codeValidation: {
                 containsAll: ['ProceduralSprite', 'generate'],
             },
@@ -441,10 +469,34 @@ const TUTORIAL_PROCEDURAL_WORLD = {
                 de: 'Was macht Perlin-Noise besser als rein zufällige Werte für Terrain?',
             },
             quizOptions: [
-                { id: 'a', text: { en: 'It\'s faster to compute', pl: 'Jest szybszy do obliczenia', de: 'Es ist schneller zu berechnen' } },
-                { id: 'b', text: { en: 'It produces smooth, continuous gradients', pl: 'Produkuje gładkie, ciągłe gradienty', de: 'Es erzeugt glatte, kontinuierliche Gradienten' } },
-                { id: 'c', text: { en: 'It uses less memory', pl: 'Zużywa mniej pamięci', de: 'Es verbraucht weniger Speicher' } },
-                { id: 'd', text: { en: 'It\'s more random', pl: 'Jest bardziej losowy', de: 'Es ist zufälliger' } },
+                {
+                    id: 'a',
+                    text: {
+                        en: "It's faster to compute",
+                        pl: 'Jest szybszy do obliczenia',
+                        de: 'Es ist schneller zu berechnen',
+                    },
+                },
+                {
+                    id: 'b',
+                    text: {
+                        en: 'It produces smooth, continuous gradients',
+                        pl: 'Produkuje gładkie, ciągłe gradienty',
+                        de: 'Es erzeugt glatte, kontinuierliche Gradienten',
+                    },
+                },
+                {
+                    id: 'c',
+                    text: {
+                        en: 'It uses less memory',
+                        pl: 'Zużywa mniej pamięci',
+                        de: 'Es verbraucht weniger Speicher',
+                    },
+                },
+                {
+                    id: 'd',
+                    text: { en: "It's more random", pl: 'Jest bardziej losowy', de: 'Es ist zufälliger' },
+                },
             ],
             quizCorrectId: 'b',
         },
@@ -459,7 +511,7 @@ const TUTORIAL_PROCEDURAL_WORLD = {
             },
             content: {
                 en: 'You can now generate infinite, unique games! Skills learned:\n• Seeded random for reproducible worlds\n• Perlin noise for natural terrain\n• Wave scaling for enemy difficulty\n• Loot tables for balanced drops\n• Procedural pixel art sprites',
-                pl: 'Teraz możesz generować nieskończone, unikalne gry! Umiejętności:\n• Losowość z seedem dla odtwarzalnych światów\n• Szum Perlina dla naturalnego terenu\n• Skalowanie fal dla trudności wrogów\n• Tabele łupów dla zbalansowanych dropów\n• Proceduralne pikselo-artowe sprite\'y',
+                pl: "Teraz możesz generować nieskończone, unikalne gry! Umiejętności:\n• Losowość z seedem dla odtwarzalnych światów\n• Szum Perlina dla naturalnego terenu\n• Skalowanie fal dla trudności wrogów\n• Tabele łupów dla zbalansowanych dropów\n• Proceduralne pikselo-artowe sprite'y",
                 de: 'Du kannst jetzt unendliche, einzigartige Spiele generieren! Gelernte Fähigkeiten:\n• Seed-Zufall für reproduzierbare Welten\n• Perlin-Noise für natürliches Terrain\n• Wellen-Skalierung für Feind-Schwierigkeit\n• Loot-Tabellen für ausgewogene Drops\n• Prozedurale Pixel-Art-Sprites',
             },
         },
@@ -498,7 +550,7 @@ const TUTORIAL_PLATFORMER = {
                 de: 'Baue einen Platformer! 🏃',
             },
             content: {
-                en: 'In this tutorial you\'ll build a complete platformer game!\n\n• Player movement & acceleration\n• Jumping with coyote time\n• Double-jump & wall-slide\n• Dash mechanic\n• Enemy AI (patrol + chase)\n• Coins & collectibles\n• Level with tilemap\n\nLet\'s make Mario-like magic!',
+                en: "In this tutorial you'll build a complete platformer game!\n\n• Player movement & acceleration\n• Jumping with coyote time\n• Double-jump & wall-slide\n• Dash mechanic\n• Enemy AI (patrol + chase)\n• Coins & collectibles\n• Level with tilemap\n\nLet's make Mario-like magic!",
                 pl: 'W tym tutorialu zbudujesz kompletną grę platformową!\n\n• Ruch gracza i przyspieszenie\n• Skakanie z coyote time\n• Podwójny skok i wall-slide\n• Mechanika dashu\n• AI wrogów (patrol + pościg)\n• Monety i zbieranie\n• Poziom z tilemapy\n\nZróbmy magię jak Mario!',
                 de: 'In diesem Tutorial baust du ein komplettes Plattformspiel!\n\n• Spielerbewegung & Beschleunigung\n• Springen mit Coyote-Time\n• Doppelsprung & Wall-Slide\n• Dash-Mechanik\n• Feind-KI (Patrouille + Verfolgung)\n• Münzen & Sammelobjekte\n• Level mit Tilemap\n\nLass uns Mario-Magie machen!',
             },
@@ -519,7 +571,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Skonfiguruj encję gracza z komponentami Transform, Sprite, Collider2D i RigidBody2D.',
                 de: 'Erstelle die Spieler-Entity mit Transform, Sprite, Collider2D und RigidBody2D Komponenten.',
             },
-            codeTemplate: "// Create the player\nconst player = world.createEntity();\n",
+            codeTemplate: '// Create the player\nconst player = world.createEntity();\n',
             codeSolution: "const player = world.createEntity();\nworld.addComponent(player, 'Transform', { x: 100, y: 300, scaleX: 1, scaleY: 1, rotation: 0 });\nworld.addComponent(player, 'Sprite', { textureId: 'player', width: 32, height: 32 });\nworld.addComponent(player, 'Collider2D', { type: 'aabb', width: 28, height: 30, offsetX: 2, offsetY: 2, isTrigger: false });\nworld.addComponent(player, 'RigidBody2D', {\n  velocityX: 0, velocityY: 0,\n  mass: 1, gravityScale: 1,\n  isKinematic: false, restitution: 0,\n});",
             codeValidation: {
                 containsAll: ['createEntity', 'Transform', 'Collider2D', 'RigidBody2D'],
@@ -544,7 +596,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Ruch w platformerze używa przyspieszenia i hamowania dla płynnego wrażenia. Sprawdź akcje `moveRight` i `moveLeft` i przyłóż prędkość.',
                 de: 'Platformer-Bewegung nutzt Beschleunigung und Verzögerung für ein flüssiges Gefühl. Prüfe `moveRight` und `moveLeft` Aktionen und wende Geschwindigkeit an.',
             },
-            codeTemplate: "// Movement system\nconst MOVE_SPEED = 200;\nconst ACCEL = 800;\nconst FRICTION = 600;\n",
+            codeTemplate: '// Movement system\nconst MOVE_SPEED = 200;\nconst ACCEL = 800;\nconst FRICTION = 600;\n',
             codeSolution: "const MOVE_SPEED = 200;\nconst ACCEL = 800;\nconst FRICTION = 600;\n\nfunction updateMovement(input: InputManager, rb: any, dt: number) {\n  let moveDir = 0;\n  if (input.getAction('moveRight')) moveDir += 1;\n  if (input.getAction('moveLeft')) moveDir -= 1;\n\n  if (moveDir !== 0) {\n    // Accelerate toward target speed\n    rb.velocityX += moveDir * ACCEL * dt;\n    // Clamp to max speed\n    if (Math.abs(rb.velocityX) > MOVE_SPEED) {\n      rb.velocityX = Math.sign(rb.velocityX) * MOVE_SPEED;\n    }\n  } else {\n    // Apply friction\n    if (Math.abs(rb.velocityX) > FRICTION * dt) {\n      rb.velocityX -= Math.sign(rb.velocityX) * FRICTION * dt;\n    } else {\n      rb.velocityX = 0;\n    }\n  }\n}",
             codeValidation: {
                 containsAll: ['ACCEL', 'FRICTION', 'velocityX', 'getAction'],
@@ -569,7 +621,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Coyote time pozwala graczowi skoczyć chwilę po opuszczeniu platformy — co sprawia, że gra jest bardziej wybaczalna. Śledź czas ostatniego kontaktu z podłożem.',
                 de: 'Coyote-Time erlaubt dem Spieler kurz nach Verlassen einer Plattform zu springen — das Spiel fühlt sich nachsichtiger an. Verfolge die letzte Bodenberührungs-Zeit.',
             },
-            codeTemplate: "// Jump system with coyote time\nconst JUMP_FORCE = -350;\nconst COYOTE_TIME = 0.1; // 100ms grace period\n",
+            codeTemplate: '// Jump system with coyote time\nconst JUMP_FORCE = -350;\nconst COYOTE_TIME = 0.1; // 100ms grace period\n',
             codeSolution: "const JUMP_FORCE = -350;\nconst COYOTE_TIME = 0.1; // 100ms grace period\nlet lastGroundedTime = 0;\nlet hasJumped = false;\n\nfunction updateJump(input: InputManager, rb: any, isGrounded: boolean, time: number) {\n  if (isGrounded) {\n    lastGroundedTime = time;\n    hasJumped = false;\n  }\n\n  const canJump = !hasJumped && (time - lastGroundedTime) < COYOTE_TIME;\n\n  if (input.getAction('jump') && canJump) {\n    rb.velocityY = JUMP_FORCE;\n    hasJumped = true;\n  }\n\n  // Variable jump height — release early = lower jump\n  if (!input.getAction('jump') && rb.velocityY < 0) {\n    rb.velocityY *= 0.5;\n  }\n}",
             codeValidation: {
                 containsAll: ['COYOTE_TIME', 'JUMP_FORCE', 'lastGroundedTime', 'canJump'],
@@ -594,7 +646,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Dodaj dodatkowy skok w powietrzu (podwójny skok) i pozwól graczowi powoli zsuwać się po ścianach gdy ich dotyka.',
                 de: 'Füge einen zusätzlichen Sprung in der Luft (Doppelsprung) hinzu und lass den Spieler langsam an Wänden herunterrutschen.',
             },
-            codeTemplate: "// Double jump + wall slide\nconst MAX_AIR_JUMPS = 1;\nconst WALL_SLIDE_SPEED = 50;\n",
+            codeTemplate: '// Double jump + wall slide\nconst MAX_AIR_JUMPS = 1;\nconst WALL_SLIDE_SPEED = 50;\n',
             codeSolution: "const MAX_AIR_JUMPS = 1;\nconst WALL_SLIDE_SPEED = 50;\nlet airJumpsLeft = MAX_AIR_JUMPS;\n\nfunction updateAirMoves(input: InputManager, rb: any, isGrounded: boolean, isTouchingWall: boolean) {\n  if (isGrounded) {\n    airJumpsLeft = MAX_AIR_JUMPS;\n  }\n\n  // Double jump (only when not grounded)\n  if (input.getAction('jump') && !isGrounded && airJumpsLeft > 0) {\n    rb.velocityY = JUMP_FORCE;\n    airJumpsLeft--;\n  }\n\n  // Wall slide — slow down fall when touching wall\n  if (isTouchingWall && !isGrounded && rb.velocityY > 0) {\n    rb.velocityY = Math.min(rb.velocityY, WALL_SLIDE_SPEED);\n  }\n}",
             codeValidation: {
                 containsAll: ['MAX_AIR_JUMPS', 'WALL_SLIDE_SPEED', 'airJumpsLeft'],
@@ -619,7 +671,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Dash daje graczowi nagły przypływ prędkości w aktualnym kierunku. Dodaj cooldown, żeby nie spamować.',
                 de: 'Ein Dash gibt dem Spieler einen Geschwindigkeitsschub in die aktuelle Richtung. Füge einen Cooldown hinzu.',
             },
-            codeTemplate: "// Dash system\nconst DASH_SPEED = 500;\nconst DASH_DURATION = 0.15;\nconst DASH_COOLDOWN = 0.5;\n",
+            codeTemplate: '// Dash system\nconst DASH_SPEED = 500;\nconst DASH_DURATION = 0.15;\nconst DASH_COOLDOWN = 0.5;\n',
             codeSolution: "const DASH_SPEED = 500;\nconst DASH_DURATION = 0.15;\nconst DASH_COOLDOWN = 0.5;\nlet dashTimer = 0;\nlet dashCooldown = 0;\nlet dashDir = 1;\n\nfunction updateDash(input: InputManager, rb: any, dt: number, facingRight: boolean) {\n  dashCooldown = Math.max(0, dashCooldown - dt);\n\n  if (input.getAction('dash') && dashCooldown <= 0 && dashTimer <= 0) {\n    dashTimer = DASH_DURATION;\n    dashCooldown = DASH_COOLDOWN;\n    dashDir = facingRight ? 1 : -1;\n  }\n\n  if (dashTimer > 0) {\n    dashTimer -= dt;\n    rb.velocityX = DASH_SPEED * dashDir;\n    rb.velocityY = 0; // freeze vertical during dash\n  }\n}",
             codeValidation: {
                 containsAll: ['DASH_SPEED', 'DASH_COOLDOWN', 'dashTimer'],
@@ -644,7 +696,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Utwórz wrogów patrolujących między dwoma punktami. Gdy gracz się zbliży, przechodzą w tryb pościgu!',
                 de: 'Erstelle Feinde, die zwischen zwei Punkten patrouillieren. Wenn der Spieler nah kommt, wechseln sie in den Verfolgungsmodus!',
             },
-            codeTemplate: "// Enemy patrol + chase AI\nconst PATROL_SPEED = 60;\nconst CHASE_SPEED = 120;\nconst DETECT_RANGE = 150;\n",
+            codeTemplate: '// Enemy patrol + chase AI\nconst PATROL_SPEED = 60;\nconst CHASE_SPEED = 120;\nconst DETECT_RANGE = 150;\n',
             codeSolution: "const PATROL_SPEED = 60;\nconst CHASE_SPEED = 120;\nconst DETECT_RANGE = 150;\n\nfunction updateEnemy(enemy: any, playerPos: any, dt: number) {\n  const dx = playerPos.x - enemy.x;\n  const dy = playerPos.y - enemy.y;\n  const dist = Math.sqrt(dx * dx + dy * dy);\n\n  if (dist < DETECT_RANGE) {\n    // Chase mode — move toward player\n    const dir = dx > 0 ? 1 : -1;\n    enemy.velocityX = CHASE_SPEED * dir;\n    enemy.state = 'chase';\n  } else {\n    // Patrol mode — walk between patrolLeft and patrolRight\n    if (enemy.x <= enemy.patrolLeft) enemy.patrolDir = 1;\n    if (enemy.x >= enemy.patrolRight) enemy.patrolDir = -1;\n    enemy.velocityX = PATROL_SPEED * enemy.patrolDir;\n    enemy.state = 'patrol';\n  }\n}",
             codeValidation: {
                 containsAll: ['PATROL_SPEED', 'CHASE_SPEED', 'DETECT_RANGE'],
@@ -676,7 +728,7 @@ const TUTORIAL_PLATFORMER = {
                 containsAll: ['createEntity', 'isTrigger', 'destroyEntity'],
             },
             hint: {
-                en: 'Set isTrigger: true on coins so they don\'t push the player',
+                en: "Set isTrigger: true on coins so they don't push the player",
                 pl: 'Ustaw isTrigger: true na monetach, aby nie odpychały gracza',
                 de: 'Setze isTrigger: true auf Münzen, damit sie den Spieler nicht wegstoßen',
             },
@@ -695,7 +747,7 @@ const TUTORIAL_PLATFORMER = {
                 pl: 'Użyj `Tilemap` do zbudowania poziomu. Zdefiniuj podłoże, platformy i ściany z kafelków.',
                 de: 'Verwende eine `Tilemap` um das Level zu bauen. Definiere Boden, Plattformen und Wände mit Kacheln.',
             },
-            codeTemplate: "// Create the level tilemap\nconst level = new Tilemap(20, 15, 32);\n",
+            codeTemplate: '// Create the level tilemap\nconst level = new Tilemap(20, 15, 32);\n',
             codeSolution: "const level = new Tilemap(20, 15, 32);\n\n// Add a ground layer\nlevel.addLayer('ground', 20, 15);\n\n// Fill the ground row\nlevel.fillRect('ground', 0, 14, 20, 1, 1); // bottom row = solid\n\n// Add some platforms\nlevel.setTile('ground', 5, 10, 1);  // floating block\nlevel.setTile('ground', 6, 10, 1);\nlevel.setTile('ground', 7, 10, 1);\n\nlevel.fillRect('ground', 12, 8, 4, 1, 1); // higher platform\n\n// Check collisions with tilemap\nconst isSolid = level.isSolid(5, 14); // true — ground!",
             codeValidation: {
                 containsAll: ['Tilemap', 'addLayer', 'fillRect'],
@@ -716,7 +768,7 @@ const TUTORIAL_PLATFORMER = {
                 de: 'Platformer fertig! 🎮',
             },
             content: {
-                en: 'Congratulations! You\'ve built a complete platformer with:\n• Smooth acceleration-based movement\n• Jumping with coyote time\n• Double jump & wall slide\n• Dash mechanic\n• Enemy AI (patrol & chase)\n• Coins with trigger colliders\n• Tilemap level design\n\nChallenge: Add moving platforms and a boss fight!',
+                en: "Congratulations! You've built a complete platformer with:\n• Smooth acceleration-based movement\n• Jumping with coyote time\n• Double jump & wall slide\n• Dash mechanic\n• Enemy AI (patrol & chase)\n• Coins with trigger colliders\n• Tilemap level design\n\nChallenge: Add moving platforms and a boss fight!",
                 pl: 'Gratulacje! Zbudowałeś kompletnego platformera z:\n• Płynny ruch z przyspieszeniem\n• Skakanie z coyote time\n• Podwójny skok i wall-slide\n• Mechanika dashu\n• AI wrogów (patrol i pościg)\n• Monety z trigger koliderami\n• Design poziomu z tilemapy\n\nWyzwanie: Dodaj ruchome platformy i walkę z bossem!',
                 de: 'Herzlichen Glückwunsch! Du hast einen kompletten Platformer gebaut mit:\n• Flüssige beschleunigungsbasierte Bewegung\n• Springen mit Coyote-Time\n• Doppelsprung & Wall-Slide\n• Dash-Mechanik\n• Feind-KI (Patrouille & Verfolgung)\n• Münzen mit Trigger-Kollidern\n• Tilemap Level-Design\n\nHerausforderung: Füge bewegliche Plattformen und einen Bosskampf hinzu!',
             },
@@ -727,11 +779,7 @@ const TUTORIAL_PLATFORMER = {
    Convenience export
    ══════════════════════════════════════════════════════════════ */
 function getTutorials_T09_T11() {
-    return [
-        TUTORIAL_MULTIPLAYER_ONLINE,
-        TUTORIAL_PROCEDURAL_WORLD,
-        TUTORIAL_PLATFORMER,
-    ];
+    return [TUTORIAL_MULTIPLAYER_ONLINE, TUTORIAL_PROCEDURAL_WORLD, TUTORIAL_PLATFORMER];
 }
 
 exports.TUTORIAL_MULTIPLAYER_ONLINE = TUTORIAL_MULTIPLAYER_ONLINE;