Decision Log

Major decisions in roughly the order they were made. Reversals are called out, so you can see why the current design looks the way it does. Line numbers point into transcripts/original-conversation.md.

Concept (L1–650)

1. A factory builder (about 75%) plus tower defense plus the WarDogs portable drill plus light RTS.
2. Noise is the central mechanic. The aliens are blind and hate noise.
3. Trucks and supply lines instead of conveyor belts.
4. A big drill for the key resource; the player turns it on and off; its circle keeps growing while on.
5. Aliens retreat to hives; offensive play against hives is valid; hidden bosses can be pulled in by over-drilling.

Multiplayer and economy (L650–1190)

6. Shared, persistent co-op map; pauses when the last player leaves.
7. Huge upgrade tree. Small resources sustain a tier; the key resource unlocks the next.
8. Aliens carry the key resource, so killing them is a way to earn it.
9. Turtle (walls as a consumable), aggressive, and hybrid strategies are all valid.
10. Hives expand and resettle, so cleared ground has to be held.
11. Ordinary noise is constant and additive. The drill ramps up and spools down slowly, so you can’t snap aggro off.
12. No avatar; units belong to buildings; missions instead of commands; very little micro.
13. Exponential upgrade costs; about 50 hours; mobile-first; drop-in/drop-out.
14. The enemy is the reason to fight (you want their resource), not just a nuisance.

Additions (L1214)

15. Automation as progression (blueprints, construction bots, auto-recall, simple logic).
16. The drill can be placed inside your base (WarDogs-style).
17. Dropped resources sink into the ground; collect them by hand at first, automate later.
18. Day/night with nastier nights (tentative).

Q&A (L1240–2490)

19. You pick the base site; robot scout drones instead of an avatar or human scouts. No population management.
20. Never softlock, from the first five minutes to 40 hours in.
21. Units have a capacity per building.
22. Shared inventory within a base, no belts. Placement matters for defense, not routing. First prototype: shared pool, keep it simple.
23. Power is a capacity, not a stockpile. Later solar and batteries.
24. The key resource is a currency; other resources are physical.
25. Tiered buildings are new buildings, not in-place upgrades; differently shaped footprints on a grid; deliberately uneven ratios.
26. Vision is a fixed radius per building and not additive; hatched fog inside the noise zone.
27. Trucks run depot to depot, loading at both ends. A Colite drill seeded once then fuels itself.
28. Introducing power unlocks tier 2; Tier 1 has no generators. First Colite mine = first taste of self-sufficiency.
29. “Oil” means unobtanium for tech, not fuel. It’s evolution inside the aliens’ bodies.
30. The aliens want quiet, not destruction. Shutting down is a defense. A quiet base with a nearby hive is safe.
31. Superseded: an indestructible central base → instead much of the base survives because only noise is targeted.
32. Targeting: threats first, then nearest noise (not loudest); memory and commitment; spreading out; momentum.
33. Basic aliens path around walls up to about 20 m, otherwise break through.
34. Ruins keep their footprint and can be walked over; repair is manual early and automatic later.
35. Superseded: explicit base identity and merge/split UI → buildings hold inventory, logically shared; splits and merges happen automatically.
36. Superseded: producers have no input inventory → (Nov 2026, by simulation) a one-chunk input buffer per input with fair sharing in shortages (see base-network-and-inventory.md). Still decided: a small output buffer; only the overflow spills to storage.
37. Per-tick netting; surplus goes to partial stack → filtered silo → any free slot; stacks; silo filters.
38. No same-tick chaining.
39. Long foundation corridors allowed but costly and exposed.
40. Reversed: ruins keep networks connected → ruins break connectivity; splits are instant.
41. Alerts on power loss or attack; no alert on disconnect; a full base split is a mystery to solve.
42. Superseded: a central base is needed → Command Center is optional and high-tier.

Bootstrap and construction (L2593–2760)

43. Recovery must come from a physical building → the Crashed Ship is the one indestructible building.
44. No avatar inventory → Engineering Crews carry materials and build; remote construction; automatic material requests later.
45. Even in-base construction is done by crews (not instant). More crews means faster building.
46. Ship starts with recon plus crew (plus a debated mining truck; see #72).

Story (L2810–3360)

47. Fighting is unavoidable in the first hour; story as a series of discoveries in comic or dialogue form; Colite named.
48. Three advisors map to play styles. Ecologist → Survivalist → Doctor; Industrialist → Director; military guy → General.
49. Narrative responds to gameplay and never drives it; advisors get rarer over time.
50. No food or water; survival means getting home.
51. Superseded: victory = build a spaceship → (#58) repair the crashed ship.
52. Dialogue ends at launch; nobody is shown boarding; play continues. The characters aren’t physically in the game; neither is the player.
53. A direct path to victory; most of the tree optional.

Names and lore (L3478–3880)

54. Underground Evolite discovered fairly early (Tier 2–3), long before the drill is affordable.
55. Names: Evolite, Colite, Ferrite, Cuprite, Silicate, Basalite, Storage Silo, Foundation, Scout Drone, Engineering Crew, Harvester, Refinery, Fabricator, Evolite Drill, Radar Station. Iron → steel beams, not iron plates.
56. Noise vs seismic signature. Rejected: light pollution. Day/night changes how creatures respond, not the radius.
57. Rejected: “Silent Running.” Shutdowns get plain names.
58. The ship was on a prospecting mission; the Director heads it. Victory = repair the original ship. No population; robots run everything. Repairs unlock real capabilities (ship restoration is a main tech branch, option A).

Costs (L4180–4500)

59. Construction is cheap and operation is where the cost is; build cost matches physical contents; Colite is never a building material.
60. Rebuild = 100%; demolish refunds 50%; ghosts are free; destruction is a chance to redesign.
61. Restoring ship electrical systems unlocks electricity, at about 30–60 min.
62. Colite machinery lingers only for reserves or quick outposts.
63. Automatic logistics only at a later tier (communications). Early trucks carry a few stacks.

Logistics detail (L4560–4800)

64. Nothing is thrown away; trucks keep undeliverable cargo and continue the route; cargo in transit belongs to nobody.
65. Machines with full output sleep and restart on their own.
66. Outpost/Truck Stop: no trucks, small buffer, one truck at a time, N:1 routes. Persistent truck slots. Per-slot loading.
67. Production overlay and status lights, available from the start.
68. Alerts only for external events; a balanced factory runs forever.
69. Depletion: agreed on Factorio-style very slow depletion (#99 later says patches don’t deplete).
70. The prototype covers the first one to two hours.

Opening (L4818–5700)

71. Spawn protection (about 150 tiles); a safe, round-trip-only scout (about 500 tiles).
72. Three starting units: Scout, Harvester, Engineering Crew.
73. Delay drills; a Harvester economy first; Depots make Harvesters; free vehicles with respawn delays; unlimited Depots.
74. Harvesters make a little noise; a swarm is still quieter than drills and is a valid quiet strategy.
75. Superseded: the first tier needs alien kills → Evolite is a global currency, found early, no killing required.
76. Drill doesn’t need a deposit; base = 1×; underground scanning reveals rich pockets later.
77. Calcified vs Live Evolite. Hives are Live Evolite; clear them with military plus Harvesters; harvesting doesn’t provoke them.
78. Depots and Barracks are tentacles. Harvesters unload only at home; Gather and Patrol & Collect (dropped Evolite only).
79. Dropped Evolite disappears after about 5 min (becoming hives is deferred).

Tiers (L5700–6800)

80. Depot, Silo, Foundation, Barracks are Tier 0; Barracks appears when aliens are spotted.
81. Tier 1 gate: bring an Evolite sample to the ship; a timed study reveals the Tier 1 tree.
82. Tier 0 buildings are revealed by resource discovery; each discovery has a story moment.
83. Prototype = Tiers 0 and 1, ending at the electrical repair.
84. Survival checklist triggered by the first basic resource found; aliens and Evolite are the surprises.
85. Tier 0 is built only from Basalite; ores must be refined. Refinery built from Basalite.
86. Primitive Refining is free when Tier 1 opens.
87. Tier 1 order: Refining → Logistics → Stationary Mining; mining is an expensive unlock, not a new tier.

Military (L6795–6990)

88. Robot security units. Sword Bot (T0, 1 slot, melee) → Gun Bot (T1, Evolite, 2 slots, guns).
89. Slot capacity per unit size for both Barracks and Depots.
90. Mixed groups are just a UI convenience. Rally points and leaders come later.

Balance (L7119–8318)

91. Focus on the Tier 0 economy first.
92. Harvester speed 2 → 1 tile/s; trucks 3 tiles/s.
93. Costs: Depot 150 → 100; Silo 100 → 67; Barracks 150 → 100; Foundation 2 → 1 → 10/tile; Stone wall 5 → 3/tile.
94. Every building includes its own foundation; walls never connect.
95. Track Depot payback; target about 5 buildings by 12 min (10+ for an experienced player).
96. Nearby small Basalite patches (15–20 tiles); a little starting stone is acceptable but not preferred.
97. Harvesters use a 2×2 footprint; others wait; linear rate per productive cell; the UI shows taken footprints.
98. Harvester deploy 90 s → 30 s; trucks can take longer.
99. Basic patches don’t deplete; they saturate.
100. Next step: move from the conversation into a structured design repo and a coding agent (this folder).

Fair sharing (Nov 2026 simulations, not in the transcript)

101. Superseded: a tally handout rule (earn a share each tick, pay first, one machine gets ahead, credit cap) → a clock per machine and input, earliest due tick first, at most one craft ahead of fair time, no banked credit (see base-network-and-inventory.md). The tally failed 52 of 300 random factories.
102. Recipes with several inputs: each input has its own buffer, clock and fair time; a machine held back by one input leaves its share of the others to the rest. Leaning: a machine waiting on an input that isn’t produced keeps one parked chunk of the others.

Platform (Nov 2026, not in the transcript)

103. The server owns the tick. Multiplayer clients send commands and receive state; they don’t run the simulation in lockstep, so they can’t desync. Single player runs the whole simulation on the phone.
104. The prototype uses the server-owned simulation at 20 ticks per second. Chosen over 10 for headroom; 20 is the top of the usual 10–20 range for strategy games and Minecraft’s rate. The fair-share allowance becomes 40 ticks (2 s).
105. TypeScript everywhere: a web client, a Node server, and one simulation package shared by both. Rejected: native Swift (Apple-only client and server, fewer game resources, weaker AI-assisted coding). Unity and Godot not chosen (see player-and-platform.md).
106. The client/host split exists from the first single-player build. The host runs in a Web Worker and is treated as a server: commands in, state updates out.
107. Tentative: placeholder art (colored shapes with letters) first; later, 3D models written as code and baked to sprites from a fixed camera.

Architecture (Nov 2026, not in the transcript)

From a later conversation, saved as transcripts/architecture-conversation.md.

108. No pending state in the interface. The player’s own action shows at once; the world’s reaction arrives with the next update; a rare rejection is undone with a reason (see runtime-and-sync.md). Rejected: dimmed actions with a spinner until the server confirms.
109. Commands go to buildings and carry sequence numbers; the host checks every command again with the same check functions the client uses. Missing materials never block placing a ghost.
110. Tentative: the prototype sends the whole state every tick as JSON, with no diffing, smoothing or binary encoding. Plans and rates (Linear, Timed, Path), diffs, fog filtering and binary come later behind the same boundary. No server framework.
111. Tentative: the sim uses ECS with Bevy’s conventions: one schedule file, a command buffer applied at the end of each phase, one writer per field, intents plus an arbiter, events read on the next tick, declared reads and writes checked in development builds (see simulation-architecture.md). Tentative until the first Harvester spike.
112. TypeScript stays for the prototype (#105). Considered: Rust with Bevy’s ECS for the sim, kept as the planned path Open. The deciding concerns were setup friction and learning two things at once; performance was a tie at Tier 1 (see tech-research.md).
113. The sim uses its own small ECS core, modeled on Bevy’s (deferred commands, message queues, resources, a phase schedule, access checks). Considered: Miniplex (unmaintained since 2023, storage and queries only), Koota (strongest alternative), bitECS 0.4, Becsy (see tech-research.md).

First test (Nov 2026, not in the transcript)

From the same conversation. Details in first-test.md.

114. The first test goes up to the first Depot: the Crashed Ship, the Scout and fog, one Harvester, a Basalite patch and the crew building the Depot. The crew idles before it (#8) and Basalite leaves the network when the crew loads (#42), both easy to change.
115. The code lives in prototype/ next to design/, built with Vite, Vitest and strict TypeScript.
116. Superseded: panels are plain DOM, built once and updated in place → (#141) panels are React, with the client’s state in a Zustand store.
117. Tentative: PixiJS v8 renders the world, with Three.js still open as the alternative (live 3D instead of baked sprites). Not chosen: Phaser, a whole game framework whose loop, scenes and physics the game wouldn’t use.
118. Seconds become ticks by rounding to the nearest tick, once per total, with a development-build warning when rounding moves a value by more than 1%.
119. Entity ids increase and are never reused; the random generator is a small well-known one; pathfinding is A in four directions; the host has pause, step and fast-forward from the first build; the first test has no saving.*
120. Tentative: no map chunks in the first test. Each map layer is one flat array behind tileAt(x, y). Terrain is sent once; each tick sends entities and newly explored tiles, and the client works out current vision itself.
121. The Python sims are ported to TypeScript tests by hand; the test suite runs no Python.
122. The ECS core’s API is designed on its own, carefully, from Bevy’s, before the sim is written. Done; see below.

ECS core API (Nov 2026, not in the transcript)

Worked out with the designer step by step, against bevy_ecs 0.20.1. Details in ecs-core.md.

123. A system declares its parameters as an object of specs ({ movers: Query([Mut(Position), Mover], Without(Asleep)), tick: Res(Tick) }), which is both the scheduler’s access declaration and the source of the argument types. Rejected: positional specs (each name apart from its type) and separate reads/writes lists (two sources of truth).
124. Read-only access is checked by the compiler with a deep Readonly type and a lint ban on as and any. Rejected: development-build proxies (slow tests) and a shallow Readonly.
125. Looking up one entity returns the item or undefined. Rejected: a Result object, and throwing plus a separate tryGet.
126. Whole numbers are checked at run time in development builds, after each phase. Rejected: a branded Int type (a wrapper on every literal and every arithmetic result).
127. No per-system private state (Local<T>) and no exclusive systems. All state lives in the world; setup is a plain function before the first tick; player commands are applied by ordinary systems.
128. Commands declares the components it adds and removes, and the access check counts them as writes. Spawning and despawning are exempt. Rejected: undeclared like Bevy, and a run-time-only check at the sync point.
129. Several systems in one phase may write the same message type, ordered by the systems’ place in the phase list. Rejected: one writer per message type per phase.
130. The access check is filter-aware like Bevy’s, is in the first test, and runs in every build. Rejected: a component-level check, and adding the check later.
131. The Cleanup phase is dropped; the core clears old messages at the start of each tick.
132. Observers and hooks are excluded on principle, because running code immediately breaks phase order and next-tick reactions.

Naming conventions (Nov 2026, not in the transcript)

Proposed while reviewing the Harvester spike’s names, and accepted by the designer. The table is in simulation-architecture.md.

133. Kind markers take the thing’s plain name (Harvester, Depot), and queries filter by kind with With(Harvester). Rejected: an Is… prefix (reads badly in queries), and telling kinds apart by the components that come with them (a new kind matches silently).
134. A unit’s decision state is …Brain, and the system that writes it is update…Brains. Rejected: …State (clashes with the type of its values), one marker per state (each change of state becomes a command), and keeping harvesterBrain as an exception to the verb-phrase rule.
135. Counters toward something are …Progress: HarvesterWork became HarvesterProgress. Rejected: …Timers (it read oddly), and folding the counters into the brain (two systems would write it).
136. Command systems are apply…Commands; resources are plain nouns; messages are past participles for things that happened and …Result for replies. When a state and an event share a name, the event keeps the past participle and the state gets an adjective. Rejected: an …Event suffix on messages.

Packages (Nov 2026, not in the transcript)

137. A hard wall between client and server: three packages, shared, sim and client. Shared holds pure functions and data shapes (checks, fog math, recipes, the protocol); the sim depends on it; the client depends on it and never on the sim. Single player runs the sim in a worker built as its own bundle, which a multiplayer client never loads. This replaces “one simulation package shared by both” (#105) and the shared checks living in the sim package (see simulation-architecture.md). Rejected: the client importing from the sim, and one sim package with separate shared and host entry points.
138. The design site moves from VitePress to Astro with Starlight. Run reports are pages next to the docs, built from data, and Astro lets those pages use plain TypeScript rather than Vue components. The docs stay plain markdown in design/. Rejected: staying on VitePress (fine for docs, but interactive pages must be Vue), and a separate reports site.
139. Superseded (#146): the first Scout reaches 150 tiles, not 250 (300 tiles of flight). 250 tiles let the first hour see everything near home; at 150 it stops at the edge of spawn protection, and hives at 160–220 tiles are out of its reach (see tier0-proposals.md). Rejected: 120 with the whole start area scaled down, and moving the hives in to stay findable.
140. Every run writes a report the design site renders, and snapshots every 5 minutes; the debug channel waits (see first-test.md). Rejected for now: a debug channel systems write to, until a bug needs it.

Client panels (Nov 2026, not in the transcript)

141. Panels are React components, and the client’s state lives in a Zustand store (see first-test.md). The prototype already has the case #116 waited for: a panel for each building type, route and mission editors, network totals, research, dialogue and alerts, all showing the player’s own commands before the host confirms them. Panels drawn from state keep up with that without hand-written update code, and React is what Claude writes most reliably. The worker writes each state into the store; a panel re-renders only when the values it reads change; Pixi reads the same store and stays outside React. Rejected: plain DOM (an update path to hand-write and keep in step for every panel), Preact (smaller and has signals, but a tiny share of new projects, so Claude keeps writing React habits into it), Astro for the client (it builds pages ahead of time and adds nothing to one long-lived page), and React’s own context for game state (every reader re-renders on every tick).

Hosting (Nov 2026, not in the transcript)

142. The game and the design site are each hosted on a Cloudflare Worker, linked to each other; the multiplayer host runs on the designer’s Mac Mini; and this is a trusted-testers phase, so both are public (see player-and-platform.md). Cloudflare now builds new hosting features into Workers rather than Pages, so Pages is a dead end. A Worker runs only per request, and a Durable Object running a 20-tick loop is unproven and billed by the time it runs; a Mac Mini that’s already on costs nothing, and the world pauses when the last player leaves. Nothing in the game or the docs needs hiding, so neither has a sign-in. This answers open question #43 and replaces “single-player builds are served from Cloudflare Pages”. Rejected: Cloudflare Pages, a Durable Object as the multiplayer host, and a rented always-on server for now.

Protocol and host (Nov 2026, not in the transcript)

143. The host is its own package, and one message covers every tick the host ran since the last (see first-test.md). The host owns the world, the command queue and the clock, and knows nothing about threads or sockets; the worker and a later WebSocket server only wire it up. At 16× the host would otherwise send 320 whole states a second. It runs at most 100 ticks a call and drops the rest, so falling behind slows the game rather than freezing it. Rejected: a message per tick (most of them stale before the client draws them), and skipping the results and events of ticks between messages (commands would go unanswered).
144. The plain client is built, and panels may read small objects compared as JSON (see first-test.md). Reading every field of a building as its own plain value made each panel a list of selectors; comparing the building as JSON re-renders only when something in it changes, which is what #141 asked for. The terrain stays out of the copied state: it’s marked in place and the renderer paints only new tiles. Rejected: one selector per field (verbose for every panel), and re-rendering the selected panel on every tick (cheap now, but the habit spreads to lists).

The first playtest (Nov 2026, not in the transcript)

145. The ship sees 20 tiles, not 12 (see tier0-proposals.md). The first find no longer depends on a lucky trip: in the playtest it took 2–3 minutes, because a 2 × 2 patch is easy to fly past. At 20 the ship sees at least one near patch on every map. Rejected: keeping 12 and moving the patches closer (crowds the start).
146. The first Scout reaches 75 tiles and flies about 6.7 tiles/s; more reach is an early upgrade (see tier0-proposals.md). A long reach makes “always send it to the edge” the obvious play, which teaches the wrong habit. At 75, covering the whole circle takes about 8 minutes. 10 tiles/s felt too fast. Rejected: keeping the 150-tile reach and only slowing the Scout.
147. Scout orders queue (see first-test.md). An order given while the Scout is away runs after the ones before it, up to 5, instead of replacing the last. A way to queue on purpose, and the same for other missions, comes later.
148. The game saves to localStorage from the first test on (see first-test.md). A reload or a closed tab wiped a playtest. The host sends a save every 5 seconds of game time; the page keeps it and loads it at start.
149. The playable client tells more than the sim’s math, so don’t over-tune with simulations before playing. Three minutes of play showed what the hand-run sims and runs couldn’t: how far the ship sees, how fast the Scout feels, and the habit a long reach teaches. Runs stay for checking the sim and for questions only time answers (the crowded hour), not for feel.
150. Flying the Scout directly is the leading next change (open question #50): a battery that drains per tick, not per tile, and an automatic return home once it has just enough to get back. Harvesters keep missions with no fuel.
151. Tapping any unit selects it and opens its building’s panel, with the unit’s slot highlighted; the camera stays put (see player-and-platform.md). It holds for every unit in the game, since missions go to buildings anyway.
152. Small Basalite patches are 7–12 cells around a full 3 × 2 core, not rectangles (see tier0-proposals.md). On screen the opening’s 2 × 2 patch was too small and a block of footprints didn’t read as a deposit. Cells are added near the core, favoring spots that touch more of the patch, so a patch is never stringy (no 12 × 1). The core keeps one full footprint, so the opening’s timings hold.
153. Each unit slot has its own dock, in a row below its building; a shared dock queues (see first-test.md). A Depot’s three docks run along one side, and a parked unit is seen in its dock. A dock that units from elsewhere use, such as an Outpost’s unload dock, holds one at a time and the rest queue. Rejected: every unit on one dock tile (they stacked out of sight), and exempting docks from the rule below.
154. Ground units never share a tile; one blocked waits, then finds a way around (see first-test.md). One blocked by a unit heading for the same tile waits in line instead. It cost the opening 2 s (the first Depot at 3:57). Rejected: only stopped units blocking (units still overlap in passing), and waiting with no rerouting (a parked unit would block a lane for good).
155. Units look busy while they work, on screen only (see first-test.md). A collecting Harvester walks its footprint and a crew walks round its ghost; a waiting Harvester stands off the patch.
156. Colite and Ferrite join Basalite on the maps before anything uses them (see first-test.md). The opening had nothing past the ship’s sight, so the Scout found nothing; it now has two more Basalite patches, a Colite and a Ferrite patch inside the Scout’s reach. Generated maps take Colite and Ferrite from tier0-proposals.md. Cuprite waits for the refinery that would use it.
157. Foundation comes next, so a Depot apart from the ship can share its stock (see first-test.md). Without it a Depot had to touch the ship to be on its network. Foundation is laid by dragging a line or a block. Rejected: tapping tile by tile (a corridor is many taps), and only laying it automatically with a new building (no free-form corridors).
158. A crew builds foundation in batches of up to 10 tiles (100 Basalite) and goes home after each batch. One tile per trip would make corridors painfully slow. The designer would rather, later, give the crew an inventory it fills for each trip from what that trip will build, so the rule is the same for every job, not one for foundation (open question #51).
159. Auto-foundation waits until a playtest shows it’s wanted (#11 stays open).
160. A full Depot or ship moves its oldest stack to the rest of its network to take a delivery, as base-network-and-inventory.md already decided; it came with foundation, since networks now reach past touching buildings.
161. Foundation builds in 1 s a tile, three times faster than 0.3 s per material gives (see first-test.md). Laying a corridor at 3 s a tile was too slow.
162. The game speaks a player’s words, not the design’s (see first-test.md). No “footprint”, “ghost” or “target” on screen; a Harvester is “Driving to Basalite”. What a unit carries shows as storage slots, the same as a building’s, rather than as a sentence.
163. Picking a unit’s row in its building’s panel selects it, moves the camera to it and readies its default mission (see player-and-platform.md). Every row shows what its unit carries, all the time. Default missions are mostly about where to go: a Harvester’s is where to mine, the Scout’s where to fly; the crew has none. Tapping a unit on the map still leaves the camera where it is.
164. Any planned building can be put at the top of the build queue (see first-test.md). The most recently put there is built first, then the rest oldest first. One at the top that can’t be paid for yet holds that resource back from everything lower down, so prioritizing a Depot means the Basalite waits for it. Rejected: skipping an unaffordable top ghost like any other (the button would do nothing when it matters most, early, when Basalite is short).
165. The game runs twice as fast: every speed and rate doubled, every time halved (see first-test.md). In the second playtest 1× felt far, far too slow and 2× felt good. The clock still shows real time, so the first Depot comes at about 2:00. Rejected: making 1× run the clock twice as fast with the numbers unchanged (game minutes would stop being play minutes, and 16× would need 640 ticks a second). Whether the pacing targets in minutes halve too is open (#52).
166. Gather names a patch; the Harvester takes a free tile of it when near (see first-test.md). Crowding slows a patch through traffic, not turn-taking, and a tile gives what a full footprint did. Rejected: the 2 × 2 footprint (the player had to aim it), and every Harvester mining the tapped tile (they queued for one tile while the rest of the patch sat idle).
167. Units live inside their building, going in and out through an entrance along one whole side (see first-test.md). Entering is instant once a unit touches the entrance, with no pathfinding or contention inside, so unloading never queues. A unit going out waits inside while the entrance is full. The entrance is drawn as arrows to keep clear: bases are road networks, and the entrances are where the roads meet the buildings. Rejected: a dock per slot outside the building (a row of Depots turned its docks into a road that queues blocked), and a one-tile doorway (every unit funnels through one tile).
168. A Harvester that can’t unload into a full home says so, with the amber light (see first-test.md).
169. Placing a building previews whether it will connect, and auto-foundation is wanted after all (see base-network-and-inventory.md). In playtests it was too easy to put a building just off the network, so it ended up with its own stock; this is the evidence #159 waited for. The preview marks the network the building will join, draws the shortest foundation path to it with the cost, and places that path with the building unless the player opts out. Rejected: a “disconnected” badge on buildings apart from a network (separate bases are valid, so it would mark every outpost forever, and it tells you after the mistake instead of while making it), and only warning without laying the path.
170. Nearly everything on screen has a hover tooltip (see player-and-platform.md): every button, item in the build list, storage slot, status light and unit row says what it is or what it does. Touch has no hover, so phones need another way to reach the same words (open: long-press, or the selection panel).
171. Engineering Crews fly over buildings, walls and units, like the Scout (see first-test.md). Laying out roads for a building a crew visits once wasn’t a fun challenge, and the tile kept clear for a planned Silo’s crew stopped it going on top of another building. The road puzzle stays for Harvesters and Sword Bots, which work outside the base. Rejected: crews building from any free side of a planned building (roads still matter, and a boxed-in plan strands its crew), and crews walking over buildings but not walls or units (a third way of moving for little visible difference).
172. Two units meeting head-on: only the higher id steps aside, and steps to one side when it can’t go round (see first-test.md). Both used to look for a way around on the same tick, pick the same side, meet again and step back, over and over. The rule keeps the sim deterministic. Rejected: a random wait before looking (the sim has to give the same result for the same commands, for saves, tests and later multiplayer).
173. Tooltips are the game’s own, not the browser’s (see first-test.md). A browser’s title tooltip didn’t show in the embedded browser used for playtests, and can’t be styled.
174. A tile is 4 m × 4 m, and the game shows distances in meters, never tiles (see world.md). At the 1 m the docs assumed, a Harvester was a 1 m square and a Depot that houses three vehicles 3 m across. At 4 m a Harvester is about a pickup, a 1 × 2 truck a box truck, a Depot a 12 m three-bay garage, the ship 24 × 16 m, the Scout’s reach 300 m and a generated map 2.5 km across. Nothing in the sim changes: it counts in tiles. Distances the docs wrote in meters, like the 20 m alien detour (#33) and the hive 50 m away, were tile counts, so they’re now 20 tiles (80 m) and 50 tiles (200 m). Rejected: 3 m (a Depot is too tight for three vehicles) and 5 m (a Harvester is as big as a large truck, leaving trucks no room to be large).
175. Each base has a stable name, and storage shows per base (see base-network-and-inventory.md). The Crashed Ship’s base is “Crashed Ship” (base 1); others are “Base 2”, “Base 3”, numbered one higher than the last ever given, gaps and all. A merge keeps the lower number; a split leaves it with the piece with the most buildings. A building’s panel shows its base’s totals by resource, and the top bar’s total of every building is gone: stock on separate networks can’t be spent together, so the sum misled. Rejected: renumbering bases to close gaps (a base’s name would change under the player).
176. Buildings can be turned so their entrance faces any side (see first-test.md). A base that could only open downward was hard to lay out and easy to box in (#49). Every building with an entrance is square, so turning moves only the entrance. The next building starts turned as the last one was.
177. Every deposit starts unknown; the Scout scans it on site before Harvesters can mine it (see units-and-missions.md). Scanning gives each discovery a moment of its own for its story beat, which explains what the resource is good for. Scan time depends on the resource, about 15 s for easy ones. The rest is open question #53.
178. A Gate: a 2 × 1 piece of wall that opens only for friendly units, and stays shut while enemies are near (see combat-and-defense.md). Opening it could let the aliens in. A fighter on its way out opens it anyway, so the fight starts at the gate; Harvesters and trucks wait. The rest is open question #54.
179. A building’s entrance is one tile, in the middle of the side it faces, marked by one arrow; the ship’s is a ramp on its short side (see first-test.md). It replaces #167’s whole side. A row of arrows looked like a wall, and a little traffic at the door is fine. Stone walls are drawn as lines, not blocks.