MBN - Modified Betza Notation

NOTE: This page is still under construction.

This page describes the modified Betza's notation system for piece movement capabilities. The original Betza notation is not complete enough for our purposes. But Betza notation was chosen as the basis for this proposed standard because it is well known and well established. This notation is called Modified Betza Notation because the old Betza Notation (also called "funny notation") is not completely valid under this new standard. Ralph Betza created a classification scheme for fairy chess pieces (including standard chess pieces) in terms of the moves of basic pieces with modifiers, and this modified notation is build for the classification of chess variants.

There exists some more enhanced versions of the Betza notation system, but none of them is sufficient in clarity, expressiveness, and unambiguousness.

Note that MBN is only useful in conjunction with FBR (Formalized Board Rules), it's not possible to define a chess variant only with the piece movements.

The advantage of the Betza notation is the readability for humans, but this notation is not useful for chess program implementation or computed equality comparison. Thus we will also give rules for a translation into a machine-friendly notation, which will also be useful for the equality comparison of pieces. This notation will be called ANCP (Algebraic Notation of Chess Pieces).

So MBN is fulfilling three purposes:

  • Readability for humans.
  • Mathematical exactness.
  • Completeness (from the point of view of a generic move generator).
  1. Prefixed Pieces
  2. Suffixed Pieces (Piece Groups)
  3. Promotions
  4. Drop Rules
  5. Base Moves
  6. Extended Base Moves
  7. Board Transition Operator
  8. Triagonal Move Operator (3D)
  9. Quadrogonal Move Operator (4D)
  10. Comment Operator
  11. Pieces in Orthodox Chess
  12. Castling
  13. Additional Pieces
  14. Macros
  15. Pieces in Hexagonal Chess
  16. Syntax of MBN
  17. Examples
  18. References

1. Piece definition

In MBN notation, a move component will be expressed in several parts:

  1. The piece letter used in game notation for this piece, followed by an equal sign (optinal). The piece letter should be an upper case letter. Instead of a single piece letter also a compound letter may be used, enclosed inside colons, e.g. :BM: (as an abbreviation for "Blind Monkey"). The compound letter should start with an upper-case letter. Note that compound letters are different only if the upper-case forms are different, e.g. :Be: and :BE: are equal. But :X: is different from the single letter X. The maximal length for compound letters is three.

    It is possible to define different moves for different colors. If the black piece has a different move, then lowercase letters will be used instead of uppercase letters. In this case only the black move will be defined.

  2. The second part following the equal sign is defining the move capabilities.

The second part is optional, but if the second part is not given, then the equal sign has to be ommitted. If a move notation consists only of a piece letter then it will move like the identically named basic piece. An example for a simple move notation is B, with the meaning that the piece denoted with letter B is moving like the bishop. The piece definitions B and B=B are equivalent. Note that combined piece letters do not have pre-defined movements, in this case the second part must be given.

Any piece definition is defining the movement from a start square to an arrival square. So far as not specifically changed with modifiers the arrival square must be empty, or may be occupied by an opponent piece, in the latter case this piece will be captured.

So far as not specifically allowed, the start square and the arrival square cannot be equal.

It is allowed to define the move capability for multiple pieces with one definition, but in this case the second part is mandatory. Example:


Both pieces P and S have the same movement.

2. Prefixed Pieces

It's possible to mark a piece with a prefix. These are the allowed prefixes:

  • Per default the prefix "+" denotes a promoted piece, based on the promotion rule for "+" (see FBR - Formalized Board Rules). Example:


    This is defining a promotion set of promoted piece +P. Promoting a piece is not changing the color of the piece. But if lowercase piece letters are used then this will force to change the color of the piece:


    The queen promotes to a queen with a different color (the queen will be flipped).


    This defines the move capability of the promoted piece +Q. If none of the rules, +Q==q, or +Q=QN is explicitly defined, then a default definition will be provided (see below). But if a promotion rule like +Q==q or +Q is specified, then the default definition is cancelled. But it's allowed to define explicitly both promotion forms: +Q==q, and +Q=Q. In this case the player has the choice which kind of promotion he likes to do.

    If the promotion for the black piece is different from the promotion of the white piece then define the different promotion explicitly, example:

    +P==Q +p==I

    It's also possible to use the piece +P without the explicit specification of a promotion rule, in this case a default promotion rule will be implicitly defined: the piece will promote to any of the other non-royal pieces.

    It's allowed to overwite the meaning of this prefix (+) in FBR.

    If both pieces P and +P are defined, for any (compound) piece letter P, then the promotion from P to +P is implicitly defined.

    Note that a piece like +Q exists if and only if an explicit move definition for this piece exists.

    It's allowed to define the promotion rule for multiple pieces with one definition:


    This is defining the promotion rule for the pieces K, L, W, N, C, and P.

  • The prefix "-" denotes a piece before promotion. With promotion the suffix will vanish. When prefix "-" is used the correspoding promotion rule is implicitly defined. Example from Checkers-Chess:

    -Q=fQ Q

    Before promotion piece -Q can only move forward, but after promotion it's the normal Queen Q. With the explicit notation -Q the promotion rule +-Q==Q is implicitly defined.

    It's allowed to overwite the meaning of this prefix (-) in FBR.

  • The prefixes "#", "*", "$", "%", and "&" can be defined in FBR for additional promotion rules (or other rules). Note that the use of a letter for promotions all the rules of letter "+" will also apply to this letter. One exception is the default promotion rule, with a prefix different from + the default promotion is the move capability of the un-promoted piece. Example:

    Q #Q

    Here the default definition is #Q=Q, this means that the piece #Q is inheriting the move capabilities of piece Q.

  • With prefix "?" a precondition rule will be declared. This precondition rule – defined as a move – must be fullfilled before the move has been performed, otherwise no move is possible – this means that this rule must match any possible move before the initial move has been done. Example:

    conversion# K #K==Q ?#K=[*]O

    The King will promoted to a Queen after it has moved, but only if the King is not checked, otherwise he has to remain a King at the end of his move.

    Note that a precondition rule don't has a default definition.

  • With prefix "!" a move definition can be canceled. Example:

    G=K+F02 +G=P !+G/DragonResurrection/

    The move definition for +G is not available if announcement DragonResurrection is active, so piece G will retain the original definition K+F02 when reaching the promotion zone (if announcement DragonResurrection is active).

  • The prefix "'" will be used for declaring side-movers. This prefix will be used additionally, and must precede any other prefix. The move of a side-mover is rotated by 90 degrees (clockwise). For example, a Pawn without double step capability can be defined as:


    This pawn is moving from bottom to top, and will promote on last rank (per default). If this piece is prefixed as a side-move, then it will move from left to right, and promotes on the last file. The piece 'P inherits all capabilities of piece P, but rotated by 90 degrees (clockwise).

  • The prefix "!" is cancelling any definition for the given (prefixed) piece.

A double piece letter prefix (without "'") can only occur when defining the promotion rule of a promoted piece to any other piece. This requires that the promoted piece is already defined. The default definition is the promotion of the promoted piece to un-promoted piece, example: ##Q==Q. Note that a piece with more than one prefix does not exists (except in combination with "'"), it's only used for a formal definition of the promotion rule.

Example from Alice Chess:

promotion#[1-8]=move Q=mQ+c{QRBNP}Q #Q=mQ+c{#Q#R#B#N#P}Q ##Q

The Queen Q will be defined (on board A). When moving the Queen (this is a promotion at the same time) it becomes the promoted piece #Q (now it belongs to board B), and moving again will promote the promoted Queen back to the Queen Q (on board A) – it becomes un-promoted. The definition ##Q is defining the un-promotion rule, per default the un-promotion is the piece before promotion.

3. Suffixed Pieces (Piece Groups)

For an improved readability pieces may have suffixes. A suffix is enclosed inside brackets ("<" and ">"), and should not have more than one alphanumeric letter (but it's allowed to be longer). Examples:

R<s>=[1-2](rW+(lR--[[a1]fR])) R<n>=[6-7](lW+(rR--[[g7]bR])) R<w>=[a-b](bW+(fR--[[a7]lR])) R<e>=[f-g](fW+(bR--[[g1]rR]))

A suffixed piece is defining an individual piece, so R<s> is different from R<n>. It is allowed to define a default movement for such a piece group:


This definition is the default for all suffixed pieces R. With R<l>=lR an individual move definition will be specified.

We need another special type of suffix for moves fulfilling an announcement, example:

+G +G/DragonResurrection/==+D

The promotion rule +G/DragonResurrection/==+D must be applied if and only if the annoucement "DragonResurrection" (see FBR) has been declared for this piece, otherwise the (default) promotion +G will be applied.

4. Promotions

A promotion rule has one of the following forms:

+<Piece> +<Piece>==<PieceSet>

The first form is the default promotion rule. Per default a piece may promote to any other piece except royal pieces. The second form expects a piece set for the definition, example:


In orthodox chess this is equivalent to the default promotion rule. The default promotion rule should be preferred, because of a better readability, it's more clear that any piece except royal pieces are available for the promotion.

It is allowed to omit the curly braces, and in general this shorter form will be used, example:


Note that promotion rules can also be defined for other prefixes than "+", but in this case the prefix has to be defined with board rule promotion.

5. Drop Rules

A drop rule has this form:




Black has to drop his King, then White has to drop his King, then Black has to drop a Winding General (W), and at least White has to drop the Storm General (S).

Note that the piece prefix (here "$") will be declared with board rule pieces (see attribute minimum).

6. Base Moves

A (m,n) leaper is a piece that moves by a fixed vector between its start square and its arrival square, inside piece definitions this will be denoted as :m,n:. One of the ordinates is the absolute value of the vertical distance, and the other ordinate is the absolute value of the horizontal distance of the move. A leaper moves in the same way to capture or not to capture. Note that a leaper is called leaper because he is jumping. For non-jumping pieces later the sliders will be introduced.

The shorthand notations of basic leapers (the fourth column gives the algebraic notation):

O Zero :0,0: (0,0) Leaper leap(0,0)
W Wazir :0,1: (0,1) Leaper leap(0,1)
F Ferz :1,1: (1,1) Leaper leap(1,1)
D Dabbaba :0,2: (0,2) Leaper leap(0,2)
N Knight :1,2: (1,2) Leaper leap(1,2)
A Alfil :2,2: (2,2) Leaper leap(2,2)
H Threeleaper :0,3: (0,3) Leaper leap(0,3)
C Camel :1,3: (1,3) Leaper (old notation is L) leap(1,3)
Z Zebra :2,3: (2,3) Leaper (old notation is J) leap(2,3)
T Tripper :3,3: (3,3) Leaper (old notation is G) leap(3,3)

The zero leaper O has a special meaning. If used, it allows explicitly to reach the start square (with a null move).

Important note: the first ordinate must be less or equal to the second ordinate, i.e. (4,2) is not a valid notation, instead (2,4) has to be used. We need this condition for a proper mapping into ANCP.

The table above corresponds to the following table of movements (jumps). The positon of the leaper is designated with the Zero leaper.



A rider is a piece that can move an unlimited distance in one direction, providing there are no pieces in the way.

There are three riders in orthodox chess: the rook can move an unlimited number of (0,1) cells, and is therefore a (0,1) rider; the bishop is a (1,1) rider; and the queen is a combined (1,1) and (0,1) rider.

Sliders are a noteworthy special case of riders which can only move between geometrically contiguous cells (sliders are not jumping). All of the riders in orthodox chess are examples of sliders.

A rider with unlimited distance will be notated with a suffixed zero. In this way the notation for the bishop is F0.

Note that an unlimited rider may reach the start square, and a given square may be visited more than once. But an unlimited rider stops before it will reach the same position twice.

Maximal Riders

We have a special notation for moving the maximal number of possible squares: 0* (zero star). Example: the slider B0* moves to the forward-most square, this means that it moves forward until it is bumping with a friendly piece, or until it is capturing an enemy piece, or until the end of board is reached (when board is not cyclic), or one step before the start square will be reached (avoids infinity); note that the latter condition voids zero-leapers.

Limited Riders

The limited rider is suffixed by a number (greater than zero) that is restricting the number of steps. For example, W3 is a slider restricted to maximal three steps.

It's also possible to specify an exact number of cells. In this case the number of steps will be prefixed with a zero. For example W03 specifies a slider which moves exact three steps. And with suffix 00 we have a null slider (equal to O).

Note that a limited rider may reach the start square, and a given square may be visited more than once.

Edge Riders

Another special notation is * (star, not zero star), denoting an edge rider, which moves to the end of the board (even if the board is cyclic). If a move is starting at an edge square, then this move is going to an edge square in a different cardinal direction. Example: B* is moving to any edge square, if it starts at square c1, then the move will end either on square c3 or h6, provided that all intermediate squares are unblocked. And the move W*, starting at square c1 (south), will move either to a1 (west), h1 (east), or c8 (north).

Note that in 2D Chess a move to an edge square could also be defined as B0[a,h,1,8], but this does not work for 3D/4D Chess.

Piece Set

A piece set will be expressed as an enumeration of (compound) piece letters inside curly brackets, for instance {ABC:C:} is a piece set containing the pieces A, B, C, and :C:. It is also possible to define a set which matches all pieces that is not in the piece set, for instance {^AB} is matching all pieces but not A, nor is it matching B. Hence {^} is a shorthand denoting all pieces.

We need a definition for a sequence of piece sets (especially for the support of macros). A sequence will be combined with intersection. Example: k{KQ}(K+k{K}N) is equivalent to k{KQ}K+k{K}N, and k{Q}(K+k{K}N) is equivalent to k{Q}K+N), because k{} is a void modification.

If a piece set is used as a prefix (before any modifier) then it means: do this move only if the start square is attacked by any of the pieces in this piece set. Example:


If the current square of the King is attacked (checked) by a Chancellor (C) then the King has the choice to make an escape move: move the King two squares in any direction instead of its usual one square.

In general the piece set includes the pieces of both colors. We define two special forms for the definition of piece sets restricted to one color: {!QRBN}, {!qrbn}, and {!Qb} the first form contains only friendly pieces, the second form only contains enemy pieces, and the third form contains a mix of friendly and enemy pieces (friendly Queen, and opponent Bishop).


The pawn can make a "Bocksprung", it hops over a friendly (and only over a friendly) pawn.

Grouping Operator

This operator is used to group move components by placing parenthesis around them. (A) is the same as A, but visually easier to understand when longer notation strings are required. For chained and combined moves (see below) grouping is a must to have.

In ANCP we are using the same grouping operator.

Combining Operator

A+B indicates the piece can move as A or B. We allow the shorthand AB, this means that the operator sign can be omitted, but in general the move may be easier to visualize when not omitting the operator sign. And there is a difference between both forms if modifiers are involved, see below.

Some pieces can be described with as combined leaper, i.e. as pieces having movement capabilities of multiple leapers. A king in orthodox chess is, as far as only its movement is concerned without taking into account check restrictions and castling capabilities, an example of a combination of F ((1,1) leaper) and W ((0,1) leaper), shortly written WF (of course, it could also be written as FW).

The grouping operator has a higher precedence than the combining operator.

Here is the formal definition for combined pieces without the use of an operator sign (for any moves P and Q):

PQ := (P+Q)

The parentheses are important. Note that this definition implies a special difference between PQ and P+Q in relation to modifiers:

mPQ = m(P+Q) = mP+mQ (for any modifier m)

This is not equivalent to mP+Q, because in latter case the modifier m only applies to P, but not to Q.

Modifier Prefixes

The move capabilities described with (a combination of) leapers can be specified more exactly with the use of modifiers. At first we will define the directional modifiers:

vvertical (forward and backward)
ssideward (left and right)
dany direction
tmakes a turn

The modifiers d, t, and z are useful for succeeding legs in chained moves (will be defined later).

Note that for F ((1,1) leaper) and N ((1,2) leaper) the notation for a direction is complicated, so the tables below will give more clearness. In case of amalgamated direction modifiers the first letter will belong to the shorter directional path (e.g. 1 step diagonally in case of an (1,2) leaper), and the second letter belongs to the wider directional path (e.g. 2 steps orthogonally in case of an (1,2) leaper).

LF lf lf f rf rf RF
fl LF lf f rf RF fr
fl fl LF f RF fr fr
l l l r r r
bl bl LB b RB br br
bl LB lb b rb RB br
LB lb lb b rb rb RB
LF ff ff f ff ff RF
ll LF ff f ff RF rr
ll ll LF f RF rr rr
l l l r r r
ll ll LB b RB rr rr
ll LB bb b bb RB rr
LB bb bb b bb bb RB
f sf sf f sf sf f
fs f sf f sf f fs
fs fs f f f fs fs
s s s s s s
bs bs b b b bs bs
bs b sb b sb b bs
b sb sb b sb sb b
LV lv lv v rv rv RV
vl LV lv v rv RV vr
vl vl LV v RV vr vr
l l l r r r
vl vl LV v RV vr vr
vl LV lv v rv RV vr
LV lv lv v rv rv RV
v sv sv v sv sv v
vs v sv v sv v vs
vs vs v v v vs vs
s s s s s s
vs vs v v v vs vs
vs v sv v sv v vs
v sv sv v sv sv v
s/v v v v v v s/v
s s/v v v v s/v s
s s s/v v s/v s s
s s s/v s/v s s
s s s/v v s/v s s
s s/v v v v s/v s
s/v v v v v v s/v
l/f f f f f f r/f
l l/f f f f r/f r
l l l/f f r/f r r
l l l r r r
l l l/b b r/b r r
l l/b b b b r/b r
l/b b b b b b r/b
LF means: lf or fl.
RF means: rf or fr.
LB means: lb or bl.
RB means: rb or br.
LV means: lv or vl.
RV means: rv or vr.

Note that amalgamated modifiers has to be parenthesized, otherwise it's a combination of modifiers. For example fsW is combining the modifiers and can also be expressed as fW+sW. So the expression lfW is a Wazir moving left or forward. For a Wazir moving left in forward direction we have to use (lf)W, here (lf) is amalgamated, and not combined, and in general (lf) cannot be replaced with (lf). But the parentheses for amalgamated modifiers can be omitted when a doubled directional modifier letter will be used; example: (ff)N can also be expressed as ffN, because here it's clear that this cannot be a combination. This has the consequence that doubled directional modifier letters will always be interpreted as an amalgamation.

In succeeding chapters we do not differantiate between directional modifiers and amalgamated directional modifiers.

About directional modifier z (reflection): this is doing a reflection and changes the direction accordingly. If the last move can be described with vector (α β), then the succeeding move (prefixed with z) will be either (-α β), if last move was a sidewards move, or (α -β), if last move was a vertical move. For instance this will be useful for the description of the Boyscout (Crooked Bishop), B=F-[(zF)0], that goes a zig-zag line.

The directional modifier t is defining a turn. If the last move can be described with vector (α β), then the succeeding move (prefixed with t) will be (-α -β).

If the succeeding move has to be completely independent from predecessing move then modifier d will accomplish this.

There are also prefixes to restrict what the move can do. For completeness the following table also includes the directional modifiers. (Note that this table covers the full alphabet.)

a All means: move or capture. This is useful when we want to restrict either the move-only or the capture-only capability with an suffixed piece set. This modifier allows moving and capturing anyway, and cannot be superseeded.
b This is the directional modifier for going backwards.
c Capture only, but do not move (only). The set of captured pieces can be restricted (or extended) to a piece set following the prefix. Per default all opponent pieces can be captured. A doubled modifier (cc) allows capturing of friendly pieces, but not the capturing of enemies. And if suffixed with y (cy) all pieces, inclusively friendly pieces, can be captured. This modifier can be declared as optional, but this is only useful if combined with a following piece set.
d This is the directional modifier for going any direction.
e In conjunction with c: capture en passant. If doubled (ee) then this is capturing en passant only. If not doubled, then allowing en passant is an addition (to capturing). A piece set may follow, defining the pieces which can be captured en passant (default is: this piece themself, in general a Pawn). In conjunction with m: this move allows capturing en passant by the opponent.
f This is the directional modifier for going forward.
g Defines a leaping slider. This means it moves like the given slider, but it is jumping (leaping) instead of sliding. When doubled (gg) then it can leap over friendly pieces, but not over enemy pieces. A following optional piece set is restricting a leap, only the pieces given in piece set can be leaped (the default piece set is the set of all pieces).
h Defines a halfling, that moves half the way to the edge of the board, rounded up (see Halflings).
i Only the initial move of this piece has this capability. If doubled (ii), then the initial move possibility will decay with the first check to this royal piece, and will decay with a drop move, and with promotion (this means that i applies for dropped pieces and promoted pieces, but in this case ii does not apply).
j This modifier is useful for jumps over hurdles. In fact for jumps a chain must be used, because modifier j means: move to any opponent piece, but without capturing (visit a piece). Either a succeeding leg is required for the destination square, or the setup operator (!) is defining a different destination square, or a capture/swap will be done, or this piece will suicicde. The jump can be restricted to a set of pieces following the prefix. This modifier is provided for defining complex jumps, in general modifier p is a useful shortcut for simple jumps. When doubled (jj) any friendly piece will be visited, but no enemy pieces. And if suffixed with a y (jy) then any piece (friendly or enemy) may be visited. This modifier can be declared as optional. It is important to note that this modifier allows royal pieces to cross checked squares, when moving to, or moving from visited square (see example below).
k This piece cannot give check. If doubled (kk), then it can give check, but cannot give immediate mate. This can be restricted to a piece set following the prefix.
l This is the directional modifier for going left.
m Move, but not capture. This can be restricted to a piece set following the prefix. This modifier can be declared as optional, but this is only useful if combined with a following piece set.
n This defines a non-jumping piece, a leaping rider will become a sliding rider. But note that in some variants the order of the decomposed legs is determined, in this case this modifier is not working.
o This modifier makes the move cylindrical. Cylindrical pieces do not stop at the left or right edge of the board. This modifier can be followed by board range, defining the connected files. If doubled (oo) also the top and bottom edges of the board will be connected.
p Must hop over any single hurdle, the hurdle can be anywhere in the path. When doubled (pp) it must hop over any number of hurdles (but at least one). An optional piece set following the modifier is restricting the hurdles. This modifier is redundant, but allows in most cases shorter definitions than with modifier j. This modifier can be declared as optional.
q (still unused)
r This is the directional modifier for going right.
s This is the directional modifier for going sidewards (left or right).
t The piece makes a turn, this means that it moves into the opposite direction as in the previous move. But when doubled (tt) then it means: the piece don't makes a turn (excludes a turn).
u The piece can move only if all move directions are unblocked, this means that no enemy piece is blocking this piece in one of the moving directions (this implies that the piece cannot capture the enemy piece).
v This is the directional modifier for going vertically (forward or backward).
w Instead of capturing this piece it will swap the piece, the position of the piece at destination square will be swapped with the piece at starting square. Because the piece will not be removed it's also possible to swap with royal pieces. If doubled (ww) then swapping will be done only with friendly pieces. And if suffixed with y (wy) then swapping can be done with all pieces. An optional piece set following the modifier is defining the pieces that can be swapped. This modifier can be declared as optional.
x This modifier flips an enemy piece to a friendly piece. When doubled (xx) then it will flip a friendly piece to an enemy piece. If suffixed with y (xy) then it will flip any piece (friendly or enemy) into an opposing piece.
y (This is not an autonomous modifier, it will be used as a suffix with the meaning: any.)
z This is the directional modifier for a reflection; useful for the definition of zig-zag lines, or reflecting bishops.

If a (doubled) modifier is suffixed with an exclamation mark (?), then this modification is optional. Example:


The Bishop may hop over any number of pieces, including zero pieces (the latter is a slide), but it cannot hop over another Bishop.

Declaring a modifier as optional is only allowed if this is explicitly specified in table above.

Some examples:

mfW Move one step forward, but do not capture (pawn move onto a free square).
W-fF This is the Horse in Xiangqi, it's a non-jumping knight. Note that we cannot use nN, because this definition would also allow the move j(F-fW).
imefW02 Move 2 steps forward, but only if this piece did not yet move (e.g. double step of pawn), and allow the opponent to capture en passant.
cefF Move one step diagonal and capture, this also allows en passant capture, like a pawn in orthodox chess.
wK Move to any adjacent square. If this square is occupied, then move the piece at destination square to the start square. This is the Guard in Maxima.
c{L}RB Allows to move like a rook or like a bishop, but only if this move is capturing opponent piece L.
ac{^C}p{^C}R This piece (a Cannon in Janggi) cannot hop over another Cannon, and it cannot capture another Cannon. Here the combination of a (move or capture) and c (capture only) makes sense, because we need to exlude the Cannon from the set of captured pieces.
ce{PS}fF Additionally allows en passant capture of the pieces specified with piece letters P and S, like a pawn in Wolf Chess.
ffN Move one square forward followed by one square diagonally forward to a square that is either empty or occupied by an opposing piece, jumping over any intervening piece of either side in the first square.
WF+iiN This royal piece moves like a King, but additionally has the right to make one knight-move during the game, provided that he hasn't been checked before he makes his knight-move.
!c{R}R Remove one enemy rook which is reachable in any orthogonal direction with a sliding rook move, but without leaving the position (don't move).
K[1-5]+!cj{K}Q Move like a King, but don't cross the river (between rank 5 and 6), and don't allow that the Kings will face each other across open lines. (This works if the King is a royal piece, and cannot be exposed into check).
nCZ Moves like a Camel or a Zebra, but as a slider. This is generating multiple paths: in the sense that it can reaches all squares reachable by King could reach in three moves that cannot be reached by R, B or N in a single move. A King would always need three steps to reach the Falcon destinations, (one diagonal and two straight, or two diagonal and one straight), but it can always do so in three ways, depending on the order of the straight and diagonal steps. This piece must follow the path a King could have followed, and if all the three paths are blocked, this piece cannot move to that destination.
o[b,g]B A cylindrical bishop move, but the b and g files are connected, this means that a bishop can move from g2 to b3, but it cannot act cylindrical if the piece is on file a or h.

Below we will translate all the given examples into ANCP:

leap(0,1)(1,2) & initial!:leap(1,2)

Range Operator

A move can be restricted to a range on the board. A range operator given before the move will restrict the range of the origin squares, and a range operator given after the move will restrict this move to the destination squares. A range operator is defining a set of squares, and will be defined inside brackets.

A compound square designator can denote more than one square. One type of compound square designator comprises a file designator followed by a rank designator. A file designator comprises either the name of a file or the names of two files separated by hyphens. A rank designator comprises either the name of a rank or the name of two ranks separated by hyphens. A three-character file designator denotes all the files inclusive between the files designated by its first and last characters. A three-character rank designator denotes all the ranks inclusive between the ranks designated by its first and last characters. A compound square designator can also comprise a sequence of square designators separated by commas. The set of squares so represented is the union of the sets of squares represented by each of the constituent square designators.

Sometimes it's easier to define a range with the help of the complement operator ^, example:


This defines the complement of the range [^a1,a8,h1,h8], this is the whole board except the edge squares.

And the empty range combined with the complement operator defines the whole board:


A square designation can be succeeded by an iterator designator, see this example:


The iterator is enclosed inside parentheses, the + operator is increasing file or rank, the - operator is decreasing file or rank, and the +- is increasing and decreasing. The first argument of the iterato apllies to the file, and the second argument applies to the rank. In our example the result is the range of all light squares.

We define some special ranges: [#] is denoting all edge squares, and [.] is denoting all inner squares. Note that an inner square has four neighbors in orthogonal directions, and an edge square has less than four neighbors. The notation [+] is the set of all threatened squares (an opponent piece giving 'check' (to any piece) at these squares, this means that pieces pinned on it's King are also threatening). [*] is denoting the set off all unthreatened squares (not attacked by any piece, even not attacked by pieces pinned on it's King), and [:] denotes the set of all squares occupied by unmoved pieces (not yet moved since start of game, equivalent to i modifier).

We need a definition for a sequence of ranges (especially for the support of macros). A sequence will be combined with intersection. Example: [1-4](K+[1]N) is equivalent to [1-4]K+[1]N, and [1-4](K+[5]N) is equivalent to [1-4]K, because []N is an empty move.

A board range can also be defined with the use of a piece set. In this case the board range containing all the squares attacked by one of these pieces is specified (see Piece Set).

The mapping of range operators into algebraic notation will be done with additional prefixes:

ƒ([Λ]Σ) := origin[Λ]:ƒ(Σ) ƒ(Σ[Λ]) := destination[Λ]:ƒ(Σ)

Examples of compound square designators:

[] denotes an empty set of squares, this can be useful in special cases
[a-c1] denotes the three squares a1, b1, and c1
[b3-5] denotes the squares b3, b4, and b5
[f-h6-8] denotes the squares f6, f7, f8, g6, g7, g8, h6, h7, and h8
[a1,c4] denotes the squares a1 and c4
[a-h1-2,a8,h8] denotes the first two ranks plus a8 and h8
[1-4] denotes the first four ranks
[1,8] denotes the first and eight rank
[#] denotes all edge squares
[.] denotes all inner squares

Example: The General in Xiangqi can move like a Wazir, but he cannot leave the palace: G=W[d-f1-3].

Example: The Cannon in Janggi can move like a leaping bishop, but only inside either palace (we have simplified the Cannon's move here):


Chaining Operator

A move can in general consist out of multiple legs, which could have arbitrarily different properties. So each leg is described using the full power of the basic Betza notation system, and that they are part of the same move is indicated by chaining them with a dash. The chain must thus be traversed as a whole, there can be no stopping half-way, and by default later legs go in the same direction as the previous one (like a rider). A Checker can be described as fcF-mF, where the first leg now is capture-only, allowed only when it can complete the chain by continuing to an empty square.

When chaining the directional modifiers will become a different meaning for all the subsequent legs. In notation W+(W-fW)+(W-fW-fW) the f means 'continuing forward', i.e. in the same direction, as directions are always measured relative to the previous leg. In the right-hand part of a chaining operator f is implied by default. To specify a bent trajectory, explicit directional prefixes are needed. Note that a bent chain can fork, and thus represent multiple moves.

Chaining implies that the intermediate square should be empty, so the move is capturing at most one piece. But this may specifically change, for example the move aW-fW may capture up to two pieces.

A chaining sequence cannot capture the same piece twice in this sequence, and it cannot swap (modifier w) with the same piece twice in this sequence.

Note that the dash operator has a lower precedence than the combination of moves, this means that fF+fcF-mF is equal to (fF+fcF)-(mF).

For the support of shorter piece definitions we define optional legs. If a leg is enclosed in brackets this leg is optional, this means it may belong to the whole move, or it may not belong to the whole move, it's a choice. Example:


This piece moves forward in any diagonal direction (forward left, or forward right) up to three squares, and this move is unblockable (jumps over any piece), and then it has the option to move like a bishop, but in same direction as prior leg. Note the capability of the first leg to capture depends on whether the last leg is involved or not.

We use another kind of optional legs. If a leg is enclosed in curly brackets, then this leg belongs to the move if the square is unblocked, and it does not belong to the move if the square is blocked. If the square is unblocked, then this move is compulsory. Example for a circular king:


For a better understanding of the explanation consider that this is equivalent to:


The first leg is a normal king move, the next moves are along a circular path 45 degrees in counter-clockwise direction, this means that a King starting at e3 may go along the path e3-d4-d5-e6-f6-g5-g4-f3-e3. But it stops before the next square is blocked (either the next square is occupied by a friendly piece, or the current square is occupied by an opponent piece). Whether the optional leg belongs to the move is not a choice, it depends on whether this leg is blocked or unblocked.

Chaining will be mapped into algebraic notation in this way:

ƒ(Σ12-...-Σn) := ƒ(Σ1) + ƒ(Σ2) + ... + ƒ(Σn)


W+(W-fW)+(W-fW-fW) ⟼ leap(0,1) & (leap(0,1) + leap!(0,1)) & (leap(0,1) + leap!(0,1) + leap!(0,1)) fmF+(fcF-mF) ⟼ move:leap!(-1,1)(1,1) & (capture:leap!(-1,1)(1,1) + move:leap!(-1,1)(1,1))

Sequence Operator

A--B indicates move A followed directly by move B, but not necessarily in the same general direction. This means that the sequence operator is like the chaining operator, but here the subsequent move is not implying the same direction as the preceding move, the directions are independent. This also means that the directional modifiers are not changing the meaning. For example the Double Knight (which makes a non-capturing knight move, followed by another knight move) would be represented as N--N (this is not the same as N02).

The sequence operator is only syntactical sugar if used for expressions not containing directional modifiers, for instance the expression N--N is equal to N-dN, but the idea of the directional independence is more easily to see.

But the sequence operator is not only syntactical sugar, consider this example:


The first leg moves one square in any direction, but the second leg moves only forward. This is equivalent to K-dfK, but this expression is more difficult to read.

We also support optional legs (both kinds) in sequences, in the same way as in chains. For instance, [K]--[K]--K is defining a piece which can step in any direction up to three times per turn. It can change direction after its first or second step, and it need not take all three steps. However it must stop when it captures. But this simple example could also be expressed with (dK)3 (see Complex Riders below).

Note that the chaining operator and the sequence operator have the same precedence.

The mapping of the sequence operator into ANCP is quite simple:

ƒ(Σ1--Σ2--...--Σn) := ƒ(Σ1) ++ ƒ(Σ2) ++ ... ++ ƒ(Σn)

Complex Riders

With the use of the grouping operator it's also possible to build riders based on modified leapers. A complex rider with suffix 0 will be unlimited, with any number greater than zero the rider will be limited, e.g. (pD)3 is limited to maximal 3 jumps. It's also possible to specify an exact number, in this case the number will be prefixed with a zero. A complex rider stops when a square is blocked, but this can be modified with the use of modifiers a and c.

For example (pmD)03 specifies a rider which jumps exact three times. This rider is not capturing pieces, but it would capture up to 3 pieces if defined with the a modifier: (paD)03. Note that the notation (pmD)03 is equal to pmD-pmD-pmD, this means that the subsequent legs will go in the same direction as the previous one unless directional modifiers are given.

For instance the multi-cpature part of the Monkey in Congo-Chess can be expressed as (dcK-mK)0 which defines: capture an enemy man on an adjacent square (orthogonally or diagonally) by jumping over it to the vacant square immediately beyond; as in international draughts, multiple captures are permitted with the same piece in the same turn. With the explicit given directional modifiers d the direction of each pair (dcK-mK) is independent from the previous one.

A complex rider will be resolved into a chain, thus it's possible to use the zero operator for optional arguments. Example:


This piece jumps over an arbitrary number of consecutive pieces of type X, inclusively a jump over zero pieces, before it moves as a Ferz.

Note that in general a complex rider can visit squares more than once, and it may reach the start square. But a complex rider cannot capture the same piece twice in a sequence, and a complex rider cannot swap (modifier w) with the same piece twice in a sequence.

Also for complex riders we allow the special 0* notations. Such a rider has to be applied the maximal number of times, but a square will not be affected (visited) more than once. A useful example is B--(dcK)0*: When the piece stops (any bishop move), *all* adjacent opposing enemy pieces will be removed from the board (this is like an explosion, but without affecting friendly pieces).

The mapping into the algebraic notation is straighforward:

ƒ(Σ0) := (ƒ(Σ))&×, if λ ∈ ℕ ƒ(Σλ) := (ƒ(Σ))&×λ, if λ ∈ ℕ ƒ(Σ0λ) := (ƒ(Σ))#λ, if λ ∈ ℕ

Circular Riders

A circular rider hat the following formal definition (for any piece P, and any directional modifier m):

(P)m0 := P-{(mP)0} (P)m0* := P-{(mP)0*}

The latter is a completed circular rider. Note that the parentheses are mandatory.

One example for a circular rider is the Rose. The Rose can be described as a circular Nightrider (N0). More specifically, the rose makes a series of continuous knight moves, except that unlike the Nightrider, which continues in the same direction, the Rose must make a 45 degree turn with each leap. Like the Knight, it can jump over intervening pieces, and like the Knightrider, each square it actually comes into contact with must be empty. Example: starting from e1, it moves along the path e1-g2-h4-g6-e7-c6-b4-c2-e1.


For completion we will define limited circular riders (for any piece P, any directional modifier m, and any number λ):

(P)mλ := P-{(mP)(λ-1)} (P)m1 := P

Setup Operator

Very useful is the setup operator, it allows to remove pieces (without doing a move), or to specify conditions after a move has been done. The setup operator will be denoted with !, and will be used as a prefix, preceding any modifier, and preceding any range operator. If encountered the first time it means: after doing the succeeding move(s) set this piece back to the setup square which is being occupied at the time the setup operator has been encountered (the setup square). And when encountered the next time, then it means: setup this piece (back to setup square), and after doing the succeeding move(s) also set this piece back to the setup square. Example:


Do a queen move, and then, if this is possible, do a single step into same direction, capture the opponent piece on this square, and step back; this is called capture by withdrawal (like in Fanorona Chess, or Ultima). In this simple case we could also use the expression mQ-{cK-tK}. Next example:


This is peforming an explosion, like in Atomic Chess. After the queen has captured an opponent piece, remove both pieces as well as all pieces (friendly and enemy) from adjacent squares. The 0* operator is doing a maximal iteration, until all possible squares have been visited. After each iteration step the queen will be setup to the square where the capturing has been done.

If the setup operator is used inside a conversion rule (see FBR), then a piece set containing exactly one piece type has to follow. Example:

conversion*=start Q*=!{X}0

After the queen has moved, the square, where the piece has just moved from, will be setup with piece X. Note that this square was empty, because the conversion will be applied after the piece has moved. And if this square was not empty (this is possible when the swap modifier has been used), then it will be replaced by piece X.

Note that this operator will be used like a modifier, but is has to precede any modifier.

Decision Operator

The decision operator (#) is designating a decisive move. Example:


Taking the opponent Chief (C) is the last move in this game, the game is won by side to move, because this capture is decisive.

Note that this operator will be used like a modifier, but is has to precede any modifier.

Conditional Operator

In a few variants a conditional operator is required. The condition is enclosed inside a pair of slashes, and the associated move can be applied only is the condition is fulfilled. A condition is a combination of a piece set and a board range. In case of a single piece the piece set curly brackets "{" and "}" can be omitted, and in case of a single square the board range brackets "[" and "]" can be ommited. Example:


If square a1 has a piece of type T on it, then piece H can move like a Wazir. If square a2 has a piece of type T on it, then piece H can move like a Dabbaba. The parentheses are only used for a better readability. This move definition can also be expressed as:


It's also possible to omit either the piece set, or the board range:


Piece H can only move if any piece of type T is no board.


Piece H can only move if square a1 is occupied by any piece.

7. Extended Base Moves

We allow the usage of extended base moves, for example :1,4: is a leaper that moves by a vector (1 4) between it's start square and arrival square. Note that the first ordinate must be less or equal to the second ordinate. More generally :α,β:, α ≤ β, defines a leaper that moves by a vector (α β).

For the basic moves the directional modifiers, especially the amalgamated directional modifiers, are specifically defined for all base moves. We have to extend this for extended base moves. See the following table:

We extend the definitions of the directional modifiers according to the rays in this table, this applies also to all other directional modifiers. For a mathematical definition see chapter Directional Modifiers on page ANCP.

8. Board Transition Operator

We need an extension for 3D, because in 3D chess we have more than one level (boards). In 2D chess we defined all the operations for X and Y axis, and in 3D chess we have to add an Z axis. Now a piece definition requires a board suffix (the Z axis) – so we don't have a clash with piece suffixes, a piece suffix always comes first. Boards will be numbered from 1 to N (N is number of boards). Any reference to a board will be enclosed inside brackets. More than one board can be referenced at once, with the use of comma-separated board numbers; for example <1,2> is referencing board 1 and board 2, this will be used as an abbreviation. The formal definition is (for any move M):

12,...,αk>M := Σ1iki>M

This definition will be extended for complex riders (for any number λ):

(<α12,...,αk>M)0 := Σ1ik (<αi>M)0 (<α12,...,αk>M)0λ := Σ1ik (<αi>M)0λ (<α12,...,αk>M)0* := Σ1ik (<αi>M)0* (<α12,...,αk>M)* := Σ1ik (<αi>M)*

We will also allow abbreviations like <+-1>, more generally (for any move M, and any numbers α, β):

<+-α>M := <+α,-α>M

Now an example of a piece definition for a three-board game:

C<2>=K+<1,3>O C<*>=K+<2>O

C<2> specifies the move capability for board number 2. <*> is a template definition for all boards, but a specialized definition (here C<2>) overrules any template definition. This means that in our example C<*> provides the definition for board 1 and board 3, for board 2 we have a specialized definition. In this example we may also use C<1,3> instead of C<*>.

Now we introduce board transitions. A piece may move to a different board, this move will be prefixed with a relational or an absolute destination board specification. See the example above, here on board 2 piece C can move one cell up (to board 1) or one cell down (to board 3). This can also be expressed with a relational expression: <+-1>; this also means, move one cell up or down. Whether moving up/down is leaping or sliding depends on the move description, the board transition only specified the destination board(s). With <+> we denote a transition to any other board. Note that the board transitions <+0> and <-0> are defining emptys moves.

Whether a relational board transition (like <+1>) allows moving from last board to first board (in this case the boards are cyclic) and vice versa depends on the board rules (see FBR). If the boards are not cyclic (the normal case) then a transition <-1> on first board (board number 0) is not a possible move. This means that in a two board game the definition Q<*>=Q+<+-1>O would define a Queen which will change the board after each queen move (whether the boards are cyclic or not).

The destination square (on different board) will be specified with the move description, example:


The piece H moves (or captures) to the middle board by making an unblockable move to a cell diagonally adjacent to the cell directly above or below it. Note that this is a direct move, the following is specifying an indirect move:


Moves (but not capture) one cell up/down, then make a diagonal move.

Now we will use a complex rider for a triagonal move:


Either move as a rook, or make a triagonal rook move. Note that a complex rider is a slider, so all intermediate squares have to be empty.

Symmetry on Z Axis (3D)

All the move definitions will be done from White's point of view, the black moves will be derived implictly with a reflection about the horizontal bisector of the board. In third dimension we don't have yet an equivalent, because here an implicit reflection is not wanted. So we need an explicit reflection about the bisector in Z plane, to accomplish this we use the <<>> notation, see this (simplified) example:

S<*>=mfW+<+1>mfW +S<5>=T

This defines a piece that can move forward, and it can go to higher level when moving. At last rank on highest level 5 it will promote. But in our example the black piece will also move forward (from Black's point of view), and it can go to lower level (to higher level from Black's point of view) when moving. At last rank on last level (first level from White's point of view) it will promote. The definition above is not working with black pieces, so we try to use two different pieces:

:WS:<*>=mfW+<+1>mfW +S<5>=T :BS:<*>=mfW+<-1>mfW +S<1>=T

This works, but from the human's point of view it's only one piece, and to have only one piece can be achieved if we use the explicit reflection:

S<*>=mfW+<<+1>>mfW +S<<5>>=T

This definition works for White and Black.

4D Chess

For 4D we have to add a further dimension – the W axis –, we are implementing this with a separator inside the curly brackets; for example <1;2> is referring the board which is number 1 in Z, and number 2 in W plane – following the chess conventions, the column (file) comes first. So a piece definition will be done like in the following example:

C<1;1>=F0+<+-1;+-1>O C<1;2>=F2+<+-1;+-1>O C<1;3>=F3+<+-1;+-1>O C<2;1>=F4+<+-1;+-1>O C<2;*>=F5+<+-1;+-1>O C<*;*>=F6+<+-1;+-1>O

In this example <*;*> is a template defining the moves of piece C for all boards. <2;*> is specialising the move definition for all boards in plane W, and the moves for the boards <1;1>, <1;2>, <1;3>, and <2;1>, are explictly defined.

We have to complete the definition of abbreviatons like <1,2;1,2> for 4D (for any move M, and any number λ):

12,...,αm12,...,βn>M := Σ1im;1jnik>M (<α12,...,αm12,...,βn>M)0 := Σ1im;1jn (<αik>M)0 (<α12,...,αm12,...,βn>M)0λ := Σ1im;1jn (<αik>M)0λ (<α12,...,αm12,...,βn>M)0* := Σ1im;1jn (<αik>M)0* (<α12,...,αm12,...,βn>M)* := Σ1im;1jn (<αik>M)*

For any positive numbers α, β: <α;> is a move in plane Z (axis W is fixed), and <;β> is a move in plane W (axis Z is fixed).

Similar to 3D chess <+-1;+-1> is an abbreviation for <+1,-1;+1,-1>, more generally (for any positive numbers α, β, and any move M):

<+-α;+-β>M := <+α,-α;+β,-β>M

Note that <+0;+0>, <+0;-0>, <+0;-0> and <-0;-0>, are defining empty moves.

Symmetry on Axes (4D)

The explicit reflection about W axis will be done similarly to 3D: <α;<β>> will derive the black moves with a reflection about the W axis. A reflection about the Z axis will be expressed as <<α>;β>. And a reflection about both axes has the syntax <<α;β>>. Note that <;<β>> is equivalent to <<;β>>, and <*;<β>> is equivalent to <<*;β>> (the same applies if we swap the axes).

Two examples: <<*;4>>, is denoting the last row in any column from White's point of view, hence implicitly this is also denoting the last row in any column from Black's point of view (row 1 from White's point of view). And <<;+1>> moves one row forward, but a black piece is moving one row backwards from White's perspective.

9. Triagonal Move Operator (3D)

The operator <>, applied to a leaper, has the following formal definition:

<>:α,β: := <+-α>gW0β+<+-β>gW0α

If we apply this to leaper N, then we get:

<>N = <>:1,2: = <+-1>gW02+<+-2>gW01 = <+-1>gW02+<+-2>gW = <+-1>gD+<+-2>W

This is a triagonal knight move, so this operator generates triagonal moves for basic leapers.

Now we extend the definition for riders (for any number λ):

<>:α,β:0 := (<+-α>gW0β)0+(<+-β>gW0α)0 <>:α,β:0λ := (<+-α>gW0β)0λ+(<+-β>gW0α)0λ <>:α,β:0* := (<+-α>gW0β)0*+(<+-β>gW0α)0* <>:α,β:* := (<+-α>gW0β)0*+(<+-β>gW0α)*

Proof this with concrete riders, at first B=F0 (bishop move):

<>B = <>F0 = <>:1,1:0 = (<+-1>gW01)0+(<+-1>gW01)0 = (<+-1>gW01)0 = (<+-1>gW)0 = (<+-1>W)0

The result is a triagonal bishop move.

And now we proof R=W0 (rook move), remember that the board transitions <+0>, and <-0>, are defining empty moves, and suffix 00 is defining a null slider (equal to O).

<>R = <>W0 = <>:0,1:0 = (<+-0>gW01)0+(<+-1>gW00)0 = (<+-1>gW00)0 = (<+-1>O)0

The result is a triagonal rook move. The queen is the combination of rook and bishop, so based on the following definition (for any moves A and B):

<>(A+B) := <>A+<>B

we get a triagonal queen move with <⁣>Q.

Finally do a proof for P=mfW+cefsF+imefW02 (extended pawn move); note that for the mapping to 3D we need the additional movement sidewards (s).

<>P = <>(mfW+cfsF+imefW02) = <>mfW+<>cefsF+<>imefW02 = <>(mf):0,1:+<>cefs:1,1:+<>imef(:0,1:)02 = <+-0>gmfW01+<+-1>gmfW00+<+-1>gcefsW01+<+-1>gcefsW01+(<+-0>gimefW01)02+(<+-1>gimefW00)02 = <+-1>gmfW00+<+-1>gcefsW01+(<+-1>gimefW00)02 = <+-1>mO+<+-1>cefsW+(<+-1>imO)02 = <+-1>mO+<+-1>cfsW+<+-2>imO

Now we have a triagonal pawn move. But in some 3D variants the move <+-1>cfW is not allowed for pawns, here the pawn movement has to be expressed in a different way; see this example defining the pawn movement in 2D and 3D (it is using a macro – will be defined later):

@P=mfW+cesF+imefW02 P=P+cefF+<>P

It is clear that different pawn definitions – for example without double step capability – will work similarly:

<>P = <+-1>mO+<+-1>cfsW (if P=mfW+cfsF)

10. Quadrogonal Move Operator (4D)

We will define a quadrogonal move operator for leapers, similar to the triagonal move operator (note that 4d means "quadrogonal"):

<4d>:α,β: := <+-α;+-β>:α,β:+<+-β;+-a>:α,β:

Now we do a projection to 3D (note that 3d means "triagonal"):

<3d>:α,β: = <+-α;>:α,β:+<+-β;>:α,β:+ <;+-α>:α,β:+<;+-β>:α,β:+ <+-α;+-β>:0,α:+<+-β;+-α>:0,α:+ <+-α;+-β>:0,β:+<+-β;+-α>:0,β:

And this will be projected to 2D (note that 2d means "diagonal"):

<2d>:α,β: = <+-α;+-β>O+<+-β;+-α>O+ <;+-α>:0,β:+<+-α;>:0,β:+ <;+-β>:0,α:+<+-β;>:0,α:

The four-dimensional operator will be extended for riders (for any number λ):

<4d>:α,β:0 := (<+-α;+-β>:α,β:)0+(<+-β;+-α>:α,β:)0 <4d>:α,β:0λ := (<+-α;+-β>:α,β:)0λ+(<+-β;+-α>:α,β:)0λ <4d>:α,β:0* := (<+-α;+-β>:α,β:)0*+(<+-β;+-α>:α,β:)0* <4d>:α,β:* := (<+-α;+-β>:α,β:)0*+(<+-β;+-α>:α,β:)*

It's easy to proof that this will give us the following three- and two-dimensional operators for riders (for any number λ):

<3d>:α,b:0 = (<+-α;>:α,β:)0+(<+-β;>:α,β:)0+ (<;+-α>:α,β:)0+(<;+-β>:α,β:)0+ (<+-α;+-β>:0,α:)0+(<+-β;+-α>:0,α:)0+ (<+-α;+-β>:0,β:)0+(<+-β;+-α>:0,β:)0 <3d>:α,β:0λ = (<+-α;>:α,β:)0+(<+-β;>:α,β:)0λ+ (<;+-α>:α,β:)0λ+(<;+-β>:α,β:)0λ+ (<+-α;+-β>:0,α:)0λ+(<+-β;+-α>:0,α:)0λ+ (<+-α;+-β>:0,β:)0λ+(<+-β;+-α>:0,β:)0λ <2d>:α,β:0 = <+-α;+-β>O+<+-β;+-α>O+ (<;+-α>:0,β:)0+(<+-α;>:0,β:)0+ (<;+-β>:0,α:)0+(<+-β;>:0,α:)0 <2d>:α,β:0λ = <+-α;+-β>O+<+-β;+-α>O+ (<;+-α>:0,β:)0λ+(<+-α;>:0,β:)0λ+ (<;+-β>:0,α:)0λ+(<+-β;>:0,α:)0λ

These definitions are working for diagonals. For orthogonal moves we define the following operator:

<3o>:α,β: := <+-α;>:0,β:+<;+-α>:0,β:+<+-β;>:0,α:+<;+-β>:0,α: <3o>:α,β:0 := (<+-α;>:0,β:)0+(<;+-α>:0,β:)0+(<+-β;>:0,α:)0+(<;+-β>:0,α:)0 <3o>:α,β:0λ := (<+-α;>:0,β:)0λ+(<;+-α>:0,β:)0λ+(<+-β;>:0,α:)0λ+(<;+-β>:0,α:)0λ <3o>:α,β:0* := (<+-α;>:0,β:)0*+(<;+-α>:0,β:)0*+(<+-β;>:0,α:)0*+(<;+-β>:0,α:)0* <3o>:α,β:* := (<+-α;>:0,β:)0*+(<;+-α>:0,β:)0*+(<+-β;>:0,α:)0*+(<;+-β>:0,α:)*

Now we proof our definitions for N (knight move):

<2d>N = <2>:1,2: = <+-1;+-2>O+<+-2;+-1>O+<;+-1>:0,2:+<+-1;>:0,2:+<;+-2>:0,1:+<+-2;>:0,1: = <+-1;+-2>O+<+-2;+-1>O+<;+-1>gW02+<+-1;>gW02+<;+-2>W+<+-2;>W = <+-1;+-2>O+<+-2;+-1>O+<;+-1>gD+<+-1;>gD+<;+-2>W+<+-2;>W

This is indeed the 2D knight move in 4D chess.

Now the 2D, 3D and 4D bishop moves:

<2d>B = <2d>F0 = <2d>:1,1:0 = (<+-1;+-1>O)0+(<+-1;+-1>O)0+ (<;+-1>:0,1:)0+(<+-1;>:0,1:)0+ (<;+-1>:0,1:)0+(<+-1;>:0,1:)0 = (<+-1;+-1>O)0+(<+-1;+-1>O)0+ (<;+-1>W)0+(<+-1;>W)0+ (<;+-1>W)0+(<+-1;>W)0 = (<+-1;+-1>O)0+(<;+-1>W)0+(<+-1;>W)0 <3d>B = <3d>F0 = <3d>:1,1:0 = (<+-1;>:1,1:)0+(<+-1;>:1,1:)0+ (<;+-1>:1,1:)0+(<;+-1>:1,1:)0+ (<+-1;+-1>:0,1:)0+(<+-1;+-1>:0,1:)0+ (<+-1;+-1>:0,1:)0+(<+-1;+-1>:0,1:)0 = (<+-1;>F)0+(<+-1;>F)0+ (<;+-1>F)0+(<;+-1>F)0+ (<+-1;+-1>W)0+(<+-1;+-1>W)0+ (<+-1;+-1>W)0+(<+-1;+-1>W)0 = (<+-1;>F)0+(<;+-1>F)0+(<+-1;+-1>W)0 <4d>B = <4d>:1,1:0 = (<+-1;+-1>:1,1:)0+(<+-1;+-1>:1,1:)0 = (<+-1;+-1>:1,1:)0 = (<+-1;+-1>F)0

This is also the expected result. Now the rook move:

<3o>R = <3o>W0 = <3o>:0,1:0 = (<+-0;>:0,1:)0+(<;+-0>:0,1:)0+(<+-1;>:0,0:)0+(<;+-1>:0,0:)0 = (<+-1;>:0,0:)0+(<;+-1>:0,0:)0 = (<+-1;>O)0+(<;+-1>O)0

11. Comment Operator

Comments are especially useful for the description of the piece letter. A comment is starting and ending with a vertical bar. Example:

B|Blue Whale|=vW+fF

A comment can be used everywhere, and may contain any character except vertical bars, even spaces (otherwise spaces are not allowed inside a notation string), but normally a comment will be used only for piece descriptions.

Note that in ANCP comments will be discarded.

12. Pieces in Orthodox Chess

Some more shorthand notations for well known pieces are predefined. The third column gives the algebraic notation.

P|Pawn|= mfW+cefF+[1-2]mefW02
move:slide!(0,1) & enpassant:slide!(-1,+1)(+1,+1) & rows[2]:move:slide!(0,2)
N|Knight|= N
B|Bishop|= F0
R|Rook|= W0
Q|Queen|= R+B
K|King|= W+F

The s modifier in Pawn definition is superfluous in 2D chess, but required for the use of triagonal and quadrogonal operators in 3D/4D chess. We are using [1-2]mefW02 instead of imefW02. The former definition is needed when used inside drop/switching chess variants, and it works for orthogonal chess. Moreover this definition avoids that the UFEN must specify the unmoved pawns.

13. Castling

MBN even allows to define the castling piece movements. Required for doing a castling move is that the initial square of the non-royal castling piece (in general the Rook) has the appropriate castling right. In general the initial square of the Rook left from King has the right for long castling, and the initial square of the Rook right from King has the right for short castling. We start with an example (for orthodox chess):

O-O=[*]isR[g]=isR[f] O-O-O=[*]isR[c]=isR[d]

Note that the castling rules above are the predefined castling rules. Remember that castling is possible only for pieces on a square with a castling right, so it's not required to withdraw these move definitions for variants without castling, but some chess variants may require different castling move definitions.

We have defined the castling movements for short castling – denoted as O-O – and long castling – denoted as O-O-O (big O's, not zeroes). Here the move definition includes the moves of both pieces, the royal piece (King) and the associate (Rook), respectively (the royal moves first). When castling short (long), here the King will move to the g-file (c-file), and the Rook will move to the f-file (d-file), this is fullfilling the Chess960 castling rules. Castling is possible only if both moves are possible. Note that both move definitions are expecting that the involved King and Rook didn't move before (usage of modifier i). Furthermore castling is not allowed if the King is in check (usage of [*]). The King cannot cross over or end on a square in which it would be in check (but this depends on the specific board rules), because the castling move of the King is sliding. If the castling move of the King is leaping than he can jump over attacked squares, but (in general) the end square must be unattacked. Because the castling move of the King is sliding, all the squares between the King and the destination square have to be unoccupied, but it is allowed that any of these squares are occupied by the associate (this means thet the associate is invisible when doing a castling move with the King). For the associate a similar rule applies: it may jump over the friendly King, although it is a slider (this means that the King is invisible when doing a castling move with the associate). This implicit rule allows simpler move definitions. Note that a piece is fulfilling the "i" modifier again after this piece has been dropped on the initial square. If you don't want to allow castling with a dropped piece then use modifier "ii".

It is important to note that a King move will be done before moving the Rook, so the definition for the Rook move is referring the position after the King has been moved.

Note that "short" castling (O-O) always means castling to right side, and "long" castling (O-O-O) always means castling to left side, even if these castling are neither short nor long (in orthodox chess it is short or long).

In some variants more than one associates are available for castling (but normally the castling right are specifying the associate). In this case the move definition is specifying the associate indirectly. Example: in variant Slide Shuffle the following definition will be used:

O-O=[*]irR=ip{k}lD O-O-O=[*]ilR=ip{k}rD

The associate is the piece which can hop as a Dabbaba over the king in opposite direction as the King has moved.

But if an indirect definition of the associate is not possible, or too complicated, then an optional piece set before first equal sign helps defining the castling for the specified piece.

We support another kind of castling, denoted with O-O-O-O. This will castle forward (vertically, not horizontally), in general with a promoted Rook. In this case the square of the associate will become the castle right with promotion to a Rook (in general this is possible only on the file of the King). This castling has no default definition, so it must be defined explicitly.

If a castling rule contains board transitions, then it is ensured that both pieces will be transferred to the same board, provided that both board transitions are identical.

14. Additional Pieces

For completeness some more shorthands will be defined, below is the complete table (full alphabet). The pieces in this table will also be called basic pieces.

A Alfil :2,2:
B Bishop F0
C Camel :1,3:
D Dabbaba :0,2:
E Empress RN
F Ferz :1,1:
G (old)Tripper T
H Threeleaper :0,3:
I Janus BN
J (old)Zebra Z
K King WF
L (old)Camel C
M Marshall WF
N Knight :1,2:
O Zero :0,0:
P Pawn mfW+cefF+[1-2]mefW02
Q Queen RB
R Rook W0
S Berolina Pawn mfsF+cefW+[1-2]mefF02
T Tripper :3,3:
U Universal Leaperg(WF)0
V Vizir BN
W Wazir :0,1:
X Explosion (!dcy{^P}OK)0*
Y Boyscout F-[(zF)0]
Z Zebra :2,3:

Some notes:

  • The letters G, J, and L, will be supported for compatibility with original Betza Notation, but t's recommended to use the new letters.
  • The "Boyscout" is also known as "Crooked Bishop".
  • "Camel" will also be called "Long Knight".
  • "Empress" is an alternative name for "Marshall", and "Chancellor".
  • "Janus" has some different names: "ArchBishop", "Princess", and "Equerry".

15. Pieces in Hexagonal Chess

In hexagonal chess variants the board will be mapped to a rectangular board with cartesian coordinates, see Hexagonal Board. For these surrogated boards we overwite the definition of the basic chess pieces K, Q, R, B, N, and P. We have to differentiate between vertically and horizontally oriented hexagonal boards. Note that the piece definitions are using the overwritten pieces (this means that R inside a move definition is denoting the overwritten Rook for hexagonal chess).

Horizontal Vertical
P Pawn mfF+imefF02+cesC mfD+imefD02+cefF
N Knight vC+s:1,5:+s:2,4: sC+v:1,5:+v:2,4:
B Bishop sC0+vD0 vC0+sD0
R Rook F0+sD0 F0+vD0
Q Queen R+B R+B
K King D+F+sC D+F+vC

Note that the triagonal and quadrogonal operators (currently) are not defined for hexagonal chess.

These are the default castling rules for vertically oriented boards (Shafran's Hexagonal Chess):

O-O=[*]ir(F02-[F])=ij{k}lF0-F O-O-O=[*]il(F02-[F])=ij{k}rF0-F

And here are the default castling rules for horizontally oriented boards (De Vasa's Hexagonal Chess):

O-O=[*]irD02=ij{k}lD0-D O-O-O=[*]ilD03=ij{k}rD0-D

16. Macros

Any single-letter piece used inside a move definition is always denoting one of the basic pieces. If the reference of a derived single-letter piece is desired then the use of a macro is required. One example:

I|Nightrider|=N0 Z|Amazon-Rider|=QI

This definition is wrong, because the Amazon-Rider is moving either as a Queen, or as a Nightrider, but the piece I refers to a basic piece (the Janus), not the Nightrider. This can be solved with a macro:

@:NR:=N0 I|Nightrider|=:NR: Z|Amazon-Rider|=Q+:NR:

Now the specification of Amazon-Rider is correct.

A macro is also useful as a shorthand for often used expressions.

The definition of a macro is quite simple, it's like a normal piece definition, but starting with an "at" sign. Note that a prefixed letter for the macro identifier is not allowed. But a macro name can have a suffix like a piece letter. It's not an error if any macro is unreferred, but in general this should be avoided. Note that a macro definition can refer other macro definitions.

It's also possible to use a single letter for the macro name, in this case this letter will be overwritten, but inside the macro still the basic piece will be referred by this letter. Example:

I|Nightrider| Z|Amazon-Rider|=QI @I=N0

Inside the definition of pieces I, and Z, now the macro for the Nightrider is referred, because the macro definition is overwriting the basic piece I.

The latter example also demonstrates that the set of rules is invariant considering the order of the definitions.

Any use of a macro will be dissolved textual, but after the macro has been dissolved (see "Technical Interpretation of Macros" below). So in Atomic Chess a piece movement with explosion can be expressed in the following way:

@X|Explosion|=(!dcy{^P}OK)** Q=mQ+(cQ--X)

Hence the queen movement definition will result to


because the macro X has been dissolved to (!dcy{^P}OWF)0*, due to definition of K.

Technical Interpretation of Macros

Before any piece definition will be interpreted, all the macro definitions have to be dissolved. See this simple example:

@I|Janus|=I J|Amazon|=I

This example will be dissolved step by step in the following way. First step:

@I=BN|basic piece letter I is defined as BN| J=I

Second step:

J=BN|macro I has been substituted with right side of dissolved macro I|

Because of these rules also the default definitions will be resolved with macro replacement. See this example:

@B=BW B +B

This is equivalent to:

@B=BW B=B +B=B

Piece B will be resolved to F0+W, the same applies to piece +B.

Piece sets and board ranges will not be dissolved, so macros will not replace piece letters inside piece sets. Example:

@C=(dWF)03 C=mC+c{C}C

This will be dissolved to:

@C=(dWF)03 C=m(dWF)03+c{C}(dWF)03

The piece letter in piece set {C} remains unchanged.

17. Syntax of MBN

Below the Backus-Naur Form of the Modifier Betza Notation is given. This definition does not include the definition of comments, comments are allowed everywhere inside the notation string. A parser will skip comments.

<MBN> ::= <Identifier> '=' <MoveDefinition> <Identifier> ::= ( '@' <MacroIdentifier> | <PieceIdentifier> ) <Suffix> <BoardIdentifier>? <PieceIdentifier> ::= [+-#*$%&]? <PieceLetter> <PieceLetter> ::= [A-Za-z] | ':' [A-Za-z] [A-Za-z0-9]? [A-Za-z0-9]? ':' <Suffix> ::= [A-Za-z0-9] [A-Za-z0-9]* <BoardIdentifier> ::= <3dBoardIdentifier> | <4dBoardIdentifier> <3dBoardIdentifier> ::= '<' <BoardNumbers> '>' | '<' '<' <BoardNumbers> '>' '>' <4dBoardIdentifier> ::= <4dBoardIdentifier1> | <4dBoardIdentifier2> <4dBoardIdentifier1> ::= '<' <3dBoardIdentifier> ';' <3dBoardIdentifier> '>' <4dBoardIdentifier2> ::= '<' '<' <BoardNumbers> ';' <BoardNumbers> '>' '>' <BoardNumbers> ::= '*' | <ListOfNumbers> <ListOfNumbers> ::= <Number> (',' <Number>)* <MoveDefinition> ::= <MoveSequence> <MoveSequence> ::= <OptionalMove> ( '-' '-'? <OptionalMove> )* <OptionalMove> ::= <CombinedMove> | '[' <MoveSequence> ']' | '{' <MoveSequence> '}' <CombinedMove> ::= <PartialMove> ( '+' <PartialMove> )* <PartialMove> ::= <MovePrefix> <BoardRange>? <ModifiedMove> <BoardRange>? <MovePrefix> ::= '!'? <BoardTransition>? <Condition>? <ModifiedMove> ::= <Attackers>* <Modification>* <Move> <Move>* <Attackers> ::= <PieceSet> <Move> ::= <ComplexRider> | <BasicLeaper> ( <Circular>? <Steps> )? <ComplexRider> ::= '(' <MoveSequence> ')' <DirectionalModifier>? <Steps>? <Steps> ::= '0' ( '*' | <Number> )? | '*' '*' | '#' | <Number> <Circular> ::= <Amalgamated> | '(' <Direction>+ ')' <BoardTransition> ::= <BoardTransition2> | <BoardTransition3> <BoardTransition2> ::= '<' <Transition> (';' <Transition>)? '>' <BoardTransition3> ::= <SingleTransition> (';' <SingleTransition>)? <SingleTransition> ::= <Transition> | '<' <Transition> '>' <Transition> ::= <RelativeTransition> | <AbsoluteTransition> <RelativeTransition> ::= '+'? '-'? <Number> <AbsoluteTransition> ::= <ListOfNumbers> <BasicLeaper> ::= [A-Z] <Modification> ::= <DirectionalModifier> | [aceghijkmnopquwy] <PieceSet>? <DirectionalModifier> ::= <Amalgamated> | <Direction> <Direction> ::= [bdflrstvz] <Amalgamated> ::= '(' <Direction> <Direction> ')' <BoardRange> ::= '[' '^'? <CompoundRange> ']' <CompoundRange> ::= <SingleRange> ( ',' <SingleRange> )* <SingleRange> ::= ( <FileRange> | <RankRange> | <SquareRange> ) <3dRange>? <4dRange>? <FileRange> ::= <File> ( '-' <File> )? <RankRange> ::= <Rank> ( '-' <Rank> )? <SquareRange> ::= <FileRange> <RankRange> <3dRange> ::= <3dLevel> ( '-' <3dLevel> )? <4dRange> ::= <4dRow> ( '-' <4dRow> )? <File> ::= <Number> <Rank> ::= [a-z] <3dLevel> ::= [A-H] <4dRow> ::= [1-8] <Number> ::= [0-9]+ <PieceSet> ::= '{' '!'? '^'? <PieceLetter>* '}' <Condition> ::= '/' ( <PieceSet> | <PieceLetter> ) ( <BoardRange> | <Square> ) '/' <Square> ::= <File> <Rank> <4dLevel>? <4dRow>?

Note that a piece notation is complete only if it can be dissolved to basic leapers. Example: @Y=fN :X:=Y02 :Y:=Y is complete, because it can be dissolved to :X:=fN02 :Y:=fN.

A technical note how to disambiguate the parsing of square brackets and curly brackets. After parsing '[' or '{', also parse until end of this parenthesized expression (until ']' or '}', respectively). If the opening bracket is either at start of expression, or preceded by '(' or '-', and if the closing bracket is either at end of expression, or succeeded by ')' or '-', then it's <OptionalMove>. In all other cases it must be <PieceSet> or <BoardRange>.

18. Examples

Some examples of complex piece types:

Short Rook

The Short Rook moves up to four squares in orthogonal direction.


This is a simple example, but in some sources here the definition R4 is used. In MBN this notation is wrong, because when dissolved this definition is nothing else than (W0)4, and this is equivalent to W0, a normal rook.


The Rampager moves up to three squares orthogonally, and may capture up to three pieces.


This examples shows the meaning of modifier all, in combination with complex riders. This modifier allows to capture an opponent piece with any single step from square to square. A definition like W3 only allows a capture at final destination square.

Flying Gold Cannon (Cannon Shogi)

The Flying Gold Cannon (:GC+:) can move any number of squares along any of the four orthogonal directions without capturing any piece (mR).

It may also jump one piece while moving on any row or column (pR), and may move one (F) or two squares diagonally, jumping the adjacent square to reach the second (pD).

Lion (Chu Shogi)

The Lion (L) can take a step in any direction up to twice per turn. It can continue after a capture on the first step, potentially capturing two pieces per turn. It can change directions after the first step, so that it can reach the squares that a knight jumps to in Western chess. By returning to its starting square with the second step, it can effectively capture a piece on an adjacent square without moving. It can step to an adjacent empty square and back without capturing anything; this leaves the board unchanged, effectively passing a turn: aK--[K] (this is equivalent to (adK)2).

The lion can jump anywhere that it could step to on an empty board; that is, anywhere within a distance of two squares. This is equivalent to jumping in any of the eight diagonal or orthogonal directions, or making any of the jumps of a knight in Western chess: ADN.

! ! !
! !
! ! !
Crocodile (Congo-Chess; 7x7 board)

(Definition: the 4th rank is called "river".)

The crocodile (C) moves and captures one step in any direction. It can also move and capture as a chess rook toward the river along a file (including entering the river), as well as down the river (rank) when in the river.

Dolphin (Whale-Shogi; 6x6 board)

The dolphin (D) can step one square forward; or, it can move any number of free squares diagonally backward, but only if it is in the farthest rank. ([1-5]fW+[6]bB)

Cannon (Janggi, 9x10 board)

The Cannon (C) moves by jumping another piece horizontally or vertically. The jump can be performed over any distance provided that there is exactly one piece anywhere between the original position and the target. But a Cannon may not jump over another Cannon. In order to capture a piece, there must be exactly one piece (friendly or otherwise) between the Cannon and the piece to be captured. The Cannon then moves to that point and captures the piece. But a Cannon may also not capture another Cannon. (a{^C}p{^C}R)

They may also move or capture diagonally along the diagonal lines in either "palace" (the squares [d-f1-3] and [d-f8-10]), provided there is an intervening piece in the centre. ([d-f1-3]a{^C}p{^C}B[d-f1-3]+[d-f8-10]a{^C}p{^C}B[d-f8-10])

4D Rook (TessChess)

The Rook in TessChess (4D) slides along orthogonals (R+<3o>R) or triagonals (<3d>B).


19. References

Google translation

Share this page

C/CIF at Sourceforge

C/CIF at Sourceforge

C/CIF at Launchpad

C/CIF at Launchpad