Stupidly Ambitious

Argus, regrettably, doesn’t have a specialised authoring tool – not yet, anyway. Authoring is done with just a text editor. Within the last few days, I’ve added file-inclusion, so that I’m no longer chasing my tail across 13,000 lines of source-text trying to find a particular scene. More on the files later.

If I had to characterise the project, I’d call it “stupidly ambitious.”

So, I’ve got thirteen(-ish) storylines to manage, which all branch and interweave in various ways. Some form of tracking and visualisation is important.

The image above is actually from another engine, specifically Twine. Yes, I’m actually using another interactive-fiction engine to keep track of the basic scene structure of my own story for my own engine.

Argus structures narrative into scenes, and like other choice-based interactive-fiction systems, scenes branch out to other scenes, but scenes are more complex than they would be in other systems.

Scenes have a cast. Anywhere from one character to a whole lot of characters, main and minor. Every main (playable) character in a scene’s cast needs narrative for everything that happens in that scene. Provisionally, I’m calling those “scene-lines”, because I’ve got to call them something.

So every main character gets a scene-line for every scene they appear in, but scene-lines aren’t necessarily straight. A main character may make a choice which causes the remainder of the scene to happen differently to how it might have otherwise.

Alternatively, characters may have made choices previously that have changed their knowledge, opinions or relationships, which cause the current scene to be different.

If everything is too different, I probably need two (or more) scenes, but those scenes may still be jam-packed with alternative dialogue, narrative or events. There are even sub-scenes (scenes we can perform and then resume the current scene). Scenes within scenes within scenes, if need be.

Imagine you’re at a family Christmas party. You’re in the kitchen, rinsing plates that have gotten a little dusty since the last party. Bob and Janice are talking over a list of things to get before the store closes. Lucy is going to make the trip to get the things, and visit the bottle-shop. The twins are near the tree scheming about ways to open their presents early. Donny is trying to get Greg on the phone because he’s late and nobody’s heard from him.

Everyone needs narrative. Most of them need dialogue. A scene-line for everyone, and you’ve hit five-thousand words before you even turn around.

And then there’s the variations. Donny can’t reach Greg because Greg forgot to charge his mobile phone … that is, unless Greg actually did remember, in which case, everyone knows Greg’s car broke down. In which case, maybe Donny goes to pick him up. Or maybe Lucy does, and Bob and Janice are making the list for Donny- which leaves you watching over the terrible twins, rather than rinsing plates, unless Bob (or Janice) does it, and you help make the list with Janice (or Bob).

Before you know it, you’ve got a dozen variations on events just within a single scene, and a heap of alternate paths down which the characters might wind up progressing.

Making some sort of chart helps a lot. Even just scrawling something on paper, to help you to maintain continuity across so many alternate realities. What’s more important, though, is keeping a to-do list. Which scene-lines are written? Which ones are missing? Have I written Janice’s scene-line all the way through scene 31’s variations? Have I not written Bob’s parts at all?

Any kind of project-management software is good. Tracking this stuff needs a task-list, and every new scene spawns a whole bunch of tasks, each of which has to be completed so that a main character doesn’t just fall off the map in mid-story.

I’m yet to discover whether dynamic scenes will help me simplify this or make things more complex. Argus supports dynamic scenes (and by extension, dynamic story arcs). A dynamic scene is a scene where one or more of the cast-members for that scene is indeterminate at the time of writing.

You specify the conditions under which the role is cast, and the narrator attempts to find a character that fits all of the conditions.

In one of SNAFU’s dynamic scenes, there are three roles. The first two roles can be either of two characters (which one takes which role depends on their prior choices). The third role is filled by one of two other characters. Which one of those two is chosen is entirely dependent on a choice another (fifth) character has made. Although there’s a chance that this scene will never actually take place in a given run, because hey, characters chose differently this time.

So, based on the previous choices of some characters, three out of four actors are cast into various roles within the scene, and then the narrative plays out. There are ways to partially specialise a scene by testing which actual character got cast into a specific role, and providing alternative/additional narrative and dialogue and even alternative choices, if need be, or you can let the characters play their assigned parts.

Scenes can take role-assignments from the cast of other scenes, allowing you to form entire story-arcs where roles were assigned to characters based on a variety of information, relationship-status, likes or dislikes.

What does all of that mean right now? It means that the diagram attached to this post is nowhere near as complex as the reality, since there’s branches and variations within scenes. Thankfully, people usually do things in groups, so the scenes I have so far are almost all for somewhere between two and a dozen actors.

So, the fact that I’ve aggressively pruned story-branches back into one major set of scenes for the latter part of Chapter One does not mean that there’s only a single narrative going on or that there’s only a single branch.

Like life, the reality is much more complex.

In any case, progress-wise, it has been a code-week not a writing-week, so the story is only up to 132,000 words. Closing in on the end of the Chapter.