Art Styles

One of the ways that Six Ages is following in the footsteps of its predecessor is to use very distinct art styles for different purposes. Here’s a brief look at the directions we’re going.

The Distant Past

HealerAlthough we debated a variety of styles, in the end we decided to stick with a “woodcut” look to represent things that took place a long time ago (i.e. for the clan questionnaire). I found our artist because she had a show at the gallery a few blocks away. Here’s a look at a Gods War event by Damara Kaminecki.

The Present

Troll tradersKeeping the ink and watercolor style for the bulk of the illustrations, which are set in the here-and-now, was not really questioned. We did consider different nuances, and Jan Pospíšil did a few test pieces. There are a number of artists working in this style — this is one of Jan’s early pieces, which helped establish the tone. (Note that the trolls are awake early, since the sun has not fully set.)

The Otherworld

Blue DragonThe world of the gods is key to a game set in Glorantha, and we again wanted a look that was very different from the mundane world. We didn’t have any preconceptions, though once again we were drawn to Magic: The Gathering artists. But we ended up going with a local artist, who has a distinctive style. Here’s Michelle Lockamy’s take on a Gloranthan archetype, the blue dragon.

So It Is Written

Rune of writingThe game just hit an important milestone: our writer/designer Robin D. Laws has completed his work. All of the interactive scenes and myths are written.

This doesn’t mean the game is almost done. If I recall correctly, Robin also finished his work on King of Dragon Pass well before anyone else. But it does shift gameplay development into a refinement phase.

Other aspects of the game have only barely started, such as music and a tutorial. And there’s still a lot of art to draw.

And it’s possible we’ll need a few new scenes, though someone else will likely write them.

A very approximate guess as to how much Robin has written is 400,000 words. (The scene compiler outputs a text file with all the strings, which we will be spell checking. This file contains 402,293 words, though some of these are names of music or other aspects of implementation.) That’s as much as ten short novels!

While you’re waiting to read Robin’s work in Six Ages, you can check out some of his other recent work, which has been nominated for ENnies Awards.

Sweeps Week

s235-pencils-cropSince essentially all of the game’s scenes have been written and coded, I figured it’s time to start sweeping.

“Sweep” is the term we use when we find an issue, and realize that it could apply to every scene in the game.

For example, the bug report

I noticed a [q > 4] which is probably not possible

is something that could affect any scene. So today I searched every script (i.e. swept the code) for similar patterns (e.g. [q = 4] was also a problem, because in rare cases, the special variable q can indeed be set to 5).

And the task

Tag @cattleWard for Cattle Ward blessing

meant I had to go through every script and see if the blessing (“Protects our cattle herds from predators”) was relevant. If so, the script needed the tag. Going through everything, I realized that the description actually needed to change, to “Protects our cattle herds from raids and predators.”

The sweep that’s had the biggest impact has been

Sweep to be sure ChooseLeader is followed by a leader test

In other words, if you pick a leader, then it’s that leader’s Bargaining or Combat that will be used to overcome opposition. We had tried to catch these cases, but missed a few. And this was by far the most brute force sweep, since ChooseLeader is very common.

It looks like there are about 15 of these in our bug tracker, and about half are done. I expect to finish them this week.


Scene Tags

Since Six Ages is our second iteration of a storytelling game, I wanted to make sure it would be easier to do certain things. Being able to categorize scenes was something that was easy to improve on, since in King of Dragon Pass, everything was a special case. For example, when we wanted to make sure you got to deal with tribal disputes when you were a king, we had to list them all.

switch (COpal::DieRoll(4)) {
 case 1:
 scene = scene_R397TradeDispute;

case 2:
 scene = scene_R398MagicalDispute;

case 3:
 scene = scene_R399PoliticalDispute;

case 4:
 scene = scene_218ComplainORama;

This was fragile — scene_218ComplainORama was actually a fairly late addition in version 2.x, and I had to make sure that it was included in that code.

Likewise any news that was considered a random rumor had to be listed. This at least was data instead of being buried in C++ code, but it was still separate from the actual news.

SceneIDT CScene::gRumors[] = {

So I came up with the idea of tagging scenes. Here’s what the OSL documentation says:

Tags begin with @. They can be any word (e.g. @help, @hurt, @tutorial, @actThree, @endgame, @notEnd, @codeTrigger, @frequent, @infrequent). Tags can be purely informational, only a few have predefined meanings. Feel free to invent tags. Tags could be used when triggering scenes at random. (For example, if the player is doing poorly, there could be an increased chance of an @help scene. If the player is very wealthy, it might be time for an @hurt scene.)

So there could be an @kingly tag and an @rumor tag. Implementing a random rumor can start with something like

rumors = [self scriptsWithTag: @"rumor" ofType: type_News];

which searches all scripts for the tag (also choosing only news scripts). A typical rumor will include the tag

news: news_R14Quake
speaker: WhoHasHighestSkill(ClanMembers, 'magic)
text: I don’t have to tell you about the earthquake, since everyone felt it.

Most of the tags are indeed invented (usually by Robin Laws as he writes scenes). To help check on consistency, the scene compiler outputs a report of tag usage, which lets us make sure it’s consistently @dwarves and not sometimes @mostali or @dwarfs. A few are used internally (e.g. @nameEntry marks a script that needs a name field added to the UI), but most of these let us control the story.

For example, Robin can create a scene where you perform anti-dwarf magic and write, “Scenes tagged @dwarves do not trigger 30 + q seasons,” which can be coded

t = "@dwarves"
w = 30 + q
triggerWithValue code_EnableTag t w

(This takes 4 lines instead of two because of some limitations in the OSL scripting language.) A typical dwarf-related scene would then be tagged

scene: scene_37DwarfTrade
scene037, left, random, @dwarves, @trade, mayRepeat

The arbitrary tags also help implement the magic system. For example, a magical effect can be defined as

 name = "Elf Friend", tag = "@elves",
 explanation = "Helps our dealings with the Aldryami"

which gives a bonus to any scene that has been properly tagged. One of the tasks to do once all scenes are coded is to verify the tagging for magical blessings that depend on it.

Robin extended the idea with what I call dynamic tags. For example, he came up with a scene which could have a variety of outsiders. So he wrote, “scene gains tag @dwarves.” The implementation is

AddSceneTag(ThisScene, "@dwarves")

Obviously, making sure a scene has the right tag for a random outsider is important when there are blessings that are tied to tags.

I’m also making use of tags to help ensure correctness. For example, sometimes a scene wants to trigger another scene years later, but perhaps a character in the scene is off exploring when the time falls due. We handle this by triggering a code fragment, which can handle whether the character is exploring, died, or whatever. This sort of check is usually added once we start testing, and it would be nice to make sure that we caught every place that triggered the delayed scene. So the scene compiler makes sure that any scene marked @triggerFromCode can’t be triggered directly (but only from a code fragment tagged @triggeringCode).

And our unit test that runs every script simply runs them in an arbitrary order. Scenes may rely on having been run in a particular order, so the unit test may need to do setup that would have happened in normal execution. So there are tags like @unitTestWithClan and @unitTestWithPerson. This isn’t necessarily an exact match for normal execution, but it works for this level of brute force testing.

By the way, the @help/@hurt idea is not implemented at the moment. I’m not sure if it will be, but the flexible tagging system makes it easy to add at any time.

Sacred Time Recap

Several King of Dragon Pass players requested a way to see what their Sacred Time allocations of clan magic were. In most cases, advisors will remind you on the relevant screen (especially in version 2, which added a lot of advice to the management screens). For example, in the Magic screen, if you put points into Quest magic, someone will have the advice “We prepared for a quest during Sacred Time. Our chance of success is good” (assuming it’s not trumped by some other circumstances).

Magic ScreenWhen I began Six Ages, I wanted to have a centralized place to see everything. Until recently, it didn’t seem like it would fit. Then Robin Laws suggested showing some other information, and I realized that the Sacred Time allocations could be added as well. (The slider lets you choose to see the gods, or the new other information.)

Concept Inspiration

Raven ConceptSomewhere along the line, Jan Pospíšil drew a concept sketch that I liked, but that didn’t seem right for a member of the player’s clan (which was the original thought).

Recently, Robin Laws and I were going over the interactive scenes that are currently in the game, and figuring out what was lacking. He came up with a new scene that seemed like it perfectly fit the sketch.

So the scene is now written and coded, and we’ll be doing a full illustration based on the quick design. Sometimes good concept ideas never make it into the game, but I’m glad this one can.

Testing In Bulk

Like King of Dragon Pass, Six Ages is a large, complex game. That means that during development, there will be a lot of bugs.

Graph of scenes written, coded, testedThe best way to find them is to start testing early. I like to start QA as early as possible, once there’s a runnable game. For example, we can start the process of making sure every interactive scene works.

We have a really good QA tester, but like KoDP, there are a lot of scenes, with a lot of branches. One of the process improvements over KoDP is that we have a way to brute force test every response of every scene. This is only a supplement to human testing. It can make sure nothing crashes, but can’t find typos or situations where the wrong person is mentioned. But it does mean we don’t waste QA’s time with testing something that isn’t fully implemented.

Some bugs have patterns. If one scene has a problem after the player has made a major story choice, it’s likely that others will too. I usually track these in our bug database as a “sweep,” meaning once all the scenes are coded, we will have to search the code for possible occurrences. We still report fix bugs as we go, and when this situation came up again in a scene, I decided to try out an idea: change the brute-force testing to set up the story situation, and then run the brute-force test. Bingo! Ten failures. Or, ten places that a person doesn’t have to either read code and see what’s going on (in a code sweep), or write up a bug report (manual testing).

Last night I got a bug report about a scene failing when there was no chief. So I decided to do another brute-force test. This found a lot of problems in scenes that had not yet been tested.

Unfortunately, the brute-force testing of every branch of every scene takes about two minutes (and getting worse, as we code more scenes). So while I probably should run each brute-force variant, for now I’m relegating them to occasional situations. But I’m definitely going to look for more places to do this.


When we work with illustrators, we’re still using much the same process as we did with King of Dragon Pass. We first get a thumbnail sketch to figure out the basic layout of the illustration, then get a more refined pencil sketch. We’ve also been reviewing an inked version, and then a colored version. Some of these terms are no longer as literal as they were back in the 1990s (more artists are using a digital process, so there may not be actual pencils or ink pens involved), but the same basic idea of refinement is the same.

One thing I’ve found a bit different in this project is what different artists consider as a thumbnail. I had never seen color used in a thumbnail before, but two artists have done so. And some of the thumbnails are very polished.

A few artists will also produce a lot of alternatives (in one case, a thumbnail was so different that it generated a new scene).

Here’s a representative sample, from five of our artists.


I chose these to show the range of detail. Some of these may not actually end up in the game. But they’re all perfectly good thumbnails that start the process of illustrating an interactive scene.

Header Runes

The runes in the header correspond to the seven personal skills in the game. They’re slightly different than in King of Dragon Pass, since we won’t have quite as big an emphasis on farming. Animals and Plants have been combined into a single skill, Food. And since it’s a clan-level game, we added Diplomacy as an explicit skill, rather than just averaging Bargaining and Leadership. (Bargaining, Combat, Leadership, and Magic are the same. Custom is renamed to Lore to reflect a wider use.)Trade, Death, Harmony, Man, Mastery, Truth, Magic

Most of the skills had fairly obvious runes (Combat = Death, Magic = Magic), but the Food skill gave me trouble until I remembered this:

ManMan rune
Meaning: Mortal humanoids
This Rune represents the humanoid shape, and is common among all intelligent humanoid races. Some other races interpret it as “slave” or “food”.

HeroQuest Glorantha, p. 17

April Progress Update

One big change since the last update: the development blog has moved. That’s the first step in improving the game’s web site.

A recent development focus has been combat, and what King of Dragon Pass called “heroic combat” is now in the game. These are 27 situations where the normal combat flow is interrupted by an opportunity for an individual hero. (King of Dragon Pass had only 16, though one was called “Ten Path Battle” so it’s about the same.) There are also additional opportunities that may occur, which players choose instead of another combat option. (I still need to write “A Chance for Slaughter.”) So while the game still takes a fairly abstract approach to combat that favors narrative, players will get to make more choices during battle.

The Otherworld was another recent focus. We have an artist creating the illustrations, and all but one of the Otherworld travels is written and in the game. This hasn’t been a major focus of testing yet, but they do seem playable.

We continue to test as we go. The game is not complete, but it’s possible to winTrying to lead a clan of 675 people is impossible (thanks to liberal applications of cows from the Debug dialog, Liana has twice won the game). This has given us some feel for what the game still needs, and Robin has been adding scenes to flesh things out or adapt to certain play styles.

There are now 272 scenes coded and 224 that Liana has fully tested. We’re not done creating them, but this is almost as many in the game as were written a month ago.

It’s not technically a scene, but we’re using a script to show a page on the Lore screen that reflects your choices in the initial questionnaire. I’ve probably said it before, but we’re making a lot more use of scripts (compared to King of Dragon Pass).

jewelry designWhile we completed the basic concept art for the game a while ago, we’ve been working on some more specifics (both individuals and Gloranthan cultures). The shared Dropbox folder of sketches and reference material is now 864 MB…

Big tasks coming up soon: starting to think about a tutorial, and music.