Squaring A Circle – Game State Preview

One of our core design planks is that Tarinoi is unopinionated. We want you to be able to write any kind of game on it. It could be a 4x, a shooter, a visual novel, a role-playing game, an adventure game, or pretty much anything with more text than Tetris. This means that we don't want to lock you into any game engine, programming language, or similar constraint.

During our testing, we got one message from our early users loud and clear. They loved the in-app playback that lets you see how dialogue plays out from any point even as they're writing, but they told us that they would really appreciate being able to prototype how it flows in different game states. This would also let them debug any game state related problems on the fly.

So we set out to find a way to let you see how your story reacts even as you're telling it, without locking you into our assumptions about how game stories are structured or how they connect to the gameplay logic.

Introducing Tarinoi Core Functions ​

Our solution is to introduce a set of core functions for setting and checking game state. These functions are optional – you can delete them if you don't want them, and recreate them if you change your mind. You use them in Tarinoi projects just like functions you've defined yourself.

The only difference is that these core functions are implemented in Tarinoi, and our official plugins will generate reference implementations of them in the game projects for you to build on. This means that if you use these functions, the in-app playback will behave just like the game engine. Setting a variable writes it into a game state, checking it reads it. So, for example, you can invoke SetFlag(rushed_door) on a card, and then use FlagIsSet(rushed_door) in a condition to gate a card on it.

A lot of the time flow control is just checking flags, or comparing strings and numbers. The core functions can handle that.

You also get a panel that displays all the variables that are referenced on a board, and lets you manage your "savegames." So you can set up your Barbarian savegame with one set of stats (held in variables) and your Wizard savegame in another one, switch between them, and see how the dialogues play out when you gate content on thresholds against player stats or story state.

Still Not A Game Engine ​

Our core function set is pretty small, and while we're open to extending it based on feedback from our users, we don't want to turn Tarinoi into a full-fledged story engine with a scripting language. We believe that kind of thing belongs in the game engine, and every game handles it differently. So, for example, the built-in functions don't handle forking at all – things like going down one path if your skill check succeeds and another if it fails. The in-app playback will just ask you to choose PASS or FAIL when it encounters a fork. That's still all in-engine.

You can still do a quite a bit:

• Set a variable. We have SetFlag, ClearFlag, SetText, SetCounter, IncrementCounter.
• Check variables and compare things against other things. For example, FlagIsSet(met_ferryman), NumberAtLeast(skill_persuasion, thresholds.MODERATE), StringEquals(player_origin, origins.MARTIAN), or NumberEquals(party_morale, 5).
• Combine these checks into a boolean condition, with AND/OR/NOT. So, for example, you can do !FlagIsSet(met_ferryman) && NumberAtLeast(stat_charisma, thresholds.EASY).

It's A Debugging Tool ​

The earlier you catch problems, the better. You'll still want to do your final debugging and playtesting in the game engine, but with the Core Functions you'll be able to get most of the way there as you write, just by switching to the playback tab and modifying or swapping out game states. We believe that the Core Functions cover about 80-100% of controlling how dialogues flow in real projects. Exactly how much, depends on the specifics of your mechanics and how your story elements integrate with them.

Tarinoi's in-app playback is there to help you with this part of the creative process. You can run through options as you're writing, use the health check to pick up any obvious structural problems, and play through your dialogues in a variety of game states. It will immediately give you a feel for how they react, and help you find and fix bugs before they even make it into the game engine. And when they do, the near-real-time sync in our plugins will let you iterate on things on that side almost as fast.