Zillions of Games

Zillions of Games
Search-based Procedural Content Generation: A Taxonomy and Survey
', Julian Togelius, Georgios N. Yannakakis, Kenneth O. Stanley, Cameron Browne, '' IEEE Transactions on Computational Intelligence and AI in Games'' 3(3):172 - 186 · October 2011 German Chu Shogi Association
/ref> is a commercial general game playing system developed by Jeff Mallett and Mark Lefler in 1998. The game rules are specified with S-expressions, ''Zillions rule language''. It was designed to handle mostly abstract strategy board games or puzzles."Can Zillions Support This Game?" FAQ
by Zillions Development Corp. After parsing the rules of the game, the system's artificial intelligence can automatically play one or more players. It treats puzzles as solitaire games and its AI can be used to solve them.

Scripting language

The scripting language of ''Zillions-of-Games'' uses S-expressions. The rules are stored in a text file with the extension ".zrf" (Zillions rules file). The users can create their own ZRF-files and make the AI of ''Zillions-of-Games'' play their newly created game.

Here is an example of rules for Tic-tac-toe (copyright by Zillions Development Inc.)

(define add-to-empty ((verify empty?) add))

(game
(title "Tic-Tac-Toe")
(description "...")
(history "...")
(strategy "...")
(players X O)
(turn-order X O)
(board
(image "images\TicTacToe\TTTbrd.bmp")
(grid
(start-rectangle 16 16 112 112) ; top-left position
(dimensions ;3x3
("top-/middle-/bottom-" (0 112)) ; rows
("left/middle/right" (112 0))) ; columns
(directions (n -1 0) (e 0 1) (nw -1 -1) (ne -1 1))
)
)
(piece
(name man)
(help "Man: drops on any empty square")
(image X "images\TicTacToe\TTTX.bmp"
O "images\TicTacToe\TTTO.bmp")
(drops (add-to-empty))
)
(board-setup
(X (man off 5))
(O (man off 5))
)

(draw-condition (X O) stalemated)
(win-condition (X O)
(or (relative-config man n man n man)
(relative-config man e man e man)
(relative-config man ne man ne man)
(relative-config man nw man nw man)
)
)
)

The result of loading of this ZRF into Zillions-of-Games (along with appropriate images) and playing against the computer is shown in screenshot at right.

The definition of games usually contains the following pattern:
* Game title. One ZRF can contain more than one game and game title allows the user to select a certain game.
* Description, history and strategy of the game. This is a text which shown to the user on demand to explain game rules, history and to give general gameplay advice.
* Players. This is a list of player names used in the game. For example, for chess it would be ''White'', ''Black''. The player name is used in some further places, for example in initial position or game goal definitions. There could be just one player (e.g. for puzzles), two or more.
* Turn order This specifies the order of moves made by the players. In the example above, the player ''X'' starts, the player ''O'' moves and then the whole sequence repeats. The definition of turn-order can be more complex, for example for balanced double-move chess it would be: ''(turn-order White repeat Black Black White White)'', which specifies the following order of moves: White, Black, Black, White, White, Black, Black, White, White, etc.

* Board definition. This sections specifies geometry of the playing board, separate positions of the board and connections between them. The board definition in the example above first specifies a bitmap image to be used for the board. A 2-dimensional board is defined using pixel coordinates from the bitmap. The definition ''("top-/middle-/bottom-" (0 112))'' specified notations to be used for rows as well as an offset in pixels between rows. The text notation is used in move list, as well for saving the played game into ".zsg" (Zillions saved game) file. The connections between board position is specified in ''(directions ...)'' statement. The example above defines four directions: n (north) - one step up, e (east) - one step right, nw - diagonally up-left and ne - diagonally up-right. The directions are used in move definitions as well as in game goal definitions.
* Piece definition. Defines pieces used in the game, their names, and how they move. In the example above one piece is defined, ''Man'', which can be dropped on any empty position of the board. Two bitmap images for ''X'' and ''O'' players are also specified.
* Board setup. Specifies initial position of the game. The example above defines that the board is empty initially and each side has 5 pieces off the board, which can be dropped.
* Goal of the game. Condition when one of players wins or when draw occurs. In Tic-Tac-Toe, the win condition (3-in-a-row) is defined as relative piece configurations, using directions n, e, ne, and nw from board definition.

Implemented games

''Zillions of Games'' is so called because of its potential to play a very large number of user-programmed games. The system is shipped with over 300 games and puzzles. These include a lot of popular board games, such as ''Alquerque'', ''Fox and geese'', '' Go'', ''Gomoku'', ''Jungle'', ''Halma'', '' Nim'', ''Nine men's morris'', ''Reversi'', ''Tafl'' and ''Tic-tac-toe''. The package includes many checkers variants, for example ''Russian'' and ''Turkish Checkers''. Besides standard FIDE chess, ''Zillions of Games'' contains many national chess variants such as shogi, xiangqi, janggi, as well as a number of popular chess variants like Ultima, Extinction chess, Losing Chess, shatranj, Berolina chess, Grand Chess and others. It also include some puzzles, such as 15-Puzzle, Towers of Hanoi, eight queens, and a variety of Solitaires.

Not long after it came to market in late 1998, users of ''Zillions of Games'' began to program new games and puzzles for it, creating many of them themselves. Two large collections of Zillions Rules Files (ZRFs) soon began to appear. One was at the ''Zillions-of-Games'' website, and the other was at the ''Chess Variant Pages'' website. The former collected together every kind of ZRF, whereas the latter focused on ZRFs for chess variants. As of November 2017, the ZILLIONS interface had 2,577 ZRF's, created by 462 ZRF authors, and the Chess Variant Pages collection had 794 ZRF's of chess variants.

The games programmed by the users include such games as 4D Tic-Tac-Toe, FreeCell, Rubik's Cube, Teeko, Mancala, Alice Chess, Chess960, Hexagonal chess, Star Trek Tridimensional Chess and Sokoban. Besides various games and puzzles, there are also educational ZRFs, such as the cellular automata Game of Life, a calculator, and some Turing machine simulations.

Uses

''Zillions of Games'' can be used for the following:

*Playing any of the games or puzzles that come with it.
*Playing any of the free games and puzzles that have been programmed for it by users.
*Playing games with remote users through the internet or a dialup connection.
*Playing games by emailing ZSG files back and forth.
*Programming it to play new games and puzzles.
*Using it as a development tool for the creation of new games and puzzles.
*Testing new games for drawishness and other qualities by having Zillions play them against itself.
*Solving puzzles or making sure that newly created puzzles can be solved.
*Creating diagrams that can be cut out of screen captures.

Capabilities

Zillions represents boards and pieces with bitmap images; these can be remapped by the user. The boards may be arbitrary directed graphs, but standard grid-like boards are easier to produce and have built-in support for detecting collinearity. The available win, loss, and draw conditions include checkmate, stalemate, repetition, piece capture, absolute configuration, relative configuration, and various types of piece count. These allow the creation of a variety of different games and puzzles.

Besides defining how pieces move, ''Zillions'' can define how pieces may be dropped. This is for introducing new pieces into a game. It is not useful for shogi, which "drops" captured pieces stored on the sides of the board. It is for games like Go, Reversi, and Tic-Tac-Toe, which routinely allow users to add new pieces to the board. As with piece movement, this is defined algorithmically, and it can be something as simple as letting a new piece drop only on an empty space or follow more complex rules.

Since version 2.0, Zillions has had the additional ability to enforce maximal capturing rules (used in some versions of Checkers) and a full-featured Go-playing engine.

Zillions includes a "random player" which selects from its available moves at random; this can be used to simulate dice in race games and Backgammon relatives.

The standard AI engine can, if need be, be replaced with user-created engines. These engines can then use opening books or other features unavailable to the standard AI.

Limitations

Despite its versatility, ''Zillions of Games'' has a number of non-trivial limitations:
* Zillions Of Games is designed to play perfect information games exclusively. This renders it of little or no use in ''fairly'' playing imperfect or hidden information games against the AI, such as card games or board games with hidden piece values like Stratego. Instead, the program will automatically use all information available to itself, including the cards in the deck and the cards in the hands of all other players. The games may still be played by human players, although there is no support for revealing information selectively to only one player.
* Its programming language lacks support for arithmetic, for functions, and for variables beyond some boolean flags.
* The engine does not have built-in support for connection-based goals such as in Hex; thus these goals must be implemented by hand.
* There is also no support for having multiple pieces per location, or for pieces covering multiple locations at once. Thus, complicated workarounds are required for games that need these features, such as Mancala, Laska or Quoridor.
* Like most AI game playing programs, the default engine plays poorly in games with large branching factors, such as shogi.
* In some vital respects, the program is too restrictive in what it allows.
** Although it can recognize repetition, the only kind it can recognize is threefold repetition.
** Although it can check for various win, loss and draw conditions at the end of a move, it cannot check for any of them when evaluating possible moves for a piece. Consequently, in shogi, for example, it cannot be programmed to always accurately enforce the rule against checkmating a King with a Pawn drop.
** Many multi-person chess variants cannot be played because it will immediately stop the game when the first player is checkmated or stalemated.
* In some cases, the quality of gameplay is compromised due to the AI automatically calculating piece values inaccurately with no option available for manually overriding it with accurate piece values.
Many of these limitations can be bypassed using extensions such as Axiom Development Kit.

References

External links

*

A review of Zillions of Games
by Hans Bodlaender

{{DEFAULTSORT:Zillions Of Games
Chess software
Multiple-game video board games
Video game engines
Video game development software