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 6x6). 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.

Subscribe to my mailing list

Wish me luck!

My early-in-development creative process.

I don’t usually bother fleshing individual ideas out in design documents because it usually takes just as long for me to implement those things and see them in the game instead. And who would want to read about an idea when you can see how it works in the game directly?

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.