shogiops 0.2.7 → 0.4.0

package/src/fen.ts

@@ -1,8 +1,10 @@
 import { Result } from '@badrap/result';
-import { Piece, Color, POCKET_ROLES, PocketRole } from './types';
+import { Piece, Color } from './types';
 import { Board } from './board';
-import { Setup, MaterialSide, Material } from './setup';
+import { Setup } from './setup';
 import { defined, roleToChar, charToRole, toBW } from './util';
+import { Hand, Hands } from './hand';
+import { ROLES } from './types';
 
 export const INITIAL_BOARD_FEN = 'lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL';
 export const INITIAL_EPD = INITIAL_BOARD_FEN + ' b -';
@@ -14,7 +16,7 @@ export const EMPTY_FEN = EMPTY_EPD + ' 1';
 export enum InvalidFen {
   Fen = 'ERR_FEN',
   Board = 'ERR_BOARD',
-  Pockets = 'ERR_POCKETS',
+  Hands = 'ERR_HANDS',
   Turn = 'ERR_TURN',
   Fullmoves = 'ERR_FULLMOVES',
 }
@@ -32,12 +34,18 @@ function charToPiece(ch: string): Piece | undefined {
 
 export function parseBoardFen(boardPart: string): Result<Board, FenError> {
   const board = Board.empty();
+  const ranks = boardPart.split('/');
+  board.numberOfRanks = ranks.length;
+  // we assume the board is square
+  // since that's good enough for now...
+  board.numberOfFiles = board.numberOfRanks;
+  const offset = 9 - board.numberOfFiles;
   let rank = 8;
-  let file = 0;
+  let file = offset;
   for (let i = 0; i < boardPart.length; i++) {
     let c = boardPart[i];
     if (c === '/' && file === 9) {
-      file = 0;
+      file = offset;
       rank--;
     } else {
       const step = parseInt(c, 10);
@@ -53,26 +61,25 @@ export function parseBoardFen(boardPart: string): Result<Board, FenError> {
       }
     }
   }
-  if (rank !== 0 || file !== 9) return Result.err(new FenError(InvalidFen.Board));
+  if (rank !== offset || file !== 9) return Result.err(new FenError(InvalidFen.Board));
   return Result.ok(board);
 }
 
-export function parsePockets(pocketPart: string): Result<Material, FenError> {
-  if (pocketPart.toLowerCase().includes('k')) return Result.err(new FenError(InvalidFen.Pockets));
-  const pockets = Material.empty();
-  for (let i = 0; i < pocketPart.length; i++) {
-    if (pocketPart[i] === '-') break;
+export function parseHands(handsPart: string): Result<Hands, FenError> {
+  const hands = Hands.empty();
+  for (let i = 0; i < handsPart.length; i++) {
+    if (handsPart[i] === '-') break;
     // max 99
     let count: number;
-    if (parseInt(pocketPart[i]) >= 0) {
-      count = parseInt(pocketPart[i++], 10);
-      if (parseInt(pocketPart[i]) >= 0) count = count * 10 + parseInt(pocketPart[i++], 10);
+    if (parseInt(handsPart[i]) >= 0) {
+      count = parseInt(handsPart[i++], 10);
+      if (parseInt(handsPart[i]) >= 0) count = count * 10 + parseInt(handsPart[i++], 10);
     } else count = 1;
-    const piece = charToPiece(pocketPart[i]);
-    if (!piece) return Result.err(new FenError(InvalidFen.Pockets));
-    pockets[piece.color][piece.role as PocketRole] += count;
+    const piece = charToPiece(handsPart[i]);
+    if (!piece) return Result.err(new FenError(InvalidFen.Hands));
+    hands[piece.color][piece.role] += count;
   }
-  return Result.ok(pockets);
+  return Result.ok(hands);
 }
 
 export function parseFen(fen: string): Result<Setup, FenError> {
@@ -89,11 +96,11 @@ export function parseFen(fen: string): Result<Setup, FenError> {
   else if (turnPart === 'w') turn = 'gote';
   else return Result.err(new FenError(InvalidFen.Turn));
 
-  // Pocket
-  const pocketPart = parts.shift();
-  let pockets: Result<Material, FenError>;
-  if (!defined(pocketPart)) pockets = Result.ok(Material.empty());
-  else pockets = parsePockets(pocketPart);
+  // Hands
+  const handsPart = parts.shift();
+  let hands: Result<Hands, FenError>;
+  if (!defined(handsPart)) hands = Result.ok(Hands.empty());
+  else hands = parseHands(handsPart);
 
   // Turn
   const fullmovesPart = parts.shift();
@@ -103,10 +110,10 @@ export function parseFen(fen: string): Result<Setup, FenError> {
   if (parts.length > 0) return Result.err(new FenError(InvalidFen.Fen));
 
   return board.chain(board =>
-    pockets.map(pockets => {
+    hands.map(hands => {
       return {
         board,
-        pockets,
+        hands,
         turn,
         fullmoves: Math.max(1, fullmoves),
       };
@@ -135,8 +142,8 @@ export function makePiece(piece: Piece): string {
 export function makeBoardFen(board: Board): string {
   let fen = '';
   let empty = 0;
-  for (let rank = 8; rank >= 0; rank--) {
-    for (let file = 0; file < 9; file++) {
+  for (let rank = 8; rank >= 9 - board.numberOfRanks; rank--) {
+    for (let file = 9 - board.numberOfFiles; file < 9; file++) {
       const square = file + rank * 9;
       const piece = board.get(square);
       if (!piece) empty++;
@@ -153,31 +160,31 @@ export function makeBoardFen(board: Board): string {
           fen += empty;
           empty = 0;
         }
-        if (rank !== 0) fen += '/';
+        if (rank !== 9 - board.numberOfRanks) fen += '/';
       }
     }
   }
   return fen;
 }
 
-export function makePocket(material: MaterialSide): string {
-  return POCKET_ROLES.map(role => {
+export function makeHand(hand: Hand): string {
+  return ROLES.map(role => {
     const r = roleToChar(role);
-    const n = material[role];
+    const n = hand[role];
     return n > 1 ? n + r : n === 1 ? r : '';
   }).join('');
 }
 
-export function makePockets(pocket: Material): string {
-  const pockets = makePocket(pocket.sente).toUpperCase() + makePocket(pocket.gote);
-  return pockets === '' ? '-' : pockets;
+export function makeHands(hands: Hands): string {
+  const handsStr = makeHand(hands.sente).toUpperCase() + makeHand(hands.gote);
+  return handsStr === '' ? '-' : handsStr;
 }
 
 export function makeFen(setup: Setup, opts?: FenOpts): string {
   return [
     makeBoardFen(setup.board),
     toBW(setup.turn),
-    makePockets(setup.pockets),
+    makeHands(setup.hands),
     ...(opts?.epd ? [] : [Math.max(1, Math.min(setup.fullmoves, 9999))]),
   ].join(' ');
 }

package/src/hand.ts

@@ -0,0 +1,94 @@
+import { Role, ROLES } from './types';
+
+// Hand alone can store anything
+// let the variants decide what to store and what not
+export class Hand {
+  pawn: number;
+  lance: number;
+  knight: number;
+  silver: number;
+  gold: number;
+  bishop: number;
+  rook: number;
+  tokin: number;
+  promotedlance: number;
+  promotedknight: number;
+  promotedsilver: number;
+  horse: number;
+  dragon: number;
+  king: number;
+
+  private constructor() {}
+
+  static empty(): Hand {
+    const m = new Hand();
+    for (const role of ROLES) m[role] = 0;
+    return m;
+  }
+
+  clone(): Hand {
+    const m = new Hand();
+    for (const role of ROLES) m[role] = this[role];
+    return m;
+  }
+
+  equals(other: Hand): boolean {
+    return ROLES.every(role => this[role] === other[role]);
+  }
+
+  add(other: Hand): Hand {
+    const m = new Hand();
+    for (const role of ROLES) m[role] = this[role] + other[role];
+    return m;
+  }
+
+  nonEmpty(): boolean {
+    return ROLES.some(role => this[role] > 0);
+  }
+
+  isEmpty(): boolean {
+    return !this.nonEmpty();
+  }
+
+  count(): number {
+    return ROLES.map(role => this[role]).reduce((acc, cur) => acc + cur);
+  }
+
+  *[Symbol.iterator](): Iterator<[Role, number]> {
+    for (const role of ROLES.filter(r => this[r] > 0)) {
+      yield [role, this[role]];
+    }
+  }
+}
+
+export class Hands {
+  constructor(public gote: Hand, public sente: Hand) {}
+
+  static empty(): Hands {
+    return new Hands(Hand.empty(), Hand.empty());
+  }
+
+  clone(): Hands {
+    return new Hands(this.gote.clone(), this.sente.clone());
+  }
+
+  equals(other: Hands): boolean {
+    return this.gote.equals(other.gote) && this.sente.equals(other.sente);
+  }
+
+  add(other: Hands): Hands {
+    return new Hands(this.gote.add(other.gote), this.sente.add(other.sente));
+  }
+
+  count(): number {
+    return this.gote.count() + this.sente.count();
+  }
+
+  isEmpty(): boolean {
+    return this.gote.isEmpty() && this.sente.isEmpty();
+  }
+
+  nonEmpty(): boolean {
+    return !this.isEmpty();
+  }
+}

package/src/hash.ts

@@ -1,6 +1,7 @@
-import { COLORS, POCKET_ROLES, ROLES } from './types';
+import { COLORS, ROLES } from './types';
 import { Board } from './board';
-import { Setup, MaterialSide, Material } from './setup';
+import { Setup } from './setup';
+import { Hand, Hands } from './hand';
 
 function rol32(n: number, left: number): number {
   return (n << left) | (n >>> (32 - left));
@@ -17,19 +18,19 @@ export function hashBoard(board: Board, state = 0): number {
   return state;
 }
 
-export function hashMaterialSide(side: MaterialSide, state = 0): number {
-  for (const role of POCKET_ROLES) state = fxhash32(side[role], state);
+export function hashHand(hand: Hand, state = 0): number {
+  for (const role of ROLES) state = fxhash32(hand[role], state);
   return state;
 }
 
-export function hashMaterial(material: Material, state = 0): number {
-  for (const color of COLORS) state = hashMaterialSide(material[color], state);
+export function hashHands(hands: Hands, state = 0): number {
+  for (const color of COLORS) state = hashHand(hands[color], state);
   return state;
 }
 
 export function hashSetup(setup: Setup, state = 0): number {
   state = hashBoard(setup.board, state);
-  state = hashMaterial(setup.pockets, state);
+  state = hashHands(setup.hands, state);
   if (setup.turn === 'sente') state = fxhash32(1, state);
   return state;
 }

package/src/index.ts

@@ -11,8 +11,6 @@ export {
   ByColor,
   Role,
   ROLES,
-  POCKET_ROLES,
-  PROMOTABLE_ROLES,
   ByRole,
   Piece,
   NormalMove,
@@ -58,7 +56,7 @@ export {
 
 export { Board } from './board';
 
-export { Material, MaterialSide, Setup, defaultSetup } from './setup';
+export { Setup, defaultSetup } from './setup';
 
 export { IllegalSetup, Shogi, Position, PositionError, Context } from './shogi';
 
@@ -70,6 +68,8 @@ export * as fen from './fen';
 
 export * as handicaps from './kifHandicaps';
 
+export * as hand from './hand';
+
 export * as hash from './hash';
 
 export * as kif from './kif';
@@ -80,8 +80,8 @@ export * as csa from './csa';
 
 export * as csaUtil from './csaUtil';
 
-export * as san from './san';
-
 export * as transform from './transform';
 
 export * as variant from './variant';
+
+export * as variantUtil from './variantUtil';

package/src/kif.ts

@@ -2,10 +2,10 @@ import { Result } from '@badrap/result';
 import { Board } from './board';
 import { INITIAL_FEN, makeFen, parseFen } from './fen';
 import { handicapNameToSfen, sfenToHandicapName } from './kifHandicaps';
-import { Material, MaterialSide, Setup } from './setup';
+import { Setup } from './setup';
 import { Position } from './shogi';
-import { Color, isDrop, Move, PocketRole, POCKET_ROLES, Square } from './types';
-import { defined, kanjiToRole, promote, roleTo1Kanji, roleTo2Kanji } from './util';
+import { Color, isDrop, Move, Square } from './types';
+import { defined, kanjiToRole, roleTo1Kanji, roleTo2Kanji } from './util';
 
 import {
   kanjiToNumber,
@@ -15,6 +15,8 @@ import {
   numberToKanji,
   parseKifSquare,
 } from './kifUtil';
+import { Hand, Hands } from './hand';
+import { allRoles, handRoles, promote } from './variantUtil';
 
 //
 // KIF HEADER
@@ -24,7 +26,7 @@ export enum InvalidKif {
   Kif = 'ERR_KIF',
   Board = 'ERR_BOARD',
   Handicap = 'ERR_HANDICAP',
-  Pockets = 'ERR_POCKETS',
+  Hands = 'ERR_HANDS',
 }
 
 export class KifError extends Error {}
@@ -38,20 +40,23 @@ export function makeKifHeader(setup: Setup): string {
 
 export function makeKifPositionHeader(setup: Setup): string {
   return [
-    '後手の持駒：' + makeKifPocket(setup.pockets.gote),
+    '後手の持駒：' + makeKifHand(setup.hands.gote),
     makeKifBoard(setup.board),
-    '先手の持駒：' + makeKifPocket(setup.pockets.sente),
+    '先手の持駒：' + makeKifHand(setup.hands.sente),
     ...(setup.turn === 'gote' ? ['後手番'] : []),
   ].join('\n');
 }
 
 export function makeKifBoard(board: Board): string {
-  let kifBoard = '  ９ ８ ７ ６ ５ ４ ３ ２ １\n+---------------------------+\n';
-  for (let rank = 8; rank >= 0; rank--) {
-    for (let file = 0; file < 9; file++) {
+  const kifFiles = ' ９ ８ ７ ６ ５ ４ ３ ２ １'.slice(-(board.numberOfFiles * 2));
+  const separator = '+' + '-'.repeat(board.numberOfFiles * 3) + '+';
+  const offset = 9 - board.numberOfFiles;
+  let kifBoard = ' ' + kifFiles + `\n${separator}\n`;
+  for (let rank = 8; rank >= 9 - board.numberOfRanks; rank--) {
+    for (let file = offset; file < 9; file++) {
       const square = file + rank * 9;
       const piece = board.get(square);
-      if (file === 0) {
+      if (file === offset) {
         kifBoard += '|';
       }
       if (!piece) kifBoard += ' ・';
@@ -64,17 +69,18 @@ export function makeKifBoard(board: Board): string {
       }
     }
   }
-  kifBoard += '+---------------------------+';
+  kifBoard += separator;
   return kifBoard;
 }
 
-export function makeKifPocket(material: MaterialSide): string {
-  if (material.isEmpty()) return 'なし';
-  return POCKET_ROLES.map(role => {
-    const r = roleTo1Kanji(role);
-    const n = material[role];
-    return n > 1 ? r + numberToKanji(n) : n === 1 ? r : '';
-  })
+export function makeKifHand(hand: Hand): string {
+  if (hand.isEmpty()) return 'なし';
+  return handRoles('shogi')
+    .map(role => {
+      const r = roleTo1Kanji(role);
+      const n = hand[role];
+      return n > 1 ? r + numberToKanji(n) : n === 1 ? r : '';
+    })
     .filter(p => p.length > 0)
     .join(' ');
 }
@@ -96,25 +102,21 @@ export function parseKifHeader(kif: string): Result<Setup, KifError> {
 export function parseKifPositionHeader(kif: string): Result<Setup, KifError> {
   const lines = normalizedKifLines(kif);
 
-  const gotePocketStr = lines.find(l => l.startsWith('後手の持駒：'));
-  const sentePocketStr = lines.find(l => l.startsWith('先手の持駒：'));
+  const goteHandStr = lines.find(l => l.startsWith('後手の持駒：'));
+  const senteHandStr = lines.find(l => l.startsWith('先手の持駒：'));
   const turn = lines.some(l => l.startsWith('後手番')) ? 'gote' : 'sente';
 
   const board: Result<Board, KifError> = parseKifBoard(kif);
 
-  const gotePocket = defined(gotePocketStr)
-    ? parseKifHand(gotePocketStr.split('：')[1])
-    : Result.ok(MaterialSide.empty());
-  const sentePocket = defined(sentePocketStr)
-    ? parseKifHand(sentePocketStr.split('：')[1])
-    : Result.ok(MaterialSide.empty());
+  const goteHand = defined(goteHandStr) ? parseKifHand(goteHandStr.split('：')[1]) : Result.ok(Hand.empty());
+  const senteHand = defined(senteHandStr) ? parseKifHand(senteHandStr.split('：')[1]) : Result.ok(Hand.empty());
 
   return board.chain(board =>
-    gotePocket.chain(gPocket =>
-      sentePocket.map(sPocket => {
+    goteHand.chain(gHand =>
+      senteHand.map(sHand => {
         return {
           board,
-          pockets: new Material(gPocket, sPocket),
+          hands: new Hands(gHand, sHand),
           turn,
           fullmoves: 1,
         };
@@ -125,13 +127,19 @@ export function parseKifPositionHeader(kif: string): Result<Setup, KifError> {
 
 export function parseKifBoard(kifBoard: string): Result<Board, KifError> {
   const lines = normalizedKifLines(kifBoard).filter(l => l.startsWith('|'));
-  if (lines.length !== 9) return Result.err(new KifError(InvalidKif.Board));
+  if (lines.length === 0) return Result.err(new KifError(InvalidKif.Board));
   const board = Board.empty();
-  let file = 0;
+
+  // assuming square board
+  board.numberOfRanks = lines.length;
+  board.numberOfFiles = lines.length;
+
+  const offset = 9 - lines.length;
+  let file = offset;
   let rank = 9;
 
   for (const l of lines) {
-    file = 0;
+    file = offset;
     rank--;
     let gote = false;
     let prom = false;
@@ -149,9 +157,9 @@ export function parseKifBoard(kifBoard: string): Result<Board, KifError> {
         default:
           if (file > 9 || rank < 0) return Result.err(new KifError(InvalidKif.Board));
           const role = kanjiToRole(c);
-          if (defined(role)) {
+          if (defined(role) && allRoles('shogi').includes(role)) {
             const square = file + rank * 9;
-            const piece = { role: prom ? promote(role) : role, color: (gote ? 'gote' : 'sente') as Color };
+            const piece = { role: prom ? promote('shogi')(role) : role, color: (gote ? 'gote' : 'sente') as Color };
             board.set(square, piece);
             prom = false;
             gote = false;
@@ -160,27 +168,27 @@ export function parseKifBoard(kifBoard: string): Result<Board, KifError> {
       }
     }
   }
-  if (rank !== 0 || file !== 9) return Result.err(new KifError(InvalidKif.Board));
+  if (rank !== 9 - lines.length || file !== 9) return Result.err(new KifError(InvalidKif.Board));
   return Result.ok(board);
 }
 
-export function parseKifHand(pocketPart: string): Result<MaterialSide, KifError> {
-  const pockets = MaterialSide.empty();
-  const pieces = pocketPart.replace(/　/g, ' ').trim().split(' ');
+export function parseKifHand(handPart: string): Result<Hand, KifError> {
+  const hand = Hand.empty();
+  const pieces = handPart.replace(/　/g, ' ').trim().split(' ');
 
-  if (pocketPart.includes('なし')) return Result.ok(pockets);
+  if (handPart.includes('なし')) return Result.ok(hand);
   for (const piece of pieces) {
     for (let i = 0; i < piece.length; i++) {
       const role = kanjiToRole(piece[i++]);
-      if (!role) return Result.err(new KifError(InvalidKif.Pockets));
+      if (!role || !handRoles('shogi').includes(role)) return Result.err(new KifError(InvalidKif.Hands));
       let countStr = '';
       while (i < piece.length && ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十'].includes(piece[i]))
         countStr += piece[i++];
       const count = kanjiToNumber(countStr) || 1;
-      pockets[role as PocketRole] += count;
+      hand[role] += count;
     }
   }
-  return Result.ok(pockets);
+  return Result.ok(hand);
 }
 
 export function parseTags(kif: string): [string, string][] {
@@ -204,7 +212,7 @@ export function parseKifMove(kifMove: string, lastDest: Square | undefined = und
     const match = kifMove.match(/((?:[１２３４５６７８９][一二三四五六七八九]|同\s?))(飛|角|金|銀|桂|香|歩)打/);
     if (!match) return;
     const move = {
-      role: kanjiToRole(match[2]) as PocketRole,
+      role: kanjiToRole(match[2])!,
       to: parseKifSquare(match[1]) ?? lastDest!,
     };
     return move;

package/src/kifHandicaps.ts

@@ -23,6 +23,9 @@ export function sfenToHandicapName(sfen: string): string | undefined {
       return '八枚落ち';
     case '4k4/9/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w -':
       return '十枚落ち';
+    // minishogi
+    case 'rbsgk/4p/5/P4/KGSBR b -':
+      return '五々将棋';
     default:
       return undefined;
   }
@@ -79,6 +82,8 @@ export function handicapNameToSfen(name: string): string | undefined {
       return '2sgkgs2/9/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w RB2N2L 1';
     case '八枚得':
       return '3gkg3/9/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL w RB2S2N2L 1';
+    case '五々将棋':
+      return 'rbsgk/4p/5/P4/KGSBR b - 1';
     default:
       return undefined;
   }

package/src/setup.ts

@@ -1,97 +1,10 @@
-import { Color, POCKET_ROLES } from './types';
+import { Color } from './types';
 import { Board } from './board';
-
-export class MaterialSide {
-  pawn: number;
-  lance: number;
-  knight: number;
-  silver: number;
-  gold: number;
-  bishop: number;
-  rook: number;
-
-  private constructor() {}
-
-  static empty(): MaterialSide {
-    const m = new MaterialSide();
-    for (const role of POCKET_ROLES) m[role] = 0;
-    return m;
-  }
-
-  static fromBoard(board: Board, color: Color): MaterialSide {
-    const m = new MaterialSide();
-    for (const role of POCKET_ROLES) m[role] = board.pieces(color, role).size();
-    return m;
-  }
-
-  clone(): MaterialSide {
-    const m = new MaterialSide();
-    for (const role of POCKET_ROLES) m[role] = this[role];
-    return m;
-  }
-
-  equals(other: MaterialSide): boolean {
-    return POCKET_ROLES.every(role => this[role] === other[role]);
-  }
-
-  add(other: MaterialSide): MaterialSide {
-    const m = new MaterialSide();
-    for (const role of POCKET_ROLES) m[role] = this[role] + other[role];
-    return m;
-  }
-
-  nonEmpty(): boolean {
-    return POCKET_ROLES.some(role => this[role] > 0);
-  }
-
-  isEmpty(): boolean {
-    return !this.nonEmpty();
-  }
-
-  count(): number {
-    return this.pawn + this.lance + this.knight + this.silver + this.gold + this.bishop + this.rook;
-  }
-}
-
-export class Material {
-  constructor(public gote: MaterialSide, public sente: MaterialSide) {}
-
-  static empty(): Material {
-    return new Material(MaterialSide.empty(), MaterialSide.empty());
-  }
-
-  static fromBoard(board: Board): Material {
-    return new Material(MaterialSide.fromBoard(board, 'gote'), MaterialSide.fromBoard(board, 'sente'));
-  }
-
-  clone(): Material {
-    return new Material(this.gote.clone(), this.sente.clone());
-  }
-
-  equals(other: Material): boolean {
-    return this.gote.equals(other.gote) && this.sente.equals(other.sente);
-  }
-
-  add(other: Material): Material {
-    return new Material(this.gote.add(other.gote), this.sente.add(other.sente));
-  }
-
-  count(): number {
-    return this.gote.count() + this.sente.count();
-  }
-
-  isEmpty(): boolean {
-    return this.gote.isEmpty() && this.sente.isEmpty();
-  }
-
-  nonEmpty(): boolean {
-    return !this.isEmpty();
-  }
-}
+import { Hands } from './hand';
 
 export interface Setup {
   board: Board;
-  pockets: Material;
+  hands: Hands;
   turn: Color;
   fullmoves: number;
 }
@@ -99,7 +12,7 @@ export interface Setup {
 export function defaultSetup(): Setup {
   return {
     board: Board.default(),
-    pockets: Material.empty(),
+    hands: Hands.empty(),
     turn: 'sente',
     fullmoves: 1,
   };