loop-benchmarking

types.ts (5440B)

---

 import type { Page } from "@playwright/test";
 
 /** A 10x20 boolean grid: true = filled cell, false = empty. Row 0 is the top. */
 export type Grid = boolean[][];
 
 /** Pixel bounds of the game grid on the page. */
 export interface GridBounds {
   x: number;
   y: number;
   width: number;
   height: number;
 }
 
 /** How the game renders its grid. */
 export type RendererType = "canvas" | "dom" | "svg" | "unknown";
 
 /** Key mappings for game controls. */
 export interface Controls {
   left: string;
   right: string;
   down: string;
   rotate: string;
   drop: string;
 }
 
 /** How the game was started. */
 export type StartMechanism =
   | "auto"
   | "click_canvas"
   | "enter"
   | "space"
   | "button"
   | "anykey"
   | "unknown";
 
 /** Pre-test survey data collected before any tests run. */
 export interface SurveyData {
   has_overlay: boolean;
   has_canvas: boolean;
   has_dom_grid: boolean;
   visible_text: string[];
   clickable_elements: number;
 }
 
 /** Competitive play results (Phase 8). */
 export interface CompetitivePlayResult {
   duration_seconds: number;
   pieces_placed: number;
   total_lines_cleared: number;
   single_clears: number;
   double_clears: number;
   triple_clears: number;
   tetris_clears: number;
   max_combo: number;
   score_readings: number[];
   score_final: number;
   score_increases: number[];
   level_readings: number[];
   level_final: number;
   game_over_reached: boolean;
   game_over_text_found: string | null;
   restart_available: boolean;
   next_piece_visible: boolean;
   speed_increased: boolean;
   bugs_detected: string[];
   rendering_trail_detected?: boolean;
 }
 
 /** Result of the calibration phase. */
 export interface CalibrationResult {
   renderer: RendererType;
   gridDetected: boolean;
   gridBounds: GridBounds | null;
   cellWidth: number;
   cellHeight: number;
   controls: Controls;
   startMechanism: StartMechanism;
   scoreElementSelector: string | null;
   backgroundColor: [number, number, number] | null;
   consoleErrors: string[];
   /** Fraction of grid reads that returned non-null during calibration polling. */
   gridConfidence: number;
   /** Details about the button that started the game, if any. */
   startButton?: {
     selector: string;
     text: string;
     disappeared: boolean;
     position: { x: number; y: number };
   };
 }
 
 /** Result of an individual test. */
 export interface TestResult {
   name: string;
   pass: boolean;
   detail: string;
 }
 
 /** Standard Tetris piece types. */
 export type PieceType = "I" | "O" | "T" | "S" | "Z" | "J" | "L" | "unknown";
 
 /**
  * Tetromino definition: cells in a bounding box.
  * Each rotation is a list of [row, col] offsets relative to the piece origin.
  */
 export interface TetrominoDef {
   type: PieceType;
   /** All rotation states. Each is a list of [row, col] cell offsets. */
   rotations: [number, number][][];
   /** Bounding box dimensions per rotation: [width, height]. */
   dimensions: [number, number][];
 }
 
 /** An event observed during continuous grid scanning. */
 export type GridEvent =
   | { type: "piece_spawned"; pieceType: PieceType; frame: number }
   | { type: "piece_locked"; frame: number; filledDelta: number }
   | { type: "line_cleared"; count: number; frame: number }
   | { type: "piece_moved"; direction: "left" | "right" | "down"; frame: number }
   | { type: "piece_rotated"; frame: number }
   | { type: "hard_drop"; frame: number }
   | { type: "game_over"; frame: number }
   | { type: "grid_read_failed"; frame: number };
 
 /** Data collected during one continuous observation session. */
 export interface GameSession {
   started: boolean;
   startMechanism: string;
   piecesSpawned: number;
   piecesLocked: number;
   linesCleared: number;
   rotationsObserved: number;
   movementsObserved: number;
   hardDropsObserved: number;
   gameOverDetected: boolean;
   consoleErrors: string[];
   durationSeconds: number;
   pieceTypes: Set<string>;
   scoreValues: number[];
   gridReadSuccess: number;
   gridReadFail: number;
   frames: number;
   events: GridEvent[];
   /** Phases that were skipped and why. */
   skippedPhases: string[];
 }
 
 /** Gameplay statistics gathered during the play phase. */
 export interface GameplayStats {
   pieces_placed: number;
   lines_cleared: number;
   max_score_observed: number;
   play_duration_seconds: number;
   errors_during_play: number;
 }
 
 /** The full JSON report written at the end. */
 export interface BotReport {
   implementation: {
     renderer: string;
     grid_detected: boolean;
     grid_bounds: GridBounds | null;
     controls: Record<string, string>;
     start_mechanism: string;
     score_element_found: boolean;
     grid_confidence: number;
     survey: SurveyData;
   };
   tests: Array<{ name: string; pass: boolean; detail: string }>;
   summary: {
     total: number;
     passed: number;
     failed: number;
     skipped: number;
     score: number;
   };
   gameplay: GameplayStats;
   competitive_play: CompetitivePlayResult | null;
   session: {
     frames: number;
     events_count: number;
     pieces_spawned: number;
     pieces_locked: number;
     lines_cleared: number;
     piece_types_seen: string[];
     grid_read_success_rate: number;
   };
   performance?: {
     load_time_ms: number;
   };
   accessibility?: {
     issues: string[];
     issue_count: number;
     pass: boolean;
   };
 }
 
 /** Context passed through calibration, play, and reporting phases. */
 export interface BotContext {
   page: Page;
   calibration: CalibrationResult;
   gameplay: GameplayStats;
   testResults: TestResult[];
 }