Hit Your Mark

A few weeks back I wrote about how the town keeps turning when you’re not looking — the scheduling layer that has villagers moving like clockwork whether or not you’re in the room. This is the sequel to that post. The town moves; now it has to talk, and talking on camera turns out to be a much weirder problem than moving.

Fair warning, same as last time: this is a background post — the dense, in-the-weeds kind. Design notes, not screenshots; no trailer beats. If you came here to see the game, this isn’t that one. If you came here to hear a two-person studio talk itself out of a corner it spent a week painting, pull up a chair.

And the standing caveat: this is work in progress. What follows is where the design landed this week, after the previous version fell over in testing. Parts of it are running in the vertical slice right now; parts are a few days old and haven’t been stress-tested across the whole game. Treat it as a snapshot from the middle of the build, not a finished system. Some of these calls will look different by the time we ship, and if they do, that’s the process working.

The thing that looks easy and isn’t

Here’s the deceptively simple goal. Two characters have a conversation. The camera should cut between them like a film would — over this shoulder, then that one — they should be framed nicely, facing each other, and when the conversation ends the camera should hand control back to the player without a seam. Every cozy game does this. It should be a solved problem.

It is not a solved problem, and the reason is one word: branching.

Our dialogue branches. Not occasionally, as a special case for big story moments — branching is the default texture of how the writing works. The very first real conversation in our Day 1 content forks in its opening exchange. The player picks a reply, and the scene goes one of several ways. That’s the whole pitch of the game, honestly: choices that build rather than break. So any system that stages conversations has to treat branching as the normal case, not the exception.

That single fact quietly demolished the first design we built.

The version that fell over

The intuitive way to build a cinematic conversation in Unreal is to reach for Sequencer — the engine’s timeline tool, the thing you’d use to author a cutscene. You lay out a track, you key your camera cuts, you drive a little director that says “now show this line, now cut to her, now show that line.” The timeline is the boss. It owns the scene from first frame to last.

We built that. We pointed it at real branching dialogue. It came apart in three different ways, and each one taught us the same lesson from a different angle.

First, a timeline is a straight line and a conversation is a tree. A Sequencer track runs start to finish. It does not natively understand “the player chose option B, so skip those three beats and play these two instead.” We could bolt branching on, but we were fighting the tool’s entire shape to do it.

Second, the dialogue logic didn’t even run in that mode. Our conversations are authored in Articy (our narrative-design tool), and the little scripts attached to each line — the conditions, the state changes, the “has the player met this person yet” checks — simply don’t execute when you’re statically stepping a timeline. The timeline was playing a recording of a conversation, not having one.

Third, and this is the one that cost the most hair: Sequencer kept re-instancing its director and losing its place. Under certain playback conditions the engine rebuilds the director object mid-scene, and any state we’d parked on it evaporated. We chased that ghost through two separate bugs before we accepted what the room was telling us.

The room was telling us we had the hierarchy upside down.

The reframe

Here’s the whole post in one sentence, the thing everything else hangs off of:

The dialogue flow is the master script. Sequences are just shots.

Flip the boss and the servant. The conversation — the branching, Articy-driven flow — is in charge. It always was the thing that actually knew what was happening: who’s talking, what they’re saying, which fork the player took. So it drives. The cinematic timeline stops being the director and becomes a prop the director can call for: a short, pre-rolled “shot” you cue when you want a flourish, and nothing more.

   OLD MODEL (fell over)              NEW MODEL (the reframe)

   Sequencer timeline                 Dialogue flow  ← the master script
        │  drives                          │  drives
        ▼                                  ▼
   plays back dialogue            staging layer (cameras, marks)
        │                                  │  cues, when asked
        ▼                                  ▼
   branching? state? ...uh        short sequence "shots" for set pieces

Once you say it out loud it sounds obvious. Most good architecture decisions do, after. The trick is that we only got there by building the wrong one first and feeling exactly where it chafed. The branching that broke the timeline is native to the flow. The scripts that wouldn’t run in static stepping run fine when the flow is the thing stepping. The director that kept getting rebuilt is gone, because the flow doesn’t get rebuilt.

A ladder, not a switch

The mistake lurking inside “make conversations cinematic” is thinking every conversation needs the full treatment. It doesn’t, and pretending it does is how a two-person studio drowns. So presentation is a ladder with three rungs, and most conversations live on the bottom two:

• Plain UI, anywhere. You walk up to someone, you talk, you get the dialogue box. No camera work, no staging. This is the default and it’s available everywhere, for everyone, including characters wandering around outdoors. Most incidental chatter is this and should be.
• Staged, at authored spots. The same conversation, but now the camera cuts between framed angles like a scene in a film. This is the new layer. It turns on at specific, hand-chosen locations — and only there.
• Hero sequences, for set pieces. The big, fully-authored moments — a dramatic entrance, a scripted beat you want keyed frame by frame, the handful of times a year you’d cut a trailer from. These are real Sequencer cinematics, cued by the flow as blocking “shots.” There are almost none of these, on purpose. They’re expensive, so we spend them like they’re expensive.

The art is in the middle rung being cheap. A designer shouldn’t have to author a cutscene to get a nicely-framed two-shot. They should be able to drop one object into the world and have staging happen. Which gets us to how that works.

How staging happens without authoring it

Two pieces do the work.

The first is a stage — a single actor you place in the world. It carries a little three-camera coverage rig (the angles a conversation cuts between) and a couple of speaker marks: the spots where the people in the scene should stand to be framed correctly. If you’ve ever seen the strips of tape on a film set floor that tell an actor where to stand, that’s a mark. Same idea, same name. The stage is “here is where a scene can happen, and here is how to shoot it.”

The second is a controller that runs the conversations. And the ergonomic we’re proudest of this week is how little it asks of anyone. The game wires up three hooks — conversation starts, a new line plays, conversation ends — once, for every conversation in the entire game. Those hooks are always called. But they do nothing at all unless there’s a stage involved. No stage nearby? The hooks quietly no-op and you get the plain dialogue box. Stage present? The same hooks light up the cameras, put everyone on their marks, cut through the scene, and tear it all down at the end.

That’s the payoff of the reframe in practical terms: staging is opt-in by placement. You don’t flag a conversation as cinematic. You don’t write a special version of it. You drop a stage where you want the scene to look good, and the exact same conversation that would’ve been a plain text box becomes a staged one. One code path, every conversation, cinematic or not. There aren’t two systems that can drift apart, because there’s only one.

Where the marks go (and where they deliberately don’t)

If staging needs marks, and marks are fixed spots in the world, then staging only works where you know in advance where people will be standing. That’s not a limitation we’re apologizing for — it’s the doctrine.

Stages go where positions are knowable at authoring time: a shopkeeper behind their counter, a character at a workstation, a quest beat that happens in a specific room. In a lot of those spots the character is already pinned to a piece of furniture or a station — and the clean trick we landed on is to put the framing mark on that station. The spot the scheduling system already sends them to and the spot the camera frames are the same spot. The old “the actor’s standing slightly off their mark” problem dissolves, because the mark is the place they were always going to be.

And the characters who roam — the ones crossing town on the navigation graph, the ones who could be anywhere when you walk up to them — deliberately get the plain UI. You can’t pre-place a camera mark for someone whose position is a moving target. Trying would mean snapping them somewhere to be filmed, which is exactly the kind of seam this whole effort exists to avoid. So we don’t. Roaming chatter is rung one, and that’s the right answer, not a fallback.

There’s one honest gap still open here, and since this is a from-the-workbench post you get to see it: when a scene’s characters are already standing in the room, we currently frame them where they are rather than nudging them onto the exact marks. Most of the time that’s fine. If it ever isn’t — if someone’s badly placed for a shot — the fix we’ll reach for is to hide the real character and stand in a double on the mark, never to teleport the real one. The scheduling system owns where characters actually are, and we learned a long time ago not to let two systems argue about a character’s position. (That was the whole spine of the last post.)

Why bother

Every call in here trades something. Inverting the hierarchy gave up the comfort of a familiar tool — Sequencer is right there, and we walked away from using it as the boss. Opt-in-by-placement gave up fine-grained control to buy a single code path nobody has to think about. The marks-only-where-positions-are-known doctrine gave up “cinematic everywhere” to buy “no seams, ever.”

The through-line is the same one as the scheduling post, because it’s the same studio with the same fear: we’d rather pay in places that are cheap and visible than in places that are expensive and silent. A conversation that falls back to a plain text box because there’s no stage is cheap and visible — you’d notice it in a second and it’s never wrong, just plain. A cinematic system with two drifting code paths and a director that quietly forgets its state is expensive and silent, and it’ll eat a week of a two-person studio’s life when it finally bites.

So: the flow is the boss, sequences are shots, staging is a thing you place rather than a thing you author, and the camera only ever frames people we already knew where to find. Boring and deterministic. That’s still the whole strategy.

This is where it stands today, mid-build. Ask us again in a couple of months and some of it will have moved under contact with the rest of the game — and we’ll write that up too when it does.

More from the workbench soon. If you want the louder updates, that’s what the socials are for — this corner of the site is where we leave the long notes.