Discussing the editing of game interactive texts from the perspective of six steps

It's difficult to write #p#.

last_monster_master(from gamasutra)

If you're good with words, that's great. You can easily create three different lines spoken by three different characters in four different situations. In general, writing non-linear text game dialogue and narrative is an effective exercise in constraints, creative reuse, and conviction.

Let's say you've outlined a text-based game. You know the theme, the main character, the major events that happen in each chapter, the player's abilities, and so on. Now you can start writing - but you're having trouble getting started. How do you write a story where anything can happen? How do you set up the player's choices? Where do you even begin?

I recently released my first unabridged text game, The Last Monster Master, to Choice of Games (250,000 words!), and in the process I came up with a basic framework that could help people write their games chapter by chapter. I used Chat Mapper (free) to write each non-linear chapter before bringing the final text into ChoiceScript (Choice of Games' own scripting language).

I broke the process down into 6 parts to complete each chapter, which helped me stay focused. In addition, Chat Mapper has a feature that allows you to change the color of each text node. This allows you to keep track of each text, and I also use this feature to change the color of each node to mark the completed content.

Pass 1 - Stub text (no color)

The first is about coming up with a structure for the chapter. Rather than writing actual dialogue or description, we can use placeholders as stub dialogue to foreshadow who will speak, when they will speak, and what the player's choices will be.

If there are different branches based on statistics and other conditions, point out the statistic in question and clearly describe the choice. Don't worry about writing any game logic yet; that will come later.

Avoid making too many revisions in this pass—the main goal is to break down the high-level chapter structure into a readable format. When you complete this task, you will have a rough idea of ​​where to go next.

In the following sequence from The Last Monster Master, one of the player's monsters becomes trapped in a tree while attacking. The player must choose to use the Telepathy or Language Detection skill to help the monster resist the attack or escape.

stub_text (from gamasutra)

Second step - modify the stub text (yellow)

In the next pass you should focus only on the structure you just created. You are looking at setting the content - don't worry about spelling mistakes or anything text-related, because everything you write will be replaced during the revision process.

You're mostly looking for choices or choice branches that don't make sense or don't fit with the story or edge cases, and that have the potential to cause problems later.

Second, you're making sure that the structure you've set up so far uses all of the player statistics or ability choices you planned to use in this chapter. If it turns out that you didn't do what you wanted to do, then you need to make a conscious decision to either revise your original plan, create a whole new sequence or choice that uses those stats, or make a note to use the omitted stats in a future chapter.

Third track - First track text (orange)

With the structure organized and polished, it's now time to write the actual text that the player will see. This is a pretty straight forward pass, but as before, you should keep your focus.

Don't worry about setting values ​​for variables, structure conversions, or any pure coding stuff. Like most pure coding stuff, this is the most fun and time consuming part.

first_text_pass(from gamasutra)

Fourth step: Modify text (purple)

Have you ever written an actual chapter? Now things move much more quickly. You'll enter edit mode.

When you read the first text, you'll notice that you wrote it without any emotion. Everything about the text is about the game - spelling, grammar, misreferences to characters or places, tighter word choice, etc. Once again, you should focus on writing. Create a living text.

Track 5 - Variables (blue)

The structure is clear and the text is tight. Now we'll go through the chapters again and look for any possible cases of variables, especially where player statistics are modified or referenced to determine outcomes. Chances are you'll only find a handful of examples for specific player items or one-off encounters.

You will refine the values ​​used here later in modifications, gameplay balancing, and testing. For now, you will draw a line where you think the values ​​should be.

Create an external reference file for the specific stats required for each chapter. For example, if the player's Strength stat must be at least 45 to kick down a wooden door in Chapter 4, it would be logical to require the player to have a Strength stat of 65 to kick down a metal door in Chapter 6.

Performing this exercise within a specific pass will ensure internal consistency of the statistics, which will further adjust subsequent values.

variable_pass (from gamasutra)

Track 6 - Output and Logic (Green)

Finally, you need to bring your finished chapters into the development tool you use to create your game. Fortunately, Chat Mapper can export to XML, JSON, Excel, and Rich Text, giving you more options. For The Last Monster Master, I simply went through each text node and copied it into my ChoiceScript file, adjusting it for formatting and some conversions.

If you're also writing the actual logic behind the scenes yourself, you'll need to start writing scripted content when you bring text into the game. Fortunately, because you've already solved the problems of when and where something happens, each scripted task will be easily separated from the content.

Other methods

This isn't the only way to write a non-linear text game, but it's a good fit for this project. Depending on the type of development you do and the tools you use, you may choose to get the stub text into the game early so you can execute it as soon as possible. Also, because Chat Mapper supports Lua, you can set up all the logic you need directly in the program, as long as you don't mind scripting everything in your development environment again.

Whatever process you choose, you should focus on one task at a time, celebrating each success and taking note of what you need to improve. Arguing for non-linear narrative is not a trivial task - so why don't you make a real game out of it?