shogiops 0.2.9 → 0.6.0

package/src/shogi.ts

@@ -1,20 +1,8 @@
 import { Result } from '@badrap/result';
-import {
-  Rules,
-  Color,
-  COLORS,
-  Square,
-  Move,
-  isDrop,
-  Piece,
-  Outcome,
-  POCKET_ROLES,
-  PROMOTABLE_ROLES,
-  PocketRole,
-} from './types';
+import { Rules, Color, COLORS, Square, Move, isDrop, Piece, Outcome, Role } from './types';
 import { SquareSet } from './squareSet';
 import { Board } from './board';
-import { Setup, Material } from './setup';
+import { Setup } from './setup';
 import {
   bishopAttacks,
   rookAttacks,
@@ -29,12 +17,26 @@ import {
   horseAttacks,
   dragonAttacks,
 } from './attacks';
-import { opposite, defined, unpromote, promote } from './util';
+import { opposite, defined } from './util';
+import { Hands } from './hand';
+import {
+  allRoles,
+  backrank,
+  handRoles,
+  pieceCanPromote,
+  pieceInDeadZone,
+  promote,
+  promotionZone,
+  secondBackrank,
+  unpromote,
+} from './variantUtil';
 
 export enum IllegalSetup {
   Empty = 'ERR_EMPTY',
   OppositeCheck = 'ERR_OPPOSITE_CHECK',
   ImpossibleCheck = 'ERR_IMPOSSIBLE_CHECK',
+  InvalidPieces = 'ERR_INVALID_PIECE',
+  InvalidPiecesHand = 'ERR_INVALID_PIECE_IN_HAND',
   InvalidPiecesPromotionZone = 'ERR_PIECES_MUST_PROMOTE',
   Kings = 'ERR_KINGS',
   Variant = 'ERR_VARIANT',
@@ -72,7 +74,7 @@ export interface Context {
 
 export abstract class Position {
   board: Board;
-  pockets: Material;
+  hands: Hands;
   turn: Color;
   fullmoves: number;
   lastMove: Move | undefined;
@@ -82,9 +84,11 @@ export abstract class Position {
   // When subclassing:
   // - static default()
   // - static fromSetup()
+  // - static promotable
+  // - static handRoles
   // - Proper signature for clone()
 
-  abstract dropDests(role: PocketRole, ctx?: Context): SquareSet;
+  abstract dropDests(role: Role, ctx?: Context): SquareSet;
   abstract dests(square: Square, ctx?: Context): SquareSet;
   abstract isVariantEnd(): boolean;
   abstract variantOutcome(ctx?: Context): Outcome | undefined;
@@ -94,9 +98,12 @@ export abstract class Position {
     return attacksTo(square, attacker, this.board, occupied);
   }
 
-  protected playCaptureAt(square: Square, captured: Piece): void {
-    const unpromotedRole = unpromote(captured.role);
-    if (unpromotedRole !== 'king') this.pockets[opposite(captured.color)][unpromotedRole]++;
+  abstract numberOfFiles: number;
+  abstract numberOfRanks: number;
+
+  protected playCaptureAt(captured: Piece): void {
+    const unpromotedRole = unpromote(this.rules)(captured.role);
+    this.hands[opposite(captured.color)][unpromotedRole]++;
   }
 
   ctx(): Context {
@@ -137,7 +144,7 @@ export abstract class Position {
   clone(): Position {
     const pos = new (this as any).constructor();
     pos.board = this.board.clone();
-    pos.pockets = this.pockets.clone();
+    pos.hands = this.hands.clone();
     pos.turn = this.turn;
     pos.fullmoves = this.fullmoves;
     pos.lastMove = this.lastMove;
@@ -146,15 +153,17 @@ export abstract class Position {
 
   equalsIgnoreMoves(other: Position): boolean {
     return (
-      // this.rules === other.rules // variants
-      this.board.equals(other.board) && this.pockets.equals(other.pockets) && this.turn === other.turn
+      this.rules === other.rules &&
+      this.board.equals(other.board) &&
+      this.hands.equals(other.hands) &&
+      this.turn === other.turn
     );
   }
 
   toSetup(): Setup {
     return {
       board: this.board.clone(),
-      pockets: this.pockets.clone(),
+      hands: this.hands.clone(),
       turn: this.turn,
       fullmoves: Math.min(Math.max(this.fullmoves, 1), 9999),
     };
@@ -169,37 +178,24 @@ export abstract class Position {
     for (const square of this.board[this.turn]) {
       if (this.dests(square, ctx).nonEmpty()) return true;
     }
-    for (const prole of POCKET_ROLES) {
-      if (this.pockets[this.turn][prole] > 0 && this.dropDests(prole, ctx).nonEmpty()) return true;
+    for (const prole of handRoles(this.rules)) {
+      if (this.hands[this.turn][prole] > 0 && this.dropDests(prole, ctx).nonEmpty()) return true;
     }
     return false;
   }
 
   isLegal(move: Move, ctx?: Context): boolean {
     if (isDrop(move)) {
-      const role = move.role as PocketRole;
-      if (!defined(role) || this.pockets[this.turn][role] <= 0) return false;
+      const role = move.role;
+      if (!defined(role) || !handRoles(this.rules).includes(role) || this.hands[this.turn][role] <= 0) return false;
       return this.dropDests(role, ctx).has(move.to);
     } else {
-      const role = this.board.getRole(move.from);
-      if (!role) return false;
+      const piece = this.board.get(move.from);
+      if (!piece || !allRoles(this.rules).includes(piece.role)) return false;
 
-      // Checking whether this role can be promoted
-      if (move.promotion && !(PROMOTABLE_ROLES as ReadonlyArray<string>).includes(role)) return false;
-      // Checking whether piece is entering/leaving the promotion zone
-      if (
-        move.promotion &&
-        !(SquareSet.promotionZone(this.turn).has(move.to) || SquareSet.promotionZone(this.turn).has(move.from))
-      )
-        return false;
-      // Checking whether the promotion must be forced
-      if (
-        !move.promotion &&
-        defined(role) &&
-        (((role === 'pawn' || role === 'lance') && SquareSet.backrank(this.turn).has(move.to)) ||
-          (role === 'knight' && SquareSet.backrank2(this.turn).has(move.to)))
-      )
-        return false;
+      // Checking whether we can promote
+      if (move.promotion && !pieceCanPromote(this.rules)(piece, move.from, move.to)) return false;
+      if (!move.promotion && pieceInDeadZone(this.rules)(piece, move.to)) return false;
 
       const dests = this.dests(move.from, ctx);
       return dests.has(move.to);
@@ -227,7 +223,7 @@ export abstract class Position {
   }
 
   isImpasse(): boolean {
-    const allPiecesInPromotionZone = SquareSet.promotionZone(this.turn).intersect(this.board[this.turn]);
+    const allPiecesInPromotionZone = promotionZone(this.rules)(this.turn).intersect(this.board[this.turn]);
     const majorPiecesInPromotionZone = allPiecesInPromotionZone.intersect(
       this.board.bishop.union(this.board.rook).union(this.board.horse).union(this.board.dragon)
     );
@@ -237,8 +233,8 @@ export abstract class Position {
       allPiecesInPromotionZone.size() -
       1 +
       majorPiecesInPromotionZone.size() * 4 +
-      this.pockets[this.turn].count() +
-      (this.pockets[this.turn].bishop + this.pockets[this.turn].rook) * 4;
+      this.hands[this.turn].count() +
+      (this.hands[this.turn].bishop + this.hands[this.turn].rook) * 4;
 
     return (
       defined(king) &&
@@ -269,12 +265,12 @@ export abstract class Position {
     return d;
   }
 
-  allDropDests(ctx?: Context): Map<PocketRole, SquareSet> {
+  allDropDests(ctx?: Context): Map<Role, SquareSet> {
     ctx = ctx || this.ctx();
     const d = new Map();
     if (ctx.variantEnd) return d;
-    for (const prole of POCKET_ROLES) {
-      if (this.pockets[this.turn][prole] > 0) d.set(prole, this.dropDests(prole, ctx));
+    for (const prole of handRoles(this.rules)) {
+      if (this.hands[this.turn][prole] > 0) d.set(prole, this.dropDests(prole, ctx));
       else d.set(prole, SquareSet.empty());
     }
     return d;
@@ -289,21 +285,19 @@ export abstract class Position {
 
     if (isDrop(move)) {
       this.board.set(move.to, { role: move.role, color: turn });
-      this.pockets[turn][move.role]--;
+      this.hands[turn][move.role]--;
     } else {
       const piece = this.board.take(move.from);
       if (!piece) return;
       const role = piece.role;
       if (
-        (move.promotion && (PROMOTABLE_ROLES as ReadonlyArray<string>).includes(role)) ||
-        (role === 'knight' && SquareSet.backrank2(turn).has(move.to)) ||
-        ((role === 'pawn' || role === 'lance') && SquareSet.backrank(turn).has(move.to))
-      ) {
-        piece.role = promote(role);
-      }
+        (move.promotion && pieceCanPromote(this.rules)(piece, move.from, move.to)) ||
+        pieceInDeadZone(this.rules)(piece, move.to)
+      )
+        piece.role = promote(this.rules)(role);
 
       const capture = this.board.set(move.to, piece);
-      if (capture) this.playCaptureAt(move.to, capture);
+      if (capture) this.playCaptureAt(capture);
     }
   }
 }
@@ -313,10 +307,13 @@ export class Shogi extends Position {
     super(rules || 'shogi');
   }
 
+  numberOfRanks = 9;
+  numberOfFiles = 9;
+
   static default(): Shogi {
     const pos = new this();
     pos.board = Board.default();
-    pos.pockets = Material.empty();
+    pos.hands = Hands.empty();
     pos.turn = 'sente';
     pos.fullmoves = 1;
     return pos;
@@ -325,7 +322,7 @@ export class Shogi extends Position {
   static fromSetup(setup: Setup, strict = true): Result<Shogi, PositionError> {
     const pos = new this();
     pos.board = setup.board.clone();
-    pos.pockets = setup.pockets;
+    pos.hands = setup.hands;
     pos.turn = setup.turn;
     pos.fullmoves = setup.fullmoves;
     return pos.validate(strict).map(_ => pos);
@@ -336,6 +333,8 @@ export class Shogi extends Position {
   }
 
   protected validate(strict: boolean): Result<undefined, PositionError> {
+    if (this.board.numberOfRanks !== this.numberOfRanks || this.board.numberOfFiles !== this.numberOfFiles)
+      return Result.err(new PositionError(IllegalSetup.Empty));
     if (!strict) return Result.ok(undefined);
     if (this.board.occupied.isEmpty()) return Result.err(new PositionError(IllegalSetup.Empty));
     if (this.board.king.size() < 1) return Result.err(new PositionError(IllegalSetup.Kings));
@@ -344,15 +343,16 @@ export class Shogi extends Position {
     if (defined(otherKing) && this.kingAttackers(otherKing, this.turn, this.board.occupied).nonEmpty())
       return Result.err(new PositionError(IllegalSetup.OppositeCheck));
 
-    const b1 = this.board.pawn.union(this.board.lance);
+    for (const rn of this.hands.sente)
+      if (!handRoles(this.rules).includes(rn[0])) return Result.err(new PositionError(IllegalSetup.InvalidPiecesHand));
+    for (const rn of this.hands.gote)
+      if (!handRoles(this.rules).includes(rn[0])) return Result.err(new PositionError(IllegalSetup.InvalidPiecesHand));
 
-    if (
-      SquareSet.backrank('sente').intersect(b1.intersect(this.board['sente'])).nonEmpty() ||
-      SquareSet.backrank('gote').intersect(b1.intersect(this.board['gote'])).nonEmpty() ||
-      SquareSet.backrank2('sente').intersect(this.board.knight.intersect(this.board['sente'])).nonEmpty() ||
-      SquareSet.backrank2('gote').intersect(this.board.knight.intersect(this.board['gote'])).nonEmpty()
-    )
-      return Result.err(new PositionError(IllegalSetup.InvalidPiecesPromotionZone));
+    for (const sp of this.board) {
+      if (!allRoles(this.rules).includes(sp[1].role)) return Result.err(new PositionError(IllegalSetup.InvalidPieces));
+      if (pieceInDeadZone(this.rules)(sp[1], sp[0]))
+        return Result.err(new PositionError(IllegalSetup.InvalidPiecesPromotionZone));
+    }
 
     return this.validateCheckers();
   }
@@ -368,12 +368,12 @@ export class Shogi extends Position {
     return Result.ok(undefined);
   }
 
-  dropDests(role: PocketRole, ctx?: Context): SquareSet {
+  dropDests(role: Role, ctx?: Context): SquareSet {
     let mask = this.board.occupied.complement();
     ctx = ctx || this.ctx();
-    // Removing backranks, where no legal moves would be possible
-    if (role === 'pawn' || role === 'lance') mask = mask.diff(SquareSet.backrank(this.turn));
-    if (role === 'knight') mask = mask.diff(SquareSet.backrank2(this.turn));
+    // Removing backranks, where no legal drop would be possible
+    if (role === 'pawn' || role === 'lance' || role === 'knight') mask = mask.diff(backrank(this.rules)(this.turn));
+    if (role === 'knight') mask = mask.diff(secondBackrank(this.rules)(this.turn));
 
     // Checking for double pawns
     if (role === 'pawn') {
@@ -458,6 +458,6 @@ export class Shogi extends Position {
   }
 
   hasInsufficientMaterial(color: Color): boolean {
-    return this.board.occupied.intersect(this.board[color]).size() + this.pockets[color].count() < 2; // sente king, gote king and one other piece
+    return this.board.occupied.intersect(this.board[color]).size() + this.hands[color].count() < 2; // sente king, gote king and one other piece
   }
 }

package/src/squareSet.ts

@@ -1,4 +1,4 @@
-import { Square, Color } from './types';
+import { Square } from './types';
 
 function popcnt27(n: number): number {
   n = trimTo27(n);
@@ -68,23 +68,6 @@ export class SquareSet implements Iterable<Square> {
     return new SquareSet(0x00000101, 0, 0x04040000);
   }
 
-  static promotionZones(): SquareSet {
-    // backranks
-    return new SquareSet(0x07ffffff, 0, 0x07ffffff);
-  }
-
-  static promotionZone(color: Color): SquareSet {
-    return color === 'sente' ? new SquareSet(0, 0, 0x07ffffff) : new SquareSet(0x07ffffff, 0, 0);
-  }
-
-  static backrank(color: Color): SquareSet {
-    return color === 'sente' ? SquareSet.fromRank(8) : SquareSet.fromRank(0);
-  }
-
-  static backrank2(color: Color): SquareSet {
-    return (color === 'sente' ? SquareSet.fromRank(7) : SquareSet.fromRank(1)).union(this.backrank(color));
-  }
-
   complement(): SquareSet {
     return new SquareSet(~this.lo, ~this.mid, ~this.hi);
   }

package/src/transform.ts

@@ -24,6 +24,8 @@ export function rotate180(s: SquareSet): SquareSet {
 
 export function transformBoard(board: Board, f: (s: SquareSet) => SquareSet): Board {
   const b = Board.empty();
+  b.numberOfFiles = board.numberOfFiles;
+  b.numberOfRanks = board.numberOfRanks;
   b.occupied = f(board.occupied);
   for (const color of COLORS) b[color] = f(board[color]);
   for (const role of ROLES) b[role] = f(board[role]);
@@ -33,7 +35,7 @@ export function transformBoard(board: Board, f: (s: SquareSet) => SquareSet): Bo
 export function transformSetup(setup: Setup, f: (s: SquareSet) => SquareSet): Setup {
   return {
     board: transformBoard(setup.board, f),
-    pockets: setup.pockets.clone(),
+    hands: setup.hands.clone(),
     turn: setup.turn,
     fullmoves: setup.fullmoves,
   };

package/src/types.ts

@@ -18,27 +18,24 @@ export type ByColor<T> = {
   [color in Color]: T;
 };
 
+// correct order for sfen hand exporting
 export const ROLES = [
-  'pawn',
-  'lance',
-  'knight',
-  'silver',
-  'gold',
-  'bishop',
   'rook',
+  'bishop',
+  'gold',
+  'silver',
+  'knight',
+  'lance',
+  'pawn',
+  'dragon',
+  'horse',
   'tokin',
-  'promotedlance',
-  'promotedknight',
   'promotedsilver',
-  'horse',
-  'dragon',
+  'promotedknight',
+  'promotedlance',
   'king',
 ] as const;
-export const POCKET_ROLES = ['rook', 'bishop', 'gold', 'silver', 'knight', 'lance', 'pawn'] as const;
-export const PROMOTABLE_ROLES = ['pawn', 'lance', 'knight', 'silver', 'bishop', 'rook'] as const;
 export type Role = typeof ROLES[number];
-export type PocketRole = typeof POCKET_ROLES[number];
-export type PromotableRole = typeof PROMOTABLE_ROLES[number];
 
 export type ByRole<T> = {
   [role in Role]: T;
@@ -56,7 +53,7 @@ export interface NormalMove {
 }
 
 export interface DropMove {
-  role: PocketRole;
+  role: Role;
   to: Square;
 }
 
@@ -71,7 +68,7 @@ export function isNormal(v: Move): v is NormalMove {
 }
 
 // variant will be added later, once lishogi supports them
-export const RULES = ['shogi'] as const;
+export const RULES = ['shogi', 'minishogi'] as const;
 export type Rules = typeof RULES[number];
 
 export interface Outcome {

package/src/util.ts

@@ -1,17 +1,4 @@
-import { SquareSet } from './squareSet';
-import {
-  FILE_NAMES,
-  RANK_NAMES,
-  Color,
-  Square,
-  Role,
-  PocketRole,
-  Move,
-  isDrop,
-  SquareName,
-  Piece,
-  PROMOTABLE_ROLES,
-} from './types';
+import { FILE_NAMES, RANK_NAMES, Color, Square, Role, Move, isDrop, SquareName } from './types';
 
 export function defined<A>(v: A | undefined): v is A {
   return v !== undefined;
@@ -21,6 +8,7 @@ export function opposite(color: Color): Color {
   return color === 'gote' ? 'sente' : 'gote';
 }
 
+// coordinate system starts at bottom left
 export function squareRank(square: Square): number {
   return Math.floor(square / 9);
 }
@@ -29,53 +17,7 @@ export function squareFile(square: Square): number {
   return square % 9;
 }
 
-export function unpromote(role: Role): PocketRole | 'king' {
-  switch (role) {
-    case 'pawn':
-    case 'tokin':
-      return 'pawn';
-    case 'lance':
-    case 'promotedlance':
-      return 'lance';
-    case 'knight':
-    case 'promotedknight':
-      return 'knight';
-    case 'silver':
-    case 'promotedsilver':
-      return 'silver';
-    case 'gold':
-      return 'gold';
-    case 'bishop':
-    case 'horse':
-      return 'bishop';
-    case 'rook':
-    case 'dragon':
-      return 'rook';
-    default:
-      return role;
-  }
-}
-
-export function promote(role: Role): Role {
-  switch (role) {
-    case 'pawn':
-      return 'tokin';
-    case 'lance':
-      return 'promotedlance';
-    case 'knight':
-      return 'promotedknight';
-    case 'silver':
-      return 'promotedsilver';
-    case 'bishop':
-      return 'horse';
-    case 'rook':
-      return 'dragon';
-    default:
-      return role;
-  }
-}
-
-export function roleToChar(role: Role): string {
+export function roleToString(role: Role): string {
   switch (role) {
     case 'pawn':
       return 'p';
@@ -261,7 +203,7 @@ export function kanjiToRole(str: string): Role | undefined {
   }
 }
 
-export function charToRole(
+export function stringToRole(
   ch:
     | 'p'
     | 'l'
@@ -290,8 +232,8 @@ export function charToRole(
     | '+B'
     | '+R'
 ): Role;
-export function charToRole(ch: string): Role | undefined;
-export function charToRole(ch: string): Role | undefined {
+export function stringToRole(ch: string): Role | undefined;
+export function stringToRole(ch: string): Role | undefined {
   switch (ch) {
     case 'P':
     case 'p':
@@ -356,7 +298,7 @@ export function makeSquare(square: Square): SquareName {
 
 export function parseUsi(str: string): Move | undefined {
   if (str[1] === '*' && str.length === 4) {
-    const role = charToRole(str[0]) as PocketRole;
+    const role = stringToRole(str[0]);
     const to = parseSquare(str.slice(2));
     if (defined(role) && defined(to)) return { role, to };
   } else if (str.length === 4 || str.length === 5) {
@@ -369,17 +311,10 @@ export function parseUsi(str: string): Move | undefined {
 }
 
 export function makeUsi(move: Move): string {
-  if (isDrop(move)) return `${roleToChar(move.role).toUpperCase()}*${makeSquare(move.to)}`;
+  if (isDrop(move)) return `${roleToString(move.role).toUpperCase()}*${makeSquare(move.to)}`;
   return makeSquare(move.from) + makeSquare(move.to) + (move.promotion ? '+' : '');
 }
 
-export function canPiecePromote(piece: Piece, from: Square, to: Square): boolean {
-  return (
-    (PROMOTABLE_ROLES as ReadonlyArray<string>).includes(piece.role) &&
-    (SquareSet.promotionZone(piece.color).has(from) || SquareSet.promotionZone(piece.color).has(to))
-  );
-}
-
 export function toBW(color: string): 'b' | 'w' {
   // white, w, gote, g
   if (color[0] === 'w' || color[0] === 'g') return 'w';

package/src/variant.ts

@@ -1,20 +1,61 @@
 import { Result } from '@badrap/result';
-import { Rules } from './types';
+import { Role, Rules, Square } from './types';
 import { Setup } from './setup';
 import { PositionError, Position, IllegalSetup, Context, Shogi } from './shogi';
+import { SquareSet } from './squareSet';
+import { Board } from './board';
+import { Hands } from './hand';
 
 export { Position, PositionError, IllegalSetup, Context, Shogi };
 
 export function defaultPosition(rules: Rules): Position {
   switch (rules) {
-    case 'shogi':
+    case 'minishogi':
+      return Minishogi.default();
+    default:
       return Shogi.default();
   }
 }
 
 export function setupPosition(rules: Rules, setup: Setup, strict = true): Result<Position, PositionError> {
   switch (rules) {
-    case 'shogi':
+    case 'minishogi':
+      return Minishogi.fromSetup(setup, strict);
+    default:
       return Shogi.fromSetup(setup, strict);
   }
 }
+
+export class Minishogi extends Shogi {
+  protected constructor() {
+    super('minishogi');
+  }
+
+  numberOfRanks = 5;
+  numberOfFiles = 5;
+
+  static default(): Minishogi {
+    const pos = new this();
+    pos.board = Board.minishogi();
+    pos.hands = Hands.empty();
+    pos.turn = 'sente';
+    pos.fullmoves = 1;
+    return pos;
+  }
+
+  static fromSetup(setup: Setup, strict: boolean): Result<Minishogi, PositionError> {
+    return super.fromSetup(setup, strict) as Result<Minishogi, PositionError>;
+  }
+
+  clone(): Minishogi {
+    return super.clone() as Minishogi;
+  }
+
+  dests(square: Square, ctx?: Context): SquareSet {
+    return super.dests(square, ctx).intersect(new SquareSet(0x0, 0x7c3e000, 0x7c3e1f0));
+  }
+
+  dropDests(role: Role, ctx?: Context): SquareSet {
+    return super.dropDests(role, ctx).intersect(new SquareSet(0x0, 0x7c3e000, 0x7c3e1f0));
+  }
+}