House rules

Making up your own house rules can be a really fun part of playing board games. It lets you wear the shoes of a game designer - not just play the game, but also play with the game.

Sometimes changing the rules makes for some really spicy games, as even a trivial tweak can have a ripple effect and unexpected consequences. But we’re here to learn and to have fun - so let’s play, shall we?

Settlers of Catan

Let’s take a look at the rule book for Settlers of Catan (PDF). Usually when you play with a new group, the more worn out is the set, the more likely it is that the group has at least one rule they made up. Sometimes they won’t even realize they made up a house rule, because they’ve mis-interpreted the instructions ten years ago, and have been playing like that ever since.

So in my first game with that particular group, I was going for the longest road achievement, which would’ve scored me 2 extra victory points (towards the target of 10). I’ve placed my fifth consecutive road piece, and reached out to claim the card with my prize, when my hand got slapped: “hey rollcat, but you have your own settlements breaking up your road!” - I immediately rebuffed, that this is not only not against the rules, it’s in practical terms impossible to claim and hold the longest road without building some settlements on it, as you’re otherwise at all times vulnerable to someone else breaking it up with their own settlements; or else you’d have to build your road in some pretty nonsensical way (like in a loop and against a far coast, “walled off” from afar with more of your own settlements). That makes the strategy require a lot of commitment for a very small reward. The very old and worn-out set didn’t have the rule book in it anymore, so (as this was a time before everyone had a smartphone) I was unable to prove the legitimacy of my claim.

(I don’t think a single person has ever finished, let alone won a game while holding the longest road with that rule in effect.)

Being introduced to a house rule like this (literally after you’ve successfully executed your strategy) can be quite frustrating; house rules should always be explained upfront, so whenever I’m playing with a new group, I always take a minute to explain mine. We have only two extra rules that we use regularly:

  1. Whenever someone rolls either 2 or 12, everyone harvests from all hexes marked 2 or 12.
  2. Whenever you move the robber to an empty hex (whenever you’re not stealing from anyone), you get to “steal” one chosen resource from the bank. This applies both if you roll 7, or if you play the knight.

Both rules are very simple changes. The first one has minimal impact (the two poorest places on the map are only half as poor, but still only barely better than a desert), but it’s designed to reduce the frustration for the player that had no other choice but to settle there - in Catan it’s very difficult to pull ahead from a losing position, but it still feels better to be 4th place with 7 points rather than with 6.

The second rule again has to do with the game being less frustrating (getting blocked/stolen from in the early game has huge impact on your economic growth), but it has more to do with the social dynamics. There is now a very good incentive to “play nice” - and when you don’t play nice (especially if you could’ve), it creates a bit more competitive tension. Even if everyone is trying to “play nice”, it creates tension within the whole group, as more settlements pop up on the board, and at some point it will be no longer possible to move the robber somewhere it doesn’t affect anyone. You could also use this as an opportunity to try to convince your neighbor to not expand somewhere, and then snatch that spot yourself. (Evil laughter.)

In any case, having house rules enables you to play your part as a game designer, to spice up a game (or make it more welcoming for beginners), create new comeback opportunities for a losing player, and otherwise have fun your own way - not necessarily as designed. Sometimes even the official rules evolve in a similar fashion - inspired by how players actually play the game.

And now, a plot twist: computer games!

In almost every computer game, the rules are not interpreted by a human. Rather, they are (in one way or another) an element of the game’s program, which for most of the games and players means they are more or less set in stone.

Many games offer the ability to create and install mods, play on custom maps, tweak the world generation settings, etc - some of these things can serve as the equivalent of house rules. For example in Factorio, you can add a simple mod that gives you a handful of free high-tier items at the beginning of the game (like a power armor, personal roboport, and a stack of bots), that makes the early game much less labor-intensive (as you get to copy-paste your early game designs, rather than placing everything by hand). These same items can be unlocked through normal game progress, so this change could be seen as similar in spirit as our Catan house rule: make the early game a bit less tedious.

Creating mods for Factorio however, requires some basic understanding of programming: at the very least, you need to know Lua; some basic concepts such as data structures, control flow, functions; and to dig throught the official modding documentation.

So let’s say, we have Settlers of Catan, but implemented as a computer game, with Python driving the game’s logic and rules. There’s a window where you can see the board and your resources, and you can play against an AI, or friends online. Let’s try to imagine how different rules of the game could have been implemented, and how could we modify them to add our own house rules.

def roll_dice_for_resources() -> int:
    x = roll_dice(sides=6, n=2)  # rolls two six-sided dice
    if x == 12:
        x = 2  # make 12 the same as 2
    return x
class Hex:
    number: int = field()
    def __post_init__(self):
        if self.number == 12:
            self.number = 2  # make 12 the same as 2

The first rule was fairly easy. We’ve made it so that every dice roll that results in a 12 is actually interpreted as a 2, and that every hex that was created with a number 12 on it, is now a 2. If the in-game AI is generic enough to look at the probabilities of each hex, it will correctly see the relative number of “2” hexes, but it would still consider the hex with a 2 using the original (lower) probability, so it wouldn’t necessarily make an optimal choice when deciding if it’s worth it to settle there. So it’s overall a bit hackish, but it’s an easy way to try out a change!

But what about the second rule? It starts getting more interesting. Detecting whether the hex has any settlements on it that can be blocked should be easy (definitely there already would be some method like Hex.list_settlements(), because you’d need that to hand out any resource cards), but this is where the easy part ends. You’d probably have to borrow the code from the “year of plenty” development card, to show a UI to the player, letting them choose a card from the bank; you’d have to extensively modify the code that governs the AI players, to enable it to use the new strategy; playtesting the changes requires modifying the code, restarting the program, starting and playing out a new game, etc.

Writing code gives you infinite flexibility in how you can modify the rules, but it sets the bar very high for casual modders, who just want to make a couple of tweaks, and spend most of their time actually playing the game - alone, or with friends.

It also makes it more difficult even to get started, even for someone (like myself) who is a professional developer. I’ve heard nothing but praise about Factorio’s modding API, however the fact alone, that you have to learn an API and dive into some code, creates a barrier - which I haven’t found the motivation yet to try to overcome.

Modding tools should be easy to use

I remember 1998. StarCraft just came out, and it was awesome - I sunk many, many hours into it. It came with a map editor, and the editor was easy enough for a 10 year old to pick up.

If you understood how to use MS Paint, then the terrain editor wasn’t any more complex than that. You’d pick a tile set, a terrain type from the palette, and sculpt the face of an alien world with simple clicks. There was undo and redo, and later on, with SCMDraft, the unofficial/community editor - even copy & paste.

But there was even more than that! In addition to a “Melee” mode, where you’d start a normal 1v1 game, with a single town hall and four workers, you also had the “Use Map Settings” game mode, where the editor allowed you to create whole scripted missions, just like in the official campaign. While the missions were scripted, the “script” wasn’t a “real” programming language: it was a simple sequence of triggers and actions, that you could edit from within a GUI in the editor, somewhat like Apple’s Shortcuts.

You could easily recreate a mission with a special objective (like in the Terran campaign, mission 7: bring the Psi Emitter to a beacon within the heart of the enemy base, to lure the Zerg to destroy it); all you had to do was place the beacon, mark it in the editor by drawing a zone over it, and add a trigger/action, like “WHEN [psi emitter] IN [zone X] THEN victory for player 1”. You could also script the in-game AI to play this asymmetric scenario in reverse, which was used in the Zerg mission 8: you’ve encircled the enemy base, and must prevent an enemy unit from escaping; the trigger system had timers, and there was a “set zone priority” action to cause the enemy AI to attack a specific position.

The whole campaign was just a lot of such triggers, and - some brilliant storytelling. It was amazing in 1998, and it’s still great in 2024 - and, by the way, free to play.

Unfortunately, the editor and the engine lacked in depth - you could not e.g. convert the existing triggers/actions to a piece of code (or write any code at all) to create more complex scenarios. You would remain limited to what the game engine authors managed to cram into a CD, in an era before the ubiquitious, 24x7 access to broadband Internet. The WarCraft III editor, that came just a few years later, was famously powerful enough to effectively create a completely new game genre (DotA/MOBA), which probably wouldn’t have been possible with the original StarCraft engine. However that new editor created a much higher barrier to entry; the basic trigger/action system was completely replaced with a scripting language, the terrain required much more careful sculpting, etc. The language itself was also unusuable outside the editor: I remember picking up C++ around that time, and deciding instead to write my own basic game from scratch.

Games as tools

An entirely different kind of phenomenon, Minecraft, is essentially a voxel sandbox, or virtual Lego bricks. The game not only has several modding engines & communities (Vanilla Tweaks, PaperMC, Curseforge, Modrinth, etc); it enables the players in the vanilla game to build not just farms, automations, or contraptions, but entire minigames, games within a game:

Board games are in general much more malleable than computer games, but I don’t think it has to be that way.

I dream of a world where more computer games empower their players to take the role of the creator, rather than just an actor; and I am thinking of ways to make such a role more accessible to the casual player. A game that naturally leads you to simple discoveries, gradually introduces more advanced concepts, ultimately giving you the tools to reshape the game itself, from within the game.

Would I have this dream today, if StarCraft didn’t release with an editor 26 years ago? Or if my hand-me-down Commodore 64 didn’t come with an introductory programming book? I would love to carry that torch.