Construction Game I – The Board Game Approach

So far, I’ve made two classical HTML5 RPG games, albeit with some unique dialogue and mystery engines. I wanted to since I was a kid, but that’s no longer my favorite game genre.

Aside from puzzles and mysteries (which are usually only good for a single play), I lean towards turn-based strategy games and the broad genre that has been termed “construction games.”

Like hordes of other gamers, my favorite strategy series is the Civilization series, which is currently in its fifth incarnation, with the sixth coming out this October. That series is enough to slack one’s thirst for grand strategy, and has a good dollop of construction in it as well.

The appeal of “construction games” is different from most other video games. One thing players seem to have in common is the desire to create. I find little pleasure in blowing up cities and shooting aliens; I’d much rather plan a city and nurture an alien civilization. When playing Civilization V, I’d sooner build opera houses and win a “cultural victory” than build tanks and win the “conquest victory.” And I’m far from alone, although players like myself tend to fall prey to more aggressive players.

So, I’m trying to design a simple construction game, a genre that has pre-historic roots in games like Hamurabi and a common ancestor in SimCity. Without giving too many details away, it will take place in the same location (and with the same characters) as my RPGs, and will have a mean edge.

Design-wise, though, I’ve been drawing a blank, so I’ve been coding different ideas to see if any make sense. Since I’m a complete German-board-game geek, I decided to first look at a “solitary” board game design and try coding that. Being a Civilization fan, I found an amateur print-and-play version of it called PocketCiv. I printed out the instructions and coded my own text-interface version in Python, a great language to use if you need to crank something out quick.

PocketCiv was intended as a version of Civilization that you could play with minimal equipment. And indeed, in its pure form, you could play it with nothing more than a deck of “event” cards and a pad of paper. The problem was the complexity of the rules.


The instructions were 28 pages of Microsoft Word, plus another 3 pages to describe the “tech tree.” Each turn, you turned an event card over and followed the instructions. How a person was supposed to memorize the event instructions, I don’t know. For a sample, here’s Python on what do to if the “civil war” event occurs:

    def CivilWarEvent(self, event, originalCard):
        dCard = self.__eventDeck.drawCard()
        activeRegion = dCard.getRedCircle()
        avActiveReduce = 2
        avNeighborReduce = 2
        cityDestruct = True
        if self.__techs.containsTech("Military"):
            avNeighborReduce = 3
        if self.__techs.containsTech("Mythology"):
            avActiveReduce = 3
        if self.__techs.containsTech("Civil Service"):
            cityDestruct = False
        if self.__techs.containsTech("Architecture"):
            avActiveReduce -= 1
            avNeighborReduce -= 1
        eCard = self.__eventDeck.drawCard()
        collateral = 0
        if self.__techs.containsTech("Law"):
            collateral = eCard.getGreenSquare()
            collateral = eCard.getBlueHex()
        if self.__techs.containsTech("Arts"):
            collateral -= 2
        if self.__techs.containsTech("Theater"):
            collateral -= 2
        if self.__techs.containsTech("Meditation"):
            collateral //= 2
        neighborList = self.__gameMap.getNeighbors(activeRegion)
        self.__gameMap.growCity(activeRegion, avActiveReduce, cityDestruct)
        self.__gameMap.addTribes(activeRegion, -collateral)
        for rId in neighborList:
            self.__gameMap.growCity(rId, avNeighborReduce, cityDestruct)
            self.__gameMap.addTribes(rId, -collateral)
        if self.__techs.containsTech("Medicine"):
            self.__gameMap.addTribes(activeRegion, 1)
            for rId in neighborList:
                self.__gameMap.addTribes(rId, 1)

And mind you – this is one type of event – there’s 14 more to go. For a simple game, the rules can be astonishingly complex. This isn’t a game I could play without the instruction book in my lap.

My annotated PocketCiv rules…

I coded a playable (or at least bug-free) version of the game to test it out, using a text-and-keyboard interface, but I ended up with three large objections:

  1. As in Civilization, a player advances in the game by researching technologies. However, the method was too strict. In the original games, one simply accumulates research points. In this version, you needed to first concentrate a number of resources on one particular city, then spend them. It can be difficult to do this.
  2. At the end of each turn, you must “maintain” your population or watch it die off. This slows the game down and makes researching even more difficult.
  3. Worst of all, the events were simply devastating. A single disaster early on could end your whole civilization.

So the board game approach didn’t work. You can read my code here, but note that someone has already coded a playable JavaScript-Angular version of it. Moving pieces around according to complex rules is fine for board game night but not a computer game.

There was a good insight here, though. The complexity of the rules didn’t matter so much, once they were converted into code and function. The final results could be harsh, but those results came instantly.

I’m trying to strike a balance between a fun game, and a realistic economic background. The Harvest Moon series was fun and appeals to construction-types, but real farmers only wish they had a guaranteed price for their crops. But too much realism is bad – SimFarm was much more realistic and much less fun (I never did figure out how to keep insects from devouring my crops).

If you think Civilization is high-level strategy, you should try Victoria II. It has possibly one of the most detailed economies I’ve ever seen. But that kills the gameplay – so many segments are simulated (especially if you run a country with a laissez-faire economy, like the United States) that there’s little left to do but sit back and wait for the CPU to crunch out the ticks.

There’s also the infamous Dwarf Fortress, which definitely involves a lot of construction, but where you can’t directly control the game, only issue orders. Plus, the interface is so complex and intense that whole books have been written on it. Learning Dwarf Fortress is on my bucket list, but not my to-do list.

Given the semi-medieval background of my RPG games, I had to get a copy of the old DOS game Stronghold, but its gameplay is confusing, to say the least. I loved the idea behind it – AD&D meets SimCity, as many critics put it – but first you need to master its weird controls.

At the same time, I can list many building games I’ve played on my smartphone over the past few years, from the purely-city-building The Simpsons: Tapped Out to the rash of construct-and-fight combos such as Clash of Clans. There’s such thing as too easy, and these games are prime examples.

So, I’m still looking for a model to work off of. At least I can scratch the board game model off my list.

Next I will be making an “idle” game, which will give me a chance to finally use the engine while still trying to think of a decent model for my construction game.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s