You would think that dealing cards at random would be trivially easy to implement. You would also be wrong.

Truly Random

Always the eternal optimist (and devout follower of the YAGNI principle), I start by implementing dealing cards by simply picking randomly among the types of cards available. Something along these lines:

for (int i=0; i<HandSize; ++i)
    hand[i] = Random_GetInt(0, CardType::COUNT-1);

The best part of this approach is that it’s simple. The bad part is… everything else.

Maybe that works for your game, and if so, congratulations, you can stop now and move on with the rest of the game. Unfortunately, this doesn’t cut it for most card games. The player might get a hand all of the same card. Or maybe never get a card type that she really needs. Most of the time, an algorithm like this will frustrate players quite a bit and get in the way of the enjoyment of the game.

Deck of Cards

The next approach I usually try is to simply copy physical games and build an actual deck. Remember that we’re talking about internal structures, so this doesn’t mean that the concept of a deck is exposed to the player at all. As far as they know, they’re just getting cards at “random”.

In this case, you create an array of card types, shuffle it, and give cards from the top to the player.

const int cardsPerType = 3;
for (int i=0; i<CardType::COUNT; ++i)
    for (int j=0; j<cardsPerType; ++j)
        Deck_Add(deck, i);

Deck_Shuffle(deck);

for (int i=0; i<HandSize; ++i)
    hand[i] = deck[i];

This is quite an improvement over our first approach. To start with, we’re guaranteed never to get more than a certain amount of cards of each type in the deck. That will prevent ridiculous hands of all cards of the same type that make the game unplayable.

It also allows us to vary the amount of cards of each type in the deck. That way we can make some cards more rare than others, or even enforce unique cards by only adding one of each of those types.

You may argue that this approach is perfect since this is how “true” (meaning “physical) card games are designed most of the time. While that is true, physical card games often involve just randomly shuffling a deck because the alternative would be very time consuming (or might need a third-party who isn’t playing to set up the deck). Because of that, most games need to be able to deal with very uneven distribution of cards, which might be too limiting for your designs.

A lot of games games will benefit of having a more controlled deck, and since we’re running on a computer, we can afford to do a lot more than just shuffle cards together. We can take advantage of the digital medium and do things we couldn’t easily do with physical cards.

Aside: Shuffling a Deck

Shuffling a deck might seem like a trivial algorithm, but as usual the details can get a bit tricky.

If you wanted to get very physical, you could try to simulate real riffle shuffling of a deck: randomly split the deck into more-or-less equal parts, and interleave them with each other with some randomness. Then you’d have to run it several times and even so I think you’d get very suspect results.

A simplified algorithm is to randomly grab two cards in the deck and swap their positions. Is that good enough? How many times do you need to run that loop in order to get a proper (i.e. fully randomized) shuffle? I haven’t analyzed that algorithm, but I get the feeling it would have to be done many times in order to get something acceptable (especially considering the not-very-random nature of computer “random” number generators).

The best and simplest approach I have found to shuffle a deck is the following: assign a random number to each card in the deck, then sort the cards based on that random number. It’s easy to understand how a single sort will shuffle the deck properly and works the same for any number of cards (and runs in O(n log n) if we want to get pedantic about it).

Multiple Decks

One way to have more control over the deck composition is to have multiple decks. We don’t need to communicate to the player that there are in fact multiple decks, this is something that happens under the hood.

This is the approach we took in Subterfuge. Players are presented with a choice of 3 specialists every X hours. Initially those specialists were completely random, but the results were very underwhelming. The approach we ended up settling on involved classifying each specialist as being in the categories of attack, defense, or other. The game prepares 3 decks, one of each category with 3 of each of the specialists in each category. Additionally, we make sure that we never have 2 of the same specialist in a row.

When it comes time to generate 3 “random” specialists for the players to choose from, we pick the top one from each of the decks.

Blocks

In my current prototype, the player has a hand of 4-5 “cards”, and as soon as they use one, a new one is drawn and their hand refilled. Cards can be roughly classified in 6 different categories, and it’s important that the player gets access to one of those categories within a few turns.

I wanted to come up with an approach that guaranteed access to tiles of all categories, but without making the pattern too obvious. For example, I didn’t want to have the deck be one card of each category.

The solution I can up with was to break up the deck in blocks of 10 cards. Within each of those blocks, I can make some guarantees about its composition. This approach was inspired by the composition of boosters in collectable card games like Magic: The Gathering, or even in the way the deck is prepared in Pandemic.

The way I implemented it, each block of 10 cards will contain one card of each category, plus 4 other random cards (as long as they are not already in the block). Then all the cards in the block are shuffled and added to the deck. This results in apparently “random” draws without feeling predictable, and yet players are never left without a key resource they may need.

This kind of enforced structure can also add some depth to the game. Expert players might notice this pattern (or read this, which is a lot easier) and use it to their advantage when they’re trying to make decisions based on what cards might appear in future terms.

Any of you out there use a different method for creating random-but-not-quite-random draws in your games?

When we started work on Lasting Legacy, I envisioned it as a quick 9-10 month project (that’s quick for me, but I know it’s long for other devs). As we worked on it, it felt like the game was interesting and rich enough to spend a little longer and flesh it out to its full potential. Maybe spend a total of a year and a half on it.

Now it’s been two full years since we started. We’ve had a playable game almost from the start, but when I have an honest look at it, it’s still far from launch. We still need lots more content, game balancing, polishing, different game modes, porting to different platforms, creating videos, and all the marketing. It’s that pesky last 20% that takes 80% of the time–OK, maybe not 80% but at least another 12 months. All of that is definitely doable, but it would bring the project to a full 3 years (at least!), or a total of 6 man-years.

The problem with that is that, for Lasting Legacy to be financially successful, it would have to sell a lot of copies. A lot more than I can realistic expect it to sell. Let’s reeeeeally stretch the meaning of “successful” and say that the goal is that we should each make $50K per year. That’s a total of $300K after the cut from the stores, or about $430K in sales. At $15 per sale, that’s almost 30K sales, and most Steam games don’t come even close to that number.

So we had a choice: We could focus really hard on the marketing aspect to make sure we hit that many sales, or we could stop development altogether, cut our loses, and move on to something else. The problem with focusing on marketing is that it would add even more time, making it necessary to sell even more copies to break even. It would also mean spending months doing work that I really dislike (making trailers, doing a Kickstarter, promoting the game, chasing reviewers and streamers…).

Would it be worth doing that marketing push? Was I really willing to bet that Lasting Legacy would be a big seller? If I’m honest, I think that Lasting Legacy has the potential to be a very good, original game, but I don’t think it’s a game that lots of people want (or if they do, I wasn’t able to connect with that audience). I’m fine making games that don’t sell very much, but at least I want to enjoy the work that I’m doing. So in the end, I’d rather stop working on Lasting Legacy and move on to other projects that I can enjoy and can be potentially more profitable.

Fortunately the time I spent on Lasting Legacy wasn’t completely wasted: Apart from developing some new tech that I didn’t have when I started (SQLite to organize data, or on-the-fly font rendering for example), I continued to grow as a designer, and I hope a lot of what I learned will carry over to my future projects.

Some people will take away from this that Lasting Legacy failed because we didn’t do market research to see if there was demand for it, or tailor it to the tastes of gamers. I disagree. My goal from the start was not to maximize profits, it was to make a game I found interesting and getting compensated for my time. The failure of Lasting Legacy was that we were just too slow. If we had managed to make the game in a year like we originally planned, just selling 5-6K units would have been enough to cover our time.

So what’s next for me? I’ve taken the lessons learned to heart and decided to make a game by myself in 6 months. That’s a hard deadline. I’m drawing inspiration from Michael Brough and Arnold Rauers, both of them excellent game designers who make small games that start with major artificial constraints and they design around them. The constraint I picked is to make a simulation game in a very small grid (single screen, around 6×6). So far I’ve been doing some prototypes and I’m pretty happy how it’s coming along. If all goes well I’ll announce it soon and release it in a few months.

As part of this shift towards making smaller games, I’m going to create a mailing list for my games in general, not for each game individually. If you’d like to keep up to date, please sign up for my mailing list and I’ll make sure you’re the first ones to know about my upcoming games.

Wish me luck!

So I decided to write a “rulebook” for Lasting Legacy. I put rulebook in quotes because Lasting Legacy isn’t 100% a board game. There’s a light simulation component behind the scenes that is opaque to the player, but everything else can be treated like a board game. I figured it would be a good exercise for me, and maybe a good reference for early testers so they know what’s going on without a fancy tutorial.

I’m happy with the final result. It’s about three pages of generously-spaced rules without any images, which beats a lot of board games out there.

A word of caution: This is not trying to be a funny, engaging rulebook. It’s a dry, to the point, description of all the rules in the game, arranged in the best way to understand all the concepts in a single read. It’s also not a “How to play” document. I think that could be another interesting exercise for down the line, where I just focus on the bare minimum to get a player playing.

Lasting Legacy Rulebook

1. Overview

Goal

Gain the highest Legacy possible.

Setting

Guide a European family around the 19th century through several generations. Socialize and find suitable marriage partners to grow you family, so you can earn Gold, Prestige, and ultimately, Legacy.

2. Concepts

Note: Any numbers shown here are just the defaults. There are always effects in the game that can modify those numbers up or down.

Family members

People in the family tree are called family members. Family members under 14 years old are considered children. They’re represented with round frames and don’t have any special abilities. Once they become adults they can choose between one or more occupations, depending on their education level. Adult family members will have children based on their age and fertility.

The head of the family, indicated with a special frame, defines which family members can be used at any given time. Only the head of the family, their spouse, and people under them (children and heirs) are enabled. Other family members are disabled and can’t be used.

Occupations

Every adult member can have an occupation. The clothes and items people have represents their occupation. Occupations can be passive or active:

• Passive occupations have a permanent effect on the game. All the current effects are shown in the effect window.
• Active occupations provide you with a potential action you can perform by clicking on the occupation button.

Some occupations require a minimum education to appear as a choice. Occupations come in 4 rarities: common, uncommon, rare, and unique. Unique occupations will appear at most once per game. Occupations also could have one or more time periods during which they can appear: early, middle, or late in the game.

Personality

Every adult family member and friend has personality traits that consists of a series of likes and dislikes.

Friends

Your family friends are shown along the bottom of the screen, in oval frames. The smiley face shows their friendship level towards the family. Each year friendships drop a fixed amount. When the friendship level for a friend drops to 0, the face turns blue, and the following year that friend leaves.

Friends can join your family through marriage. The heart in the friend’s frame represents how much they love someone in your family. Love is determined by many factors, including personality match, sexual preference, age similarity, and friendship amount. If that love level is above a certain threshold, it means they’re in love with someone and they’re willing to marry that person (see section 3: Proposing and Accepting Proposals).

Gold

Gold is one of the primary resources in the game. It can be earned through actions and effects of people. Additionally, you may have a recurring Gold income (shown in the green arrow), and a recurring Gold payment (shown in the red arrow) that happen every year.

You can spend more Gold than you have, automatically taking a loan. Every year your Gold is negative, your family pays 10% of that negative amount in interest payments. 200 Gold is the debt limit. If you ever owe more that amount, the game ends in bankruptcy.

Prestige

Prestige is the other primary resource of the game. It represents your social standing, and the more Prestige you have, the more friend slots you have available. You always have at least one friend slot. For every 10 Prestige you accumulate, you gain an additional friend slot up to a maximum of 10. Beyond that, you can accumulate more Prestige but you won’t gain any more slots.

If at any point you gain a friend but you have no empty slots available, the friend with the lowest friendship leaves and the new one takes its place.

Prestige can also be spent to do actions that are usually associated with negative social implications. Friends can leave you if your Prestige falls and you lose a slot occupied by a friend.

Unlike Gold, Prestige can’t even go below zero. However, you can still use actions that would cause your Prestige to go to zero. If you do, the person who did the action will be disowned by the family and won’t be part of the active family anymore.

Health

People normally are healthy. Sometimes they will become sick due to a variety of reasons. From there, each year they can either become healthy, stay sick, or turn terminally ill. Once someone is terminally ill, unless something is done about it, they will die the following year.

Heir

A yellow line in the tree indicates the next heir to the head of the family, which is the preferred child of the current head of the family. Whenever a family member does an action that’s related to one of those traits, their parents will change their opinion of that person, either in a positive or negative way.

You can see the current opinion of someone by selecting them and looking at the smiley faces over each of their children. The more filled in that face is, the higher the parent’s opinion of that child is.

When the head of the family dies, the current heir becomes the new head of the family. The new head of the family also presents you with a new family goal due to their tastes and whims. This goal will let you gain Legacy by doing certain things during their time as head of the family.

Heirlooms

Heirlooms will give you Legacy based on different criteria. You start the game with one random family heirloom in your collection.

Events

Every 30 to 70 years, an event will happen which will affect how things normally work. You will be notified 10 years before the event becomes active.

Countries

The majority of the people you’ll encounter during a playthrough come from the country you are playing in. You might encounter a few friends that come from neighboring countries. If you manage to add those friends to your family, that country will be unlocked and available for a future playthrough.

Countries add variety in the form of starting conditions, tweaked rules, and some unique occupations to those countries among other things.

3. How to play

Each turn, take one of the following actions. Each action will move the year forward one year.

Socialize

Gain one friend. The new friend’s age and education level is influenced by the person who socialized.

Visit Friend

Restore one friend’s friendship level to the maximum.

Propose in marriage

Men in the family can propose in marriage to friends. When you click on the propose in marriage button, only the friends who are willing to accept will be highlighted. Click on one of them to marry them.

Women will sometimes have a dowry made out of Gold and/or Prestige associated with them. When you marry a woman with a dowry, those resources are added to the family resources. On the other hand, women from the family will sometimes have to offer a dowry in order to marry a man. In that case, those resources will be taken away from the family resources.

Accept marriage proposal

People in the family can receive marriage proposals from friends (indicated by the hearts above their heads). These proposals are only available for one year. If you accept it, they’ll be married right away. Otherwise, the friend will feel rejected and their friendship will drop more than usual.

Choose an occupation

When a family member becomes an adult, they can choose an occupation (indicated by the question marks above their heads and their lack of occupation item and clothes).

If you don’t choose an occupation, they will pick one of the available ones after 5 years.

Use occupation action

You can click on the occupation action of any active family member to perform that action. Occupation actions are unique to each occupation. Sick people can’t do any occupation actions.

You can also use the occupation action of a friend. That’s like asking them for a huge favor, so they’ll do the action, but then leave.

Restore heirloom

Whenever someone in your family over the age of 50 dies, they will leave a family heirloom in the attic. Each heirloom in the attic has a cost associated with restoring it. You need to restore an heirloom to add it to your heirloom collection so it generates Legacy.

Pass

When there’s nothing else better to do, you can pass the turn and earn 5 Gold.

4. End of game

The game will end when one of these conditions is true:

• You run out of time and the war starts. The year display will always tell you how many years you have remaining.
• You reach your Gold debt limit.
• The head of the family dies without an heir.

The amount of Legacy you have at the end of the game is your final score.

My early-in-development creative process.

During this phase I need to generate lots of different ideas because only some of them are going to stick. The more varied the better, so I like to approach my idea generation from different angles. The two most common approaches are starting from the theme, and starting from the mechanics

For example, in Lasting Legacy, we quickly came up with occupations like Family Doctor or Ball Organizer from the theme, and figured out what useful things they could do in the game (heal people, and attract new friends respectively).

We also came up with several occupations starting from a mechanics point of view. For example, we knew we wanted someone to increase the income of other people, so we came up with the Savvy Businessman occupation.

This time around I also used a third approach to generate ideas: Isomorphism.

Isomorphism is a word that comes from the greek composed of “isos” (same) and “morphe” (shape) and it means that two concepts are equal. This concept is very useful in mathematics. Imagine you have a very tough problem that you don’t know how to solve. Instead of having to go through the very difficult task of trying to solve that problem, you could instead show that it maps exactly (is isomorphic) to another problem you have already solved.

How does that help us with game design? If we can determine that our game, or at least parts of our game, map to parts of other games, we can look to see if the mechanics of those games can apply to ours.

I didn’t set out to design the Lasting Legacy this way, but it turns out there is a close correspondence between a lot of concepts in Lasting Legacy and Magic: The Gathering. That’s really good news because not only is Magic a great game, but it has been in active development for 25 years and it has explored a lot of different mechanics. So being able to draw parallels and tap into those ideas is a great resource and a very different angle of attack to a tough problem.

The mapping between Magic and Lasting Legacy goes something like this:

• Hand of cards = Friends
• Permanents = Active family tree
• Graveyard = Dead and inactive family members
• Library = Upcoming friends

I want to highlight that we’re talking about looking at concepts from another game, mapping them to our game, and then applying them, not using them straight. Those concepts couldn’t be used as it is, or wouldn’t make any sense, without the mapping from game to game. For example, in Magic: The Gathering, the player has a hand of cards but Lasting Legacy doesn’t, so the idea of discarding a card to achieve something doesn’t apply. Once we establish the mapping between the hand of cards and available friends, we could use the idea of dismissing a friend for similar purposes.

These are are some of the mechanics that we were able to map and apply to Lasting Legacy.

Bringing cards back from graveyard. Reanimating creatures has been a staple of black decks in Magic from the beginning. Thematically we could revive a dead family member, but that doesn’t fit very well with the more realistic approach of Lasting Legacy. Instead, we created a Genealogy Researcher, who can become the same occupation as a dead family ancestor.

Looking at cards from the top of the deck. Deck searching and manipulation is a very common blue Mechanic in Magic, but Lasting Legacy doesn’t really have the concept of a deck of cards, so we can’t do a lot of that. We can, however, look at the “top” X friends that would come up and pick one, which is exactly what the Dashing Socialite does. It’s a very useful occupation because it gives you a degree of filtering of your friends and reduces randomness.

Enter the battlefield effects. In Magic, many creatures have an effect that is triggered whenever they “enter the battlefield” (meaning, enter in play). This is a very useful tool, and we adopted it in Lasting Legacy. It gives you another reason to bring someone into the family, even if it’s not for their occupation or even to extend the main family branch. For example, the Charismatic Musician increases your prestige whenever he enters the family.

Blinking. Several cards in Magic allow players to “blink” permanents. That means those permanents go away and immediately enter into play again. That’s very useful to protect those permanents or re-triggering their enter the battlefield effects. We haven’t added this to Lasting Legacy yet, but it’s definitely towards the top of the lit of possibilities, especially if we end up with many other occupations that have effects when they join the family. This mechanic might make for an interesting subtheme for an expansion down the line.

There are many more mechanics that could be mapped to Lasting Legacy, but these are some of the most interesting ones we’ve done so far. If we end up making expansions, I’m sure we’ll revisit this topic as a source of new ideas and mechanics.

Apologies for the less than ideal sound and video quality. We’re working on fixing that for next time.

By now you’ve probably heard of Lasting Legacy: you’re managing a family around the 19th century through several generations, socializing, choosing good marrying prospects, and helping family members pick an occupation. Ah, occupations…

Occupations

Occupations and the life and blood of the game. It’s what gives the player lots of new actions and effects that can be combined in lots of different ways to achieve lots of powerful effects. The only downside of occupations is that… there are a lot of them! Right now we have about 50 and that’s just some really basic stuff. I expect the game will ship with about 100 occupations, and possibly more once we add country-specific ones.

50 doesn’t sound too bad you say. Sure, but each occupation has a lot of data that goes along with it: a name, whether it has an action or not, text for the action,text for the log, costs, whether it’s inherited… Hang on, let me tell you exactly what an occupation has:

struct OccupationInfo
{
     Occupation::Enum occupation;
     Rarity::Enum rarity;
     const char* maleName;
     const char* femaleName;
     const char* description;
     const char* logEntry;
     IconSpriteId::Enum spriteId;
     uint32_t periodFlags;
     int goldIncome;
     bool incomeMultiplied;
     int prestigeIncome;
     int legacyIncome;
     bool action;
     int goldCost;
     int prestigeCost;
     bool educationRequired;
     int targetCount;
     bool pickable;
     bool destructive;
     bool inherited;
     Occupation::Enum childrenOccupation;
     int personLike;
     uint32_t tags;
     AccessoryType::Enum maleAccessories[MaxAccessories];
     AccessoryType::Enum femaleAccessories[MaxAccessories];
     int maleAccessoriesCount;
     int femaleAccessoriesCount;
};

How do we set all that data for 50 different occupations? Back when I was working for big game companies I’m sure that someone’s job would have been to create a GUI tool to let designers enter those values. Then someone else would create a fancy XML format that could be exported from the tool. Then, if we were lucky, someone else would take that XML and crunch it during the asset conversion process into something binary that could be read directly into memory. Probably someone else would work on tech that would let you hot load new data while the game was running. Sweet!

Except that now I’m a lowly indie developer and I don’t have time for any of that stuff that doesn’t actually make the game better. Fortunately, I also don’t have a team of 50 designers to deal with, so my solution is this:

{
	OccupationInfo& info = OccupationInfos[Occupation::Banker];
	info = OccupationInfo(Occupation::Banker, "Town Banker", IconSpriteId::Banker);
	strcpy(info.description, "Gain 100 gold. Income decreases by 1.");
	info.logEntry = "%s %s gained %d gold.";
	info.tags = OccupationTags::Gold;
}
{
	OccupationInfo& info = OccupationInfos[Occupation::Poisoner];
	info = OccupationInfo(Occupation::Poisoner, "Cunning Poisoner", IconSpriteId::Poisoner);
	strcpy(info.description, "Kill another family member.");
	info.logEntry = "%s %s poisoned %s %s.";
	info.cost = 500;
	info.tags = OccupationTags::Danger;
	info.rarity = Rarity::Uncommon;
}
{
	OccupationInfo& info = OccupationInfos[Occupation::Tutor];
	info = OccupationInfo(Occupation::Tutor, "Private Tutor", IconSpriteId::Tutor);
	strcpy(info.description, "Another adult family member leaves their occupation and becomes educated.");
	info.logEntry = "%s %s sent %s %s to school.";
	info.educationRequired = true;
	info.tags = OccupationTags::Social;
}

“Oh the horror! Hardcoded data!” shriek all new CS students as they recoil from the screen.

But it really isn’t that bad. Actually, it’s pretty great: I don’t have any exporting/importing to do, I don’t have to load anything at runtime, and the compiler does a lot of checking for me. True, I can’t change it on the fly, but I don’t really need to when rebuilding the whole game takes about a second.

Unfortunately the problem is that we have 50 of those initialization blocks. Hopefully a lot more by the time we ship. They’re perfectly fine to work on each of them in isolation, but I’m not able to get a big picture. Have I created a similar one to this new one I’m thinking about? How much do other similar occupations cost? Can I get all the Social occupations together so I can compare them? How many rare occupations do we have in the late period? I can’t answer those questions very well by looking at that code. I needed something else.

Global View

Using some kind of text file wouldn’t help any. It would be a matter of changing that into an ini or an XML file, which would be much more painful without any of the benefits.

I started setting up a Google Spreadsheet, which is something we did for the specialists in Subterfuge. Spreadsheets have some nice capabilities like doing data validation on cells (for example, to enter enums), or letting you sort records based on some criteria. In Subterfuge the spreadsheet method worked reasonably well because we didn’t have as many specialists and each of them had less data, so the spreadsheet was pretty manageable. Here we just had too much data for each occupation and the spreadsheet was getting unwieldy.

Miguel mentioned SQLite, but I wasn’t too keen on linking with some extra library and loading that data at runtime. It also sounded like total overkill to have a full relational database for what amounts to a single table. Then I realized how wrong I totally was.

People have written GUI tools for SQLite that let you create, edit, and browse databases very easily. For example, we’re using DB Browser for SQLite and I think there are better ones out there (although maybe not free ones). Our main table looks something like this:

And the data itself like this:

It looks like a spreadsheet until you realize that you can very easily search any field and you can even create “views” with more complex queries ahead of time. So now I can quickly see how many rare occupations we have in the late period with a single click. Very sweet! It definitely gives me that global view I was hoping for.

How about loading this data from the database at runtime? I doubt it would be a big deal, but it’s still something I’m not crazy about. Fortunately, it’s super easy to extract the data from SQLite. We have this in our make file:

@sqlite3 -header -csv $(DB_SRC) 'SELECT * FROM Occupations' > $(DB_CSV)

And that spits out a nice comma-separated file with all the data. Still, loading csv files at runtime isn’t much of an improvement, so we do a bit more processing. Initially I started converting the csv file into an ini file (since we already have an ini-reader library), but then I realized there was no point in doing that. Unlike Subterfuge, I’ll never want to have different versions of the game data around and load them based on different rules versions. We just want one true version. What’s the easiest way to put that data in the game? C code!

So with a simple Python script, I convert that csv file into a C file that looks an awful lot like the one we started with, except that this time it’s completely derived from the contents of the database. One of the great benefits of this is that we can let the compiler do a lot of the checking instead of having to do it in the script or (gasp) at runtime. For example, some occupations force their children to have a particular occupation (King -> Prince). I don’t even have any code that checks that the occupation you enter there is valid. We just generate code like this:

info.childrenOccupation = Occupation::XXXXX;

If XXXXX doesn’t happen to be a valid Occupation enum, you get a build error until you fix it. And again, since the whole turnaround time between editing the database and building the game can be a second or two, it’s really no big deal at all.

Constants

I left one small detail: Constants. Look at some of the first code I put up early on:

strcpy(info.description, "Gain 100 gold. Income decreases by 1.");

What’s wrong with that? Yup, you got it. Somewhere else in the code, I have some constants like this:

const int BankerReward = 100;
const int BankerIncomePenalty = 1;

Now every time I change how much money the Banker gives, I need to change the string and the constant (let’s not even talk about localized strings yet).

So instead now I use global string replacement while we’re generating the C code. The string on the database is this:

Gain [[BankerReward]] gold. Income decreases by [[BankerIncomePenalty]].

Whenever we load the csv file, we look for any substrings with the pattern [[…]] and we try to match them from a header file with constants that we’ve loaded. If we find them, we replace them with their values, and if we don’t, we spit out an error and stop because clearly someone wanted to have a string replaced there and probably mistyped it.

Does all of that sound complicated? Not really. When I said earlier that the Python script was simple, I wasn’t kidding. This is the bulk of it, including the constant replacement (just a couple helper functions are missing):

def main():
	dir = os.path.dirname(os.path.realpath(__file__))
	baseDir = dir + "/../LastingLegacy/AssetsRaw/"
	reader = csv.DictReader(open(baseDir + 'db/occupations.csv', 'rU'))

	sourceCodeDir = baseDir + "../src/"
	globalVariables = readGlobalVars(sourceCodeDir)
	pattern = re.compile(r'\b(' + '|'.join(globalVariables.keys()) + r')\b')

	Rarities = {'C': 'Rarity::Common' , 'U': 'Rarity::Uncommon', 'R': 'Rarity::Rare', 'Q': 'Rarity::Unique'}
	Periods = {'E': 'Period::Early' , 'M': 'Period::Middle', 'L': 'Period::Late'}

	defFile = open(sourceCodeDir + "Occupations.inc", 'w')
	for entry in reader:
		type = entry['id']
		defFile.write('{\nOccupationInfo& info = OccupationInfos[Occupation::' + type + '];\n')
		defFile.write('info.occupation = Occupation::' + type + ';\n')
		defFile.write('info.spriteId = IconSpriteId::' + type + ';\n')
		defFile.write('info.maleName = "' + entry['maleName'] + '";\n')
		if entry['femaleName']:
			defFile.write('info.femaleName = "' + entry['femaleName'] + '";\n')
		else:
			defFile.write('info.femaleName = info.maleName;\n')
		
		description = multipleReplace(entry['description'], globalVariables)
		defFile.write('info.description = "' + description +'";\n')
		
		defFile.write('info.logEntry = "' + entry['logEntry'] + '";\n')
		WriteOptionalBool(defFile, entry, 'educationRequired', type)
		WriteOptionalKey(defFile, entry, 'goldCost', type)
		WriteOptionalKey(defFile, entry, 'prestigeCost', type)
		WriteOptionalKey(defFile, entry, 'goldIncome', type)
		WriteOptionalKey(defFile, entry, 'prestigeIncome', type)
		WriteOptionalKey(defFile, entry, 'legacyIncome', type)
		WriteOptionalBool(defFile, entry, 'incomeMultiplied', type)
		WriteOptionalBool(defFile, entry, 'action', type)
		WriteEnum(defFile, entry, 'rarity', Rarities, type)
		WritePeriodFlags(defFile, entry, 'periods', Periods, type)
		WriteOptionalKey(defFile, entry, 'targetCount', type)
		WriteOptionalBool(defFile, entry, 'destructive', type)
		WriteOptionalBool(defFile, entry, 'pickable', type)
		WriteOptionalBool(defFile, entry, 'inherited', type)
		if entry['childrenOccupation']:
			defFile.write("info.childrenOccupation = Occupation::" + entry['childrenOccupation'] + ";\n")
		WriteOptionalKey(defFile, entry, 'personLike', type)
		WriteOptionalTags(defFile, entry, 'tags', type)
		WriteOptionalAccessories(defFile, entry, 'maleAccessories', type)
		WriteOptionalAccessories(defFile, entry, 'femaleAccessories', type)

		defFile.write('}\n')

	defFile.close()	

Here’s the full script in case anyone is interested in the details.

Boom! Done!

Ship it.

I managed to keep things shorter than last time, so this one is only 12 minutes. For those of you who prefer text updates, don’t worry, we’ll have one of those next week.

It’s a whopping 19 minutes long, so I may have overdone it a bit! I’ll try to keep it shorter for future updates.

Since this is the first time we’re doing this, any feedback is appreciated. Would you like to see more of these in the future? What should the focus be? Any technical issues I should improve?

Lasting Legacy is a fairly unique game, so it doesn’t quite fit in any predetermined genre. The closest category would be single-player, turn-based simulation, although the simulation part in Lasting Legacy is very light (unlike something like Sim City or The Sims), and in that respect it’s more like a board game. So it’s more accurate to say that Lasting Legacy is a blend of simulation games and board games.

Intrigued? You’re in the right place. Read on.

What Do You Do in Lasting Legacy?

The description of the game says that you manage a family for about 200 years and build a lasting legacy. Every action you perform moves the time forward one year, and actions are performed directly on individual people.

There are some common, general actions available:

• Socialize, which helps you find more friends.
• Visit a friend, to increase that friendship.
• Propose in marriage or accept a marriage proposal.
• Pick an occupation for someone who recently became an adult.

Those actions allow you to tend to the family and continue growing the family tree. The meat of the game comes from each person having an occupation, and that occupation provides either a special action, or an ongoing effect.

For example, having a Doctor in the family gives you an action to heal a sick person.

On the other hand, a Moneylender in the family gives you the ongoing effect of not having maximum debt anymore (time to run those credit cards!).

The ultimate goal of the game is to achieve the highest legacy possible each time you play. You gain legacy in one of two ways:

1. By acquiring heirlooms from deceased family members that give you legacy for different reasons (for example, number of people in your family with a particular occupation).
2. By meeting the whims of some important family members. For example, someone in the family might have a thing for big weddings, so you’ll gain legacy for every big wedding you have while they’re around.

Sounds simple enough, but in order to do those things, you’ll have to balance the maintenance of your family (social needs, marriages, children, sickness), acquiring gold and prestige, and, to top it all, dealing with the rising military tension in your country. War is inevitable, but you may be able to deflate military tension and push off the start of the war (which brings the end of the game).

Game Mechanics

Stepping back and looking at the game from a high-level point of view, there are two major mechanics that appear:

1. Tableau building. The family tree is your tableau, because it represents the powers and actions that are available to you. A lot of card games have a similar mechanic (Race for the Galaxy is one of the best and most famous ones), but in Lasting Legacy the tableau has a twist: It’s dynamic. People can only make a contribution while they’re alive, so your tableau will change as decades go by, and you’ll have to adapt your strategy and plan ahead to take full advantage of it.
2. Hand management. Your friends are a very similar resource to a hand of cards in most games. You may be able to bring them into play as part of your family, or maybe you can do their action once and discard them. This hand of cards is also very dynamic and it changes with the friendship levels and your family prestige.

Those two mechanics are very common in card and board games. That’s not surprising since Lasting Legacy has strong board game influences. However, Lasting Legacy is not a board game, and it would be very difficult to make a straight translation into a physical game. There’s a light simulation under the hood that makes people do things by themselves: have children, propose in marriage, pick occupations (unless you pick them for them), etc. Hopefully it’s a good blend borrowing the best of both the digital and the physical worlds.

Want to find out more about Lasting Legacy as we announce it? Make sure you sign up for our mailing list and/or join the Facebook page.

Once you have defined that feel, you can run every single design decision by it. Every game feature should support those feelings in some way, if not, they’re a good candidate to cut. And if some contradict them directly, you can veto them right away and not go down that path any further.

For Lasting Legacy, we have two main feelings we want to evoke in players:

1. Experiencing the drama of complex family stories.

A playthrough of Lasting Legacy lasts about 20-30 minutes and the game is intended to be played over many times (more details on this for a later post). Each of those playthroughs is completely different, and the player experiences an entirely different story of a family through the generations. The combination of the player’s actions and the behaviors of the game characters should create funny, memorable, and sometimes bizarre situations.

For example, this is a recount of something that happened in just one of the generations of one of my recent plays of the game:

The Novak family was pennyless and without any income. Mr. and Ms. Novak spent all their effort into trying to gain prestige and money to secure a place in society. They had two children, Jakab and Andrea. Jakab, unfortunately, ended up being the Town Gossipmonger and never held any real jobs. Andrea managed to become a Baker, but the income was meager.

Things started looking up when Andrea, caught the eye of Mr. Kende, a handsome, rich friend of the family. They were quickly married and the family felt the relief as they had access to Mr. Kende’s fortune. The parents approved very strongly of this union and made sure that Andrea would become the heir of the family.

Years passed, and even though the disappointing Jakab was married and provided numerous grandchildren to Mr. Novak, Andrea and Mr. Kende didn’t have any children of their own yet. This was a grave cause of concern for her parents, who even encouraged them to see an herbalist to increase their fertility. A few more years passed and at this point it was clear that there would be no children out of that marriage. Something had to be done or the dynasty would end right there.

Jakab started spreading rumors about how Mr. Kende had come by his fortune through shady means, hoping to hurt his reputation and have his parents choose him as the new heir. His attempt failed, ended up being further distanced from his parents, and Andrea was still the sole heir.

Mr. and Ms. Novak died after some time, and Andrea and Mr. Kende, still childless, became the new head of the family. It looked like the dynasty would end here, but that’s when they became acquainted with Ms. Bognar, the orphanage director. She was able to facilitate the adoption of Henrietta, an adorable 6 year-old girl who would become the hope of the family’s future for years to come.

We want to be able to let players share their most memorable stories, but we haven’t fleshed out exactly how we’re going to do that. As you can see from the previous paragraphs, it’s not a trivial matter. One possibility is to export some kind of autogenerated scrapbook that players can annotate if they want to, but there are many other ways we can go wit this (Any great ideas? Let us know in the comments).

2. Feeling smart for discovering combinations of occupations that create really powerful outcomes.

The explicit goal of Lasting Legacy is to score as many points as possible (i.e. build the largest legacy). In order to do that, players will acquire gold, prestige, and eventually turn it into legacy through different means. To get really high scores, players will have to carefully combine the actions and abilities from the different members of their family and their friends. The more outrageous the combination, the bigger the score.

This is an example of the kind of thinking that goes behind finding combinations of powers:

The current head of the family likes prestige and will give 1 legacy for every 10 prestige the family earns. You have a Philantropic Benefactor in your family that gives you 5 prestige for every 50 gold you “donate”, but gold is running low. However, you also have access to a Ruthless Negotiator, who reduces all action costs by half, so each Philanthropic Benefactor activation gives you 5 prestige for 25 gold. This works for a few years, but you’re almost out of money.

Then you notice that one of your friends is a Radical Anarchist, whose power is to get rid of all debt but he goes to jail. So you bring him to the family, rack up the debt to the maximum with the Philanthropic Benefactor, and finally send off the Radical Anarchist to erase all the debt. As a result, you gained a large amount of legacy, greatly increased your prestige, and didn’t spend much gold in the process.

This is very similar to the kind of combination of powers you find in games like Magic: The Gathering (a huge influence on me in general), and also reminiscent of the specialists powers in Subterfuge.

Those two goals are orthogonal. I could see some players enjoying one but not caring about the other, so we’re making the game that can be enjoyable even if you just care about one of those aspects. We’re making sure that both kinds of players can enjoy the game to the fullest. Someone who mostly cares about the stories, can just focus on growing the family and dealing with the emerging drama. On the other hand, someone who cares about maximizing their score also need to maintain the family going because it means playing longer and scoring more points, but they can ignore the in-game meaning of the actions they’re taking and just visualize it in terms of how big of a legacy they’re creating.

We hope that once players have played through the game many times and they become really good at it, that they ignore the explicit game goals and make their own constraints. The game becomes more of a toy at that point (unconstrained play) which is an aspect I love in games (we did that with Casey’s Contraptions as well). For example, the player may want to decide to play through a family in extreme poverty that never earns any gold, or a family that is all made out of criminals and low-life characters, or maybe just try to breed the most extreme physical characteristics possible. We hope there’s a lot of room for exploration and enjoyment beyond just getting high scores.

You can read more about Lasting Legacy in the official web site. There isn’t a lot of information yet, but we wanted to announce it now so we can talk openly about it until release. We’ll definitely be revealing more information here over the upcoming weeks.

Platforms

The first thing that might surprise some people is that we’re going to release Lasting Legacy for Windows and Mac first (hopefully through Steam). This is a departure from all of my games as an independent developer, but I feel that PC is a better fit than mobile for Lasting Legacy. Also, I know Steam is flooded with new game releases, but it’s not quite the mad house that mobile is these days, especially for a game that follows the old “pay-once play-forever” approach.

It won’t be difficult to make a tablet/phone version later, so assuming it’s moderately successful, we’re likely to make an iOS version afterwards (Android is such a horrible development environment for native C games, that it probably won’t be worth our time). And I suppose there’s always the possibility of a console version if the opportunity presents itself.

Goals

Why are we making Lasting Legacy? There are several high-level goals I had for my next project.

1. Shorter development. When I look back at the development times of the games I released over the years, I see a disturbing trend.
   

   I really didn’t want my next project to take nearly as long as Subterfuge did. Part of it meant tackling a game with a smaller scope, and part of it meant making it single player. My hope is that Lasting Legacy takes us less than 18 months from start to launch. Let’s see if we can make it.

2. Potential for wide appeal. The nature of Subterfuge meant that it was always a very niche product. We went into it knowing that and we successfully created a game that a very small percentage of people really love. This time I wanted to change things and wanted to create a game that had potential for wide appeal. It doesn’t mean that it’s going to be a clone of existing games or that we’re going to dumb down anything. It just means that more people might like it, and some will hopefully love it as much as the devoted Subterfuge fans.

   So far, in the extremely tiny, non-statistically meaningful sample of our close families, my wife, who is definitely not a video gamer, really likes the idea of the game and is interested to hear more about it (which is more than I can say for any of my projects since Flower Garden).

3. Low money investment. Maybe it’s not quite the Indipocalypse but there’s no doubt it’s a lot harder to make money from selling independent, original games than it was 5 years ago. Because of that, I don’t feel comfortable investing a large amount of money into a project that might or might not end up being financially successful. That means picking a game that we can do almost completely between the two of us, minimizing the amount of contracting we have to do, and the scope of Lasting Legacy is perfect for that.

Roadmap

We still have a lot of work to do ahead of us.

• Steam Greenlight. Once we have a lot more content in the game, we’ll be able to create a video for the game and get it on Steam through the Greenlight process.
• Early access. Once we’re on Steam, we’ll have a period of Early Access. Because the Lasting Legacy is highly replayable, it’s going to be a good candidate for Early Access. That time is also really going to help us fine tune the balance of the game and take player feedback into account for the final release.
• Release. When will this be? Once the game is done (but it better be this year!!).

Want to help us make Lasting Legacy a success? Make sure you sign up for the mailing list and/or join the Facebook page. Apart from progress updates, we’ll announce when the game is on Greenlight so you can help vote us through it. Once we hit Early Access, we’d love it if you can play the game and send us your feedback.

Some interesting observations:

• I made zero income in my first two years as as independent developer! I was supplementing my income writing a column for Game Developer Magazine, teaching classes, and doing some contracting. I even started interviewing thinking I would have to give up the indie life and go back to work for a company. I always tell new game developers to be ready not to make any money for a while for this reason.
• Flower Garden seems to have a reasonable tail in spite of minimal updates. Every so often I feel a bit guilty for not doing more with it, but even if I wanted to spend time on it, I can’t think of anything that would increase sales.
• Subterfuge is a blip in the radar. But what’s even worse, Subterfuge took 3.5 years to make, whereas Flower Garden was around 2 years (including all updates).
• The US tax system isn’t really set up for people with really spikey income like this.
• I need to make games more quickly.

Here’s to releasing a game in 2017 that is visible on that chart!

Instead, I’m going to try something a bit different. I want to highlight the games that have had the most influence on me as a game maker. Not the best games, not the most memorable games, not the most impressive games, but the ones that have directly influenced me and the games I’ve made.

It was actually really hard coming up with this list. I initially had games that I absolutely love as a player and I spent many hours playing them. When I started fleshing things out, I realized they didn’t directly influence me as a designer, so I ended up cutting them, even though it was really hard to do that (anyone who knows me will wonder why Fallout or Master of Orion are missing from this list).

Sorcery (1985)

This game single-handedly set me in the course of making games. I saw Sorcery at a friend’s house, and I knew I had to make my own games, even before I owned a computer. I was blown away with everything about it: The sense of exploration and adventure, the atmosphere, the graphics, and the gameplay. I even dared replay this game recently and it mostly stands the test of time (although the tunnels over water are as frustrating as always).

The Hobbit (1982)

This is the oldest game in the list, but I actually didn’t discover until later. The Hobbit, along with other text adventures, changed my preconceptions of what games could do. I felt I was free to walk around and interact with the world in any way I wanted in a way that graphic adventure games wouldn’t let me.

I also learned the power of text in games, and how some good paragraphs of text can be much more evocative than graphics.

All of this led to the first serious game I completed: La máquina del tiempo (which was an adaptation of H.G. Well’s The Time Machine).

Macadam Bumper (1985)

This was the first game I played that allowed me to create my own levels (I suppose that in another world I should have played the earlier Pinball Construction Set). For a budding game creator, this was a dream come true. I remember spending many afternoons with my cousin making our own version of a pinball table at the local arcade. I didn’t play it much beyond that, but the seed of games with built-in level creation had been planted.

Casey’s Contraptions is clearly the game I created that was most directly influenced by Macadam Bumper.

Sim City (1989)

The idea of a game being a simulation you can interact with was completely new to me, and I was instantly drawn to Sim City (even with the horrendous initial graphics). Later versions became much prettier and refined, but the basic idea remained the same. As a game designer, simulations are probably my favorite genre, and I’m planning on exploring them more in the future.

Magic: The Gathering (1994)

Another love at first sight. So many ideas from this game were new to me! Customization, card interactions, expandability… I also saw first hand how a game can grow beyond being a game that you play and “finish” to a full hobby that becomes part of your life. I’ve taken some breaks from the game over the years, but even today I’m playing it quite actively.

In spite of its flaws, I consider it one of the best and deepest games I’ve ever played.

There’s a lot I could write about Magic, but I’m going to save it for another (or multiple) posts down the line.

Braid (2008)

Braid (along with World of Goo) really showed me how an independent developer can make not just similar, but better and different games than traditional companies. This was particularly relevant to me at the time since it was around the time I had quit my full-time job to go independent and make games with a friend.

Playing through Braid and listening to Jon’s talks also opened my eyes to the idea of deliberate design. In Braid everything has a reason to be where it is. Every puzzle explores a slightly different consequence of the rules of the game (even when they’re not very player friendly). That’s an important idea I’ve tried to carry with me since then, and it definitely had an impact in Subterfuge.

Binding of Isaac (2011)

Binding of Isaac is a bit of an odd duck in this list. I’m usually not a big fan of games that rely on speed and reflexes, yet Binding of Isaac is very much a twitch game. It’s also a game that was not love at first sight. I played it for a bit and put it down. I even remember asking on Twitter what’s so good about it. Fortunately some friends convinced me to give it another try, thinking about it less as an arcade game and more as the rogue-like it really is. At that point everything clicked in and I was hooked.

It was my first and strongest experience with rogue-like games (sorry Spelunky, I tried but never really got into you). I fell in love with the idea of games that can be completed relatively quickly, but are intended to be replayed over and over as things change from play to play.

Observations

I had no idea what list I was going to come up with when I started writing this, so it’s quite interesting to see the date distribution. There are more games from the 80s in this list than any other decade. That’s to be expected since that was my first contact with games and that’s when I had the strongest influences.

What’s more interesting is that all decades since then are represented. I consider myself to be pretty jaded with respect to games (and movies and books), so it takes a lot for me to take notice of something and get excited about it. So I’m really glad to see that there are standout games recently that wow me with something new and awesome.

Another interesting point is that there are no Japanese games in this list. Most game developers I know (especially in the US), grew up with Nintendo and Sega consoles and playing lots of Japanese games there. On the other hand, I never played more than 5 minutes of a Mario, Zelda, or Castlevania game! Instead, I grew up on Jet Set Willy, Roland in Time, and Dizzy. Whether you want it or not, that definitely changes the way I see and interpret games today (it never happened, but maybe I’ll revisit the idea in the future).

At one point I was even going to use that source of uniqueness to make a game based around my love of the old games I grew up with. The idea was to present something familiar but that would be different to most people that had a different gaming background than me.

Finally, the game I’m currently working on (which I hope we can announce any day now) has very clear influences from games on this list:

• Strong game element interactions and combinations(Magic: The Gathering).
• Some simulation elements (Sim City).
• Deliberate design (Braid).
• Rogue-like structure (Binding of Isaac).

Hopefully next post I can finally talk about this super-duper secret project.

Happy new year!

2015 was the year when I started focusing on playing more often the games I loved, and stopped chasing after trying all the hot new games.

Towards the end of 2014 it dawned on me that most new board games I was playing were ranging from bad to just OK, and only a selected few made it into the good or very good category. So why was I spending so much time and energy playing new games? It’s not like I had played the old ones too much and was done with them. As a matter of fact, I was frustrated with how little I was playing them, and how, if I only play a game once every six months or a year, I’m basically starting over from scratch. So I was always playing games at a very superficial level, without being able to get deeper into them. Not to mention it’s a pleasure to pull out a game and not have to worry about reading or explaining the rules!

2015 was the year of depth for me.

Of course depth comes at the cost of breath, so when it comes time to make a best-of list for 2015, I don’t have nearly as many different games to draw on as other years. Because of that, I’ll limit my list to just 3 games.

Honorable mention: Magic: The Gathering

Magic: the Gathering and I go a long way back. I’ve played Magic on and off for over 20 years and it’s irrevocably intertwined with a lot of the different stages of my life. It has also strongly influenced me as a game designer.

But why list Magic as one of the best games of this year? Because I started playing seriously it again and it’s an amazing game, in every way better than it was in 1995. Standard competitive play is constantly evolving and adapting, and booster draft is very balanced, fun, and skill-intensive. Wizards of the Coast did an amazing job with the Khans of Tarkir, Fate Reforged, Dragons of Tarkir, and Origins sets, and even though Battle for Zendikar was a big let down, I have my hopes up for Shadows Over Innistrad.

3. The Gallerist

Even though I’m moving away from complex games, one of my favorite games of 2015 was The Gallerist by Vital Lacerda. Kanban, by the same author, snuck in my top games of all time list that I created last year, and I like the Gallerist better. The theme is quite unique, the mechanics fresh and different, and you’re hardly ever locked out of a particular action, which is something I find very frustrating in games. The game feels like a giant puzzle with lots of gears where you need to figure out how to make the most money before the end.

To top it off, my wife Amy had a painting accepted in the abstract paintings category, so it’s really cool to play a game with a piece of her art in it.

2. Grand Austria Hotel

I love it when a neat theme meets good design into a very cohesive game. That’s exactly what happened in Grand Austria Hotel, and somehow, it manages to go beyond the usual resource-conversion-to-points-engine to something fairly unique and interesting. Two warnings with this game though: 1) It can be a bit brain-burning towards the end with all the bonus actions, and 2) I would avoid playing this at full player count. There’s a fair amount of downtime, and the board state would probably change too much between turns. It worked great at two players and I suspect it would be good with three as well.

1. Pandemic Legacy

(Spoiler free) And the #1 game for 2015 is… Pandemic Legacy! But… this is not the glowing review you may be expecting of the game that rocketed up the BGG rankings and was the first game to displace the Twilight Struggle from the top spot in many years.

I love Pandemic and I love the Pandemic expansions. My wife and I play it frequently and it’s always a fun experience, teetering between success and world collapse. We can play it over and over. None of this should be a surprise since Pandemic was #6 of my all-time games list from last year.

How about Pandemic Legacy? Frankly, if I have to choose, I’ll pick regular Pandemic. Pandemic Legacy is a nice little distraction. It’s a sequence of games where the rules keep changing a bit, sometimes half way through a game. If I didn’t already know and love Pandemic, I might even find it annoying. We’re only about half way through the campaign, but I feel that nothing we do has a meaningful impact in the overall storyline. Things are going to happen independently of what you do, and you’re just going to reveal the next card in the legacy deck.

Still, is Pandemic Legacy fun? Yes, but because it’s Pandemic. It’s good enough to take the #1 spot for 2015 for me. But plain Pandemic is better and it’s the place you should start if you haven’t already.

How about you? Any interesting picks for you top board games of 2015?

Yikes! It was over a year ago! That’s probably the longest gap ever in the history of this blog. What happened? And most importantly for the two of you still reading, what’s going to happen over here?

Subterfuge happened mostly. It was a long project that ran much longer than we expected. This last year I was focused on getting Subterfuge out the door. The little bit of writing energy I had went into writing for the Subterfuge development blog.

For those of you who missed it, here are some of the highlights of the stuff I wrote focused on game design. Also check it all out because Ron wrote a bunch of good stuff as well:

• A Board Game At Heart. Where I explain how Subterfuge is more like a board game without any of the physical manifestations of a physical board game.
• Luck in Subterfuge. Applying one of my favorite topics to Subterfuge.
• Balancing Different Paths to Victory. Balancing a competitive, multiplayer game was tricky and new for me. Lots of lessons learned.
• Emergent Depth. Why simplicity and depth are not mutually exclusive.
• Depth-First Design. More on how we first designed Subterfuge for depth.
• Gaming the Game. The pains of a multiplayer, competitive game. And that was even before launch!
• Cycling and Subterfuge. One of the least popular posts, but one of my favorites, highlighting how Subterfuge and road cycling have several similar dynamics.

OK, so I was busy. You get it. What’s going to happen over here in the future? To be honest, it wasn’t an easy decision.

I considered stopping writing new entries in the blog and just leaving it up as an archive. Interesting game design conversations happen over at Twitter fairly frequently and so I have a reduced impulse to write here. Unfortunately those conversations are a) hard to follow b) quickly lost. So if what I write gets split up in a bunch of small tweets, it would be an overall loss.

At the other extreme, I considered getting back on a regular schedule and writing one article every week while back in the days of #idevblogaday. It’s tempting, but I didn’t like the pressure to have something written by a particular day. Nor did I like to feel that I had to come up with a significant, polished article.

So instead I’ll take a middle road: I’ll write relatively short posts in a relatively frequent schedule. How’s that for vague?

As for the content of the posts, it will all be centered around game design (probably not much pure programming anymore) and hopefully cover all the phases of my next project. I’m also curious about possibly doing some streaming, but I have to find some content that fits well with that medium.

If you have some topics you’d like me to cover, make sure to let me know on the comments or on Twitter.

Happy 2016 everybody!