Romance without routes. Breaking the CYOA/VN formula

Choice-based interactive-fiction comes in a whole bunch of narrative models. If you haven’t read the These Heterogenous Tasks article, Standard Patterns in Choice-Based Games, you should run right out and do that. It’s excellent, and I’ll be making some references to it. I’ll wait. Promise.

Done that? Good, let’s move along.

Probably the single most familiar pattern in Visual Novel romances is the Sorting Hat model. This typically follows the model of a first-act, which performs the usual first-act functions, as well as a series of choices that ultimately funnel the user down a specific narrative route that is distinct from the others. These routes take the function of second/third/final-act and terminate in one or more possible endings. Once a route commences, the user is committed to it.

Pick up any Visual Novel romance, and the odds are at least eight out of ten that you’re following this model. A branch-and-bottleneck first-act, followed by the Sorting Hat’s distinct, individual routes (usually along the Gauntlet model).

It’s common, and it’s effective, and … well, I started thinking that perhaps it was time to move on from that a little.

That was part of the motivation for the Argus Story Engine (which drives SNAFU – which is still coming along very nicely, if nowhere near as quickly as I’d like).

If you’re one of the regulars here, you already know that Argus isn’t limited to one character or a story built on one character’s set of choices, allowing multiple characters to have empowered, simultaneously play of the narrative, any of whom you may play. You’re already across that.

Instead, I’m talking about a different (and I think equally nifty) aspect of the engine. The way it handles arcs, scenes, characters and casting.

A story in Argus could be as simple and linear as a kinetic novel, with no choice-based interaction at all. Or you could produce pretty much any of the standard choice-based design patterns with it.

Or you could do something far cooler.

Argus operates in scenes, as you might expect from a CYOA/VN engine, even though the scenes are much more intricate than other engines deal with. In Argus, scenes (as logical units) are grouped into larger abstracts called Arcs.

An Arc, is essentially a story arc. You don’t need story arcs explained to you in general, so I can skip over that part. Argus’ Arcs are collections of scenes that form a story arc, and that can be scheduled by the Narrator module.

In old-school VN terms, you could think of an Arc as a route, but we can have more than one of them happening at a time. Short ones, long ones, branching ones, linear ones, with their individual scenes scheduled and interspersed by the Narrator into what (hopefully) winds up as a single, cohesive overarching story, containing a lot of individual story arcs.

You know, just like regular stories have.

Argus’ narrator tries to find Arcs that match certain preconditions, so it can set them running. Two characters who like each-other enough for a budding romance? Or two and a rival? Or a character who has been wronged and seeking revenge? A mystery to be solved, requiring four meddling kids and their dog? Or can some Arcs not take place before, after, or concurrently with certain other Arcs? That’s a factor too.

Once the Narrator has determined that one or more Arcs are plausible, the Narrator starts to schedule scenes according to supplied criteria. There could be a number of those (some scenes might have to take place at certain times or in certain locations, for example). Advancing the story of an Arc requires some scheduling.

There’s also casting to consider. Argus’ scenes can just be pure hand-crafted, artisanal narrative. Some of the scenes in SNAFU are certainly no more than that. But many of them are not. Ultimately most of them, when SNAFU is complete won’t be that simple. Instead, scenes are specialisable templates.

Characters in the story (Actors) are assigned to Roles in the scene by Argus’ Narrator.

In one Arc in chapter one, there are three roles assigned – but I don’t know which characters will be assigned to specific roles within the scenes. Who winds up in each role depends on previous choices made by two of them (and by a third character who isn’t present in this Arc).

Depending on who is cast for which roles, the narrative varies, alternate choices may be present or absent, and different Arcs may become available down the track, later in the story.

Casting actors for a variety of roles can lean on all sorts of criteria. You could, for example, cast a scene whose requirements are: three students, one of whom is female, and one of whom is male and does not like the other two, plus an adult teacher.

Assuming the Narrator can fulfil all of the requirements the scene will go ahead (whether the human player/reader’s character is a part of that scene or not – if not, then the player simply will not see it. The participating characters will still have the scene, and any effects, choices or changes that are made will apply to the story and characters).

Mostly, the Arc-based underpinning of the narrative isn’t particularly obvious. The story might, on a first play-through appear to be any one of a number of the other models. On the surface, it probably looks most like the Branch/Bottleneck model.

It isn’t. It only looks that way if you play/read through once. Or maybe twice. This is a non-random Floating Modules model disguising itself as a consistent narrative.

So, there’s no routes here. That notion doesn’t work here. We have interwoven character stories, built from parts, the way any writer might, and combined in unique ways to tell personal stories against the backdrop of external forces and events.

It’s a hell of a thing to write and implement, but I think the results will be worth the effort.