1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/**
 * GameStatus - All possible states of a chess game
 * 
 * Design: Explicit states make status checks and transitions clear.
 * Terminal states are distinguished from active states.
 */
enum GameStatus {
    // === Pre-Game ===
    WAITING_FOR_PLAYERS = 'WAITING_FOR_PLAYERS',
    READY_TO_START = 'READY_TO_START',
    
    // === Active States ===
    ACTIVE = 'ACTIVE',           // Normal play, no check
    CHECK = 'CHECK',             // King is threatened but can escape
    
    // === Terminal States: Decisive ===
    CHECKMATE_WHITE_WINS = 'CHECKMATE_WHITE_WINS',
    CHECKMATE_BLACK_WINS = 'CHECKMATE_BLACK_WINS',
    RESIGNATION_WHITE_WINS = 'RESIGNATION_WHITE_WINS',
    RESIGNATION_BLACK_WINS = 'RESIGNATION_BLACK_WINS',
    TIMEOUT_WHITE_WINS = 'TIMEOUT_WHITE_WINS',
    TIMEOUT_BLACK_WINS = 'TIMEOUT_BLACK_WINS',
    
    // === Terminal States: Draw ===
    DRAW_STALEMATE = 'DRAW_STALEMATE',
    DRAW_AGREEMENT = 'DRAW_AGREEMENT',
    DRAW_INSUFFICIENT_MATERIAL = 'DRAW_INSUFFICIENT_MATERIAL',
    DRAW_THREEFOLD_REPETITION = 'DRAW_THREEFOLD_REPETITION',
    DRAW_FIFTY_MOVE_RULE = 'DRAW_FIFTY_MOVE_RULE',
    DRAW_TIMEOUT_VS_INSUFFICIENT = 'DRAW_TIMEOUT_VS_INSUFFICIENT',
}
 
/**
 * Helper methods for status classification
 */
class GameStatusHelper {
    static isActive(status: GameStatus): boolean {
        return status === GameStatus.ACTIVE || status === GameStatus.CHECK;
    }
    
    static isTerminal(status: GameStatus): boolean {
        return !this.isActive(status) && 
               status !== GameStatus.WAITING_FOR_PLAYERS &&
               status !== GameStatus.READY_TO_START;
    }
    
    static isDecisive(status: GameStatus): boolean {
        return status.includes('CHECKMATE') || 
               status.includes('RESIGNATION') ||
               (status.includes('TIMEOUT') && !status.includes('INSUFFICIENT'));
    }
    
    static isDraw(status: GameStatus): boolean {
        return status.startsWith('DRAW_');
    }
    
    static getWinner(status: GameStatus): Color | null {
        if (status.includes('WHITE_WINS')) return Color.WHITE;
        if (status.includes('BLACK_WINS')) return Color.BLACK;
        return null;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

/**
 * Turn management within the Game class
 */
class Game {
    private players: [Player, Player];  // [White, Black]
    private currentPlayerIndex: number = 0;  // 0 = White's turn
    private moveNumber: number = 1;  // Full moves (increments after Black)
    private halfMoveCount: number = 0;  // Half-moves (ply) since game start
    
    /**
     * Get the player whose turn it is
     */
    public getCurrentPlayer(): Player {
        return this.players[this.currentPlayerIndex];
    }
    
    /**
     * Get the color of the current player
     */
    public getCurrentColor(): Color {
        return this.currentPlayerIndex === 0 ? Color.WHITE : Color.BLACK;
    }
    
    /**
     * Get the opponent of the current player
     */
    public getOpponent(): Player {
        return this.players[this.currentPlayerIndex === 0 ? 1 : 0];
    }
    
    /**
     * Switch to the next player's turn
     * Called after a successful move
     */
    private switchTurn(): void {
        this.currentPlayerIndex = this.currentPlayerIndex === 0 ? 1 : 0;
        this.halfMoveCount++;
        
        // Move number increments after Black's move
        if (this.currentPlayerIndex === 0) {
            this.moveNumber++;
        }
    }
    
    /**
     * Revert turn (for undo)
     */
    private revertTurn(): void {
        // If we're reverting to White's move, decrement move number
        if (this.currentPlayerIndex === 0) {
            this.moveNumber--;
        }
        
        this.currentPlayerIndex = this.currentPlayerIndex === 0 ? 1 : 0;
        this.halfMoveCount--;
    }
    
    /**
     * Validate that a piece can be moved by the current player
     */
    private validateTurn(piece: Piece): boolean {
        return piece.color === this.getCurrentColor();
    }
    
    /**
     * Get current move number in standard notation
     * Format: "1." for White's move, "1..." for Black's move
     */
    public getMoveNotation(): string {
        if (this.currentPlayerIndex === 0) {
            return `${this.moveNumber}.`;
        } else {
            return `${this.moveNumber}...`;
        }
    }
    
    /**
     * Get total half-moves (ply) since game start
     * Useful for timing, analysis, and draw detection
     */
    public getPlyCount(): number {
        return this.halfMoveCount;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

/**
 * Checkmate and Stalemate Detection
 * 
 * Key insight: Both checkmate and stalemate involve having no legal moves.
 * The difference is whether the King is in check.
 */
class GameStateDetector {
    private game: Game;
    
    constructor(game: Game) {
        this.game = game;
    }
    
    /**
     * Detect if the given color is checkmated
     * Checkmate = In check + No legal moves
     */
    public isCheckmate(color: Color): boolean {
        // Must be in check
        if (!this.isInCheck(color)) {
            return false;
        }
        
        // Must have no legal moves
        return !this.hasLegalMove(color);
    }
    
    /**
     * Detect if the given color is stalemated
     * Stalemate = Not in check + No legal moves
     */
    public isStalemate(color: Color): boolean {
        // Must NOT be in check
        if (this.isInCheck(color)) {
            return false;
        }
        
        // Must have no legal moves
        return !this.hasLegalMove(color);
    }
    
    /**
     * Check if the given color has any legal move
     * Early termination for efficiency—we only need to find ONE legal move
     */
    private hasLegalMove(color: Color): boolean {
        const pieces = this.game.getBoard().getAllPieces(color);
        
        for (const piece of pieces) {
            const legalMoves = this.game.getLegalMoves(piece.getPosition());
            if (legalMoves.length > 0) {
                return true;  // Early termination
            }
        }
        
        return false;
    }
    
    /**
     * Is the King of the given color in check?
     */
    private isInCheck(color: Color): boolean {
        return CheckDetector.isInCheck(this.game.getBoard(), color);
    }
    
    /**
     * Comprehensive game state check after each move
     * Returns the new game status
     */
    public detectGameState(): GameStatus {
        const currentColor = this.game.getCurrentColor();
        
        // Check for checkmate
        if (this.isCheckmate(currentColor)) {
            return currentColor === Color.WHITE 
                ? GameStatus.CHECKMATE_BLACK_WINS 
                : GameStatus.CHECKMATE_WHITE_WINS;
        }
        
        // Check for stalemate
        if (this.isStalemate(currentColor)) {
            return GameStatus.DRAW_STALEMATE;
        }
        
        // Check for other draw conditions
        if (this.isInsufficientMaterial()) {
            return GameStatus.DRAW_INSUFFICIENT_MATERIAL;
        }
        
        if (this.isThreefoldRepetition()) {
            return GameStatus.DRAW_THREEFOLD_REPETITION;
        }
        
        if (this.isFiftyMoveRule()) {
            return GameStatus.DRAW_FIFTY_MOVE_RULE;
        }
        
        // Game continues—is the current player in check?
        if (this.isInCheck(currentColor)) {
            return GameStatus.CHECK;
        }
        
        return GameStatus.ACTIVE;
    }
}
 
/**
 * Integration in Game class
 */
class Game {
    private stateDetector: GameStateDetector;
    
    /**
     * Called after each move to update game status
     */
    private updateGameStatus(): void {
        this.status = this.stateDetector.detectGameState();
    }
    
    /**
     * Main move execution flow
     */
    public makeMove(from: Position, to: Position, promoteTo?: PieceType): MoveResult {
        // ... validation logic ...
        
        // Execute the move
        this.executeMove(move);
        
        // Switch to opponent's turn
        this.switchTurn();
        
        // Detect new game state (check/checkmate/stalemate)
        this.updateGameStatus();
        
        // If game ended, record the outcome
        if (GameStatusHelper.isTerminal(this.status)) {
            this.recordGameEnd();
        }
        
        return MoveResult.success(move);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

/**
 * Insufficient Material Detection
 * 
 * These material configurations cannot force checkmate:
 * - King vs King
 * - King + Bishop vs King
 * - King + Knight vs King
 * - King + Bishop vs King + Bishop (same color bishops)
 */
class InsufficientMaterialDetector {
    public static isInsufficientMaterial(board: Board): boolean {
        const whitePieces = board.getAllPieces(Color.WHITE);
        const blackPieces = board.getAllPieces(Color.BLACK);
        
        const whiteMaterial = this.categorizeMaterial(whitePieces);
        const blackMaterial = this.categorizeMaterial(blackPieces);
        
        // King vs King
        if (whiteMaterial.total === 1 && blackMaterial.total === 1) {
            return true;
        }
        
        // King + minor piece vs King
        if (whiteMaterial.total === 2 && blackMaterial.total === 1) {
            if (whiteMaterial.bishops === 1 || whiteMaterial.knights === 1) {
                return true;
            }
        }
        if (blackMaterial.total === 2 && whiteMaterial.total === 1) {
            if (blackMaterial.bishops === 1 || blackMaterial.knights === 1) {
                return true;
            }
        }
        
        // King + Bishop vs King + Bishop (same color squares)
        if (whiteMaterial.total === 2 && blackMaterial.total === 2) {
            if (whiteMaterial.bishops === 1 && blackMaterial.bishops === 1) {
                const whiteBishop = whitePieces.find(p => p.type === PieceType.BISHOP)!;
                const blackBishop = blackPieces.find(p => p.type === PieceType.BISHOP)!;
                
                if (this.isSameColorSquare(whiteBishop, blackBishop)) {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    private static categorizeMaterial(pieces: Piece[]): MaterialCount {
        return {
            total: pieces.length,
            queens: pieces.filter(p => p.type === PieceType.QUEEN).length,
            rooks: pieces.filter(p => p.type === PieceType.ROOK).length,
            bishops: pieces.filter(p => p.type === PieceType.BISHOP).length,
            knights: pieces.filter(p => p.type === PieceType.KNIGHT).length,
            pawns: pieces.filter(p => p.type === PieceType.PAWN).length,
        };
    }
    
    private static isSameColorSquare(piece1: Piece, piece2: Piece): boolean {
        const pos1 = piece1.getPosition();
        const pos2 = piece2.getPosition();
        
        // Square color is determined by (file + rank) parity
        const color1 = (pos1.getFileIndex() + pos1.rank) % 2;
        const color2 = (pos2.getFileIndex() + pos2.rank) % 2;
        
        return color1 === color2;
    }
}
 
interface MaterialCount {
    total: number;
    queens: number;
    rooks: number;
    bishops: number;
    knights: number;
    pawns: number;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

/**
 * Threefold Repetition Detection
 * 
 * A position is defined by:
 * - Piece placement
 * - Active color (whose turn)
 * - Castling availability (KQkq)
 * - En passant target square
 * 
 * We use a hash of these elements to track position occurrences.
 */
class RepetitionDetector {
    private positionHistory: Map<string, number> = new Map();
    
    /**
     * Record the current position after a move
     */
    public recordPosition(game: Game): void {
        const hash = this.computePositionHash(game);
        const count = this.positionHistory.get(hash) ?? 0;
        this.positionHistory.set(hash, count + 1);
    }
    
    /**
     * Check if current position has occurred 3+ times
     */
    public isThreefoldRepetition(game: Game): boolean {
        const hash = this.computePositionHash(game);
        const count = this.positionHistory.get(hash) ?? 0;
        return count >= 3;
    }
    
    /**
     * Undo position recording (for move undo)
     */
    public unrecordPosition(game: Game): void {
        const hash = this.computePositionHash(game);
        const count = this.positionHistory.get(hash) ?? 0;
        if (count > 1) {
            this.positionHistory.set(hash, count - 1);
        } else {
            this.positionHistory.delete(hash);
        }
    }
    
    /**
     * Compute a unique hash for the current position
     * Uses FEN-like encoding for consistency
     */
    private computePositionHash(game: Game): string {
        const board = game.getBoard();
        const parts: string[] = [];
        
        // Piece placement
        for (let rank = 8; rank >= 1; rank--) {
            let emptyCount = 0;
            let rankStr = '';
            
            for (const file of Board.FILES) {
                const piece = board.getPieceAt(Position.at(file, rank));
                if (piece) {
                    if (emptyCount > 0) {
                        rankStr += emptyCount;
                        emptyCount = 0;
                    }
                    rankStr += this.pieceToChar(piece);
                } else {
                    emptyCount++;
                }
            }
            
            if (emptyCount > 0) rankStr += emptyCount;
            parts.push(rankStr);
        }
        
        const placement = parts.join('/');
        
        // Active color
        const activeColor = game.getCurrentColor() === Color.WHITE ? 'w' : 'b';
        
        // Castling availability
        const castling = this.getCastlingString(game);
        
        // En passant target
        const enPassant = game.getEnPassantTarget()?.toAlgebraic() ?? '-';
        
        return `${placement} ${activeColor} ${castling} ${enPassant}`;
    }
    
    private pieceToChar(piece: Piece): string {
        const chars: Record<PieceType, string> = {
            [PieceType.KING]: 'k',
            [PieceType.QUEEN]: 'q',
            [PieceType.ROOK]: 'r',
            [PieceType.BISHOP]: 'b',
            [PieceType.KNIGHT]: 'n',
            [PieceType.PAWN]: 'p',
        };
        const char = chars[piece.type];
        return piece.color === Color.WHITE ? char.toUpperCase() : char;
    }
    
    private getCastlingString(game: Game): string {
        let result = '';
        if (game.canCastleKingside(Color.WHITE)) result += 'K';
        if (game.canCastleQueenside(Color.WHITE)) result += 'Q';
        if (game.canCastleKingside(Color.BLACK)) result += 'k';
        if (game.canCastleQueenside(Color.BLACK)) result += 'q';
        return result || '-';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/**
 * Fifty-Move Rule Detection
 * 
 * The fifty-move rule states that a player may claim a draw if 
 * 50 consecutive moves have been made by both players without:
 * - Any pawn being moved
 * - Any piece being captured
 * 
 * We track this with a "half-move clock" (reset on pawn move or capture)
 */
class FiftyMoveDetector {
    private halfMoveClock: number = 0;  // Counts half-moves (ply)
    
    /**
     * Update clock after a move
     * Reset if pawn move or capture, otherwise increment
     */
    public updateAfterMove(move: Move): void {
        if (move.piece.type === PieceType.PAWN || move.capturedPiece) {
            this.halfMoveClock = 0;  // Reset
        } else {
            this.halfMoveClock++;  // Increment
        }
    }
    
    /**
     * Revert clock (for undo)
     * This requires storing the previous clock value in Move
     */
    public revertToValue(previousValue: number): void {
        this.halfMoveClock = previousValue;
    }
    
    /**
     * Check if fifty-move rule applies
     * Note: 50 moves = 100 half-moves (ply)
     */
    public isFiftyMoveRule(): boolean {
        return this.halfMoveClock >= 100;
    }
    
    /**
     * Get current half-move clock value
     */
    public getClock(): number {
        return this.halfMoveClock;
    }
}
 
/**
 * Enhanced Move class to support undo of fifty-move clock
 */
class Move {
    // ... existing properties ...
    
    // For fifty-move rule undo
    public readonly previousHalfMoveClock: number;
    
    constructor(/* ... */, previousHalfMoveClock: number) {
        // ... existing logic ...
        this.previousHalfMoveClock = previousHalfMoveClock;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

/**
 * Game Events - Typed events for the Observer pattern
 */
interface GameEvent {
    type: string;
    timestamp: Date;
    gameId: string;
}
 
interface GameStartedEvent extends GameEvent {
    type: 'GAME_STARTED';
    whitePlayer: Player;
    blackPlayer: Player;
}
 
interface MoveMadeEvent extends GameEvent {
    type: 'MOVE_MADE';
    move: Move;
    moveNumber: number;
    fen: string;  // Current position
    isCheck: boolean;
    timeRemaining?: { white: number; black: number };
}
 
interface GameEndedEvent extends GameEvent {
    type: 'GAME_ENDED';
    status: GameStatus;
    winner: Color | null;
    reason: string;
    finalFen: string;
    totalMoves: number;
    pgn: string;
}
 
interface CheckEvent extends GameEvent {
    type: 'CHECK';
    checkedColor: Color;
    checkingPieces: Position[];
}
 
/**
 * Event emitter for game events
 */
type GameEventListener = (event: GameEvent) => void;
 
class GameEventEmitter {
    private listeners: Map<string, Set<GameEventListener>> = new Map();
    
    public on(eventType: string, listener: GameEventListener): void {
        if (!this.listeners.has(eventType)) {
            this.listeners.set(eventType, new Set());
        }
        this.listeners.get(eventType)!.add(listener);
    }
    
    public off(eventType: string, listener: GameEventListener): void {
        this.listeners.get(eventType)?.delete(listener);
    }
    
    public emit(event: GameEvent): void {
        const eventListeners = this.listeners.get(event.type);
        if (eventListeners) {
            eventListeners.forEach(listener => listener(event));
        }
        
        // Also emit to wildcard listeners
        const wildcardListeners = this.listeners.get('*');
        if (wildcardListeners) {
            wildcardListeners.forEach(listener => listener(event));
        }
    }
}
 
/**
 * Integration in Game class
 */
class Game {
    private eventEmitter: GameEventEmitter = new GameEventEmitter();
    
    public on(eventType: string, listener: GameEventListener): void {
        this.eventEmitter.on(eventType, listener);
    }
    
    public start(): void {
        this.board.setupStandardPosition();
        this.status = GameStatus.ACTIVE;
        
        this.eventEmitter.emit({
            type: 'GAME_STARTED',
            timestamp: new Date(),
            gameId: this.id,
            whitePlayer: this.players[0],
            blackPlayer: this.players[1],
        } as GameStartedEvent);
    }
    
    private executeMove(move: Move): void {
        // ... execute move logic ...
        
        this.eventEmitter.emit({
            type: 'MOVE_MADE',
            timestamp: new Date(),
            gameId: this.id,
            move: move,
            moveNumber: this.moveNumber,
            fen: this.toFEN(),
            isCheck: move.isCheck,
        } as MoveMadeEvent);
        
        if (move.isCheck) {
            this.eventEmitter.emit({
                type: 'CHECK',
                timestamp: new Date(),
                gameId: this.id,
                checkedColor: this.getOpponentColor(),
                checkingPieces: this.getCheckingPiecePositions(),
            } as CheckEvent);
        }
    }
    
    private recordGameEnd(): void {
        this.eventEmitter.emit({
            type: 'GAME_ENDED',
            timestamp: new Date(),
            gameId: this.id,
            status: this.status,
            winner: GameStatusHelper.getWinner(this.status),
            reason: this.getEndReason(),
            finalFen: this.toFEN(),
            totalMoves: this.moveHistory.length,
            pgn: this.toPGN(),
        } as GameEndedEvent);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

/**
 * Handling voluntary game termination
 */
class Game {
    private pendingDrawOffer: Color | null = null;
    
    /**
     * A player resigns, conceding the game
     */
    public resign(resigningColor: Color): void {
        if (!GameStatusHelper.isActive(this.status)) {
            throw new GameError('Cannot resign: game is not active');
        }
        
        this.status = resigningColor === Color.WHITE 
            ? GameStatus.RESIGNATION_BLACK_WINS 
            : GameStatus.RESIGNATION_WHITE_WINS;
        
        this.recordGameEnd();
    }
    
    /**
     * A player offers a draw
     * The offer is only valid until the opponent moves
     */
    public offerDraw(offeringColor: Color): void {
        if (!GameStatusHelper.isActive(this.status)) {
            throw new GameError('Cannot offer draw: game is not active');
        }
        
        // Can only offer on your own turn (or immediately after your move)
        if (this.getCurrentColor() !== offeringColor) {
            throw new GameError('Can only offer draw on your turn');
        }
        
        this.pendingDrawOffer = offeringColor;
        
        this.eventEmitter.emit({
            type: 'DRAW_OFFERED',
            timestamp: new Date(),
            gameId: this.id,
            offeringColor: offeringColor,
        });
    }
    
    /**
     * Opponent responds to draw offer
     */
    public respondToDrawOffer(respondingColor: Color, accept: boolean): void {
        if (!this.pendingDrawOffer) {
            throw new GameError('No pending draw offer');
        }
        
        if (this.pendingDrawOffer === respondingColor) {
            throw new GameError('Cannot respond to your own draw offer');
        }
        
        if (accept) {
            this.status = GameStatus.DRAW_AGREEMENT;
            this.recordGameEnd();
        }
        
        this.pendingDrawOffer = null;
        
        this.eventEmitter.emit({
            type: 'DRAW_RESPONDED',
            timestamp: new Date(),
            gameId: this.id,
            accepted: accept,
            respondingColor: respondingColor,
        });
    }
    
    /**
     * Making a move automatically declines a pending draw offer
     */
    public makeMove(from: Position, to: Position, promoteTo?: PieceType): MoveResult {
        // ... validation ...
        
        // Decline pending draw offer by making a move
        if (this.pendingDrawOffer && this.pendingDrawOffer !== this.getCurrentColor()) {
            this.pendingDrawOffer = null;
            // Implicitly declined
        }
        
        // ... execute move ...
    }
    
    /**
     * Claim a draw (for rules that require claiming)
     * Threefold repetition and fifty-move rule can be claimed
     */
    public claimDraw(claimingColor: Color, reason: 'REPETITION' | 'FIFTY_MOVE'): void {
        if (this.getCurrentColor() !== claimingColor) {
            throw new GameError('Can only claim draw on your turn');
        }
        
        if (reason === 'REPETITION') {
            if (!this.isThreefoldRepetition()) {
                throw new GameError('Threefold repetition has not occurred');
            }
            this.status = GameStatus.DRAW_THREEFOLD_REPETITION;
        } else {
            if (!this.isFiftyMoveRule()) {
                throw new GameError('Fifty-move rule does not apply');
            }
            this.status = GameStatus.DRAW_FIFTY_MOVE_RULE;
        }
        
        this.recordGameEnd();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

/**
 * Time Control Types
 */
interface TimeControl {
    type: 'NONE' | 'BULLET' | 'BLITZ' | 'RAPID' | 'CLASSICAL' | 'CUSTOM';
    initialTimeMs: number;
    incrementMs: number;  // Added after each move
}
 
/**
 * Clock management (sketch)
 */
class ChessClock {
    private timeRemaining: [number, number];  // [White, Black] in ms
    private activePlayer: number = 0;
    private lastTickTime: number | null = null;
    private intervalId: NodeJS.Timer | null = null;
    
    constructor(private timeControl: TimeControl) {
        this.timeRemaining = [
            timeControl.initialTimeMs,
            timeControl.initialTimeMs
        ];
    }
    
    public start(): void {
        this.lastTickTime = Date.now();
        this.intervalId = setInterval(() => this.tick(), 100);
    }
    
    public switchPlayer(): void {
        // Add increment to player who just moved
        this.timeRemaining[this.activePlayer] += this.timeControl.incrementMs;
        
        // Switch
        this.activePlayer = this.activePlayer === 0 ? 1 : 0;
        this.lastTickTime = Date.now();
    }
    
    public stop(): void {
        if (this.intervalId) {
            clearInterval(this.intervalId);
        }
    }
    
    private tick(): void {
        if (this.lastTickTime === null) return;
        
        const now = Date.now();
        const elapsed = now - this.lastTickTime;
        this.lastTickTime = now;
        
        this.timeRemaining[this.activePlayer] -= elapsed;
        
        if (this.timeRemaining[this.activePlayer] <= 0) {
            this.timeRemaining[this.activePlayer] = 0;
            this.onTimeout(this.activePlayer === 0 ? Color.WHITE : Color.BLACK);
        }
    }
    
    private onTimeout(color: Color): void {
        // Emit timeout event for Game to handle
    }
    
    public getTimeRemaining(color: Color): number {
        return this.timeRemaining[color === Color.WHITE ? 0 : 1];
    }
}