loop-benchmarking

player.ts (19702B)

---

 // Pierre Dellacherie's 4-heuristic Tetris AI (2003).
 // Weights from Colin Fahey's genetic algorithm optimization.
 // Reference implementation: LeeYiyuan/tetrisai (MIT License) -- piece
 // definitions and simulation logic adapted from that codebase.
 
 import type { Page } from "@playwright/test";
 import type { Grid, CalibrationResult, PieceType } from "./types";
 import { readGrid, detectActivePieceCells, identifyPieceType, gridsAreDifferent } from "./grid-reader";
 
 // Genetically-optimized weights (Fahey)
 const W_HEIGHT = -0.510066;
 const W_LINES = 0.760666;
 const W_HOLES = -0.35663;
 const W_BUMPINESS = -0.184483;
 
 const GRID_ROWS = 20;
 const GRID_COLS = 10;
 
 /**
  * Standard Tetris piece definitions.
  * Each piece has 4 rotation states.
  * Each rotation state is a list of [row, col] offsets from the piece origin.
  * Adapted from LeeYiyuan/tetrisai piece.js (reference implementation)
  */
 const PIECES: Record<string, [number, number][][]> = {
   I: [
     [[0, 0], [0, 1], [0, 2], [0, 3]],   // horizontal
     [[0, 0], [1, 0], [2, 0], [3, 0]],   // vertical
     [[0, 0], [0, 1], [0, 2], [0, 3]],   // horizontal (same as 0)
     [[0, 0], [1, 0], [2, 0], [3, 0]],   // vertical (same as 1)
   ],
   O: [
     [[0, 0], [0, 1], [1, 0], [1, 1]],
     [[0, 0], [0, 1], [1, 0], [1, 1]],
     [[0, 0], [0, 1], [1, 0], [1, 1]],
     [[0, 0], [0, 1], [1, 0], [1, 1]],
   ],
   T: [
     [[0, 1], [1, 0], [1, 1], [1, 2]],   // T up
     [[0, 0], [1, 0], [1, 1], [2, 0]],   // T right
     [[0, 0], [0, 1], [0, 2], [1, 1]],   // T down
     [[0, 1], [1, 0], [1, 1], [2, 1]],   // T left
   ],
   S: [
     [[0, 1], [0, 2], [1, 0], [1, 1]],   // S horizontal
     [[0, 0], [1, 0], [1, 1], [2, 1]],   // S vertical
     [[0, 1], [0, 2], [1, 0], [1, 1]],
     [[0, 0], [1, 0], [1, 1], [2, 1]],
   ],
   Z: [
     [[0, 0], [0, 1], [1, 1], [1, 2]],   // Z horizontal
     [[0, 1], [1, 0], [1, 1], [2, 0]],   // Z vertical
     [[0, 0], [0, 1], [1, 1], [1, 2]],
     [[0, 1], [1, 0], [1, 1], [2, 0]],
   ],
   J: [
     [[0, 0], [1, 0], [1, 1], [1, 2]],   // J up
     [[0, 0], [0, 1], [1, 0], [2, 0]],   // J right
     [[0, 0], [0, 1], [0, 2], [1, 2]],   // J down
     [[0, 0], [1, 0], [2, 0], [2, -1]],  // J left (using relative)
   ],
   L: [
     [[0, 2], [1, 0], [1, 1], [1, 2]],   // L up
     [[0, 0], [1, 0], [2, 0], [2, 1]],   // L right
     [[0, 0], [0, 1], [0, 2], [1, 0]],   // L down
     [[0, 0], [0, 1], [1, 1], [2, 1]],   // L left
   ],
 };
 
 /** The result of finding the best placement. */
 interface Placement {
   rotations: number;
   column: number;
   score: number;
   linesCleared: number;
   pieceType: string;
 }
 
 /**
  * Play the game using continuous grid polling and the 4-heuristic AI.
  * Adapted from mikhail-vlasenko/Tetris-AI's continuous polling approach.
  *
  * Instead of "snapshot, act, snapshot, compare", this continuously reads
  * the grid and reacts to changes.
  */
 export async function playGame(
   page: Page,
   cal: CalibrationResult,
   options: { maxPieces?: number; maxDurationMs?: number; scoreSelector?: string }
 ): Promise<{ piecesPlaced: number; linesCleared: number; errors: number; gridReads: number; gridReadFails: number; scoreValues: number[] }> {
   const maxPieces = options.maxPieces ?? 100;
   const maxDuration = options.maxDurationMs ?? 30000;
   const scoreSelector = options.scoreSelector ?? null;
   const start = Date.now();
   let piecesPlaced = 0;
   let linesCleared = 0;
   let errors = 0;
   let gridReads = 0;
   let gridReadFails = 0;
   let consecutiveReadFails = 0;
   const scoreValues: number[] = [];
   let scorePollCounter = 0;
 
   let previousGrid: Grid | null = null;
   let settledGrid: Grid | null = null;
   let lastPlacementTime = Date.now();
   let waitingForNewPiece = false;
 
   while (piecesPlaced < maxPieces && Date.now() - start < maxDuration) {
     try {
       const grid = await readGrid(page, cal);
 
       if (!grid) {
         gridReadFails++;
         consecutiveReadFails++;
         if (consecutiveReadFails > 10) {
           // Grid reading is broken, fall back to random play
           await playRandomForDuration(page, cal, Math.min(5000, maxDuration - (Date.now() - start)));
           piecesPlaced += 3;
           break;
         }
         await page.waitForTimeout(60);
         continue;
       }
 
       gridReads++;
       consecutiveReadFails = 0;
 
       // Lightweight score tracking: read score every ~5 polls
       if (scoreSelector) {
         scorePollCounter++;
         if (scorePollCounter % 5 === 0) {
           try {
             const scoreText = await page.textContent(scoreSelector);
             if (scoreText) {
               const nums = (scoreText.match(/\d+/g) || []).map(Number);
               if (nums.length > 0) {
                 scoreValues.push(Math.max(...nums));
               }
             }
           } catch { /* ignore score read failures */ }
         }
       }
 
       // Detect if anything changed
       if (previousGrid && !gridsAreDifferent(grid, previousGrid)) {
         // Nothing changed, wait and poll again
         // If we've been waiting too long without changes, the game may be paused
         if (Date.now() - lastPlacementTime > 8000) {
           // Try pressing a key to unpause/restart
           await page.keyboard.press(cal.controls.drop);
           lastPlacementTime = Date.now();
         }
         await page.waitForTimeout(60);
         continue;
       }
 
       // Grid changed -- figure out what happened
       if (waitingForNewPiece) {
         // We just dropped a piece and are waiting for the next one
         settledGrid = grid;
         waitingForNewPiece = false;
         lastPlacementTime = Date.now();
         previousGrid = grid;
         await page.waitForTimeout(60);
         continue;
       }
 
       // Try to detect the active piece
       const activeCells = detectActivePieceCells(grid, settledGrid);
 
       if (activeCells && activeCells.length === 4) {
         const pieceType = identifyPieceType(activeCells);
 
         // Find best placement for this piece
         const boardWithoutPiece = settledGrid ?? stripActivePiece(grid, activeCells);
         const placement = findBestPlacement(boardWithoutPiece, pieceType);
 
         if (placement) {
           await executePlacement(page, cal, placement, activeCells);
           linesCleared += placement.linesCleared;
           piecesPlaced++;
           waitingForNewPiece = true;
         } else {
           // Can't find placement, just hard drop
           await page.keyboard.press(cal.controls.drop);
           piecesPlaced++;
           waitingForNewPiece = true;
         }
 
         // Wait for the piece to lock and next piece to spawn
         await page.waitForTimeout(100);
 
         // Read the settled state
         const afterGrid = await readGrid(page, cal);
         if (afterGrid) {
           // Check if lines were cleared
           if (settledGrid) {
             const filledBefore = countTotalFilled(settledGrid);
             const filledAfter = countTotalFilled(afterGrid);
             // If filled count dropped significantly, lines were cleared
             if (filledAfter < filledBefore) {
               const possibleClears = Math.round((filledBefore + 4 - filledAfter) / GRID_COLS);
               if (possibleClears > 0 && possibleClears <= 4) {
                 linesCleared += possibleClears;
               }
             }
           }
           settledGrid = afterGrid;
         }
 
         lastPlacementTime = Date.now();
       } else {
         // Could not detect active piece -- the grid changed but we can't
         // identify what moved. This could be auto-drop, line clear animation, etc.
         // Just update our view and wait.
       }
 
       previousGrid = grid;
       await page.waitForTimeout(60);
     } catch {
       errors++;
       await playRandomMove(page, cal);
       piecesPlaced++;
       await page.waitForTimeout(60);
     }
   }
 
   return { piecesPlaced, linesCleared, errors, gridReads, gridReadFails, scoreValues };
 }
 
 /**
  * Execute a single hard drop (for tests that just need to drop a piece).
  */
 export async function hardDrop(page: Page, cal: CalibrationResult): Promise<void> {
   await page.keyboard.press(cal.controls.drop);
   await page.waitForTimeout(200);
 }
 
 /**
  * Execute a placement: rotate, move to column, then hard drop.
  * Uses the detected active piece position to calculate the correct moves.
  */
 async function executePlacement(
   page: Page,
   cal: CalibrationResult,
   placement: Placement,
   activeCells: [number, number][]
 ): Promise<void> {
   // Rotate to target rotation
   for (let i = 0; i < placement.rotations; i++) {
     await page.keyboard.press(cal.controls.rotate);
     await page.waitForTimeout(50);
   }
 
   // Determine current column of the piece (leftmost cell)
   const currentCol = Math.min(...activeCells.map(([, c]) => c));
 
   // After rotation, the piece position may have shifted, so we estimate
   // the column based on the original position
   const diff = placement.column - currentCol;
 
   if (diff < 0) {
     for (let i = 0; i < Math.abs(diff); i++) {
       await page.keyboard.press(cal.controls.left);
       await page.waitForTimeout(30);
     }
   } else if (diff > 0) {
     for (let i = 0; i < diff; i++) {
       await page.keyboard.press(cal.controls.right);
       await page.waitForTimeout(30);
     }
   }
 
   // Hard drop
   await page.keyboard.press(cal.controls.drop);
   await page.waitForTimeout(60);
 }
 
 /**
  * Play a random move (fallback when grid reading fails).
  */
 async function playRandomMove(page: Page, cal: CalibrationResult): Promise<void> {
   const moves = [cal.controls.left, cal.controls.right, cal.controls.rotate, cal.controls.down];
   const randomMoves = Math.floor(Math.random() * 4) + 1;
   for (let i = 0; i < randomMoves; i++) {
     const key = moves[Math.floor(Math.random() * moves.length)];
     await page.keyboard.press(key);
     await page.waitForTimeout(50);
   }
   await page.keyboard.press(cal.controls.drop);
   await page.waitForTimeout(100);
 }
 
 /**
  * Play randomly for a set duration (when grid reading is broken).
  */
 async function playRandomForDuration(
   page: Page,
   cal: CalibrationResult,
   durationMs: number
 ): Promise<void> {
   const start = Date.now();
   const moves = [cal.controls.left, cal.controls.right, cal.controls.rotate, cal.controls.down, cal.controls.drop];
 
   while (Date.now() - start < durationMs) {
     const key = moves[Math.floor(Math.random() * moves.length)];
     await page.keyboard.press(key);
     await page.waitForTimeout(100);
   }
 }
 
 /**
  * Try to fill a specific row by placing pieces strategically.
  * Uses repeated hard drops at different columns to build up the bottom row.
  */
 export async function tryFillRow(
   page: Page,
   cal: CalibrationResult,
   maxAttempts: number
 ): Promise<boolean> {
   // Strategy: move piece to each column left to right and hard drop
   const columns = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
   let attempts = 0;
 
   for (const targetCol of columns) {
     if (attempts >= maxAttempts) break;
 
     // Move to far left first
     for (let i = 0; i < 6; i++) {
       await page.keyboard.press(cal.controls.left);
       await page.waitForTimeout(30);
     }
 
     // Then move right to target column
     for (let i = 0; i < targetCol; i++) {
       await page.keyboard.press(cal.controls.right);
       await page.waitForTimeout(30);
     }
 
     await page.keyboard.press(cal.controls.drop);
     await page.waitForTimeout(200);
     attempts++;
   }
 
   // Check if a line was cleared
   const grid = await readGrid(page, cal);
   if (!grid) return false;
 
   // If bottom row is now empty after being full, a line was cleared
   const bottomFilled = grid[GRID_ROWS - 1].filter(Boolean).length;
   return bottomFilled < 8;
 }
 
 /**
  * Quickly stack pieces to reach game over.
  */
 export async function stackToGameOver(
   page: Page,
   cal: CalibrationResult,
   maxAttempts: number
 ): Promise<boolean> {
   // Strategy: hard drop in the same column repeatedly to build a tower
   for (let i = 0; i < maxAttempts; i++) {
     await page.keyboard.press(cal.controls.drop);
     await page.waitForTimeout(150);
   }
 
   // Check if the game appears to have stopped
   const shot1 = await page.screenshot();
   await page.waitForTimeout(1000);
   await page.keyboard.press(cal.controls.drop);
   await page.waitForTimeout(500);
   const shot2 = await page.screenshot();
 
   const screenshotsSame = Buffer.from(shot1).equals(Buffer.from(shot2));
 
   const hasGameOverText = await page.evaluate(() => {
     const text = document.body.innerText.toLowerCase();
     return (
       text.includes("game over") ||
       text.includes("gameover") ||
       text.includes("you lose") ||
       text.includes("try again") ||
       text.includes("restart") ||
       text.includes("play again")
     );
   });
 
   return screenshotsSame || hasGameOverText;
 }
 
 // --- Heuristic evaluation functions ---
 // Pierre Dellacherie 4-heuristic, reference: LeeYiyuan/tetrisai (MIT License)
 
 /**
  * Find the best column and rotation for a given piece type using the
  * 4-heuristic scoring function.
  *
  * For each possible (rotation, column) combination:
  * 1. Simulate placing the piece (drop it straight down)
  * 2. Score the resulting board
  * 3. Pick the best score
  */
 function findBestPlacement(board: Grid, pieceType: PieceType): Placement | null {
   const rotations = PIECES[pieceType];
   if (!rotations) {
     // Unknown piece type -- try all rotations with single-cell simulation
     return findBestPlacementGeneric(board);
   }
 
   let bestScore = -Infinity;
   let bestPlacement: Placement | null = null;
 
   for (let rot = 0; rot < rotations.length; rot++) {
     const shape = rotations[rot];
 
     // Determine the piece's width in this rotation
     const minCol = Math.min(...shape.map(([, c]) => c));
     const maxCol = Math.max(...shape.map(([, c]) => c));
     const pieceWidth = maxCol - minCol + 1;
 
     // Try every valid column position
     for (let col = -minCol; col <= GRID_COLS - pieceWidth + (-minCol); col++) {
       // Simulate dropping the piece at this column
       const simResult = simulateDropPiece(board, shape, col);
       if (!simResult) continue;
 
       const { cleared, resultBoard } = simResult;
       const score =
         W_HEIGHT * aggregateHeight(resultBoard) +
         W_LINES * cleared +
         W_HOLES * countHoles(resultBoard) +
         W_BUMPINESS * bumpiness(resultBoard);
 
       if (score > bestScore) {
         bestScore = score;
         bestPlacement = {
           rotations: rot,
           column: col,
           score,
           linesCleared: cleared,
           pieceType,
         };
       }
     }
   }
 
   return bestPlacement;
 }
 
 /**
  * Generic placement finder when piece type is unknown.
  * Simulates dropping a single cell at each column (simplified).
  */
 function findBestPlacementGeneric(board: Grid): Placement | null {
   let bestScore = -Infinity;
   let bestPlacement: Placement | null = null;
 
   for (let col = 0; col < GRID_COLS; col++) {
     const simGrid = simulateDropSingleCell(board, col);
     if (!simGrid) continue;
 
     const { cleared, resultBoard } = clearLines(simGrid);
     const score =
       W_HEIGHT * aggregateHeight(resultBoard) +
       W_LINES * cleared +
       W_HOLES * countHoles(resultBoard) +
       W_BUMPINESS * bumpiness(resultBoard);
 
     if (score > bestScore) {
       bestScore = score;
       bestPlacement = { rotations: 0, column: col, score, linesCleared: cleared, pieceType: "unknown" };
     }
   }
 
   return bestPlacement;
 }
 
 /**
  * Simulate dropping a piece (defined by its shape offsets) at a given column.
  * Returns the resulting board after clearing lines, or null if placement is invalid.
  */
 function simulateDropPiece(
   board: Grid,
   shape: [number, number][],
   col: number
 ): { cleared: number; resultBoard: Grid } | null {
   // Find the lowest valid row for this piece
   let landRow = -1;
 
   for (let row = 0; row <= GRID_ROWS; row++) {
     let valid = true;
     for (const [dr, dc] of shape) {
       const r = row + dr;
       const c = col + dc;
       if (r >= GRID_ROWS || c < 0 || c >= GRID_COLS) {
         valid = false;
         break;
       }
       if (r >= 0 && board[r][c]) {
         valid = false;
         break;
       }
     }
     if (!valid) {
       landRow = row - 1;
       break;
     }
   }
 
   if (landRow < 0) {
     // Check if the piece can sit at row 0
     let valid = true;
     for (const [dr, dc] of shape) {
       const r = dr;
       const c = col + dc;
       if (r >= GRID_ROWS || c < 0 || c >= GRID_COLS || (r >= 0 && board[r][c])) {
         valid = false;
         break;
       }
     }
     if (valid) landRow = 0;
     else return null;
   }
 
   // Clone board and place piece
   const newBoard: Grid = board.map((row) => [...row]);
   for (const [dr, dc] of shape) {
     const r = landRow + dr;
     const c = col + dc;
     if (r >= 0 && r < GRID_ROWS && c >= 0 && c < GRID_COLS) {
       newBoard[r][c] = true;
     }
   }
 
   return clearLines(newBoard);
 }
 
 /**
  * Simulate dropping a single cell at the given column (simplified fallback).
  */
 function simulateDropSingleCell(board: Grid, col: number): Grid | null {
   if (col < 0 || col >= GRID_COLS) return null;
 
   let landRow = -1;
   for (let r = GRID_ROWS - 1; r >= 0; r--) {
     if (!board[r][col]) {
       landRow = r;
       break;
     }
   }
   if (landRow < 0) return null;
 
   const newGrid: Grid = board.map((row) => [...row]);
   newGrid[landRow][col] = true;
   return newGrid;
 }
 
 /**
  * Remove the active piece cells from a grid to get the settled state.
  */
 function stripActivePiece(grid: Grid, activeCells: [number, number][]): Grid {
   const result: Grid = grid.map((row) => [...row]);
   for (const [r, c] of activeCells) {
     if (r >= 0 && r < result.length && c >= 0 && c < result[r].length) {
       result[r][c] = false;
     }
   }
   return result;
 }
 
 /**
  * Clear completed lines and return the count + new board.
  */
 function clearLines(grid: Grid): { cleared: number; resultBoard: Grid } {
   const remaining: boolean[][] = [];
   let cleared = 0;
 
   for (const row of grid) {
     if (row.every(Boolean)) {
       cleared++;
     } else {
       remaining.push([...row]);
     }
   }
 
   // Add empty rows at the top
   while (remaining.length < GRID_ROWS) {
     remaining.unshift(new Array(GRID_COLS).fill(false));
   }
 
   return { cleared, resultBoard: remaining };
 }
 
 /**
  * Sum of column heights (distance from top to highest filled cell per column).
  */
 function aggregateHeight(grid: Grid): number {
   let total = 0;
   for (let col = 0; col < GRID_COLS; col++) {
     for (let row = 0; row < GRID_ROWS; row++) {
       if (grid[row]?.[col]) {
         total += GRID_ROWS - row;
         break;
       }
     }
   }
   return total;
 }
 
 /**
  * Count holes (empty cells with a filled cell above them in the same column).
  */
 function countHoles(grid: Grid): number {
   let holes = 0;
   for (let col = 0; col < GRID_COLS; col++) {
     let blockFound = false;
     for (let row = 0; row < GRID_ROWS; row++) {
       if (grid[row]?.[col]) {
         blockFound = true;
       } else if (blockFound) {
         holes++;
       }
     }
   }
   return holes;
 }
 
 /**
  * Sum of absolute height differences between adjacent columns.
  */
 function bumpiness(grid: Grid): number {
   const heights: number[] = [];
   for (let col = 0; col < GRID_COLS; col++) {
     let h = 0;
     for (let row = 0; row < GRID_ROWS; row++) {
       if (grid[row]?.[col]) {
         h = GRID_ROWS - row;
         break;
       }
     }
     heights.push(h);
   }
 
   let bump = 0;
   for (let i = 0; i < heights.length - 1; i++) {
     bump += Math.abs(heights[i] - heights[i + 1]);
   }
   return bump;
 }
 
 /**
  * Count total filled cells in the grid.
  */
 function countTotalFilled(grid: Grid): number {
   let count = 0;
   for (const row of grid) {
     for (const cell of row) {
       if (cell) count++;
     }
   }
   return count;
 }