@lichess-org/chessground 9.7.2 → 9.8.0

package/src/premove.ts

@@ -1,29 +1,14 @@
 import * as util from './util.js';
 import * as cg from './types.js';
 import { HeadlessState } from './state.js';
+import { Mobility, MobilityContext } from './types.js';
 
-type MobilityContext = {
-  pos1: cg.Pos;
-  pos2: cg.Pos;
-  allPieces: cg.Pieces;
-  friendlies: cg.Pieces;
-  enemies: cg.Pieces;
-  unrestrictedPremoves: boolean;
-  color: cg.Color;
-  canCastle: boolean;
-  rookFilesFriendlies: number[];
-  lastMove: cg.Key[] | undefined;
-};
-
-type Mobility = (ctx: MobilityContext) => boolean;
-
-const isDestOccupiedByFriendly = (ctx: MobilityContext): boolean =>
-  ctx.friendlies.has(util.pos2key(ctx.pos2));
+const isDestOccupiedByFriendly = (ctx: MobilityContext): boolean => ctx.friendlies.has(ctx.dest.key);
 
-const isDestOccupiedByEnemy = (ctx: MobilityContext): boolean => ctx.enemies.has(util.pos2key(ctx.pos2));
+const isDestOccupiedByEnemy = (ctx: MobilityContext): boolean => ctx.enemies.has(ctx.dest.key);
 
-const anyPieceBetween = (pos1: cg.Pos, pos2: cg.Pos, pieces: cg.Pieces): boolean =>
-  util.squaresBetween(...pos1, ...pos2).some(s => pieces.has(s));
+const anyPieceBetween = (orig: cg.Pos, dest: cg.Pos, pieces: cg.Pieces): boolean =>
+  util.squaresBetween(...orig, ...dest).some(s => pieces.has(s));
 
 const canEnemyPawnAdvanceToSquare = (pawnStart: cg.Key, dest: cg.Key, ctx: MobilityContext): boolean => {
   const piece = ctx.enemies.get(pawnStart);
@@ -53,10 +38,10 @@ const canEnemyPawnCaptureOnSquare = (pawnStart: cg.Key, dest: cg.Key, ctx: Mobil
 };
 
 const canSomeEnemyPawnAdvanceToDest = (ctx: MobilityContext): boolean =>
-  [...ctx.enemies.keys()].some(key => canEnemyPawnAdvanceToSquare(key, util.pos2key(ctx.pos2), ctx));
+  [...ctx.enemies.keys()].some(key => canEnemyPawnAdvanceToSquare(key, ctx.dest.key, ctx));
 
 const isDestControlledByEnemy = (ctx: MobilityContext, pieceRolesExclude?: cg.Role[]): boolean => {
-  const square: cg.Pos = ctx.pos2;
+  const square: cg.Pos = ctx.dest.pos;
   return [...ctx.enemies].some(([key, piece]) => {
     const piecePos = util.key2pos(key);
     return (
@@ -74,48 +59,58 @@ const isDestControlledByEnemy = (ctx: MobilityContext, pieceRolesExclude?: cg.Ro
 
 const isFriendlyOnDestAndAttacked = (ctx: MobilityContext): boolean =>
   isDestOccupiedByFriendly(ctx) &&
-  (canBeCapturedBySomeEnemyEnPassant(util.pos2key(ctx.pos2), ctx.friendlies, ctx.enemies, ctx.lastMove) ||
+  (canBeCapturedBySomeEnemyEnPassant(ctx.dest.key, ctx.friendlies, ctx.enemies, ctx.lastMove) ||
     isDestControlledByEnemy(ctx));
 
 const canBeCapturedBySomeEnemyEnPassant = (
-  potentialSquareOfFriendlyPawn: cg.Key,
+  potentialSquareOfFriendlyPawn: cg.Key | undefined,
   friendlies: cg.Pieces,
   enemies: cg.Pieces,
   lastMove?: cg.Key[],
 ): boolean => {
-  if (lastMove && potentialSquareOfFriendlyPawn !== lastMove[1]) return false;
+  if (!potentialSquareOfFriendlyPawn || (lastMove && potentialSquareOfFriendlyPawn !== lastMove[1]))
+    return false;
   const pos = util.key2pos(potentialSquareOfFriendlyPawn);
   const friendly = friendlies.get(potentialSquareOfFriendlyPawn);
   return (
     friendly?.role === 'pawn' &&
     pos[1] === (friendly.color === 'white' ? 3 : 4) &&
     (!lastMove || util.diff(util.key2pos(lastMove[0])[1], pos[1]) === 2) &&
-    [1, -1].some(delta => enemies.get(util.pos2key([pos[0] + delta, pos[1]]))?.role === 'pawn')
+    [1, -1].some(delta => {
+      const k = util.pos2key([pos[0] + delta, pos[1]]);
+      return !!k && enemies.get(k)?.role === 'pawn';
+    })
   );
 };
 
-const isPathClearEnoughOfFriendliesForPremove = (ctx: MobilityContext): boolean => {
+const isPathClearEnoughOfFriendliesForPremove = (ctx: MobilityContext, isPawnAdvance: boolean): boolean => {
   if (ctx.unrestrictedPremoves) return true;
-  const squaresBetween = util.squaresBetween(...ctx.pos1, ...ctx.pos2);
+  const squaresBetween = util.squaresBetween(...ctx.orig.pos, ...ctx.dest.pos);
+  if (isPawnAdvance) squaresBetween.push(ctx.dest.key);
   const squaresOfFriendliesBetween = squaresBetween.filter(s => ctx.friendlies.has(s));
+  if (!squaresOfFriendliesBetween.length) return true;
+  const firstSquareOfFriendliesBetween = squaresOfFriendliesBetween[0];
+  const nextSquare = util.squareShiftedVertically(
+    firstSquareOfFriendliesBetween,
+    ctx.color === 'white' ? -1 : 1,
+  );
   return (
-    !squaresOfFriendliesBetween.length ||
-    (squaresOfFriendliesBetween.length === 1 &&
-      canBeCapturedBySomeEnemyEnPassant(
-        squaresOfFriendliesBetween[0],
-        ctx.friendlies,
-        ctx.enemies,
-        ctx.lastMove,
-      ) &&
-      !squaresBetween.includes(
-        util.squareShiftedVertically(squaresOfFriendliesBetween[0], ctx.color === 'white' ? -1 : 1),
-      ))
+    squaresOfFriendliesBetween.length === 1 &&
+    canBeCapturedBySomeEnemyEnPassant(
+      firstSquareOfFriendliesBetween,
+      ctx.friendlies,
+      ctx.enemies,
+      ctx.lastMove,
+    ) &&
+    !!nextSquare &&
+    !squaresBetween.includes(nextSquare)
   );
 };
 
-const isPathClearEnoughOfEnemiesForPremove = (ctx: MobilityContext): boolean => {
+const isPathClearEnoughOfEnemiesForPremove = (ctx: MobilityContext, isPawnAdvance: boolean): boolean => {
   if (ctx.unrestrictedPremoves) return true;
-  const squaresBetween = util.squaresBetween(...ctx.pos1, ...ctx.pos2);
+  const squaresBetween = util.squaresBetween(...ctx.orig.pos, ...ctx.dest.pos);
+  if (isPawnAdvance) squaresBetween.push(ctx.dest.key);
   const squaresOfEnemiesBetween = squaresBetween.filter(s => ctx.enemies.has(s));
   if (squaresOfEnemiesBetween.length > 1) return false;
   if (!squaresOfEnemiesBetween.length) return true;
@@ -125,36 +120,38 @@ const isPathClearEnoughOfEnemiesForPremove = (ctx: MobilityContext): boolean =>
 
   const enemyStep = enemy.color === 'white' ? 1 : -1;
   const squareAbove = util.squareShiftedVertically(enemySquare, enemyStep);
-  const enemyPawnDests: cg.Key[] = [
-    ...util.adjacentSquares(squareAbove).filter(s => canEnemyPawnCaptureOnSquare(enemySquare, s, ctx)),
-    ...[squareAbove, util.squareShiftedVertically(squareAbove, enemyStep)].filter(
-      s => s && canEnemyPawnAdvanceToSquare(enemySquare, s, ctx),
-    ),
-  ];
-  const badSquares = [...squaresBetween, util.pos2key(ctx.pos1)];
+  const enemyPawnDests: cg.Key[] = squareAbove
+    ? [
+        ...util.adjacentSquares(squareAbove).filter(s => canEnemyPawnCaptureOnSquare(enemySquare, s, ctx)),
+        ...[squareAbove, util.squareShiftedVertically(squareAbove, enemyStep)]
+          .filter(s => !!s)
+          .filter(s => canEnemyPawnAdvanceToSquare(enemySquare, s, ctx)),
+      ]
+    : [];
+  const badSquares = [...squaresBetween, ctx.orig.key];
   return enemyPawnDests.some(square => !badSquares.includes(square));
 };
 
-const isPathClearEnoughForPremove = (ctx: MobilityContext): boolean =>
-  isPathClearEnoughOfFriendliesForPremove(ctx) && isPathClearEnoughOfEnemiesForPremove(ctx);
+const isPathClearEnoughForPremove = (ctx: MobilityContext, isPawnAdvance: boolean): boolean =>
+  isPathClearEnoughOfFriendliesForPremove(ctx, isPawnAdvance) &&
+  isPathClearEnoughOfEnemiesForPremove(ctx, isPawnAdvance);
 
 const pawn: Mobility = (ctx: MobilityContext) => {
   const step = ctx.color === 'white' ? 1 : -1;
-  if (util.diff(ctx.pos1[0], ctx.pos2[0]) > 1) return false;
-  if (!util.diff(ctx.pos1[0], ctx.pos2[0])) {
+  if (util.diff(ctx.orig.pos[0], ctx.dest.pos[0]) > 1) return false;
+  if (!util.diff(ctx.orig.pos[0], ctx.dest.pos[0]))
     return (
-      util.pawnDirAdvance(...ctx.pos1, ...ctx.pos2, ctx.color === 'white') &&
-      isPathClearEnoughForPremove({ ...ctx, pos2: [ctx.pos2[0], ctx.pos2[1] + step] })
+      util.pawnDirAdvance(...ctx.orig.pos, ...ctx.dest.pos, ctx.color === 'white') &&
+      isPathClearEnoughForPremove(ctx, true)
     );
-  }
-  if (ctx.pos2[1] !== ctx.pos1[1] + step) return false;
+  if (ctx.dest.pos[1] !== ctx.orig.pos[1] + step) return false;
   if (ctx.unrestrictedPremoves || isDestOccupiedByEnemy(ctx)) return true;
   if (isDestOccupiedByFriendly(ctx)) return isDestControlledByEnemy(ctx);
   else
     return (
       canSomeEnemyPawnAdvanceToDest(ctx) ||
       canBeCapturedBySomeEnemyEnPassant(
-        util.pos2key([ctx.pos2[0], ctx.pos2[1] + step]),
+        util.pos2key([ctx.dest.pos[0], ctx.dest.pos[1] + step]),
         ctx.friendlies,
         ctx.enemies,
         ctx.lastMove,
@@ -164,37 +161,37 @@ const pawn: Mobility = (ctx: MobilityContext) => {
 };
 
 const knight: Mobility = (ctx: MobilityContext) =>
-  util.knightDir(...ctx.pos1, ...ctx.pos2) &&
+  util.knightDir(...ctx.orig.pos, ...ctx.dest.pos) &&
   (ctx.unrestrictedPremoves || !isDestOccupiedByFriendly(ctx) || isFriendlyOnDestAndAttacked(ctx));
 
 const bishop: Mobility = (ctx: MobilityContext) =>
-  util.bishopDir(...ctx.pos1, ...ctx.pos2) &&
-  isPathClearEnoughForPremove(ctx) &&
+  util.bishopDir(...ctx.orig.pos, ...ctx.dest.pos) &&
+  isPathClearEnoughForPremove(ctx, false) &&
   (ctx.unrestrictedPremoves || !isDestOccupiedByFriendly(ctx) || isFriendlyOnDestAndAttacked(ctx));
 
 const rook: Mobility = (ctx: MobilityContext) =>
-  util.rookDir(...ctx.pos1, ...ctx.pos2) &&
-  isPathClearEnoughForPremove(ctx) &&
+  util.rookDir(...ctx.orig.pos, ...ctx.dest.pos) &&
+  isPathClearEnoughForPremove(ctx, false) &&
   (ctx.unrestrictedPremoves || !isDestOccupiedByFriendly(ctx) || isFriendlyOnDestAndAttacked(ctx));
 
 const queen: Mobility = (ctx: MobilityContext) => bishop(ctx) || rook(ctx);
 
 const king: Mobility = (ctx: MobilityContext) =>
-  (util.kingDirNonCastling(...ctx.pos1, ...ctx.pos2) &&
+  (util.kingDirNonCastling(...ctx.orig.pos, ...ctx.dest.pos) &&
     (ctx.unrestrictedPremoves || !isDestOccupiedByFriendly(ctx) || isFriendlyOnDestAndAttacked(ctx))) ||
   (ctx.canCastle &&
-    ctx.pos1[1] === ctx.pos2[1] &&
-    ctx.pos1[1] === (ctx.color === 'white' ? 0 : 7) &&
-    ((ctx.pos1[0] === 4 &&
-      ((ctx.pos2[0] === 2 && ctx.rookFilesFriendlies.includes(0)) ||
-        (ctx.pos2[0] === 6 && ctx.rookFilesFriendlies.includes(7)))) ||
-      ctx.rookFilesFriendlies.includes(ctx.pos2[0])) &&
+    ctx.orig.pos[1] === ctx.dest.pos[1] &&
+    ctx.orig.pos[1] === (ctx.color === 'white' ? 0 : 7) &&
+    ((ctx.orig.pos[0] === 4 &&
+      ((ctx.dest.pos[0] === 2 && ctx.rookFilesFriendlies.includes(0)) ||
+        (ctx.dest.pos[0] === 6 && ctx.rookFilesFriendlies.includes(7)))) ||
+      ctx.rookFilesFriendlies.includes(ctx.dest.pos[0])) &&
     (ctx.unrestrictedPremoves ||
       /* The following checks if no non-rook friendly piece is in the way between the king and its castling destination.
          Note that for the Chess960 edge case of Kb1 "long castling", the check passes even if there is a piece in the way
          on c1. But this is fine, since premoving from b1 to a1 as a normal move would have already returned true. */
       util
-        .squaresBetween(...ctx.pos1, ctx.pos2[0] > ctx.pos1[0] ? 7 : 1, ctx.pos2[1])
+        .squaresBetween(...ctx.orig.pos, ctx.dest.pos[0] > ctx.orig.pos[0] ? 7 : 1, ctx.dest.pos[1])
         .map(s => ctx.allPieces.get(s))
         .every(p => !p || util.samePiece(p, { role: 'rook', color: ctx.color }))));
 
@@ -209,10 +206,12 @@ export function premove(state: HeadlessState, key: cg.Key): cg.Key[] {
   const color = piece.color,
     friendlies = new Map([...pieces].filter(([_, p]) => p.color === color)),
     enemies = new Map([...pieces].filter(([_, p]) => p.color === util.opposite(color))),
-    pos = util.key2pos(key),
-    mobility: Mobility = mobilityByRole[piece.role],
-    ctx = {
-      pos1: pos,
+    orig = { key, pos: util.key2pos(key) },
+    mobility: Mobility = (ctx: MobilityContext) =>
+      mobilityByRole[piece.role](ctx) && state.premovable.additionalPremoveRequirements(ctx),
+    partialCtx = {
+      orig,
+      role: piece.role,
       allPieces: pieces,
       friendlies: friendlies,
       enemies: enemies,
@@ -226,5 +225,5 @@ export function premove(state: HeadlessState, key: cg.Key): cg.Key[] {
         .map(([k]) => util.key2pos(k)[0]),
       lastMove: state.lastMove,
     };
-  return util.allPos.filter(pos2 => mobility({ ...ctx, pos2 })).map(util.pos2key);
+  return util.allPosAndKey.filter(dest => mobility({ ...partialCtx, dest })).map(pk => pk.key);
 }

package/src/state.ts

@@ -23,6 +23,7 @@ export interface HeadlessState {
   blockTouchScroll: boolean; // block scrolling via touch dragging on the board
   touchIgnoreRadius: number; // ignore touches within a radius of an occupied square, in units of its circumradius
   pieceKey: boolean; // add a data-key attribute to piece elements
+  pixelCoordsOfMouchDownToMaybeClearShapes?: cg.NumberPair;
   trustAllEvents?: boolean; // disable checking for human only input (e.isTrusted)
   highlight: {
     lastMove: boolean; // add last-move class to squares
@@ -53,6 +54,7 @@ export interface HeadlessState {
     customDests?: cg.Dests; // use custom valid premoves. {"a2" ["a3" "a4"] "b1" ["a3" "c3"]}
     current?: cg.KeyPair; // keys of the current saved premove ["e2" "e4"]
     unrestrictedPremoves?: boolean; // if falsy, the positions of friendly pieces will be used to trim premove options
+    additionalPremoveRequirements: cg.Mobility;
     events: {
       set?: (orig: cg.Key, dest: cg.Key, metadata?: cg.SetPremoveMetadata) => void; // called after the premove has been set
       unset?: () => void; // called after the premove has been unset
@@ -145,6 +147,7 @@ export function defaults(): HeadlessState {
       enabled: true,
       showDests: true,
       castle: true,
+      additionalPremoveRequirements: _ => true,
       events: {},
     },
     predroppable: {
@@ -174,7 +177,7 @@ export function defaults(): HeadlessState {
       enabled: true, // can draw
       visible: true, // can view
       defaultSnapToValidMove: true,
-      eraseOnClick: true,
+      eraseOnMovablePieceClick: true,
       shapes: [],
       autoShapes: [],
       brushes: {

package/src/types.ts

@@ -5,6 +5,10 @@ export type Rank = (typeof ranks)[number];
 export type Key = 'a0' | `${File}${Rank}`;
 export type FEN = string;
 export type Pos = [number, number];
+export interface PosAndKey {
+  pos: Pos;
+  key: Key;
+}
 export interface Piece {
   role: Role;
   color: Color;
@@ -112,3 +116,19 @@ export type BrushColor = 'green' | 'red' | 'blue' | 'yellow';
 export type SquareClasses = Map<Key, string>;
 
 export type DirectionalCheck = (x1: number, y1: number, x2: number, y2: number) => boolean;
+
+export type MobilityContext = {
+  orig: PosAndKey;
+  dest: PosAndKey;
+  role: Role;
+  allPieces: Pieces;
+  friendlies: Pieces;
+  enemies: Pieces;
+  unrestrictedPremoves: boolean;
+  color: Color;
+  canCastle: boolean;
+  rookFilesFriendlies: number[];
+  lastMove: Key[] | undefined;
+};
+
+export type Mobility = (ctx: MobilityContext) => boolean;

package/src/util.ts

@@ -4,7 +4,10 @@ export const invRanks: readonly cg.Rank[] = [...cg.ranks].reverse();
 
 export const allKeys: readonly cg.Key[] = cg.files.flatMap(f => cg.ranks.map(r => (f + r) as cg.Key));
 
-export const pos2key = (pos: cg.Pos): cg.Key => allKeys[8 * pos[0] + pos[1]];
+export const pos2key = (pos: cg.Pos): cg.Key | undefined =>
+  pos.every(x => x >= 0 && x <= 7) ? allKeys[8 * pos[0] + pos[1]] : undefined;
+
+export const pos2keyUnsafe = (pos: cg.Pos): cg.Key => pos2key(pos)!;
 
 export const key2pos = (k: cg.Key): cg.Pos => [k.charCodeAt(0) - 97, k.charCodeAt(1) - 49];
 
@@ -16,6 +19,8 @@ export const uciToMove = (uci: string | undefined): cg.Key[] | undefined => {
 
 export const allPos: readonly cg.Pos[] = allKeys.map(key2pos);
 
+export const allPosAndKey: readonly cg.PosAndKey[] = allKeys.map((key, i) => ({ key, pos: allPos[i] }));
+
 export function memo<A>(f: () => A): cg.Memo<A> {
   let v: A | undefined;
   const ret = (): A => {
@@ -148,7 +153,7 @@ export const squaresBetween = (x1: number, y1: number, x2: number, y2: number):
     x += stepX;
     y += stepY;
   }
-  return squares.map(sq => pos2key(sq));
+  return squares.map(pos2key).filter(k => k !== undefined);
 };
 
 export const adjacentSquares = (square: cg.Key): cg.Key[] => {
@@ -156,10 +161,10 @@ export const adjacentSquares = (square: cg.Key): cg.Key[] => {
   const adjacentSquares: cg.Pos[] = [];
   if (pos[0] > 0) adjacentSquares.push([pos[0] - 1, pos[1]]);
   if (pos[0] < 7) adjacentSquares.push([pos[0] + 1, pos[1]]);
-  return adjacentSquares.map(pos2key);
+  return adjacentSquares.map(pos2key).filter(k => k !== undefined);
 };
 
-export const squareShiftedVertically = (square: cg.Key, delta: number): cg.Key => {
+export const squareShiftedVertically = (square: cg.Key, delta: number): cg.Key | undefined => {
   const pos = key2pos(square);
   pos[1] += delta;
   return pos2key(pos);