17 Jan 2003 sab39   » (Master)

Rule change

Still no implementation in the forseeable future, but I thought a little bit more about the rules of the game I described in my last diary, and identified a problem: the results of the "attack" move can be immediately reversed by the opponent by another "attack" (for example, with OOXXX in a line, O attacks giving OOOXX, X can attack back and revert it to OOXXX). This kind of endless cycle of play is what the "ko" rule in Go is designed to prevent, but I felt that a ko rule would be over-complex for this game, so I tried to think of an alternative to the attack rule as stated.

One idea I kept coming back to was that in place of the existing rule where an attack makes OOX into OOO, it could instead make OOX into O-O (the hyphen being a blank space). The scenario above would then be impossible, because the sequence would become OOXXX => O-OXX => O-X-X, so no further attack is possible. I kept rejecting this because it causes a scoring problem - with this rule, every move except for "sacrifice" causes a net gain of one token on the board compared to the opponent, so the only way to gain a score advantage was to force the opponent to sacrifice. That seemed like it would force every game to get rather drawn out, as one player would have to completely dominate the board and force lots of sacrifices to win.

Eventually I realized a different natural solution to this problem. Instead of trying to formulate an attack rule that causes the number of tokens on the board to increase by the right amount, I could change the scoring system to get the same effect by counting each "captured" token as a point as well.

So here are the revised rules...

The board is a hexagonal grid of tesselated hexagons, something like this (the one shown is 6*6*6 giving 91 cells, slightly bigger than a chessboard, which seems about right - but alternative sizes are certainly possible). The game starts with each player having a single token, in the places marked by an X and an O in the linked text file. The starting player is chosen at random.

Players take it in turns to move. There are three moves available in the game:

  • Advance: Remove one of your tokens from position A and place two new tokens in positions B and C instead. B and C must be adjacent to each other, and both must be adjacent to A (that is, A, B and C must all be adjacent to each other).
  • Attack: This is permissible only when three tokens form a straight line, the first two (in order) being yours, and the last being your opponent's. The opponent's token is removed from the board and the middle token is moved into its space. The attacking player keeps the opponent's token, which is said to have been captured. Captured tokens cannot be used in the game, but count towards the player's score.
  • Sacrifice: Remove any single one of your tokens from the board. This move is permitted at any time except when you have only one token on the board, in which case it is permitted only if there is no other move you can make.

Scoring is as follows: Each player gets a score equal to the number of tokens they have on the board plus the number of captured tokens they hold. The player who went second has an extra half-point added as a handicap. The game is won when the difference between the two scores becomes greater than ten points (again, nothing special about ten, it could be any number that makes the game work well), or when one player is forced to sacrifice his last token.

Latest blog entries     Older blog entries

New Advogato Features

New HTML Parser: The long-awaited libxml2 based HTML parser code is live. It needs further work but already handles most markup better than the original parser.

Keep up with the latest Advogato features by reading the Advogato status blog.

If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!