LANCER: The Default Turn Flowchart

Remembering things on your turn is hard, so do that as little as possible!

Recently in Pilot NET, I and a few other GMs had a discussion on running Lancer in person as a pickup game. The idea of having a “default turn” spelled out in writing came up, and I remembered the notion of making flowcharts for specific builds. Flowcharts are great because they offload so much decision making and memory to something I might have already decided in terms of contingencies a while ago.

Another GM (@stormtalus on Discord) correctly pointed out that flowcharts that look complex can mentally shut players off, defeating the purpose. So I made a compromise: The Default Turn Flowchart.

The Default Turn itself is relatively simple: You look at a combatant and outline what they might fall back on as a standard turn with no external factors. Look at protocols, movement options, and actions. Maybe include some simple decisions like what happens if something hits or if their Loading weapon is empty as well. Don’t overthink it, it’s the default for a reason. (Note that I say combatant: GMs can do this too!)

Here’s an example of a default turn for one of my own PC mechs, from turn start to turn finish:

1. Move if I need to, flying as necessary

2. Deploy Javelin Rockets

3. Are my Missile Racks loaded?

   1. Yes? Skirmish with the Missile Racks

   2. No? Skirmish with Sharanga Missiles

4. Did I hit with my Launcher Skirmish?

   1. Yes? Hit them with Stormbending!

The Default Turn Flowchart is taking that and then making it into a flowchart. For this, I actually have a template for PlantUML.

The PlantUML Template

PlantUML is a way of making diagrams using text/code.

If you got scared looking at that, don’t worry, it’s not bad at all. I’ll walk you through it.

First things first, you’re going to want open the PlantUML Activity Diagram Docs (it is in beta, but that just means not everything is fully fleshed out, it’ll more than work for our purposes). Don’t worry about anything before the Simple Action header.

Once you have that, click on this link here to open up the template I have set up.

Making and Modifying Blocks

Blocks are the well, building blocks of the diagram. Each block representing movement, protocols, and actions is marked with «task» at the end. PlantUML renders blocks one after the other, in the order you specify them.

Blocks look like this in the PlantUML code:

:Move; <<task>>

And this produces:

Again, everything is rendered in the order that you specify it, so this code renders to the image below:

:Protocol
(PROTOCOL NAME); <<task>>

:Move; <<task>>

Note that making a line break in the Protocol block code actually made a line break in the diagram. You can also achieve this with \n, like this:

:Protocol\n(PROTOCOL NAME); <<task>>

This produces the same Protocol block as before.

If you want to change a block, all you have to do is modify the text between the colon and the semicolon, so in order to modify a block like:

:Quick Action (JAVELIN ROCKETS); <<task>>

You would just change the Quick Action (JAVELIN ROCKETS) text, ignoring everything else. If you accidentally delete something, just look at the other blocks for reference.

To delete a block from the rendering, just delete it in the code. Easy!

Blocks can have whatever text you’d like in them. You can represent Protocols, Quick Actions, Full Actions, Movement, whatever you need!

Decisions: What if . . . ?

If something isn’t guaranteed, like an on hit effect, you can represent that with a decision. Programmers know these as conditional statements, or “if” statements.

Decisions have three components: A question, a “yes” path, and a “no” path. Let’s have a look at an example and break it down:

if (Question?) then (YES)
    :Skirmish
    (WEAPON/MOUNT 1); <<task>>
else (NO)
    :Skirmish
    (WEAPON/MOUNT 2); <<task>>
endif

The question is fairly self-explanatory, just write whatever question you need to ask, such as: Did my Launcher attack hit? Do I have a charge of a particular Limited system?

Then, the “yes” path is the first one, and the blocks are indented here for visibility. So if our Question has an answer of YES, we go down the leftmost path in the diagram, and the first set of indented blocks in the code, after the if (Question?) then (YES) line.

If our Question has an answer of NO, then we go down the rightmost path in the diagram, and the second set of indented blocks in the code, after the else (NO) line. Pretty simple, right?

If you have more than two conditions, they’re rendered from top to bottom in the code, left to right in the diagram. You’ll also need an elseif line. Here’s an example:

if (Multi-Answer
Question?) then (YES)
    :Overcharge; <<task>>
    :Skirmish
    (WEAPON/MOUNT 2); <<task>>
(NO) elseif (Other Question?) then (YES)
    :Overcharge; <<task>>
    :Invade
    (INVASION OPTION); <<task>>
else (NO)
    :FREE ACTION; <<task>>
endif

As you can see:

• The if (Multi-Answer Question?) then (YES) line leads down the left path,

• The (NO) elseif (Other Question?) then (YES) line leads down the middle path, and

• The else (NO) line leads down the right path.

Comments: Note To Self . . .

If there’s some particularly tricky bit of logic you need to explain to yourself, or some block you want to not render, you can use a comment to have some text within the code not render at all.

PlantUML ignores anything with an apostrophe (‘) in front of it. As an example:

':I won't get rendered!; <<task>>

'Neither will I!

:But I will!; <<task>>

And if you have a system or talent or other text you need to render with an apostrophe in it, don’t worry: Any text inside a block is processed as-is, apostrophes and all.

:I'm Your\nHuckleberry!; <<task>>

Last Thing: Titles & Multiple

If you want a quick reference for which Default Turn you’re looking at (if, say, you have multiple), you can add a Title to it. For example:

title My Default Turn

Plus, if you want to have multiple Default Turns for a single build (or for multiple builds), you can make a little index of your diagrams and when you might use them. For example, let’s say we have a mech named Sweet Victory:

Sweet Victory’s Default Turn Index

Sweet Victory Default: Move and attack. Use this if there’s no specific opportunity.

Sweet Victory Focus: Lock on and attack. Use this for high-evasion enemies.

Sweet Victory Ultimate: Pop core, wreck face. Use this when it’s do or die.

Conclusion

To sum up, Default Turn Flowcharts are visual representations of a preset turn that you can fall back on if you ever get stuck. They can be handy for newbies and veterans alike. Remember, all of this can be adapted for NPCs as well, so don’t think this is just for players!