Virus Fight

From IcehouseOrg
Jump to: navigation, search
Virus Fight
Jorge Arroyo
Vf-example4.jpg
A game of combat between two ever changing computer programs
:Players Players: 2 - 5
:Time Length: Medium?
:Complexity Complexity: Medium
Trios per color: 5
Number of colors: 5
Pyramid trios:
Monochr. stashes:
Five-color sets:
- - - - - - Other equipment - - - - - -
5x5 or 6x6 Board, optional play-aids and hollow pawns/volcano caps/TH set of different type (as long as all the others are equal).
Setup time: 1 minute
Playing time: 10 Min
0.167 Hr
- 30 Min
0.5 Hr
Strategy depth: Medium
Random chance: Small
Game mechanics:
Theme: Programming
BGG Link: Virus Fight
Status: complete? (v1.0), Year released: 2987


Each player owns 4 types of "computer instructions" and builds a small program which then runs around the board (computer memory) changing itself and trying to destroy the opposing programs.

Each player uses a Treehouse set to represent the instructions, so for each player, the same instruction may use a different color, as the game can be played with mixed types of TH sets.

There's a special piece (represented by a small opaque or a hollow plastic pawn) that acts as the program counter, or instruction marker. This piece is placed on top of the instruction that will be executed next. If a player cannot move this piece then that player is eliminated.

Material Needed

You will need one Treehouse set (of any type) per player. These will be the computer instructions. You'll also need one hollow token in a unique color for each player.

In a two player game, one of those tokens may be the small opaque. If each player uses a different type of Treehouse set, then you can use the two small opaques (black and white).

With more players, it's possible to use small hollow plastic pawns (these seem to be quite common) in addition to the opaque pieces. If all the Treehouse sets used for Computer Instructions are of the same type, you can use the small pieces from a different Treehouse set too. Also, if available, one player can always use a Volcano Cap (or grey small).

For two players, use a 5x5 (Volcano) board. The board should be different (and bigger) with more players. There should be at least as many spaces on the board as the number of pieces used by all the players, so for a 3 player game, a 6x6 board would be best.

Also, each player should set up their pieces as far as possible from the other player's pieces, using the side spaces on the board. If there are more players than sides, just use consecutive spaces on the side of the board so that there is as much free space between the players as possible.

I've made three pdf files for this game. One is a 5x5 board with play-aids ( http://george.makasoft.net/icehouse/VirusFight-Board.pdf ) and the others are just the play-aids in color ( http://george.makasoft.net/icehouse/VirusFight-PlayAids.pdf ) and in B/W with the color names ( http://george.makasoft.net/icehouse/VirusFight-BWPlayaids.pdf ) for those that already have a suitable board, or to play with a bigger board.

Setup

Place a the board between the players. Each player takes one of the TreeHouse sets and places all the translucent pieces, ordered by color, standing up, in front of them outside the board. They represent the instructions. Then each player chooses one of the unique hollow tokens to be their instruction marker.

Color Meanings and Definitions

Three blocks: A two instruction block, a three instruction block and a one instruction block. All these blocks are Empty Blocks.
One block. It's both the active block for the black player and for the grey player.
Three blocks: An empty block with one instruction, the active block for the black player and the active block for the grey player. Both have 3 instructions.

In the game, each translucent color represents a different type of computer instruction:

  • YELLOW / ORANGE = MOVE
  • GREEN / CYAN = WRITE
  • BLUE / PURPLE = JUMP
  • RED / CLEAR = ERASE

The actions a player might take when running one of those instructions will be explained later.

The size of the instruction represents the preference of the instruction. Bigger instructions are run first.

The "INSTRUCTION MARKER" as mentioned above is represented by a small pyramid of a color not used for the instructions or another hollow token. It is placed over one of the pieces on the board and the instruction below it is the one that will be executed next for that player.

A "BLOCK OF INSTRUCTIONS" or "PROGRAM" is any number of pyramids grouped together on the board (and separated from the rest of the pieces). Two instructions belong to the same block if it's possible to make a path from one to the other, only with orthogonal steps, that only passes through spaces occupied by other instructions. This way, two pieces that are adjacent to each other diagonally do not form a block.

The "ACTIVE BLOCK" is the block in which the player's instruction marker is currently on. Note that it is perfectly possible for a block to be the active block for two or more players. In this case, all the players sharing it, act on their turn as if it was just theirs, being able to affect it freely. (Hey, this is a game about computer viruses after all!!)


An "EMPTY BLOCK" is a block of instructions that doesn't have an instruction marker from any player.

Program Setup

During the first phase of the game, the players build their initial programs in secret. They can use up to 5 instructions (of any color or size and in any order) forming a line, to do it. Then they place their Instruction Marker on top of any instruction in their program. When all the players are done, they reveal their programs and place them on the board, on the row (from their point of view) closest to them. The program instructions must be placed together, with no spaces between any two pieces, forming one block. No two programs (from different players) may touch each other at this point.

Game Play

The player with the smallest program goes first. In case of a tie, the one with less total of pips from their program's pieces starts, if there's still a tie, the player with the biggest piece under their instruction marker starts. If there's yet another tie, decide randomly.

The game is played in rounds of as many turns as players playing (one for each player). After the first round, the first player for the next round may change.

After the first round, before a new round starts, look at the instruction each player is about to execute. If the current first player has the biggest piece (even if tied with other players) then the first player remains the same next round. If only one of the instructions is the biggest, then the player owning that instruction will become the first player for this round. In case of a tie not involving the first player, the player closest to the first player (in clockwise direction) becomes the first player.

Using a stack made from the left over opaque pyramids, you can mark who's the first player for the current round.

During their turn, a player has to execute the instruction their marker is standing on. Here's what the player can do for each type of instruction. Note that any piece that has an instruction marker on top, cannot be affected in any way by any instruction executed:

  • MOVE (YELLOW / ORANGE) - The player must take one of the instructions from his active block and move it to any other empty space adjacent orthogonally to an instruction from the same block. This way, blocks can be divided or merged (even with active blocks from other players).
  • WRITE (GREEN / CYAN) - The player must take any one of his spare instructions (the ones in their play area outside the board) and place it on an empty space adjacent to an instruction from his active block. This way, blocks may also be merged (even with active blocks from other players).
  • JUMP (BLUE / PURPLE) - The player must move his instruction marker to any other piece on his active block or to any empty block.
  • ERASE (RED / CLEAR) - The player can destroy an instruction if it is adjacent orthogonally to any ERASE instruction in the active block. An erased piece is "captured" by the player and they just place it back on their play area outside the board to be used again at a later time. Note that as long as there's one empty space adjacent to one of the ERASE pieces, the player can choose to target it and not actually erase any piece, but if all the ERASE pieces from the active block are surrounded by other pieces (friendly or not) the player must target an actual piece.

After executing the instruction, unless it was a JUMP instruction, the active player must move his instruction marker to an orthogonally adjacent instruction that doesn't have another instruction marker on top. The marker has to be moved, otherwise the active player is eliminated from the game.

When this is done, play passes to the player to the left (clockwise). When all the players have taken their turn, after checking for a possible first player change, a new round starts.

Ending the Game

If a player cannot move their instruction marker to a new instruction at the end of their turn, then they are eliminated. The last player remaining after everyone else has been eliminated is the winner.

There are a few cases when a player might not have much chance of winning (all their WRITE pieces erased) or no chance at all (all their ERASE pieces erased). In some of those cases, it might be possible for that player to force a stalemate if the other player's position is weak enough. If it's clear that one player will eventually win, players are encourage to concede. If it's not clear, just play and in case of a stalemate (agreed by both players) the winner is the player with more spare pieces outside the board. In case of a draw, count the total number pips.

Inspiration

The idea for this game came to me as I asked myself what icehouse game would a friend of mine (who works programming) like. In the 80s this friend of mine had some magazines from his father (Maybe Scientific American) and in one, they talked about computer programs fighting in a simulated memory. The programs where made with a simple language and they could modify the simulated memory trying to disrupt the opponent programs. I even made a couple of really simple versions of this concept for the Amiga computer back in the day. I just tried adapting this concept to an icehouse game, but instead of building the program and just letting it run (not much interaction there), I gave the player control of the instruction marker, deciding which instruction would be run next (simulating possible loops and if-then conditions that the program might have). This way, the players take the part of simple computer AIs :)

Other ways to play the game

Even thought the game was created with the Icehouse system in mind, and uses some of its special characteristics such as pip number and stacking (to a certain degree), it can be played with other game systems such as the Piecepack game system or a standard deck of cards (plus some pawns). The pdf linked below contains the rules for all three game systems.

External Links

  • A pdf with the rules to the game for all three game systems it can be played with, including playaids can be downloaded from BGG: VirusFight-Univ.pdf
  • Virus Fight is listed on BoardGameGeek
  • Virus Fight is listed on the piecepack wiki

License

http://i.creativecommons.org/l/by-nc-nd/2.5/es/88x31.png
This work is distributed by Jorge Arroyo under the Creative Commons Attribution-Noncommercial-No Derivative Works 2.5 License.

Competitions

This game was entered in the Winter 2007-08 Icehouse Games Design Competition. Even though it didn't seem to perform very well overall, it was the only game to win against the winner in the individual pairings. Also, the number of votes was too small to be totally conclussive, so if you like abstract games with no random elements, don't let that deter you from giving it a try. And if you do, don't hesitate to post your opinion/questions/suggestions on the discussion page.

Entered in the Icehouse Game Design Competition, Winter 2008
Winner: Martian 12s - Runners-Up: WreckTangle, Timelock
Other Entries (in alphabetical order): Chicken Run, Hunt, Martian Gunslinger, Timberland, Virus Fight
Entered in the Icehouse Game Design Competition, Summer 2008
Winner: Ambush 2nd: Logger 3rd: Albiorix 4th: Virus_Fight 5th: Atom_Smasher
6th: Dog_Eat_Dog & Martian_BattleSpires 8th: Pass_The_Pyramids 9th: T-Minus 10th: Tresurion