Hi all, Oliver here. This week I’m going to talk about how we’re putting together Imperia’s story structure – or, I should say, taking it apart and putting it back together again. I’ll refrain from giving away any plot details, so if you’re worried about spoilers, you can relax now.

Initially, the plan was to produce a story tree on which a single ‘cursor’ (in the programming sense) would progress from node to node, reacting to the gamestate, producing in-game effects and Twine-like interludes at each, until it hit an ending. And this structure I actually designed. Now this had a certain obvious inelegance – by the time you got to the bottom, there were four or five duplicates of most of the endings. But the real issue was that between any given adjacent pair of plot points you had to account for a whole pile of different potential circumstances: the gamestate might shift one of a whole pile of different ways, meaning each branch point needed to have a number of permitted outcomes. In practice, they couldn’t all have that many, producing a design which, while flexible, would in practice have come up with some weird situations.

This was all brought into focus when we introduced a couple of minor changes to the plot. Having read some really interesting and useful articles on plot structure (here and here, both well worth a read if you’re interested in interactive story design) I realised that what we needed was a ground-up restructure of the whole system. The result – which I’m in the process of setting out right now – is a system involving a number of parallel ‘blocks’ along which independent cursors progress and sometimes regress. Each block has several parallel versions, between which its cursor can move according to the gamestate – in particular, when certain characters have progressed along one or another of their potential character arcs, booleans will be flipped that shift several blocks from one version to another. The Twine-esque interludes and the in-game effects are still very much there, and are still triggered by the arrival of cursors at nodes, but rather than an enormous combinatorial explosion like we would face in an old-school Choose Your Own Adventure-style decision tree, the system allows unrelated chains of events to proceed in parallel without interfering with one another. If a character is not involved in a given part of the story, for example, Booleans relating to their character arc simply need not be considered.

This doesn’t just apply to separate, parallel storylines – not to give too much away, there aren’t many of those – but also to fixed points in the story that are only affected by one or two variables. I would give an example, but that would rather spoil the fun – I’d better stop writing before I give anything away.

Until next time,

Oliver

Advertisements

Leave a Reply

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

WordPress.com Logo

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

Twitter picture

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

Facebook photo

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

Google+ photo

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

Connecting to %s