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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206

/**
 * MovementStrategy - The Strategy interface
 * 
 * Defines the contract for all piece movement behaviors.
 * Each piece type implements this differently.
 */
interface MovementStrategy {
    /**
     * Get all squares this piece can potentially move to
     * (pseudo-legal moves, not considering check)
     */
    getPossibleMoves(piece: Piece, board: Board): Position[];
    
    /**
     * Can this piece attack the target square?
     * Used for check detection.
     */
    canAttack(piece: Piece, target: Position, board: Board): boolean;
}
 
/**
 * KingMovementStrategy - One square in any direction
 */
class KingMovementStrategy implements MovementStrategy {
    private static readonly DIRECTIONS: [number, number][] = [
        [-1, -1], [-1, 0], [-1, 1],
        [0, -1],           [0, 1],
        [1, -1],  [1, 0],  [1, 1]
    ];
    
    getPossibleMoves(piece: Piece, board: Board): Position[] {
        const moves: Position[] = [];
        const pos = piece.getPosition();
        
        for (const [df, dr] of KingMovementStrategy.DIRECTIONS) {
            const target = pos.offset(df, dr);
            if (target && !board.isOccupiedByColor(target, piece.color)) {
                moves.push(target);
            }
        }
        
        return moves;
    }
    
    canAttack(piece: Piece, target: Position, board: Board): boolean {
        const pos = piece.getPosition();
        const fileDiff = Math.abs(target.getFileIndex() - pos.getFileIndex());
        const rankDiff = Math.abs(target.rank - pos.rank);
        
        return fileDiff <= 1 && rankDiff <= 1 && (fileDiff + rankDiff > 0);
    }
}
 
/**
 * SlidingMovementStrategy - Base class for Queen, Rook, Bishop
 * Uses Template Method pattern within Strategy pattern
 */
abstract class SlidingMovementStrategy implements MovementStrategy {
    protected abstract getDirections(): [number, number][];
    
    getPossibleMoves(piece: Piece, board: Board): Position[] {
        const moves: Position[] = [];
        const pos = piece.getPosition();
        
        for (const [df, dr] of this.getDirections()) {
            let distance = 1;
            
            while (true) {
                const target = pos.offset(df * distance, dr * distance);
                if (!target) break;
                
                if (board.isEmpty(target)) {
                    moves.push(target);
                    distance++;
                } else if (!board.isOccupiedByColor(target, piece.color)) {
                    moves.push(target);  // Can capture
                    break;
                } else {
                    break;  // Blocked by own piece
                }
            }
        }
        
        return moves;
    }
    
    canAttack(piece: Piece, target: Position, board: Board): boolean {
        const pos = piece.getPosition();
        
        for (const [df, dr] of this.getDirections()) {
            let distance = 1;
            
            while (true) {
                const checkPos = pos.offset(df * distance, dr * distance);
                if (!checkPos) break;
                
                if (checkPos.equals(target)) return true;
                if (board.isOccupied(checkPos)) break;
                
                distance++;
            }
        }
        
        return false;
    }
}
 
class RookMovementStrategy extends SlidingMovementStrategy {
    protected getDirections(): [number, number][] {
        return [[0, 1], [0, -1], [1, 0], [-1, 0]];
    }
}
 
class BishopMovementStrategy extends SlidingMovementStrategy {
    protected getDirections(): [number, number][] {
        return [[1, 1], [1, -1], [-1, 1], [-1, -1]];
    }
}
 
class QueenMovementStrategy extends SlidingMovementStrategy {
    protected getDirections(): [number, number][] {
        return [
            [0, 1], [0, -1], [1, 0], [-1, 0],  // Rook directions
            [1, 1], [1, -1], [-1, 1], [-1, -1] // Bishop directions
        ];
    }
}
 
/**
 * KnightMovementStrategy - L-shaped jumps
 */
class KnightMovementStrategy implements MovementStrategy {
    private static readonly JUMPS: [number, number][] = [
        [-2, -1], [-2, 1], [-1, -2], [-1, 2],
        [1, -2],  [1, 2],  [2, -1],  [2, 1]
    ];
    
    getPossibleMoves(piece: Piece, board: Board): Position[] {
        const moves: Position[] = [];
        const pos = piece.getPosition();
        
        for (const [df, dr] of KnightMovementStrategy.JUMPS) {
            const target = pos.offset(df, dr);
            if (target && !board.isOccupiedByColor(target, piece.color)) {
                moves.push(target);
            }
        }
        
        return moves;
    }
    
    canAttack(piece: Piece, target: Position, board: Board): boolean {
        const pos = piece.getPosition();
        const fileDiff = Math.abs(target.getFileIndex() - pos.getFileIndex());
        const rankDiff = Math.abs(target.rank - pos.rank);
        
        return (fileDiff === 2 && rankDiff === 1) || 
               (fileDiff === 1 && rankDiff === 2);
    }
}
 
/**
 * PawnMovementStrategy - The most complex movement rules
 */
class PawnMovementStrategy implements MovementStrategy {
    getPossibleMoves(piece: Piece, board: Board): Position[] {
        const moves: Position[] = [];
        const pos = piece.getPosition();
        const direction = piece.color === Color.WHITE ? 1 : -1;
        const startRank = piece.color === Color.WHITE ? 2 : 7;
        
        // Forward one
        const oneForward = pos.offset(0, direction);
        if (oneForward && board.isEmpty(oneForward)) {
            moves.push(oneForward);
            
            // Forward two from start
            if (pos.rank === startRank) {
                const twoForward = pos.offset(0, direction * 2);
                if (twoForward && board.isEmpty(twoForward)) {
                    moves.push(twoForward);
                }
            }
        }
        
        // Diagonal captures
        for (const fileDir of [-1, 1]) {
            const captureSquare = pos.offset(fileDir, direction);
            if (captureSquare && board.isOccupiedByOpponent(captureSquare, piece.color)) {
                moves.push(captureSquare);
            }
        }
        
        return moves;
    }
    
    canAttack(piece: Piece, target: Position, board: Board): boolean {
        const pos = piece.getPosition();
        const direction = piece.color === Color.WHITE ? 1 : -1;
        
        const fileDiff = Math.abs(target.getFileIndex() - pos.getFileIndex());
        const expectedRank = pos.rank + direction;
        
        return fileDiff === 1 && target.rank === expectedRank;
    }
}

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

/**
 * Piece with Strategy Pattern
 * 
 * Now Piece is simpler—it delegates movement logic to its strategy.
 * Adding a new piece type only requires a new strategy class.
 */
class Piece {
    public readonly type: PieceType;
    public readonly color: Color;
    private position: Position;
    private movementStrategy: MovementStrategy;
    private hasMoved: boolean = false;
    
    constructor(type: PieceType, color: Color, position: Position) {
        this.type = type;
        this.color = color;
        this.position = position;
        this.movementStrategy = MovementStrategyFactory.create(type);
    }
    
    /**
     * Delegate to strategy
     */
    public getPossibleMoves(board: Board): Position[] {
        return this.movementStrategy.getPossibleMoves(this, board);
    }
    
    public canAttack(target: Position, board: Board): boolean {
        return this.movementStrategy.canAttack(this, target, board);
    }
    
    // ... other methods unchanged
}
 
/**
 * Factory for creating appropriate strategy
 */
class MovementStrategyFactory {
    private static strategies: Map<PieceType, MovementStrategy> = new Map([
        [PieceType.KING, new KingMovementStrategy()],
        [PieceType.QUEEN, new QueenMovementStrategy()],
        [PieceType.ROOK, new RookMovementStrategy()],
        [PieceType.BISHOP, new BishopMovementStrategy()],
        [PieceType.KNIGHT, new KnightMovementStrategy()],
        [PieceType.PAWN, new PawnMovementStrategy()],
    ]);
    
    public static create(type: PieceType): MovementStrategy {
        const strategy = this.strategies.get(type);
        if (!strategy) {
            throw new Error(`Unknown piece type: ${type}`);
        }
        return strategy;
    }
}

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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367

/**
 * MoveCommand - The Command interface
 * 
 * Each move type implements this interface with its own
 * execution and undo logic.
 */
interface MoveCommand {
    /**
     * Execute the move on the board
     */
    execute(board: Board): void;
    
    /**
     * Reverse the move, restoring previous state
     */
    undo(board: Board): void;
    
    /**
     * Get algebraic notation for this move
     */
    getNotation(): string;
    
    /**
     * Get move metadata for history
     */
    getMetadata(): MoveMetadata;
}
 
interface MoveMetadata {
    piece: PieceType;
    color: Color;
    from: Position;
    to: Position;
    isCapture: boolean;
    isCheck: boolean;
    isCheckmate: boolean;
    timestamp: Date;
}
 
/**
 * NormalMoveCommand - Simple piece movement without capture
 */
class NormalMoveCommand implements MoveCommand {
    private piece: Piece;
    private from: Position;
    private to: Position;
    private wasFirstMove: boolean;
    
    constructor(piece: Piece, from: Position, to: Position) {
        this.piece = piece;
        this.from = from;
        this.to = to;
        this.wasFirstMove = !piece.hasBeenMoved();
    }
    
    execute(board: Board): void {
        board.removePiece(this.from);
        board.placePiece(this.piece, this.to);
        this.piece.setPosition(this.to);
    }
    
    undo(board: Board): void {
        board.removePiece(this.to);
        board.placePiece(this.piece, this.from);
        this.piece.setPosition(this.from);
        
        // Restore hasMoved state if this was first move
        if (this.wasFirstMove) {
            this.piece.resetMoved();
        }
    }
    
    getNotation(): string {
        return `${this.piece.getSymbol()}${this.to.toAlgebraic()}`;
    }
    
    getMetadata(): MoveMetadata {
        return {
            piece: this.piece.type,
            color: this.piece.color,
            from: this.from,
            to: this.to,
            isCapture: false,
            isCheck: false,
            isCheckmate: false,
            timestamp: new Date(),
        };
    }
}
 
/**
 * CaptureCommand - Move that captures an opponent piece
 */
class CaptureCommand implements MoveCommand {
    private piece: Piece;
    private from: Position;
    private to: Position;
    private capturedPiece: Piece;
    private wasFirstMove: boolean;
    
    constructor(
        piece: Piece, 
        from: Position, 
        to: Position, 
        capturedPiece: Piece
    ) {
        this.piece = piece;
        this.from = from;
        this.to = to;
        this.capturedPiece = capturedPiece;
        this.wasFirstMove = !piece.hasBeenMoved();
    }
    
    execute(board: Board): void {
        // Remove captured piece first
        board.removePiece(this.to);
        
        // Move attacking piece
        board.removePiece(this.from);
        board.placePiece(this.piece, this.to);
        this.piece.setPosition(this.to);
    }
    
    undo(board: Board): void {
        // Move piece back
        board.removePiece(this.to);
        board.placePiece(this.piece, this.from);
        this.piece.setPosition(this.from);
        
        // Restore captured piece
        board.placePiece(this.capturedPiece, this.to);
        
        if (this.wasFirstMove) {
            this.piece.resetMoved();
        }
    }
    
    getNotation(): string {
        const pieceSymbol = this.piece.type === PieceType.PAWN 
            ? this.from.file 
            : this.piece.getSymbol();
        return `${pieceSymbol}x${this.to.toAlgebraic()}`;
    }
    
    getMetadata(): MoveMetadata {
        return {
            piece: this.piece.type,
            color: this.piece.color,
            from: this.from,
            to: this.to,
            isCapture: true,
            isCheck: false,
            isCheckmate: false,
            timestamp: new Date(),
        };
    }
}
 
/**
 * CastlingCommand - Complex move involving King and Rook
 */
class CastlingCommand implements MoveCommand {
    private king: Piece;
    private rook: Piece;
    private kingFrom: Position;
    private kingTo: Position;
    private rookFrom: Position;
    private rookTo: Position;
    private isKingside: boolean;
    
    constructor(
        king: Piece,
        rook: Piece,
        kingFrom: Position,
        kingTo: Position,
        rookFrom: Position,
        rookTo: Position,
        isKingside: boolean
    ) {
        this.king = king;
        this.rook = rook;
        this.kingFrom = kingFrom;
        this.kingTo = kingTo;
        this.rookFrom = rookFrom;
        this.rookTo = rookTo;
        this.isKingside = isKingside;
    }
    
    execute(board: Board): void {
        // Move King
        board.removePiece(this.kingFrom);
        board.placePiece(this.king, this.kingTo);
        this.king.setPosition(this.kingTo);
        
        // Move Rook
        board.removePiece(this.rookFrom);
        board.placePiece(this.rook, this.rookTo);
        this.rook.setPosition(this.rookTo);
    }
    
    undo(board: Board): void {
        // Move King back
        board.removePiece(this.kingTo);
        board.placePiece(this.king, this.kingFrom);
        this.king.setPosition(this.kingFrom);
        this.king.resetMoved();
        
        // Move Rook back
        board.removePiece(this.rookTo);
        board.placePiece(this.rook, this.rookFrom);
        this.rook.setPosition(this.rookFrom);
        this.rook.resetMoved();
    }
    
    getNotation(): string {
        return this.isKingside ? 'O-O' : 'O-O-O';
    }
    
    getMetadata(): MoveMetadata {
        return {
            piece: PieceType.KING,
            color: this.king.color,
            from: this.kingFrom,
            to: this.kingTo,
            isCapture: false,
            isCheck: false,
            isCheckmate: false,
            timestamp: new Date(),
        };
    }
}
 
/**
 * EnPassantCommand - Pawn captures pawn in passing
 */
class EnPassantCommand implements MoveCommand {
    private pawn: Piece;
    private from: Position;
    private to: Position;
    private capturedPawn: Piece;
    private capturedPawnPos: Position;
    
    constructor(
        pawn: Piece,
        from: Position,
        to: Position,
        capturedPawn: Piece
    ) {
        this.pawn = pawn;
        this.from = from;
        this.to = to;
        this.capturedPawn = capturedPawn;
        // Captured pawn is on same rank as attacking pawn, target file
        this.capturedPawnPos = Position.at(to.file, from.rank);
    }
    
    execute(board: Board): void {
        // Remove captured pawn (not at destination!)
        board.removePiece(this.capturedPawnPos);
        
        // Move attacking pawn
        board.removePiece(this.from);
        board.placePiece(this.pawn, this.to);
        this.pawn.setPosition(this.to);
    }
    
    undo(board: Board): void {
        // Move pawn back
        board.removePiece(this.to);
        board.placePiece(this.pawn, this.from);
        this.pawn.setPosition(this.from);
        
        // Restore captured pawn
        board.placePiece(this.capturedPawn, this.capturedPawnPos);
    }
    
    getNotation(): string {
        return `${this.from.file}x${this.to.toAlgebraic()} e.p.`;
    }
    
    getMetadata(): MoveMetadata {
        return {
            piece: PieceType.PAWN,
            color: this.pawn.color,
            from: this.from,
            to: this.to,
            isCapture: true,
            isCheck: false,
            isCheckmate: false,
            timestamp: new Date(),
        };
    }
}
 
/**
 * PromotionCommand - Pawn transforms to another piece
 */
class PromotionCommand implements MoveCommand {
    private pawn: Piece;
    private promotedPiece: Piece;
    private from: Position;
    private to: Position;
    private capturedPiece: Piece | null;
    
    constructor(
        pawn: Piece,
        promoteTo: PieceType,
        from: Position,
        to: Position,
        capturedPiece: Piece | null
    ) {
        this.pawn = pawn;
        this.from = from;
        this.to = to;
        this.capturedPiece = capturedPiece;
        
        // Create the promoted piece
        this.promotedPiece = new Piece(promoteTo, pawn.color, to);
    }
    
    execute(board: Board): void {
        // Remove captured piece if any
        if (this.capturedPiece) {
            board.removePiece(this.to);
        }
        
        // Remove pawn
        board.removePiece(this.from);
        
        // Place promoted piece
        board.placePiece(this.promotedPiece, this.to);
    }
    
    undo(board: Board): void {
        // Remove promoted piece
        board.removePiece(this.to);
        
        // Restore pawn
        board.placePiece(this.pawn, this.from);
        
        // Restore captured piece if any
        if (this.capturedPiece) {
            board.placePiece(this.capturedPiece, this.to);
        }
    }
    
    getNotation(): string {
        const captureNotation = this.capturedPiece 
            ? `${this.from.file}x` 
            : '';
        const promotionSymbol = this.promotedPiece.getSymbol();
        return `${captureNotation}${this.to.toAlgebraic()}=${promotionSymbol}`;
    }
    
    getMetadata(): MoveMetadata {
        return {
            piece: PieceType.PAWN,
            color: this.pawn.color,
            from: this.from,
            to: this.to,
            isCapture: this.capturedPiece !== null,
            isCheck: false,
            isCheckmate: false,
            timestamp: new Date(),
        };
    }
}

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

/**
 * Game as Command Invoker
 * 
 * The Game maintains a stack of executed commands
 * and a stack of undone commands (for redo).
 */
class Game {
    private commandHistory: MoveCommand[] = [];
    private redoStack: MoveCommand[] = [];
    
    /**
     * Execute a move command
     */
    private executeCommand(command: MoveCommand): void {
        command.execute(this.board);
        this.commandHistory.push(command);
        
        // Clear redo stack (new branch)
        this.redoStack = [];
    }
    
    /**
     * Undo the last move
     */
    public undo(): boolean {
        if (this.commandHistory.length === 0) {
            return false;
        }
        
        const command = this.commandHistory.pop()!;
        command.undo(this.board);
        this.redoStack.push(command);
        
        this.revertTurn();
        this.updateGameStatus();
        
        return true;
    }
    
    /**
     * Redo the last undone move
     */
    public redo(): boolean {
        if (this.redoStack.length === 0) {
            return false;
        }
        
        const command = this.redoStack.pop()!;
        command.execute(this.board);
        this.commandHistory.push(command);
        
        this.switchTurn();
        this.updateGameStatus();
        
        return true;
    }
    
    /**
     * Get move history as notations
     */
    public getMoveHistory(): string[] {
        return this.commandHistory.map(cmd => cmd.getNotation());
    }
    
    /**
     * Export game as PGN (Portable Game Notation)
     */
    public toPGN(): string {
        const moves = this.commandHistory.map((cmd, idx) => {
            const moveNum = Math.floor(idx / 2) + 1;
            const notation = cmd.getNotation();
            
            if (idx % 2 === 0) {
                // White's move
                return `${moveNum}. ${notation}`;
            } else {
                // Black's move
                return notation;
            }
        });
        
        return moves.join(' ');
    }
}

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

/**
 * GameSnapshot - The Memento
 * 
 * Captures complete game state at a point in time.
 * Immutable once created.
 */
class GameSnapshot {
    // Private state—only Game can access contents
    private readonly boardState: BoardState;
    private readonly currentPlayerIndex: number;
    private readonly status: GameStatus;
    private readonly castlingRights: CastlingRights;
    private readonly enPassantTarget: Position | null;
    private readonly halfMoveClock: number;
    private readonly fullMoveNumber: number;
    private readonly moveHistory: MoveRecord[];
    private readonly timestamp: Date;
    
    constructor(
        boardState: BoardState,
        currentPlayerIndex: number,
        status: GameStatus,
        castlingRights: CastlingRights,
        enPassantTarget: Position | null,
        halfMoveClock: number,
        fullMoveNumber: number,
        moveHistory: MoveRecord[]
    ) {
        // Deep copy everything to ensure immutability
        this.boardState = JSON.parse(JSON.stringify(boardState));
        this.currentPlayerIndex = currentPlayerIndex;
        this.status = status;
        this.castlingRights = { ...castlingRights };
        this.enPassantTarget = enPassantTarget;
        this.halfMoveClock = halfMoveClock;
        this.fullMoveNumber = fullMoveNumber;
        this.moveHistory = [...moveHistory];
        this.timestamp = new Date();
    }
    
    // Getters for restoration (accessed by Game)
    public getBoardState(): BoardState { return this.boardState; }
    public getCurrentPlayerIndex(): number { return this.currentPlayerIndex; }
    public getStatus(): GameStatus { return this.status; }
    public getCastlingRights(): CastlingRights { return this.castlingRights; }
    public getEnPassantTarget(): Position | null { return this.enPassantTarget; }
    public getHalfMoveClock(): number { return this.halfMoveClock; }
    public getFullMoveNumber(): number { return this.fullMoveNumber; }
    public getMoveHistory(): MoveRecord[] { return this.moveHistory; }
    public getTimestamp(): Date { return this.timestamp; }
    
    /**
     * Serialize to FEN (Forsyth-Edwards Notation) for portability
     * FEN is a standard string format for chess positions
     */
    public toFEN(): string {
        // [position] [active] [castling] [en passant] [halfmove] [fullmove]
        const position = this.boardStateToFENPosition();
        const active = this.currentPlayerIndex === 0 ? 'w' : 'b';
        const castling = this.castlingToFEN();
        const enPassant = this.enPassantTarget?.toAlgebraic() ?? '-';
        
        return `${position} ${active} ${castling} ${enPassant} ${this.halfMoveClock} ${this.fullMoveNumber}`;
    }
    
    private boardStateToFENPosition(): string {
        // Implementation of FEN position encoding
        // Returns format like: rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR
        // ...
    }
    
    private castlingToFEN(): string {
        let result = '';
        if (this.castlingRights.whiteKingside) result += 'K';
        if (this.castlingRights.whiteQueenside) result += 'Q';
        if (this.castlingRights.blackKingside) result += 'k';
        if (this.castlingRights.blackQueenside) result += 'q';
        return result || '-';
    }
}
 
interface BoardState {
    pieces: Array<{
        type: PieceType;
        color: Color;
        position: string;  // Algebraic notation
        hasMoved: boolean;
    }>;
}
 
interface CastlingRights {
    whiteKingside: boolean;
    whiteQueenside: boolean;
    blackKingside: boolean;
    blackQueenside: boolean;
}
 
interface MoveRecord {
    notation: string;
    piece: PieceType;
    from: string;
    to: string;
}

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

/**
 * Game with Memento support
 */
class Game {
    /**
     * Create a snapshot of current state
     */
    public createSnapshot(): GameSnapshot {
        return new GameSnapshot(
            this.getBoardState(),
            this.currentPlayerIndex,
            this.status,
            this.getCastlingRights(),
            this.enPassantTarget,
            this.halfMoveClock,
            this.moveNumber,
            this.getMoveRecords()
        );
    }
    
    /**
     * Restore state from a snapshot
     */
    public restoreFromSnapshot(snapshot: GameSnapshot): void {
        // Restore board
        this.board = new Board();
        for (const pieceData of snapshot.getBoardState().pieces) {
            const piece = new Piece(
                pieceData.type,
                pieceData.color,
                Position.fromAlgebraic(pieceData.position)
            );
            if (pieceData.hasMoved) piece.markAsMoved();
            this.board.placePiece(piece, piece.getPosition());
        }
        
        // Restore game state
        this.currentPlayerIndex = snapshot.getCurrentPlayerIndex();
        this.status = snapshot.getStatus();
        this.castlingRights = snapshot.getCastlingRights();
        this.enPassantTarget = snapshot.getEnPassantTarget();
        this.halfMoveClock = snapshot.getHalfMoveClock();
        this.moveNumber = snapshot.getFullMoveNumber();
        
        // Clear command history (we're at a new state)
        this.commandHistory = [];
        this.redoStack = [];
        
        this.eventEmitter.emit({
            type: 'GAME_RESTORED',
            timestamp: new Date(),
            gameId: this.id,
            fromFEN: snapshot.toFEN(),
        });
    }
    
    /**
     * Load from FEN string
     */
    public static fromFEN(fen: string, players: [Player, Player]): Game {
        const game = new Game(generateId(), players[0], players[1]);
        const snapshot = GameSnapshot.fromFEN(fen);
        game.restoreFromSnapshot(snapshot);
        return game;
    }
    
    /**
     * Get current position as FEN
     */
    public toFEN(): string {
        return this.createSnapshot().toFEN();
    }
    
    private getBoardState(): BoardState {
        const pieces: BoardState['pieces'] = [];
        
        for (const piece of this.board.getAllPieces()) {
            pieces.push({
                type: piece.type,
                color: piece.color,
                position: piece.getPosition().toAlgebraic(),
                hasMoved: piece.hasBeenMoved(),
            });
        }
        
        return { pieces };
    }
    
    private getCastlingRights(): CastlingRights {
        return {
            whiteKingside: this.canCastleKingside(Color.WHITE),
            whiteQueenside: this.canCastleQueenside(Color.WHITE),
            blackKingside: this.canCastleKingside(Color.BLACK),
            blackQueenside: this.canCastleQueenside(Color.BLACK),
        };
    }
}

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

/**
 * Example: Making a move with all patterns
 */
class Game {
    public makeMove(from: Position, to: Position, promoteTo?: PieceType): MoveResult {
        // 1. Get piece and validate ownership
        const piece = this.board.getPieceAt(from);
        if (!piece || piece.color !== this.getCurrentColor()) {
            return MoveResult.error('Invalid piece');
        }
        
        // 2. Use STRATEGY to get possible moves
        const possibleMoves = piece.getPossibleMoves(this.board);
        
        // 3. Validate legality (not in check after move)
        const legalMoves = possibleMoves.filter(pos => 
            !this.wouldLeaveKingInCheck(piece, from, pos)
        );
        
        if (!legalMoves.some(pos => pos.equals(to))) {
            return MoveResult.error('Illegal move');
        }
        
        // 4. Create appropriate COMMAND
        const command = this.createMoveCommand(piece, from, to, promoteTo);
        
        // 5. Execute command
        this.executeCommand(command);
        
        // 6. Update turn and state
        this.switchTurn();
        this.updateGameStatus();
        
        return MoveResult.success(command.getMetadata());
    }
    
    private createMoveCommand(
        piece: Piece,
        from: Position,
        to: Position,
        promoteTo?: PieceType
    ): MoveCommand {
        const targetPiece = this.board.getPieceAt(to);
        
        // Determine move type and create appropriate command
        
        // Castling
        if (piece.type === PieceType.KING && Math.abs(to.getFileIndex() - from.getFileIndex()) === 2) {
            return this.createCastlingCommand(piece, from, to);
        }
        
        // En passant
        if (piece.type === PieceType.PAWN && from.file !== to.file && !targetPiece) {
            return this.createEnPassantCommand(piece as Pawn, from, to);
        }
        
        // Promotion
        if (piece.type === PieceType.PAWN && this.isPromotionRank(to, piece.color)) {
            return new PromotionCommand(
                piece, 
                promoteTo ?? PieceType.QUEEN, 
                from, 
                to, 
                targetPiece
            );
        }
        
        // Capture
        if (targetPiece) {
            return new CaptureCommand(piece, from, to, targetPiece);
        }
        
        // Normal move
        return new NormalMoveCommand(piece, from, to);
    }
    
    /**
     * Save game state using MEMENTO
     */
    public save(): GameSnapshot {
        return this.createSnapshot();
    }
    
    /**
     * Load game state using MEMENTO
     */
    public load(snapshot: GameSnapshot): void {
        this.restoreFromSnapshot(snapshot);
    }
}