Simplified Boardgames

We formalize Simplified Boardgames language, which describes a subclass of arbitrary board games. The language structure is based on the regular expressions, which makes the rules easily machine-processable while keeping the rules concise and fairly human-readable.



There are no comments yet.


page 1

page 2

page 3

page 4


Regular Boardgames

We present an initial version of Regular Boardgames general game descrip...

Procedural Content Generation for GDL Descriptions of Simplified Boardgames

We present initial research towards procedural generation of Simplified ...

Hint Orchestration Using ACL2's Simplifier

This paper describes a strategy for providing hints during an ACL2 proof...

Language ASPf with Arithmetic Expressions and Consistency-Restoring Rules

In this paper we continue the work on our extension of Answer Set Progra...

Formalizing Traffic Rules for Machine Interpretability

Autonomous vehicles need to be designed to abide by the same rules that ...

Strategic Features for General Games

This short paper describes an ongoing research project that requires the...

Polygames: Improved Zero Learning

Since DeepMind's AlphaZero, Zero learning quickly became the state-of-th...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1. Introduction

Simplified Boardgames is a class of fairy-chess-like games, first introduced in [1], and slightly extended in [3] (see [2] for an alternative extension). The class was developed for the purpose of learning the game rules through the observation of plays. The Simplified Boardgames language describes turn-based, two player, zero-sum games on a rectangular board with piece movements being a subset of a regular language.

Here we provide a formal specification for Simplified Boardgames. Despite the fact that the class has been used in several papers, its formal grammar was still not clearly defined, and some issues were left ambiguous. Such a definition is crucial for further research concerning AI contests, procedural content generation, translations, etc. For comparison, Metagame system, which can be seen as Simplified Boardgames predecessor, had its grammar explicitly declared in [7].

2. Syntax and semantics

In this section we present the formal grammar for Simplified Boardgames, inspired by the look of training records provided by Björnsson in his initial work [1]. The grammar construction is also affected by our experiences concerning Simplified Boardgames, especially in the domain of procedural content generation. The version presented differs only slightly comparing to the versions used in [3, 4, 5].

2.1. Grammar

The formal grammar in EBNF is presented in Figure 1. C-like comments can appear anywhere in the game definition: “//” starts a line comment and every next character in the line is ignored. “/*” starts a multiline comment and every character is ignored until the first occurrence of “*/”.

<sbg> ::= ‘< <’ <name> ‘> >’ ‘<BOARD>’ <board> ‘<PIECES>’ <pieces> ‘<GOALS>’ <goals>

<name> ::= alphanumspace {alphanumspace}

<board> ::= <nat> <nat> { <row> }

<row> ::= ‘|’ {"[.a-zA-Z]"} ‘|’

<pieces> ::= { "[A-Z]" <regexp> ‘&’ }

<regexp> ::= <rsc> | <regexp> <regexp> | <regexp> ‘+’ <regexp> | ‘(’ <regexp> ‘)’ [<power>]

<rsc> ::= ‘(’ <int> ‘,’ <int> ‘,’ <on> ‘)’ [<power>]

<power> ::= ‘^’ <nat> | ‘^’ ‘*’

<on> ::= "[epw]"

<goals> ::= <nat> ‘&’ { <goal> ‘&’ }

<goal> ::= ‘#’ <letter> <nat> | ‘@’ <letter> <squares>

<letter> ::= "[a-zA-Z]"

<squares> ::= <nat> <nat> { ‘,’ <nat> <nat> }

Figure 1. Formal grammar for Simplified Boardgames game rules.

The start non-terminal symbol is “sbg”. The “nat” non-terminal stands for a natural number (thus a non-empty sequence of digits), while “int” stands for a signed integer (thus it is “nat” optionally preceded by “-”). The “alphanumspace” non-terminal generates all alphanumerical characters or a space.

2.2. Example

An exemplary game called Gardner111, formatted according to Simplified Boardgames grammar is presented partially in Figure 2. It is chess variant proposed by Martin Gardner in 1969 and weakly solved in 2013 [6] – the game-theoretic value has been proved to be a draw.

The starting position looks as in the regular chess with removed columns , , , and rows , , . The rules are those of classical chess without the two squares move for pawns, en-passant moves and castling. Additionally, as a countermeasure for not supporting promotions, our implementation provides additional winning condition by reaching the opponent’s backrank with a pawn.

<<Simplified Gardner>>
5 5
<PIECES>       // P - pawn, R - rook, N - knight, B - bishop, Q - queen, K - king
P (0,1,e) + (-1,1,p) + (1,1,p) &
R (0,1,e)(0,1,e)^* + (0,1,e)^*(0,1,p) + (0,-1,e)(0,-1,e)^* + (0,-1,e)^*(0,-1,p) +
  (1,0,e)(1,0,e)^* + (1,0,e)^*(1,0,p) + (-1,0,e)(-1,0,e)^* + (-1,0,e)^*(-1,0,p) &
N (2,1,e) + (2,-1,e) + ... + (-1,-2,p) &
B (1,1,e) + (1,1,p) + (1,1,e)^2 + (1,1,e)(1,1,p) + (1,1,e)^3 + (1,1,e)^2(1,1,p) +
  (1,1,e)^4 + (1,1,e)^3(1,1,p) + ... + (-1,-1,e)^4 + (-1,-1,e)^3(-1,-1,p) &
Q (0,1,e)(0,1,e)^* + (0,1,e)^*(0,1,p) + (0,-1,e)(0,-1,e)^* + (0,-1,e)^*(0,-1,p) +
  (1,0,e)(1,0,e)^* + (1,0,e)^*(1,0,p) + (-1,0,e)(-1,0,e)^* + (-1,0,e)^*(-1,0,p) +
  (1,1,e)(1,1,e)^* + (1,1,e)^*(1,1,p) + (1,-1,e)(1,-1,e)^* + (1,-1,e)^*(1,-1,p) +
  (1,-1,e)(1,-1,e)^*+(1,-1,e)^*(1,-1,p)+(-1,-1,e)(-1,-1,e)^*+(-1,-1,e)^*(-1,-1,p) &
K (0,1,e) + (0,1,p) + (0,-1,e) + (0,-1,p) + ...  + (-1,-1,e) + (-1,-1,p) &
100 &
@P 0 4, 1 4, 2 4, 3 4, 4 4 &
@p 0 0, 1 0, 2 0, 3 0, 4 0 &
#K 0 &
#k 0 &
Figure 2. The Simplified Boardgames version of Gardner.

2.3. Semantics

The game is played between two players, black and white, on a rectangular board. White player is always the first to move. The board size is given by the two numbers in the <BOARD> section, generated from “board” non-terminal, which represents the width and the height, respectively. Subsequently the initial position is given: empty squares are represented by dots, white pieces as the uppercase letters, and black pieces as the lowercase letters. To be considered as valid, there must be exactly height rows and width columns. Although it may be asymmetric, the initial position is given from the perspective of the white player, i.e. forward means “up” for white, and “down” for black.

During a single turn, a player has to make a move using one of his pieces. Making a move is done by choosing the piece, and change its position according to the specified movement rule for this piece. At any time, at most one piece can occupy a square, so finishing a move on a square containing a piece (regardless of the owner) results in removing it (capturing). Note that in the situation when the destination square is the starting one, the whole board remains unchanged. No piece addition is possible. After performing a move, the player gives control to the opponent.

The movement rules of available game pieces are declared in the <PIECES> section and generated from the “pieces” non-terminal. One piece can have at most one movement rule, which consists of the letter of the piece and a regular expression. A piece without the movement rule is allowed but cannot be moved. For a given piece, the set of legal moves is the set of words described by a regular expression over an alphabet containing triplets , where and are relative column/row distances, and describes the content of the destination square: indicates an empty square, a square occupied by an opponent piece, and a square occupied by an own piece. We assume that , and , and so is finite.

While the piece’s owner is defined by the case (upper or lower), its letter encode the piece’s type. Pieces with the same type have the same language of legal moves, thus declaration is made for the white pieces only. Note, however, that a positive means forward, which is a subjective direction, and differs in meaning depending on the player.

Consider a piece and a word that belongs to the language described by the regular expression in the movement rule for this piece. Let , where each , and suppose that the piece stands on a square . Then, describes a move of the piece, which is applicable in the current board position if and only if, for every such that , the content condition is fulfilled by the content of the square . The move of changes the position of the piece piece from to .

In contrast to the Björnsson’s definition, rules where the same square is visited more then once are allowed. Technically, we found this restriction superfluous. Note that during computation of legal moves, the board position is not changed, so the field with relative coordinates always contains the player’s moving piece. Hence, is always legal, while is always illegal. An example of how move rules work is shown in Figure 3.

Figure 3. A chess example. Two legal moves for the queen on are shown. The capture to is codified by a word , while move to is encoded by . The move to is illegal, as in the language of queen’s moves, no move can end on a square containg own’s piece. The knight move is a direct jump codified by a one-letter word .

Lastly, the <GOALS> section provides game terminal conditions. The first value is the turnlimit, whose exceedance automatically causes a draw if no other terminal condition is fulfilled. The turnlimit is given in the so-called “half-moves” in chess, i.e. the value means moves of the first player and moves of the second player. A player automatically loses the game when he has no legal moves at the beginning of his turn (e.g. because he has no pieces left).

A player can win by moving a certain piece to a fixed set of squares, which are defined by entries denoted by the @ symbol. The values are given in absolute coordinates, and square is located in the lower left corner of the board. Alternatively, as introduced in [3], a player can lose if the number of his pieces of a certain type reaches a given amount, defined by entries denoted by the # symbol. The terminal conditions can be asymmetric.

3. Summary

The language can describe many of the fairy chess variants in a concise way. Unlike Metagame, Simplified Boardgames includes games with asymmetry and position-dependent moves (e.g. Chess initial double pawn move). The usage of finite automata for describing pieces’ rules, and thus to move generation, allows fast and efficient computation of all legal moves given a board setup. The regularity of the description makes it also convenient for e.g. procedural content generation [4, 5]. However, it causes some important limitations. Actions like castling, en-passant, or promotions are impossible to express, as all the moves depending on the game history. Although absolute position of a piece is not available, this nuisance can be cleverly bypassed, so it is possible to describe e.g. chess pawn initial two-square advance.