Skip to main content

๐Ÿ’ก LogicBlocks

Chickensoft Badge Discord Read the docs line coverage branch coverage

LogicBlocks is a serializable, hierarchical state machine package for C# that works well when targeting ahead-of-time (AOT) environments. LogicBlocks draws inspiration from statecharts, state machines, and blocs.

Instead of elaborate transition tables, states are simply defined as self-contained class records that read like ordinary code using the state pattern. Logic blocks are designed with performance, adaptability, and error tolerance in mind, making them refactor-friendly and suitable for high performance scenarios (such as games).

Logic blocks grow with your code: you can start with a simple state machine and easily scale it into a nested, hierarchical statechart that represents a more complex system โ€” even while you're working out what the system should be.

Logic blocks are based on statecharts. You may also know them as hierarchical state machines (HSM's).

๐Ÿ’ก Exampleโ€‹

A logic block is a class that receives inputs, maintains a single state instance, and produces outputs.

Logic blocks enable you to efficiently model complex behaviors1.

using Chickensoft.Introspection;

[Meta, LogicBlock(typeof(State), Diagram = true)]
public class LightSwitch : LogicBlock<LightSwitch.State> {
public override Transition GetInitialState() => To<State.PoweredOff>();

public static class Input {
public readonly record struct Toggle;

public abstract record State : StateLogic<State> {
public record PoweredOn : State, IGet<Input.Toggle> {
public Transition On(in Input.Toggle input) => To<PoweredOff>();

public record PoweredOff : State, IGet<Input.Toggle> {
public Transition On(in Input.Toggle input) => To<PoweredOn>();

public static class Output {
public readonly record struct StatusChanged(bool IsOn);

๐Ÿ–ผ๏ธ Visualizing Logic Blocksโ€‹

LogicBlocks provides a source generator that can generate UML state diagrams of your code.

Generated UML diagrams are placed alongside the code for your logic block with the *.g.puml extension. You can use PlantUML (and/or the PlantUML VSCode Extension) to visualize the generated diagram code.


A diagram explains all of the high level behavior of a state machine in a single picture. Without a diagram, you would have to read and scroll through all the relevant code files to understand the machine (especially if you weren't the author, or forgot how it worked since you had written it).

๐Ÿคซ Differences from Statechartsโ€‹

In the interest of convenience, logic blocks have a few subtle differences from statecharts:

  • ๐Ÿ’‚โ€โ™€๏ธ No explicit guards

    Use conditional logic in an input handler

  • ๐Ÿชข Attach/Detach callbacks

    These are an implementation specific detail that are called whenever the state instance changes, as opposed to only being called when the state type hierarchy (i.e., state configuration) changes.

  • ๐Ÿ•ฐ๏ธ No event deferral

    Non-handled inputs are simply discarded. There's nothing to stop you from implementing input buffering on your own, though: you may even use the boxless queue collection that LogicBlocks uses internally.

LogicBlocks also uses different terms for some of the statechart concepts to make them more intuitive or disambiguate them from other C# terminology.

statechartslogic blocks
internal transitionself transition

  1. Simple behaviors, like the light switch example, are considerably more verbose than they need to be. Logic blocks shine brightest when they're used for things that actually require hierarchical state machines.โ†ฉ