リファレンス

ルールと棋譜

import { … } from "@johnmorrisdotca/narabe";

最小化と gzip 圧縮をしたサイズは 20.8 kB（読み込むものをすべて含み、esbuild で計測）

リファレンスの説明と例は英語です。見出しと目次は日本語です。

Narabe 並べ: one rules engine for forty-eight abstract board games.

Every game is a row of data (VARIANT_SPECS), and every function takes a GameState and returns a new one. Start with createGame, play with playMove, movePiece, placePiece, twistBoard or passTurn, and ask turnChoices what the player to move may do. Records are plain move lists: replayMoves and replayGame read them back, undoMove steps one back.

Deeper pieces (each rule module on its own) are reachable by path as well, for example @johnmorrisdotca/narabe/rules/go.

エクスポート

名前	種類	概要
`ALL_BOARD_SIZES`	定数	Every size any game here is played on, for the schemas at the API edge.
`availableOpenings`	関数	The openings these settings may use: what the variant offers, less the colour-swapping ones when a handicap is bound to a colour — and only the free opening under a head start.
`Blocked`	型	An intersection the rules have taken out of play.
`BLOCKED`	定数	The unavailable-cell marker.
`BOARD_GRIDS`	定数	Where a game's stones sit when it is drawn its own way: on the crossings, or in the squares.
`BOARD_SIZES`	定数	Board is `size` × `size`.
`BoardGrid`	型	Where a game's stones sit when it is drawn the way it is traditionally played: on the crossings of the lines, as in go and gomoku, or inside the squares, as in tic-tac-toe, Othello and checkers.
`boardSizesFor`	関数	The board sizes a variant plays on, smallest first — the order they are drawn in.
`BRAZILIAN_DRAUGHTS_RULES`	定数	Brazilian draughts: the international rules of capture and crowning on 8×8, with twelve men, and the draws of the Brazilian confederation's own rules (CBJD, Regras Oficiais) rather than the FMJD's 8×8 set, which differs.
`campOf`	関数	Whose home camp `point` lies in, or null for the open board.
`campSize`	関数	Pieces a side has on `size`: the squares of its camp.
`campSquares`	関数	The squares of a colour's home camp.
`CANADIAN_CHECKERS_RULES`	定数	Canadian checkers: the international rules on 12×12, thirty men a side in five rows.
`canBeDrawn`	関数	Whether this game can be drawn at all.
`canChooseColour`	関数	Whether the game is waiting on a seat to pick a colour.
`canExtendOpening`	関数	Swap2 only: the first chooser may add two stones and pass the choice back.
`canForfeit`	関数	Whether a recorded forfeit could have been written here: only where the clock had no pass to write instead.
`canGrowBoard`	関数	Whether resizing is enabled and a larger native board is available.
`canPass`	関数	Whether passing is on offer: forced in a piece game with nothing to lay, free at any point in Go.
`canShrinkBoard`	関数	Whether resizing is enabled and a smaller native board is available.
`canSkip`	関数	Whether skipping is enabled and a legal corner stone can burn the turn.
`canSwapSeats`	関数	Whether the seat to play may trade seats right now.
`canTwist`	関数	Whether the colour to move owes a quarter turn before the move is complete.
`canUndo`	関数	Whether undo is enabled and a recorded move can be removed.
`CAPTURE_CHOICES`	定数	The free-choice and maximum-capture draughts modes.
`CaptureChoice`	型	Which capture a checkers-family player may choose, when more than one is on offer.
`capturePaths`	関数	The squares each capture has passed through so far, move by move, or null for a move that took nothing.
`Cell`	型	One intersection of the board: a stone, an obstacle, a hotspot, a wormhole, or nothing.
`cellAt`	関数	Read a cell from a valid zero-based board point; null means empty.
`centreSquares`	関数	The four centre squares, top-left first.
`checkersHasCapture`	関数	Whether any of `stone`'s pieces on the board has a capture available right now.
`CheckersRules`	型	How one game of the checkers family is played, as data: the rows of men each side sets out, which way a man may take, how far a king may travel, which capture must be chosen, and what crowning does to a capture under way.
`chooseColour`	関数	The deciding seat takes `stone`.
`ColourRules`	型	The rules one colour actually plays under: the variant's spec for that colour with the handicap laid over it.
`COLUMN_LETTERS`	定数	Column letters used in coordinate labels, left to right.
`columnLetter`	関数	Column letter, left to right: A, B, C ...
`createGame`	関数	Create an initial immutable position from native settings and an opening roll.
`CROWN_MID_CAPTURE`	定数	The supported promotion behavior during a capture chain.
`CrownMidCapture`	型	What becomes of a man that reaches the far row in the middle of a capture.
`DEFAULT_BOARD_SIZE`	定数	The default side length for an unconstrained board.
`DEFAULT_CAPTURES_TO_WIN`	定数	Enemy stones to capture for a win in the capture game: five pairs.
`DEFAULT_SETTINGS`	定数	The defaults used when creating a game without overrides.
`DEFAULT_SWAPS_PER_SEAT`	定数	The default seat-swap allowance for each player.
`defaultBoardFor`	関数	The board a game OPENS on, where nothing else has said: its own `defaultBoard` if it has one, else the first of its boards.
`DIRECTIONS`	定数	The four line orientations through a point.
`discCount`	関数	Count black and white discs currently on a board.
`DRAW_LIMIT_LIST`	定数	The selectable configured game-length limits.
`DRAW_LIMIT_MIN_POINTS`	定数	The smallest board a length means anything on, in points.
`DRAW_LIMIT_SHARE`	定数	The board fractions used by configured draw limits.
`DRAW_LIMITS`	定数	The shares of the board a game may be called a draw at.
`DrawLimit`	型	When a game nobody has won is called a draw.
`drawnByLength`	関数	Whether a finished game was drawn because it ran to its length, rather than because the board filled or both sides made a line at once.
`dropTarget`	関数	Where a stone dropped into `col` lands, or null when the column is full.
`emptyPoints`	関数	Every intersection still open: no stone, no obstacle.
`endedWithNoMoves`	関数	Whether the game ended because neither side had a move: two forced passes, the last two moves on the record.
`ENDGAME_COUNT_KINDS`	定数	The specific-ending and material-balance draw count modes.
`EndgameCount`	型	An ending that must be won within so many moves or it is a draw, once each player has made `movesEach` more moves inside it.
`EndgameCountKind`	型	The two shapes an endgame count is written in — see `EndgameCount`.
`endsOnItsOwn`	関数	Whether the rules alone guarantee this game ends.
`ENGLISH_CHECKERS_RULES`	定数	English draughts, American checkers: three rows of men, a man takes forward only, a king moves one square, any capture may be chosen, and a man crowned by a capture ends the move there.
`extendOpening`	関数	The chooser declines to choose and lays two more stones instead.
`findWinningLine`	関数	The winning line through `point`, if the stone there completes one under the rule that applies to its colour.
`FIRST_PLAYERS`	定数	The supported opening colours and random opener choice.
`FIRST_STONE`	定数	Black opens unless the settings say otherwise.
`FirstPlayer`	型	Who opens.
`flipsAt`	関数	The discs a stone of `stone` at `point` would turn.
`footprintAt`	関数	The absolute cells of an orientation anchored with its origin at `anchor`.
`footprintFits`	関数	Whether every cell of a footprint is on the board and empty.
`FORBIDDEN_PATTERNS`	定数	The named forbidden shapes checked by line games.
`forbiddenAt`	関数	Why `stone` may not play `point`, or null when it may.
`ForbiddenPattern`	型	Shapes a colour may be forbidden from making.
`forbiddenPoints`	関数	Every empty point the colour to move is forbidden from playing right now.
`forbiddenReason`	関数	Why the colour to move may not play `point`, when a forbidden shape is why.
`forfeitOnRecord`	関数	A missed turn, as the position the record will replay it to.
`forfeitTurn`	関数	Takes the turn away from the colour to move without a stone: the graceful penalty for a missed deadline.
`GAME_STATUS`	定数	The playing, won and drawn outcome labels.
`GameSettings`	型	Native rule, layout, opening, handicap and optional action settings.
`GameState`	型	The complete immutable position and its move history, seats and outcome.
`GameStatus`	型	Whether the game is playing, won or drawn.
`groupAt`	関数	The connected group of stones sharing the colour at `from`, and the empty points touching any of them — its liberties.
`growBoard`	関数	Returns the game on a larger board, or the state unchanged when it cannot grow.
`Handicap`	型	Extra restrictions one colour plays under, so a stronger player can give a weaker one a fair game.
`HANDICAP_RULES`	定数	The handicap toggles, in the order the settings list them.
`HandicapRule`	型	The toggles of a handicap, without the colour that carries them.
`HandicapTerms`	型	EVERYTHING THAT MAKES A GAME UNEVEN ON PURPOSE, as `hasHandicap` reads it: the per-colour handicap and the head start.
`hasFlipMove`	関数	Whether the colour has a legal disc-flipping move.
`hasHandicap`	関数	Whether any handicap is in force for anyone: harder rules for one colour, or a head start for one.
`HEAD_START_FREE_TURNS`	定数	The free turns a head start may give, none included.
`HeadStart`	型	A start given to one colour — the weaker player's — before the game is even.
`HeadStartTurns`	型	The most free turns a game offers as a head start: 0 where it offers none.
`HEX_LINE_DIRECTIONS`	定数	The three line orientations on the hexagon lattice — see rules/hexagon.ts for the embedding.
`Hot`	型	A hotspot: an intersection that counts as either colour's stone in a line.
`HOT`	定数	The cell marker that counts as either colour in a line.
`indexOf`	関数	Convert a board point into its row-major array index.
`inLayingPhase`	関数	Classic reversi: the first four discs are laid by the players, in the centre, with no flipping.
`inMovePhase`	関数	Whether the colour to move has all its pieces down and must now slide one.
`INTERNATIONAL_DRAUGHTS_RULES`	定数	International draughts, from the FMJD's official rules (Annex 1, 2018, and the 2024 Annexes).
`isDarkSquare`	関数	Checkers is played on one colour of square only: the board's own dark squares.
`isKingAt`	関数	Whether the piece at `at`, if any, is a king.
`isLegalMove`	関数	Whether the colour to move may play `point`: on the board, empty, allowed by the opening, not a shape the variant forbids that colour, the landing cell of its column in a drop game, and not while a twist or a slide is owed.
`isOnBoard`	関数	Whether both coordinates are within the square board.
`isStone`	関数	Narrows a cell to a played stone, excluding empties and obstacles.
`KOMI`	定数	Go: stones never move once played, and nothing about a line ever decides anything.
`landingPoints`	関数	The one landing cell per column with room: the only cells a drop can fill.
`lastMove`	関数	The point of the latest stone or piece move; null when no point was played.
`leavesNoStone`	関数	Whether a recorded move put nothing on the board: a pass, or a turn the clock took away.
`legalPoints`	関数	Every intersection the colour to move may play right now.
`LINE_RULES`	定数	The at-least, exact and open-exact winning line modes.
`lineDirectionsFor`	関数	The directions a winning line may run: the hexagon's three axes on a hexagon board, the square's four otherwise.
`LineRule`	型	What a completed line has to look like to win.
`longestPossibleGame`	関数	The most moves a game of these settings can contain, or null when nothing in the rules bounds it.
`Move`	型	A move rebuilt by the engine, including captures and other replay effects.
`MOVE_KINDS`	定数	The stable labels used in move records.
`MOVE_NARROWINGS`	定数	The reasons a move list is restricted to captures.
`MoveInput`	型	The shape of a move as a record or a request carries it, without the colour.
`MoveKind`	型	`place`: an ordinary stone.
`MoveNarrowing`	型	A rule that has narrowed the moves on offer below what the pieces could make: a capture that must be made, or carried on, instead of a step; or — where the game takes the most — the capture taking the most pieces, over shorter ones the pieces also have.
`movePiece`	関数	Slides a piece one step, or in checkers a step or a capture.
`movesBeforeDraw`	関数	How many moves may be played before a game nobody has won is a draw, or null when it is to be played out.
`mustPass`	関数	Whether the colour to move has nothing it may play.
`nextBoardSize`	関数	The next size up, or null when the board is already the largest.
`NO_HANDICAP`	定数	The default terms with no colour-bound rule restrictions.
`NO_HEAD_START`	定数	Nobody given a start: the even game, which is most games.
`NO_POINT`	定数	A pass has no point on the board.
`noBoundReason`	関数	What stops this game being bounded by its board, or null when nothing does.
`NoBoundReason`	型	Why a game has no bound, or null when the board is its bound.
`normaliseSettings`	関数	Settings that agree with their variant: a pinned line length wins over the player's choice, an opening the variant does not offer falls back to free, and a handicap rules out the openings that swap colours.
`OBSTACLE_LAYOUTS`	定数	The native empty and star-point obstacle layouts.
`ObstacleLayout`	型	`none`: every intersection is playable.
`OPENING_CHOICE_EXTEND`	定数	The one opening choice that is not a colour.
`OPENING_RULE_LIST`	定数	All supported opening identifiers in display order.
`OPENING_RULES`	定数	The stable identifiers for supported opening protocols.
`OPENING_STAGES`	定数	The stages of the opening protocol.
`OpeningChoice`	型	A decision taken during the opening: a colour, or two more stones.
`OpeningRule`	型	How the first stones go down.
`OpeningStage`	型	Where a swap-style opening stands.
`OpeningState`	型	The opening protocol stage, acting seat and recorded colour choices.
`orientations`	関数	Every distinct way the piece can lie: four rotations, each also mirrored.
`orientCells`	関数	The piece turned `turns` quarter turns and, if asked, mirrored — the shape a player has in hand.
`otherStone`	関数	The other stone colour.
`passesOwed`	関数	The position after every pass the rules force: none when the colour to move has something to play, one when only it is stuck, and two — ending the game — when neither side can move.
`passTurn`	関数	Takes a turn without a stone.
`Piece`	型	A piece from the queue: its cells relative to the top-left of its bounding box.
`PIECE_PREVIEW`	定数	How many queued pieces a player is shown ahead of the one in hand.
`PIECE_QUEUES`	定数	The domino and tetromino queue identifiers.
`PieceCell`	型	One cell of a multi-cell piece, with the colour it carries.
`pieceMoves`	関数	Where a piece of the colour to move may step from `from`; empty if it may not move.
`piecePlacements`	関数	Every legal footprint of the piece in hand.
`PieceQueue`	型	Which queue of pieces a game draws from.
`piecesHome`	関数	How many of `stone`'s pieces stand in the far camp.
`PieceTally`	型	A side's pieces, as an endgame count names them.
`Placement`	型	Where a stone goes when played.
`PLACEMENTS`	定数	The free, dropped and supported-edge placement modes.
`placePiece`	関数	Lays the piece in hand on `cells`.
`playMove`	関数	Plays the stone to move at `point`.
`Point`	型	Zero-based board coordinates.
`pointName`	関数	Renju-style name for an intersection, e.g.
`pointOf`	関数	Convert a row-major array index into board coordinates.
`POOL_CHECKERS_RULES`	定数	Pool checkers, from the American Pool Checker Association's Tournament Rules of Play (2016): men take both ways (rule 14), kings fly (15, 18), any capture may be chosen — "not compelled to take the greater or lesser number" (20) — and a capture once begun is completed (21).
`previousBoardSize`	関数	The next size down, or null when the board is already the smallest.
`quadrantCount`	関数	How many quadrants a board of this size holds.
`quadrantOrigin`	関数	The top-left corner of quadrant `quadrant`.
`queuedPiece`	関数	The piece the colour to move must lay next, or null outside the piece games.
`ReplayFacts`	型	What a replay needs to know about a record that its moves cannot say.
`replayGame`	関数	The position as it stands now.
`replayMoves`	関数	Replays a record through the engine: every position it passed through, including the ones a swap-opening decision produced.
`replayTimeline`	関数	Rebuilds every position a game passed through by replaying its moves.
`resign`	関数	Gives the game up.
`resolveOpener`	関数	The colour that opens.
`resolvePlacement`	関数	Where a stone played at `point` actually goes: the same point, or in a drop game the bottom of its column.
`rowNumber`	関数	Row number counted from the bottom edge, so the bottom row is 1.
`RULE_VARIANT_LIST`	定数	The variants in the order the browser and the filters list them.
`RULE_VARIANTS`	定数	The stable identifiers for all forty-eight rule variants.
`rulesFor`	関数	The rules a colour plays under: the variant's spec for that colour, with the handicap laid over it when the handicap belongs to that colour.
`RuleVariant`	型	The named rule sets.
`RUSSIAN_DRAUGHTS_RULES`	定数	Russian draughts (shashki), from the Russian Draughts Federation's rules (ФШР, shashki.ru) and the FMJD/IDF rules for 8×8 draughts: men take both ways, kings fly, any capture may be chosen whatever it takes (FMJD-64 4.13), and a man that reaches the far row in the middle of a capture is crowned there and carries on capturing as a king (4.14).
`scoreArea`	関数	The area score: every stone on the board, plus every empty region whose only neighbours are one colour.
`Seat`	型	The two people at the board.
`seatOf`	関数	The seat holding `stone` right now.
`SEATS`	定数	The first and second player seat labels.
`seatToPlay`	関数	The seat whose turn it is.
`SECOND_STONE_EXCLUSIONS`	定数	Half-widths of the central square a handicapped second stone must leave.
`SEED_RANGE`	定数	Seeds are 31-bit integers, small enough for every store and reproducible everywhere.
`seededRandom`	関数	A small seeded random number generator, so anything a game decides by chance — where the dead squares fall, which pieces come next — is fixed by the seed stored with the game and comes out the same on every replay.
`shrinkBoard`	関数	Returns the game on a smaller board, or the state unchanged when the ring that would be removed is in use.
`singlesLeft`	関数	Single stones the colour to move may still lay instead of a piece.
`sizeForVariant`	関数	The board this variant will actually be played on, given a size somebody asked for.
`skipMove`	関数	Burns the turn on a corner stone.
`skipTarget`	関数	Where a skipped turn puts its stone: the open intersection furthest from the action, picked from the corner chosen by `roll`.
`SlideMove`	型	What a record needs of a move to say whether it slid, jumped, or went on jumping.
`slideWord`	関数	A slide as the draughts records write it: square to square with an arrow, a capture with a colon (g5:e3), and a multi-jump as every square it landed on (g5:e3:c1).
`STAR_POINTS`	定数	Hoshi (star point) positions drawn on the board, by board size: the four corner points, plus tengen at the centre, and for 19×19 the side points too.
`STAR_RADIUS`	定数	How many rows deep each of the star's six points is.
`starCampOf`	関数	Whose home point `point` lies in, or null outside both.
`starCampSize`	関数	Pieces a side has: the cells of one point, ten on the standard board.
`starPiecesHome`	関数	How many of `stone`'s pieces stand in the far point.
`starSize`	関数	The side of the square array a star of this radius is embedded in.
`STARTING_DISCS`	定数	The fixed, laid or absent starting-disc layouts.
`StartingDiscs`	型	How a flipping game begins: nothing, the fixed four, or four the players lay themselves.
`Stone`	型	One of the two stone colours.
`STONELESS_WORDS`	定数	How a written move list says the two moves that have no point.
`stonelessWord`	関数	How a written record says a move with no point, or null for a move that has one.
`STONES`	定数	The black and white stone labels.
`stonesLeft`	関数	Stones the colour to move still has to place before the turn passes.
`StoredGame`	型	The stored shape of a game, as both the API and the pages see it.
`swapSeats`	関数	Trades seats: the player to move hands over their colour and takes the opponent's stones instead.
`TRADITIONAL_HEAD_STARTS`	定数	The traditional head starts, see TraditionalHeadStart.
`TraditionalHeadStart`	型	The head start a game's own tradition gives a weaker player, where it has one: Go's handicap stones on the star points, Othello's corners, and draughts' piece odds, the men taken off the stronger side before the start.
`TURN_CHOICE_KINDS`	定数	The piece-moving and stone-placement choice modes.
`TurnChoiceKind`	型	Whether a turn moves a piece already on the board, or places on a point.
`turnChoices`	関数	What the colour to move may do this turn — every piece that has a move, or every point that may be played — and whether a rule narrowed it.
`TurnChoices`	型	What the colour to move may do this turn, as the engine answers it — see `turnChoices`.
`turnPassedBy`	関数	The colour whose turn passed because it had no move, as the latest turn left the board — or null when nobody's did.
`Twist`	型	A quarter turn of one quadrant, which ends a move in the twist games.
`twistBoard`	関数	Turns one quadrant to finish the move.
`undoMove`	関数	Removes the last move, putting back anything it captured, a piece where it came from, and a twisted quadrant the way it was.
`upcomingPieces`	関数	The pieces after the one in hand, for the preview.
`VARIANT_SPECS`	定数	Every rule set, as data.
`VariantSpec`	型	One rule set, as data.
`WIN_LENGTH`	定数	Stones in a line needed to win, unless a variant pins it.
`WIN_LENGTHS`	定数	Line lengths a player may pick in the variants that leave it open.
`WIN_REASONS`	定数	The recorded reasons a game is won.
`winOnTime`	関数	Ends the game against a player who has run out of time.
`WinReason`	型	How a won game was won.
`Worm`	型	A wormhole: a line entering it comes out of its partner and carries on.
`WORM`	定数	The linked wormhole-cell marker.
`WRAP_MODES`	定数	The supported board edge-wrapping modes.
`WrapMode`	型	Which edges of the board join up: a plane, a cylinder, or a torus.

ソースを見る GitHub で編集@johnmorrisdotca/narabe 1.3.0 のソースから作成しました。

この日本語は、まだ日本語を母語とする方の確認を受けていません。訂正を歓迎します。