Building branching Storyline simulations that let learners go down the wrong path

There is definitely value in allowing learners to fail and experience the consequences of their decisions, but is there value in continually allowing them to make mistakes?

My preference would be to let learners experience the consequences of a poor decision, then give them the opportunity to retry that part of the scenario or gently nudge them back towards the correct path.

That way, they still learn from their mistakes without becoming stuck in a cycle of failure.

Twine is my go-to if I want to quickly and easily start creating branching narratives. Its interface makes it really easy. There's a process in getting it over into Storyline, but Twine is built to make interactive narratives really easy. As you add more scenes/pages, you'll be able to see the story and paths in a way that Storyline can't show you, a way that makes it much easier to debug and understand at a glance.

Everything's tracked with variables of one kind or another.

For my own sake, I've lately been trying to change my perspective from the idea of branching from slides or pages (I grew up on the old school CYOA books from the 70s and 80s) and instead trying to design content that adapts.

When I've designed from the perspective of slides or pages, I usually imagine a bunch of button choices and each button goes to a slide where the NPC being spoken to can provide a custom response. Imagine the NPC asks the player where they should go first, and the NPC's response varies based on the button chosen by the player. Many light branching implementations will converge all of those slides back together. Regardless of where you tell the NPC you want to go, maybe everyone ends up in the break room. That branching is easy to write, and if done well can provide important agency for the player and flavor text for the experience, but if done poorly or too often, comes across as useless filler. People don't want to provide answers to questions that never matter.

You can imagine a larger, game-like branching that sends learners to different locations with different characters and different challenges, and maybe there are unique end-states or maybe they all again converge. But that's a lot of slides. Duplication can be a time-saver, and this method aims for distinct content.

A happy middle seems to me to be training that provides either mostly-all good choices or mostly-all bad, and then the learner has to make decisions with trade-offs. I've helped with safety training before and the behavioral questions are always so painfully obvious. Should you wear the helmet, eat a snack, or take a nap? Add some holistic variables (time, money, CSAT) and have the learner's choices make those go up and down. If you choose action A, your manager loses trust but you save time. If you choose action B, you lose time but you save money (or something.)

Then the content can adapt to those choices in both large and small ways. Perhaps one character throughout the course can have an energetically-talking state, a neutrally-talking state, and a closed-off-talking state, and each time the character appears, alter the state based on his mood variable or something. The impression is of "branching" content in that the content responds to the learner's actions and choices but we don't have to create 70 slides that any one learner will never see 80% of.

I should instead try to design simulation slides that everyone sees and that modify themselves to guide. A JavaScript switch-case could easily switch an NPC's "now that you're done..." text depending on how well the learner performed, how quickly they did it, how many tries they needed, what day of the week it is, and more. A more personalized narrative without flowcharts telling me to turn to page 79. 

KevinReagh​: There are different ways to branch in Storyline. For extended "paths," I branch to slides (instead of layers). But the "best" method really depends on the complexity of the branching, as well as personal preferences. 

I think these are the most important steps:

• Map out the branching in advance.
• Test all the possible paths, including recovering/restarting. 

 

My post about branching includes a .story file that demonstrates how to let the users choose their own path. However, the same programming advice applies for branching simulations.