@nice2dev/game-engine 1.1.6 → 1.1.9

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

@@ -35,9 +35,9 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
             id: 'mp-online-intro',
             type: 'text',
             title: {
-                en: 'Online Multiplayer Architecture 🌐',
-                pl: 'Architektura multiplayera online 🌐',
-                de: 'Online-Mehrspieler-Architektur 🌐',
+                en: 'Online Multiplayer Architecture',
+                pl: 'Architektura multiplayera online',
+                de: 'Online-Mehrspieler-Architektur',
             },
             content: {
                 en: 'In this tutorial you will learn:\n• WebRTC peer-to-peer connections\n• Signaling via WebSocket\n• Creating and joining lobby rooms\n• State synchronization (snapshots)\n• Client-side prediction and reconciliation\n\nYour game will run in real-time across the internet!',
@@ -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'],
             },
@@ -202,9 +202,9 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
             id: 'mp-online-quiz',
             type: 'quiz',
             title: {
-                en: 'Multiplayer Quiz 🧠',
-                pl: 'Quiz Multiplayer 🧠',
-                de: 'Multiplayer-Quiz 🧠',
+                en: 'Multiplayer Quiz',
+                pl: 'Quiz Multiplayer',
+                de: 'Multiplayer-Quiz',
             },
             content: {
                 en: 'Why is client-side prediction important in online games?',
@@ -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',
         },
@@ -249,12 +277,12 @@ const TUTORIAL_MULTIPLAYER_ONLINE = {
             id: 'mp-online-complete',
             type: 'checkpoint',
             title: {
-                en: 'Multiplayer Online Complete! 🎉',
-                pl: 'Multiplayer online gotowy! 🎉',
-                de: 'Online-Mehrspieler fertig! 🎉',
+                en: 'Multiplayer Online Complete!',
+                pl: 'Multiplayer online gotowy!',
+                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',
             },
@@ -289,13 +317,13 @@ const TUTORIAL_PROCEDURAL_WORLD = {
             id: 'proc-intro',
             type: 'text',
             title: {
-                en: 'Procedural Generation 🌍',
-                pl: 'Generowanie proceduralne 🌍',
-                de: 'Prozedurale Generierung 🌍',
+                en: 'Procedural Generation',
+                pl: 'Generowanie proceduralne',
+                de: 'Prozedurale Generierung',
             },
             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'],
             },
@@ -431,9 +459,9 @@ const TUTORIAL_PROCEDURAL_WORLD = {
             id: 'proc-quiz',
             type: 'quiz',
             title: {
-                en: 'Procedural Generation Quiz 🎲',
-                pl: 'Quiz z generowania proceduralnego 🎲',
-                de: 'Prozedurale Generierung Quiz 🎲',
+                en: 'Procedural Generation Quiz',
+                pl: 'Quiz z generowania proceduralnego',
+                de: 'Prozedurale Generierung Quiz',
             },
             content: {
                 en: 'What makes Perlin noise better than purely random values for terrain?',
@@ -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',
         },
@@ -453,13 +505,13 @@ const TUTORIAL_PROCEDURAL_WORLD = {
             id: 'proc-complete',
             type: 'checkpoint',
             title: {
-                en: 'Procedural Generation Complete! 🌟',
-                pl: 'Generowanie proceduralne opanowane! 🌟',
-                de: 'Prozedurale Generierung fertig! 🌟',
+                en: 'Procedural Generation Complete!',
+                pl: 'Generowanie proceduralne opanowane!',
+                de: 'Prozedurale Generierung fertig!',
             },
             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',
             },
         },
@@ -493,12 +545,12 @@ const TUTORIAL_PLATFORMER = {
             id: 'plat-intro',
             type: 'text',
             title: {
-                en: 'Build a Platformer! 🏃',
-                pl: 'Zbuduj platformera! 🏃',
-                de: 'Baue einen Platformer! 🏃',
+                en: 'Build a Platformer!',
+                pl: 'Zbuduj platformera!',
+                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'],
@@ -711,12 +763,12 @@ const TUTORIAL_PLATFORMER = {
             id: 'plat-complete',
             type: 'checkpoint',
             title: {
-                en: 'Platformer Complete! 🎮',
-                pl: 'Platformer gotowy! 🎮',
-                de: 'Platformer fertig! 🎮',
+                en: 'Platformer Complete!',
+                pl: 'Platformer gotowy!',
+                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;