schess 1.0.0

package/src/ui/GameScreen.ts

@@ -0,0 +1,183 @@
+import chalk from 'chalk';
+import { ChessGame } from '../game/ChessGame.js';
+import type { GameState, PlayerColor, Square, Position } from '../game/types.js';
+import { renderBoard, renderStatus, renderControls, positionToSquare, squareToPosition } from './Board.js';
+import { createKeyboardHandler, type KeyAction } from './Keyboard.js';
+
+export interface NetworkCallbacks {
+  onMove: (from: Square, to: Square) => void;
+  onResign: () => void;
+}
+
+export class GameScreen {
+  private game: ChessGame;
+  private state: GameState;
+  private keyboard: ReturnType<typeof createKeyboardHandler>;
+  private networkCallbacks: NetworkCallbacks;
+
+  constructor(playerColor: PlayerColor, callbacks: NetworkCallbacks) {
+    this.game = new ChessGame();
+    this.networkCallbacks = callbacks;
+
+    // Initialize cursor at center
+    const startRow = playerColor === 'w' ? 6 : 1; // Start near own pieces
+    this.state = {
+      cursor: { row: startRow, col: 4 },
+      selectedSquare: null,
+      validMoves: [],
+      lastMove: null,
+      isMyTurn: playerColor === 'w', // White goes first
+      playerColor,
+      gameOver: false,
+      gameOverReason: null,
+    };
+
+    this.keyboard = createKeyboardHandler(this.handleKey.bind(this));
+  }
+
+  private handleKey(action: KeyAction): void {
+    if (this.state.gameOver) {
+      if (action === 'quit' || action === 'enter') {
+        this.stop();
+        process.exit(0);
+      }
+      return;
+    }
+
+    switch (action) {
+      case 'up':
+        this.moveCursor(-1, 0);
+        break;
+      case 'down':
+        this.moveCursor(1, 0);
+        break;
+      case 'left':
+        this.moveCursor(0, -1);
+        break;
+      case 'right':
+        this.moveCursor(0, 1);
+        break;
+      case 'enter':
+        this.handleSelect();
+        break;
+      case 'escape':
+        this.cancelSelection();
+        break;
+      case 'quit':
+        this.networkCallbacks.onResign();
+        this.stop();
+        console.log(chalk.yellow('\nYou resigned. Game over.'));
+        process.exit(0);
+        break;
+    }
+
+    this.render();
+  }
+
+  private moveCursor(dRow: number, dCol: number): void {
+    // Adjust for board orientation
+    const actualDRow = this.state.playerColor === 'w' ? dRow : -dRow;
+    const actualDCol = this.state.playerColor === 'w' ? dCol : -dCol;
+
+    const newRow = Math.max(0, Math.min(7, this.state.cursor.row + actualDRow));
+    const newCol = Math.max(0, Math.min(7, this.state.cursor.col + actualDCol));
+    this.state.cursor = { row: newRow, col: newCol };
+  }
+
+  private handleSelect(): void {
+    if (!this.state.isMyTurn) return;
+
+    const cursorSquare = positionToSquare(this.state.cursor);
+
+    if (this.state.selectedSquare) {
+      // Try to make a move
+      if (this.state.validMoves.includes(cursorSquare)) {
+        const move = this.game.makeMove(this.state.selectedSquare, cursorSquare);
+        if (move) {
+          this.state.lastMove = { from: this.state.selectedSquare, to: cursorSquare };
+          this.networkCallbacks.onMove(this.state.selectedSquare, cursorSquare);
+          this.state.isMyTurn = false;
+
+          // Check game over
+          if (this.game.isGameOver()) {
+            this.state.gameOver = true;
+            this.state.gameOverReason = this.game.getGameOverReason();
+          }
+        }
+        this.cancelSelection();
+      } else {
+        // Clicked on a different square - check if it's own piece
+        const piece = this.game.getPiece(cursorSquare);
+        if (piece && piece.color === this.state.playerColor) {
+          this.selectPiece(cursorSquare);
+        } else {
+          this.cancelSelection();
+        }
+      }
+    } else {
+      // Select a piece
+      const piece = this.game.getPiece(cursorSquare);
+      if (piece && piece.color === this.state.playerColor) {
+        this.selectPiece(cursorSquare);
+      }
+    }
+  }
+
+  private selectPiece(square: Square): void {
+    this.state.selectedSquare = square;
+    this.state.validMoves = this.game.getValidMoves(square);
+  }
+
+  private cancelSelection(): void {
+    this.state.selectedSquare = null;
+    this.state.validMoves = [];
+  }
+
+  // Called when opponent makes a move
+  receiveMove(from: Square, to: Square): void {
+    this.game.loadMove(from, to);
+    this.state.lastMove = { from, to };
+    this.state.isMyTurn = true;
+
+    // Check game over
+    if (this.game.isGameOver()) {
+      this.state.gameOver = true;
+      this.state.gameOverReason = this.game.getGameOverReason();
+    }
+
+    this.render();
+  }
+
+  // Called when opponent resigns
+  opponentResigned(): void {
+    this.state.gameOver = true;
+    this.state.gameOverReason = 'Opponent resigned';
+    this.render();
+  }
+
+  render(): void {
+    // Clear screen
+    console.clear();
+
+    // Title
+    console.log(chalk.bold.cyan('\n  ♔ SCHESS - Chess over LAN ♚\n'));
+
+    // Board
+    console.log(renderBoard(this.game, this.state));
+    console.log();
+
+    // Status
+    console.log(renderStatus(this.game, this.state));
+    console.log(renderControls());
+    console.log();
+  }
+
+  start(): void {
+    this.keyboard.start();
+    this.render();
+  }
+
+  stop(): void {
+    this.keyboard.stop();
+  }
+}

package/src/ui/Keyboard.ts

@@ -0,0 +1,57 @@
+import * as readline from 'readline';
+
+export type KeyAction = 'up' | 'down' | 'left' | 'right' | 'enter' | 'escape' | 'quit' | 'unknown';
+
+export interface KeyboardHandler {
+  onKey: (action: KeyAction) => void;
+  start: () => void;
+  stop: () => void;
+}
+
+export function createKeyboardHandler(onKey: (action: KeyAction) => void): KeyboardHandler {
+  let isRunning = false;
+
+  const handleKeypress = (_str: string, key: readline.Key): void => {
+    if (!isRunning) return;
+
+    let action: KeyAction = 'unknown';
+
+    if (key.name === 'up') action = 'up';
+    else if (key.name === 'down') action = 'down';
+    else if (key.name === 'left') action = 'left';
+    else if (key.name === 'right') action = 'right';
+    else if (key.name === 'return') action = 'enter';
+    else if (key.name === 'escape') action = 'escape';
+    else if (key.name === 'q' || (key.ctrl && key.name === 'c')) action = 'quit';
+
+    if (action !== 'unknown') {
+      onKey(action);
+    }
+  };
+
+  return {
+    onKey,
+    start: () => {
+      if (isRunning) return;
+      isRunning = true;
+
+      // Enable raw mode
+      if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('keypress', handleKeypress);
+      }
+    },
+    stop: () => {
+      if (!isRunning) return;
+      isRunning = false;
+
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('keypress', handleKeypress);
+        process.stdin.pause();
+      }
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}