Overboard!, inkle's new game, is a whodunnit in reverse: on a boat with six suspects, the player takes the role of the murderer, and the goal of the game isn't to catch the killer, but rather to make sure the wrong person takes the blame. The player does this by spinning lies, avoiding accusations, and planting evidence on other people. 

But at the end of the game, like any classic whodunnit, the suspects are gathered together by the detective character in a room, and the plot is laid bare. The final scene attempts to take all the things you've done (or failed to do) throughout the course of the game, knit them into a coherent scene, and then produce a result that feels fair. 

This final scene is assembled from pieces using a system somewhere between an authored branching flow and a bark-system. We built this in ink and it uses a few core features of that language, though it would be possible to recreate in other systems.

Note: the following article includes some mild spoilers for the story of Overboard! If you want to play the game fresh, please don't read this yet!

Underlying Knowledge

The game is played through choices of where to go and what to say. Other characters move around the boat on schedules; it can be useful to catch them, and equally useful to be in a location unobserved! Characters all know different things about each other, so interrogation is vital to getting the information you need to form strategies. 

As you take actions, and learn facts, there's a knowledge model which is keeping track of what you know, and also what other characters know. Characters can find things independently of you; characters can even meet up when the player isn't present and share information.

This knowledge model is the only thing the game uses to pace and determine the final scene. Every relevant fact is stored there. So the main game can be seen as a process of setting the input conditions, and the concluding scene is the black box that takes input, and generates one of the various endings that the game allows. 

Core Spine 

The flow of conversation is built around a central spine, which broadly speaking dictates what would happen if the player did nothing and no initial information was set. In this flow, the detective introduces the crime, various characters contribute what they know about it, and a conclusion is reached. 

This conclusion is delivered as a series of beats. 

The core spine is short and sweet, and largely a monologue! 

Curveballs and Home Runs 

Having built this core spine, it's now up to the various characters in the scene - including, but not limited to, the player - to throw this conversation off course. This is done by inserting coherent "barks", distraction and side-topics in the flow, in places where they naturally go. 

For example, after the detective introduces the idea that the husband is missing, one of the passengers on the boat cries out in despair: "I knew it!" The player can then jump in, either to treat that as an admission of guilt, or to dismiss it, to try and divert the conversation back to its main flow. 

These side comments and diversions are all gated by logical preconditions - Clarissa can't call out if she has also been murdered, and Lady H won't accuse you to your face if you've threatened her. Carstairs won't bring up the matter of the missing earring if he never saw it, or if you convinced him it was no significant. Because we have a core spine to follow, diversions which are not taken aren't a problem - the flow continues past them regardless.

Diversions which are taken can open up whole new possibilities, however. The results of a side conversation aren't systemic, and can vary depending on the particular line the player chooses, or what their relationships are like with other characters in the game, or what other facts are present in the knowledge model. 

Sometimes a side-flow will be brief, and sometimes it'll spin off a whole side conversation. Side conversations rejoin the main spine eventually, but they can also contain curveballs and distractions, which can take the flow into further side conversations. 

And the knowledge model is still active - so things which are said or revealed during these side conversations can be used later in the conclusion scene to alter the course of the conversation further. Some of these revelations can be very significant indeed, causing the core spine to skip over a beat which has become unnecessary.

Some are so significant they complete the scene - a home run, so to speak, that lands an accusation permanently on a character.  

Patchwork

So far this sounds like a branching tree, albeit one grounded in a strong model, but it's not, because the same diversion can be triggered at multiple places in the script. The game ensures that if a diversion has already been seen it isn't run again; and keeps track of where the diversion was invoked, so if the side thread collapses uneventually it can return to where it was. (Both of these are easy to implement in ink, using read counts and tunnels respectively.)

This means the steward can mention the same evidence in different contexts. Perhaps he has found an incriminating bottle of pills in your cabin - does he bring them up at the moment your character comes into question? Or the moment when the same bottle of pills is being used to pin the blame on another character? 

By patching in the steward's dialogue about the pills in both places, it ensures that he always gets to speak his piece, and by referencing the knowledge model, we can be sure he delivers his information in a way that makes sense in the current context. 

It also means that as designers we don't need to keep track of the overall state of the knowledge model while writing our alternatives. So long as characters are trying to offer their input in relevant places, and so long as that input is always tested by the relevant preconditions when it is invoked, we can ensure that the key elements of the plot come to life as and when they're needed - with the core spine serving as a "fallback" position, should the no one know what to say next! 

It also allows us to deliver the occasional Poirot-style bait-and-switch, in which the finger of guilt is firmly pointing one way, only to swing at the last moment, when another character "patches in" a curveball which significantly changes the state of play. 

Adding Complexity 

In the process of play-testing Overboard! we were continually finding and adding new strategies to the main game - enabling alternative sets of initial conditions. 

This became a relatively simple process to manage: after adding a new piece of evidence - say, an incriminating piece of blackmail - a new diversion was written to deliver that information in the final scene, and that diversion was then patched in to all the places where it made sense for it to go. These diversions were guaranteed not to break the flow because there was always a clear direction to the core spine. 

It was also straightforward to remove characters from the scene! If characters had died during the game, then they're not available to patch in their comments and reactions, so we test for their existence before they speak and continue onwards if they're not there.

So... who did it? 

The final conclusion is determined based on elements of the knowledge model which are flagged as "core evidence". Each piece of core evidence lands guilt firmly on one person (in the eyes of the detective; other characters may still disagree!) 

At the moment of the verdict, if there is enough core evidence against one person, the detective will accuse them; otherwise the death is ruled a suicide. 

(Of course, we include several opportunties for the player to choose the wrong to say and incriminate themselves. That's half the fun.)