Zillions of Games

From Wikipedia, the free encyclopedia

Zillions of Games
Developed by	Zillions Development Corp.
Latest release	2.0.1 / 2003
OS	Microsoft Windows
Genre	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. The game rules are specified using LISP-like language, Zillions rule language. It was designed to handle mostly abstract strategy board games or puzzles.^[1] 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.

[edit] Scripting language

The scripting language of Zillions-of-Games allows exactly define rules of a board game in LISP-like language. 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.)^[2]:

(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 is usually contains the following pattern^[3]:

• 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 specifed 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.

[edit] 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 200 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 Chinese, 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^[4]. The former collected together every kind of ZRF, whereas the latter focused on ZRFs for chess variants. As of 2006, the Zillions collection had 1350 ZRFs^[5], and the Chess Variant Pages collection had almost 800 ZRFs 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.

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

[edit] Benefits

Since Zillions of Games is principally for puzzles and strategy board games, playing almost any game or puzzle on it is good for exercising logical and strategic thinking. In addition, some of its games are intended to be educational. Its use of a programming language for creating new games encourages creativity, ingenuity, and logical thinking. And, of course, there is the simple pleasure of playing games and solving puzzles on it.

Zillions of Games is also very helpful for learning new games. Each ZRF normally displays text descriptions of a game's rules, history, and strategy in separate menu items. When you hover the mouse over a piece, it will give a brief description of the piece and how it moves, and the mouse cursor will indicate whether you can move that piece. You can right click on a piece for a more detailed description. When you left click on a piece, which is how you pick up a piece to move it, it will place a green dot over every space the piece can move to. One more way an advanced user can use Zillions to learn a new game is by programming it, which requires careful attention to all of a game's rules.

For game designers, programming a game helps the designer cover every detail of the rules that needs covering. In the past, game designers have sometimes failed to think through all the implications of their rules, thereby leaving some details to be ruled on later or even post-mortem, such as the details concerning en passant in Parton's Alice chess. By describing the rules in a programming language, a game designer is forced to consider every minute detail, some of which might get overlooked by writing only a verbal description. Once a game is coded, one more benefit for the game designer is the ability to playtest new games before making them public. This provides feedback for making a game better, which enables a game designer to more reliably release only good games to the public.

[edit] Capabilities

By using bitmap images for boards, it can use any type of board that can be represented with two-dimensional computer graphics. It provides a grid command for quickly defining the spaces on a board; for boards with very unusual shapes, it allows the individual creation and linking together of spaces. By these means, it can use many kinds of boards, including the usual 8x8 Chess board, smaller and larger boards, hexagonal boards, triangular boards, circular boards, boards for three-dimensional and even four-dimensional games, and boards of even more unusual shapes.

Its ZRF programming language allows the specification of such details as spaces, pieces, piece positions, turn order, and win, loss, and draw conditions. Spaces have specific locations and are linked to other spaces by directions of movement. Pieces are given graphic images and powers of movement. The 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.

Powers of movement are defined algorithmically. They may be as simple as letting a piece move in certain directions, such as a Bishop does in Chess, or very complicated. The most complicated example in Chess is castling, which involves keeping track of whether the King or Rook have moved, and also of performing the castling move itself. En passant is another example of a complicated move in Chess. More examples come from Ultima, whose pieces normally capture by means other than displacement, the most complicated one being the Chameleon, which captures another piece by its own powers of capture. The movement powers of this piece involve lots of complicated ZRF code, but the ZRF language is up to the task. Pieces may even be given the power to move other pieces. For example, Zillions can be used for Magnetic Chess, which moves pieces toward or away from the piece that just moved, and in games like Shogi, it can allow a single piece, such as the King, to handle all piece drops instead of giving that power individually to every piece. Piece movement can also be programmed to be dependent on board location. This is used in Chess for en passant and Pawn promotion, and it has made it possible to program the rules of Smess. Pieces may change into other pieces, which is used in Chess for Pawn promotion, but which can be used to even greater effect in games that let pieces combine, split apart, or more freely change into other pieces. By using blank space-shaped pieces, parts of the board can be covered for games with moving or changing terrain, such as Parton's Cheshire Cat Chess.

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.

[edit] Limitations

Despite its versatility, Zillions of Games has a number of non-trivial limitations:

• Its programming language lacks support for arithmetic, for functions, and for variables beyond some boolean flags.
• 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.
• 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, 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.
• Zillions of Games is designed as a universal gaming program. As such, it nearly always lacks the potential to play as well as programs designed exclusively to play one particular game incisively well. Its playing strength is compromised mainly by its inability to utilize an opening book or any other game-specific information. However, you can write a zrf to use opening books (as demonstrated by Karl Scherer's "Chess with Opening Books") and you can write and plug-in your own game-specific playing engine (as demonstrated by e.g. Greg Schmidt's "Sudoku Solver").

[edit] See also

• General Game Playing

[edit] References

[edit] External links

• Zillions of Games homepage
• A review of Zillions of Games by Hans Bodlaender
• Zillions Games by Karl Scherer.