Devlog #40 - Writing Structure in Detail


This week it's my turn again to write a devlog and because most of the work I'm doing right now isn't really ready to be put into a devlog just yet, I decided to go into a bit more detail on the writing in //TODO: today in terms of its structure and branching.

But before we get to that, as you might have noticed we weren't able to keep up with the posting schedule of the remaining poll answers. Due to other responsibilities we have to take care of, we ran into a few delays so we'll only be able to post one answer per week. So even if it will take a bit longer now, you'll definitely see them all!

And now back to writing!

If you were already reading our devlogs back in 2017, this might sound familiar but there is a lot I couldn't write about yet back then. Now that the game is out and pretty much complete though, it's finally time for an addition to the second devlog we ever posted!

I already wrote about the overall structure almost two years ago, so I won't repeat all of that now. What's important to know though is that //TODO: today features very little branching on a broader scale. Most of the time there are several ways to get through certain in-game days but all the branches eventually rejoin.
With the exception of one day towards the end of the month, every playthrough will go through every in-game day in one way or another, but if there isn't much branching in the overall story path, then how does the story react to player choices?

Quite a while ago before we even started thinking about making //TODO: today, I read a blog post by Nicky Case in which they briefly talk about a concept they call "broadening". I think it's quite an interesting alternative to traditional branching as it tackles the problem of interactive stories growing exponentially due to player choices while still making the choices feel meaningful.

The gist of this idea is to keep a comparably concise path through the story but remember the choices that were made along the way (both important and unimportant). By doing that you can add callbacks to them when it's appropriate and as a result the story essentially feels "broader" than it actually is, even without entirely unique branches.

Of course there are some problems with this as well because you still need to find natural ways to include the callbacks in order to keep the illusion alive.
If your story doesn't have branching and you make it too obvious that you are just repeating something from a previous choice (maybe even verbatim), the player will probably become aware that they are experiencing a linear story that tries to trick them into thinking it's not.

And given the premise of //TODO: today where you experience the story of a struggling artist who basically has a month to get their life in order, that would not only fail the player but also the basic concept.

In the end //TODO: today uses a combination of "branching" and "broadening" and especially in the second half, this is used quite extensively.

Because there's no way around it to fully go into detail on this, the following part will be somewhat spoiler-heavy but if you've read this far, I'm assuming you've played the game already.

Essentially, there is one major event that influences pretty much the entirety of the second half: Joyce's departure. More important structurally though is whether or not Joyce returns.

All scenes at Teal's home after March 22nd have two versions depending on whether Joyce is there or not. Other scenes maybe change a few lines but can usually avoid having too drastic changes.

Some days like the Naughty Cat competition have whole variations where Teal either takes part or watches a live stream of it (although it reuses some text here and there, too).
The variation where Teal is at home and watches the live stream also has two versions, one with and one without Joyce but for the most part those aren't entirely separate scenes and instead use if-statements to selectively use or skip certain lines.

This gets especially complicated once the romance comes into play and we have a scene like the following one where effectively half of the dialogue is made up of these conditional-statements:

if joyceReturn:
    if joyceRejected:
        j "Good morning, [tName]."
        j "How are you feeling today?"
        j "Good morning, [tName]!"
        j "How are you feeling on this wonderful Monday?"
    t "Morning, Joyce."
    t "I'm fine."
    if romance == "Joyce" or romance == "Phoenix":
        t "Actually,{w=0.3} I feel pretty good."
    if joyceRejected:
        j "That's good to hear."
        j "That's great to hear!"
    if romance == "Joyce":
        j "It's the same for me."
    j "Today is another day at the bookstore, right?"
    if romance == "Phoenix":
        t "Yeah.{w=0.3} And it's one of the last days Phoenix will be there."
        t "Yeah.{w=0.3} There's only two left this month."
    j "Oh, right. The month is almost over now."
    if tMoney < 700:
        t "I hope I'll make enough money..."
        t "At least I made enough money."

Well, and of course there's also a version of this scene without Joyce.

    t "March is almost over now."
    t "I only have two more work days this month."
    if tMoney < 700:
        t "I hope I'll make enough money..."
        t "At least I managed to make enough money..."
    if romance == "Phoenix":
        t "But I still can't believe what happened on Saturday."
        t "I'm somehow really excited to see [pthem] at the bookstore today!"
        t "Especially because it's one of the last days we'll be working together..."

This basic technique is used quite often to various extends so sometimes it's just a single line that could change based on previous events, sometimes the difference can be a whole scene (like the customer during the afternoon shift on March 13th who only comes back to return a book if you chose the correct one four days earlier), or like in the above example: a mixture of both.

As you can see, this way of handling the consequences of player choices doesn't entirely cut down on writing variations but just in terms of sheer scope I think it's still easier to handle than writing the same scene twice or more. Of course intertwining the variations with nested if-statements brings some problems of its own because it becomes increasingly difficult to see if the dialogue still flows well in all possible variations.

Ultimately it all comes down to deciding which structure or technique best strikes a balance between being economic and making the story feel interactive. And there's no one true way to do that.

For //TODO: today's overall theme and structure it made sense to tell the story day for day and weave in all the branches and variations within those fixed sections of the plot.
Having said that, there are plenty of moments where I strayed from the economic side and wrote some dialogue for cases that are highly unlikely to be seen by many people. Conversely, other moments in the game may be disillusioning if you play it multiple times and realize just how much (or little) changes.

Figuring out what use of branching (or other techniques) is sensible or not for certain situations is a whole other topic so I'll just leave it at that, but I hope this insight into //TODO: today's script was interesting!

Next week PECTIN will be back with another post about the art of the game.
As always, thank you for reading and have a nice day!

Get //TODO: today

Download NowName your own price

Leave a comment

Log in with to leave a comment.