Base Networks and Inventory

There are no conveyor belts and no inserters. Inside a connected base, resources are shared. The interesting logistics happen between bases (see logistics.md). Inside a base, the puzzle is about footprints, ratios, starvation, power and defensive layout.

Foundations and connectivity Decided

Foundation (working name was “flooring”) is the base’s network: it carries shared inventory and, from Tier 2, electricity.
Every building includes foundation under its own footprint. Placing buildings next to each other connects them automatically.
Standalone foundation tiles bridge gaps between buildings.
A building can be placed on bare ground (it’s just the building) or on foundation.
Auto-foundation for nearby placement: when placing a building a little way from the network (about 5–10 tiles), there’s an option to lay the connecting foundation automatically. That costs foundation you may not otherwise want Tentative.
- Placing shows whether the building will connect Decided. In playtests it was too easy to put a building just off the network without noticing, so it got its own stock. The preview marks the network it will join, or says it will stand on its own.
- The preview draws the connecting foundation and its cost Tentative. Within range of a network, it shows the shortest path of foundation tiles that joins it, avoiding buildings, entrances and walls. Placing the building also places those foundation ghosts. A modifier (Shift on a PC) or a toggle places the building on its own, for a deliberate outpost. The building stays apart until a crew lays the path.
- Being apart isn’t flagged on the map. Separate bases are valid, so a badge on every outpost would be noise. A building’s panel may say quietly that it’s on its own network, with that network’s stock Tentative.
Walls never connect anything. A wall on bare ground is only a barrier. A wall built on foundation doesn’t break the foundation under it.
Foundation tiles can be attacked and destroyed.
Price: 10 Basalite per tile Tentative. It must stay cheaper per tile than any building, which already includes its own foundation. Long corridors are deliberately expensive (40 tiles = 400 Basalite = four Depots).

Networks emerge from connectivity Decided

There’s no required central “base” building. Every connected group of buildings is a network.

Connect two networks and they merge automatically.
Cut a network and it splits automatically. Each piece keeps whatever is physically stored in its own buildings, with no allocation dialog.
Destroyed buildings DO break connectivity. (This reversed an earlier idea that ruins keep networks joined.) The ruin keeps the footprint so it’s easy to rebuild, but the link is gone until it’s rebuilt.
A split takes effect instantly. The cut-off piece becomes its own network. It keeps power only if it has its own generation, so it usually loses power.
Each base has a name Tentative. The Crashed Ship’s base is called Crashed Ship and counts as base 1; every other is Base 2, Base 3 and so on. A new base gets one more than the last number given out, even if that leaves a gap, so a name never moves to another base. When two merge, the higher number goes and the lower stays. When one splits, the piece with the most buildings keeps the name and the rest get new numbers.
A building’s panel shows its base’s storage: the base’s name and its total of each resource, not stacks. There’s no total of every building anywhere, since stock on networks that can’t reach each other doesn’t add up to anything the player can spend.
A thin base chewed through the middle splits in two. That’s a big disruption from little damage, and it rewards wide, redundant layouts over thin ones. Small abandoned factory fragments after attacks are expected.
Long foundation corridors to remote mines are allowed. Large bases naturally swallow nearby deposits. But corridors cost per tile, expose a long line to attack, and split when cut, while trucks are much cheaper, can be withdrawn and are cheap to replace.

	Foundation corridor	Depot-to-depot trucks
Resource movement	Instant, shared network	Real travel time
Build cost	Grows with distance	Depots (vehicles are free)
Exposure	The whole corridor can be attacked	Trucks can be intercepted, but recalled
Failure	Network splits	Deliveries pause until trucks respawn
Flexibility	Fixed	Routes can be reassigned

No throughput limit on foundation connections for now Tentative.

Storage model Decided

Resources physically live inside buildings but are logically shared across the network.
Production buildings (drills, refineries, fabricators):
- An input buffer holding at most one chunk of each input (see Input buffers and fair sharing). This replaced the earlier “no input inventory” rule.
- A small output buffer holding only their own product.
- When the buffer is full, only the overflow (one unit at a time) moves to general storage. The buffer isn’t emptied. Small outposts can therefore run with very little storage as long as trucks keep taking things away.
- If the buffer is full and there’s nowhere to put the overflow, the machine sleeps (see Building states).
Storage Silos provide bulk general storage: about 24 stacks (a 6×4 grid in a 2×2 building) [Tentative number]. Depots and other buildings give small amounts.
A Depot holds about 6 stacks Decided, matching a full load for its trucks (3 trucks × 2 cargo slots). These slots receive what trucks and the Depot’s own Harvesters bring in, and work like an output buffer: only the overflow moves on to general storage. Pre-loading stock for outgoing trucks (“staging”) was considered and dropped, because it would reserve stock other machines need.
The Crashed Ship holds about 6 stacks [Tentative number]. It needs some storage because the first Harvester can only unload at its home building, and the first Depot costs two Harvester loads.
Receiving buildings are first in, first out Decided. This covers Depots, the Crashed Ship and Outposts: the buildings that take in deliveries of mixed resources.
- When a delivery arrives and the building is full, its oldest stack moves to general storage (using the normal placement order) to make room. The new cargo lands in the building. So a Depot full of old Colite still accepts Ferrite, and its slots always hold the most recent deliveries.
- This isn’t rebalancing: stock moves only because something arrived.
- If there’s no room in the network for the oldest stack, nothing moves and the vehicle keeps its cargo (for trucks, see logistics.md).
Input buffers don’t count as network inventory Decided. Iron in a machine’s input buffer is spoken for, so it isn’t shown in the network’s totals and other machines can’t take it. Output buffers do count.
Storage uses stacks Decided. A building has slots. Each resource has a stack size (for example, ore = 50). A stack is always a single resource; there are no mixed stacks.
Silo filters Decided: a silo can be given a whitelist of one or more resources and then accepts only those. Existing contents stay. Filters don’t move inventory around. That lets a tidy player keep an “iron silo” next to the refineries so that side of the base keeps working if a split happens.
Players don’t need to care where things are stored day to day. It only matters when a network splits.
If a silo is destroyed, its contents move to other free storage in the network. If there isn’t enough room, an overflow rule applies: the network sits over capacity and can still consume but can’t add more until there’s space again Tentative. Ground spill was considered and rejected for now, because there’s nowhere to collect it into.

Simulation: per-tick netting Decided

This is the key simplification. We don’t simulate moving items between buildings by distance. Each tick, items move straight from wherever they are to wherever they’re needed.

Each tick, the available stock of a resource is what’s in output buffers and general storage (made on earlier ticks).
That stock is handed out to machines’ input buffers (see below).
Whatever isn’t handed out stays where it is or overflows to storage.

Placing a surplus (deterministic, no distance math):

Top up an existing partial stack of that resource.
Otherwise, an empty slot in a silo whose filter matches.
Otherwise, any free general storage slot.
Otherwise, there’s no room, so producers block.

Drawing a deficit: take from existing stacks (output buffers first, then general storage) Tentative.

Resources never move just to rebalance. (A full receiving building moving its oldest stack out when a delivery arrives doesn’t count: the arrival causes that move. See the storage model.)

No same-tick chaining Decided: an item finished on tick N goes into that machine’s output buffer and can only be used on tick N+1 or later. The simulation must be phased and fully deterministic.

Later, advanced storage features could include request/pull silos, reserved amounts, and priority distribution Tentative.

Worked out by simulation (Nov 2026). The goal: if production is 70% of consumption, every machine produces at 70% of full speed over time, whatever its recipe.

Requirements Decided

Whole items only. An input buffer never holds part of an item.
Recipes can need several of an input, for example 10 iron per magazine. The machine waits until it has the full amount, then crafts at full speed. It doesn’t run slower.
No hoarding. A machine doesn’t pull stock it can’t use yet. Shared inventory with instant transfers shouldn’t leave one machine sitting on stock while another starves.
Big batches can’t be starved by small ones. A machine needing 10 iron must not be outbid every tick by machines needing 1.
Equal speed, not equal turns. In a shortage every consumer slows by the same percentage. (A round-robin queue giving each machine its whole batch in turn was simulated and rejected: at 67% supply the magazine maker ran at 86% and the bolt maker at 17%.)

Chunks Decided

An input buffer holds at most one chunk of each input: the amount needed to start the next craft.
Big recipes are built in chunks. A 1000-iron item is 100 chunks of 10 iron; each chunk adds 1% to the build. Unlike small recipes, a chunked build can pause partway when starved.
This keeps every request small, so no single machine can absorb the whole supply for long. It replaced a proposed 50-item cap per turn.
Open: whether each big recipe defines its chunks, or any recipe needing more than about one stack of an input is split automatically.

The handout rule [Decided in principle; details Tentative]

For each input, every machine keeps an invisible clock counted in ticks of full-speed work. Each chunk it receives moves the clock forward by one craft time: a magazine maker (10 iron, 5 ticks) gains 5 ticks per chunk, a bolt maker (1 iron, 1 tick) gains 1. The player never sees it. A machine’s due tick is where its clock will be once the chunk it’s filling is complete.

Each resource also has a fair time: how far the furthest-behind machine that’s short of it has got. A machine is short of iron if iron was missing the last time it had to wait.

Each tick, for each resource:

Earliest due tick first. Stock goes to the machines that want it, in order of due tick. Each takes the rest of its chunk: an idle machine all at once, a machine mid-craft no faster than its full-speed rate.
At most one craft ahead. While any machine is short of the resource, a machine whose clock is more than one craft (plus about 20 ticks) ahead of fair time gets nothing this tick. That stock stays in storage for the machines that are behind.
No banked credit. A machine coming back into the running (newly built, switched back on, or done waiting for a different input) has its clock moved up to fair time if it’s behind.

This replaced an earlier tally rule (iron earned minus iron received, with “pay first”, “one machine gets ahead”, a credit cap and other patches), which failed 52 of 300 random factories. The due-tick order does what “one machine gets ahead” did: a stocked network fills one machine’s chunk at a time, and identical machines start staggered because each start moves that machine’s clock. Clocks count ticks, not items, so a big chunk can’t jump the queue.

Details found by simulation Tentative:

Rate cap while crafting (kept from the earlier rule). A machine that’s mid-craft fills its next chunk at no more than its full-speed rate per tick. This is the anti-hoarding rule when stock is plentiful; it doesn’t affect fairness.
Fair time uses progress through the current craft, not what a machine has received. A machine that has just taken a 30-tick chunk counts as being at the start of that craft. Otherwise one slow machine pushes fair time ahead of everyone and the one-craft limit locks fast machines out (with crafts of 40–120 ticks, a machine fell 23 points under its fair speed).
“Short” only changes when the machine has to wait again. A machine running flat out between truck deliveries still counts as short of iron. That’s what keeps the one-craft limit working across a whole delivery cycle.
The limit only applies while something is short. If nothing is waiting on iron, nobody is held back. Otherwise a machine held back by copper would throttle iron for everyone.
The 20-tick allowance only smooths timing. Without it, machines took their crafts in bursts (at the 95th percentile, the longest idle gap was 9.5 times the expected one; with it, 5 times). Fair speeds are the same either way. The sims counted abstract ticks; at the decided 20 ticks per second the allowance is 40 ticks (2 s). Replaying the 800 random factories with every timing doubled (sweep.py --scale 2) gives the same results: several inputs with trucks, 178 of 200 within 1 point (179 before), worst machine 9.2 points under its fair speed (the same).
Ties go to a fixed order (for example, build order), so the simulation stays deterministic.
All clocks are whole ticks. No fractions, which keeps the game simulation exact and deterministic.

What each rule fixes (200 random factories per family, rule switched off):

Without	What breaks
Earliest due tick first	27 of 200 one-input factories miss by more than 5 points; a bolt maker next to a magazine maker gets nothing
At most one craft ahead	With truck deliveries, 108 of 200 miss by more than 5 points: machines with long crafts fill up while stock lasts and keep running through the gap. Steady supply also fails (24 of 200)
No banked credit	A magazine maker switched off for 2000 ticks runs at 100% when it comes back, while the others drop to 17–25%
“Short” only changes on a wait	With trucks, 96 of 200 miss by more than 5 points

Recipes with several inputs Tentative

Each input has its own one-chunk buffer, its own clock and its own fair time. Each resource is handed out on its own.
A machine held back by one input leaves its share of the others to the rest. Once its other buffers are full it stops asking for them, so they go to other machines. Example: iron and copper both short, copper tighter. Circuit makers (iron + copper) run at copper’s 50%; gear makers (iron only) get the iron the circuits can’t use and run at 100%.
That’s the fair target for several inputs: every consumer of a short resource slows by the same amount, except machines that another input holds back further.
A parked chunk. A machine waiting for copper holds one chunk of iron that nobody else can use. If copper isn’t produced at all, the chunk stays there until it is. It’s at most one chunk per input per machine, and it’s shown on the machine’s panel (#37). Considered: stop asking for iron while there’s no copper in stock. That freed the iron, but with truck deliveries copper is often out of stock between loads, so it made two-input machines miss their share more often (more than 5 points off in 14 of 200 random factories instead of 9). Stopping only when nothing on the network makes copper works without that cost, but adds a rule for a factory that’s already broken. Leaning: allow the parked chunk.
Known limit: when inputs come in separate truck deliveries out of step, a machine that needs several of them waits for the later one. Such machines ran up to 9 points under their fair speed in 200 random factories (2.4 when the deliveries arrive together). Other machines use the stock in the meantime, so nothing is wasted.

What the simulations showed

The simulation is in scripts/sim/.

Case	Result
5 identical magazine makers, 70% supply	70% each; first starts on ticks 2, 3, 5, 6, 8 rather than all at once
5 idle magazine makers, 30 iron, no income	3 start; no iron left stuck in half-filled buffers
Super fast (30 iron/tick) + magazine + bolt, 70% supply	all 70% (missed by 3.6 points under the earlier rule)
A 50-iron batch + 20 bolt makers, 48% supply	all 48%
30× speed spread at 1 iron per tick	all 48%
120 iron by truck every 30 ticks; fast, magazine and slow (20-tick) makers	70% / 70% / 70%. Without the one-craft limit: 66% / 67% / 100%
Magazine maker switched off for 2000 ticks, then back on	back at its fair share within about 100 ticks, with no catch-up burst
Silo of 2000 iron runs dry, then 52% supply	everything at 100% until it’s empty, then 51%
Iron short, copper plentiful	wire 100%; gear and circuit makers 62.5%
19 hand-built one-input cases, 6 with trucks or several inputs	all within 1 point of their fair speed
The earlier sweep’s 900 random factories	895 within 1 point, worst 1.3 (the earlier rule: 52 of 300 off by more than 5)
200 random factories per family	one input: 200 within 1 point. One input, trucks: 196, worst 1.7. Several inputs: 200. Several inputs, trucks: 179; the worst machine 9 points under its fair speed (see the known limit above)

Production balance Decided

Machines run as hard as they can, pulling from the shared pool. When a resource runs short, every consumer of it slows by the same percentage (see Input buffers and fair sharing). Players balance by adding producers, toggling consumers, or adding storage.
Recipes deliberately use uneven ratios (2:3, 4:5…), not 1:1, so finding the ideal ratio is a long-term puzzle players will make calculators for.
Tap a building to see its efficiency, which mostly means how often it’s starved.
All consumers of a resource on one network share one efficiency for it, since shortages are shared evenly. The exception is a machine that another input holds back further; it runs at that input’s efficiency (see Recipes with several inputs).
It’s just-in-time production rather than a queue.

Grid and footprints Decided

A square grid (1 tile = 4 m; see world.md). Everything snaps; nothing is placed off-grid.
Buildings come in different shapes: mostly squares, but also rectangles, long thin ones, and U-shapes and T-shapes that fit together well. Footprint fitting is part of the puzzle.
New tiers add new buildings; nothing upgrades in place. A Tier 2 drill is a separate building, possibly bigger or a different shape, and Tier 1 drills keep running.
Tentative footprints so far: Depot 3×3, Storage Silo 2×2, Barracks 3×3.

Driveways and getting out of the base Open

The crowded hour showed a packed base boxing its own units in (first-test.md, #49). The designer’s direction:

No roads for units. Trucks and Harvesters drive over open ground, foundation and deposits. Nobody builds roads for them.
The puzzle is for units that work outside the base: Harvesters, Sword Bots and later trucks. Engineering Crews fly over everything Tentative, since planning roads for a building a crew visits once isn’t a fun challenge (first-test.md).
Getting out of the base is an early puzzle. Anything that sends units out, such as a Depot with Harvesters or a truck stop, has to sit near the edge of the base or have a clear way out through it. A tight first base that keeps growing in rings soon traps its inner Depots, and the player learns those first Depots weren’t worth keeping. On the next base they leave space and use foundation to connect buildings across it. Foundation then fills the space between buildings and doubles as a road, because units can drive over it.
Rejected: a margin around every building. A forced road or ring of foundation around each building makes building tedious.
Idea: parts of a footprint that don’t block. Every building has a footprint, but a new component could mark some of its tiles as passable. The building is still there, and its foundation still connects it to the network.
Idea: the Depot’s driveway. A 3×3 core plus one passable tile of foundation sticking out from the middle of one side, with the dock on it. The player picks which way it faces, so placing a Depot means choosing which way its units leave. This is also a first non-square shape (see Grid and footprints), and shapes like this lead players to leave lanes between buildings.

Building states Decided

Each condition is tracked separately; a building can have several at once.

State	Meaning	Auto-restart
Running	Producing normally	—
Idle: input starved	A required input isn’t available	Yes, when it arrives
Idle: output blocked	Output buffer and all storage are full; machine sleeps (maybe with less power draw)	Yes, when space frees up
Unpowered	Not enough electricity	Yes, when power returns
Off	Deliberately switched off by the player or automation	No
Damaged	Needs repair	After repair

Production overlay Decided

This replaces the information that watching belts gives you:

A toggleable overlay shows each building’s input and output resource icons, with the blocked one highlighted (for example, a red copper input).
Small status lights on buildings are visible across the map: a flashing light on an input bay, a red light on an output bay, and so on.
Tapping a building gives full detail.
Available from the start, not a research unlock. Many players will leave it on.
The network inventory screen shows totals per resource (not stacks) plus the net change over the last minute. A silo’s own screen shows its stacks.

Alerts Decided

A well-designed factory is stable forever until the player changes something or something external happens.
Production problems are not alerts. Starvation and blocking are normal balancing information, shown in overlays and stats. If the player changed something and broke it, that’s on them.
Alerts are for disruptive events only: attacks or damage, power loss caused by an attack, a deposit running out (if depletion ever exists), trucks destroyed.
Alert on the cause, not the consequences: one “generator destroyed” alert, not 40 “factory unpowered” alerts.
Something running out of power or coming under attack flashes on the map.
Disconnects aren’t alerted, since the piece just becomes its own network. If a base splits down the middle, the game says “something has gone terribly wrong,” and the player has to go find out why. That’s deliberate.

Switches and shutdown [Decided in principle]

Buildings can be switched on and off individually.
On/off switches can be wired to an area or a group of buildings. Later tiers add timers, then triggers and signals (simpler than Factorio’s circuits).
A manual base-wide shutdown switch is so useful for shedding aggro that it may be given for free as soon as power exists Tentative.
Cutting electricity isn’t a full shutdown: Colite machines and trucks keep making noise. A later unlock could add a network-wide quiet mode that also recalls vehicles, and later still trigger it automatically when threats are detected Tentative.

Command Center Tentative

Since connectivity now defines a base, a central building has no essential job. The designer still likes a Command Center, but as a high-tier optional building, not the core of every base. Possible roles: naming a base, network status, coordinated shutdowns and recalls, automated threat responses, inter-base coordination, and eventually bootstrapping other planets.