There are some decent strategy guides out there (see the links at the bottom of the Colossus page, for example), and I highly recommend using Colossus to help tune your game.

But, one lingering question I've had is how good are the creatures in the game, really? The game assigns point values, in the range of 12–40, that is computed crudely: simply multiply the strength and level. But this is incorrect: a centaur isn't really the same as an ogre, is it?

Answering that question in general is tough. One thing I can do, though, is to figure out which creatures are more effective in one-on-one battles against each other. This is exactly what I did.

Here are some simple results for just the beginning ("tower") creatures, to decide which ones are inherently better. These results are averaged over 1,000,000 runs.

Essentially, they are all nearly equal when it comes to killing each other, but the Centaur has a slightly better chance of surviving against an Ogre, and an Ogre has a better chance of surviving against a Gargoyle. Not exactly a clear victory for anyone, but I would have to say that the Centaur appears to be the best tower creature here.

It is fairly easy to extend these results to all one-on-one battles possible, which I have included in this table (PDF). The table is arranged so that the creature on the left-hand-side is attacking the creature on top, and the pair of numbers represents the probability of the left creature defeating the top creating and the probability of the left creature getting killed, respectively.

The simulation to generate these numbers took about two hours (all written in Python / Cython, source code available here, if you are curious).

The main difference is that when stealing from your neighbors, any word you steal will cost them points. In addition, you get bonuses for long words and for using all of your letters.

However, there is a rule that states that on your turn you can only steal one word from one other player. This gives you incentives to steal long, valuable words from another player, especially if it contains the current "trump" suit (worth more points).

I quickly discovered a few useful rules of thumb when playing this game.

• Always use all of your letters. It's nearly always possible if you have time to think it through, especially if you follow the next rule. Also, the more letters you use, then the more points you will score, as the game has a finite length based on who finishes first.
• Make lots of short, crappy words. Even though making words of all the same suit will "lock" them (thereby preventing players from stealing them), in general, the other players won't want to steal a really small, less valuable words. In addition, by making lots of small words, it is easier to use all of your tiles, and the damage from having a word stolen is minimized.
• Punish your opponents for long words. If they only play a long word on their turn, steal it (thereby taking away a lot of their points) and turn it into a ton of small words, punishing them for making a long word.

I love competitive word games. But I, at least, have to remember that a lot of my friends who like to play word games like Word Thief are not hardcore gamers, so maybe I shouldn't be so competitive with them.

Photo — Lainey's Repertoire

Over the holidays, I put together a Twilight Imperium game at my house, and I thought I would share some tips for preparation and organizing your own game.

You need at least 5 players. No, really. The game is not fun with less than five, because the alliances could form too easily, and the bigger maps can't be used. I think the game works best with 6 or 8 players (but you can only do more than 6 if you have the expansion).

Make sure that there is enough room for everyone. This means a large table, enough chairs for everyone, and possibly some smaller tables for people to organize their bits on (I like TV trays for this).

Despite what the box says, TI3 takes more than 4 hours to play. Typically, for an 6-player game, it's going to be at least 5 or 6 hours, and 8 players bring that closer to 8 hours.

Unless you and your friends have a lot of downtime regularly (for example, you are in college), you will need to set a date a few weeks in advance. Since you are going to have to start pretty early and eat up most of a day, your friends' schedules will matter in planning, so give everyone time to come together for this.

Have everyone bring cash. I like to start before lunch and go up until dinner (at least). This usually means that everyone will need to eat at least once, possibly takeout, and cash is a good thing to make this go easier.

Have a large table and lots of chairs.

The most important rule: make sure everyone has read the rules before coming. Nothing will make the game take longer than having to have a long rules exposition at the beginning of the game, and constant questions during it. The rules are long (about 44 pages for the base game), so this is a non-trivial, but necessary requirement.

Explain the Imperial–Initiative tick–tock unwritten "rule." If you have never played TI3 before, this may be new to you: whoever chooses the strategy card first should always pick the Imperial (8) card, since it gives 2 victory points and gets the game closer to victory. The next person should always pick the Initiative (1) card so that they can pick the Imperial card next time.

If not everyone understands this, then someone will run away with the game as soon as they figure out that the Imperial card is overpowered. Nothing is less fun than being 2 hours into a 6-hour game and noticing that there is no way for anyone to catch up with one of the players because someone let them draw the Imperial card twice in a row.

A possible alternative to this is to use the Imperial II card (in the expansion) with the Age of Empires option.

Minimize the number of optional rules and expansion pieces if you have new players. The game is complicated enough to learn as it is. Specifically, with new players, I don't play with Distant Suns, Leaders, Artifacts, Space Mines, Facilities, or Shock Troops. I will play with the expansion races and cards, but I try to make the first game with people as straightforward as possible.

Many of these ideas can be adapted to other long-running games, such as Diplomacy. Does anyone else have any tips or suggestions for organizing or running a large game?

Best Overall Game: Twilight Imperium 3rd Edition

This game has won my heart by being the most fun for me. The box is large enough that I think it ate all of other games and absorbed all of their fun.

This game is not for a light afternoon of gaming: it is a fairly serious all-day affair. It incorporates a wide variety of game elements including alliances, politics, strategy, tactics, turn order, resource management, and more. However, for a moderate to serious gamer, I can think of no better way to spend most of a day.

Best Cooperative Game: Battlestar Galactica

Battlestar Galactica is a cooperative game in the loosest of senses: all of the players (theoretically) are working together to survive the Cylon swarms and numerous challenges to get to Kobol. However, there is guaranteed to be at least on traitor in the game, with the possibility of two or three.

The game has a unique twist that halfway through, players are dealt an additional loyalty card, meaning that whether or not you are a traitor can change halfway though. So, you can't do too well in the beginning, even if you aren't a traitor, because that may change.

This dynamic as well as the fully fleshed out gameplay makes this a big win over comparable cooperative games for me.

Best Word Game: Bananagrams

Bananagrams is short and sweet: everyone rushes to make a complete Scrabble board at the same time as other players. There is no scrounging for points for two-letter words and no score to keep track of, making it ideal for players who haven't bothered to learn the two-letter word list but still want to have fun with a word game.

It's low price, portability, and replay value make this game a huge favorite these days.

Best Card Game: Dominion

Card games normally suffer from many problems that have limited my playing them in the past: too many cards increases the randomness of the game, too few reduces the replayability and fun, too complicated detracts from people playing it, too simple also reduces the fun (generally). Managing a massive deck of cards can be daunting, and hand management is almost too simple.

Dominion strikes a delicate but amazing balance between all of these elements, creating a game that is not too long (30–45 minutes), is flexible with the number of players, has a good selection of cards, and is not too complicated. How well you do in the game is essentially how well you manage the randomness of the cards in your deck, so in a way you are fighting against the randomness.

Best Random Game: Galaxy Trucker

Sometimes, you just have to say screw it to deep strategy, alliance making and breaking, and lots of thinking. You just want to spend an hour and a half with some friends laughing over how well the tiles have screwed you over, or how bad the draw pile is going to mess up all of your work.

Enter Galaxy Trucker. It is a game that embraces its random nature. Your job is to build an interstellar piece of junk that can get you from one end of the galaxy to other, maximizing your collection of cargo along the way. You also must survive a swarm of pirates, slavers, asteroid fields, laser blasts, and (yes) open space.

Photo — Chris Blakely

What is Google Wave? I like to think of Google Wave as a collaboration platform that allows multiple people to "grow" a document, as well as add comments, and many other things. Someone put it like "If email were invented today, it would look like Google Wave."

Since it is a flexible platform, I was curious if it would be possible to use it as a virtual board gaming platform. I am still investigating that matter, and I think, so far, "maybe".

As a first step onto this road, I created a quick dice-rolling gadget for Google Wave:

Google Wave Dice-Rolling Gadget

If you want to use the gadget, add it by clicking on the "Add Gadget by URL" button with the following URL:

http://github.com/swenson/wavegaming/raw/889cf5757b51ca3e0d6df02c18948c1f864eab0a/dice.xml

Note that this is a specific version of the gadget. The newest can always be found on my GitHub account, but if you switch to a new version, it might not work with your saved state. Hence, using the correct version of the gadget is important.

Let me know what you think in the comments.

Enter Bananagrams. It's Scrabble, but without the board, points, or turn-order. Everyone scrambles to complete their own mini-Scrabble board (minus the physical board) piece-by-piece. Whoever can use all of their letters first wins. The tiles are given out piecemeal, making it important to plan ahead with words you can build off later.

My favorite part of the game is that it is ridiculously fun, flexible in space (it can be played on practically any surface), and flexible in numbers of players: it supports 2–8 by default, but there's not much of a reason it can't scale bigger, especially if you combine two sets. Since my board game group tends to vary pretty wildly in number of players and in space available, flexibility is always valued.

In addition, the game is just a bunch of letters in a bag. Although the game is cheap, you almost don't have to buy it to play it, especially if you have a few extra sets of Scrabble laying around (and who doesn't).

Even better, you can make the rules completely your own. Some suggestions are even presented in the package, but I've heard of one group awarding two winners: the one who wins the game traditionally (by completing the board fastest) and also for most creative word. You could also do longest word, or most complicated design, etc. Like all good games, Bananagrams is limited only by your imagination.

And then, once you figure out some mechanic that will make the game move, you have to start doing the more boring parts of finding out *exactly* how the mechanic affects the game. How balanced does it need to be, how many players will it support? Will there be resources to be used, and how should they be distributed and utilized? How will the players interact with this game?

To solve these problems, you want to scratch down on paper or computer how these things work, and then start playing through a quick round of the mechanic to see how it plays out.

Since my primary profession is as a computer scientist, I am a big fan of generating computing models for, if not the entire game, at least several of the major components. It helps especially to determine balance, that elusive trait that is so hard to nail down by hand. How often does a player in a certain position win, how much relies on chance, how much on skill, how hard is it to gain those skills? Developing good computer models of the mechanics can help to determine the answers to these questions.

And, for the craftier people out there, there is always the fun of building physical prototypes. I'm not a particularly crafty person, sadly, but I am looking forward to creating a really sharp, fun physical version of my game. Even if you aren't too amazing with Photoshop or an Exacto knife, you can have fun scavenging eBay, game store miniatures, or just other board games for pieces to combine into your prototype. If you have an artsy acquaintance you can ask (or pay for their help), or perhaps find someone on Etsy to help you bring your idea to physical form. Or, perhaps, you can use it as an excuse to learn how to mold clay, whittle, or play with Photoshop.

Does anyone else have any good tips for prototyping games?

Photo — hisks

The most basic technique of simulating a game is called rejection sampling. That is, you try your best to simulate every possible variable in a game (or in the piece you are studying), and then randomly pick values for the variables and measure the outcomes. After some amount of time, you just stop, and tabulate the results.

It's called rejection sampling because, typically, you are measuring the likelihood of one particular event happening, and you do this by randomly simulating as above, and throwing away all of the results where the event did not happen. It's by far the laziest and usually easiest way to measure something in a system such as a board game.

In addition to being the laziest way, it is also good for confirming the results of other types of analysis – it is unlikely for your rejection sampling technique to be wrong, unless the model is bad or the events you are trying to measure are extremely unlikely.

To demonstrate how I use rejection sampling, we can use it to confirm the Monty Hall riddle. Basically, you are a contestant on a game show, and are asked to pick on of three doors, behind one of which is a new car that you win if you pick it. After picking a door, the host then reveals one of the other doors without a car in it, and offers to let you switch your choice. So, should you switch? The answer is always yes, though I won't go into details: suffice it to say that it's a non-intuitive probability calculation. If you switch, you have a 2/3 chance of winning the car, and if you stay the course, you have a 1/3 chance of winning.

The following is a piece of Python code to simulate this using rejection sampling.

import random
 
# reproducible results
random.seed(1234)
 
def monty_hall():
  doors = [0, 1, 2]
  winner = [0, 0, 1] # three doors, only one with a win
 
  random.shuffle(winner) # shuffle the doors
 
  mydoor = random.sample(doors, 1)[0] # pick a random door
  doors.remove(mydoor)
 
  # reveal one of the two doors
  revealed = random.sample(doors, 1)[0]
  doors.remove(revealed)
  # sanity check: don't reveal the door with the prize
  if winner[revealed] == 1: revealed, doors = doors[0], [revealed]
 
  # would you like to switch to the other door?
  # ALWAYS ANSWER YES
  mydoor = doors[0] # switch
 
  return winner[mydoor]
 
# perform rejection sampling 10,000 times
total = 10000
wins = 0
for i in xrange(total):
  if monty_hall() == 1: wins += 1
 
print "Won:", 100.0 * wins / total, "percent of the time"

Produces the output:

Won: 66.68 percent of the time

The code is pretty straightforward as far as Python board game simulation code goes. There's no odd probability counting going on, no calls to permuted choice functions, no brute force or clever backtracking. Just simply doing a run and seeing if you win, repeat.

This demonstrates two key principles for board game simulations: you should almost always do some kind of rejection sampling code as a reality check of any other results you come up with, and probabilities are weird and often counter-intuitive, so tread lightly.

Photo — Debaird

Michael Larson was a contestant on Press Your Luck in 1984. The game was a simple kind of gambling, involving players taking "spins" on a board, where they have a chance at winning money, or losing it all. The gimmick of the show were the Whammies, which were little red cartoon creatures that would dance across the screen and take all of a contestant's money when they hit them.

The science comes in with Michael. Michael discovered, through OCD-like analysis, that the game's randomizer was very poor: the squares on the board were selected in a few fixed patterns, and Whammies would only appear in certain squares, and never in others. Even better, some of the bigger amounts of money appeared in those Whammy-free squares.

Armed with this knowledge, Michael went on the show and tore it apart, winning over $110,237.

I find it an inspirational story to show what kind of results can come from simple analysis of a game.

Photo — Mike Fischer