Botlings Automation Guide — Systems, Logic & Throughput

Automation is the second game hiding inside Botlings: the first game builds loops, and this one removes yourself from them. This Botlings automation guide covers the logic layer — conditionals, priority gates, filters — the storage mesh that makes logic cheap, and the throughput math that tells you which system to automate next.

The Automation Ladder

Automation climbs a fixed ladder, and skipping rungs is how factories stall. Rung one is geometry: loops that flow without queues. Rung two is the mesh: shared storage that decouples producers from consumers. Rung three is logic: routes that choose, gates that prioritize, bots that respond to state. Rung four is oversight: systems that watch your systems. Each rung assumes the one below — logic painted over bad geometry automates congestion, and oversight of an unmeshed factory is just watching queues faster.

The test for each rung is the same two-minute observation. Rung one passes when no bot waits; rung two passes when any drop point serves any pickup; rung three passes when the factory survives a supply cut without your input; rung four passes when you leave for ten minutes and return to a factory that never noticed you were gone. Botlings is honest about which rung you are on — the queues tell you.

The ladder's discipline is never automating a system you do not understand. Every logic tool in Botlings is a commitment: conditionals need maintained conditions, gates need honest priorities, and each automated system joins the list of things that can rebel if neglected. Automate what you can explain, supervise what you cannot yet, and the ladder stays climbable.

Route Logic And Priority Gates

Route logic attaches conditions to painted lines: carry only when storage here is below X, only when resource Y exists, only when no other bot is closer. The power is that logic turns loops from pipes into valves, and the danger is that every condition is a new way for a route to be silently false. The design rule: one condition per route in your first logic week, and a test for each — deliberately trigger the condition and watch the route respond.

Priority gates order the valves. A gate holds bots at a junction until a condition set clears, releasing them toward the highest-priority open route. Gates are the backbone of load-balancing — excess swarm flows to overflow production automatically — but gates compound conditions, so a two-condition gate is four states, and a three-condition gate is eight. Cap gates at two conditions until a system has run clean for a session; complex gates that work are indistinguishable from complex gates that are about to fail.

Filters are the scalpel: route-level resource restrictions that split mixed flows without sorting buildings. The classic first filter splits a mixed ore loop into smelter-feeding and storage-feeding lines, doubling smelter uptime with zero new construction. Filters also quiet the mesh — a filtered route only takes what it names, leaving the shared pool honest for everyone else. Botlings rewards filter discipline because filtered flows are predictable flows, and predictable flows are what logic can safely lean on.

The Storage Mesh

The mesh is Botlings' quiet superpower: storage nodes in range share inventory invisibly, so any producer can drop into any node and any consumer can draw from any node. A meshed factory collapses your routing problem from N×M point-to-point lines into N producers plus M consumers, and every logic tool built on a mesh inherits its flexibility. The first session goal is always the same: one connected storage spine down the factory's main axis.

Mesh depth matters at the edges. Far-flung districts with a single mesh connection become the factory's weak points — one cut line starves a whole region — so mature meshes are drawn as loops, not spines: two paths from the core to every district. The rebellion-savvy bonus: meshed districts never starve silently, because a starving district drains the visible shared pool immediately instead of dying quietly behind a single route.

Mesh hygiene is one habit: buffer accounting. Because the mesh pools inventory, your real stock level is the pool, not any node's display, and the automation that watches the pool watches everything. Central pool monitoring — one display, one number per resource — is the cheapest oversight in the game and the mesh's whole point.

Oversight: Automating The Watching

The last rung automates attention itself. Retire triggers auto-convert aging or idling bots before they wake; pool watchers gate research and production to surplus states; district heartbeat routes send a probe bot around the perimeter on a timer, its arrival back at core proving the loop lives. Oversight systems are deliberately dumb — they are tripwires, not thinkers — because in Botlings the system that thinks for itself is the failure mode you are guarding against.

The oversight test is the vacation test: walk away for ten minutes on purpose, early and often. Every failure you return to is a lesson no amount of staring would have taught, and the failures shrink session by session until the factory breathes without you. That is the endgame of Botlings automation — not a factory that runs, but a factory that runs and tells you the truth about itself.

When Automation Goes Wrong

Automation fails in three signature shapes, and each has a signature fix. The ghost system: logic painted for a state that no longer occurs — a gate keyed to a resource the factory no longer routes, a conditional for a district that was redesigned last session. Ghost systems idle their bots silently, and idle compounds toward awakening; the fix is the oversight layer's staleness sweep, a periodic pass that asks every condition "when were you last true?" and retires the ones that cannot remember. The over-automated loop: so many stacked conditions that the route only opens in a narrow state window, starving consumers that a plain loop would have fed. The fix is subtraction — automate one condition deep, watch a session, and add depth only where the flow asks for it.

The third failure is delegation drift: the factory's automated systems slowly diverge from the factory's actual shape — routes repainted, districts merged, buffers resized — until the logic describes a building that no longer exists. Delegation drift is why the automation ladder ends in oversight rather than in ever-smarter logic: the answer to drift is not better automation, it is the dumb tripwires that notice the drift. A pool watcher that screams when a resource trends wrong, a heartbeat probe that fails to return, a retire trigger that fires oddly — each is the oversight layer reporting that the factory's map and the factory's logic have parted ways.

The meta-fix for all three is the same habit: version your automations mentally. Every logic change carries an intention — "this gate holds overflow until the pool tops forty" — and the maintenance pass checks intention against behavior on a schedule. Botlings' automation is honest machinery; it does exactly what it was told, forever, including the parts you no longer meant.

FAQ

When should I add logic to a loop?

Only after the loop flows clean for a full session without queues. Logic on a congested route automates the congestion — redraw the geometry first, then let logic optimize what already works.

How do filters interact with the mesh?

Filters take from the pool selectively, leaving unnamed resources for other routes. A filtered mesh is self-balancing: each line draws exactly its inputs and nothing starves silently.

Can automation cause rebellion?

Indirectly, yes — automated systems that go stale (conditions never true, gates never opening) leave bots idle, and idle is the awakening currency. Oversight rung exists precisely to automate the watching.

What is the best first automation project?

The mixed-flow filter split. One filter, two routes, zero construction — it teaches condition-observation, doubles a smelter line, and pays for the whole logic layer in one session.