export type ExperimentalState = {
    snakeIndex: number;
    snakeCurrent: number[];
    snakeDirection: "up" | "down" | "right" | "left";
    snakeAppleIndex: number;
    snakeScore: number;
    snakeSpeed: number;
    snakeInterval: number;
    /** Image grid stress test: hex color per tile index (one iframe per pixel). */
    imageGridPixels: string[];
    /** Dxball: paddle width (game units). Host sizes bar iframe from this. */
    dxballBar: {
        width: number;
    };
    /** Dxball: ball position (host may mirror for widgets). */
    dxballBall: {
        left: number;
        top: number;
    };
    /** Dxball: one per brick; type = kind, level = hit points (0 = gone). */
    dxballBricks: Array<{
        type: number;
        level: number;
    }>;
    /** Dxball: wall segments (left, right, top). */
    dxballWalls: Array<{
        side: "left" | "right" | "top";
        left: number;
        top: number;
        width: number;
        height: number;
    }>;
    /** Dxball: score; used for bar growth. */
    dxballScore: number;
    /** Tower Defense HQ: ground tiles 20x20 (index 0..399). */
    tdGround: Array<{
        type: "grass" | "path" | "towerSlot";
    }>;
    /** Tower Defense HQ: castle/HQ health. */
    tdCastle: {
        hp: number;
        maxHp: number;
    };
    /** Tower Defense HQ: towers (max 32). cellIndex -1 = empty; deathProgress 1 = removed. */
    tdTowers: Array<{
        cellIndex: number;
        type: number;
        level: number;
        hp: number;
        maxHp: number;
        targetEnemyId: number | null;
        deathProgress: number;
    }>;
    /** Tower Defense HQ: enemies (max 48). active false = slot free; deathProgress 0..1 = dying. */
    tdEnemies: Array<{
        id: number;
        pathProgress: number;
        hp: number;
        maxHp: number;
        typeId: number;
        active: boolean;
        deathProgress: number;
    }>;
    /** Tower Defense HQ: projectiles (max 32). active false = inactive. */
    tdProjectiles: Array<{
        x: number;
        y: number;
        fromTowerIndex: number;
        targetEnemyId: number;
        active: boolean;
    }>;
    /** Tower Defense HQ: upgrade panel. */
    tdUpgradePanel: {
        visible: boolean;
        selectedTowerIndex: number | null;
        gold: number;
    };
    /** Tower Defense HQ: game state. */
    tdGame: {
        gold: number;
        waveIndex: number;
        wavePhase: "building" | "wave" | "next";
        running: boolean;
        levelId: string;
        gameOver: boolean;
        win: boolean;
    };
    /** Tower Defense HQ: applicant type definitions (id, title, hp, speed, damageToHq, goldOnKill). */
    tdEnemyTypes: Array<{
        id: number;
        title: string;
        hp: number;
        speed: number;
        damageToHq: number;
        goldOnKill: number;
    }>;
    /** Tower Defense HQ: show coin pile when HQ is destroyed (game over). */
    tdShowCoinPile: boolean;
    /** VONQieBird: bird position and state. */
    vonqieBird: {
        y: number;
        vy: number;
        alive: boolean;
    };
    /** VONQieBird: pipe obstacles (recycled by host). */
    vonqieObstacles: Array<{
        x: number;
        gapY: number;
        gapHeight: number;
        width: number;
        active: boolean;
    }>;
    /** VONQieBird: background scroll. */
    vonqieScene: {
        scrollOffset: number;
    };
    /** VONQieBird: game state. */
    vonqieGame: {
        score: number;
        running: boolean;
        gameOver: boolean;
    };
    /** Merge game: 100 cells, null = empty. */
    mergeGrid: Array<{
        category: number;
        level: number;
    } | null>;
    /** Merge game: score. */
    mergeScore: number;
    /** Merge game: running flag. */
    mergeGame: {
        running: boolean;
    };
    /** Tetris: 200 cells (10x20), 0 = empty, 1–7 = locked block color. */
    tetrisBoard: number[];
    /** Tetris: current piece (type 0–6, rotation 0–3, x, y); null when none. */
    tetrisCurrentPiece: {
        type: number;
        rotation: number;
        x: number;
        y: number;
    } | null;
    /** Tetris: score, level, lines, gameOver, running. */
    tetrisGame: {
        score: number;
        level: number;
        lines: number;
        gameOver: boolean;
        running: boolean;
    };
    /** Tetris: next piece type 0–6. */
    tetrisNextPiece: number;
    /** Tavla: 24 points, index 0 = point 1. */
    tavlaPoints: Array<{
        black: number;
        white: number;
    }>;
    /** Tavla: checkers on bar. */
    tavlaBar: {
        black: number;
        white: number;
    };
    /** Tavla: whose turn. */
    tavlaTurn: "black" | "white";
    /** Tavla: phase. */
    tavlaPhase: "opening_roll" | "rolling" | "moving" | "game_over";
    /** Tavla: dice roll or null. */
    tavlaDice: [number, number] | null;
    /** Tavla: move sizes left this turn. */
    tavlaMovesRemaining: number[];
    /** Tavla: opening roll (who goes first). */
    tavlaOpeningRolls: {
        black: number | null;
        white: number | null;
    };
    /** Tavla: selected point 1–24 or 0 for bar. */
    tavlaSelectedPoint: number | null;
    /** Tavla: valid move targets. */
    tavlaHighlightTargets: number[];
    /** Tavla: hitting checker cannot move again this turn. */
    tavlaHitAndRunBlocked: boolean;
    /** Tavla: match score. */
    tavlaScores: {
        black: number;
        white: number;
    };
    /** Tavla: game result. */
    tavlaGameResult: {
        winner: "black" | "white";
        mars: boolean;
    } | null;
    /** Battleship: my board 100 cells; 0=water, 1=ship unhit, 2=ship hit, 3=miss. */
    battleshipMyBoard: number[];
    /** Battleship: their board 100 cells; 0=not shot, 1=miss, 2=hit. */
    battleshipTheirBoard: number[];
    /** Battleship: whose turn to fire. */
    battleshipTurn: "host" | "guest";
    /** Battleship: phase. */
    battleshipPhase: "setup" | "playing" | "game_over";
    /** Battleship: game result. */
    battleshipGameResult: {
        winner: "host" | "guest";
    } | null;
    /** Battleship: true when it is my turn and phase is playing. */
    battleshipCanFire: boolean;
    /** Image Reveal: hex color per tile index (pixel grid). */
    imageRevealPixels: string[];
    /** Image Reveal: which tiles have been revealed. */
    imageRevealRevealed: boolean[];
    /** Image Reveal: player data for leaderboard. */
    imageRevealPlayers: Array<{
        username: string;
        score: number;
        misses: number;
        bonus: number;
    }>;
    /** Image Reveal: current game phase. */
    imageRevealPhase: "lobby" | "playing" | "ended";
    /** Image Reveal: remote cursor positions. */
    imageRevealCursors: Array<{
        username: string;
        x: number;
        y: number;
        color: string;
    }>;
    /** DOOM: viewport column data for canvas (raycast result). */
    doomViewport: {
        columns: Array<{
            height: number;
            color: string;
        }>;
        width: number;
        height: number;
    };
    /** DOOM: player state. */
    doomPlayer: {
        x: number;
        y: number;
        angle: number;
        health: number;
        ammo: number;
        weaponId: number;
    };
    /** DOOM: HUD state for primitives. */
    doomHud: {
        health: number;
        maxHealth: number;
        ammo: number;
        weaponId: number;
        message: string;
        messageTime: number;
    };
    /** DOOM: minimap data. */
    doomMap: {
        cells: number[][];
        playerX: number;
        playerY: number;
        angle: number;
    };
};
//# sourceMappingURL=state.types.d.ts.map