shogiops 0.2.9 → 0.6.0

package/src/{kifUtil.ts → notation/notationUtil.ts}

@@ -1,24 +1,42 @@
-import { Square } from './types';
-import { parseSquare, squareFile, squareRank } from './util';
+import { Position } from '../shogi';
+import { Piece, Square } from '../types';
+import { parseSquare, squareFile, squareRank } from '../util';
+import { SquareSet } from '../squareSet';
 
-export function parseKifSquare(str: string): Square | undefined {
+export function piecesAiming(pos: Position, piece: Piece, to: Square): SquareSet {
+  // Disambiguation
+  let pieces = SquareSet.empty();
+  for (const s of pos.board.pieces(pos.turn, piece.role))
+    if (pos.dests(s).has(to)) pieces = pieces.union(SquareSet.fromSquare(s));
+  return pieces;
+}
+
+export function makeNumberSquare(sq: Square): string {
+  return (9 - squareFile(sq)).toString() + (9 - squareRank(sq));
+}
+
+export function parseNumberSquare(str: string): Square | undefined {
   if (str.length !== 2) return;
-  const file = str[0].charCodeAt(0) >= 65297 ? String.fromCharCode(str[0].charCodeAt(0) - 65248) : str[0];
-  const rank = String.fromCharCode(
-    ('一二三四五六七八九'.includes(str[1]) ? fromKanjiDigit(str[1]).toString() : str[1]).charCodeAt(0) + 48
-  );
-  return parseSquare(file + rank);
+  const file = Math.abs(str.charCodeAt(0) - '9'.charCodeAt(0));
+  const rank = Math.abs(str.charCodeAt(1) - '9'.charCodeAt(0));
+  if (file < 0 || file >= 9 || rank < 0 || rank >= 9) return;
+  return file + 9 * rank;
 }
 
-export function kifDestSquare(sq: Square): string {
+export function makeJapaneseSquare(sq: Square): string {
   return (
     String.fromCharCode((9 - squareFile(sq)).toString().charCodeAt(0) + 0xfee0) +
     toKanjiDigit((9 - squareRank(sq)).toString())
   );
 }
 
-export function kifOrigSquare(sq: Square): string {
-  return 9 - squareFile(sq) + (9 - squareRank(sq)).toString();
+export function parseJapaneseSquare(str: string): Square | undefined {
+  if (str.length !== 2) return;
+  const file = str[0].charCodeAt(0) >= 65297 ? String.fromCharCode(str[0].charCodeAt(0) - 65248) : str[0];
+  const rank = String.fromCharCode(
+    ('一二三四五六七八九'.includes(str[1]) ? fromKanjiDigit(str[1]).toString() : str[1]).charCodeAt(0) + 48
+  );
+  return parseSquare(file + rank);
 }
 
 export function toKanjiDigit(str: string): string {
@@ -48,13 +66,6 @@ export function toKanjiDigit(str: string): string {
   }
 }
 
-// max 99, meant for pieces in hand, you don't need more than 99 pieces...
-export function numberToKanji(n: number): string {
-  n = Math.max(0, Math.min(n, 99));
-  const res = n >= 20 ? toKanjiDigit(Math.floor(n / 10).toString()) + '十' : n >= 10 ? '十' : '';
-  return res + toKanjiDigit(Math.floor(n % 10).toString());
-}
-
 export function fromKanjiDigit(str: string): number {
   switch (str) {
     case '一':
@@ -82,7 +93,14 @@ export function fromKanjiDigit(str: string): number {
   }
 }
 
-// max 99, meant for pieces in hand, you don't need more than 99 pieces...
+// max 99
+export function numberToKanji(n: number): string {
+  n = Math.max(0, Math.min(n, 99));
+  const res = n >= 20 ? toKanjiDigit(Math.floor(n / 10).toString()) + '十' : n >= 10 ? '十' : '';
+  return res + toKanjiDigit(Math.floor(n % 10).toString());
+}
+
+// max 99
 export function kanjiToNumber(str: string): number {
   let res = str.startsWith('十') ? 1 : 0;
   for (const s of str) {
@@ -91,12 +109,3 @@ export function kanjiToNumber(str: string): number {
   }
   return Math.max(0, Math.min(res, 99));
 }
-
-export function normalizedKifLines(kif: string): string[] {
-  return kif
-    .replace(/:/g, '：')
-    .replace(/　/g, ' ') // full-width space to normal space
-    .split(/[\r\n]+/)
-    .map(l => l.trim())
-    .filter(l => l);
-}

package/src/notation/western.ts

@@ -0,0 +1,21 @@
+import { roleToString } from '../util';
+import { Position } from '../shogi';
+import { Move, isDrop } from '../types';
+import { pieceCanPromote } from '../variantUtil';
+import { makeNumberSquare, piecesAiming } from './notationUtil';
+
+// P-76
+export function makeWesternMove(pos: Position, move: Move): string | undefined {
+  if (isDrop(move)) {
+    return roleToString(move.role).toUpperCase() + '*' + makeNumberSquare(move.to);
+  } else {
+    const piece = pos.board.get(move.from);
+    if (piece) {
+      const roleStr = roleToString(piece.role).toUpperCase();
+      const ambStr = piecesAiming(pos, piece, move.to).without(move.from).isEmpty() ? '' : makeNumberSquare(move.from);
+      const actionStr = pos.board.has(move.to) ? 'x' : '-';
+      const promStr = move.promotion ? '+' : pieceCanPromote(pos.rules)(piece, move.from, move.to) ? '=' : '';
+      return `${roleStr}${ambStr}${actionStr}${makeNumberSquare(move.to)}${promStr}`;
+    } else return undefined;
+  }
+}

package/src/notation/westernEngine.ts

@@ -0,0 +1,21 @@
+import { makeSquare, roleToString } from '../util';
+import { Position } from '../shogi';
+import { Move, isDrop } from '../types';
+import { pieceCanPromote } from '../variantUtil';
+import { piecesAiming } from './notationUtil';
+
+// P-7f
+export function makeWesternEngineMove(pos: Position, move: Move): string | undefined {
+  if (isDrop(move)) {
+    return roleToString(move.role).toUpperCase() + '*' + makeSquare(move.to);
+  } else {
+    const piece = pos.board.get(move.from);
+    if (piece) {
+      const roleStr = roleToString(piece.role).toUpperCase();
+      const ambStr = piecesAiming(pos, piece, move.to).without(move.from).isEmpty() ? '' : makeSquare(move.from);
+      const actionStr = pos.board.has(move.to) ? 'x' : '-';
+      const promStr = move.promotion ? '+' : pieceCanPromote(pos.rules)(piece, move.from, move.to) ? '=' : '';
+      return `${roleStr}${ambStr}${actionStr}${makeSquare(move.to)}${promStr}`;
+    } else 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,
   };

package/src/sfen.ts

@@ -0,0 +1,190 @@
+import { Result } from '@badrap/result';
+import { Piece, Color } from './types';
+import { Board } from './board';
+import { Setup } from './setup';
+import { defined, roleToString, stringToRole, toBW } from './util';
+import { Hand, Hands } from './hand';
+import { ROLES } from './types';
+
+export const INITIAL_BOARD_SFEN = 'lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL';
+export const INITIAL_EPD = INITIAL_BOARD_SFEN + ' b -';
+export const INITIAL_SFEN = INITIAL_EPD + ' 1';
+export const EMPTY_BOARD_SFEN = '9/9/9/9/9/9/9/9/9';
+export const EMPTY_EPD = EMPTY_BOARD_SFEN + ' b -';
+export const EMPTY_SFEN = EMPTY_EPD + ' 1';
+
+export enum InvalidSfen {
+  Sfen = 'ERR_SFEN',
+  Board = 'ERR_BOARD',
+  Hands = 'ERR_HANDS',
+  Turn = 'ERR_TURN',
+  Fullmoves = 'ERR_FULLMOVES',
+}
+
+export class SfenError extends Error {}
+
+function parseSmallUint(str: string): number | undefined {
+  return /^\d{1,4}$/.test(str) ? parseInt(str, 10) : undefined;
+}
+
+function stringToPiece(s: string): Piece | undefined {
+  const role = stringToRole(s);
+  return role && { role, color: s.toLowerCase() === s ? 'gote' : 'sente' };
+}
+
+export function parseBoardSfen(boardPart: string): Result<Board, SfenError> {
+  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 = offset;
+  for (let i = 0; i < boardPart.length; i++) {
+    let c = boardPart[i];
+    if (c === '/' && file === 9) {
+      file = offset;
+      rank--;
+    } else {
+      const step = parseInt(c, 10);
+      if (step > 0) file += step;
+      else {
+        if (file >= 9 || rank < 0) return Result.err(new SfenError(InvalidSfen.Board));
+        if (c === '+' && i + 1 < boardPart.length) c += boardPart[++i];
+        const square = file + rank * 9;
+        const piece = stringToPiece(c);
+        if (!piece) return Result.err(new SfenError(InvalidSfen.Board));
+        board.set(square, piece);
+        file++;
+      }
+    }
+  }
+  if (rank !== offset || file !== 9) return Result.err(new SfenError(InvalidSfen.Board));
+  return Result.ok(board);
+}
+
+export function parseHands(handsPart: string): Result<Hands, SfenError> {
+  const hands = Hands.empty();
+  for (let i = 0; i < handsPart.length; i++) {
+    if (handsPart[i] === '-') break;
+    // max 99
+    let count: number;
+    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 = stringToPiece(handsPart[i]);
+    if (!piece) return Result.err(new SfenError(InvalidSfen.Hands));
+    hands[piece.color][piece.role] += count;
+  }
+  return Result.ok(hands);
+}
+
+export function parseSfen(sfen: string): Result<Setup, SfenError> {
+  const parts = sfen.split(' ');
+
+  // Board
+  const boardPart = parts.shift()!;
+  const board: Result<Board, SfenError> = parseBoardSfen(boardPart);
+
+  // Turn
+  const turnPart = parts.shift();
+  let turn: Color;
+  if (!defined(turnPart) || turnPart === 'b') turn = 'sente';
+  else if (turnPart === 'w') turn = 'gote';
+  else return Result.err(new SfenError(InvalidSfen.Turn));
+
+  // Hands
+  const handsPart = parts.shift();
+  let hands: Result<Hands, SfenError>;
+  if (!defined(handsPart)) hands = Result.ok(Hands.empty());
+  else hands = parseHands(handsPart);
+
+  // Turn
+  const fullmovesPart = parts.shift();
+  const fullmoves = defined(fullmovesPart) ? parseSmallUint(fullmovesPart) : 1;
+  if (!defined(fullmoves)) return Result.err(new SfenError(InvalidSfen.Fullmoves));
+
+  if (parts.length > 0) return Result.err(new SfenError(InvalidSfen.Sfen));
+
+  return board.chain(board =>
+    hands.map(hands => {
+      return {
+        board,
+        hands,
+        turn,
+        fullmoves: Math.max(1, fullmoves),
+      };
+    })
+  );
+}
+
+interface SfenOpts {
+  epd?: boolean;
+}
+
+export function parsePiece(str: string): Piece | undefined {
+  if (!str) return;
+  const piece = stringToPiece(str[0]);
+  if (!piece) return;
+  else if (str.length > 1 && str[1] !== '+') return;
+  return piece;
+}
+
+export function makePiece(piece: Piece): string {
+  let r = roleToString(piece.role);
+  if (piece.color === 'sente') r = r.toUpperCase();
+  return r;
+}
+
+export function makeBoardSfen(board: Board): string {
+  let sfen = '';
+  let empty = 0;
+  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++;
+      else {
+        if (empty > 0) {
+          sfen += empty;
+          empty = 0;
+        }
+        sfen += makePiece(piece);
+      }
+
+      if (file === 8) {
+        if (empty > 0) {
+          sfen += empty;
+          empty = 0;
+        }
+        if (rank !== 9 - board.numberOfRanks) sfen += '/';
+      }
+    }
+  }
+  return sfen;
+}
+
+export function makeHand(hand: Hand): string {
+  return ROLES.map(role => {
+    const r = roleToString(role);
+    const n = hand[role];
+    return n > 1 ? n + r : n === 1 ? r : '';
+  }).join('');
+}
+
+export function makeHands(hands: Hands): string {
+  const handsStr = makeHand(hands.sente).toUpperCase() + makeHand(hands.gote);
+  return handsStr === '' ? '-' : handsStr;
+}
+
+export function makeSfen(setup: Setup, opts?: SfenOpts): string {
+  return [
+    makeBoardSfen(setup.board),
+    toBW(setup.turn),
+    makeHands(setup.hands),
+    ...(opts?.epd ? [] : [Math.max(1, Math.min(setup.fullmoves, 9999))]),
+  ].join(' ');
+}