Zillions of Games

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Zillions of Games
Zillions of games.jpg
Developer(s) Zillions Development Corp.
Stable release 2.0.1 / 2003
Operating system Microsoft Windows
Type General game playing
Website www.zillions-of-games.com

Zillions of Games is a commercial general game playing system developed by Jeff Mallett and Mark Lefler in 1998.[1] The game rules are specified with S-expressions, Zillions rule language. It was designed to handle mostly abstract strategy board games or puzzles.[2] 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[edit]

The scripting language of Zillions-of-Games uses S-expressions. The rules are stored in a text file with 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.):[3]

(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)
                )
    )
)
Playing Tic-Tac-Toe in Zillions-of-Games.

The result of loading of this ZRF into Zillions-of-Games and playing against the computer is shown in screenshot at right.

The definition of games usually contains the following pattern:[4]

  • 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 in Zillions-of-Games. This picture shows all positions in the defined game and their corresponding names. Also all specified directions from the middle-middle position are shown.
  • 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 moved. In the example above one pieces is defined, Man, which can be dropped on any empty position of the board. Besides this two bitmaps for X and O players are 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 win condition (3-in-a-row) is defined as relative piece configurations, using directions n, e, ne and nw from board definition.

Implemented games[edit]

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.[5] The former collected together every kind of ZRF, whereas the latter focused on ZRFs for chess variants. As of 2013, the ZILLIONS interface had 2,162 ZRF's, created by 423 ZRF authors,[6] and the Chess Variant Pages collection had 800 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[edit]

Zillions of Games can be used for the following:

  • Playing any of the games or puzzles that come with it.
  • Playing any of the thousands of 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[edit]

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.[2]

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.

[7]

Limitations[edit]

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.[2]
  • Its programming language lacks support for arithmetic, for functions, and for variables beyond some boolean flags.[2]
  • The engine does not have built-in support for connection-based goals such as in Hex; thus these goals must be implemented by hand.[2]
  • 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.[2]
  • Like most AI game playing programs, the default engine plays poorly in games with large branching factors, such as shogi.[2]
  • 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.

See also[edit]

References[edit]

  1. ^ David N. L. Levy (2006). Robots unlimited. A K Peters, Ltd. ISBN 1-56881-239-6. 
  2. ^ a b c d e f g "Can Zillions Support This Game?" FAQ by Zillions Development Corp.
  3. ^ The example of Tic-Tac-Toe is taken from "TicTacToe.zrf" in Zillions-of-Games installation and slightly simplified. The usage in Wikipedia is for illustration purpose and is believed to be according to fair use U.S. law.
  4. ^ Complete specification of the Zillions-of-Games scripting language can be found in Zillions Language Reference, which can be found in Zillions installation.
  5. ^ Zillions of Games - The Chess Variant Pages collection of chess variants for Zillions of Games
  6. ^ Free add-on games for Zillions-of-Games
  7. ^ Capabilities of Zillions, Capabilities added in version 2.0

External links[edit]