Emily Short’s First Draft of the Revolution is a pretty straightforward example of how to do this. It’s an adaptation of epistolary fiction, where the interaction consists of drafting and redrafting letters. The story uses the interaction prompts themselves to reveal more and more of its characters and its world, a complement to the core idea of the epistolary novel as a narrow window into the lives of its characters.

Not all genres lend themselves so readily to this kind of translation, of course. Many attempts and iterations have been made on constructing an interactive mystery story, and those have met with difficulty. In a way, the mystery novel already relies on a form of interactivity (given the expectation that the reader might tease out the solution ahead of the characters), which, when made explicit as actual interactivity, loses its expressive power. Jon Ingold’s Make it Good presents itself as a detective story, but contains a twist that recasts it into a different type of narrative entirely — that twist enables it to have the trappings of a detective story while shaking off the expectations that might render it nonfunctional.

For the sake of an object example, I want to walk through adapting in a different direction. Rather than looking to literary genres and adapting into interactive fiction, I want to think of video game ideas and adapt them into interactive fiction. To pick up on last month’s column about building climactic moments, I’d like to consider the boss fight.

Boss fights work poorly in a lot of games. Often they seem tacked on, nothing but an enemy with an exceedingly long health bar. But where they work well — as in Dark Souls’ gallery of grotesques, or in the Monster Hunter series where the entire game revolves around elaborate boss fights — they can be a real anchor for what a game is about and how it feels to play it. I’m not interested, here, in the fiction of fighting a large monster, but in the underlying mechanical ideas and how we might plunder them for our own use. Maybe the Monster Hunter hunt could be a basis for something else — an emotional confrontation with a character, perhaps.

Monster Hunter’s monsters are, in themselves, complex systems with many mechanics attached to them: they can become enraged, exhausted, or hungry; they can flee in fear; hunters can stun them, make them flinch, mount them, trip up their legs to bring them down or attack their wings to keep them from taking flight. But what makes the hunt a useful example to me is that each one of those systems is individually very simple and straightforward, and they all work in orthogonal ways that are comparable to each other. Stunning the monster is done by dealing “KO damage,” which comes from hitting the head with an impact attack. Mounting the monster is done by dealing “mounting damage,” by attacking it from above, and so on. Those values are hidden to the player (indeed, Monster Hunter tells you almost nothing about the monster’s state explicitly, preferring to use animation and diegetic cues), in much the same way a lot of IF uses underlying variables that are hidden. Tripping, stunning, or toppling the monster creates a big opening to deal damage and move the fight towards its conclusion, but the special damage needed to bring it down increases each time, making it hard to repeatedly employ the same tactics.

How do we think about this in terms of a different kind of story? When trying to persuade someone, or walk them to some emotional catharsis, we might have different weapons we can bring to bear: appealing to their reason, their guilt, their emotional attachments, the opinions of third parties, their better angels (or worse devils). Maybe some of these choices are made ahead of time, before the confrontation even starts; we choose what we bring to the table, much like a hunter chooses which weapon to take into a hunt.

We build a cycle of threat-response-reaction. The adversary starts to make a move, argument, or direct the conversation; the player character responds in some way; the adversary reacts to that response, concluding their original move. In a way, the two characters are talking past each other, each one trying to make their point separately — mimicking plenty of real arguments I’ve been in.

Successfully reacting to a move might create an opening for the player character to insert their own appeals into the conversation, whatever it may be; concluding that argument might break down a barrier that allows the conflict to progress. The characters start by circling around each other warily, but their responses gradually get more aggressive, desperate, and involved. On the adversary’s side, as they approach exhaustion (or catharsis, depending on your story); on the player’s side, as they employ and then discard each tactic available to them in turn.

Of course, this is a very adversarial, even cruel, framework to apply to interactions between two people — maybe that’s right for your story, or maybe not. But I hope the underlying idea is helpful: You can find models for building story mechanics in strange places, and sometimes there’s serendipitous consonance there.

Bruno Dias is a writer and narrative designer based in São Paulo. His work has appeared in video game publications (Waypoint, PC Gamer), games (Where the Water Tastes Like Wine) and interactive fiction on Sub-Q and elsewhere

The post Making Interactive Fiction: Adapting from Other Genres appeared first on sub-Q Magazine.

When a specific scene plays a pivotal role in the story – a key bit of setup, a major confrontation, a climax – it’s often valuable to give that scene a different interaction and mechanical treatment from the rest of the story. Changing how the player interacts can highlight a change of stakes: two characters that were dancing around each other enter open confrontation; a situation that was merely worrying turns dangerous; the monster steps out of the shadows.

This change in the language of interaction we’re using opens up some risks. New mechanical ideas might seem tacked on or underdeveloped, and in a choice-driven story where underlying mechanics (like variables tracking the story’s direction) aren’t shown to the player, the change in rules can seem arbitrary or hard for players to grasp.

But it’s also an opportunity to harmonize the story to the interactivity. A significant scene might have more variability and offer the reader a different class of choices from what they’ve been used to. This consonance between having some richer choices, and the significant story moment surrounding those choices, is very useful in simply allocating your resources. We can only include so much variation and branching in a project, and having the most pivotal story moments vary more dramatically across playthroughs is a good rule of thumb.

Here are a few common ways of thinking about climactic scenes in interactive narratives:

Cashing in chips: The player spends the entire story building up to this moment, accumulating something that feeds into this confrontation. This is a classic adventure-fantasy structure — we spend the book collecting macguffins that all feed into the final boss fight — but you can use it in other ways, too. Mystery stories (how much evidence do you present at the moment when you accuse the culprit?) are another example.

Sorting: The player’s overall decision-making is judged, and the story branches (possibly into an ending) from there. There’s a complex continuum in IF between role-playing as a character making choices and making choices to define who your character is. In stories that lean towards the latter, it’s often helpful to have an explicit moment when those choices are “locked in” and we find out what this person really is made of. Marrying that moment to an climactic story beat makes it read as logical and earned.

Shifts in interaction: If a story is mostly about wandering and exploring, transitioning into a conversation sequence can immediately suggest that the rules have changed. Similarly, moving from conversation to an action sequence, or to a different scale of decision, can reset the stakes and the expectations for a new scene.

Freedom (or constraint): Changing how wide-ranging the viewpoint character’s actions are can highlight a tense moment. If up until now we’ve only had dialogue choices, and suddenly we’re given the option to scream, or throw things or run away, that helps raise the tension. Conversely, the player character might find themselves suddenly constrained – suddenly a game with a variety of moves available to the player turns into a strict dialogue funnel. This can reflect some diegetic element of the plot (eg, the player character is tied to a chair), but it doesn’t have to.

Gauntlets: Climactic scenes often involve self-contained choices that have significant effects on the subsequent story. If done poorly, this can make the rest of the story seem inconsequential as it gets flattened by the outcome of the endgame. But it’s still a useful tool for raising tension. Having the bulk of the story feed into the climax somehow – by opening up more alternatives, by shifting the attitudes of different characters, or just by coloring how this section is viewed by the player character – is a good way of tying everything together.

Hopefully these examples get you thinking. A lot of IF establishes its mode of interaction and its mechanics right from the start and never shifts them, which can make those interactive components feel like they don’t have an arc to complement the arc of the story. Thinking both from a big-picture perspective, and in terms of each individual scene, can make for a stronger composition of interactive elements.

In essence, you can think of key scenes as miniature interactive narratives within your overarching narrative, with their own rules and preconditions: working this way can help you use a broader palette of ideas about interaction and agency without those getting muddled.

Bruno Dias is a writer and narrative designer based in São Paulo. His work has appeared in video game publications (Waypoint, PC Gamer), games (Where the Water Tastes Like Wine) and interactive fiction on Sub-Q and elsewhere

The post Making Interactive Fiction: Scenes appeared first on sub-Q Magazine.

In part one, I walked through a series of questions that help clarify a narrative design. Now, I’m going to talk about how one puts all of this together.

The output of narrative design as a process is a design document — in games, it’s common to produce a GDD (game design document) outlining an entire game, but I like writing smaller and shorter treatments of individual systems, mechanics, or simply of a game’s narrative structure apart from any mechanic. In interactive fiction, especially short or experimental fiction, GDDs are rarely written. But I find a narrative design document, marrying major plot events to chunks of content and spelling out how they’re structured and accessed, to be more useful than a screenplay-style story outline.

In fact, flat story outlines are often hard to read or misleading when it comes to interactive narrative. I tend to draw diagrams; some of my work is “documented” in photos of whiteboard sketches or cramped up in notebook pages. Spelling out how things are supposed to work is great for finding holes in your own logic or seeing combinations of actions players could take that you didn’t anticipate. Prototyping the main narrative branching points as a simple Twine is a popular approach when dealing with that kind of structure; it lets you both see the shape of the narrative, and play through it to explore individual versions of the plot.

At this point, you can start asking some more systematic questions about the story: Does a typical playthrough get across everything I want to say? Does every playthrough? What are the things players will always see? What are the things that only a small fraction of players will see? If players can fail, where and how can they fail? If players are managing some kind of resource, what does that resource economy look like?

Those questions will lead you towards iterating on your design, and they’ll help clarify a lot of underlying issues that we often don’t think about until it’s a little too late. A game where players can miss large segments of story, and therefore get a version of the story that heavily elides important events or backstory, is very different from a game trying to make sure players get a chance to see everything important. Seeing what your structure does will help you figure out what you want it to do, give yourself an aim to steer by.

I know this seems like a lot of prepwork before you begin writing (though nothing says you can’t sketch out scenes, moments, or snippets of story before thinking through structural stuff — I often do that, too; it’s useful for figuring out what the story really is). But the idea here is to get you off the autopilot that tools (whether Twine or something else) tend to induce and get you thinking about how to construct a story as a sort of machine of meaning that players will engage with.

Bruno Dias is a writer and narrative designer based in São Paulo. His work has appeared in video game publications (Waypoint, PC Gamer), games (Where the Water Tastes Like Wine) and interactive fiction on Sub-Q and elsewhere

The post Making Interactive Fiction: Narrative Design for Writers (Part 2) appeared first on sub-Q Magazine.

First things first: What is narrative design? The real answer is that the role of “narrative designer” is relatively new in the games industry and has something of a fluid or even vague meaning. Different teams will use the term differently. But this is how I approach it: narrative design comprises the structures, mechanics, and dynamics that convey a story to a player.

Narrative design is about the whys and hows of story. It approaches the twin problems of how you deliver story (Are there non-player characters in the game? Can they talk? Do they talk spontaneously or only “in conversation” with the player?) and how story functions (Can the player change what happens in the story? Are there branching paths and/or an underlying world model?).

There’s a lot to say about how to build these structures, but a starting point is to think about them in terms of specific questions.

When you use a tool like Twine, for instance, you’re relying on a set of assumptions that essentially make up a narrative design for you — first-time Twine authors often write a narrative that relies on path branching for its underlying logic, because Twine pushes for that. To think like a narrative designer, you’ll need to make those choices into conscious decisions.

Here are some questions to ask:

Structure: How is the story organized? Are there explicit “chunks” of content that are self-contained (chapters, passages)? Can those be seen in different orders? How does the order vary? Is there a single overarching structure to the whole piece, or are there different “sections”?

Time: Does the story always move forward, or does the player have to do something specific to advance it? Are player actions limited by some resource or constraint? If the story isn’t always moving forward, what is the player doing other than advancing the story? Is there action going on in the background, independent from the player, or is all action tied to the player’s actions?

Choice: Is the player making choices as they advance the story? How are those choices presented? How does this presentation limit choice? How many choices do we want to give the player at once? What are the choices about: courses of action, emotional valence, player character self-expression, several of those, or something else entirely? Do choices feed into some underlying system? Can choices branch the story? Can choices be hidden or disabled? If so, under what circumstances?

Model: Is there some underlying simulation that impacts the story? How is the state of it surfaced to the player, if at all (for example, Choice of Games stories have an explicit stat screen)? Can the “world model” branch the story? Affect the choices you offer?

Gating: Does the player have to perform certain actions, accrue certain resources, or put the game into a certain state to advance the story or access certain branches? What happens if they fail or delay? What are we putting behind those “gates”: critical parts of the story, optional scenes, better story outcomes?

Goals: What is the player trying to do in this story? Are they trying to get the best outcome possible for the player character? Are they trying to implement a certain value system or express their own from a range of choices? Are they simply observers or low-agency participants in a process, with a goal to understand or explore? How do we make it clear to the player what their role is?

If this seems a bit overwhelming — well, yeah. The goal here is just to point out that interactive narrative is variable, and you really start to see things when you examine your assumptions. I hope this gets you thinking.

[Editor’s note: Part 2 of this post will go live Tuesday, July 10th — be sure to check in with us then for more on this topic!]

Bruno Dias is a writer and narrative designer based in São Paulo. His work has appeared in video game publications (Waypoint, PC Gamer), games (Where the Water Tastes Like Wine) and interactive fiction on Sub-Q and elsewhere.

The post Making Interactive Fiction: Narrative Design for Writers (part 1) appeared first on sub-Q Magazine.

How, when, and where to use generative text is a complicated question. Some IF is built entirely around a generative idea, like Epitaph or Begscape. Sometimes generative prose is used more sparingly or almost invisibly, like the way Savoir-Faire carefully supports the player’s ability to THROW any object in the game at anything else.

There’s a lot of mysticism and misconception, in games, around procedural generation and procedural prose in particular. People who are encountering procedural generation for the first time often approach it as a labor-saving device, as a way of getting a lot of “content” into a game without a whole lot of effort.

This isn’t a very useful way of thinking about it. Procedural generation, really, is a way of getting 200% as much content with 400% as much work. It’s easy to look at something like Spelunky’s level generator and see an “easy” path to giving players “infinite levels,” but this is very misleading. Level generators take an enormous amount of effort to build, tune, and iterate on before they consistently generate levels that are functional, let alone fun and engaging for the player. And levels in Spelunky are still built out of individually-authored “chunks;” often, in procedural generation, you’re still authoring everything that goes into the game, only at a more micro scale suitable for later recombination.

Voyageur, for example, contains thousands of words of hand-written prose. Writing that prose was very different from writing static descriptions in a purely authored game; I was writing loose sentences and phrases that the game would recombine later. This was, however, more work than simply writing descriptions. Each sentence had to operate within a myriad different contexts and variations, and had to come loaded with machine-readable metadata that ensured the game would use it correctly. And that’s not counting the work of programming that system in the first place.

So, given that it’s so much work, why would you use generative prose in your game? Why not just write everything by hand? There are some good reasons. A very direct one is simple responsiveness, the ability to adapt what the game is writing to the player’s actions; THROWing objects in Savoir-Faire is a classic example. This really helps an interactive story involve the player; it makes the story feel responsive to what the player is doing, aware of its underlying reality.

Another reason to use generative prose is replayability. Randomized elements allow for a story that can be run through multiple times with surprising circumstances each time. Generative prose is a way of expressing those variations, making them readable to the player.

But I enjoy using generative text for its aesthetics. Generative text has a specific valence to it; it can suggest a vast space of possibilities, hint at the interchangeable nature of something (imagine a game set in a major city, where you’re constantly bumping into procedurally-generated pedestrians), or simply offer up imagery and subtext, invite interpretation genuinely detached from trying to guess at authorial intent.

This “generative aesthetic,” however, brings up another major caution: Don’t make generative text into a lesser option that competes with fully authored material. Machine writing really flourishes when allowed to stand in its own context; like anything else, it looks better in flattering lighting.

The post Making Interactive Fiction: Using Generative Prose appeared first on sub-Q Magazine.

Okay, so you’ve taken your story from a concept to a draft. You’re ready to show it to folks; maybe you’re even pretty proud of what you’ve put together. You take it to beta readers… and then they give you feedback.

Ah. Yeah. You signed up for this. What do you do with it?

Receiving feedback, and making use of it, is a hurdle for a lot of first-time writers. And it’s tough when you’re writing fiction that you feel is personal, or deeply subjective. Getting good feedback means finding people who can be good testers, which is challenging in itself.

A good test reader is someone who shares your aesthetic goals, someone who you can trust to be honest with you, but ideally not someone who is like you in every respect. Cultivating a circle of peers that I can exchange feedback with has been really useful to me, though I honestly couldn’t tell you how to make that happen.

You’ve probably been told to swallow your pride already, but really that’s just the start. Yes, feedback is going to be useless to you if you can’t stay objective about it, but it’s not enough to be objective. You need to know how to contextualize what you’re getting back from testers.

But what most new writers really struggle with is the frustration-guilt seesaw of getting feedback you think is bad, but you can’t be sure you’re not just giving in to your own biases. And yeah, sometimes you are being biased; I can’t really give you a way of knowing for sure. It gets easier with experience… I hope.

But for me, the key has been realizing that not all feedback is good, but all feedback is useful. Ultimately, even if someone’s perspective isn’t representative of who you’re trying to reach, they’re going to have a reaction that you can get something out of. The trick is to temper those reactions with other feedback, and keep circling back to the original vision for the project. Look at feedback not as answering the question what you should do but what are you doing now, and from there you derive what to change to get to what you want to be doing.

Most of all, don’t take early feedback looking for small tweaks. Early versions of your story are probably going to need some substantial surgery; embrace that. It’s often worth thinking through big structural changes in early revisions. IF writing is inevitably very iterative; it’s difficult to know how something will land ahead of time. And often, seemingly small problems are just the tip of the iceberg of a deeper weakness; getting to a story that hangs together well often means finding big solutions rather than spackling over the little cracks.

So: Writing is hard, not everyone shares your goals and aesthetics, but everyone has something you can glean information from. The worst possible feedback will tell you the boundaries of the audience you’re going to reach, or the ways you can expect to be misunderstood, but don’t expect (or settle) for the worst. Seeking out good feedback can be hugely rewarding, and over time, it’ll make you a better writer. Nothing has helped me improve more than editors, and while a lot of IF writing doesn’t have the luxury of a full-on editor, the basic principle still holds: Putting more eyes on a project will make it stronger.

Bruno Dias is a writer and narrative designer based in São Paulo. His work has appeared in video game publications (Waypoint, PC Gamer), games (Where the Water Tastes Like Wine) and interactive fiction on Sub-Q and elsewhere.

The post Making Interactive Fiction: Going beyond “test your stuff.” appeared first on sub-Q Magazine.

It’s easy to fall into the trap of viewing choice as a tool for player expression. That relates to how interactive narrative is sold: as a world of agency into which the player gets dropped and can express their desires. But as far as how interactive narrative communicates, here’s a dirty little secret: what the player chooses matters, but not as much as what choices are offered.

The core of this is the “road not taken” effect. Every choice you offer to the player suggests what the space of possibilities are—what’s imaginable, or doable, for the viewpoint character. If my choices are “I swallowed my anger / I yelled at him,” that communicates something very different from “I yelled at him / I stabbed him with my knife,” even if you pick the “yelled” option anyway. Even if the consequences are identical, a character who might have turned a confrontation violent is different, and there is a different valence to their actions, than a character who at best would have yelled.

This is especially important to consider in terms of the power dynamic between two characters. What choices someone has in interacting with someone else sends a very strong signal for whatever hierarchy exists between those two people. Peer-peer relationships, master-servant relationships, romantic relationships, platonic relationships, and abuser-victim relationships all present different options to the people on either side, and represent one of the most fraught places where the effect of unchosen choices can be felt.

This is why it’s dangerous to offer a choice like “I stabbed him with my knife” and then respond to it with something like “Or at least, I wanted to, in that moment. But…” The player who picks that choice will see that you backed away, but everyone else will not. What you implied through the initial choice text will linger and help make up the player’s image of their character, of what they’re capable of. This bears repeating: A choice can easily create misunderstandings for the players who don’t take that choice.

Choice text, too, is a major consideration. You might use a short summation of an action (Explain it to him), or a literal quoting of what the player character might do or say (“I was running down the highway, feeling bad…”). And you often want to be scrupulously consistent about this kind of style.

But short, poetic choice text has significant power, and makes for a more interesting read. In Where the Water Tastes Like Wine, (Which, full disclosure, I wrote for) a lot of the choice text consists of short fragments like “ASK WHY” or “HOW?”; this gives particular power to the times where that text can be imbued with particular meaning (“BEAR WITNESS”) or simply with a joke (“BE A GOOD SPORT / BE A DICK”). Part of what makes this work is that this is a game of limited agency; in the stories you encounter, you are largely a passer-by, a witness. The shorter choice text is better at expressing the tone and significance of an action; longer and more specific text is better at expressing the specifics of an action.

So: everything about a choice you present—how many options, how they’re written, and the breadth of possibilities on offer—is read by the player, and helps tell the story. How do you keep all this straight? In any interactive story of significant length, you will have hundreds of choice points; knowing how to write them right for that story, consistently, is all about setting style rules and knowing your character, your tone, and the type of agency you’re expressing. I hope this helps you make conscious choices about choice.

Bruno Dias is a writer and narrative designer based in São Paulo. His work has appeared in video game publications (Waypoint, PC Gamer), games (Where the Water Tastes Like Wine) and interactive fiction on Sub-Q and elsewhere.

The post Making Interactive Fiction: Branching Choices appeared first on sub-Q Magazine.

The mandate for writing this column – 600 words about any subject I like, related to IF – is too broad. I had to pare it down, come up with a more focused mission statement of sorts.

Fortunately, this is a problem I see a lot. Let’s talk about cutting scope, about the practice of finding things that were planned to be in your game and taking them out.

Most games and most pieces of fiction eventually find a point where scope has to be cut. The ambitions set out at the start of the project turn out to be unfeasible in practice. Or ideas that have been hanging around since the beginning turn out to be dead weight and have to be shoved out an airlock.

Sometimes it’s a matter of resources, of only having so much space, time, money, patience. That’s always difficult, because it’s externally imposed; we can imagine the world where we halt everything and spend the rest of our lives working on this one thing, and we can maybe just barely see the edge of what the final product of that looks like. Of course, we don’t live in that world.

Sometimes it’s a matter of focus, of trying to cohere disparate ideas together.  Of making sure you’re producing something that can be taken in as a unit, and not as a collection of stuff. Most murals don’t need to wrap around the building they’re painted on. This is hard in a different way, because often the hardest thing to see is the valuable core of something. We arrive at it obliquely too often, still carrying a lingering attachment to an original idea that might not be what matters. A lot of novels start as plot-driven and end up character-driven. In the process of making something, we clarify what that thing needs to be.

So: When cutting scope, one focuses on what’s important, on what’s unique about a project. What’s unique about this column is that it’s an open-ended column about IF, in the very particular space that is Sub-Q. So, writing reviews, impressions pieces, that’s out; I can do that elsewhere. I’m also not going to use this for broad Takes about video games. What can I write here that I can’t get published anywhere else?

Craft advice about writing interactive fiction; more theoretical discussion of issues in that field. Something that exercises my thinking as a working writer, rather than my thinking as a critic.

There are always going to be casualties. 6000-word essay about why Super Mario RPG is the most important game on the SNES catalogue: Gone. Long digression about the colonialist overtones of the Knack franchise: Deleted. In-depth review of Ad Verbum 17 years after its release: Not to be seen in this space.

Instead: How do you create a sense of place in IF? How do you deploy randomness? How did the parser canon of the 1990s influence Twine games in the 2010s? We clear space for things that couldn’t exist anywhere else.

Opening up that space is the trite argument for parsimony. There’s a longer-view point to it, a more significant reason for cutting back: By narrowing down what you set out to make, you might actually manage to finish things.

And whatever you want to accomplish as a writer, finishing something will get you far closer to it than poring over a seventeenth draft will.

The post Making Interactive Fiction: Scope appeared first on sub-Q Magazine.

“Prospero”, which sub-Q published earlier this week, was written using a relatively new tool called Raconteur. Raconteur is a library of tools that wraps and extends Undum, an engine for writing choice-based and cybertext interactive fiction using plain JavaScript. Raconteur supplies a toolchain and CoffeeScript-targeted API for Undum, which is meant to hugely accelerate the process of writing Undum stories.

For a while now, Raconteur has lacked a full code example. “Prospero” is just about the right length for it, and sub-Q has graciously agreed to publish the full source code. The story file for “Prospero” is about 871 lines long and contains all of the unique story text and logic.

You can find out more about Raconteur, including documentation and tutorials to help you start writing with it, on the Raconteur website.

# " There comes Poe, with his Raven, like Barnaby Rudge,
#   Three-fifths of him genius, and two-fifths sheer fudge. "
# 
#   -- James Russel Lowe, A Fable for Critics
# 
# The story source code for Prospero begins here. (C) Bruno Dias 2015.
# Originally published by Sub-Q magazine (http://sub-q.com/)
# 
# This source code is distributed as a code example for educational purposes.
# No permission is granted to redistribute or rebuild the story from this
# source code.


# ----------------------------------------------------------------------------
# 0 -- Front Matter

# Require the libraries we rely on.

situation = require('raconteur')
undum = require('undum-commonjs')
oneOf = require('raconteur/lib/oneOf.js')
elements = require('raconteur/lib/elements.js')
qualities = require('raconteur/lib/qualities.js')

a = elements.a
span = elements.span
img = elements.img

# IFID and game version -- Required by Undum

undum.game.id = "0a7f01b6-b435-483c-8874-bdbee2683255" # UUID
undum.game.version = "source-distribution"

# ----------------------------------------------------------------------------
# 1 -- Preamble

# Helper functions

# Cycles through an array's contents
Array.prototype.cycle = () ->
  return this[1..].concat(this[0])

# Checks if a situation has been visited by the player
seen = (situation) -> Boolean undum.game.situations[situation].visited

# Typographical shorthand

# An alias for setting up an "aside" link
# (that creates a parenthetical when clicked, usually)
aside = (word) ->
  ref = "#{word}-aside"
  inner = a(word).once().inserter(ref).toString()
  span(inner).id(ref)

# An alias for setting up a link to another situation, with the correct
# element class.
segue = (content, ref) -> a(content).class('segue').ref(ref)

# An object to hold reusable templates.
type =
  ending: '<h2 class="ending">an ending</h2>'

# ----------------------------------------------------------------------------
# 2 -- Game content

# 2.0 -- Prologue

situation 'start',
  content: () ->
    prospero =
      span(a('Prospero').inserter('prospero').once().toString()).id('prospero')
    """
    The "Red Death" had long devastated the country. No pestilence had ever
    been so fatal, or so hideous. Blood was its Avatar and its seal -- the
    redness and horror of blood. There were sharp pains, and sudden dizziness,
    and then profuse bleeding at the pores, with dissolution. The scarlet
    stains upon the body and especially upon the face of the victim, were the
    pest-ban which shut them out from the aid and from the sympathy of their
    neighbors. The whole seizure, progress and termination of the disease,
    were the incidents of half an hour.

    When Prince #{prospero} found his dominions half depopulated, he summoned
    to his presence a thousand hale and light-hearted friends from among the
    people of his court, and with these retired to the deep seclusion of one
    of his summer #{segue('retreats', 'retreats')}.

    """
  writers:
    prospero: " (happy and dauntless and sagacious)"

situation 'retreats',
  content: """
    # Prospero

    ## Adapted by Bruno Dias from the short story by Edgar Allan Poe
    """
  choices: ['cars']

situation 'cars',
  optionText: 'Continue'
  content: """
    It was an extensive and magnificent structure, a modernist design not
    unlike the carved *béton brut* that had sprouted all over Europe. An
    angular steel fence surrounded it. Courtiers had abandoned their cars all
    along the gravel paths of the courtyard, gleaming silver and black
    machines defying the rust each misty Savoyard morning. Their keys had been
    collected and buried behind the enormous house, leaving no means of egress
    to the sudden impulses of despair or frenzy from within. Its exterior had
    #{a('suffered').once().writer('suffered')} the passage of time.

    Of all the #{aside('cars')}, one #{segue('stood out', 'red-car')}.
    """
  writers:
    'cars-aside': " (stately Hässels from Prussia, sinuous Verbeeks from New
      Amsterdam, sharklike Bulettes from Brittany)"
    'suffered': """
      In months of grinding, desperate seclusion, no servant had stepped outside
      the house. The panes of safety glass -- surrounding the house like scales
      -- had accrued a layer of dark grime from the wind and rain. The garden
      was an overgrown, matted ruin. Native weeds thrived among the corpses of
      neglected foreign flowers. And not far from the door was a pile of ashes
      -- remains of clothes and surgical masks suspected of carrying disease.
      """

situation 'red-car',
  content: """
    It was a ruddy, beautiful *coupé* -- a Carrièr Matador, from Toulouse.
    Painted a color too dark to be cherry red.
    Fresh gouges in the gravel behind it, mud
    on its rims.

    She stepped out of the car, not bothering to lock it. She made her way,
    through undisturbed gravel, to the #{segue 'trunk', 'open-trunk'}.
    """ 

situation 'open-trunk',
  # Note how we can attach arbitrary properties to situation objects
  books: ['Relics', 'Mementos', 'Evidence']
  content: () ->
    mask = a('masque').once().writer('mask')
    novels = a('novels').once().writer('novels')
    """
    Inside the trunk were a stack of paperback #{novels} and a curiously made
    #{mask}.
    """
  writers:
    novels: () ->
      finger = a('finger').once().replacer('finger-inserter')
      here = span('.').id('finger-inserter')
      relics = 
        span(
          a(this.books[0])
          .replacer('relic-book')
          .toString())
        .id('relic-book')

      """
      They had been with her as she drove through the back country of Savoy,
      taken from abandoned bookstores and gas stations. #{relics} of the desert
      she left behind her. She ran one #{finger} through the the pile, reading
      the titles#{here}
      """
    'finger-inserter': " -- Short stories collected from pulp authors;
    Chamber's The King in Yellow; a clandestine copy of the banned,
    pseudonymous Return of the Worm; louche Italian romances for all
    kinds of underserved audiences..."
    mask: """
      The masque was red, to match her outfit, and cleverly constructed for
      effect. The top resembled those delicate porcelain features, the shaded
      eyes, of a Venetian *columbina*. But this one had a mouth covering in the
      form of a silken, draping scarf, meant to be pulled down to reveal the
      full #{segue('visage', 'visage')} of the masque.
      """
    'relic-book': () ->
      this.books = this.books.cycle() # `this` is the situation object itself
      span(
        a(this.books[0]).replacer('relic-book').toString()
        ).id('relic-book').toString()

situation 'visage',
  content: """
      She tentatively slid a finger behind the masque's silk covering, as though
      to check that what had always been underneath it remained. In this, she
      was interrupted by the #{segue('chiming', 'chiming')} of the great clock
      within the #{segue('mansion', 'mansion')}. She had arrived just in time.
    """

situation 'chiming',
  content: """
    Somewhere deep inside the Prince's apartments was an enormous, grotesque
    clock. Made of ebony and sharp angles -- a modernist retelling of
    a Gothic original the Prince's ancestors had neglected in a castle
    elsewhere.

    The Prince had it attached to the metal
    bones of the mansion. On the hour, the whole building would reverberate
    along with its chiming, phasing the guests, halting the music, shaking
    the floor.

    Its tolling, just now, signaled the start of the #{segue 'ball', 'ball'}.
    """

situation 'mansion',
  content: """
    The mansion had been erected out of glass, steel, tropical woods from the
    domains of distant cousins; unlike the ostentatious glass houses of his
    peers, the retreat had been built wholly out of sheer, broken angles; so
    that the glass could not provide a clear sight-line through the house at all
    -- instead of an airy rectangle, it was a steel snake hiding in its own
    coils.

    It was a small palace and a world unto itself; and presently, it all shook
    to the ringing of the clock, signaling the start of the
    #{segue 'ball', 'ball'}.
    """

situation 'ball',
  content: """
    Within the mansion, the Prince had gathered perhaps two hundred guests and
    nearly as many servants. The summer home, a small palace, was amply
    provisioned. A remote stand of cypress surrounded it. The world outside
    could care for itself, and in the meantime, it was folly to grieve -- or to
    think. To that end, the Prince had supplied all appliances of pleasure:
    There were dancers, there were musicians, there was Beauty, there was wine.
    As all signals traveling through the Prince's *aether* ceased to carry any
    joy for him, the servants had hidden away all the radios and television
    sets, cutting cords to #{segue 'silence', 'ball-continue'} them completely;
    so that the guests, finally, were left to the labors of pleasure and life in
    seclusion.
    """

situation 'ball-continue',
  content: """
    When the Prince's collection of #{aside 'films'} ran out, the lights were
    turned on and the servants were made to play in blackbox comedies, their
    scripts supplied by dilettante guests.

    When even that entertainment ran thin, the Prince announced a night of
    extreme revel, a masquerade ball, where the guests and servants would
    mingle, shed their identities, forget. Wine, and song, and whatever earthly
    pleasures remained, would flow freely.

    She #{segue 'donned her masque', 'put-on-mask'},
    having arrived just in time.
    """
  writers:
    'films-aside': " (from bolshevik *kinopoesiya* to staid
      adaptations of the *commedia dell'arte*)"

situation 'put-on-mask',
  optionText: "She put on her masque, and made her way to the ball."
  content: """
    The ball had been arranged within a sequence of seven apartments joined
    together -- a grand suite. In other mansions and palaces, those suites open
    widely, so that one can see clearly through all of their spaces, their
    sliding doors receding almost entirely into the walls.

    However, this suite was crooked, each chamber at a sharp angle from the
    next, so that the guests could see only one room at a time. Outside, through
    the great panes of safety glass, was darkness.

    The seven apartments were each one decorated in a particular color and
    style, a neon mirage of a different place and time. The first one was blue,
    and everything in it had some tint of blue, matched by the bright blue
    lights overhead. The second chamber was purple, from the carpet to the
    ceiling. The third chamber was green throughout; the fourth, orange; the
    fifth, white; the sixth, violet. And at the edge of the great house was the
    last apartment, itself decorated wholly in #{segue 'black', 'black'}.
    """

situation 'black',
  content: """
    The black chamber was closely shrouded in black velvet tapestries that hung
    all over the ceiling and down the walls, falling in heavy folds upon a
    carpet of the same material and hue. BUt in this chamber only, the color of
    the neon lights failed to correspond to the decorations. The tubes here were
    scarlet -- a deep blood color.

    In the black chamber, the effect of the neon light that dappled across the
    dark hangings was ghastly in the extreme, and produced so wild a look upon
    the countenances of those who entered, that there were few guests bold
    enough to set foot within the chamber at all. No dancing happened within --
    only furtive whispers, and abortive trysts cut short by the eeriness of the
    chambers.

    She #{segue 'followed the procession of revelers', 'ball-begin'}.
    """

situation 'ball-begin',
  content: """
    Her costume was a draping, heavy robe, covering her form in red. Topped
    with the strange masque, she was an imposing figure, wearing a color that
    horror had forbidden, shocking those few guests who bothered to notice
    her presence at all.

    She had walked slowly through the revelers, noting how they clung to
    the western end of the grand suite, how they avoided the other end with
    its black velvet room. She moved between them, unnoticed.
    And as the ninth hour approached, she stopped at the halfway point,
    the orange chamber, where the warm neon overhead suggested some
    distant tropical sunset.
    """
  classes: ['orange']
  choices: ['ninth-third', 'ninth-fifth']

# 2.1 -- The Ball

###
From here on out, situation ids take the form "bell-room", eg "ninth-fifth"
means the fifth (white) room, at the tolling of the ninth bell.
###

# 2.1.0 -- Ninth bell

# The descriptions for these chambers shows up the first time they're visited,
# which can happen in different situations. So we set up an adhoc object to
# hold them, as well as the connecting paragraph about the bell tolling.

chambers =
  green: """
  She stepped into the green chamber, and found it covered in leafy arabesques
  that recalled the cypress stand outside. Glistening vinyl ferns sprouted from
  the walls, their artificiality only heightened by the color of the lights.
  """
  white: """
  She took stock of the white chamber: Lit with a staid white light, this room
  was made to resemble a sarcastic mockery of a church undercroft, complete
  with arched niches in the walls holding sconces with flickering candles.
  The plastic skulls that would have completed the effect, however, had
  been taken away by the servants -- the Prince wanted no *memento mori*.
  """
  toll: """
  At the far end of the suite, in the black chamber, was the clock. Its
  tolling reverberated violently through the entire house, with a sound so
  strange and musical it compelled the musicians to stop and harken to its
  sound; and here the dancers, too, would cease their revolutions around one
  another, listening to the brazen vibrations of the hour.

  But just as it had come, it would fade away, the shaking of the walls the
  sound of mere moments, soon replaced by the revived noises of revelry and
  joy.

  The striking of the tenth hour approached.
  """

situation 'ninth-third',
  crowdReactions: [
    "She noted sadly the interrupted futures of the young ones in the crowd."
    "She cataloged their lives with ennui, seeing the common arc of their
    fates."
    "In them, she saw only a mass of indistinct humanity."
  ] # Once again we attach a list of possible phrases to the situation object
  content: () ->
    crowd = a('crowd').once().writer('crowd')
    """
    #{chambers.green}

    A woman stood uncomfortably #{segue 'distant', 'save-woman'} from the
    party, leaning furtively against the wall, her lithe body vanishing into
    the gaudy plastic bush. She did not seem to fit the #{crowd} of courtly
    hangers-on around her.
    """
  choices: ['tenth-second', 'tenth-fourth']
  optionText: 'She retreated to the green chamber.'
  classes: ['green']
  writers:
    crowd: () ->
      """
      The green room seemed the most agreeable to the guests. A circle of
      courtiers orbited around some of the Prince's favored friends: Masked
      actors, musicians, and a brooding novelist or two. They were stared at
      by industry barons and literal barons, investment bankers, lesser
      sons of princely families. From the middle of the crowd, camera flashes
      would sometimes emerge, casting their masks in stark light for a moment.
      #{this.writers['crowd-react'].call(this)}
      """
    'crowd-react': () ->
      this.crowdReactions = this.crowdReactions.cycle()
      span(
        a(this.crowdReactions[0]).replacer('crowd-react').toString()
        ).id('crowd-react').toString()

situation 'save-woman',
  content: """
    She saw a small woman, raven-haired and short, wearing a golden tragedy
    masque and a black cocktail dress that fit her poorly.  The stranger in
    red approached her, noting that the woman was neither servant nor
    courtier. In her borrowed dress, she tried to mingle, but too awkwardly,
    clutching an untouched glass of wine. A party crasher, perhaps? Or a
    survivor from a nearby village, taken in by the Prince?

    The stranger did not need to know.
    """
  choices: ['give-woman-key', 'tenth-second', 'tenth-fourth']
  extendSection: true

situation 'give-woman-key',
  optionText: "She gave her the keys."
  content: """
    From the folds of her robe she produced her keys, which she pressed into
    the hand of the young woman. "Leave." There was no argument. Behind her
    tragedy masque, she recognized who spoke to her.
    """
  after: (character) -> character.sandbox.hasKeys = false
  choices: ['tenth-second', 'tenth-fourth']
  extendSection: true


situation 'ninth-fifth',
  adverbs: ['soberly', 'longingly', 'distractedly', 'curiously']
  # Situations can also encapsulate arbitrary functions. This one wraps an
  # adverb from the list in the right tags to generate a link; it's used
  # both in the main content and by the related writer.
  adverbise: () ->
    this.adverbs = this.adverbs.cycle()
    span(
      a(this.adverbs[0]).replacer('wine-adverb').toString()
      ).id('wine-adverb')
  content: () -> 

    """
    #{chambers.white}

    Wine flowed from the white chamber, a play on communion. She glanced
    #{this.adverbise()} at a glass of dark red liquid left abandoned on an
    arched sill.

    #{chambers.toll}
    """
  choices: ['tenth-fourth', 'tenth-sixth']
  optionText: 'She advanced to the white chamber.'
  classes: ['white']
  writers:
    'wine-adverb': () -> this.adverbise().toString()

# Tenth bell

bells =
  eleventh: "The striking of the eleventh hour approached."
  musicians: """
    When the hourly shaking of the house ceased, and the great clock had rung
    ten times, she could hear a distant song: Musicians in another room,
     picking up on the very
    note where they stopped, their song interrupted by the clock.
    """

situation 'tenth-second',
  musicReactions: [
    'swayed along to the rhythm'
    'listened with distant interest'
    'did not harken to the sound'
  ]
  musicReact: () ->
    this.musicReactions = this.musicReactions.cycle()
    span(
      a(this.musicReactions[0]).replacer('music-react').toString()
      ).id('music-react')
  content: () ->
    acted = this.musicReact()
    musicians = a('musicians').once().writer('musicians')

    """
    The purple room felt hazy, unreal. The walls and floor had been covered in
    a single, abstract mural, which dancers would unsteadily wobble over in
    their convolutions. It was hard to discern where the floor ended and the
    walls began.

    Here stood the #{musicians}, playing through an interminable
    medley, the bassist's arm drooping slightly under the weight of the
    instrument. As the sound of the bells faded, they would pick up on the
    very note where they had stopped. As she moved unseen through the crowd,
    she #{acted}.
    """
  writers:
    musicians: """
      They worked their way laboriously through a half-improvised swing, six
      minutes into a minor key jazz that is only three minutes long. It was
      wearily joyful, the sound of a band that played nothing but final
      numbers.

      #{bells.eleventh}
      """
    'music-react': () -> this.musicReact().toString()
  choices: ['eleventh-first', 'eleventh-third']
  optionText: 'She moved to the purple chamber'
  classes: ['purple']

# Since we know the player has already seen the orange chamber
# (it's a bottleneck), we don't have to print its description.
situation 'tenth-fourth',
  content: () ->
    youth = a('youth').once().writer('youth')
    """
    At the tolling of the tenth bell, she walked again around the tight scrum
    of dancers that spun through the center of the orange room, most too
    unsteady from wine and #{youth} to fall properly on their steps.

    #{bells.musicians}
    """
  writers:
    youth: """
      Here was a clique of idle young scions from mercantile houses and their
      hangers-on, interrupted in their holiday through the Savoyard countryside
      by the plague that forced them to seek shelter in the house of the Prince,
      showing up at his doorstep in their fast cars, with their cheap wine and
      dilettante typewriters. One of them caught her masked
      #{segue 'eye', 'save-dilettante'}.
      """
  choices: ['eleventh-third', 'eleventh-fifth']
  optionText: 'She returned to the orange chamber.'

situation 'save-dilettante',
  content: """
    He had known grief beyond his years, which he hid with sarcasm and a little
    too much wine. He and his two friends fancied themselves writers. But their
    typewriters had been silent for a while.
    """
  choices: ['give-dilettante-key', 'eleventh-third', 'eleventh-fifth']
  extendSection: true

# Normally, the output of each situation is put into its own section, allowing
# it to be styled accordingly (in Prospero, by giving it the proper colour
# background). But here we set the `extendSection` property to `true`, so that
# it will instead write into the existing section, so that the background will
# extend over the new text.

situation 'give-dilettante-key',
  optionText: 'She gave him her keys.'
  canChoose: (character) -> character.sandbox.hasKeys
  content: """
    She startled him, drawing nervous laughter from the youth. She pressed a car
    key into the shaking palm of his hand. "Leave." She knew he would gather
    his friends. That he would know which one of the cars parked outside to
    take.

    Three souls made it out alive that evening.
    """
  after: (character) -> character.sandbox.hasKeys = false
  choices: ['eleventh-third', 'eleventh-fifth']
  extendSection: true;

situation 'tenth-sixth',
  content: () ->
    secrets = segue 'secrets', 'chamber-secrets'
    lies = segue 'lies', 'chamber-lies'
    """
    The violet apartment was a prelude for the black chamber. It was filled
    with mock horror that prefigured what was beyond the black
    door. The decor, deliberately disturbed like a crime scene,
    resembled a horror film, or perhaps a
    sanitized *giallo*. The walls were covered in foreboding Gothic stonework,
    rendered in papier-mâché.

    #{bells.musicians}

    She stopped for a moment to listen to the whispering of the gossips who
    retreated from the main body of the fête to find themselves here. Under
    the glow of the violet light, their whispers carried #{secrets} and #{lies}
    to one another, more out of habit than necessity.
    """
  optionText: 'She walked into the violet chamber'
  classes: ['violet']

situation 'chamber-secrets',
  content: """
    The Prince's tastes for the curious and the bizarre had always manifested,
    in his courtiers, in the form of a secretive and peculiar fear. They still
    passed on stories of the man's nocturnal activities, of what went on in
    the black chamber at the edge of the suite. And as she approached them,
    they dispersed, turning away masked faces.

    #{bells.eleventh}
    """
  choices: ['eleventh-fifth', 'eleventh-seventh']
  extendSection: true

situation 'chamber-lies',
  content: """
    Even amidst death, the business of the court went on. The lies they told
    one another were becoming extravagant in desperation, shifting from hour
    to hour as furtive news of the calamity outside starkly changed the value
    of lands and titles.

    They still discussed the news and events of the day, even though no news had
    reached the mansion in weeks. There was much talk of an antipope that had
    already been deposed, of an oil industry merger that had already happened,
    of war with Lombardy that was pre-empted by the plague. The world outside
    had moved on in their absence, as it would continue to do.

    #{bells.eleventh}
  """
  choices: ['eleventh-fifth', 'eleventh-seventh']
  extendSection: true

# Eleventh bell

situation 'eleventh-first',
  content: () ->
    prospero = segue 'Prospero', 'prospero'
    """
    Starkly ultramarine, the blue chamber greeted the Prince's guests to his
    chromatic fantasy.

    Here huddled the offended ones, the fearful, the religious. Those guests
    who did not care for the revelry or its accoutrements, who thought the
    whole affair a small blasphemy. They clung to the exit, caught between
    politeness and piety.

    And there, stuck trying to placate them with his silent presence,
    was #{prospero}.
    """
  optionText: 'She moved into the blue chamber'
  # We always find Prospero in the last chamber we visit; this variable tracks
  # where, exactly.
  after: (character) -> character.sandbox.prosperoAt = 1
  classes: ['blue']

# Check if those rooms have been seen before.

situation 'eleventh-third',
  content: () ->
    guard = a('guard').once().writer('green-chamber-guard')
    """
    #{if not seen('ninth-third') then chambers.green else ''}

    The green chamber held the food, the night's banquet, carefully measured out
    from the mansion's provisions. Weary servants had laid it out in faux-
    pastoral splendor. At each edge of the table, a reminder of the creeping
    scarcity, stood a #{guard}.

    And at the edge of his own party, staring at his dwindling food,
    stood #{segue 'Prospero', 'prospero'}.
    """
  optionText: 'She moved to the green chamber.'
  writers:
    'green-chamber-guard': () ->
      crest = aside 'crest'
      weapons = aside 'weapons'
      """
      Liveried in dark turtlenecks and berets bearing Prospero's family
      #{crest}, the guards were ever-presence and furtive, gaunt, faces hardened
      from watching the despair of the poor and the lost caught outside the
      manor's walls. Tonight, they watched the guests, clutched their
      #{weapons}, and didn't touch the food.
      """
    "crest-aside": " (gold emblazoned with a sable sun)"
    "weapons-aside": " (something compact and full-auto from Lombardy)"
  after: (character) -> character.sandbox.prosperoAt = 3
  classes: ['green']

situation 'eleventh-fifth',
  content: () ->
    # Note how if-then-else statements are expressions, so we can embed them
    # right into the output text; we need the else clause so it won't just
    # output `undefined` if the value is false.

    # Note, too, how this `content` property has to be a function, so that
    # the `seen` expression will be checked at runtime when the situation
    # is reached, and not when the situations are being generated.
    """
    #{if not seen('ninth-fifth') then chambers.white else ''}

    She had seen the path that wine took on its way around the chambers, from
    the great casket in the white apartment. Guests would timidly sip it or
    hurriedly down it; servants would disappear with glasses and flasks of it.
    There was so much of it to go through.

    And there, all but laying his head beneath the tap, was Prince 
    #{segue 'Prospero', 'prospero'} himself.
    """
  optionText: 'She moved to the white chamber.'
  after: (character) -> character.sandbox.prosperoAt = 5
  classes: ['white']

situation 'eleventh-seventh',
  content: """
    Few dared step into the last, velvet-draped chamber. The effect of the
    crimson neon distorted
    the visages of those within into a masque of horror. Those who came --
    dared by others, drunkenly stumbling through the curtain -- did not stay
    long. When she happened upon it, the black chamber was nearly empty.

    There was only Prince #{segue 'Prospero', 'prospero'} himself, seated on
    a black velvet and ebony ottoman, caught up in his own
    dark fantasy.
  """
  optionText: 'She entered the black chamber.'
  after: (character) -> character.sandbox.prosperoAt = 7
  classes: ['black']

situation 'prospero',
  content: (character, system, from) ->
    # `switch` statements in CoffeeScript are expressions, too
    # so we can assign their return value to a variable. Here, we
    # have a different reaction for Prospero depending on where he
    # was found, without having four different situations.
    prosperoGraph = switch from
      when 'eleventh-first'
        """
        But his staid, pious exterior melted into rage when she saw her,
        dressed head to toe in crimson.
        """
      when 'eleventh-third'
        """
        But his hungry smile faded away when he saw her, covered head to
        toe in scarlet.
        """
      when 'eleventh-fifth'
        """
        But he snapped out of his stupor when he saw her, covered head to
        toe in vermilion.
        """
      else
        """
        But his melancholy turned to anger when he saw her, covered head to
        toe in red.
        """
    """
    Prince Prospero was hale, and strong. He stood too tall for his guests in
    samite finery, the spitting image of some forgotten Gothic ancestor. He
    had, for too long, led his guests in their revels.

    #{prosperoGraph}
    """
  choices: ['prospero-unmask', 'prospero-leave']
  extendSection: true;

situation 'prospero-unmask',
  optionText: 'She took off the veil.'
  content: (character) ->
    ###
    The final sequence is a run through the chambers of the suite. The more
    chambers there are to run through, the longer it is; so we splice into
    a point determined by where we start.
    ###
    chamber = switch character.sandbox.prosperoAt
      when 1
        segue 'purple', 'death-finale-2'
      when 3
        segue 'orange', 'death-finale-4'
      when 5
        segue 'violet', 'death-finale-6'
      when 7
        segue 'black', 'death-finale-7'
    chamberGraph = if character.sandbox.prosperoAt < 7
      "But the masked figure already retreated into the #{chamber} chamber."
    else
      "The masked figure stood in the middle of the #{chamber} chamber."

    """
    As the house shook with the striking of midnight, she disposed of the veil
    that had concealed her masque.

    And beneath the veil, her masque was made to so closely resemble the visage
    of a stiffened corpse, daubed and sprinkled delicately with blood, that one
    could scarcely see anything but mockery of the tragedy that had befallen
    the Prince's domain.

    Prospero's face convulsed with disgust, then reddened with anger: "Who
    dares?"

    #{chamberGraph}
    """

situation 'death-finale-2',
  content: """
    Stunned by his momentary hesitation, the Prince
    #{segue 'chased', 'death-finale-4'} her through the apartments.
    """

situation 'death-finale-4',
  content: """
    As she moved through them, the assembled crowd parted in mute horror,
    stepping out of the way of the stalking spectre and the
    #{segue 'prince', 'death-finale-6'} who stalked her.
    """

situation 'death-finale-6',
  content: """
    He might have screamed for his guards to seize her, or simply silently
    cursed at the affront to his #{segue 'authority', 'death-finale-7'}.
    """

situation 'death-finale-7',
  before: () ->
    # If we haven't seen the black background effect yet, then we see it here.
    if not seen 'eleventh-seventh' then this.classes = ['black']
  content: () ->
    """
    #{if seen 'eleventh-seventh' then '' else "She stood in the middle of the
    black chamber, defying him."}

    He bore aloft a drawn pistol, and approached her impetuously, to within
    two or three feet of the spectral figure, when she turned sharply and
    confronted the Prince. There was a sharp cry -- and the pistol dropped
    inert upon the sable carpet, upon which, instantly afterward, fell
    prostrate in death the Prince Prospero.

    And now was acknowledged the presence of the Red Death. She had come as an
    uninvited guest. And one by one dropped the revelers in the blood-flecked
    halls of their revel, and died each in the despairing posture of their fall.
    And the life of the ebony clock went out with the of the last of the joyful.
    And the colorful neon lights flickered and expired. And Darkness and Decay
    and the Red Death held illimitable dominion over all.

    #{type.ending}
    """

situation 'prospero-leave',
  optionText: 'She turned to leave.'
  canChoose: (character) -> character.sandbox.hasKeys
  before: (character) ->
    character.sandbox.leaveMotivation =
      ['sadness', 'mercy', 'ennui', 'weariness', 'apathy', 'kindness',
      'forgiveness']
  content: (character) ->
    """
    But to his anger, she could respond only with a sudden
    #{this.writers.selectmotivation(character)}. Five months hidden
    in his manse had made of the Prince a ragged man, slightly too thin
    for his sequined party garb, eyeglasses slightly askew on a wrinkled
    nose. It had taken her so long to arrive at this man's party that
    she was no longer sure these were the people she had come to
    #{segue 'collect', 'leave-collect'}.
    """
  writers:
    selectmotivation: (character) ->
      character.sandbox.leaveMotivation =
        character.sandbox.leaveMotivation.cycle()
      inner =
        a(character.sandbox.leaveMotivation[0])
        .replacer('selectmotivation')
        .toString()
      span(inner).id('selectmotivation').toString()

situation 'leave-collect',
  content: """
    She walked through a parting way in the middle of the throng of distraught
    guests, out of the richly decorated apartments of the Prince who could
    scarcely muster the strength to #{segue 'follow', 'leave-follow'}.
    """

situation 'leave-follow',
  content: """
    Her footfalls made no sound as she strode onto the gravel path, tailed by
    a baffled Prince. He stood, paralyzed, watching as his iron gate was
    thrown open by crimson-gloved #{segue 'hands', 'leave-hands'}.
    """

situation 'leave-hands',
  content: """
    From one of his guards, the Prince had at some point reached for a drawn
    pistol. But he could not lift it against her. The open gates were a sign of
    black fear to him, a sign of the outside world creeping in on the sanctuary
    he had built, a sign of death. The ebony clock struck twelve, unheeded by
    the two figures standing before the great house. Darkness and Decay had
    arrived ahead of her.

    And so the Red Death got in her car and drove away.

    #{type.ending}
    """

#-----------------------------------------------------------------------------
# 3 -- Initialisation Code

undum.game.init = (character, system) ->
  character.sandbox.hasKeys = true
  # Undum's sandbox can hold arbitrary values inside the `character` object
  # passed to situation methods. Here, we use it to track whether the player
  # character has given away her car keys.

# When the DOM is ready, get Undum running.
window.onload = undum.begin

The post Behind the Scenes: Prospero appeared first on sub-Q Magazine.