share
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> }
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 Gardner111http://en.wikipedia.org/wiki/Minichess#5.C3.975_chess, 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>> <BOARD> 5 5 |rnbqk| |ppppp| |.....| |PPPPP| |RNBQK| <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) & <GOALS> 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 &
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.
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.
References
-
[1]
Y. Björnsson.
Learning Rules of Simplified Boardgames by Observing.
In
European Conference on Artificial Intelligence
, volume 242 of FAIA, pages 175–180. 2012. - [2] P. Gregory, Y. Björnsson, and S. Schiffel. The GRL System: Learning Board Game Rules With Piece-Move Interactions. In IJCAI Workshop on General Intelligence in Game-Playing Agents (GIGA’15), pages 55–62, 2015.
- [3] J. Kowalski and A. Kisielewicz. Testing General Game Players Against a Simplified Boardgames Player Using Temporal-difference Learning. In Evolutionary Computation (CEC), 2015 IEEE Congress on, pages 1466–1473. IEEE, 2015.
- [4] J. Kowalski and M. Szykuła. Procedural Content Generation for GDL Descriptions of Simplified Boardgames. arXiv:1108.1494 [cs.AI], 2015.
- [5] J. Kowalski and M Szykuła. Evolving Chesslike Games Using Relative Algorithm Performance Profiles. In Applications of Evolutionary Computation, volume 9597 of LNCS, pages 574–589. 2016.
- [6] M. Mhalla and F. Prost. Gardner’s minichess variant is solved. 2013. arXiv:1307.7118 [cs.GT].
- [7] B. Pell. METAGAME in Symmetric Chess-Like Games. In Programming in Artificial Intellegence: The Third Computer Olympiad., 1992.
Comments
There are no comments yet.