Last updated 19 Sept 2000
OBJECT OF THE GAME
In Programmer's Nightmare, you are trying to take control of a program, or in the second version, create a program that you control, as it is built. Certain instructions in the program let you gain points or cause you to lose them, or shift control over certain instructions in the main program loop. The object of this game is to get 20 points, in which case you have won. If you reach zero points, you are out of the game. If you lose all your control tokens, you are also out of the game.
THE PLAY OF THE GAME, Version 1.
There are two ways to play this game, Version 1 is a bit easier to learn, since all the players get to see all the cards at the same time, but there is much more strategy. Still, we advise playing this version before trying the other. Version 2 is a bit faster and easier to play. My own preference, as game designer, is Version 1. In Version 1 you deal the entire program out and then players claim instructions. In Version 2, players build the program, instruction by instruction, from cards in a playing hand.
For Version 1, first remove all the following cards from the deck; the Break (3 of them), Run (4), Secret (2), and Insert (1). They are not used in this version of the game. These are "one-shot" cards used for Version 2.
A certain number of cards (which varies depending on the number of players) are dealt out in a circle in the middle of the table, so that the last card dealt connects to the first card dealt. Each player has a number of colored markers (Bits) with which they may "claim" a program instruction (a card). The players take turns placing a single colored marker on one card until all the players have run out of markers. No other actions are taken until all the Bits are played. Only one token may be put on each card at this time in the game. The PROGRAM COUNTER is placed next to the first card dealt, in the direction that the program goes (as dealt). It tracks the direction that the program runs, and which instruction (card) the program is currently executing.
# of Players; 2 3 4 5 6 # of Cards dealt; 14 18 18 18 21 # of Bits per player; 6 5 4 3 3Some cards will introduce new Bits into the game besides the ones you start with; if you run out, you can get no more.
Once all the players have played all their Bits, the sequence of cards is "run", like a computer program, starting with the first card played, performing each action on each card once, then proceeding to the next card (clockwise). Naturally, the player whose marker is on a card is the one that chooses whether or not the action on the card is performed. Some cards will refer back to other cards, thus creating the potential for infinite loops. Since the program is a giant loop, once you have run all the cards, the program starts all over again, and runs over and over until one player wins, or until it becomes obvious that no one can gain an obvious advantage. In such a case, reshuffle all the cards and deal again. The cards "program" will be run in a big loop as much as possible, but many of the cards will interfere with the main loop, creating little sub-loops and jumping around in the sequence.
For cards with multiple Bits on them (this occurs when certain instructions move Bits around in the program), that instruction is performed multiple times, starting with the player who first placed a bit there, and continuing with any other Bits in order of placement upon that instruction. Place the Bits such that the person who was there first is closest to the side with the Program Counter. The player who was there second places his Bit next to the first, the third player next to the second, and so on. It's possible for the first person to act on a card to destroy or replace the second person's Bit before he or she has a chance to act on that card. It's also possible for the first person to replace the card upon which the Bits are sitting before the second player can act, in which case the second player would have to use the new instruction on the new card.
Once all the cards and tokens are played, the "program" is run, looping over and over until one player reaches 20 points, or all the other players reach zero. As the Program Counter reaches each instruction, each player with a token on that instruction decides whether or not to execute the instruction. Each player starts with 10 points. If a single player reaches zero points, all his or her tokens are removed from the cards. Likewise, if that player loses all of his or her Bits before losing all their points, they are out of the game.
Any player whose card performs an infinitely long operation that does not include losing or gaining points may perform the loop action up to three times, then must pass the play to the next card. Otherwise, the action of losing or gaining points is performed an infinite number of times, either allowing you or another player to win, or forcing you or another player to drop out of the game. (note that this does not apply to Version 2, as it's possible to win merely by creating a loop with no one but yourself in it).
Each player chooses a color to play, and takes all the tokens for that color. Shuffle the deck (the Program Stack) and deal 4 cards (program instructions) to each player. Then, deal one face up in the middle of the table with the Program Counter next to it, pointing either up or down. The Program Counter keeps track of which direction the program is running, and where in the program you are.
All players start with 10 points, marked down on a sheet of paper. With the youngest player going first, players then take turns playing cards from their hands and drawing replacement cards from the Program Stack (the deck). Cards may be played above OR below the existing string of program instructions, all the cards ending up in a long row. Play rotates clockwise. As each player plays a card, he or she puts a token of their color (an "Ownership Bit") onto the card they play. If they play a PROGRAM ERROR card, they take a token (Bit) belonging to an opponent and put it on the card. Cards are played at the head of the program, or at the end, in a straight line of cards. The Program Counter is not moved while this happens, and the program instructions are not performed, or "Executed" as they are played, that occurs later. The players attempt to play instructions in such a way that, WHEN the program is run, they will gain points or new Ownership tokens, while their opponents lose them.
RUNNING a program; this occurs if any player plays a RUN card, which they play instead of an instruction on their turn. When a RUN card is played, the program starts running, starting at the current instruction at which the Program Counter is adjacent, in the direction that it is pointing. If there is no player Ownership Bit on the instruction, then you skip it and proceed to the next one in the program in the direction that the pointer is pointing. If there IS an Ownership Bit there, then the player who controls that color gets to decide whether to execute that Program Instruction or not. If he or she chooses not to execute the instruction, then that instruction is skipped and the Program Counter is moved to the next instruction. If that player chooses to execute it, he or she performs the instructions on the cards in any way allowed by those instructions. Thus, if the instruction says that they can move a Bit to an adjacent card, then you can choose any Bit, including your own, and move it from its current card to an adjacent card. Once the instruction has been executed, the Program Counter moves on to the next instruction.
When the Program Counter reaches the end of the row, it gets moved back to the beginning of the row, looping the ends of the Program together. Note that at the start of the game, if players have been playing new instructions at both the top and bottom of the program, then the Program Counter will begin, roughly, in the middle of the program. Since the program loops around from end to end, this isn't really the middle at all, or course, just a point in the program loop.
While a Program is running, no one may play a card, except for a BREAK.
If a program reaches 20 cards in length, then the program immediately starts running, and continues to run until there is a winner. No BREAKS may be used after 20 cards are played.
STOPPING A RUNNING PROGRAM WITH A BREAK; If someone plays a BREAK card on a running program, the program stops at the next unexecuted Program Instruction. No BREAK of any type can be used on a running program until at least one instruction is about to be executed a second time.
In addition to playing BREAK on a running program and then discarding it, a BREAK can also be played in the body of a program; then, when it comes up to be executed, the player that owns it may decide whether to stop the program or not. The danger here, of course, is that some other Program Instruction might remove your Bit from that card before you have a chance to execute the BREAK. After a BREAK is played, players once again take turns building onto the existing program, starting with the player who played the RUN.
The player that started the program running may verbally BREAK the program. Any other player may BREAK a program by spending 3 life-points without playing a card.
There are a few other cards in the Stack that aren't actually instructions that get placed in the body of the program, like RUN, which are labeled "ONE-SHOTS". You play them once, follow the instructions on them, then discard them. Some will cause you to play 2 cards during your turn, in which case you draw 2 at the end of your turn, always ending your turn with 4 cards in your hand.
As the program is run, players will gain or lose points and markers (Bits). If they get down to zero points or Bits, they lose, if they get up to 20 points, they win. If a loop is created such that only one player is in the loop, then that player wins.
When more than one player has a Bit on a single instruction, players execute the instruction in the order that their tokens were played there. Note that during the initial play of the cards there will only be one Bit per card, except for the very first card of the program which will have no Bit at all.
INCREMENTING AND DECREMENTING CARDS; Some instructions can change a number on a card, but ONLY numbers. The difference between a card that says "...you can remove 1 Bit..." or "...you can remove a Bit..." is that you can't increment the latter card, since it isn't a number. Numbers cannot go negative, but if you have a card that decrements a "1" by 2 points, then it only decrements the card to zero. Players may, optionally, try playing without this rule, but it will get even more confusing than it already is.
Here is a list of all the cards. You don't have to read these unless questions arise as to how cards interact during game play. They are defined in some detail here, while on the cards the explanations are quite brief. Keep in mind that it is OPTIONAL as to whether a player uses a program card's instruction or not; a REVERSE does not always have to reverse the program direction.
SAMPLE GAME SEGMENT (VERSION 2)
GO TO (player 2) FUTURE (player 1) ACQUIRE (player 3) DECREMENT (player 1) OVERWRITE (no owner, first card played) PROGRAM ERROR (player 2 put player 3's token on it when played) BUG (player 3) COPY (player 1) REVERSE PROGRAM (player 2) INCREMENT (player 3)For this example, we will assume that the first card dealt was OVERWRITE, so it has no marker (Bit) on it. Player 1 has decided to play a RUN on his turn. The program starts at OVERWRITE which does nothing because nobody owns it, then moves to PROGRAM ERROR, where player 3 loses a point (has 9). Then the program moves to BUG; player 3 has the option to make everyone lose a point if she wants to, which she does, and the score drops to 9 to 9 to 8 for players 1 ,2, and 3 respectively. Then, player 1 gets to decide whether to execute the COPY. He decides not to, since COPY becomes equal to the PROGRAM ERROR and BUG, in sequence, which would mean he'd lose 2 points if he activated the COPY. Player 2, here, has a lot of power with the next instruction in the sequence; if he reverses the program, then player 1's COPY will copy the reverse and the increment. He chooses not to REVERSE, since he doesn't want player 1 getting the INCREMENT ability next turn. Instead, player 3 does.
Now some very interesting strategy occurs. Player 3 sees that it is possible for player 2 to completely lock out players 1 and 3 from accomplishing anything more by using his GOTO next turn to jump to the BUG, not performing his own REVERSE, and letting player 3 increment anything she wants to no effect (except for BUG, which would kill them all, eventually), since none of the other instructions are being performed, but player 3 is holding a BREAK in her hand, which she decides she will play at first opportunity. In the meantime, she increments the ACQUIRE card, so that when it does activate, she gets 3 points instead of just 2.
The program then loops around to the GOTO, where player 2 has a chance to jump to the BUG statement. He does it, since he sees that the upcoming FUTURE and ACQUIRE will boost players 1 and 3 up by 3 points each, so he's hoping that one of them will eventually play a BREAK. Just before the BUG is activated, player 3 plays a BREAK to stop the program, since she sees that, even if she continues to INCREMENT the ACQUIRE every loop of the program, the FUTURE of player 1 will always occur first, meaning player 1 would almost certainly get 20 points before player 3. Also, the FUTURE could take advantage of the ACQUIRE, then DECREMENT it before player 3 ever had a chance to use it herself.
Once the BREAK is played, players start playing program instructions again, starting with the player who played the RUN card. Eventually someone will play another RUN, and the horror will start all over again.
Programmer's Nightmare is copyright 1998 and 2000, by;
Jolly Games 3236 Peacock Lane Santa Maria, CA 93455Thanks to Dave Allsopp and his gang of merry Englishmen who helped playtest this game, Stephen Tavener, and many others who I am no doubt forgetting.