ddd-team1 0.0.6 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-team1",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "bin": {
     "ddd-team1": "./src/infrastructure/tui/index.tsx"

package/src/domain/value-objects/Board.ts

@@ -1,56 +1,56 @@
 import type { StandardAlgebraicNotationMove } from "./StandardAlgebraicNotationMove.ts";
-import { Piece } from "./Piece.ts";
 import { Position } from "./Position.ts";
 import { ValueObject } from "../shared";
-import { Rook } from "./pieces/Rook.ts";
-import type { PieceV2 } from "./PieceV2.ts";
+import { Piece } from "./Piece.ts";
+import { Rook, Knight, Bishop, King, Queen, Pawn } from "./pieces/index.ts";
+
 
-type BoardState = (Piece | PieceV2 | null)[][];
+type BoardState = (Piece | null)[][];
 
 export class Board extends ValueObject {
   static initialBoardState: BoardState = [
     [
       new Rook("white"),
-      Piece.WhiteKnight,
-      Piece.WhiteBishop,
-      Piece.WhiteQueen,
-      Piece.WhiteKing,
-      Piece.WhiteBishop,
-      Piece.WhiteKnight,
+      new Knight("white"),
+      new Bishop("white"),
+      new Queen("white"),
+      new King("white"),
+      new Bishop("white"),
+      new Knight("white"),
       new Rook("white"),
     ],
     [
-      Piece.WhitePawn,
-      Piece.WhitePawn,
-      Piece.WhitePawn,
-      Piece.WhitePawn,
-      Piece.WhitePawn,
-      Piece.WhitePawn,
-      Piece.WhitePawn,
-      Piece.WhitePawn,
+      new Pawn("white"),
+      new Pawn("white"),
+      new Pawn("white"),
+      new Pawn("white"),
+      new Pawn("white"),
+      new Pawn("white"),
+      new Pawn("white"),
+      new Pawn("white"),
     ],
     [null, null, null, null, null, null, null, null],
     [null, null, null, null, null, null, null, null],
     [null, null, null, null, null, null, null, null],
     [null, null, null, null, null, null, null, null],
     [
-      Piece.BlackPawn,
-      Piece.BlackPawn,
-      Piece.BlackPawn,
-      Piece.BlackPawn,
-      Piece.BlackPawn,
-      Piece.BlackPawn,
-      Piece.BlackPawn,
-      Piece.BlackPawn,
+      new Pawn("black"),
+      new Pawn("black"),
+      new Pawn("black"),
+      new Pawn("black"),
+      new Pawn("black"),
+      new Pawn("black"),
+      new Pawn("black"),
+      new Pawn("black"),
     ],
     [
       new Rook("black"),
-      Piece.BlackKnight,
-      Piece.BlackBishop,
-      Piece.BlackQueen,
-      Piece.BlackKing,
-      Piece.BlackBishop,
-      Piece.BlackKnight,
+      new Knight("black"),
+      new Bishop("black"),
+      new Queen("black"),
+      new King("black"),
+      new Bishop("black"),
+      new Knight("black"),
       new Rook("black"),
     ],
   ];
@@ -110,55 +110,7 @@ export class Board extends ValueObject {
     if (capturedPiece?.color == this.color) {
       throw new Error("You cannot capture yourself");
     }
-    if (move.piece instanceof Piece) {
-      if (move.piece?.type === "pawn" && this.color === "white") {
-        if (capturedPiece !== null) {
-          if (position.file > 0) rulesToCheck.push([position.offset(-1, -1)]);
-          if (position.file < 7) rulesToCheck.push([position.offset(1, -1)]);
-        } else {
-          let forwardMoves = [position.offset(0, -1)];
-          if (position.rank === 3) {
-            forwardMoves.push(position.offset(0, -2));
-          }
-          rulesToCheck.push(forwardMoves);
-        }
-      }
-
-      if (move.piece?.type === "pawn" && this.color === "black") {
-        if (capturedPiece !== null) {
-          if (position.file > 0) rulesToCheck.push([position.offset(-1, 1)]);
-          if (position.file < 7) rulesToCheck.push([position.offset(1, 1)]);
-        } else {
-          let forwardMoves = [position.offset(0, 1)];
-          if (position.rank === 4) {
-            forwardMoves.push(position.offset(0, 2));
-          }
-          rulesToCheck.push(forwardMoves);
-        }
-      }
-
-      if (move.piece?.type === "bishop") {
-        rulesToCheck = position.diagonalMask;
-      }
-
-      if (move.piece?.type === "knight") {
-        rulesToCheck = position.jumpMask;
-      }
-
-      if (move.piece?.type === "queen") {
-        rulesToCheck = position.straightMask.concat(position.diagonalMask);
-      }
-
-      if (move.piece?.type === "king") {
-        rulesToCheck = position.straightMask
-          .slice(0, 1)
-          .concat(position.diagonalMask.slice(0, 1));
-      }
-    } else {
-      if (move.piece instanceof Rook) {
-        rulesToCheck = move.piece.getRulesToCheck(position);
-      }
-    }
+    rulesToCheck = move.piece?.getRulesToCheck(position, capturedPiece) ?? [];
 
     /*
      * checks each position in the rules to see if the piece at that position matches the move's piece, and returns

package/src/domain/value-objects/Piece.ts

@@ -1,91 +1,85 @@
-import { ValueObject } from '../shared';
+import { ValueObject } from "../shared";
+import { Position } from "./Position.ts";
 
-export type PieceColor = 'white' | 'black';
-export type PieceType = 'king' | 'queen' | 'rook' | 'bishop' | 'knight' | 'pawn';
+export type PieceColor = "white" | "black";
+export type PieceType =
+  | "king"
+  | "queen"
+  | "rook"
+  | "bishop"
+  | "knight"
+  | "pawn";
 
 const ICONS: Record<PieceColor, Record<PieceType, string>> = {
-  black: { king: '♔', queen: '♕', rook: '♖', bishop: '♗', knight: '♘', pawn: '♙' },
-  white: { king: '♚', queen: '♛', rook: '♜', bishop: '♝', knight: '♞', pawn: '♟' },
+  black: {
+    king: "♔",
+    queen: "♕",
+    rook: "♖",
+    bishop: "♗",
+    knight: "♘",
+    pawn: "♙",
+  },
+  white: {
+    king: "♚",
+    queen: "♛",
+    rook: "♜",
+    bishop: "♝",
+    knight: "♞",
+    pawn: "♟",
+  },
 };
 
 const PIECE_LETTER: Record<string, PieceType> = {
-  K: 'king',
-  Q: 'queen',
-  R: 'rook',
-  B: 'bishop',
-  N: 'knight',
-  '': 'pawn',
+  K: "king",
+  Q: "queen",
+  R: "rook",
+  B: "bishop",
+  N: "knight",
+  "": "pawn",
 };
 
 const LETTER_PIECE: Record<PieceType, string> = {
-  king: 'K',
-  queen: 'Q',
-  rook: 'R',
-  bishop: 'B',
-  knight: 'N',
-  pawn: '',
-}
+  king: "K",
+  queen: "Q",
+  rook: "R",
+  bishop: "B",
+  knight: "N",
+  pawn: "",
+};
 
-export class Piece extends ValueObject {
-  private constructor(
-    public readonly color: PieceColor,
-    public readonly type: PieceType,
-  ) {
-    super();
-  }
+export abstract class Piece extends ValueObject {
+  private static registry = new Map<PieceType, new (color: PieceColor) => Piece>();
 
-  get icon(): string {
-    return ICONS[this.color][this.type];
+  static register(type: PieceType, constructor: new (color: PieceColor) => Piece) {
+    this.registry.set(type, constructor);
   }
 
-  override toString(): string {
-    return `${this.icon} (${this.color} ${this.type})`;
+  constructor(public readonly color: PieceColor) {
+    super();
   }
 
-  toIcon(): string {
-    return this.icon;
-  }
+  abstract readonly icon: string;
+  abstract readonly char: string;
+  abstract getRulesToCheck(position: Position, getCapturedPiece?: any): Position[][];
 
-  toChar(): string {
-    return LETTER_PIECE[this.type];
+  override toString(): string {
+    return `${this.icon} (${this.color} ${this.constructor.name})`;
   }
 
   protected getAtomicValues(): any[] {
-    return [this.color, this.type];
+    return [this.color, this.constructor.name];
   }
 
-  static fromIcon(icon: string): Piece | null {
-    for (const color in ICONS) {
-      for (const type in ICONS[color as PieceColor]) {
-        if (ICONS[color as PieceColor][type as PieceType] === icon) {
-          return new Piece(color as PieceColor, type as PieceType);
-        }
-      }
-    }
-    return null;
-  }
-
-  static fromLetter(letter: string, color: 'white' | 'black'): Piece | null {
+  static fromLetter(letter: string, color: "white" | "black"): Piece | null {
     const pieceType = PIECE_LETTER[letter.toUpperCase()];
     if (!pieceType) {
       return null;
     }
-    return new Piece(color, pieceType);
-  }
-
-  // White pieces
-  static readonly WhiteKing = new Piece('white', 'king');
-  static readonly WhiteQueen = new Piece('white', 'queen');
-  static readonly WhiteRook = new Piece('white', 'rook');
-  static readonly WhiteBishop = new Piece('white', 'bishop');
-  static readonly WhiteKnight = new Piece('white', 'knight');
-  static readonly WhitePawn = new Piece('white', 'pawn');
+    const PieceConstructor = this.registry.get(pieceType);
+    if (!PieceConstructor) {
+      throw new Error(`Piece type ${pieceType} not registered`);
+    }
 
-  // Black pieces
-  static readonly BlackKing = new Piece('black', 'king');
-  static readonly BlackQueen = new Piece('black', 'queen');
-  static readonly BlackRook = new Piece('black', 'rook');
-  static readonly BlackBishop = new Piece('black', 'bishop');
-  static readonly BlackKnight = new Piece('black', 'knight');
-  static readonly BlackPawn = new Piece('black', 'pawn');
+    return new PieceConstructor(color);
+  }
 }

package/src/domain/value-objects/StandardAlgebraicNotationMove.ts

@@ -1,7 +1,6 @@
-import { Piece, type PieceType } from "./Piece.ts";
 import { Position } from "./Position.ts";
 import { ValueObject } from "../shared";
-import type { PieceV2 } from "./PieceV2.ts";
+import { Piece } from "./Piece.ts";
 import { Rook } from "./pieces/Rook.ts";
 
 const SAN_REGEX =
@@ -24,7 +23,7 @@ export class StandardAlgebraicNotationMove extends ValueObject {
   private constructor(
     public readonly turn: number,
     public readonly destination: Position | null,
-    public readonly piece: Piece | PieceV2 | null,
+    public readonly piece: Piece | null,
     public readonly isCapture: boolean,
     public readonly fromFile: number | null,
     public readonly fromRank: number | null,
@@ -65,10 +64,8 @@ export class StandardAlgebraicNotationMove extends ValueObject {
     }
 
     const destination = Position.fromAlgebraicNotation(g.toFile! + g.toRank!);
-    let piece: Piece | PieceV2 | null = Piece.fromLetter(g.piece ?? "", color);
-    if (g.piece == "R") {
-      piece = new Rook(color);
-    }
+    let piece: Piece | null = Piece.fromLetter(g.piece ?? "", color);
+
     const isCapture = g.capture === "x";
 
     // Disambiguation: fromFile/fromRank only count when toFile is also present
@@ -91,6 +88,7 @@ export class StandardAlgebraicNotationMove extends ValueObject {
     const promotion = g.promotion
       ? Piece.fromLetter(g.promotion!, color)
       : null;
+
     const check = (g.check as "+" | "#") ?? null;
 
     return new StandardAlgebraicNotationMove(
@@ -116,7 +114,7 @@ export class StandardAlgebraicNotationMove extends ValueObject {
     }
 
     if (this.piece) {
-      result += this.piece.toChar();
+      result += this.piece.char;
     }
 
     if (this.fromFile !== null) {
@@ -134,7 +132,7 @@ export class StandardAlgebraicNotationMove extends ValueObject {
     result += this.destination!.toString();
 
     if (this.promotion) {
-      result += `=${this.promotion.toChar()}`;
+      result += `=${this.promotion.char}`;
     }
 
     if (this.check) {

package/src/domain/value-objects/pieces/Bishop.ts

@@ -0,0 +1,31 @@
+import { Piece, type PieceColor } from "../Piece.ts";
+import { Position } from "../Position.ts";
+
+export class Bishop extends Piece {
+  constructor(color: PieceColor) {
+    super(color);
+  }
+
+  get icon(): string {
+    if (this.color === "white") {
+      return "♝";
+    }
+    return "♗";
+  }
+
+  get char(): string {
+    return "B";
+  }
+
+  override toString(): string {
+    return `${this.icon} (${this.color} Bishop)`;
+  }
+
+  getRulesToCheck(position: Position) {
+    return position.diagonalMask;
+  }
+}
+
+Piece.register("bishop", Bishop);
+
+

package/src/domain/value-objects/pieces/King.ts

@@ -0,0 +1,33 @@
+import { Piece, type PieceColor } from "../Piece.ts";
+import { Position } from "../Position.ts";
+
+export class King extends Piece {
+  constructor(color: PieceColor) {
+    super(color);
+  }
+
+  get icon(): string {
+    if (this.color === "white") {
+      return "♚";
+    }
+    return "♔";
+  }
+
+  get char(): string {
+    return "K";
+  }
+
+  override toString(): string {
+    return `${this.icon} (${this.color} King)`;
+  }
+
+  getRulesToCheck(position: Position) {
+    return position.straightMask
+      .slice(0, 1)
+      .concat(position.diagonalMask.slice(0, 1));
+  }
+}
+
+Piece.register("king", King);
+
+

package/src/domain/value-objects/pieces/Knight.ts

@@ -0,0 +1,31 @@
+import { Piece, type PieceColor } from "../Piece.ts";
+import { Position } from "../Position.ts";
+
+export class Knight extends Piece {
+  constructor(color: PieceColor) {
+    super(color);
+  }
+
+  get icon(): string {
+    if (this.color === "white") {
+      return "♞";
+    }
+    return "♘";
+  }
+
+  get char(): string {
+    return "N";
+  }
+
+  override toString(): string {
+    return `${this.icon} (${this.color} Knight)`;
+  }
+
+  getRulesToCheck(position: Position) {
+    return position.jumpMask;
+  }
+}
+
+Piece.register("knight", Knight);
+
+

package/src/domain/value-objects/pieces/Pawn.ts

@@ -0,0 +1,53 @@
+import { Piece, type PieceColor } from "../Piece.ts";
+import { Position } from "../Position.ts";
+
+export class Pawn extends Piece {
+  constructor(color: PieceColor) {
+    super(color);
+  }
+
+  get icon(): string {
+    if (this.color === "white") {
+      return "♟";
+    }
+    return "♙";
+  }
+
+  get char(): string {
+    return "";
+  }
+
+  override toString(): string {
+    return `${this.icon} (${this.color} Pawn)`;
+  }
+
+  getRulesToCheck(position: Position, capturedPiece: any = null) {
+    let rulesToCheck: Position[][] = [];
+
+    const colorRules = {
+        "white": {
+            direction: -1,
+            rank: 3
+        },
+        "black": {
+            direction: 1,
+            rank: 4
+        }
+    }
+
+    if (capturedPiece !== null) {
+      if (position.file > 0) rulesToCheck.push([position.offset(-1, colorRules[this.color].direction)]);
+      if (position.file < 7) rulesToCheck.push([position.offset(1, colorRules[this.color].direction)]);
+      } else {
+        let forwardMoves = [position.offset(0, colorRules[this.color].direction)];
+        if (position.rank === colorRules[this.color].rank) {
+          forwardMoves.push(position.offset(0, 2 * colorRules[this.color].direction));
+        }
+        rulesToCheck.push(forwardMoves);
+      }
+    return rulesToCheck;
+  }
+}
+
+Piece.register("pawn", Pawn);
+

package/src/domain/value-objects/pieces/Queen.ts

@@ -0,0 +1,29 @@
+import { Piece, type PieceColor } from "../Piece.ts";
+import { Position } from "../Position.ts";
+
+export class Queen extends Piece {
+  constructor(color: PieceColor) {
+    super(color);
+  }
+
+  get icon(): string {
+    if (this.color === "white") {
+      return "♛";
+    }
+    return "♕";
+  }
+
+  get char(): string {
+    return "Q";
+  }
+
+  override toString(): string {
+    return `${this.icon} (${this.color} Queen)`;
+  }
+
+  getRulesToCheck(position: Position) {
+    return position.straightMask.concat(position.diagonalMask);
+  }
+}
+
+Piece.register("queen", Queen);

package/src/domain/value-objects/pieces/Rook.ts

@@ -1,7 +1,7 @@
-import { PieceV2, type PieceColor } from "../PieceV2";
+import { Piece, type PieceColor } from "../Piece.ts";
 import { Position } from "../Position.ts";
 
-export class Rook extends PieceV2 {
+export class Rook extends Piece {
   constructor(color: PieceColor) {
     super(color);
   }
@@ -17,10 +17,6 @@ export class Rook extends PieceV2 {
     return "R";
   }
 
-  toChar(): string {
-    return "R";
-  }
-
   override toString(): string {
     return `${this.icon} (${this.color} Rook)`;
   }
@@ -29,3 +25,6 @@ export class Rook extends PieceV2 {
     return position.straightMask;
   }
 }
+
+Piece.register("rook", Rook);
+

package/src/domain/value-objects/pieces/index.ts

@@ -0,0 +1,7 @@
+export { Bishop } from "./Bishop.ts";
+export { King } from "./King.ts";
+export { Knight } from "./Knight.ts";
+export { Pawn } from "./Pawn.ts";
+export { Queen } from "./Queen.ts";
+export { Rook } from "./Rook.ts";
+

package/src/domain/value-objects/PieceV2.ts

@@ -1,79 +0,0 @@
-import { ValueObject } from "../shared";
-import { Rook } from "./pieces/Rook";
-
-export type PieceColor = "white" | "black";
-export type PieceType =
-  | "king"
-  | "queen"
-  | "rook"
-  | "bishop"
-  | "knight"
-  | "pawn";
-
-const ICONS: Record<PieceColor, Record<PieceType, string>> = {
-  black: {
-    king: "♔",
-    queen: "♕",
-    rook: "♖",
-    bishop: "♗",
-    knight: "♘",
-    pawn: "♙",
-  },
-  white: {
-    king: "♚",
-    queen: "♛",
-    rook: "♜",
-    bishop: "♝",
-    knight: "♞",
-    pawn: "♟",
-  },
-};
-
-const PIECE_LETTER: Record<string, PieceType> = {
-  K: "king",
-  Q: "queen",
-  R: "rook",
-  B: "bishop",
-  N: "knight",
-  "": "pawn",
-};
-
-const LETTER_PIECE: Record<PieceType, string> = {
-  king: "K",
-  queen: "Q",
-  rook: "R",
-  bishop: "B",
-  knight: "N",
-  pawn: "",
-};
-
-export abstract class PieceV2 extends ValueObject {
-  constructor(public readonly color: PieceColor) {
-    super();
-  }
-
-  abstract readonly icon: string;
-  abstract readonly char: string;
-  abstract toChar(): string;
-
-  override toString(): string {
-    return `${this.icon} (${this.color} ${this.constructor.name})`;
-  }
-
-  protected getAtomicValues(): any[] {
-    return [this.color, this.constructor.name];
-  }
-
-  static fromLetter(letter: string, color: "white" | "black"): PieceV2 | null {
-    const pieceType = PIECE_LETTER[letter.toUpperCase()];
-    if (!pieceType) {
-      return null;
-    }
-    switch (pieceType) {
-      case "rook":
-        return new Rook(color);
-      default:
-        throw new Error(`Unknown letter ${letter}`);
-    }
-  }
-}