@hypersocial/cli-games 0.2.0 → 0.2.2

package/dist/index.js

@@ -623,8 +623,8 @@ var TILE_BG_COLORS = {
 };
 function run2048Game(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 36;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 36;
+  const MIN_ROWS2 = 16;
   const GRID_SIZE = 4;
   const TILE_WIDTH = 8;
   const TILE_HEIGHT = 3;
@@ -688,7 +688,7 @@ function run2048Game(terminal) {
   function addScorePopup2(x, y, text, color = "\x1B[1;33m") {
     scorePopups.push({ x, y, text, frames: 20, color });
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -812,13 +812,13 @@ function run2048Game(terminal) {
     if (anyMoved) {
       score += totalMergeScore;
       if (totalMergeScore > 0) {
-        triggerShake2(4, 1);
+        triggerShake3(4, 1);
       }
       spawnTile();
       if (!won && !continuedAfterWin && has2048()) {
         won = true;
         if (score > highScore) highScore = score;
-        triggerShake2(8, 2);
+        triggerShake3(8, 2);
         for (let y = 0; y < GRID_SIZE; y++) {
           for (let x = 0; x < GRID_SIZE; x++) {
             if (grid[y][x] === 2048) {
@@ -904,12 +904,12 @@ function run2048Game(terminal) {
     if (shakeFrames > 0) shakeFrames--;
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = needWidth && needHeight ? "Make pane larger" : needWidth ? "Make pane wider ->" : "Make pane taller v";
-      const msg2 = `Need: ${MIN_COLS}x${MIN_ROWS}  Have: ${cols}x${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}x${MIN_ROWS2}  Have: ${cols}x${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -1221,8 +1221,8 @@ function run2048Game(terminal) {
 // src/games/asteroids/index.ts
 function runAsteroidsGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 35;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 35;
+  const MIN_ROWS2 = 16;
   let GAME_WIDTH = 30;
   let GAME_HEIGHT = 12;
   const SHIP_TURN_SPEED = 0.2;
@@ -1320,7 +1320,7 @@ function runAsteroidsGame(terminal) {
     if (value >= max) return value - max;
     return value;
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -1357,7 +1357,7 @@ function runAsteroidsGame(terminal) {
     if (invincibilityFrames > 0) return;
     lives--;
     spawnParticles3(ship.x, ship.y, 15, "\x1B[91m");
-    triggerShake2(10, 3);
+    triggerShake3(10, 3);
     if (lives <= 0) {
       gameOver = true;
       if (score > highScore) highScore = score;
@@ -1438,7 +1438,7 @@ function runAsteroidsGame(terminal) {
           bullets.splice(j, 1);
           splitAsteroid(ast);
           asteroids.splice(i, 1);
-          triggerShake2(4, 1);
+          triggerShake3(4, 1);
           break;
         }
       }
@@ -1468,9 +1468,9 @@ function runAsteroidsGame(terminal) {
     if (shakeFrames > 0) shakeFrames--;
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg = "Terminal too small!";
-      const need = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const need = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       output += `\x1B[${Math.floor(rows / 2)};${Math.max(1, Math.floor((cols - msg.length) / 2))}H${themeColor}${msg}\x1B[0m`;
       output += `\x1B[${Math.floor(rows / 2) + 2};${Math.max(1, Math.floor((cols - need.length) / 2))}H\x1B[2m${need}\x1B[0m`;
       terminal.write(output);
@@ -1661,8 +1661,8 @@ function runAsteroidsGame(terminal) {
 // src/games/breakout/index.ts
 function runBreakoutGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 18;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 18;
   const GAME_WIDTH = 46;
   const GAME_HEIGHT = 20;
   const PADDLE_WIDTH_NORMAL = 7;
@@ -1731,7 +1731,7 @@ function runBreakoutGame(terminal) {
   function addScorePopup2(x, y, text, color = "\x1B[1;33m") {
     scorePopups.push({ x, y, text, frames: 18, color });
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -1788,7 +1788,7 @@ function runBreakoutGame(terminal) {
     powerUps.push({ x, y, type: types[Math.floor(Math.random() * types.length)], vy: 0.15 });
   }
   function applyPowerUp(type) {
-    triggerShake2(8, 2);
+    triggerShake3(8, 2);
     borderFlash = 15;
     switch (type) {
       case "multiball": {
@@ -1964,7 +1964,7 @@ function runBreakoutGame(terminal) {
             const totalPts = basePts + comboBonus;
             score += totalPts;
             const intensity = Math.min(comboCount, 8);
-            triggerShake2(3 + intensity, 1 + Math.floor(intensity / 3));
+            triggerShake3(3 + intensity, 1 + Math.floor(intensity / 3));
             spawnParticles3(brick.x + brick.width / 2, brick.y, 6 + intensity, brickColors[brick.type]);
             addScorePopup2(brick.x + 1, brick.y - 1, comboCount > 1 ? `+${totalPts}!` : `+${totalPts}`, brickColors[brick.type]);
             spawnPowerUp(brick.x + brick.width / 2, brick.y);
@@ -1982,12 +1982,12 @@ function runBreakoutGame(terminal) {
       if (lives <= 0) {
         gameOver = true;
         if (score > highScore) highScore = score;
-        triggerShake2(20, 4);
+        triggerShake3(20, 4);
         spawnParticles3(paddleX, GAME_HEIGHT - 2, 15, "\x1B[1;91m", ["\u2717", "\u2620", "\xD7", "\u2593"]);
       } else {
         ballAttached = true;
         balls = [{ x: paddleX, y: GAME_HEIGHT - 3, vx: 0, vy: 0, active: true }];
-        triggerShake2(10, 2);
+        triggerShake3(10, 2);
       }
     }
     const aliveBricks = bricks.filter((b) => b.alive);
@@ -1996,7 +1996,7 @@ function runBreakoutGame(terminal) {
       gameOver = true;
       level++;
       if (score > highScore) highScore = score;
-      triggerShake2(12, 2);
+      triggerShake3(12, 2);
       for (let i = 0; i < 5; i++) setTimeout(() => spawnParticles3(Math.random() * GAME_WIDTH, Math.random() * GAME_HEIGHT / 2, 15, brickColors[Math.floor(Math.random() * brickColors.length)], ["\u2605", "\u2726", "\u25C6", "\u25CF", "\u2727"]), i * 100);
     }
   }
@@ -2005,11 +2005,11 @@ function runBreakoutGame(terminal) {
     if (shakeFrames > 0) shakeFrames--;
     if (borderFlash > 0) borderFlash--;
     const cols = terminal.cols, rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needW = cols < MIN_COLS, needH = rows < MIN_ROWS;
+      const needW = cols < MIN_COLS2, needH = rows < MIN_ROWS2;
       const hint2 = needW && needH ? "Make pane larger" : needW ? "Make pane wider \u2192" : "Make pane taller \u2193";
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const cX = Math.floor(cols / 2), cY = Math.floor(rows / 2);
       output += `\x1B[${cY - 1};${Math.max(1, cX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
       output += `\x1B[${cY + 1};${Math.max(1, cX - Math.floor(msg2.length / 2))}H\x1B[2m${msg2}\x1B[0m`;
@@ -2571,8 +2571,8 @@ var ROPE_RETRACT_SPEED = 0.15;
 var ROPE_FAST_RETRACT_SPEED = 0.3;
 function runCourierGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 16;
   let running = true;
   let gameStarted = false;
   let gameOver = false;
@@ -3201,8 +3201,8 @@ function runCourierGame(terminal) {
     output += "\x1B[2J\x1B[H";
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
-      const msg = `Need ${MIN_COLS}\xD7${MIN_ROWS}, have ${cols}\xD7${rows}`;
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
+      const msg = `Need ${MIN_COLS2}\xD7${MIN_ROWS2}, have ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY};${Math.max(1, centerX - msg.length / 2)}H${themeColor}${msg}\x1B[0m`;
@@ -3961,8 +3961,8 @@ var LOG_MESSAGES = {
 };
 function runCrackGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 16;
   let cols = terminal.cols;
   let rows = terminal.rows;
   const updateDimensions = () => {
@@ -4174,9 +4174,9 @@ function runCrackGame(terminal) {
   function render() {
     let output = "";
     output += "\x1B[2J\x1B[H";
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const msg2 = `Need: ${MIN_COLS}x${MIN_ROWS}  Have: ${cols}x${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}x${MIN_ROWS2}  Have: ${cols}x${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -4629,8 +4629,8 @@ function runCrackGame(terminal) {
 // src/games/frogger/index.ts
 function runFroggerGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 16;
   const LILY_PAD_COUNT = 5;
   const TIME_LIMIT = 45;
   const MOVE_COOLDOWN = 100;
@@ -5015,10 +5015,10 @@ function runFroggerGame(terminal) {
     output += "\x1B[2J\x1B[H";
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
-      const hint2 = cols < MIN_COLS && rows < MIN_ROWS ? "Make pane larger" : cols < MIN_COLS ? "Make pane wider \u2192" : "Make pane taller \u2193";
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
+      const hint2 = cols < MIN_COLS2 && rows < MIN_ROWS2 ? "Make pane larger" : cols < MIN_COLS2 ? "Make pane wider \u2192" : "Make pane taller \u2193";
       const cx = Math.floor(cols / 2);
       const cy = Math.floor(rows / 2);
       output += `\x1B[${cy - 1};${Math.max(1, cx - msg1.length / 2)}H${themeColor}${msg1}\x1B[0m`;
@@ -5456,8 +5456,8 @@ var HANGMAN_STAGES = [
 function runHangmanGame(terminal) {
   const themeColor = getCurrentThemeColor();
   const GAME_WIDTH = 40;
-  const MIN_COLS = 32;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 32;
+  const MIN_ROWS2 = 16;
   let running = true;
   let gameStarted = false;
   let gameOver = false;
@@ -5621,10 +5621,10 @@ function runHangmanGame(terminal) {
     }
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = "";
       if (needWidth && needHeight) {
         hint2 = "Make pane larger";
@@ -5633,7 +5633,7 @@ function runHangmanGame(terminal) {
       } else {
         hint2 = "Make pane taller \u2193";
       }
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -5988,7 +5988,7 @@ function runMinesweeperGame(terminal) {
   function addScorePopup2(x, y, text, color = "\x1B[1;33m") {
     scorePopups.push({ x, y, text, frames: 20, color });
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -6075,7 +6075,7 @@ function runMinesweeperGame(terminal) {
     if (cell.isMine) {
       gameOver = true;
       won = false;
-      triggerShake2(25, 4);
+      triggerShake3(25, 4);
       spawnExplosion(x * 2 + 1, y);
       addScorePopup2(x * 2, y - 1, "MALWARE!", "\x1B[1;91m");
       revealAllMines();
@@ -6124,7 +6124,7 @@ function runMinesweeperGame(terminal) {
     if (cellsRevealed >= totalNonMines) {
       gameOver = true;
       won = true;
-      triggerShake2(10, 2);
+      triggerShake3(10, 2);
       for (let i = 0; i < 5; i++) {
         const x = Math.floor(Math.random() * difficulty.width);
         const y = Math.floor(Math.random() * difficulty.height);
@@ -6522,8 +6522,8 @@ function runMinesweeperGame(terminal) {
 // src/games/pong/index.ts
 function runPongGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 16;
   const getGameDimensions = () => {
     const cols = terminal.cols;
     const rows = terminal.rows;
@@ -6663,10 +6663,10 @@ function runPongGame(terminal) {
     }
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = "";
       if (needWidth && needHeight) {
         hint2 = "Make pane larger";
@@ -6675,7 +6675,7 @@ function runPongGame(terminal) {
       } else {
         hint2 = "Make pane taller \u2193";
       }
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX2 = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX2 - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -7111,8 +7111,8 @@ function runRunnerGame(terminal) {
   const GAME_WIDTH = ROAD_WIDTH_BOTTOM + SCENERY_WIDTH * 2;
   let gameTop = 5;
   let gameLeft = 4;
-  const MIN_COLS = GAME_WIDTH + 2;
-  const MIN_ROWS = TRACK_HEIGHT + 8;
+  const MIN_COLS2 = GAME_WIDTH + 2;
+  const MIN_ROWS2 = TRACK_HEIGHT + 8;
   let running = true;
   let gameStarted = false;
   let gameOver = false;
@@ -7343,12 +7343,12 @@ function runRunnerGame(terminal) {
     }
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = needWidth && needHeight ? "Make pane larger" : needWidth ? "Make pane wider \u2192" : "Make pane taller \u2193";
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX2 = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX2 - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -7875,8 +7875,8 @@ function runRunnerGame(terminal) {
 // src/games/simon/index.ts
 function runSimonGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 18;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 18;
   const GAME_WIDTH = 40;
   const GAME_HEIGHT = 18;
   const QUADRANT_COLORS = [
@@ -7990,7 +7990,7 @@ function runSimonGame(terminal) {
   function addScorePopup2(x, y, text, color = "\x1B[1;33m") {
     scorePopups.push({ x, y, text, frames: 20, color });
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -8052,7 +8052,7 @@ function runSimonGame(terminal) {
         statusMessage = "PATTERN ACCEPTED";
         statusColor = "\x1B[1;92m";
         statusBlink = true;
-        triggerShake2(6, 1);
+        triggerShake3(6, 1);
       }
     } else {
       phase = "failure";
@@ -8064,7 +8064,7 @@ function runSimonGame(terminal) {
       statusMessage = "ACCESS DENIED";
       statusColor = "\x1B[1;91m";
       statusBlink = true;
-      triggerShake2(15, 3);
+      triggerShake3(15, 3);
       const centerX = GAME_WIDTH / 2;
       const centerY = GAME_HEIGHT / 2;
       spawnParticles3(centerX, centerY, 15, "\x1B[1;91m", ["\u2717", "\u2716", "\xD7", "\u2573"]);
@@ -8190,12 +8190,12 @@ function runSimonGame(terminal) {
     if (shakeFrames > 0) shakeFrames--;
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       const hint2 = needWidth && needHeight ? "Make pane larger" : needWidth ? "Make pane wider \u2192" : "Make pane taller \u2193";
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       outputParts.push(`\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`);
@@ -8457,8 +8457,8 @@ function runSimonGame(terminal) {
 // src/games/snake/index.ts
 function runSnakeGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 36;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 36;
+  const MIN_ROWS2 = 16;
   let cols = terminal.cols;
   let rows = terminal.rows;
   let gameTop = 6;
@@ -8561,7 +8561,7 @@ function runSnakeGame(terminal) {
       });
     }
   }
-  function updateParticles3() {
+  function updateParticles4() {
     for (let i = particles.length - 1; i >= 0; i--) {
       const p = particles[i];
       p.x += p.vx;
@@ -8586,7 +8586,7 @@ function runSnakeGame(terminal) {
       scorePopup.y -= 0.3;
       if (scorePopup.frames <= 0) scorePopup = null;
     }
-    updateParticles3();
+    updateParticles4();
     let renderGameLeft = gameLeft;
     let renderGameTop = gameTop;
     if (shakeFrames > 0) {
@@ -8595,10 +8595,10 @@ function runSnakeGame(terminal) {
       renderGameLeft = Math.max(1, gameLeft + shakeX);
       renderGameTop = Math.max(3, gameTop + shakeY);
     }
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = "";
       if (needWidth && needHeight) {
         hint2 = "Make pane larger";
@@ -8607,7 +8607,7 @@ function runSnakeGame(terminal) {
       } else {
         hint2 = "Make pane taller \u2193";
       }
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -8929,8 +8929,8 @@ function runSnakeGame(terminal) {
 // src/games/spaceinvaders/index.ts
 function runSpaceInvadersGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 16;
   const getGameDimensions = () => {
     const cols = terminal.cols;
     const rows = terminal.rows;
@@ -9108,10 +9108,10 @@ function runSpaceInvadersGame(terminal) {
     }
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = "";
       if (needWidth && needHeight) {
         hint2 = "Make pane larger";
@@ -9120,7 +9120,7 @@ function runSpaceInvadersGame(terminal) {
       } else {
         hint2 = "Make pane taller \u2193";
       }
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -9593,13 +9593,13 @@ function runTetrisGame(terminal) {
   const themeColor = getCurrentThemeColor();
   const BOARD_WIDTH = 12;
   const BOARD_HEIGHT = 20;
-  const SIDE_PANEL_WIDTH = 14;
+  const SIDE_PANEL_WIDTH2 = 14;
   const BOARD_ONLY_WIDTH = BOARD_WIDTH * 2 + 2;
-  const TOTAL_WIDTH = BOARD_WIDTH * 2 + SIDE_PANEL_WIDTH + 4;
-  const TICK_MS = 25;
+  const TOTAL_WIDTH = BOARD_WIDTH * 2 + SIDE_PANEL_WIDTH2 + 4;
+  const TICK_MS2 = 25;
   const SPRINT_TARGET_LINES = 40;
-  const MIN_COLS = BOARD_ONLY_WIDTH + 2;
-  const MIN_ROWS = BOARD_HEIGHT + 3;
+  const MIN_COLS2 = BOARD_ONLY_WIDTH + 2;
+  const MIN_ROWS2 = BOARD_HEIGHT + 3;
   const MIN_ROWS_WITH_TITLE = BOARD_HEIGHT + 4;
   let running = true;
   let gameStarted = false;
@@ -9682,7 +9682,7 @@ function runTetrisGame(terminal) {
     const shape = TETROMINOES[currentPiece][0];
     pieceX = Math.floor((BOARD_WIDTH - shape[0].length) / 2);
     pieceY = 0;
-    if (!isValidPosition(pieceX, pieceY, currentRotation)) {
+    if (!isValidPosition2(pieceX, pieceY, currentRotation)) {
       gameOver = true;
       if (score > highScore) highScore = score;
     }
@@ -9691,7 +9691,7 @@ function runTetrisGame(terminal) {
     const rotations = TETROMINOES[currentPiece];
     return rotations[rotation % rotations.length];
   }
-  function isValidPosition(x, y, rotation) {
+  function isValidPosition2(x, y, rotation) {
     const shape = TETROMINOES[currentPiece][rotation % TETROMINOES[currentPiece].length];
     for (let row = 0; row < shape.length; row++) {
       for (let col = 0; col < shape[row].length; col++) {
@@ -9808,23 +9808,23 @@ function runTetrisGame(terminal) {
     }
   }
   function moveLeft() {
-    if (isValidPosition(pieceX - 1, pieceY, currentRotation)) {
+    if (isValidPosition2(pieceX - 1, pieceY, currentRotation)) {
       pieceX--;
     }
   }
   function moveRight() {
-    if (isValidPosition(pieceX + 1, pieceY, currentRotation)) {
+    if (isValidPosition2(pieceX + 1, pieceY, currentRotation)) {
       pieceX++;
     }
   }
   function moveDown() {
-    if (isValidPosition(pieceX, pieceY + 1, currentRotation)) {
+    if (isValidPosition2(pieceX, pieceY + 1, currentRotation)) {
       pieceY++;
       return true;
     }
     return false;
   }
-  function hardDrop() {
+  function hardDrop2() {
     if (hardDropping) return;
     if (hardDropConsumed) return;
     hardDropping = true;
@@ -9832,13 +9832,13 @@ function runTetrisGame(terminal) {
   }
   function rotate() {
     const newRotation = (currentRotation + 1) % TETROMINOES[currentPiece].length;
-    if (isValidPosition(pieceX, pieceY, newRotation)) {
+    if (isValidPosition2(pieceX, pieceY, newRotation)) {
       currentRotation = newRotation;
       return;
     }
     const kicks = [-1, 1, -2, 2];
     for (const kick of kicks) {
-      if (isValidPosition(pieceX + kick, pieceY, newRotation)) {
+      if (isValidPosition2(pieceX + kick, pieceY, newRotation)) {
         pieceX += kick;
         currentRotation = newRotation;
         return;
@@ -9850,10 +9850,10 @@ function runTetrisGame(terminal) {
     output += "\x1B[2J\x1B[H";
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint = "";
       if (needWidth && needHeight) {
         hint = "Make pane larger";
@@ -9862,7 +9862,7 @@ function runTetrisGame(terminal) {
       } else {
         hint = "Make pane taller \u2193";
       }
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -9996,7 +9996,7 @@ function runTetrisGame(terminal) {
         }
       }
       let ghostY = pieceY;
-      while (isValidPosition(pieceX, ghostY + 1, currentRotation)) {
+      while (isValidPosition2(pieceX, ghostY + 1, currentRotation)) {
         ghostY++;
       }
       if (ghostY !== pieceY) {
@@ -10096,7 +10096,7 @@ function runTetrisGame(terminal) {
       return;
     }
     dropCounter++;
-    if (dropCounter * TICK_MS >= dropInterval) {
+    if (dropCounter * TICK_MS2 >= dropInterval) {
       dropCounter = 0;
       if (!moveDown()) {
         lockPiece();
@@ -10127,14 +10127,14 @@ function runTetrisGame(terminal) {
         return;
       }
       render();
-    }, TICK_MS);
+    }, TICK_MS2);
     const gameInterval = setInterval(() => {
       if (!running) {
         clearInterval(gameInterval);
         return;
       }
       update();
-    }, TICK_MS);
+    }, TICK_MS2);
     const handleKeyUp = (e) => {
       if (e.key === " ") {
         hardDropConsumed = false;
@@ -10271,7 +10271,7 @@ function runTetrisGame(terminal) {
           rotate();
           break;
         case " ":
-          hardDrop();
+          hardDrop2();
           break;
       }
     });
@@ -10306,8 +10306,8 @@ var BLOCK_COLORS = [
 ];
 function runTowerGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 30;
-  const MIN_ROWS = 16;
+  const MIN_COLS2 = 30;
+  const MIN_ROWS2 = 16;
   const INITIAL_BLOCK_WIDTH = 8;
   const MIN_BLOCK_WIDTH = 2;
   const PERFECT_THRESHOLD = 0.5;
@@ -10386,7 +10386,7 @@ function runTowerGame(terminal) {
   function addScorePopup2(x, y, text, color = "\x1B[1;33m") {
     scorePopups.push({ x, y, text, frames: 24, color });
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -10447,7 +10447,7 @@ function runTowerGame(terminal) {
       if (score > highScore) highScore = score;
       if (perfectCombo > maxCombo) maxCombo = perfectCombo;
       spawnParticles3(dropX + dropWidth / 2, landY, 15, "\x1B[91m");
-      triggerShake2(10, 3);
+      triggerShake3(10, 3);
       return;
     }
     const isPerfect = Math.abs(dropLeft - topLeft) < PERFECT_THRESHOLD && Math.abs(dropRight - topRight) < PERFECT_THRESHOLD;
@@ -10465,7 +10465,7 @@ function runTowerGame(terminal) {
         popupText,
         perfectCombo > 3 ? "\x1B[1;91m" : "\x1B[1;93m"
       );
-      triggerShake2(4, 1);
+      triggerShake3(4, 1);
     } else {
       if (perfectCombo > maxCombo) maxCombo = perfectCombo;
       perfectCombo = 0;
@@ -10479,7 +10479,7 @@ function runTowerGame(terminal) {
         spawnFallingPiece(topRight, landY, overhangWidth, dropColor);
         spawnParticles3(topRight + overhangWidth / 2, landY, 5, dropColor);
       }
-      triggerShake2(3, 1);
+      triggerShake3(3, 1);
     }
     score += points;
     height++;
@@ -10547,12 +10547,12 @@ function runTowerGame(terminal) {
     if (shakeFrames > 0) shakeFrames--;
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       const hint2 = needWidth && needHeight ? "Make pane larger" : needWidth ? "Make pane wider \u2192" : "Make pane taller \u2193";
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -10797,8 +10797,8 @@ function runTowerGame(terminal) {
 // src/games/tron/index.ts
 function runTronGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 40;
-  const MIN_ROWS = 18;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 18;
   const GAME_WIDTH = 46;
   const GAME_HEIGHT = 18;
   const ROUNDS_TO_WIN = 3;
@@ -10867,9 +10867,9 @@ function runTronGame(terminal) {
   }
   function spawnExplosion(x, y, color) {
     spawnParticles3(x, y, 20, color, ["\u2717", "\xD7", "\u2591", "\u2592", "\u2593", "\u2588"]);
-    triggerShake2(12, 3);
+    triggerShake3(12, 3);
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -11084,7 +11084,7 @@ function runTronGame(terminal) {
           arenaMinY += SHRINK_AMOUNT;
           arenaMaxY -= SHRINK_AMOUNT;
         }
-        triggerShake2(4, 1);
+        triggerShake3(4, 1);
       }
     }
   }
@@ -11151,12 +11151,12 @@ function runTronGame(terminal) {
     if (shakeFrames > 0) shakeFrames--;
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       const hint2 = needWidth && needHeight ? "Make pane larger" : needWidth ? "Make pane wider \u2192" : "Make pane taller \u2193";
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -11245,7 +11245,7 @@ function runTronGame(terminal) {
       const nextMsg = "Press SPACE for next round";
       const nextX = gameLeft + Math.floor((GAME_WIDTH - nextMsg.length) / 2) + 1;
       output += `\x1B[${msgY + 2};${nextX}H\x1B[2m${themeColor}${nextMsg}\x1B[0m`;
-      output = renderParticles(output, renderLeft, renderTop);
+      output = renderParticles2(output, renderLeft, renderTop);
     } else if (gameOver) {
       output = renderTrailsAndCycles(output, renderLeft, renderTop);
       const overColor = playerWins >= ROUNDS_TO_WIN ? "\x1B[1;92m" : "\x1B[1;91m";
@@ -11259,7 +11259,7 @@ function runTronGame(terminal) {
       const restart = "\u255A [R] RESTART  [Q] QUIT \u255D";
       const restartX = gameLeft + Math.floor((GAME_WIDTH - restart.length) / 2) + 1;
       output += `\x1B[${overY + 2};${restartX}H\x1B[2m${themeColor}${restart}\x1B[0m`;
-      output = renderParticles(output, renderLeft, renderTop);
+      output = renderParticles2(output, renderLeft, renderTop);
     } else {
       for (const pos of player.trail) {
         if (pos.x > arenaMinX && pos.x < arenaMaxX && pos.y > arenaMinY && pos.y < arenaMaxY) {
@@ -11277,7 +11277,7 @@ function runTronGame(terminal) {
       if (ai.alive) {
         output += `\x1B[${renderTop + 1 + ai.y};${renderLeft + 1 + ai.x}H\x1B[1m${ai.color}${ai.char}\x1B[0m`;
       }
-      output = renderParticles(output, renderLeft, renderTop);
+      output = renderParticles2(output, renderLeft, renderTop);
     }
     const hint = gameStarted && !gameOver && !paused ? `SPEED: ${Math.round((1 - gameSpeed / BASE_SPEED) * 100) + 100}%  [ ESC ] MENU` : "";
     const hintX = Math.floor((cols - hint.length) / 2);
@@ -11299,7 +11299,7 @@ function runTronGame(terminal) {
     }
     return output;
   }
-  function renderParticles(output, renderLeft, renderTop) {
+  function renderParticles2(output, renderLeft, renderTop) {
     for (const p of particles) {
       const screenX = Math.round(renderLeft + 1 + p.x);
       const screenY = Math.round(renderTop + 1 + p.y);
@@ -11634,8 +11634,8 @@ var SENTENCES = [
 function runTypingTest(terminal) {
   const themeColor = getCurrentThemeColor();
   const GAME_WIDTH = 60;
-  const MIN_COLS = 40;
-  const MIN_ROWS = 18;
+  const MIN_COLS2 = 40;
+  const MIN_ROWS2 = 18;
   let running = true;
   let gameStarted = false;
   let gameOver = false;
@@ -11834,10 +11834,10 @@ function runTypingTest(terminal) {
     }
     const cols = terminal.cols;
     const rows = terminal.rows;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint2 = "";
       if (needWidth && needHeight) {
         hint2 = "Make pane larger";
@@ -11846,7 +11846,7 @@ function runTypingTest(terminal) {
       } else {
         hint2 = "Make pane taller \u2193";
       }
-      const msg2 = `Need: ${MIN_COLS}\xD7${MIN_ROWS}  Have: ${cols}\xD7${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}\xD7${MIN_ROWS2}  Have: ${cols}\xD7${rows}`;
       const centerX = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -12491,8 +12491,8 @@ var WORDS2 = [
 ];
 function runWordleGame(terminal) {
   const themeColor = getCurrentThemeColor();
-  const MIN_COLS = 36;
-  const MIN_ROWS = 20;
+  const MIN_COLS2 = 36;
+  const MIN_ROWS2 = 20;
   const MAX_GUESSES = 6;
   const WORD_LENGTH = 5;
   const KEYBOARD_ROWS = [
@@ -12557,7 +12557,7 @@ function runWordleGame(terminal) {
       });
     }
   }
-  function spawnFirework3(x, y) {
+  function spawnFirework4(x, y) {
     const colors = ["\x1B[1;92m", "\x1B[1;93m", "\x1B[1;96m", "\x1B[1;95m"];
     const color = colors[Math.floor(Math.random() * colors.length)];
     const chars = ["*", "+", "o", ".", "`", "'"];
@@ -12578,7 +12578,7 @@ function runWordleGame(terminal) {
   function addScorePopup2(x, y, text, color = "\x1B[1;33m") {
     scorePopups.push({ x, y, text, frames: 25, color });
   }
-  function triggerShake2(frames, intensity) {
+  function triggerShake3(frames, intensity) {
     shakeFrames = frames;
     shakeIntensity = intensity;
   }
@@ -12636,7 +12636,7 @@ function runWordleGame(terminal) {
   }
   function submitGuess() {
     if (currentGuess.length !== WORD_LENGTH) {
-      triggerShake2(4, 2);
+      triggerShake3(4, 2);
       addScorePopup2(Math.floor(cols / 2), 8, "NOT ENOUGH LETTERS", "\x1B[1;91m");
       return;
     }
@@ -12662,7 +12662,7 @@ function runWordleGame(terminal) {
       }
       stats.guessDistribution[guesses.length - 1]++;
       borderFlash = 20;
-      triggerShake2(10, 3);
+      triggerShake3(10, 3);
       const messages = ["CIPHER BREACHED!", "CODE CRACKED!", "DECRYPTED!", "BRILLIANT!"];
       addScorePopup2(centerX, guessY - 2, messages[Math.floor(Math.random() * messages.length)], "\x1B[1;92m");
       setTimeout(() => {
@@ -12670,7 +12670,7 @@ function runWordleGame(terminal) {
           for (let i = 0; i < 5; i++) {
             setTimeout(() => {
               if (running && won) {
-                spawnFirework3(
+                spawnFirework4(
                   10 + Math.random() * (cols - 20),
                   5 + Math.random() * 10
                 );
@@ -12683,7 +12683,7 @@ function runWordleGame(terminal) {
       gameOver = true;
       stats.gamesPlayed++;
       stats.currentStreak = 0;
-      triggerShake2(8, 4);
+      triggerShake3(8, 4);
       borderFlash = 15;
       addScorePopup2(centerX, guessY - 2, "DECRYPTION FAILED", "\x1B[1;91m");
       spawnParticles3(centerX, guessY, 10, "\x1B[1;91m", ["X", "x", ".", "*"]);
@@ -12754,12 +12754,12 @@ function runWordleGame(terminal) {
     rows = terminal.rows;
     if (shakeFrames > 0) shakeFrames--;
     if (borderFlash > 0) borderFlash--;
-    if (cols < MIN_COLS || rows < MIN_ROWS) {
+    if (cols < MIN_COLS2 || rows < MIN_ROWS2) {
       const msg1 = "Terminal too small!";
-      const needWidth = cols < MIN_COLS;
-      const needHeight = rows < MIN_ROWS;
+      const needWidth = cols < MIN_COLS2;
+      const needHeight = rows < MIN_ROWS2;
       let hint = needWidth && needHeight ? "Make pane larger" : needWidth ? "Make pane wider" : "Make pane taller";
-      const msg2 = `Need: ${MIN_COLS}x${MIN_ROWS}  Have: ${cols}x${rows}`;
+      const msg2 = `Need: ${MIN_COLS2}x${MIN_ROWS2}  Have: ${cols}x${rows}`;
       const centerX2 = Math.floor(cols / 2);
       const centerY = Math.floor(rows / 2);
       output += `\x1B[${centerY - 1};${Math.max(1, centerX2 - Math.floor(msg1.length / 2))}H${themeColor}${msg1}\x1B[0m`;
@@ -13078,164 +13078,2653 @@ function runWordleGame(terminal) {
   return controller;
 }
 
-// src/games/gamesMenu.ts
-function showGamesMenu(terminal, optionsOrCallback) {
-  const options = typeof optionsOrCallback === "function" ? { onGameSelect: optionsOrCallback } : optionsOrCallback || {};
-  const { onGameSelect, onQuit } = options;
-  const themeColor = getCurrentThemeColor();
-  const lightTheme = isLightTheme2();
-  let running = true;
-  let selectedIndex = 0;
-  let scrollOffset = 0;
-  const controller = {
-    stop: () => {
-      if (!running) return;
-      running = false;
-    },
-    get isRunning() {
-      return running;
-    }
+// src/games/hyper-fighter/engine.ts
+var BOARD_ROWS = 12;
+var BOARD_COLS = 6;
+var COLORS = ["red", "green", "blue", "yellow"];
+var CRASH_GEM_CHANCE = 0.25;
+var DROP_ALLEY_COL = 3;
+var DIAMOND_INTERVAL = 25;
+var nextPowerGemId = 1;
+function createBoard() {
+  const board = [];
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    board.push(new Array(BOARD_COLS).fill(null));
+  }
+  return board;
+}
+function randomColor() {
+  return COLORS[Math.floor(Math.random() * COLORS.length)];
+}
+function randomGem() {
+  const isCrash = Math.random() < CRASH_GEM_CHANCE;
+  return {
+    color: randomColor(),
+    type: isCrash ? "crash" : "normal"
   };
-  const title = [
-    "\u2588\u2580\u2580 \u2584\u2580\u2588 \u2588\u2580\u2584\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580",
-    "\u2588\u2584\u2588 \u2588\u2580\u2588 \u2588 \u2580 \u2588 \u2588\u2588\u2584 \u2584\u2588"
-  ];
-  function render() {
-    let output = "";
-    output += "\x1B[2J\x1B[H";
-    const cols = terminal.cols;
-    const rows = terminal.rows;
-    const titleX = Math.floor((cols - title[0].length) / 2);
-    output += `\x1B[2;${titleX}H${themeColor}\x1B[1m${title[0]}\x1B[0m`;
-    output += `\x1B[3;${titleX}H${themeColor}\x1B[1m${title[1]}\x1B[0m`;
-    const subtitle = `Select a game to play (${games.length} games)`;
-    output += `\x1B[5;${Math.floor((cols - subtitle.length) / 2)}H\x1B[2m${subtitle}\x1B[0m`;
-    const boxWidth = 38;
-    const columnGap = 2;
-    const twoColumnWidth = boxWidth * 2 + columnGap;
-    const useTwoColumns = cols >= twoColumnWidth + 8;
-    const listStartY = 6;
-    const availableRows = rows - listStartY - 4;
-    const maxVisibleGames = Math.max(1, Math.floor(availableRows / 2));
-    if (useTwoColumns) {
-      renderTwoColumns(output, cols, rows, boxWidth, columnGap, listStartY, maxVisibleGames);
-    } else {
-      renderSingleColumn(output, cols, rows, boxWidth, listStartY, maxVisibleGames);
+}
+function generatePair() {
+  return {
+    primary: randomGem(),
+    secondary: randomGem(),
+    col: DROP_ALLEY_COL,
+    row: 0,
+    orientation: 0
+  };
+}
+function getSecondaryPos(pair) {
+  switch (pair.orientation) {
+    case 0:
+      return { row: pair.row - 1, col: pair.col };
+    // up
+    case 1:
+      return { row: pair.row, col: pair.col + 1 };
+    // right
+    case 2:
+      return { row: pair.row + 1, col: pair.col };
+    // down
+    case 3:
+      return { row: pair.row, col: pair.col - 1 };
+    // left
+    default:
+      return { row: pair.row - 1, col: pair.col };
+  }
+}
+function isValidPosition(pair, board) {
+  const sec = getSecondaryPos(pair);
+  if (pair.col < 0 || pair.col >= BOARD_COLS) return false;
+  if (pair.row >= BOARD_ROWS) return false;
+  if (sec.col < 0 || sec.col >= BOARD_COLS) return false;
+  if (sec.row >= BOARD_ROWS) return false;
+  if (pair.row >= 0 && board[pair.row][pair.col] !== null) return false;
+  if (sec.row >= 0 && board[sec.row][sec.col] !== null) return false;
+  return true;
+}
+function movePair(pair, board, dx) {
+  const test = { ...pair, col: pair.col + dx };
+  if (isValidPosition(test, board)) {
+    pair.col += dx;
+    return true;
+  }
+  return false;
+}
+function rotatePair(pair, board, clockwise) {
+  const newOrientation = clockwise ? (pair.orientation + 1) % 4 : (pair.orientation + 3) % 4;
+  const test = { ...pair, orientation: newOrientation };
+  if (isValidPosition(test, board)) {
+    pair.orientation = newOrientation;
+    return true;
+  }
+  for (const kick of [1, -1, 2, -2]) {
+    const kicked = { ...test, col: test.col + kick };
+    if (isValidPosition(kicked, board)) {
+      pair.orientation = newOrientation;
+      pair.col += kick;
+      return true;
     }
   }
-  function renderSingleColumn(baseOutput, cols, rows, boxWidth, listStartY, maxVisibleGames) {
-    let output = baseOutput;
-    const boxX = Math.floor((cols - boxWidth) / 2);
-    const visibleGames = Math.min(maxVisibleGames, games.length);
-    if (selectedIndex < scrollOffset) {
-      scrollOffset = selectedIndex;
-    } else if (selectedIndex >= scrollOffset + visibleGames) {
-      scrollOffset = selectedIndex - visibleGames + 1;
+  const upKick = { ...test, row: test.row - 1 };
+  if (isValidPosition(upKick, board)) {
+    pair.orientation = newOrientation;
+    pair.row -= 1;
+    return true;
+  }
+  return false;
+}
+function dropPair(pair, board) {
+  const test = { ...pair, row: pair.row + 1 };
+  if (isValidPosition(test, board)) {
+    pair.row += 1;
+    return true;
+  }
+  return false;
+}
+function hardDrop(pair, board) {
+  let dropped = 0;
+  while (dropPair(pair, board)) {
+    dropped++;
+  }
+  return dropped;
+}
+function lockPair(pair, board) {
+  if (pair.row >= 0 && pair.row < BOARD_ROWS) {
+    board[pair.row][pair.col] = { ...pair.primary };
+  }
+  const sec = getSecondaryPos(pair);
+  if (sec.row >= 0 && sec.row < BOARD_ROWS) {
+    board[sec.row][sec.col] = { ...pair.secondary };
+  }
+}
+function applyGravityFull(board, powerGems) {
+  void powerGems;
+  stripPowerGemIds(board);
+  let moved = false;
+  for (let col = 0; col < BOARD_COLS; col++) {
+    let writeRow = BOARD_ROWS - 1;
+    for (let row = BOARD_ROWS - 1; row >= 0; row--) {
+      if (board[row][col] !== null) {
+        if (row !== writeRow) {
+          board[writeRow][col] = board[row][col];
+          board[row][col] = null;
+          moved = true;
+        }
+        writeRow--;
+      }
     }
-    scrollOffset = Math.max(0, Math.min(scrollOffset, games.length - visibleGames));
-    const hasScrollUp = scrollOffset > 0;
-    const hasScrollDown = scrollOffset + visibleGames < games.length;
-    const topScrollIndicator = hasScrollUp ? " \u25B2 more " : "\u2550".repeat(8);
-    const topBorderWidth = boxWidth - 2 - topScrollIndicator.length;
-    const topLeftPad = Math.floor(topBorderWidth / 2);
-    const topRightPad = topBorderWidth - topLeftPad;
-    output += `\x1B[${listStartY};${boxX}H${themeColor}\u2554${"\u2550".repeat(topLeftPad)}${hasScrollUp ? "\x1B[33m" : ""}${topScrollIndicator}${hasScrollUp ? themeColor : ""}${"\u2550".repeat(topRightPad)}\u2557\x1B[0m`;
-    for (let vi = 0; vi < visibleGames; vi++) {
-      const i = scrollOffset + vi;
-      const game = games[i];
-      const y = listStartY + 1 + vi * 2;
-      const isSelected = i === selectedIndex;
-      output += renderGameEntry(game, i, isSelected, y, boxX, boxWidth);
+  }
+  return moved;
+}
+function stripPowerGemIds(board) {
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = board[r][c];
+      if (gem && gem.powerGemId !== void 0) {
+        delete gem.powerGemId;
+      }
     }
-    const bottomY = listStartY + 1 + visibleGames * 2;
-    const bottomScrollIndicator = hasScrollDown ? " \u25BC more " : "\u2550".repeat(8);
-    const bottomBorderWidth = boxWidth - 2 - bottomScrollIndicator.length;
-    const bottomLeftPad = Math.floor(bottomBorderWidth / 2);
-    const bottomRightPad = bottomBorderWidth - bottomLeftPad;
-    output += `\x1B[${bottomY};${boxX}H${themeColor}\u255A${"\u2550".repeat(bottomLeftPad)}${hasScrollDown ? "\x1B[33m" : ""}${bottomScrollIndicator}${hasScrollDown ? themeColor : ""}${"\u2550".repeat(bottomRightPad)}\u255D\x1B[0m`;
-    const controls = `\u2191\u2193 Navigate | ENTER Select | 1-9 Quick | Q Quit`;
-    output += `\x1B[${rows - 1};${Math.floor((cols - controls.length) / 2)}H\x1B[2m${controls}\x1B[0m`;
-    terminal.write(output);
   }
-  function renderTwoColumns(baseOutput, cols, rows, boxWidth, columnGap, listStartY, maxVisibleGames) {
-    let output = baseOutput;
-    const gamesPerColumn = Math.min(maxVisibleGames, Math.ceil(games.length / 2));
-    const selectedRow = Math.floor(selectedIndex / 2);
-    if (selectedRow < scrollOffset) {
-      scrollOffset = selectedRow;
-    } else if (selectedRow >= scrollOffset + gamesPerColumn) {
-      scrollOffset = selectedRow - gamesPerColumn + 1;
+}
+function detectPowerGems(board) {
+  const found = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = board[r][c];
+      if (!gem || gem.type !== "normal") continue;
+      for (let h = 2; h <= BOARD_ROWS - r; h++) {
+        for (let w = 2; w <= BOARD_COLS - c; w++) {
+          if (isUniformRect(board, r, c, w, h, gem.color)) {
+            const key = `${r},${c},${w},${h}`;
+            if (!used.has(key)) {
+              found.push({
+                id: nextPowerGemId++,
+                color: gem.color,
+                x: c,
+                y: r,
+                width: w,
+                height: h
+              });
+            }
+          }
+        }
+      }
     }
-    const maxScroll = Math.max(0, Math.ceil(games.length / 2) - gamesPerColumn);
-    scrollOffset = Math.max(0, Math.min(scrollOffset, maxScroll));
-    const hasScrollUp = scrollOffset > 0;
-    const hasScrollDown = (scrollOffset + gamesPerColumn) * 2 < games.length;
-    const totalWidth = boxWidth * 2 + columnGap;
-    const startX = Math.floor((cols - totalWidth) / 2);
-    const leftBoxX = startX;
-    const rightBoxX = startX + boxWidth + columnGap;
-    const topScrollIndicator = hasScrollUp ? " \u25B2 " : "\u2550\u2550\u2550";
-    const topBorderContent = boxWidth - 2 - topScrollIndicator.length;
-    const topLeft = Math.floor(topBorderContent / 2);
-    const topRight = topBorderContent - topLeft;
-    output += `\x1B[${listStartY};${leftBoxX}H${themeColor}\u2554${"\u2550".repeat(topLeft)}${hasScrollUp ? "\x1B[33m" : ""}${topScrollIndicator}${hasScrollUp ? themeColor : ""}${"\u2550".repeat(topRight)}\u2557\x1B[0m`;
-    output += `\x1B[${listStartY};${rightBoxX}H${themeColor}\u2554${"\u2550".repeat(topLeft)}${hasScrollUp ? "\x1B[33m" : ""}${topScrollIndicator}${hasScrollUp ? themeColor : ""}${"\u2550".repeat(topRight)}\u2557\x1B[0m`;
-    for (let row = 0; row < gamesPerColumn; row++) {
-      const leftIdx = (scrollOffset + row) * 2;
-      const rightIdx = leftIdx + 1;
-      const y = listStartY + 1 + row * 2;
-      if (leftIdx < games.length) {
-        output += renderGameEntry(games[leftIdx], leftIdx, leftIdx === selectedIndex, y, leftBoxX, boxWidth);
-      } else {
-        output += `\x1B[${y};${leftBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
-        output += `\x1B[${y + 1};${leftBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
+  }
+  found.sort((a, b) => b.width * b.height - a.width * a.height);
+  const result = [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const pg of found) {
+    let overlap = false;
+    for (let r = pg.y; r < pg.y + pg.height; r++) {
+      for (let c = pg.x; c < pg.x + pg.width; c++) {
+        if (claimed.has(`${r},${c}`)) {
+          overlap = true;
+          break;
+        }
       }
-      if (rightIdx < games.length) {
-        output += renderGameEntry(games[rightIdx], rightIdx, rightIdx === selectedIndex, y, rightBoxX, boxWidth);
-      } else {
-        output += `\x1B[${y};${rightBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
-        output += `\x1B[${y + 1};${rightBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
+      if (overlap) break;
+    }
+    if (!overlap) {
+      result.push(pg);
+      for (let r = pg.y; r < pg.y + pg.height; r++) {
+        for (let c = pg.x; c < pg.x + pg.width; c++) {
+          claimed.add(`${r},${c}`);
+          const gem = board[r][c];
+          if (gem) gem.powerGemId = pg.id;
+        }
       }
     }
-    const bottomY = listStartY + 1 + gamesPerColumn * 2;
-    const bottomScrollIndicator = hasScrollDown ? " \u25BC " : "\u2550\u2550\u2550";
-    const bottomBorderContent = boxWidth - 2 - bottomScrollIndicator.length;
-    const bottomLeft = Math.floor(bottomBorderContent / 2);
-    const bottomRight = bottomBorderContent - bottomLeft;
-    output += `\x1B[${bottomY};${leftBoxX}H${themeColor}\u255A${"\u2550".repeat(bottomLeft)}${hasScrollDown ? "\x1B[33m" : ""}${bottomScrollIndicator}${hasScrollDown ? themeColor : ""}${"\u2550".repeat(bottomRight)}\u255D\x1B[0m`;
-    output += `\x1B[${bottomY};${rightBoxX}H${themeColor}\u255A${"\u2550".repeat(bottomLeft)}${hasScrollDown ? "\x1B[33m" : ""}${bottomScrollIndicator}${hasScrollDown ? themeColor : ""}${"\u2550".repeat(bottomRight)}\u255D\x1B[0m`;
-    const controls = `\u2191\u2193\u2190\u2192 Navigate | ENTER Select | 1-9 Quick | Q Quit`;
-    output += `\x1B[${rows - 1};${Math.floor((cols - controls.length) / 2)}H\x1B[2m${controls}\x1B[0m`;
-    terminal.write(output);
   }
-  function renderGameEntry(game, index, isSelected, y, boxX, boxWidth) {
-    let output = "";
-    const contentWidth = boxWidth - 2;
-    const prefix = isSelected ? "\u25B6" : " ";
-    const highlight = isSelected ? lightTheme ? "\x1B[1;7;97m" : "\x1B[1;7m" : "";
-    const keyColor = isSelected ? "" : "\x1B[33m";
-    const keyNum = index + 1;
-    const keyDisplay = keyNum <= 9 ? `${keyNum}` : " ";
-    const lineContent = `${prefix} [${keyDisplay}] ${game.name}`;
-    const padding = Math.max(0, contentWidth - lineContent.length);
-    output += `\x1B[${y};${boxX}H${themeColor}\u2551\x1B[0m${highlight}${keyColor}${lineContent}${" ".repeat(padding)}\x1B[0m${themeColor}\u2551\x1B[0m`;
-    const descContent = `    ${game.description}`;
-    const descPadding = Math.max(0, contentWidth - descContent.length);
-    const descColor = isSelected ? lightTheme ? "\x1B[2;7;97m" : "\x1B[2;7m" : "\x1B[2m";
-    output += `\x1B[${y + 1};${boxX}H${themeColor}\u2551\x1B[0m${descColor}${descContent}${" ".repeat(descPadding)}\x1B[0m${themeColor}\u2551\x1B[0m`;
-    return output;
+  return result;
+}
+function isUniformRect(board, startRow, startCol, width, height, color) {
+  for (let r = startRow; r < startRow + height; r++) {
+    for (let c = startCol; c < startCol + width; c++) {
+      const gem = board[r][c];
+      if (!gem || gem.type !== "normal" || gem.color !== color) return false;
+    }
   }
-  setTimeout(() => {
-    if (!running) return;
-    if (!isTerminalValid(terminal)) {
-      console.warn("[GamesMenu] Terminal became invalid before menu could start");
-      running = false;
-      return;
+  return true;
+}
+function findCrashTargets(board, _powerGems) {
+  void _powerGems;
+  const targets = findCrashTargetsCore(board);
+  return targets;
+}
+function findCrashTargetsWithPowerInfo(board, powerGems) {
+  const targets = findCrashTargetsCore(board);
+  const destroyedPgIds = /* @__PURE__ */ new Set();
+  for (const t of targets) {
+    const gem = board[t.row][t.col];
+    if (gem && gem.powerGemId !== void 0) {
+      destroyedPgIds.add(gem.powerGemId);
     }
-    let keyListener = null;
-    try {
-      enterAlternateBuffer(terminal, "games-menu");
-      render();
+  }
+  const destroyedPowerGemSizes = [];
+  for (const pg of powerGems) {
+    if (destroyedPgIds.has(pg.id)) {
+      destroyedPowerGemSizes.push(pg.width * pg.height);
+    }
+  }
+  return { targets, destroyedPowerGemSizes };
+}
+function findCrashTargetsCore(board) {
+  const targetsByCell = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = board[r][c];
+      if (!gem || gem.type !== "crash") continue;
+      const neighbors = getNeighbors(r, c);
+      let hasTarget = false;
+      for (const [nr, nc] of neighbors) {
+        const ng = board[nr][nc];
+        if (ng && ng.color === gem.color && ng.type === "normal") {
+          hasTarget = true;
+          break;
+        }
+      }
+      if (hasTarget) {
+        const connected = floodFillCrashGroup(board, r, c, gem.color, visited);
+        for (const cell of connected) {
+          targetsByCell.set(`${cell.row},${cell.col}`, { ...cell, color: gem.color });
+        }
+      }
+    }
+  }
+  const targetSet = new Set(Array.from(targetsByCell.keys()));
+  for (const key of Array.from(targetSet)) {
+    const [rStr, cStr] = key.split(",");
+    const r = parseInt(rStr, 10);
+    const c = parseInt(cStr, 10);
+    for (const [nr, nc] of getNeighbors(r, c)) {
+      const nKey = `${nr},${nc}`;
+      if (targetSet.has(nKey)) continue;
+      const ng = board[nr][nc];
+      if (ng && ng.type === "counter") {
+        targetsByCell.set(nKey, { row: nr, col: nc, color: ng.color });
+        targetSet.add(nKey);
+      }
+    }
+  }
+  return Array.from(targetsByCell.values());
+}
+function getNeighbors(row, col) {
+  const n = [];
+  if (row > 0) n.push([row - 1, col]);
+  if (row < BOARD_ROWS - 1) n.push([row + 1, col]);
+  if (col > 0) n.push([row, col - 1]);
+  if (col < BOARD_COLS - 1) n.push([row, col + 1]);
+  return n;
+}
+function floodFillCrashGroup(board, startRow, startCol, color, globalVisited) {
+  const result = [];
+  const stack = [[startRow, startCol]];
+  const localVisited = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const [r, c] = stack.pop();
+    const key = `${r},${c}`;
+    if (localVisited.has(key) || globalVisited.has(key)) continue;
+    const gem = board[r][c];
+    if (!gem) continue;
+    if (gem.color !== color) continue;
+    if (gem.type !== "normal" && gem.type !== "crash") continue;
+    localVisited.add(key);
+    globalVisited.add(key);
+    result.push({ row: r, col: c });
+    for (const [nr, nc] of getNeighbors(r, c)) {
+      stack.push([nr, nc]);
+    }
+  }
+  return result;
+}
+function clearGems(board, targets) {
+  for (const t of targets) {
+    board[t.row][t.col] = null;
+  }
+}
+function resolveDiamond(board) {
+  const cleared = [];
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = board[r][c];
+      if (!gem || gem.type !== "diamond") continue;
+      let targetColor = null;
+      if (r + 1 < BOARD_ROWS && board[r + 1][c]) {
+        targetColor = board[r + 1][c].color;
+      }
+      if (!targetColor) {
+        for (const [nr, nc] of getNeighbors(r, c)) {
+          if (board[nr][nc] && board[nr][nc].type !== "diamond") {
+            targetColor = board[nr][nc].color;
+            break;
+          }
+        }
+      }
+      board[r][c] = null;
+      cleared.push({ row: r, col: c, color: targetColor || "red" });
+      if (!targetColor) continue;
+      for (let dr = 0; dr < BOARD_ROWS; dr++) {
+        for (let dc = 0; dc < BOARD_COLS; dc++) {
+          const g = board[dr][dc];
+          if (g && g.color === targetColor) {
+            cleared.push({ row: dr, col: dc, color: targetColor });
+            board[dr][dc] = null;
+          }
+        }
+      }
+    }
+  }
+  return cleared;
+}
+function shouldSpawnDiamond(totalDrops) {
+  return totalDrops > 0 && totalDrops % DIAMOND_INTERVAL === 0;
+}
+function generateDiamondPair() {
+  return {
+    primary: { color: "red", type: "diamond" },
+    secondary: randomGem(),
+    col: DROP_ALLEY_COL,
+    row: 0,
+    orientation: 0
+  };
+}
+function calculateStepAttack(info) {
+  let pgBonus = 0;
+  for (const area of info.powerGemSizes) {
+    pgBonus += Math.floor(area / 8);
+  }
+  return Math.floor((info.gemsCleared + pgBonus) * info.chainStep);
+}
+function applyAttackModifiers(total, damageModifier = 1, isDiamondClear = false) {
+  let attack = Math.floor(total * damageModifier);
+  if (isDiamondClear) attack = Math.floor(attack * 0.5);
+  return attack;
+}
+function resolveCounterAttack(attack, pendingGarbage, ratio = 2) {
+  if (attack <= 0 || pendingGarbage <= 0) {
+    return {
+      remainingAttack: attack,
+      remainingPending: pendingGarbage,
+      canceledGems: 0,
+      pendingStartsAtThree: false
+    };
+  }
+  const cancelable = Math.floor(attack / ratio);
+  const canceledGems = Math.min(cancelable, pendingGarbage);
+  const remainingPending = pendingGarbage - canceledGems;
+  const remainingAttack = attack - canceledGems * ratio;
+  return {
+    remainingAttack,
+    remainingPending,
+    canceledGems,
+    pendingStartsAtThree: canceledGems > 0 && remainingPending > 0
+  };
+}
+function decrementCounters(player) {
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = player.board[r][c];
+      if (gem && gem.type === "counter" && gem.counterTimer !== void 0) {
+        gem.counterTimer--;
+        if (gem.counterTimer <= 0) {
+          gem.type = "normal";
+          delete gem.counterTimer;
+        }
+      }
+    }
+  }
+}
+function checkGameOver(board) {
+  return board[0][DROP_ALLEY_COL] !== null;
+}
+function getGhostPosition(pair, board) {
+  const ghost = { ...pair };
+  while (true) {
+    const test = { ...ghost, row: ghost.row + 1 };
+    if (!isValidPosition(test, board)) break;
+    ghost.row++;
+  }
+  const sec = getSecondaryPos(ghost);
+  return {
+    primaryRow: ghost.row,
+    primaryCol: ghost.col,
+    secondaryRow: sec.row,
+    secondaryCol: sec.col
+  };
+}
+function createPlayerState() {
+  return {
+    board: createBoard(),
+    currentPair: null,
+    nextPair: generatePair(),
+    powerGems: [],
+    score: 0,
+    pendingGarbage: 0,
+    pendingCounteredGarbage: 0,
+    alive: true,
+    totalDrops: 0
+  };
+}
+function spawnPair(player) {
+  player.currentPair = player.nextPair;
+  player.currentPair.col = DROP_ALLEY_COL;
+  player.currentPair.row = 0;
+  player.currentPair.orientation = 0;
+  player.totalDrops++;
+  if (shouldSpawnDiamond(player.totalDrops + 1)) {
+    player.nextPair = generateDiamondPair();
+  } else {
+    player.nextPair = generatePair();
+  }
+  if (!isValidPosition(player.currentPair, player.board)) {
+    player.alive = false;
+    return false;
+  }
+  return true;
+}
+
+// src/games/hyper-fighter/ai.ts
+var DIFFICULTIES2 = {
+  easy: { name: "EASY", thinkFrames: 14, mistakeRate: 0.3, dropSpeedBoost: 1, simulateDepth: 0 },
+  normal: { name: "NORMAL", thinkFrames: 8, mistakeRate: 0.1, dropSpeedBoost: 1.5, simulateDepth: 0 },
+  hard: { name: "HARD", thinkFrames: 4, mistakeRate: 0.02, dropSpeedBoost: 2, simulateDepth: 1 }
+};
+function createAIState(difficulty) {
+  return {
+    targetCol: 2,
+    targetOrientation: 0,
+    thinkTimer: 0,
+    moveTimer: 0,
+    decided: false,
+    difficulty
+  };
+}
+function getColumnHeight(board, col) {
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    if (board[r][col] !== null) return BOARD_ROWS - r;
+  }
+  return 0;
+}
+function evaluateBoard(board) {
+  let score = 0;
+  for (let c = 0; c < BOARD_COLS; c++) {
+    const h = getColumnHeight(board, c);
+    score -= h * h * 2;
+  }
+  const heights = [];
+  for (let c = 0; c < BOARD_COLS; c++) {
+    heights.push(getColumnHeight(board, c));
+  }
+  for (let c = 0; c < BOARD_COLS - 1; c++) {
+    const diff = Math.abs(heights[c] - heights[c + 1]);
+    score -= diff * 3;
+  }
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = board[r][c];
+      if (!gem || gem.type === "counter") continue;
+      if (c + 1 < BOARD_COLS) {
+        const right = board[r][c + 1];
+        if (right && right.color === gem.color && right.type !== "counter") {
+          score += 4;
+        }
+      }
+      if (r + 1 < BOARD_ROWS) {
+        const below = board[r + 1][c];
+        if (below && below.color === gem.color && below.type !== "counter") {
+          score += 4;
+        }
+      }
+    }
+  }
+  for (let r = 0; r < BOARD_ROWS; r++) {
+    for (let c = 0; c < BOARD_COLS; c++) {
+      const gem = board[r][c];
+      if (!gem || gem.type !== "crash") continue;
+      const neighbors = [
+        [r - 1, c],
+        [r + 1, c],
+        [r, c - 1],
+        [r, c + 1]
+      ];
+      for (const [nr, nc] of neighbors) {
+        if (nr >= 0 && nr < BOARD_ROWS && nc >= 0 && nc < BOARD_COLS) {
+          const ng = board[nr][nc];
+          if (ng && ng.color === gem.color && ng.type === "normal") {
+            score += 15;
+          }
+        }
+      }
+    }
+  }
+  const powerGems = detectPowerGems(board);
+  for (const pg of powerGems) {
+    score += pg.width * pg.height * 8;
+  }
+  const targets = findCrashTargets(board, powerGems);
+  score += targets.length * 10;
+  const maxHeight = Math.max(...heights);
+  if (maxHeight >= BOARD_ROWS - 2) score -= 200;
+  if (maxHeight >= BOARD_ROWS - 1) score -= 500;
+  const deathHeight = heights[DROP_ALLEY_COL];
+  if (deathHeight >= BOARD_ROWS - 3) score -= 100;
+  return score;
+}
+function cloneBoard(board) {
+  return board.map((row) => row.map((gem) => gem ? { ...gem } : null));
+}
+function evaluatePlacement(pair, board, simulateDepth = 0) {
+  const testBoard = cloneBoard(board);
+  const testPair = {
+    primary: { ...pair.primary },
+    secondary: { ...pair.secondary },
+    col: pair.col,
+    row: pair.row,
+    orientation: pair.orientation
+  };
+  while (true) {
+    const next = { ...testPair, row: testPair.row + 1 };
+    if (!isValidPosition(next, testBoard)) break;
+    testPair.row++;
+  }
+  lockPair(testPair, testBoard);
+  applyGravityFull(testBoard, []);
+  if (simulateDepth > 0) {
+    const pg = detectPowerGems(testBoard);
+    const targets = findCrashTargets(testBoard, pg);
+    if (targets.length > 0) {
+      clearGems(testBoard, targets);
+      applyGravityFull(testBoard, []);
+    }
+  }
+  return evaluateBoard(testBoard);
+}
+function selectMove(player, ai) {
+  const pair = player.currentPair;
+  if (!pair) return;
+  if (Math.random() < ai.difficulty.mistakeRate) {
+    ai.targetCol = Math.floor(Math.random() * BOARD_COLS);
+    ai.targetOrientation = Math.floor(Math.random() * 4);
+    ai.decided = true;
+    return;
+  }
+  const options = [];
+  for (let orient = 0; orient < 4; orient++) {
+    for (let col = 0; col < BOARD_COLS; col++) {
+      const testPair = {
+        primary: { ...pair.primary },
+        secondary: { ...pair.secondary },
+        col,
+        row: 0,
+        orientation: orient
+      };
+      if (!isValidPosition(testPair, player.board)) continue;
+      const score = evaluatePlacement(testPair, player.board, ai.difficulty.simulateDepth);
+      options.push({ col, orientation: orient, score });
+    }
+  }
+  if (options.length === 0) {
+    ai.targetCol = pair.col;
+    ai.targetOrientation = pair.orientation;
+    ai.decided = true;
+    return;
+  }
+  options.sort((a, b) => b.score - a.score);
+  const best = options[0];
+  ai.targetCol = best.col;
+  ai.targetOrientation = best.orientation;
+  ai.decided = true;
+}
+function aiTick(player, ai) {
+  if (!player.currentPair) return "none";
+  ai.thinkTimer++;
+  if (!ai.decided) {
+    if (ai.thinkTimer >= ai.difficulty.thinkFrames) {
+      selectMove(player, ai);
+      ai.thinkTimer = 0;
+    }
+    return "none";
+  }
+  ai.moveTimer++;
+  const moveInterval = Math.max(2, Math.floor(ai.difficulty.thinkFrames / 3));
+  if (ai.moveTimer < moveInterval) return "none";
+  ai.moveTimer = 0;
+  const pair = player.currentPair;
+  if (pair.orientation !== ai.targetOrientation) {
+    const cwDist = (ai.targetOrientation - pair.orientation + 4) % 4;
+    const ccwDist = (pair.orientation - ai.targetOrientation + 4) % 4;
+    return cwDist <= ccwDist ? "rotate_cw" : "rotate_ccw";
+  }
+  if (pair.col < ai.targetCol) {
+    return "move";
+  } else if (pair.col > ai.targetCol) {
+    return "move";
+  }
+  return "drop";
+}
+function getAIMoveDirection(player, ai) {
+  if (!player.currentPair) return 0;
+  if (player.currentPair.col < ai.targetCol) return 1;
+  if (player.currentPair.col > ai.targetCol) return -1;
+  return 0;
+}
+
+// src/games/hyper-fighter/effects.ts
+var GEM_ANSI = {
+  red: "\x1B[1;38;5;196m",
+  green: "\x1B[1;38;5;46m",
+  blue: "\x1B[1;38;5;27m",
+  yellow: "\x1B[1;38;5;226m"
+};
+var PARTICLE_CHARS = ["\u2726", "\u2605", "\u25C6", "\u25CF", "\xB7", "*", "\u25AA"];
+function spawnClearParticles(x, y, color, count, particles) {
+  const ansi = GEM_ANSI[color];
+  for (let i = 0; i < count; i++) {
+    particles.push({
+      x: x + (Math.random() - 0.5) * 2,
+      y: y + (Math.random() - 0.5),
+      char: PARTICLE_CHARS[Math.floor(Math.random() * PARTICLE_CHARS.length)],
+      color: ansi,
+      vx: (Math.random() - 0.5) * 3,
+      vy: (Math.random() - 0.8) * 2,
+      life: 8 + Math.floor(Math.random() * 8),
+      maxLife: 16
+    });
+  }
+}
+function spawnFirework2(x, y, particles) {
+  const colors = ["\x1B[91m", "\x1B[93m", "\x1B[92m", "\x1B[96m", "\x1B[95m"];
+  for (let i = 0; i < 20; i++) {
+    const angle = Math.PI * 2 * i / 20;
+    const speed = 1.5 + Math.random();
+    particles.push({
+      x,
+      y,
+      char: PARTICLE_CHARS[Math.floor(Math.random() * PARTICLE_CHARS.length)],
+      color: colors[Math.floor(Math.random() * colors.length)],
+      vx: Math.cos(angle) * speed,
+      vy: Math.sin(angle) * speed * 0.5,
+      life: 12 + Math.floor(Math.random() * 8),
+      maxLife: 20
+    });
+  }
+}
+function spawnCollapse(startX, startY, width, height, particles) {
+  for (let r = 0; r < height; r++) {
+    for (let c = 0; c < width; c++) {
+      if (Math.random() < 0.4) {
+        particles.push({
+          x: startX + c * 2,
+          y: startY + r,
+          char: "\u2593",
+          color: "\x1B[90m",
+          vx: (Math.random() - 0.5) * 0.5,
+          vy: 0.3 + Math.random() * 0.5,
+          life: 10 + Math.floor(Math.random() * 15),
+          maxLife: 25
+        });
+      }
+    }
+  }
+}
+function updateParticles2(particles) {
+  for (let i = particles.length - 1; i >= 0; i--) {
+    const p = particles[i];
+    p.x += p.vx;
+    p.y += p.vy;
+    p.vy += 0.08;
+    p.life--;
+    if (p.life <= 0) {
+      particles.splice(i, 1);
+    }
+  }
+}
+function renderParticles(particles, minX, minY, maxX, maxY) {
+  let output = "";
+  for (const p of particles) {
+    const px = Math.round(p.x);
+    const py = Math.round(p.y);
+    if (px < minX || px > maxX || py < minY || py > maxY) continue;
+    const fade = p.life > p.maxLife * 0.5 ? "\x1B[1m" : "\x1B[2m";
+    output += `\x1B[${py};${px}H${fade}${p.color}${p.char}\x1B[0m`;
+  }
+  return output;
+}
+var COMBO_MESSAGES = [
+  { text: "NICE!", color: "\x1B[92m" },
+  { text: "GREAT!", color: "\x1B[93m" },
+  { text: "AMAZING!", color: "\x1B[96m" },
+  { text: "UNSTOPPABLE!", color: "\x1B[95m" },
+  { text: "GODLIKE!!", color: "\x1B[91m" },
+  { text: "GODLIKE!!", color: "\x1B[1;91m" }
+];
+function spawnComboText(chains, x, y, texts) {
+  const idx = Math.min(chains - 1, COMBO_MESSAGES.length - 1);
+  const msg = COMBO_MESSAGES[idx];
+  texts.push({
+    text: `${msg.text} \xD7${chains}`,
+    x: x - Math.floor(msg.text.length / 2),
+    y,
+    color: msg.color,
+    frames: 20,
+    maxFrames: 20
+  });
+}
+function spawnChainCounter(chains, x, y, texts) {
+  texts.push({
+    text: `${chains} CHAIN`,
+    x: x - 3,
+    y: y + 1,
+    color: "\x1B[1;97m",
+    frames: 16,
+    maxFrames: 16
+  });
+}
+function updateFloatingTexts(texts) {
+  for (let i = texts.length - 1; i >= 0; i--) {
+    const t = texts[i];
+    t.frames--;
+    if (t.frames % 3 === 0) t.y -= 1;
+    if (t.frames <= 0) {
+      texts.splice(i, 1);
+    }
+  }
+}
+function renderFloatingTexts(texts) {
+  let output = "";
+  for (const t of texts) {
+    if (t.y < 1) continue;
+    const fade = t.frames > t.maxFrames * 0.4 ? "\x1B[1m" : "\x1B[2m";
+    output += `\x1B[${t.y};${Math.max(1, t.x)}H${fade}${t.color}${t.text}\x1B[0m`;
+  }
+  return output;
+}
+function spawnProjectile(fromX, toX, y, count, projectiles) {
+  let char;
+  let color;
+  if (count >= 8) {
+    char = "\u25C8";
+    color = "\x1B[1;91m";
+  } else if (count >= 4) {
+    char = "\u25C6";
+    color = "\x1B[1;93m";
+  } else {
+    char = "\u25CF";
+    color = "\x1B[1;97m";
+  }
+  projectiles.push({ fromX, toX, y, progress: 0, char, color, count });
+}
+function updateProjectiles(projectiles) {
+  for (let i = projectiles.length - 1; i >= 0; i--) {
+    const p = projectiles[i];
+    p.progress += 1 / 7;
+    if (p.progress >= 1) {
+      projectiles.splice(i, 1);
+    }
+  }
+}
+function renderProjectiles(projectiles) {
+  let output = "";
+  for (const p of projectiles) {
+    const x = Math.round(p.fromX + (p.toX - p.fromX) * p.progress);
+    if (x < 1) continue;
+    output += `\x1B[${p.y};${x}H${p.color}${p.char}\x1B[0m`;
+  }
+  return output;
+}
+function renderPortrait(lines, x, y, color) {
+  let output = "";
+  for (let i = 0; i < lines.length; i++) {
+    output += `\x1B[${y + i};${x}H${color}${lines[i]}\x1B[0m`;
+  }
+  return output;
+}
+function triggerShake(shake, intensity, frames) {
+  shake.intensity = Math.max(shake.intensity, intensity);
+  shake.frames = Math.max(shake.frames, frames);
+}
+function updateShake(shake) {
+  if (shake.frames <= 0) return { dx: 0, dy: 0 };
+  shake.frames--;
+  if (shake.frames <= 0) {
+    shake.intensity = 0;
+    return { dx: 0, dy: 0 };
+  }
+  return {
+    dx: Math.round((Math.random() - 0.5) * shake.intensity * 2),
+    dy: Math.round((Math.random() - 0.5) * shake.intensity)
+  };
+}
+function triggerFlash(flash, color, frames) {
+  flash.color = color;
+  flash.frames = frames;
+}
+function updateFlash(flash) {
+  if (flash.frames <= 0) return null;
+  flash.frames--;
+  return flash.color;
+}
+function renderEnergyBar(x, y, level, maxLevel) {
+  const barHeight = 6;
+  const filled = Math.min(barHeight, Math.round(level / Math.max(1, maxLevel) * barHeight));
+  let output = "";
+  for (let i = 0; i < barHeight; i++) {
+    const isFilled = i >= barHeight - filled;
+    const char = isFilled ? "\u2588" : "\u2591";
+    const color = isFilled ? filled >= barHeight - 1 ? "\x1B[91m" : filled >= barHeight / 2 ? "\x1B[93m" : "\x1B[92m" : "\x1B[90m";
+    output += `\x1B[${y + i};${x}H${color}${char}\x1B[0m`;
+  }
+  return output;
+}
+
+// src/games/hyper-fighter/characters.ts
+var R = "red";
+var G = "green";
+var B = "blue";
+var Y = "yellow";
+var ryu = {
+  id: "ryu",
+  name: "Ryu",
+  description: "Vertical columns",
+  damageModifier: 1,
+  dropPattern: [
+    [R, G, B, Y, R, G],
+    [R, G, B, Y, R, G],
+    [R, G, B, Y, R, G],
+    [R, G, B, Y, R, G]
+  ],
+  portraits: {
+    idle: ["  __  ", " (-_-)", "  /|  "],
+    attack: [" _\\__ ", " (>o<)", " =|/  "],
+    hit: ["  __  ", " (x_x)", "  /|  "],
+    win: [" \\__/ ", " (^o^)", "  /\\  "],
+    lose: ["  __  ", " (;_;)", "   |  "]
+  }
+};
+var ken = {
+  id: "ken",
+  name: "Ken",
+  description: "Horizontal rows",
+  damageModifier: 1,
+  dropPattern: [
+    [Y, Y, Y, Y, Y, Y],
+    [G, G, G, G, G, G],
+    [B, B, B, B, B, B],
+    [R, R, R, R, R, R]
+  ],
+  portraits: {
+    idle: [" ^^^  ", " [>_>]", "  /|  "],
+    attack: [" ^^^/ ", " [>o<]", " /=|  "],
+    hit: [" ^^^  ", " [x_x]", "  /|  "],
+    win: [" \\^^/ ", " [^o^]", "  /\\  "],
+    lose: [" ^^^  ", " [;_;]", "   |  "]
+  }
+};
+var chunLi = {
+  id: "chunli",
+  name: "Chun-Li",
+  description: "2x2 color blocks",
+  damageModifier: 1.2,
+  dropPattern: [
+    [R, R, G, G, B, B],
+    [R, R, G, G, B, B],
+    [Y, Y, R, R, G, G],
+    [Y, Y, R, R, G, G]
+  ],
+  portraits: {
+    idle: [" @  @ ", " {^.^}", "  /|  "],
+    attack: [" @  @\\", " {>.<}", "  /|= "],
+    hit: [" @  @ ", " {x.x}", "  /|  "],
+    win: ["\\@  @/", " {^o^}", "  /\\  "],
+    lose: [" @  @ ", " {;.;}", "   |  "]
+  }
+};
+var sakura = {
+  id: "sakura",
+  name: "Sakura",
+  description: "Fixed edges, alt middle",
+  damageModifier: 1,
+  dropPattern: [
+    [G, R, B, R, B, Y],
+    [G, B, R, B, R, Y],
+    [G, R, B, R, B, Y],
+    [G, B, R, B, R, Y]
+  ],
+  portraits: {
+    idle: ["  >>  ", " <*_*>", "  /|  "],
+    attack: ["  >>/ ", " <*o*>", "  /|= "],
+    hit: ["  >>  ", " <x_x>", "  /|  "],
+    win: [" \\>>/ ", " <^o^>", "  /\\  "],
+    lose: ["  >>  ", " <;_;>", "   |  "]
+  }
+};
+var morrigan = {
+  id: "morrigan",
+  name: "Morrigan",
+  description: "Symmetric mirrored",
+  damageModifier: 1,
+  dropPattern: [
+    [B, G, R, R, G, B],
+    [G, B, R, R, B, G],
+    [R, G, B, B, G, R],
+    [G, R, B, B, R, G]
+  ],
+  portraits: {
+    idle: [" ~  ~ ", " ~^_^~", "  /|  "],
+    attack: [" ~/~\\ ", " ~>_<~", "  /|  "],
+    hit: [" ~  ~ ", " ~x_x~", "  /|  "],
+    win: ["\\~  ~/", "  ~^o~ ", "  /\\  "],
+    lose: [" ~  ~ ", " ~;_;~", "   |  "]
+  }
+};
+var hsienKo = {
+  id: "hsienKo",
+  name: "Hsien-Ko",
+  description: "Diagonal staircase",
+  damageModifier: 1,
+  dropPattern: [
+    [R, G, B, Y, R, G],
+    [G, B, Y, R, G, B],
+    [B, Y, R, G, B, Y],
+    [Y, R, G, B, Y, R]
+  ],
+  portraits: {
+    idle: ["  ==  ", " |o_o|", "  /|  "],
+    attack: ["  ==\\ ", " |o_o|", "  /|= "],
+    hit: ["  ==  ", " |x_x|", "  /|  "],
+    win: [" \\==/ ", " |^o^|", "  /\\  "],
+    lose: ["  ==  ", " |;_;|", "   |  "]
+  }
+};
+var felicia = {
+  id: "felicia",
+  name: "Felicia",
+  description: "Fixed edges, swap mid",
+  damageModifier: 1,
+  dropPattern: [
+    [G, R, B, R, B, Y],
+    [G, B, R, B, R, Y],
+    [Y, R, B, R, B, G],
+    [Y, B, R, B, R, G]
+  ],
+  portraits: {
+    idle: [" /\\/\\ ", " =^w^=", "  /|  "],
+    attack: [" /\\/\\\\", " =^o^=", "  /|= "],
+    hit: [" /\\/\\ ", " =x_x=", "  /|  "],
+    win: ["\\/\\/\\/", " =^w^=", "  /\\  "],
+    lose: [" /\\/\\ ", " =;w;=", "   |  "]
+  }
+};
+var donovan = {
+  id: "donovan",
+  name: "Donovan",
+  description: "3-col halves + alt base",
+  damageModifier: 1,
+  dropPattern: [
+    [R, R, R, G, G, G],
+    [R, R, R, G, G, G],
+    [B, B, B, Y, Y, Y],
+    [R, G, B, R, G, B]
+  ],
+  portraits: {
+    idle: ["  ||  ", " #-_-#", "  /|  "],
+    attack: ["  ||/ ", " #>_<#", "  /|= "],
+    hit: ["  ||  ", " #x_x#", "  /|  "],
+    win: [" \\||/ ", " #^o^#", "  /\\  "],
+    lose: ["  ||  ", " #;_;#", "   |  "]
+  }
+};
+var dan = {
+  id: "dan",
+  name: "Dan",
+  description: "ALL RED (joke char)",
+  damageModifier: 1,
+  dropPattern: [
+    [R, R, R, R, R, R],
+    [R, R, R, R, R, R],
+    [R, R, R, R, R, R],
+    [R, R, R, R, R, R]
+  ],
+  portraits: {
+    idle: ["  ^^  ", " (?_?)", "  /|  "],
+    attack: ["  ^^! ", " (!o!)", "  /|~ "],
+    hit: ["  ^^  ", " (x_x)", "  /|  "],
+    win: [" \\^^/ ", " (^o^)", "  /\\  "],
+    lose: ["  ^^  ", " (T_T)", "   |  "]
+  }
+};
+var akuma = {
+  id: "akuma",
+  name: "Akuma",
+  description: "Diagonal rainbow cycle",
+  damageModifier: 0.7,
+  dropPattern: [
+    [R, Y, B, G, R, Y],
+    [Y, B, G, R, Y, B],
+    [B, G, R, Y, B, G],
+    [G, R, Y, B, G, R]
+  ],
+  portraits: {
+    idle: [" /MM\\ ", " !>_<!", "  /|  "],
+    attack: [" /MM\\|", " !>o<!", " =/|  "],
+    hit: [" /MM\\ ", " !x_x!", "  /|  "],
+    win: ["\\/MM\\/", " !^_^!", "  /\\  "],
+    lose: [" /MM\\ ", " !;_;!", "   |  "]
+  }
+};
+var devilotte = {
+  id: "devilotte",
+  name: "Devilotte",
+  description: "Reverse diagonal rainbow",
+  damageModifier: 0.7,
+  dropPattern: [
+    [G, B, Y, R, G, B],
+    [B, Y, R, G, B, Y],
+    [Y, R, G, B, Y, R],
+    [R, G, B, Y, R, G]
+  ],
+  portraits: {
+    idle: ["  vVv ", " $v_v$", "  /|  "],
+    attack: ["  vVv\\", " $>_<$", "  /|= "],
+    hit: ["  vVv ", " $x_x$", "  /|  "],
+    win: [" \\vVv/", " $^_^$", "  /\\  "],
+    lose: ["  vVv ", " $;_;$", "   |  "]
+  }
+};
+var CHARACTERS = [
+  ryu,
+  ken,
+  chunLi,
+  sakura,
+  morrigan,
+  hsienKo,
+  felicia,
+  donovan,
+  dan,
+  akuma,
+  devilotte
+];
+var CHAR_GRID = [
+  [0, 1, 2, 3],
+  [4, 5, 6, 7],
+  [8, 9, 10]
+];
+function getRandomCharacter() {
+  return CHARACTERS[Math.floor(Math.random() * CHARACTERS.length)];
+}
+
+// src/games/hyper-fighter/index.ts
+var TICK_MS = 50;
+var MIN_COLS = 60;
+var MIN_ROWS = 36;
+var VS_COL_WIDTH = 12;
+var SIDE_PANEL_WIDTH = 14;
+var HEADER_HEIGHT = 2;
+var FOOTER_HEIGHT = 2;
+var MIN_CELL_WIDTH = 3;
+var MAX_CELL_WIDTH = 6;
+var MIN_CELL_HEIGHT = 2;
+var MAX_CELL_HEIGHT = 4;
+var GEM_COLORS = {
+  red: "\x1B[1;38;5;196m",
+  green: "\x1B[1;38;5;46m",
+  blue: "\x1B[1;38;5;27m",
+  yellow: "\x1B[1;38;5;226m"
+};
+var COUNTER_BG_COLORS = {
+  red: "\x1B[48;5;196m",
+  green: "\x1B[48;5;34m",
+  blue: "\x1B[48;5;27m",
+  yellow: "\x1B[48;5;178m"
+};
+var BASE_DROP_SPEED = 16;
+var MIN_DROP_SPEED = 3;
+var SPEED_RAMP_DROPS = 8;
+var PHASE_NONE = 0;
+var PHASE_FLASH = 1;
+var PHASE_DISSOLVE = 2;
+var PHASE_GRAVITY = 3;
+var PHASE_CHECK = 4;
+var PHASE_GARBAGE = 5;
+var FLASH_FRAMES = 6;
+var DISSOLVE_FRAMES = 4;
+var GRAVITY_FRAMES = 1;
+var COUNTER_TIMER_NORMAL = 5;
+var COUNTER_TIMER_DEFENDED = 3;
+var GARBAGE_DROP_STEP_FRAMES = 2;
+function runHyperFighterGame(terminal) {
+  const themeColor = getCurrentThemeColor();
+  let running = true;
+  let gameState = "difficulty";
+  let difficultySelection = 1;
+  let pauseMenuSelection = 0;
+  let p1;
+  let p2;
+  let aiState;
+  let selectedDifficulty = DIFFICULTIES2.normal;
+  let p1Character = CHARACTERS[0];
+  let p2Character = getRandomCharacter();
+  let charGridRow = 0;
+  let charGridCol = 0;
+  let p1DropTimer = 0;
+  let p2DropTimer = 0;
+  let p1DropSpeed = BASE_DROP_SPEED;
+  let p2DropSpeed = BASE_DROP_SPEED;
+  let p1Phase = PHASE_NONE;
+  let p2Phase = PHASE_NONE;
+  let p1PhaseTimer = 0;
+  let p2PhaseTimer = 0;
+  let p1ClearedCells = [];
+  let p2ClearedCells = [];
+  let p1ChainCount = 0;
+  let p2ChainCount = 0;
+  let p1TotalCleared = 0;
+  let p2TotalCleared = 0;
+  let p1GarbageDrop = null;
+  let p2GarbageDrop = null;
+  let p1GarbagePatternCursor = 0;
+  let p2GarbagePatternCursor = 0;
+  let p1IsDiamondClear = false;
+  let p2IsDiamondClear = false;
+  let p1AttackAccum = 0;
+  let p2AttackAccum = 0;
+  let particles = [];
+  let floatingTexts = [];
+  let projectiles = [];
+  let p1Shake = { intensity: 0, frames: 0 };
+  let p2Shake = { intensity: 0, frames: 0 };
+  let p1Flash = { color: "", frames: 0 };
+  let p2Flash = { color: "", frames: 0 };
+  let p1Pose = "idle";
+  let p2Pose = "idle";
+  let p1PoseTimer = 0;
+  let p2PoseTimer = 0;
+  let winner = 0;
+  let gameOverTimer = 0;
+  let glitchFrame = 0;
+  let cellWidth = 3;
+  let cellHeight = 2;
+  let boardDisplayWidth = BOARD_COLS * cellWidth + 2;
+  let boardDisplayHeight = BOARD_ROWS * cellHeight + 2;
+  let cellEmpty = " ".repeat(cellWidth);
+  let cellSolid = "\u2588".repeat(cellWidth);
+  let cellPower = "\u2593".repeat(cellWidth);
+  let cellGhost = "\u2591".repeat(cellWidth);
+  let cellCrash = "\u25C6".repeat(cellWidth);
+  let cellDiamond = "\u25C7".repeat(cellWidth);
+  let cellEmptyDot = " ".repeat(Math.floor((cellWidth - 1) / 2)) + "\x1B[38;5;238m\xB7\x1B[0m" + " ".repeat(cellWidth - Math.floor((cellWidth - 1) / 2) - 1);
+  let showSidePanels = false;
+  let sidePanel1X = 0;
+  let sidePanel2X = 0;
+  let boardLeft1 = 2;
+  let boardLeft2 = 28;
+  let vsColX = 16;
+  let boardTop = 3;
+  function recalcCellStrings() {
+    boardDisplayWidth = BOARD_COLS * cellWidth + 2;
+    boardDisplayHeight = BOARD_ROWS * cellHeight + 2;
+    cellEmpty = " ".repeat(cellWidth);
+    cellSolid = "\u2588".repeat(cellWidth);
+    cellPower = "\u2593".repeat(cellWidth);
+    cellGhost = "\u2591".repeat(cellWidth);
+    cellCrash = "\u25C6".repeat(cellWidth);
+    cellDiamond = "\u25C7".repeat(cellWidth);
+    const padLeft = Math.floor((cellWidth - 1) / 2);
+    cellEmptyDot = " ".repeat(padLeft) + "\xB7" + " ".repeat(cellWidth - padLeft - 1);
+  }
+  const controller = {
+    stop: () => {
+      if (!running) return;
+      running = false;
+    },
+    get isRunning() {
+      return running;
+    }
+  };
+  const title = [
+    "\u2588 \u2588 \u2588 \u2588 \u2588\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2588",
+    "\u2588\u2580\u2588 \u2580\u2584\u2580 \u2588\u2580\u2580 \u2588\u2588\u2584 \u2588\u2580\u2584",
+    "\u2588\u2580\u2580 \u2588 \u2588\u2580\u2580 \u2588 \u2588 \u2580\u2588\u2580 \u2588\u2580\u2580 \u2588\u2580\u2588",
+    "\u2588\u2580  \u2588 \u2588 \u2588 \u2588\u2580\u2588  \u2588  \u2588\u2588\u2584 \u2588\u2580\u2584"
+  ];
+  const GLITCH_CHARS2 = "!@#$%^&*\u2591\u2592\u2593\u2588\u2580\u2584";
+  function initGame() {
+    p1 = createPlayerState();
+    p2 = createPlayerState();
+    aiState = createAIState(selectedDifficulty);
+    p1DropTimer = 0;
+    p2DropTimer = 0;
+    p1DropSpeed = BASE_DROP_SPEED;
+    p2DropSpeed = BASE_DROP_SPEED;
+    p1Phase = PHASE_NONE;
+    p2Phase = PHASE_NONE;
+    p1PhaseTimer = 0;
+    p2PhaseTimer = 0;
+    p1ClearedCells = [];
+    p2ClearedCells = [];
+    p1ChainCount = 0;
+    p2ChainCount = 0;
+    p1TotalCleared = 0;
+    p2TotalCleared = 0;
+    p1GarbageDrop = null;
+    p2GarbageDrop = null;
+    p1GarbagePatternCursor = 0;
+    p2GarbagePatternCursor = 0;
+    p1IsDiamondClear = false;
+    p2IsDiamondClear = false;
+    p1AttackAccum = 0;
+    p2AttackAccum = 0;
+    particles = [];
+    floatingTexts = [];
+    projectiles = [];
+    p1Shake = { intensity: 0, frames: 0 };
+    p2Shake = { intensity: 0, frames: 0 };
+    p1Flash = { color: "", frames: 0 };
+    p2Flash = { color: "", frames: 0 };
+    p1Pose = "idle";
+    p2Pose = "idle";
+    p1PoseTimer = 0;
+    p2PoseTimer = 0;
+    winner = 0;
+    gameOverTimer = 0;
+    pauseMenuSelection = 0;
+    spawnPair(p1);
+    spawnPair(p2);
+  }
+  function calculateLayout() {
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    cellHeight = Math.max(MIN_CELL_HEIGHT, Math.min(
+      MAX_CELL_HEIGHT,
+      Math.floor((rows - HEADER_HEIGHT - FOOTER_HEIGHT - 2 - 2) / BOARD_ROWS)
+    ));
+    const availWidthWithPanels = cols - 2 * SIDE_PANEL_WIDTH - VS_COL_WIDTH - 4;
+    const availWidthWithout = cols - VS_COL_WIDTH - 4;
+    const cwWithPanels = Math.floor(availWidthWithPanels / (2 * BOARD_COLS));
+    const cwWithout = Math.floor(availWidthWithout / (2 * BOARD_COLS));
+    if (cwWithPanels >= MIN_CELL_WIDTH) {
+      showSidePanels = true;
+      cellWidth = Math.max(MIN_CELL_WIDTH, Math.min(MAX_CELL_WIDTH, cwWithPanels));
+    } else {
+      showSidePanels = false;
+      cellWidth = Math.max(MIN_CELL_WIDTH, Math.min(MAX_CELL_WIDTH, cwWithout));
+    }
+    const maxAspectWidth = Math.floor(cellHeight * 1.5);
+    if (cellWidth > maxAspectWidth && maxAspectWidth >= MIN_CELL_WIDTH) {
+      cellWidth = maxAspectWidth;
+    }
+    recalcCellStrings();
+    if (showSidePanels) {
+      const totalWidth = SIDE_PANEL_WIDTH + boardDisplayWidth + VS_COL_WIDTH + boardDisplayWidth + SIDE_PANEL_WIDTH;
+      const startX = Math.max(1, Math.floor((cols - totalWidth) / 2) + 1);
+      sidePanel1X = startX;
+      boardLeft1 = startX + SIDE_PANEL_WIDTH;
+      vsColX = boardLeft1 + boardDisplayWidth + 1;
+      boardLeft2 = boardLeft1 + boardDisplayWidth + VS_COL_WIDTH;
+      sidePanel2X = boardLeft2 + boardDisplayWidth;
+    } else {
+      const totalWidth = boardDisplayWidth * 2 + VS_COL_WIDTH;
+      boardLeft1 = Math.max(1, Math.floor((cols - totalWidth) / 2) + 1);
+      boardLeft2 = boardLeft1 + boardDisplayWidth + VS_COL_WIDTH;
+      vsColX = boardLeft1 + boardDisplayWidth + 1;
+      sidePanel1X = 0;
+      sidePanel2X = 0;
+    }
+    const availHeight = rows - HEADER_HEIGHT - FOOTER_HEIGHT;
+    boardTop = HEADER_HEIGHT + Math.max(1, Math.floor((availHeight - boardDisplayHeight) / 2));
+  }
+  function getDropSpeed(player) {
+    const ramp = Math.floor(player.totalDrops / SPEED_RAMP_DROPS);
+    return Math.max(MIN_DROP_SPEED, BASE_DROP_SPEED - ramp);
+  }
+  function startResolution(player, isP1) {
+    if (isP1) p1AttackAccum = 0;
+    else p2AttackAccum = 0;
+    const diamondCleared = resolveDiamond(player.board);
+    if (diamondCleared.length > 0) {
+      applyGravityFull(player.board, player.powerGems);
+      if (isP1) p1IsDiamondClear = true;
+      else p2IsDiamondClear = true;
+    } else {
+      if (isP1) p1IsDiamondClear = false;
+      else p2IsDiamondClear = false;
+    }
+    player.powerGems = detectPowerGems(player.board);
+    const { cleared, clearedCells: crashCells, powerGemSizes } = resolveOneStep(player);
+    const clearedCells = [...diamondCleared, ...crashCells];
+    const totalStepCleared = cleared + diamondCleared.length;
+    if (clearedCells.length === 0) {
+      finishResolution(player, isP1);
+      return;
+    }
+    if (isP1) {
+      p1ClearedCells = clearedCells;
+      p1ChainCount++;
+      p1TotalCleared += totalStepCleared;
+      p1Phase = PHASE_FLASH;
+      p1PhaseTimer = FLASH_FRAMES;
+      const stepInfo = { gemsCleared: totalStepCleared, powerGemSizes, chainStep: p1ChainCount };
+      p1AttackAccum += calculateStepAttack(stepInfo);
+    } else {
+      p2ClearedCells = clearedCells;
+      p2ChainCount++;
+      p2TotalCleared += totalStepCleared;
+      p2Phase = PHASE_FLASH;
+      p2PhaseTimer = FLASH_FRAMES;
+      const stepInfo = { gemsCleared: totalStepCleared, powerGemSizes, chainStep: p2ChainCount };
+      p2AttackAccum += calculateStepAttack(stepInfo);
+    }
+    const bLeft = isP1 ? boardLeft1 : boardLeft2;
+    const chainCount = isP1 ? p1ChainCount : p2ChainCount;
+    if (chainCount >= 1) {
+      spawnComboText(chainCount, bLeft + boardDisplayWidth / 2, boardTop + 2, floatingTexts);
+      if (chainCount >= 2) {
+        spawnChainCounter(chainCount, bLeft + boardDisplayWidth / 2, boardTop + 3, floatingTexts);
+      }
+    }
+    for (const cell of clearedCells) {
+      const px = bLeft + 1 + cell.col * cellWidth + Math.floor(cellWidth / 2);
+      const py = boardTop + 1 + cell.row * cellHeight + Math.floor(cellHeight / 2);
+      spawnClearParticles(px, py, cell.color, 3, particles);
+    }
+    const shakeAmount = Math.min(3, Math.ceil(clearedCells.length / 4));
+    if (isP1) {
+      triggerShake(p1Shake, shakeAmount, 6);
+      triggerFlash(p1Flash, "\x1B[97m", 4);
+      p1Pose = "attack";
+      p1PoseTimer = 12;
+    } else {
+      triggerShake(p2Shake, shakeAmount, 6);
+      triggerFlash(p2Flash, "\x1B[97m", 4);
+      p2Pose = "attack";
+      p2PoseTimer = 12;
+    }
+  }
+  function resolveOneStep(player) {
+    player.powerGems = detectPowerGems(player.board);
+    const { targets, destroyedPowerGemSizes } = findCrashTargetsWithPowerInfo(player.board, player.powerGems);
+    if (targets.length === 0) return { cleared: 0, chains: 0, clearedCells: [], powerGemSizes: [] };
+    for (const t of targets) {
+      player.board[t.row][t.col] = null;
+    }
+    applyGravityFull(player.board, player.powerGems);
+    player.powerGems = [];
+    return { cleared: targets.length, chains: 1, clearedCells: targets, powerGemSizes: destroyedPowerGemSizes };
+  }
+  function buildGarbageDropState(player, defendedCount, normalCount, startCursor, dropPattern) {
+    const occupied = player.board.map((row) => row.map((cell) => cell !== null));
+    const timers = [];
+    for (let i = 0; i < defendedCount; i++) timers.push(COUNTER_TIMER_DEFENDED);
+    for (let i = 0; i < normalCount; i++) timers.push(COUNTER_TIMER_NORMAL);
+    const gems = [];
+    const patternRows = dropPattern.length;
+    const patternCols = dropPattern[0].length;
+    const patternLen = patternRows * patternCols;
+    let placedCount = 0;
+    function findLandingRow(col) {
+      for (let r = BOARD_ROWS - 1; r >= 0; r--) {
+        if (!occupied[r][col]) return r;
+      }
+      return -1;
+    }
+    for (let i = 0; i < timers.length; i++) {
+      const patternIdx = (startCursor + i) % patternLen;
+      const pRow = Math.floor(patternIdx / patternCols);
+      const pCol = patternIdx % patternCols;
+      const color = dropPattern[pRow][pCol];
+      let placeCol = -1;
+      let placeRow = -1;
+      const landing = findLandingRow(pCol);
+      if (landing >= 0) {
+        placeCol = pCol;
+        placeRow = landing;
+      } else {
+        for (let offset = 1; offset < BOARD_COLS; offset++) {
+          for (const dir of [1, -1]) {
+            const adjCol = pCol + offset * dir;
+            if (adjCol >= 0 && adjCol < BOARD_COLS) {
+              const adjLanding = findLandingRow(adjCol);
+              if (adjLanding >= 0) {
+                placeCol = adjCol;
+                placeRow = adjLanding;
+                break;
+              }
+            }
+          }
+          if (placeRow >= 0) break;
+        }
+      }
+      if (placeRow < 0 || placeCol < 0) continue;
+      occupied[placeRow][placeCol] = true;
+      gems.push({
+        col: placeCol,
+        targetRow: placeRow,
+        currentRow: 0,
+        timer: timers[i],
+        color,
+        delayFrames: i
+      });
+      placedCount++;
+    }
+    if (gems.length === 0) {
+      return { dropState: null, nextCursor: startCursor };
+    }
+    const nextCursor = (startCursor + placedCount) % patternLen;
+    return { dropState: { gems, frameTick: 0 }, nextCursor };
+  }
+  function triggerLoss(isP1) {
+    const loser = isP1 ? p1 : p2;
+    loser.alive = false;
+    gameState = "gameOver";
+    winner = isP1 ? 2 : 1;
+    gameOverTimer = 0;
+    pauseMenuSelection = 0;
+    if (isP1) {
+      p1Pose = "lose";
+      p2Pose = "win";
+    } else {
+      p2Pose = "lose";
+      p1Pose = "win";
+    }
+    const loserLeft = isP1 ? boardLeft1 : boardLeft2;
+    const winnerLeft = isP1 ? boardLeft2 : boardLeft1;
+    spawnCollapse(loserLeft, boardTop, boardDisplayWidth, BOARD_ROWS * cellHeight, particles);
+    spawnFirework2(winnerLeft + boardDisplayWidth / 2, boardTop + 3, particles);
+  }
+  function finalizePostResolution(player, isP1) {
+    if (checkGameOver(player.board)) {
+      triggerLoss(isP1);
+      return;
+    }
+    player.powerGems = detectPowerGems(player.board);
+    if (!spawnPair(player)) {
+      triggerLoss(isP1);
+    }
+  }
+  function tickGarbageDrop(player, isP1) {
+    const dropState = isP1 ? p1GarbageDrop : p2GarbageDrop;
+    if (!dropState) {
+      if (isP1) p1Phase = PHASE_NONE;
+      else p2Phase = PHASE_NONE;
+      finalizePostResolution(player, isP1);
+      return;
+    }
+    dropState.frameTick++;
+    if (dropState.frameTick < GARBAGE_DROP_STEP_FRAMES) return;
+    dropState.frameTick = 0;
+    let stillDropping = false;
+    for (const gem of dropState.gems) {
+      if (gem.delayFrames > 0) {
+        gem.delayFrames--;
+        stillDropping = true;
+        continue;
+      }
+      if (gem.currentRow < gem.targetRow) {
+        gem.currentRow++;
+        stillDropping = true;
+      }
+    }
+    if (stillDropping) return;
+    for (const gem of dropState.gems) {
+      if (player.board[gem.targetRow][gem.col] !== null) continue;
+      player.board[gem.targetRow][gem.col] = {
+        color: gem.color,
+        type: "counter",
+        counterTimer: gem.timer
+      };
+    }
+    if (isP1) {
+      p1GarbageDrop = null;
+      p1Phase = PHASE_NONE;
+    } else {
+      p2GarbageDrop = null;
+      p2Phase = PHASE_NONE;
+    }
+    finalizePostResolution(player, isP1);
+  }
+  function tickResolution(isP1) {
+    const phase = isP1 ? p1Phase : p2Phase;
+    const timer = isP1 ? p1PhaseTimer : p2PhaseTimer;
+    const player = isP1 ? p1 : p2;
+    if (phase === PHASE_NONE) return;
+    if (timer > 0) {
+      if (isP1) p1PhaseTimer--;
+      else p2PhaseTimer--;
+      return;
+    }
+    switch (phase) {
+      case PHASE_FLASH:
+        if (isP1) {
+          p1Phase = PHASE_DISSOLVE;
+          p1PhaseTimer = DISSOLVE_FRAMES;
+        } else {
+          p2Phase = PHASE_DISSOLVE;
+          p2PhaseTimer = DISSOLVE_FRAMES;
+        }
+        break;
+      case PHASE_DISSOLVE:
+        if (isP1) {
+          p1Phase = PHASE_GRAVITY;
+          p1PhaseTimer = GRAVITY_FRAMES;
+        } else {
+          p2Phase = PHASE_GRAVITY;
+          p2PhaseTimer = GRAVITY_FRAMES;
+        }
+        break;
+      case PHASE_GRAVITY:
+        if (isP1) {
+          p1Phase = PHASE_CHECK;
+          p1PhaseTimer = 0;
+        } else {
+          p2Phase = PHASE_CHECK;
+          p2PhaseTimer = 0;
+        }
+        break;
+      case PHASE_GARBAGE:
+        tickGarbageDrop(player, isP1);
+        break;
+      case PHASE_CHECK: {
+        player.powerGems = detectPowerGems(player.board);
+        const { targets: more, destroyedPowerGemSizes: pgSizes } = findCrashTargetsWithPowerInfo(player.board, player.powerGems);
+        if (more.length > 0) {
+          for (const t of more) {
+            player.board[t.row][t.col] = null;
+          }
+          applyGravityFull(player.board, player.powerGems);
+          player.powerGems = [];
+          if (isP1) {
+            p1ClearedCells = more;
+            p1ChainCount++;
+            p1TotalCleared += more.length;
+            p1Phase = PHASE_FLASH;
+            p1PhaseTimer = FLASH_FRAMES;
+            const stepInfo = { gemsCleared: more.length, powerGemSizes: pgSizes, chainStep: p1ChainCount };
+            p1AttackAccum += calculateStepAttack(stepInfo);
+          } else {
+            p2ClearedCells = more;
+            p2ChainCount++;
+            p2TotalCleared += more.length;
+            p2Phase = PHASE_FLASH;
+            p2PhaseTimer = FLASH_FRAMES;
+            const stepInfo = { gemsCleared: more.length, powerGemSizes: pgSizes, chainStep: p2ChainCount };
+            p2AttackAccum += calculateStepAttack(stepInfo);
+          }
+          const chainCount = isP1 ? p1ChainCount : p2ChainCount;
+          const bLeft = isP1 ? boardLeft1 : boardLeft2;
+          spawnComboText(chainCount, bLeft + boardDisplayWidth / 2, boardTop + 2, floatingTexts);
+          for (const cell of more) {
+            const px = bLeft + 1 + cell.col * cellWidth + Math.floor(cellWidth / 2);
+            const py = boardTop + 1 + cell.row * cellHeight + Math.floor(cellHeight / 2);
+            spawnClearParticles(px, py, cell.color, 4 + chainCount, particles);
+          }
+          triggerShake(isP1 ? p1Shake : p2Shake, Math.min(4, chainCount), 8);
+        } else {
+          const totalCleared = isP1 ? p1TotalCleared : p2TotalCleared;
+          const chainCount = isP1 ? p1ChainCount : p2ChainCount;
+          const dmgMod = isP1 ? p1Character.damageModifier : p2Character.damageModifier;
+          const isDiamond = isP1 ? p1IsDiamondClear : p2IsDiamondClear;
+          const rawAttack = isP1 ? p1AttackAccum : p2AttackAccum;
+          let attack = applyAttackModifiers(rawAttack, dmgMod, isDiamond);
+          if (attack > 0 && player.pendingGarbage > 0) {
+            const defense = resolveCounterAttack(attack, player.pendingGarbage);
+            attack = defense.remainingAttack;
+            player.pendingGarbage = defense.remainingPending;
+            player.pendingCounteredGarbage = defense.pendingStartsAtThree ? defense.remainingPending : 0;
+            if (defense.canceledGems > 0) {
+              const left = isP1 ? boardLeft1 : boardLeft2;
+              floatingTexts.push({
+                text: `DEFENSE -${defense.canceledGems}`,
+                x: left + 2,
+                y: Math.max(1, boardTop - 1),
+                color: "\x1B[96m",
+                frames: 18,
+                maxFrames: 18
+              });
+            }
+          }
+          if (attack > 0) {
+            const opponent = isP1 ? p2 : p1;
+            opponent.pendingGarbage += attack;
+            const fromBLeft = isP1 ? boardLeft1 : boardLeft2;
+            const toBLeft = isP1 ? boardLeft2 : boardLeft1;
+            spawnProjectile(
+              fromBLeft + boardDisplayWidth / 2,
+              toBLeft + boardDisplayWidth / 2,
+              boardTop + Math.floor(boardDisplayHeight / 2),
+              attack,
+              projectiles
+            );
+            if (isP1) {
+              p2Pose = "hit";
+              p2PoseTimer = 10;
+            } else {
+              p1Pose = "hit";
+              p1PoseTimer = 10;
+            }
+            triggerFlash(isP1 ? p2Flash : p1Flash, "\x1B[91m", 6);
+            triggerShake(isP1 ? p2Shake : p1Shake, Math.min(3, Math.ceil(attack / 2)), 6);
+          }
+          player.score += totalCleared * 10 + (chainCount > 1 ? chainCount * 50 : 0);
+          finishResolution(player, isP1);
+        }
+        break;
+      }
+    }
+  }
+  function finishResolution(player, isP1) {
+    if (isP1) {
+      p1Phase = PHASE_NONE;
+      p1PhaseTimer = 0;
+      p1ChainCount = 0;
+      p1TotalCleared = 0;
+      p1ClearedCells = [];
+      p1AttackAccum = 0;
+    } else {
+      p2Phase = PHASE_NONE;
+      p2PhaseTimer = 0;
+      p2ChainCount = 0;
+      p2TotalCleared = 0;
+      p2ClearedCells = [];
+      p2AttackAccum = 0;
+    }
+    decrementCounters(player);
+    player.powerGems = detectPowerGems(player.board);
+    const { targets: postCounterTargets } = findCrashTargetsWithPowerInfo(player.board, player.powerGems);
+    if (postCounterTargets.length > 0) {
+      startResolution(player, isP1);
+      return;
+    }
+    if (player.pendingGarbage > 0) {
+      const incomingCount = player.pendingGarbage;
+      const defendedCount = Math.min(player.pendingCounteredGarbage, player.pendingGarbage);
+      const normalCount = player.pendingGarbage - defendedCount;
+      const cursor = isP1 ? p1GarbagePatternCursor : p2GarbagePatternCursor;
+      const attackerPattern = isP1 ? p2Character.dropPattern : p1Character.dropPattern;
+      const { dropState, nextCursor } = buildGarbageDropState(player, defendedCount, normalCount, cursor, attackerPattern);
+      if (isP1) p1GarbagePatternCursor = nextCursor;
+      else p2GarbagePatternCursor = nextCursor;
+      player.pendingGarbage = 0;
+      player.pendingCounteredGarbage = 0;
+      const left = isP1 ? boardLeft1 : boardLeft2;
+      floatingTexts.push({
+        text: `DROP +${incomingCount}`,
+        x: left + 2,
+        y: Math.max(1, boardTop - 1),
+        color: "\x1B[1;91m",
+        frames: 20,
+        maxFrames: 20
+      });
+      if (dropState) {
+        if (isP1) {
+          p1GarbageDrop = dropState;
+          p1Phase = PHASE_GARBAGE;
+          p1PhaseTimer = 0;
+        } else {
+          p2GarbageDrop = dropState;
+          p2Phase = PHASE_GARBAGE;
+          p2PhaseTimer = 0;
+        }
+        return;
+      }
+    }
+    finalizePostResolution(player, isP1);
+  }
+  function update() {
+    if (gameState !== "running") return;
+    glitchFrame++;
+    updateParticles2(particles);
+    updateFloatingTexts(floatingTexts);
+    updateProjectiles(projectiles);
+    if (p1PoseTimer > 0) {
+      p1PoseTimer--;
+      if (p1PoseTimer <= 0) p1Pose = "idle";
+    }
+    if (p2PoseTimer > 0) {
+      p2PoseTimer--;
+      if (p2PoseTimer <= 0) p2Pose = "idle";
+    }
+    if (p1Phase !== PHASE_NONE) {
+      tickResolution(true);
+    }
+    if (p2Phase !== PHASE_NONE) {
+      tickResolution(false);
+    }
+    if (p1Phase === PHASE_NONE && p1.currentPair && p1.alive) {
+      p1DropSpeed = getDropSpeed(p1);
+      p1DropTimer++;
+      if (p1DropTimer >= p1DropSpeed) {
+        p1DropTimer = 0;
+        if (!dropPair(p1.currentPair, p1.board)) {
+          lockAndResolve(p1, true);
+        }
+      }
+    }
+    if (p2Phase === PHASE_NONE && p2.currentPair && p2.alive) {
+      p2DropSpeed = Math.max(MIN_DROP_SPEED, Math.floor(getDropSpeed(p2) / aiState.difficulty.dropSpeedBoost));
+      const action = aiTick(p2, aiState);
+      switch (action) {
+        case "rotate_cw":
+          rotatePair(p2.currentPair, p2.board, true);
+          break;
+        case "rotate_ccw":
+          rotatePair(p2.currentPair, p2.board, false);
+          break;
+        case "move": {
+          const dir = getAIMoveDirection(p2, aiState);
+          if (dir !== 0) movePair(p2.currentPair, p2.board, dir);
+          break;
+        }
+        case "drop":
+          if (!dropPair(p2.currentPair, p2.board)) {
+            lockAndResolve(p2, false);
+          }
+          break;
+      }
+      p2DropTimer++;
+      if (p2DropTimer >= p2DropSpeed) {
+        p2DropTimer = 0;
+        if (p2.currentPair && !dropPair(p2.currentPair, p2.board)) {
+          lockAndResolve(p2, false);
+        }
+      }
+    }
+  }
+  function lockAndResolve(player, isP1) {
+    if (!player.currentPair) return;
+    lockPair(player.currentPair, player.board);
+    player.currentPair = null;
+    applyGravityFull(player.board, player.powerGems);
+    if (!isP1) {
+      aiState.decided = false;
+      aiState.thinkTimer = 0;
+      aiState.moveTimer = 0;
+    }
+    startResolution(player, isP1);
+  }
+  function render() {
+    if (!running) return;
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    if (cols < MIN_COLS || rows < MIN_ROWS) {
+      let output2 = "\x1B[2J\x1B[H";
+      output2 += `\x1B[${Math.floor(rows / 2)};${Math.max(1, Math.floor(cols / 2) - 10)}H`;
+      output2 += `${themeColor}Need ${MIN_COLS}\xD7${MIN_ROWS} (have ${cols}\xD7${rows})\x1B[0m`;
+      terminal.write(output2);
+      return;
+    }
+    calculateLayout();
+    let output = "\x1B[2J\x1B[H";
+    switch (gameState) {
+      case "difficulty":
+        output += renderDifficultyScreen();
+        break;
+      case "characterSelect":
+        output += renderCharacterSelectScreen();
+        break;
+      case "running":
+        output += renderGame();
+        break;
+      case "paused":
+        output += renderGame();
+        output += renderPauseOverlay();
+        break;
+      case "gameOver":
+        output += renderGame({
+          showEffects: false,
+          showHud: false,
+          showControls: false,
+          showVs: false
+        });
+        output += renderGameOverOverlay();
+        break;
+    }
+    terminal.write(output);
+  }
+  function renderDifficultyScreen() {
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    const centerX = Math.floor(cols / 2);
+    let output = "";
+    const titleY = Math.max(2, Math.floor(rows / 2) - 8);
+    for (let i = 0; i < title.length; i++) {
+      let line = title[i];
+      if (Math.random() < 0.15) {
+        const pos = Math.floor(Math.random() * line.length);
+        const glitchChar = GLITCH_CHARS2[Math.floor(Math.random() * GLITCH_CHARS2.length)];
+        line = line.substring(0, pos) + glitchChar + line.substring(pos + 1);
+      }
+      const x = Math.max(1, centerX - Math.floor(line.length / 2));
+      const color = i < 2 ? themeColor : "\x1B[93m";
+      output += `\x1B[${titleY + i};${x}H${color}\x1B[1m${line}\x1B[0m`;
+    }
+    const subtitle = "\u2554\u2550\u2550 GEM BATTLE VS AI \u2550\u2550\u2557";
+    const subX = Math.max(1, centerX - Math.floor(subtitle.length / 2));
+    output += `\x1B[${titleY + title.length + 1};${subX}H${themeColor}${subtitle}\x1B[0m`;
+    const diffY = titleY + title.length + 4;
+    const diffs = ["easy", "normal", "hard"];
+    const diffLabels = ["EASY", "NORMAL", "HARD"];
+    const diffDescs = ["Relaxed pace, AI makes mistakes", "Balanced challenge", "Fast & ruthless AI"];
+    for (let i = 0; i < diffs.length; i++) {
+      const isSelected = i === difficultySelection;
+      const label = `[${i + 1}] ${diffLabels[i]}`;
+      const text = isSelected ? `\u25BA ${label} \u25C4` : `  ${label}  `;
+      const style = isSelected ? "\x1B[1;93m" : `\x1B[2m${themeColor}`;
+      const x = Math.max(1, centerX - Math.floor(text.length / 2));
+      output += `\x1B[${diffY + i * 2};${x}H${style}${text}\x1B[0m`;
+      if (isSelected) {
+        const descX = Math.max(1, centerX - Math.floor(diffDescs[i].length / 2));
+        output += `\x1B[${diffY + i * 2 + 1};${descX}H\x1B[2m${themeColor}${diffDescs[i]}\x1B[0m`;
+      }
+    }
+    const controlsY = diffY + 8;
+    const controls = "\u2191\u2193 Select  Enter Confirm  Q Quit";
+    const cX = Math.max(1, centerX - Math.floor(controls.length / 2));
+    output += `\x1B[${controlsY};${cX}H\x1B[2m${themeColor}${controls}\x1B[0m`;
+    const refY = controlsY + 2;
+    const refLines = [
+      "\u2190\u2192/AD Move  \u2191/W Rotate  Z Counter-rotate",
+      "\u2193/S Soft drop  Space Hard drop  ESC Pause"
+    ];
+    for (let i = 0; i < refLines.length; i++) {
+      const rx = Math.max(1, centerX - Math.floor(refLines[i].length / 2));
+      output += `\x1B[${refY + i};${rx}H\x1B[2m\x1B[90m${refLines[i]}\x1B[0m`;
+    }
+    return output;
+  }
+  const PATTERN_PREVIEW_COLORS = {
+    red: "\x1B[1;38;5;196m",
+    green: "\x1B[1;38;5;46m",
+    blue: "\x1B[1;38;5;27m",
+    yellow: "\x1B[1;38;5;226m"
+  };
+  function renderCharacterSelectScreen() {
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    const centerX = Math.floor(cols / 2);
+    let output = "";
+    const titleY = Math.max(2, Math.floor(rows / 2) - 14);
+    const selectTitle = "\u2554\u2550\u2550 SELECT YOUR FIGHTER \u2550\u2550\u2557";
+    const stX = Math.max(1, centerX - Math.floor(selectTitle.length / 2));
+    output += `\x1B[${titleY};${stX}H${themeColor}\x1B[1m${selectTitle}\x1B[0m`;
+    const badge = `[${selectedDifficulty.name}]`;
+    const bX = Math.max(1, centerX - Math.floor(badge.length / 2));
+    output += `\x1B[${titleY + 1};${bX}H\x1B[2m${themeColor}${badge}\x1B[0m`;
+    const gridY = titleY + 3;
+    const cellW = 11;
+    const selectedIdx = CHAR_GRID[charGridRow][charGridCol];
+    for (let row = 0; row < CHAR_GRID.length; row++) {
+      const rowChars = CHAR_GRID[row];
+      const rowWidth = rowChars.length * cellW;
+      const rowStartX = Math.max(1, centerX - Math.floor(rowWidth / 2));
+      for (let col = 0; col < rowChars.length; col++) {
+        const charIdx = rowChars[col];
+        const char2 = CHARACTERS[charIdx];
+        const isSelected = charIdx === selectedIdx;
+        const x = rowStartX + col * cellW;
+        const y = gridY + row * 3;
+        const name = char2.name.slice(0, cellW - 2).padEnd(cellW - 2);
+        if (isSelected) {
+          output += `\x1B[${y};${x}H\x1B[1;93m\u25BA${name}\u25C4\x1B[0m`;
+        } else {
+          output += `\x1B[${y};${x}H${themeColor} ${name} \x1B[0m`;
+        }
+        const dmgStr = char2.damageModifier !== 1 ? `${Math.round(char2.damageModifier * 100)}%` : "   ";
+        const dmgColor = char2.damageModifier > 1 ? "\x1B[92m" : char2.damageModifier < 1 ? "\x1B[96m" : "\x1B[90m";
+        output += `\x1B[${y + 1};${x + 1}H${dmgColor}${dmgStr}\x1B[0m`;
+      }
+    }
+    const char = CHARACTERS[selectedIdx];
+    const detailY = gridY + CHAR_GRID.length * 3 + 1;
+    const charTitle = `${char.name} \u2014 ${char.description}`;
+    const ctX = Math.max(1, centerX - Math.floor(charTitle.length / 2));
+    output += `\x1B[${detailY};${ctX}H\x1B[1;97m${charTitle}\x1B[0m`;
+    const dmgLabel = char.damageModifier === 1 ? "Damage: 100% (standard)" : char.damageModifier > 1 ? `Damage: ${Math.round(char.damageModifier * 100)}% (bonus)` : `Damage: ${Math.round(char.damageModifier * 100)}% (reduced)`;
+    const dmgLabelColor = char.damageModifier > 1 ? "\x1B[92m" : char.damageModifier < 1 ? "\x1B[96m" : "\x1B[90m";
+    const dlX = Math.max(1, centerX - Math.floor(dmgLabel.length / 2));
+    output += `\x1B[${detailY + 1};${dlX}H${dmgLabelColor}${dmgLabel}\x1B[0m`;
+    const previewWidth = 6 * 2;
+    const previewX = Math.max(1, centerX - Math.floor(previewWidth / 2));
+    const previewY = detailY + 3;
+    output += `\x1B[${previewY - 1};${previewX}H\x1B[2m${themeColor}Drop Pattern:\x1B[0m`;
+    for (let pr = 0; pr < char.dropPattern.length; pr++) {
+      let rowStr = "";
+      for (let pc = 0; pc < char.dropPattern[pr].length; pc++) {
+        const color = char.dropPattern[pr][pc];
+        rowStr += `${PATTERN_PREVIEW_COLORS[color]}\u2588\u2588\x1B[0m`;
+      }
+      output += `\x1B[${previewY + pr};${previewX}H${rowStr}`;
+    }
+    const portraitX = previewX + previewWidth + 3;
+    const portraitLines = char.portraits.idle;
+    output += renderPortrait(portraitLines, portraitX, previewY, themeColor);
+    const controlsY = previewY + char.dropPattern.length + 2;
+    const controls = "\u2190\u2192\u2191\u2193 Select  Enter Confirm  Esc Back";
+    const cX = Math.max(1, centerX - Math.floor(controls.length / 2));
+    output += `\x1B[${controlsY};${cX}H\x1B[2m${themeColor}${controls}\x1B[0m`;
+    return output;
+  }
+  function renderGame(options) {
+    const config = {
+      showEffects: options?.showEffects ?? true,
+      showHud: options?.showHud ?? true,
+      showControls: options?.showControls ?? true,
+      showVs: options?.showVs ?? true
+    };
+    let output = "";
+    output += renderHeaderBar();
+    const s1 = updateShake(p1Shake);
+    const s2 = updateShake(p2Shake);
+    output += renderBoard(p1, boardLeft1 + s1.dx, boardTop + s1.dy, true, true, p1Phase, p1PhaseTimer, p1ClearedCells, p1Flash);
+    output += renderBoard(p2, boardLeft2 + s2.dx, boardTop + s2.dy, false, false, p2Phase, p2PhaseTimer, p2ClearedCells, p2Flash);
+    if (config.showVs) {
+      output += renderVSColumn();
+    }
+    if (showSidePanels && config.showHud) {
+      output += renderSidePanel(true);
+      output += renderSidePanel(false);
+    }
+    if (!showSidePanels) {
+      output += `\x1B[${boardTop - 1};${boardLeft1 + 2}H${themeColor}${p1Character.name}\x1B[0m`;
+      output += `\x1B[${boardTop - 1};${boardLeft2 + 2}H\x1B[91m${p2Character.name}\x1B[0m`;
+      output += renderNextStrip(p1, boardLeft1, Math.max(1, boardTop - 2), themeColor);
+      output += renderNextStrip(p2, boardLeft2, Math.max(1, boardTop - 2), "\x1B[91m");
+      if (config.showHud) {
+        const panelY = boardTop + boardDisplayHeight + 1;
+        output += renderScorePanel(
+          boardLeft1,
+          panelY,
+          p1.score,
+          p1.pendingGarbage,
+          themeColor,
+          `S${Math.round(BASE_DROP_SPEED / Math.max(1, p1DropSpeed) * 100)}%`
+        );
+        output += renderScorePanel(
+          boardLeft2,
+          panelY,
+          p2.score,
+          p2.pendingGarbage,
+          "\x1B[1;38;5;203m",
+          "AI"
+        );
+      }
+    }
+    if (config.showEffects) {
+      output += renderParticles(particles, 1, 1, terminal.cols, terminal.rows);
+      output += renderFloatingTexts(floatingTexts);
+      output += renderProjectiles(projectiles);
+    }
+    if (config.showControls) {
+      output += renderFooterBar();
+    }
+    return output;
+  }
+  function renderNextStrip(player, left, y, accent) {
+    if (!player.nextPair) return "";
+    let output = "";
+    output += `\x1B[${y};${left}H${accent}\x1B[1mNEXT\x1B[0m `;
+    output += renderGemCell(player.nextPair.primary, false, false);
+    output += renderGemCell(player.nextPair.secondary, false, false);
+    output += ` \x1B[2m${accent}\u25CF\u25CF\u25CF\x1B[0m`;
+    return output;
+  }
+  function renderScorePanel(left, y, score, pending, accent, tag) {
+    const { levelLabel, levelColor } = getIncomingThreatLevel(pending);
+    const meterWidth = 5;
+    const filled = Math.min(meterWidth, pending);
+    const meter = `${"\u25A0".repeat(filled)}${"\xB7".repeat(meterWidth - filled)}`;
+    const scoreLine = `SCORE ${score.toString().padStart(6, "0")} ${tag}`.slice(0, boardDisplayWidth).padEnd(boardDisplayWidth, " ");
+    const statusLine = `IN${pending.toString().padStart(2, "0")} ${meter} ${levelLabel}`.slice(0, boardDisplayWidth).padEnd(boardDisplayWidth, " ");
+    let output = "";
+    output += `\x1B[${y};${left}H${accent}\x1B[48;5;237m${scoreLine}\x1B[0m`;
+    output += `\x1B[${y + 1};${left}H${levelColor}\x1B[48;5;235m${statusLine}\x1B[0m`;
+    return output;
+  }
+  function getIncomingThreatLevel(pending) {
+    if (pending <= 0) return { levelLabel: "CLEAR", levelColor: "\x1B[92m" };
+    if (pending <= 2) return { levelLabel: "LOW", levelColor: "\x1B[93m" };
+    if (pending <= 5) return { levelLabel: "HIGH", levelColor: "\x1B[91m" };
+    return { levelLabel: "DANGER", levelColor: "\x1B[1;91m" };
+  }
+  function renderBoard(player, left, top, isP1Board, showGhost, phase, phaseTimer, clearedCells, flash) {
+    let output = "";
+    const board = player.board;
+    const pair = player.currentPair;
+    const flashColor = updateFlash(flash);
+    const borderColor = flashColor || themeColor;
+    output += `\x1B[${top};${left}H${borderColor}\u2554${"\u2550".repeat(BOARD_COLS * cellWidth)}\u2557\x1B[0m`;
+    const clearedSet = new Set(clearedCells.map((c) => `${c.row},${c.col}`));
+    let ghost = null;
+    if (showGhost && pair) {
+      ghost = getGhostPosition(pair, board);
+    }
+    for (let r = 0; r < BOARD_ROWS; r++) {
+      let rowContent0 = "";
+      let rowContentN = "";
+      for (let c = 0; c < BOARD_COLS; c++) {
+        const gem = board[r][c];
+        const isCleared = clearedSet.has(`${r},${c}`);
+        let pairGem = null;
+        if (pair) {
+          if (pair.row === r && pair.col === c) pairGem = pair.primary;
+          const sec = getSecondaryPos(pair);
+          if (sec.row === r && sec.col === c) pairGem = pair.secondary;
+        }
+        if (pairGem) {
+          const cell = renderGemCell(pairGem, false, false);
+          rowContent0 += cell;
+          rowContentN += cell;
+        } else if (isCleared && phase === PHASE_FLASH) {
+          const cell = clearedCells.find((cc) => cc.row === r && cc.col === c);
+          let s;
+          if (cell && phaseTimer % 2 === 0) {
+            s = `\x1B[1;97m${cellSolid}\x1B[0m`;
+          } else {
+            s = `${GEM_COLORS[cell?.color || "red"]}${cellSolid}\x1B[0m`;
+          }
+          rowContent0 += s;
+          rowContentN += s;
+        } else if (isCleared && phase === PHASE_DISSOLVE) {
+          const stage = DISSOLVE_FRAMES - phaseTimer;
+          let s;
+          if (stage === 0) s = `\x1B[2m${cellPower}\x1B[0m`;
+          else if (stage === 1) s = `\x1B[2m${cellGhost}\x1B[0m`;
+          else s = cellEmpty;
+          rowContent0 += s;
+          rowContentN += s;
+        } else if (gem) {
+          const inPowerGem = gem.powerGemId !== void 0;
+          const cell = renderGemCell(gem, inPowerGem, false);
+          rowContent0 += cell;
+          rowContentN += cell;
+        } else {
+          let isGhost = false;
+          if (ghost) {
+            if (ghost.primaryRow === r && ghost.primaryCol === c || ghost.secondaryRow === r && ghost.secondaryCol === c) {
+              isGhost = true;
+            }
+          }
+          if (isGhost) {
+            const g = `\x1B[2;90m${cellGhost}\x1B[0m`;
+            rowContent0 += g;
+            rowContentN += g;
+          } else {
+            rowContent0 += `\x1B[38;5;238m${cellEmptyDot}\x1B[0m`;
+            rowContentN += cellEmpty;
+          }
+        }
+      }
+      for (let h = 0; h < cellHeight; h++) {
+        const rowY = top + 1 + r * cellHeight + h;
+        output += `\x1B[${rowY};${left}H${borderColor}\u2551\x1B[0m`;
+        output += h === 0 ? rowContent0 : rowContentN;
+        output += `${borderColor}\u2551\x1B[0m`;
+      }
+    }
+    output += `\x1B[${top + boardDisplayHeight - 1};${left}H${borderColor}\u255A${"\u2550".repeat(BOARD_COLS * cellWidth)}\u255D\x1B[0m`;
+    const garbageDrop = isP1Board ? p1GarbageDrop : p2GarbageDrop;
+    if (garbageDrop) {
+      for (const g of garbageDrop.gems) {
+        if (g.delayFrames > 0) continue;
+        const row = Math.max(0, Math.min(BOARD_ROWS - 1, g.currentRow));
+        const cellStr = renderGemCell({ color: g.color, type: "counter", counterTimer: g.timer }, false, false);
+        for (let h = 0; h < cellHeight; h++) {
+          const y = top + 1 + row * cellHeight + h;
+          const x = left + 1 + g.col * cellWidth;
+          output += `\x1B[${y};${x}H${cellStr}`;
+        }
+      }
+    }
+    return output;
+  }
+  function renderGemCell(gem, isPowerGem, _dimmed) {
+    const color = GEM_COLORS[gem.color];
+    switch (gem.type) {
+      case "normal":
+        if (isPowerGem) {
+          return `${color}${cellPower}\x1B[0m`;
+        }
+        return `${color}${cellSolid}\x1B[0m`;
+      case "crash":
+        return `\x1B[1m${color}${cellCrash}\x1B[0m`;
+      case "counter": {
+        const bg = COUNTER_BG_COLORS[gem.color];
+        if (gem.counterTimer !== void 0) {
+          const timerStr = gem.counterTimer.toString().padStart(2, " ");
+          return `\x1B[1;97m${bg}${timerStr.padEnd(cellWidth, " ")}\x1B[0m`;
+        }
+        return `\x1B[1;97m${bg}${" ?".padEnd(cellWidth, " ")}\x1B[0m`;
+      }
+      case "diamond":
+        return `\x1B[1;97m${cellDiamond}\x1B[0m`;
+      default:
+        return `${color}${cellSolid}\x1B[0m`;
+    }
+  }
+  function renderVSColumn() {
+    let output = "";
+    const x = vsColX;
+    const y = boardTop + Math.max(2, Math.floor(boardDisplayHeight / 2) - 5);
+    output += `\x1B[${Math.max(1, y - 2)};${x + 1}H\x1B[1;96mHYPER\x1B[0m`;
+    output += `\x1B[${Math.max(1, y - 1)};${x + 1}H\x1B[1;95mFIGHT\x1B[0m`;
+    output += `\x1B[${y};${x + 2}H\x1B[1;93mVS\x1B[0m`;
+    const p1Lines = p1Character.portraits[p1Pose];
+    output += renderPortrait(p1Lines, x, y + 2, themeColor);
+    const p2Lines = p2Character.portraits[p2Pose];
+    output += renderPortrait(p2Lines, x, y + 6, "\x1B[91m");
+    const maxEnergy = 10;
+    const p1Energy = p1ChainCount * 3 + p1TotalCleared;
+    output += renderEnergyBar(x + 8, y + 2, p1Energy, maxEnergy);
+    return output;
+  }
+  function renderHeaderBar() {
+    const cols = terminal.cols;
+    let output = "";
+    const leftText = " HYPER FIGHTER";
+    const rightText = `${p1Character.name} vs ${p2Character.name} [${selectedDifficulty.name}] `;
+    const padLen = Math.max(0, cols - leftText.length - rightText.length);
+    const row1 = leftText + " ".repeat(padLen) + rightText;
+    output += `\x1B[1;1H\x1B[1;97m\x1B[48;5;236m${row1.slice(0, cols).padEnd(cols, " ")}\x1B[0m`;
+    output += `\x1B[2;1H\x1B[38;5;240m${"\u2500".repeat(cols)}\x1B[0m`;
+    return output;
+  }
+  function renderFooterBar() {
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    let output = "";
+    output += `\x1B[${rows - 1};1H\x1B[38;5;240m${"\u2500".repeat(cols)}\x1B[0m`;
+    const controls = "\u2190\u2192 Move  \u2191/W Rotate  Z CCW  \u2193/S Soft  Space Drop  ESC Pause";
+    const cx = Math.max(1, Math.floor((cols - controls.length) / 2) + 1);
+    output += `\x1B[${rows};${cx}H\x1B[2m\x1B[90m${controls}\x1B[0m`;
+    return output;
+  }
+  function renderMiniBar(value, max, width, fillColor) {
+    const filled = Math.min(width, Math.round(value / Math.max(1, max) * width));
+    const empty = width - filled;
+    return `${fillColor}${"\u25A0".repeat(filled)}\x1B[38;5;238m${"\xB7".repeat(empty)}\x1B[0m`;
+  }
+  function renderSidePanel(isLeft) {
+    const player = isLeft ? p1 : p2;
+    const x = isLeft ? sidePanel1X : sidePanel2X;
+    const accent = isLeft ? themeColor : "\x1B[1;38;5;203m";
+    const dropSpeed = isLeft ? p1DropSpeed : p2DropSpeed;
+    const chainCount = isLeft ? p1ChainCount : p2ChainCount;
+    let output = "";
+    let y = boardTop + 1;
+    output += `\x1B[${y};${x}H${accent}\x1B[1mNEXT\x1B[0m`;
+    y++;
+    if (player.nextPair) {
+      output += `\x1B[${y};${x}H`;
+      output += renderGemCell(player.nextPair.primary, false, false);
+      output += renderGemCell(player.nextPair.secondary, false, false);
+    }
+    y += 2;
+    output += `\x1B[${y};${x}H\x1B[38;5;245mSCORE\x1B[0m`;
+    y++;
+    output += `\x1B[${y};${x}H${accent}${player.score.toString().padStart(7, "0")}\x1B[0m`;
+    y += 2;
+    output += `\x1B[${y};${x}H\x1B[38;5;245mSPEED\x1B[0m`;
+    y++;
+    const speedPct = Math.round(BASE_DROP_SPEED / Math.max(1, dropSpeed) * 100);
+    output += `\x1B[${y};${x}H${speedPct >= 200 ? "\x1B[91m" : speedPct >= 150 ? "\x1B[93m" : "\x1B[92m"}${speedPct}%\x1B[0m `;
+    output += renderMiniBar(speedPct, 300, 6, speedPct >= 200 ? "\x1B[91m" : "\x1B[92m");
+    y += 2;
+    if (chainCount > 0) {
+      output += `\x1B[${y};${x}H\x1B[38;5;245mCHAIN\x1B[0m`;
+      y++;
+      output += `\x1B[${y};${x}H\x1B[1;93m${chainCount}\x1B[0m`;
+      y += 2;
+    } else {
+      y += 3;
+    }
+    const { levelLabel, levelColor } = getIncomingThreatLevel(player.pendingGarbage);
+    output += `\x1B[${y};${x}H\x1B[38;5;245mINCOMING\x1B[0m`;
+    y++;
+    output += `\x1B[${y};${x}H${levelColor}${player.pendingGarbage.toString().padStart(2, "0")}\x1B[0m `;
+    output += renderMiniBar(player.pendingGarbage, 10, 6, levelColor);
+    y++;
+    output += `\x1B[${y};${x}H${levelColor}${levelLabel}\x1B[0m`;
+    return output;
+  }
+  function renderPauseOverlay() {
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    const centerX = Math.floor(cols / 2);
+    const centerY = Math.floor(rows / 2);
+    let output = "";
+    output += `\x1B[${centerY - 3};${centerX - 4}H\x1B[1;5m${themeColor}\u23F8 PAUSED\x1B[0m`;
+    output += renderSimpleMenu(PAUSE_MENU_ITEMS, pauseMenuSelection, {
+      centerX,
+      startY: centerY - 1,
+      showShortcuts: true
+    });
+    return output;
+  }
+  function renderGameOverOverlay() {
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    const centerX = Math.floor(cols / 2);
+    const centerY = Math.floor(rows / 2);
+    let output = "";
+    gameOverTimer++;
+    const panelWidth = Math.min(44, Math.max(34, cols - 8));
+    const panelHeight = 12;
+    const panelLeft = Math.max(2, centerX - Math.floor(panelWidth / 2));
+    const panelTop = Math.max(2, centerY - Math.floor(panelHeight / 2));
+    for (let y = 0; y < panelHeight; y++) {
+      output += `\x1B[${panelTop + y};${panelLeft}H\x1B[40m${" ".repeat(panelWidth)}\x1B[0m`;
+    }
+    output += `\x1B[${panelTop};${panelLeft}H${themeColor}\u2554${"\u2550".repeat(panelWidth - 2)}\u2557\x1B[0m`;
+    for (let y = 1; y < panelHeight - 1; y++) {
+      output += `\x1B[${panelTop + y};${panelLeft}H${themeColor}\u2551\x1B[0m`;
+      output += `\x1B[${panelTop + y};${panelLeft + panelWidth - 1}H${themeColor}\u2551\x1B[0m`;
+    }
+    output += `\x1B[${panelTop + panelHeight - 1};${panelLeft}H${themeColor}\u255A${"\u2550".repeat(panelWidth - 2)}\u255D\x1B[0m`;
+    const winnerChar = winner === 1 ? p1Character : p2Character;
+    const winText = winner === 1 ? `${winnerChar.name} WINS!` : `${winnerChar.name} WINS!`;
+    const winColor = winner === 1 ? "\x1B[1;92m" : "\x1B[1;91m";
+    const winX = Math.max(1, centerX - Math.floor(winText.length / 2));
+    output += `\x1B[${panelTop + 2};${winX}H${winColor}${winText}\x1B[0m`;
+    const scoreLine = `${p1Character.name}: ${p1.score}  |  ${p2Character.name}: ${p2.score}`;
+    const sX = Math.max(1, centerX - Math.floor(scoreLine.length / 2));
+    output += `\x1B[${panelTop + 4};${sX}H${themeColor}${scoreLine}\x1B[0m`;
+    const menuItems = [
+      { label: "RESTART", shortcut: "R" },
+      { label: "QUIT", shortcut: "Q" },
+      { label: "LIST GAMES", shortcut: "L" },
+      { label: "NEXT GAME", shortcut: "N" }
+    ];
+    output += renderSimpleMenu(menuItems, pauseMenuSelection, {
+      centerX,
+      startY: panelTop + 6,
+      showShortcuts: true
+    });
+    return output;
+  }
+  const keyListener = terminal.onKey(({ domEvent }) => {
+    if (!running) return;
+    domEvent.preventDefault();
+    domEvent.stopPropagation();
+    const key = domEvent.key.toLowerCase();
+    switch (gameState) {
+      case "difficulty":
+        handleDifficultyInput(key, domEvent);
+        break;
+      case "characterSelect":
+        handleCharacterSelectInput(key, domEvent);
+        break;
+      case "running":
+        handleGameInput(key, domEvent);
+        break;
+      case "paused":
+        handlePauseInput(key, domEvent);
+        break;
+      case "gameOver":
+        handleGameOverInput(key, domEvent);
+        break;
+    }
+  });
+  function handleDifficultyInput(key, domEvent) {
+    if (domEvent.key === "ArrowUp" || key === "w") {
+      difficultySelection = (difficultySelection - 1 + 3) % 3;
+    } else if (domEvent.key === "ArrowDown" || key === "s") {
+      difficultySelection = (difficultySelection + 1) % 3;
+    } else if (domEvent.key === "Enter" || domEvent.key === " ") {
+      const diffs = ["easy", "normal", "hard"];
+      selectedDifficulty = DIFFICULTIES2[diffs[difficultySelection]];
+      enterCharacterSelect();
+    } else if (key === "1") {
+      selectedDifficulty = DIFFICULTIES2.easy;
+      difficultySelection = 0;
+      enterCharacterSelect();
+    } else if (key === "2") {
+      selectedDifficulty = DIFFICULTIES2.normal;
+      difficultySelection = 1;
+      enterCharacterSelect();
+    } else if (key === "3") {
+      selectedDifficulty = DIFFICULTIES2.hard;
+      difficultySelection = 2;
+      enterCharacterSelect();
+    } else if (key === "q") {
+      cleanup();
+      dispatchGameQuit(terminal);
+    }
+  }
+  function enterCharacterSelect() {
+    gameState = "characterSelect";
+    charGridRow = 0;
+    charGridCol = 0;
+  }
+  function handleCharacterSelectInput(key, domEvent) {
+    if (key === "q" || key === "escape") {
+      gameState = "difficulty";
+      return;
+    }
+    if (domEvent.key === "ArrowLeft" || key === "a") {
+      const row = CHAR_GRID[charGridRow];
+      charGridCol = (charGridCol - 1 + row.length) % row.length;
+    } else if (domEvent.key === "ArrowRight" || key === "d") {
+      const row = CHAR_GRID[charGridRow];
+      charGridCol = (charGridCol + 1) % row.length;
+    } else if (domEvent.key === "ArrowUp" || key === "w") {
+      charGridRow = (charGridRow - 1 + CHAR_GRID.length) % CHAR_GRID.length;
+      charGridCol = Math.min(charGridCol, CHAR_GRID[charGridRow].length - 1);
+    } else if (domEvent.key === "ArrowDown" || key === "s") {
+      charGridRow = (charGridRow + 1) % CHAR_GRID.length;
+      charGridCol = Math.min(charGridCol, CHAR_GRID[charGridRow].length - 1);
+    } else if (domEvent.key === "Enter" || domEvent.key === " ") {
+      const idx = CHAR_GRID[charGridRow][charGridCol];
+      p1Character = CHARACTERS[idx];
+      p2Character = getRandomCharacter();
+      gameState = "running";
+      initGame();
+    }
+  }
+  function handleGameInput(key, domEvent) {
+    if (key === "escape") {
+      gameState = "paused";
+      pauseMenuSelection = 0;
+      return;
+    }
+    if (!p1.currentPair || p1Phase !== PHASE_NONE) return;
+    switch (domEvent.key) {
+      case "ArrowLeft":
+      case "a":
+        movePair(p1.currentPair, p1.board, -1);
+        break;
+      case "ArrowRight":
+      case "d":
+        movePair(p1.currentPair, p1.board, 1);
+        break;
+      case "ArrowUp":
+      case "w":
+        rotatePair(p1.currentPair, p1.board, true);
+        break;
+      case "z":
+        rotatePair(p1.currentPair, p1.board, false);
+        break;
+      case "ArrowDown":
+      case "s":
+        if (dropPair(p1.currentPair, p1.board)) {
+          p1DropTimer = 0;
+        } else {
+          lockAndResolve(p1, true);
+        }
+        break;
+      case " ":
+        hardDrop(p1.currentPair, p1.board);
+        lockAndResolve(p1, true);
+        break;
+    }
+  }
+  function handlePauseInput(key, domEvent) {
+    if (key === "escape") {
+      gameState = "running";
+      return;
+    }
+    const { newSelection, confirmed } = navigateMenu(
+      pauseMenuSelection,
+      PAUSE_MENU_ITEMS.length,
+      key,
+      domEvent
+    );
+    if (newSelection !== pauseMenuSelection) {
+      pauseMenuSelection = newSelection;
+    }
+    const shortcutIdx = checkShortcut(PAUSE_MENU_ITEMS, key);
+    if (confirmed || shortcutIdx >= 0) {
+      const idx = shortcutIdx >= 0 ? shortcutIdx : pauseMenuSelection;
+      const item = PAUSE_MENU_ITEMS[idx];
+      switch (item.label) {
+        case "RESUME":
+          gameState = "running";
+          break;
+        case "RESTART":
+          gameState = "running";
+          initGame();
+          break;
+        case "QUIT":
+          cleanup();
+          dispatchGameQuit(terminal);
+          break;
+        case "LIST GAMES":
+          cleanup();
+          dispatchGamesMenu(terminal);
+          break;
+        case "NEXT GAME":
+          cleanup();
+          dispatchGameSwitch(terminal);
+          break;
+      }
+    }
+  }
+  function handleGameOverInput(key, domEvent) {
+    const menuItems = [
+      { label: "RESTART", shortcut: "R" },
+      { label: "QUIT", shortcut: "Q" },
+      { label: "LIST GAMES", shortcut: "L" },
+      { label: "NEXT GAME", shortcut: "N" }
+    ];
+    const { newSelection, confirmed } = navigateMenu(
+      pauseMenuSelection,
+      menuItems.length,
+      key,
+      domEvent
+    );
+    if (newSelection !== pauseMenuSelection) {
+      pauseMenuSelection = newSelection;
+    }
+    const shortcutIdx = checkShortcut(menuItems, key);
+    if (confirmed || shortcutIdx >= 0) {
+      const idx = shortcutIdx >= 0 ? shortcutIdx : pauseMenuSelection;
+      switch (menuItems[idx].label) {
+        case "RESTART":
+          gameState = "difficulty";
+          pauseMenuSelection = 0;
+          break;
+        case "QUIT":
+          cleanup();
+          dispatchGameQuit(terminal);
+          break;
+        case "LIST GAMES":
+          cleanup();
+          dispatchGamesMenu(terminal);
+          break;
+        case "NEXT GAME":
+          cleanup();
+          dispatchGameSwitch(terminal);
+          break;
+      }
+    }
+  }
+  const resizeListener = terminal.onResize(() => {
+    calculateLayout();
+  });
+  function cleanup() {
+    running = false;
+    clearInterval(gameLoop);
+    keyListener.dispose();
+    resizeListener.dispose();
+  }
+  enterAlternateBuffer(terminal, "hyper-fighter");
+  const gameLoop = setInterval(() => {
+    if (!running) {
+      clearInterval(gameLoop);
+      return;
+    }
+    update();
+    render();
+  }, TICK_MS);
+  const originalStop = controller.stop;
+  controller.stop = () => {
+    cleanup();
+    exitAlternateBuffer(terminal, "hyper-fighter");
+    originalStop();
+  };
+  return controller;
+}
+
+// src/games/gamesMenu.ts
+function showGamesMenu(terminal, optionsOrCallback) {
+  const options = typeof optionsOrCallback === "function" ? { onGameSelect: optionsOrCallback } : optionsOrCallback || {};
+  const { onGameSelect, onQuit } = options;
+  const themeColor = getCurrentThemeColor();
+  const lightTheme = isLightTheme2();
+  let running = true;
+  let selectedIndex = 0;
+  let scrollOffset = 0;
+  const controller = {
+    stop: () => {
+      if (!running) return;
+      running = false;
+    },
+    get isRunning() {
+      return running;
+    }
+  };
+  const title = [
+    "\u2588 \u2588 \u2588\u2584\u2588 \u2588\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2588   \u2588\u2580\u2580 \u2584\u2580\u2588 \u2588\u2580\u2584\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580",
+    "\u2588\u2580\u2588  \u2588  \u2588\u2580  \u2588\u2588\u2584 \u2588\u2580\u2584   \u2588\u2584\u2588 \u2588\u2580\u2588 \u2588 \u2580 \u2588 \u2588\u2588\u2584 \u2584\u2588"
+  ];
+  function render() {
+    let output = "";
+    output += "\x1B[2J\x1B[H";
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    const titleX = Math.floor((cols - title[0].length) / 2);
+    output += `\x1B[2;${titleX}H${themeColor}\x1B[1m${title[0]}\x1B[0m`;
+    output += `\x1B[3;${titleX}H${themeColor}\x1B[1m${title[1]}\x1B[0m`;
+    const subtitle = `Select a game to play (${games.length} games)`;
+    output += `\x1B[5;${Math.floor((cols - subtitle.length) / 2)}H\x1B[2m${subtitle}\x1B[0m`;
+    const boxWidth = 38;
+    const columnGap = 2;
+    const twoColumnWidth = boxWidth * 2 + columnGap;
+    const useTwoColumns = cols >= twoColumnWidth + 8;
+    const listStartY = 6;
+    const availableRows = rows - listStartY - 4;
+    const maxVisibleGames = Math.max(1, Math.floor(availableRows / 2));
+    if (useTwoColumns) {
+      renderTwoColumns(output, cols, rows, boxWidth, columnGap, listStartY, maxVisibleGames);
+    } else {
+      renderSingleColumn(output, cols, rows, boxWidth, listStartY, maxVisibleGames);
+    }
+  }
+  function renderSingleColumn(baseOutput, cols, rows, boxWidth, listStartY, maxVisibleGames) {
+    let output = baseOutput;
+    const boxX = Math.floor((cols - boxWidth) / 2);
+    const visibleGames = Math.min(maxVisibleGames, games.length);
+    if (selectedIndex < scrollOffset) {
+      scrollOffset = selectedIndex;
+    } else if (selectedIndex >= scrollOffset + visibleGames) {
+      scrollOffset = selectedIndex - visibleGames + 1;
+    }
+    scrollOffset = Math.max(0, Math.min(scrollOffset, games.length - visibleGames));
+    const hasScrollUp = scrollOffset > 0;
+    const hasScrollDown = scrollOffset + visibleGames < games.length;
+    const topScrollIndicator = hasScrollUp ? " \u25B2 more " : "\u2550".repeat(8);
+    const topBorderWidth = boxWidth - 2 - topScrollIndicator.length;
+    const topLeftPad = Math.floor(topBorderWidth / 2);
+    const topRightPad = topBorderWidth - topLeftPad;
+    output += `\x1B[${listStartY};${boxX}H${themeColor}\u2554${"\u2550".repeat(topLeftPad)}${hasScrollUp ? "\x1B[33m" : ""}${topScrollIndicator}${hasScrollUp ? themeColor : ""}${"\u2550".repeat(topRightPad)}\u2557\x1B[0m`;
+    for (let vi = 0; vi < visibleGames; vi++) {
+      const i = scrollOffset + vi;
+      const game = games[i];
+      const y = listStartY + 1 + vi * 2;
+      const isSelected = i === selectedIndex;
+      output += renderGameEntry(game, i, isSelected, y, boxX, boxWidth);
+    }
+    const bottomY = listStartY + 1 + visibleGames * 2;
+    const bottomScrollIndicator = hasScrollDown ? " \u25BC more " : "\u2550".repeat(8);
+    const bottomBorderWidth = boxWidth - 2 - bottomScrollIndicator.length;
+    const bottomLeftPad = Math.floor(bottomBorderWidth / 2);
+    const bottomRightPad = bottomBorderWidth - bottomLeftPad;
+    output += `\x1B[${bottomY};${boxX}H${themeColor}\u255A${"\u2550".repeat(bottomLeftPad)}${hasScrollDown ? "\x1B[33m" : ""}${bottomScrollIndicator}${hasScrollDown ? themeColor : ""}${"\u2550".repeat(bottomRightPad)}\u255D\x1B[0m`;
+    const controls = `\u2191\u2193 Navigate | ENTER Select | 1-9 Quick | Q Quit`;
+    output += `\x1B[${rows - 1};${Math.floor((cols - controls.length) / 2)}H\x1B[2m${controls}\x1B[0m`;
+    terminal.write(output);
+  }
+  function renderTwoColumns(baseOutput, cols, rows, boxWidth, columnGap, listStartY, maxVisibleGames) {
+    let output = baseOutput;
+    const gamesPerColumn = Math.min(maxVisibleGames, Math.ceil(games.length / 2));
+    const selectedRow = Math.floor(selectedIndex / 2);
+    if (selectedRow < scrollOffset) {
+      scrollOffset = selectedRow;
+    } else if (selectedRow >= scrollOffset + gamesPerColumn) {
+      scrollOffset = selectedRow - gamesPerColumn + 1;
+    }
+    const maxScroll = Math.max(0, Math.ceil(games.length / 2) - gamesPerColumn);
+    scrollOffset = Math.max(0, Math.min(scrollOffset, maxScroll));
+    const hasScrollUp = scrollOffset > 0;
+    const hasScrollDown = (scrollOffset + gamesPerColumn) * 2 < games.length;
+    const totalWidth = boxWidth * 2 + columnGap;
+    const startX = Math.floor((cols - totalWidth) / 2);
+    const leftBoxX = startX;
+    const rightBoxX = startX + boxWidth + columnGap;
+    const topScrollIndicator = hasScrollUp ? " \u25B2 " : "\u2550\u2550\u2550";
+    const topBorderContent = boxWidth - 2 - topScrollIndicator.length;
+    const topLeft = Math.floor(topBorderContent / 2);
+    const topRight = topBorderContent - topLeft;
+    output += `\x1B[${listStartY};${leftBoxX}H${themeColor}\u2554${"\u2550".repeat(topLeft)}${hasScrollUp ? "\x1B[33m" : ""}${topScrollIndicator}${hasScrollUp ? themeColor : ""}${"\u2550".repeat(topRight)}\u2557\x1B[0m`;
+    output += `\x1B[${listStartY};${rightBoxX}H${themeColor}\u2554${"\u2550".repeat(topLeft)}${hasScrollUp ? "\x1B[33m" : ""}${topScrollIndicator}${hasScrollUp ? themeColor : ""}${"\u2550".repeat(topRight)}\u2557\x1B[0m`;
+    for (let row = 0; row < gamesPerColumn; row++) {
+      const leftIdx = (scrollOffset + row) * 2;
+      const rightIdx = leftIdx + 1;
+      const y = listStartY + 1 + row * 2;
+      if (leftIdx < games.length) {
+        output += renderGameEntry(games[leftIdx], leftIdx, leftIdx === selectedIndex, y, leftBoxX, boxWidth);
+      } else {
+        output += `\x1B[${y};${leftBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
+        output += `\x1B[${y + 1};${leftBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
+      }
+      if (rightIdx < games.length) {
+        output += renderGameEntry(games[rightIdx], rightIdx, rightIdx === selectedIndex, y, rightBoxX, boxWidth);
+      } else {
+        output += `\x1B[${y};${rightBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
+        output += `\x1B[${y + 1};${rightBoxX}H${themeColor}\u2551${" ".repeat(boxWidth - 2)}\u2551\x1B[0m`;
+      }
+    }
+    const bottomY = listStartY + 1 + gamesPerColumn * 2;
+    const bottomScrollIndicator = hasScrollDown ? " \u25BC " : "\u2550\u2550\u2550";
+    const bottomBorderContent = boxWidth - 2 - bottomScrollIndicator.length;
+    const bottomLeft = Math.floor(bottomBorderContent / 2);
+    const bottomRight = bottomBorderContent - bottomLeft;
+    output += `\x1B[${bottomY};${leftBoxX}H${themeColor}\u255A${"\u2550".repeat(bottomLeft)}${hasScrollDown ? "\x1B[33m" : ""}${bottomScrollIndicator}${hasScrollDown ? themeColor : ""}${"\u2550".repeat(bottomRight)}\u255D\x1B[0m`;
+    output += `\x1B[${bottomY};${rightBoxX}H${themeColor}\u255A${"\u2550".repeat(bottomLeft)}${hasScrollDown ? "\x1B[33m" : ""}${bottomScrollIndicator}${hasScrollDown ? themeColor : ""}${"\u2550".repeat(bottomRight)}\u255D\x1B[0m`;
+    const controls = `\u2191\u2193\u2190\u2192 Navigate | ENTER Select | 1-9 Quick | Q Quit`;
+    output += `\x1B[${rows - 1};${Math.floor((cols - controls.length) / 2)}H\x1B[2m${controls}\x1B[0m`;
+    terminal.write(output);
+  }
+  function renderGameEntry(game, index, isSelected, y, boxX, boxWidth) {
+    let output = "";
+    const contentWidth = boxWidth - 2;
+    const prefix = isSelected ? "\u25B6" : " ";
+    const highlight = isSelected ? lightTheme ? "\x1B[1;7;97m" : "\x1B[1;7m" : "";
+    const keyColor = isSelected ? "" : "\x1B[33m";
+    const keyNum = index + 1;
+    const keyDisplay = keyNum <= 9 ? `${keyNum}` : " ";
+    const lineContent = `${prefix} [${keyDisplay}] ${game.name}`;
+    const padding = Math.max(0, contentWidth - lineContent.length);
+    output += `\x1B[${y};${boxX}H${themeColor}\u2551\x1B[0m${highlight}${keyColor}${lineContent}${" ".repeat(padding)}\x1B[0m${themeColor}\u2551\x1B[0m`;
+    const descContent = `    ${game.description}`;
+    const descPadding = Math.max(0, contentWidth - descContent.length);
+    const descColor = isSelected ? lightTheme ? "\x1B[2;7;97m" : "\x1B[2;7m" : "\x1B[2m";
+    output += `\x1B[${y + 1};${boxX}H${themeColor}\u2551\x1B[0m${descColor}${descContent}${" ".repeat(descPadding)}\x1B[0m${themeColor}\u2551\x1B[0m`;
+    return output;
+  }
+  setTimeout(() => {
+    if (!running) return;
+    if (!isTerminalValid(terminal)) {
+      console.warn("[GamesMenu] Terminal became invalid before menu could start");
+      running = false;
+      return;
+    }
+    let keyListener = null;
+    try {
+      enterAlternateBuffer(terminal, "games-menu");
+      render();
+      const resizeListener = terminal.onResize(() => {
+        if (running) render();
+      });
       keyListener = terminal.onKey(({ domEvent }) => {
         if (!running) {
           keyListener?.dispose();
@@ -13329,6 +15818,7 @@ function showGamesMenu(terminal, optionsOrCallback) {
       const originalStop = controller.stop;
       controller.stop = () => {
         keyListener?.dispose();
+        resizeListener.dispose();
         exitAlternateBuffer(terminal, "games-menu-stop");
         originalStop();
       };
@@ -13662,7 +16152,7 @@ function runRebootEffect(terminal) {
 
 // src/games/shared/effects.ts
 var MAX_PARTICLES2 = 100;
-var PARTICLE_CHARS = {
+var PARTICLE_CHARS2 = {
   explosion: ["\u2717", "\xD7", "\xB7", "\u25CB", "\u2592", "\u2591"],
   success: ["\u2726", "\u2605", "\u25C6", "\u25CF", "\u2666"],
   fire: ["\u2593", "\u2592", "\u2591", "\u25CF", "\u25C6"],
@@ -13695,8 +16185,8 @@ function spawnParticles2(particles, x, y, count, color, chars = ["\u2726", "\u26
     });
   }
 }
-function spawnFirework2(particles, x, y, intensity = 1) {
-  const chars = PARTICLE_CHARS.firework;
+function spawnFirework3(particles, x, y, intensity = 1) {
+  const chars = PARTICLE_CHARS2.firework;
   for (let i = 0; i < 12 * intensity; i++) {
     const angle = Math.PI * 2 * i / (12 * intensity);
     const speed = 0.4 + Math.random() * 0.4;
@@ -13731,7 +16221,7 @@ function spawnSparkleTrail2(particles, x, y, count = 6, color = "\x1B[1;93m") {
     particles.push({
       x: x + (Math.random() - 0.5) * 4,
       y,
-      char: PARTICLE_CHARS.sparkle[Math.floor(Math.random() * PARTICLE_CHARS.sparkle.length)],
+      char: PARTICLE_CHARS2.sparkle[Math.floor(Math.random() * PARTICLE_CHARS2.sparkle.length)],
       color,
       vx: (Math.random() - 0.5) * 0.2,
       vy: -0.3 - Math.random() * 0.3,
@@ -13739,7 +16229,7 @@ function spawnSparkleTrail2(particles, x, y, count = 6, color = "\x1B[1;93m") {
     });
   }
 }
-function updateParticles2(particles, gravityMult = 1) {
+function updateParticles3(particles, gravityMult = 1) {
   for (let i = particles.length - 1; i >= 0; i--) {
     const p = particles[i];
     p.x += p.vx;
@@ -13763,7 +16253,7 @@ function updatePopups2(popups) {
 function createShakeState() {
   return { frames: 0, intensity: 0 };
 }
-function triggerShake(state, frames, intensity) {
+function triggerShake2(state, frames, intensity) {
   state.frames = frames;
   state.intensity = intensity;
 }
@@ -13780,10 +16270,10 @@ function applyShake(state) {
 function createFlashState() {
   return { frames: 0 };
 }
-function triggerFlash(state, frames) {
+function triggerFlash2(state, frames) {
   state.frames = frames;
 }
-function updateFlash(state) {
+function updateFlash2(state) {
   if (state.frames > 0) {
     state.frames--;
     return true;
@@ -13814,7 +16304,8 @@ var games = [
   { id: "typingtest", name: "Typing Test", description: "Test your speed", run: runTypingTest },
   { id: "tron", name: "Tron", description: "Light cycle battle", run: runTronGame },
   { id: "crack", name: "Crack", description: "Hack the system", run: runCrackGame },
-  { id: "chopper", name: "Chopper", description: "Deliver passengers", run: runCourierGame }
+  { id: "chopper", name: "Chopper", description: "Deliver passengers", run: runCourierGame },
+  { id: "hyper-fighter", name: "Hyper Fighter", description: "Gem battle vs AI", run: runHyperFighterGame }
 ];
 function getGame(id) {
   return games.find((g) => g.id === id);
@@ -13831,7 +16322,7 @@ export {
   GAME_EVENTS,
   MAX_PARTICLES2 as MAX_PARTICLES,
   MODE_SELECT_ITEMS,
-  PARTICLE_CHARS,
+  PARTICLE_CHARS2 as PARTICLE_CHARS,
   PAUSE_MENU_ITEMS,
   addScorePopup,
   applyShake,
@@ -13901,14 +16392,14 @@ export {
   runWordleGame,
   setTheme,
   showGamesMenu,
-  spawnFirework2 as spawnFirework,
+  spawnFirework3 as spawnFirework,
   spawnParticles2 as spawnParticles,
   spawnSparkleTrail2 as spawnSparkleTrail,
   startMatrixRain,
-  triggerFlash,
-  triggerShake,
-  updateFlash,
-  updateParticles2 as updateParticles,
+  triggerFlash2 as triggerFlash,
+  triggerShake2 as triggerShake,
+  updateFlash2 as updateFlash,
+  updateParticles3 as updateParticles,
   updatePopups2 as updatePopups
 };
 //# sourceMappingURL=index.js.map