shogiops 0.2.9 → 0.6.0

package/src/{csa.ts → notation/csa/csa.ts}

@@ -1,10 +1,14 @@
 import { Result } from '@badrap/result';
-import { Board } from './board';
-import { Material, MaterialSide, Setup } from './setup';
-import { Position } from './shogi';
-import { Color, isDrop, Move, PocketRole, POCKET_ROLES } from './types';
-import { csaToRole, defined, promote, roleToCsa } from './util';
-import { makeCsaSquare, parseCsaSquare } from './csaUtil';
+import { Board } from '../../board';
+import { Setup } from '../../setup';
+import { Position } from '../../shogi';
+import { Color, isDrop, Move } from '../../types';
+import { csaToRole, defined, roleToCsa } from '../../util';
+import { Hand, Hands } from '../../hand';
+import { allRoles, handRoles, promote } from '../../variantUtil';
+import { makeNumberSquare, parseNumberSquare } from '../notationUtil';
+
+// Olny supports standard shogi no variants
 
 //
 // CSA HEADER
@@ -14,7 +18,7 @@ export enum InvalidCsa {
   CSA = 'ERR_CSA',
   Board = 'ERR_BOARD',
   Handicap = 'ERR_HANDICAP',
-  Pockets = 'ERR_POCKETS',
+  Hands = 'ERR_HANDS',
   AdditionalInfo = 'ERR_ADDITIONAL',
 }
 
@@ -24,8 +28,8 @@ export class CsaError extends Error {}
 export function makeCsaHeader(setup: Setup): string {
   return [
     makeCsaBoard(setup.board),
-    makeCsaPocket(setup.pockets.sente, 'P+'),
-    makeCsaPocket(setup.pockets.gote, 'P-'),
+    makeCsaHand(setup.hands.sente, 'P+'),
+    makeCsaHand(setup.hands.gote, 'P-'),
     setup.turn === 'gote' ? '-' : '+',
   ]
     .filter(p => p.length > 0)
@@ -50,15 +54,16 @@ export function makeCsaBoard(board: Board): string {
   return csaBoard;
 }
 
-export function makeCsaPocket(material: MaterialSide, prefix: string): string {
-  if (material.isEmpty()) return '';
+export function makeCsaHand(hand: Hand, prefix: string): string {
+  if (hand.isEmpty()) return '';
   return (
     prefix +
-    POCKET_ROLES.map(role => {
-      const r = roleToCsa(role);
-      const n = material[role];
-      return ('00' + r).repeat(Math.min(n, 18));
-    })
+    handRoles('shogi')
+      .map(role => {
+        const r = roleToCsa(role);
+        const n = hand[role];
+        return ('00' + r).repeat(Math.min(n, 18));
+      })
       .filter(p => p.length > 0)
       .join('')
   );
@@ -75,7 +80,7 @@ export function parseCsaHeader(csa: string): Result<Setup, CsaError> {
   return baseBoard.chain(board => {
     const setup = {
       board: board,
-      pockets: Material.empty(),
+      hands: Hands.empty(),
       turn: turn,
       fullmoves: 1,
     };
@@ -90,7 +95,7 @@ export function parseCsaHandicap(handicap: string): Result<Board, CsaError> {
   const splitted = handicap.substring(2).match(/.{4}/g) || [];
   const intitalBoard = Board.default();
   for (const s of splitted) {
-    const sq = parseCsaSquare(s.substring(0, 2));
+    const sq = parseNumberSquare(s.substring(0, 2));
     if (defined(sq)) {
       intitalBoard.take(sq);
     } else {
@@ -114,7 +119,7 @@ function parseCsaBoard(csaBoard: string[]): Result<Board, CsaError> {
       else {
         if (file >= 9 || rank < 0) return Result.err(new CsaError(InvalidCsa.Board));
         const role = csaToRole(s.substring(1));
-        if (defined(role)) {
+        if (defined(role) && allRoles('shogi').includes(role)) {
           const square = file + rank * 9;
           const piece = { role: role, color: (s.startsWith('-') ? 'gote' : 'sente') as Color };
           board.set(square, piece);
@@ -131,13 +136,13 @@ function parseAdditions(initialSetup: Setup, additions: string[]): Result<Setup,
   for (const line of additions) {
     const color: Color = line[1] === '+' ? 'sente' : 'gote';
     for (const sp of line.substring(2).match(/.{4}/g) || []) {
-      const sq = parseCsaSquare(sp.substring(0, 2));
+      const sqString = sp.substring(0, 2);
+      const sq = parseNumberSquare(sqString);
       const role = csaToRole(sp.substring(2, 4));
-      if (defined(sq) && defined(role)) {
-        if (sq === 0) {
-          if (!(POCKET_ROLES as ReadonlyArray<string>).includes(role))
-            return Result.err(new CsaError(InvalidCsa.Pockets));
-          initialSetup.pockets[color][role as PocketRole]++;
+      if ((defined(sq) || sqString === '00') && defined(role)) {
+        if (!defined(sq)) {
+          if (!handRoles('shogi').includes(role)) return Result.err(new CsaError(InvalidCsa.Hands));
+          initialSetup.hands[color][role]++;
         } else {
           initialSetup.board.set(sq, { role: role, color: color });
         }
@@ -153,6 +158,14 @@ export function parseTags(csa: string): [string, string][] {
     .map(l => l.substring(1).split(/:(.*)/, 2) as [string, string]);
 }
 
+export function normalizedCsaLines(csa: string): string[] {
+  return csa
+    .replace(/,/g, '\n')
+    .split(/[\r\n]+/)
+    .map(l => l.trim())
+    .filter(l => l);
+}
+
 //
 // CSA MOVES
 //
@@ -166,16 +179,16 @@ export function parseCsaMove(pos: Position, csaMove: string): Move | undefined {
     const match = csaMove.match(/(?:[\+-])?00([1-9][1-9])(HI|KA|KI|GI|KE|KY|FU)/);
     if (!match) return;
     const drop = {
-      role: csaToRole(match[2]) as PocketRole,
-      to: parseCsaSquare(match[1])!,
+      role: csaToRole(match[2])!,
+      to: parseNumberSquare(match[1])!,
     };
     return drop;
   }
   const role = csaToRole(match[3])!;
-  const orig = parseCsaSquare(match[1])!;
+  const orig = parseNumberSquare(match[1])!;
   return {
     from: orig,
-    to: parseCsaSquare(match[2])!,
+    to: parseNumberSquare(match[2])!,
     promotion: pos.board.get(orig)?.role !== role,
   };
 }
@@ -193,30 +206,16 @@ export function parseCsaMoves(pos: Position, csaMoves: string[]): Move[] {
 }
 
 // Making CSA formatted moves
-export function makeCsaMove(pos: Position, move: Move): string {
+export function makeCsaMove(pos: Position, move: Move): string | undefined {
   if (isDrop(move)) {
-    return '00' + makeCsaSquare(move.to) + roleToCsa(move.role);
+    return '00' + makeNumberSquare(move.to) + roleToCsa(move.role);
   } else {
     const role = pos.board.getRole(move.from);
-    if (!role) return '%ERROR';
-    return makeCsaSquare(move.from) + makeCsaSquare(move.to) + roleToCsa(move.promotion ? promote(role) : role);
-  }
-}
-
-export function makeCsaVariation(pos: Position, variation: Move[]): string {
-  pos = pos.clone();
-  const line = [];
-  for (const m of variation) {
-    line.push((pos.turn === 'sente' ? '+' : '-') + makeCsaMove(pos, m));
-    pos.play(m);
+    if (!role) return undefined;
+    return (
+      makeNumberSquare(move.from) +
+      makeNumberSquare(move.to) +
+      roleToCsa(move.promotion ? promote('shogi')(role) : role)
+    );
   }
-  return line.join('\n');
-}
-
-export function normalizedCsaLines(csa: string): string[] {
-  return csa
-    .replace(/,/g, '\n')
-    .split(/[\r\n]+/)
-    .map(l => l.trim())
-    .filter(l => l);
 }

package/src/notation/japanese.ts

@@ -0,0 +1,74 @@
+import { roleTo2Kanji, squareFile, squareRank } from '../util';
+import { Position } from '../shogi';
+import { Move, isDrop, Square, Piece } from '../types';
+import { pieceCanPromote } from '../variantUtil';
+import { makeJapaneseSquare, piecesAiming } from './notationUtil';
+import { SquareSet } from '../squareSet';
+
+// ７六歩
+export function makeJapaneseMove(pos: Position, move: Move, lastDest?: Square): string | undefined {
+  if (isDrop(move)) {
+    const ambStr = piecesAiming(pos, { role: move.role, color: pos.turn }, move.to).isEmpty() ? '' : '打';
+    return `${makeJapaneseSquare(move.to)}${roleTo2Kanji(move.role).toUpperCase()}${ambStr}`;
+  } else {
+    const piece = pos.board.get(move.from);
+    if (piece) {
+      const destStr = lastDest === move.to ? '同　' : makeJapaneseSquare(move.to);
+      const roleStr = roleTo2Kanji(piece.role).toUpperCase();
+      const ambPieces = piecesAiming(pos, piece, move.to).without(move.from);
+      const ambStr = ambPieces.isEmpty() ? '' : disambiguate(piece, move.from, move.to, ambPieces);
+      const promStr = move.promotion ? '成' : pieceCanPromote(pos.rules)(piece, move.from, move.to) ? '不成' : '';
+      return `${destStr}${roleStr}${ambStr}${promStr}`;
+    } else return undefined;
+  }
+}
+
+function disambiguate(piece: Piece, orig: Square, dest: Square, others: SquareSet): string {
+  const myRank = squareRank(orig);
+  const myFile = squareFile(orig);
+
+  const destRank = squareRank(dest);
+  const destFile = squareFile(dest);
+
+  const movingUp = myRank < destRank;
+  const movingDown = myRank > destRank;
+
+  // special case if gold/silver like piece is moving directly forward
+  if (
+    myFile === destFile &&
+    (piece.color === 'sente') === movingUp &&
+    ['gold', 'silver', 'promotedlance', 'promotedknight', 'promotedsilver', 'tokin'].includes(piece.role)
+  )
+    return '直';
+
+  // is this the only piece moving in certain vertical direction (up, down, horizontally)
+  if (![...others].map(squareRank).some(r => r > destRank === movingDown && r < destRank === movingUp))
+    return verticalDisambiguation(piece, movingUp, movingDown);
+
+  const othersFiles = [...others].map(squareFile);
+  const rightest = othersFiles.reduce((prev, cur) => (prev > cur ? prev : cur));
+  const leftest = othersFiles.reduce((prev, cur) => (prev < cur ? prev : cur));
+
+  // is this piece positioned most on one side, not in the middle
+  if (rightest < myFile || leftest > myFile || (others.size() === 2 && rightest > myFile && leftest < myFile))
+    return sideDisambiguation(piece, rightest < squareFile(orig), leftest > squareFile(orig));
+
+  return (
+    sideDisambiguation(piece, rightest <= squareFile(orig), leftest >= squareFile(orig)) +
+    verticalDisambiguation(piece, movingUp, movingDown)
+  );
+}
+
+function verticalDisambiguation(piece: Piece, up: Boolean, down: Boolean): string {
+  return up === down
+    ? '寄'
+    : (piece.color === 'sente') === up
+    ? ['horse', 'dragon'].includes(piece.role)
+      ? '行'
+      : '上'
+    : '引';
+}
+
+function sideDisambiguation(piece: Piece, right: Boolean, left: Boolean): string {
+  return !left && !right ? '中' : (piece.color === 'sente') === right ? '右' : '左';
+}

package/src/{kif.ts → notation/kif/kif.ts}

@@ -1,20 +1,21 @@
 import { Result } from '@badrap/result';
-import { Board } from './board';
-import { INITIAL_FEN, makeFen, parseFen } from './fen';
+import { Board } from '../../board';
+import { INITIAL_SFEN, makeSfen, parseSfen } from '../../sfen';
 import { handicapNameToSfen, sfenToHandicapName } from './kifHandicaps';
-import { Material, MaterialSide, 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 { Setup } from '../../setup';
+import { Position } from '../../shogi';
+import { Color, isDrop, Move, Square } from '../../types';
+import { defined, kanjiToRole, roleTo1Kanji, roleTo2Kanji } from '../../util';
 
+import { Hand, Hands } from '../../hand';
+import { allRoles, handRoles, promote } from '../../variantUtil';
 import {
   kanjiToNumber,
-  kifDestSquare,
-  kifOrigSquare,
-  normalizedKifLines,
+  makeJapaneseSquare,
+  makeNumberSquare,
   numberToKanji,
-  parseKifSquare,
-} from './kifUtil';
+  parseJapaneseSquare,
+} from '../notationUtil';
 
 //
 // KIF HEADER
@@ -24,34 +25,37 @@ export enum InvalidKif {
   Kif = 'ERR_KIF',
   Board = 'ERR_BOARD',
   Handicap = 'ERR_HANDICAP',
-  Pockets = 'ERR_POCKETS',
+  Hands = 'ERR_HANDS',
 }
 
 export class KifError extends Error {}
 
 // Export
 export function makeKifHeader(setup: Setup): string {
-  const handicap = sfenToHandicapName(makeFen(setup, { epd: true }));
+  const handicap = sfenToHandicapName(makeSfen(setup, { epd: true }));
   if (defined(handicap)) return '手合割：' + handicap;
   return makeKifPositionHeader(setup);
 }
 
 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 +68,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(' ');
 }
@@ -83,12 +88,12 @@ export function makeKifPocket(material: MaterialSide): string {
 export function parseKifHeader(kif: string): Result<Setup, KifError> {
   const lines = normalizedKifLines(kif);
   const handicap = lines.find(l => l.startsWith('手合割：'));
-  const hSfen = defined(handicap) ? handicapNameToSfen(handicap.split('：')[1]) : INITIAL_FEN;
+  const hSfen = defined(handicap) ? handicapNameToSfen(handicap.split('：')[1]) : INITIAL_SFEN;
   return parseKifPositionHeader(kif).unwrap(
     kifBoard => Result.ok(kifBoard),
     () => {
       if (!defined(hSfen)) return Result.err(new KifError(InvalidKif.Handicap));
-      return parseFen(hSfen);
+      return parseSfen(hSfen);
     }
   );
 }
@@ -96,25 +101,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 +126,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 +156,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 +167,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][] {
@@ -189,6 +196,15 @@ export function parseTags(kif: string): [string, string][] {
     .map(l => l.replace('：', ':').split(/:(.*)/, 2) as [string, string]);
 }
 
+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);
+}
+
 //
 // KIF MOVES
 //
@@ -204,15 +220,15 @@ 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,
-      to: parseKifSquare(match[1]) ?? lastDest!,
+      role: kanjiToRole(match[2])!,
+      to: parseJapaneseSquare(match[1]) ?? lastDest!,
     };
     return move;
   }
 
   return {
-    from: parseKifSquare(match[4])!,
-    to: parseKifSquare(match[1]) ?? lastDest!,
+    from: parseJapaneseSquare(match[4])!,
+    to: parseJapaneseSquare(match[1]) ?? lastDest!,
     promotion: !!match[3],
   };
 }
@@ -229,30 +245,13 @@ export function parseKifMoves(kifMoves: string[], lastDest: Square | undefined =
 }
 
 // Making kif formatted moves
-export function makeKifMove(pos: Position, move: Move, same = false): string {
-  const moveDest = same ? '同　' : kifDestSquare(move.to);
+export function makeKifMove(pos: Position, move: Move, lastDest?: Square): string | undefined {
+  const moveDest = lastDest === move.to ? '同　' : makeJapaneseSquare(move.to);
   if (isDrop(move)) {
     return moveDest + roleTo1Kanji(move.role) + '打';
   } else {
     const role = pos.board.getRole(move.from);
-    if (!role) return '反則';
-    return moveDest + roleTo2Kanji(role) + (move.promotion ? '成' : '') + '(' + kifOrigSquare(move.from) + ')';
-  }
-}
-
-export function makeKifVariation(
-  pos: Position,
-  variation: Move[],
-  lastDest: Square | undefined = undefined,
-  startTurn = 1
-): string {
-  pos = pos.clone();
-  const line = [];
-  const padding = (startTurn + variation.length - 1).toString().length;
-  for (const m of variation) {
-    line.push((startTurn++).toString().padStart(padding) + ' ' + makeKifMove(pos, m, m.to === lastDest));
-    pos.play(m);
-    lastDest = m.to;
+    if (!role) return undefined;
+    return moveDest + roleTo2Kanji(role) + (move.promotion ? '成' : '') + '(' + makeNumberSquare(move.from) + ')';
   }
-  return line.join('\n');
 }

package/src/{kifHandicaps.ts → notation/kif/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/notation/kitaoKawasaki.ts

@@ -0,0 +1,24 @@
+import { roleTo2Kanji } from '../util';
+import { Position } from '../shogi';
+import { Move, isDrop, Square } from '../types';
+import { pieceCanPromote } from '../variantUtil';
+import { makeNumberSquare, piecesAiming } from './notationUtil';
+
+// 歩-76
+export function makeKitaoKawasakiMove(pos: Position, move: Move, lastDest?: Square): string | undefined {
+  if (isDrop(move)) {
+    return roleTo2Kanji(move.role).toUpperCase() + '*' + makeNumberSquare(move.to);
+  } else {
+    const piece = pos.board.get(move.from);
+    if (piece) {
+      const roleStr = roleTo2Kanji(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 destStr = lastDest === move.to ? '' : makeNumberSquare(move.to);
+      const promStr = move.promotion ? '+' : pieceCanPromote(pos.rules)(piece, move.from, move.to) ? '=' : '';
+      return `${roleStr}${ambStr}${actionStr}${destStr}${promStr}`;
+    } else return undefined;
+  }
+}