ROADMAP.md

Roadmap

Status legend: done = playable and tested, partial = real but
incomplete, next = current development target, future = not started.
A system is never "done" because a schema exists — it must have at least one
real playable vertical implementation.

Phase 0 — Vertical slice ✅ done

Proved every major system cooperates end-to-end (verified by
apps/server/scripts/sliceTest.ts on every change): authoritative server,
Babylon client (WebGPU/WebGL), Source-style predicted movement, interest-
managed replication, physics props with sleep-aware snapshotting, gathering,
inventory, data-driven crafting, physgun building, persistence across
restart, zone rules, logs//metrics//healthz.

Phase 0.5 — City, skills, tools, protection ✅ done

Scrap City safe city (map-authored, zone-enforced), tool capability system,
gathering professions with respawning typed nodes, 6 skills with XP/levels/
recipe gates, building content, prop protection with persistent trust,
weld constraint foundation (engine + persistence — no player-facing tool).

Phase 0.75 — Survival & sandbox life ✅ done (was undocumented)

Shipped after 0.5, ahead of the old roadmap: hunger/thirst/stamina/health
vitals with eating/drinking, food items + burn-barrel cooking, fall damage,
death/respawn; melee PvP with weapon capability, knockback, zone gating;
container props (storage box) with trusted access; hinged doors; planter
farming prototype (berry seeds, timestamp growth); merchant trades (bottle
caps); supply-drop crates (hardcoded event v1); day/night clock; guest
identity + openvibe.network SSO ranks; map editor as a mature authoring subsystem
with live world reconciliation.

Phase 1 — Sandbox depth ✅ done (Stage 2)

• Player-facing constraint toolset on a clean ConstraintDefinition/Record/
  Service architecture: weld, rope, hinge, slider, spring, axis, motor
• Constraint visuals (endpoints, ropes), two-click tool UX, unweld/cut
• Constraint islands: settled structures sleep as units; island metrics
• Placement ghost preview + optional surface/grid snapping (free placement
  stays; modifier for precise unrestricted placement)
• Physgun precision polish (snap angles, translation snap)
• Prop health/damage/repair capability (melee + impact; zone-gated
  destruction; repair materials; destroy loot)
• Hostile-input tests for every new message

Phase 2 — Item, container & survival depth ✅ done (Stage 3)

• Container domain module shared by boxes/machines/vehicles/merchants;
  quick transfer, split, sort; container-to-container
• Equipment slots + stack metadata (durability, instances) where gameplay
  needs it — no speculative fields
• Temperature (environment/wetness/shelter/clothing/heat sources) with
  understandable rules; generic timed status-effect framework
• Server-authoritative environment state: time of day, weather
  (clear/cloudy/rain/storm/fog), temperature — client renders, gameplay
  consumes

Phase 3 — Farming, utilities & production ✅ done (Stage 4)

• Data-driven crop definitions (several materially different crops:
  stages, water/fertility needs, temperature ranges, regrow) — timestamp
  progression, never per-tick
• Irrigation/fertilizer/farm props via logical utility connections
• Generic utility networks: power (producer/consumer/storage), fuel
  (items), water (tanks/pipes/pumps) — cheap when sleeping
• Machine production chains: inputs → machine + time (+power/fuel/water/
  skill) → outputs; crop processing feeds the same crafting economy

Phase 4 — Combat foundation ✅ done (Stage 5; hitscan pistol, armor, medical)

• Generic damage pipeline (source/target/type/amount/position/impulse);
  blunt/cutting/projectile/explosive/environment/fall types; zone gating
• Server-authoritative ranged weapons (fire intent → validate equipped/
  ammo/cadence/direction → server raycast); small test weapon set
• Armor/clothing damage reduction; bandage/medical consumables

Phase 5 — Spatial world foundation ✅ done (Stage 6)

• Uniform spatial hash replacing the linear interest scan and prop
  proximity scans (workstations, shops); one index, many consumers
• Region/cell activation concept (players, active NPCs, awake physics per
  region) — the seam for simulation LOD and later streaming

Phase 6 — NPCs ✅ done (Stage 7; straight-line nav v1)

• Server-authoritative NPC domain: composition capabilities (npc, health,
  inventory, faction, perception, combat, merchant, job) — no subclass
  towers
• Archetypes: civilian, city guard, merchant, bandit/scavenger, wildlife
  (content-defined loadout/behavior/loot/importance)
• NavigationService boundary (request path/waypoints/repath/invalidation)
• Modular perception: vision (distance/FOV/LOS), hearing (bounded sound
  events from gameplay), threat
• Behavior state modules (idle/wander/patrol/investigate/trade/guard/
  chase/attack/retreat/return) — deterministic/testable
• Simulation LOD tiers: full / simplified / abstract (no engine objects
  far from players); persistence of abstract state

Phase 7 — Factions, reputation, economy ✅ done (Stage 8)

• Data-driven factions + relations; persistent player reputation with
  thresholds (stock, prices, jobs, access)
• Markets generalizing the fixed trade sheet (stock, restock, pricing,
  reputation requirements) behind a transactional economy API
• Production chains as player businesses, legal and underground, on the
  same machinery; player specialization emerges from skills/machines/
  geography — never class locks

Phase 8 — World events & extraction ✅ done (Stage 9)

• Generic server-owned event engine (scheduled/announced/active/
  completed/cleanup); supply drops migrated onto it as proof
• Extraction events: countdown, capacity, in-zone validation, contest
  rules; explicit at-risk vs secured loot semantics owned by the server
• High-risk regions via zone/event rules (better loot, hostile NPCs,
  hazards)

Phase 9 — Progression & jobs ✅ done (Stage 10)

• Skills unlock capabilities (constraint tools, machines, crops,
  components), not just recipes
• Blueprint/discovery: persistent unlock state fed by skill, merchants,
  jobs, found blueprints, dangerous regions, extraction, reputation
• Job/contract foundation (deliver/gather/transport/kill/repair/escort)
  with data-driven objectives and rewards

Phase 10 — Vehicles ✅ done (Stage 11; scrap cart prototype)

• Modular vehicle prototype from the SAME item + physics + constraint
  architecture: chassis/wheels/suspension/engine/seat/storage/lights
• Assembly recognition + activation; server-authoritative driving; fuel;
  cargo containers; damage/repair; persistence + replication

Phase 11 — Scale 🔜 next (Stage 12)

ADR-0007 M4 now covers several rooms of one place in one process, PostgreSQL
leases, in-process transfer, cell interest and a socketless load probe. This
phase still covers streaming, multi-host routing and larger load profiles.

• Region persistence/streaming when the authored world justifies it
• Network measurement first (bytes/client, snapshot sizes, entity counts);
  binary snapshot codec only when measurements demand it
• Synthetic load tests: hundreds of sessions/props/constraints/NPCs —
  hunting algorithmic scaling problems, not benchmark vanity

Phase 12 — Content & hardening (Stage 13)

• Interconnected content web (forest→sawmill→lumber; mine→forge→
  components; farm→processing→trade), geography with economic meaning
• Cross-system acceptance scenario (farm → process → haul → job → combat
  → extraction → sell → blueprint → restart-verified persistence)
• Hostile-client test sweep across every network action

Platform integration (network roadmap Wave 12) — partial

• done: canonical Network subjects as account keys; games service
  principal; durable events via outbox; Media copies of map-editor assets;
  mod manifest validation, registry (install / grant / enable / disable /
  revoke, audit) and the capability-checked runtime seam for declarative
  games-content@1 packs
• waiting on the platform: mod principals and grants in OpenVibe.Network;
  sandboxed executable mods (OpenVibe.Host Stage C); games.progress.summary
  user-module writes are granted but not implemented

Standing engineering rules

• The slice test must stay green; new systems extend it
• Content changes never require engine changes
• No system may read another's internals — protocol/events/repositories only
• The map editor is load-bearing infrastructure: run pnpm audit:editor
  and pnpm test:editor when map/content schemas change
• Plants, machines and networks progress by timestamp/state transition,
  never per-tick simulation
• Every new network action ships with hostile-input tests