Zillions of Games: Difference between revisions

Zillions of Games

Developer(s)	Zillions Development Corp.
Stable release	2.0.1
Operating system	Microsoft Windows
Type	Game Engine
Website	www.zillions-of-games.com

Zillions of Games is an expandable computer game engine. It runs on Microsoft Windows and allows users to create a huge number of abstract strategy board games or puzzle games in the Zillions format. Zillions games and puzzles are programmed using ZRF—a domain-specific, LISP-like language. After coding the rules to define a new game, the system's artificial intelligence can automatically play one or more players. It treats puzzles as solitaire games, which don't normally require a computerized opponent, but its AI may still be employed to solve them.

Zillions of Games is a commercial product, sold in stores or via internet from the Zillions of Games website. There is a demo version available, but it can only be used for a subset of the games that come with the full version, and it cannot be used for any of the games that have been programmed by users.

Zillions of Games is so called because of its potential to play a very large number of user-programmed games. Just for starters, it 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^[1]. 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^[2], 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, Klin Zha, Jetan, Smess, 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.

The scripting language of Zillions-of-Games allows exactly define rules 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 own ZRF-files and make the AI of Zillions-of-Games play 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")
   (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)
		)
    )
)

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.

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.

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 Chesire 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.

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 three-fold 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.

• board game
• game
• list of computer puzzle games
• puzzle

• Zillions of Games
• Atlantis Games : Karl Scherer's home page with his 400 freeware games.
• Fergus Duniho's Games Gallery
• Symmetrical Chess Collection
• Zillions of Games feedback by Adrian King and Joao Neto