AgrarianGameArchive/AGRARIAN_DEVELOPMENT_ROADMAP.md

Agrarian Development Roadmap

This roadmap converts the Agrarian master vision into a practical, trackable development plan. It is intentionally broad and granular so the project can grow from a small playable Unreal prototype into a long-term persistent civilization platform without losing the original direction.

Project North Star

Agrarian is a persistent generational civilization simulator where players rebuild humanity through survival, stewardship, family, labor, trade, governance, and technological progress.

The guiding question is:

What survives after you are gone?

Core commitments:

• Civilization is built, not spawned.
• Legacy matters more than levels.
• History is never erased.
• The frontier always exists somewhere.
• Knowledge is the true progression system.
• AGR has both in-game and real-world community value.
• No pay-to-win mechanics.
• No seasonal wipes.
• No loot boxes.
• No fragmented DLC model.
• Build the smallest strong survival foundation first.
• Keep every system compatible with long-term persistence and generations.
• Build toward an Earth-scale world made from real-world terrain tiles.
• Keep travel paced by believable real-world movement, vehicles, terrain, and character condition.
• Treat terrain, bathymetry, biomes, resources, rivers, and mountains as data-driven long-term infrastructure, not one-off maps.
• Keep base world time grounded; the world should progress without feeling artificially sped up.
• Make player skill, tools, infrastructure, cooperation, and knowledge improve efficiency, yield, reliability, quality, and capacity rather than breaking natural biological time.

Time And Progression Philosophy

Baseline rule:

• Use 4 real hours = 1 in-game day as the default server-authoritative world clock unless testing proves it is too slow.

Design intent:

• The world does not get faster; the player gets better.
• Human-scale actions such as walking, gathering, chopping, fishing, hunting, hauling, crafting interaction time, and combat stay close to believable real-time pacing.
• Biological and seasonal systems such as crop growth, livestock maturity, pregnancy, spoilage, disease, healing, soil recovery, tree growth, and seasons use the Agrarian calendar.
• Skills should mostly improve efficiency, yield, quality, reliability, survival odds, and working capacity.
• Skills should rarely shorten natural biological time directly.
• Domesticated crops and livestock can require meaningful calendar time because hunting, gathering, fishing, scavenging, and primitive crafting remain available.
• Early survival should feel hands-on, difficult, inefficient, and somewhat fragile.
• Starting over should hurt because players lose knowledge, tools, stored food, seeds, livestock, shelter, infrastructure, claims, and local advantage.
• Progression should move players from hand-gathered survival to tools, storage, domestication, farms, logistics, labor systems, trade, and industrial-scale production.

Current Known Project Location

Primary development repository:

git@github.com:pacificao/AgrarianGameBuild.git

Primary local Codex/server checkout:

/mnt/projects/AgrarianGameBulid

Ubuntu-Codex host:

192.168.5.10

Unraid project share:

\\DevBox\projects\AgrarianGameBulid

Windows build VM:

Windows-Builder / 192.168.5.12

Codex headless editor build command:

UNRAID_PASSWORD=<set in environment> /home/nathan/bin/agrarian-build-editor

Important tracked project root files/folders:

• AgrarianGame.uproject
• Source/
• Content/
• Config/
• Scripts/
• .gitignore
• .gitattributes
• Roadmap and vision docs

Important generated/local-only files/folders:

• Binaries/ ignored
• Intermediate/ ignored
• Saved/ ignored
• DerivedDataCache/ ignored
• .vs/ ignored
• *.sln ignored and regenerated locally

Roadmap Status Legend

Use these markers as the project progresses:

• [ ] Not started
• [~] In progress
• [x] Complete
• [!] Blocked or needs decision
• [?] Needs design decision

---

Milestone Flow And Current Focus

Roadmap order is now:

1. Current milestone status and decision log.
2. Phase 0 foundation and guardrails.
3. Phase 1 foundational survival MVP.
4. Later gameplay, civilization, technical, release, and community tracks.
5. Calendar, MVP definition of done, and earliest next actions.

Phase subsection numbers such as 0.1, 0.2, and 0.7 are workstream sections, not release versions. Release versions are tracked separately as milestones such as 0.01, 0.1, 0.6, and 1.0.

Active Milestone - Version 0.01 Foundation Baseline

Status: in progress.

Purpose: establish the project in GitHub, prove Windows builds from a clean checkout, and create the first C++ gameplay foundation for survival, inventory, crafting, building, persistence, admin testing, wildlife, and early terrain pipeline planning.

Major version 0.01 work already completed:

• Created GitHub repository pacificao/AgrarianGameBuild.
• Imported the Unreal project into Git with Git LFS.
• Added Unreal-safe .gitignore and .gitattributes.
• Added Windows build and cleanup helper scripts.
• Removed stale VisualStudioTools plugin reference.
• Confirmed Windows build succeeds through Scripts/BuildEditor-Windows.bat.
• Added replicated survival, inventory, interaction, crafting, building, persistence, admin/dev command, wildlife, time, and weather foundations.
• Added item definition and recipe data asset classes.
• Created first gameplay item and recipe assets.
• Created first resource, campfire, primitive shelter, wildlife, foliage, stone, and freshwater Blueprints.
• Built AgrarianGameEditor Win64 Development successfully on Windows-Builder.
• Added Codex headless Windows build and Unreal Python automation lanes.
• Confirmed the project loads through Unreal Editor command mode and the default test map passes map check.
• Added IA_Interact, bound it to keyboard/gamepad, and assigned it to the character Blueprint.
• Added smoke/automation coverage for gathering, crafting, placement, persistence, wildlife harvest, foliage, resources, and freshwater placement.
• Selected Ground Zero MVP terrain tile and added the first tile registry schema.
• Prototyped and imported real elevation data for the Ground Zero tile.
• Verified the Ground Zero terrain test map is centered and spans 1 km x 1 km in Unreal.
• Set the packaged investor demo default map to Ground Zero.
• Added Agrarian Studio splash, startup movie, demo notice, motto, version, and copyright language.
• Built and smoke-tested a Windows Development packaged demo.

Remaining version 0.01 cleanup before moving deeper into new gameplay:

• Decide whether to keep current Unreal template variants or remove unused starter variants.
• [!] Create protected main branch. Blocked while the repo remains private on the current GitHub plan; GitHub API reports this requires GitHub Pro or making the repository public.
• Decide whether to create/use a long-lived dev branch. Decision: do not use one yet; use main plus short-lived task branches until team size or release channels require a staging branch.
• Finish branch naming conventions.
• Finish commit message conventions.
• Define GitHub/LFS free-tier storage guardrails.
• Define backup expectations for NAS and repository.
• Implement Linastorage incremental project backup job.
• Implement quiesced VM backup job for Windows-Builder and Ubuntu-Codex.
• Create repeatable dedicated server build instructions.
• [~] Finish required plugin documentation.
• Confirm the project opens cleanly from a fresh checkout, not just the current working share.
• Organize Content/Agrarian/ folders and move starter/prototype assets into clearly named locations.
• Launch near-term MVP map-tile serving cloud VM.
• Define MVP day/night length, survival pressure target, success loop, failure conditions, and closed-test readiness criteria.

Phase 0 - Project Foundation And Guardrails

Goal: Prepare the project so all future development is controlled, recoverable, documented, and aligned with the long-term vision.

0.1 Repository And Source Control

• Decide where the Unreal project repository will live.
• Create or confirm GitHub repository for the Unreal project.
• Decide whether large assets use Git LFS.
• Add Git LFS for .uasset, .umap, large media, and binary assets if using Git.
• Create .gitignore for Unreal Engine.
• Ensure Binaries/, Intermediate/, Saved/, and DerivedDataCache/ are excluded unless intentionally needed.
• Commit clean baseline project.
• [!] Create protected main branch. Blocked while the repo remains private on the current GitHub plan; GitHub API reports this requires GitHub Pro or making the repository public.
• Create dev branch if we want staging before main. Decision: do not create a long-lived dev branch yet.
• Define branch naming conventions.
• Define commit message conventions.
• Define GitHub/LFS free-tier storage guardrails.
• Define backup expectations for NAS and repo.
• Confirm this roadmap file is committed or otherwise backed up.

0.2 Engine And Tooling Decisions

• Confirm Unreal Engine version.
• Decide Blueprint-first, C++-first, or hybrid approach.
• [?] Decide whether Gameplay Ability System is needed now or later.
• Decide networking model for MVP.
• Decide dedicated server target platform.
• Decide local development platforms.
• Decide build machine strategy.
• Create repeatable local build instructions.
• Create repeatable packaged build instructions.
• Create repeatable dedicated server build instructions.
• [~] Document required plugins.
• Disable unneeded plugins.
• Confirm project compiles from a clean checkout.
• Confirm project opens from a clean checkout.

Current tooling decisions:

• Unreal Engine version: 5.7.
• Development approach: hybrid C++ foundation with Blueprint/content assembly in the editor.
• Source control and daily coding: Ubuntu-Codex working against the Unraid projects share.
• Editor/build host: Windows-Builder VM with GPU passthrough.
• Headless build path for Codex: Unraid QEMU guest agent into Windows-Builder.
• Preferred interactive editor/gameplay connection: Parsec or similar real-GPU remote desktop, not RDP.
• Dedicated server target: Linux for multiplayer hosting.
• Windows compiler used by Unreal 5.7: VS 2022 Build Tools MSVC 14.44.35207.
• Packaged Windows demo wrapper: Scripts/PackageWindowsDevelopment.bat.
• Current investor demo starts on the Ground Zero terrain map: /Game/Agrarian/Maps/L_GroundZeroTerrain_Test.
• Rendering baseline: the project remains DX12-first for future Unreal 5 features, while packaged investor builds include a Windows compatibility override and launchers so demo machines can start reliably with DX11 if DX12 startup fails.
• Investor-demo release rule: whenever all tracked roadmap items for a version milestone are complete, including minor versions like .01 or .6 and major versions like 1, build and smoke-test a fresh Windows packaged executable for investor/demo review.

0.3 Design Documentation

• Create game design document.
• Create technical design document.
• Create multiplayer/networking design document.
• Create persistence design document.
• Create Earth-scale terrain/tile streaming design document.
• Create tile registry/database design document.
• Create real-world terrain source data evaluation document.
• Create economy and AGR design document.
• Create art direction document.
• Create UX/HUD direction document.
• Create content naming conventions.
• Create folder conventions for Unreal assets.
• Create coding standards.
• Create Blueprint standards if using Blueprints.
• [~] Create data asset standards.
• [~] Create save/persistence standards.

0.4 Project Structure

• Organize Content/Agrarian/ root folder.
• Create folders for Characters.
• Create folders for Environment.
• Create folders for Items.
• Create folders for UI.
• Create folders for Systems.
• Create folders for Maps.
• Create folders for Materials.
• Create folders for Audio.
• Create folders for DataAssets.
• Create folders for Prototypes.
• Create folders for Developer-only test assets.
• Create naming convention for assets.
• Move any starter content into clear prototype folders.

0.5 MVP Definition

• Define what qualifies as the 6-month MVP.
• Define what will not be included in MVP.
• Define target player count for MVP test.
• Select the real-world "Ground Zero" 1 km x 1 km MVP tile.
• Define target map size for MVP around the Ground Zero tile.
• Define MVP biome.
• Define acceptable real terrain accuracy for MVP.
• Define acceptable real bathymetry/ocean-depth handling for MVP if Ground Zero is coastal.
• Define acceptable first-pass biome/resource accuracy for MVP.
• Define MVP day/night length.
• Define survival pressure target.
• Define basic success loop.
• Define failure conditions.
• Define first playable internal milestone.
• Define closed test readiness criteria.

0.6 Operational Infrastructure

• Stand up Unraid DevBox as shared project storage.
• Create and expose the projects SMB share.
• Add LAN name resolution for DevBox.
• Mount \\DevBox\projects on Ubuntu-Codex at /mnt/projects.
• Clone pacificao/AgrarianGameBuild to /mnt/projects/AgrarianGameBulid.
• Configure GitHub SSH access on Ubuntu-Codex for clone, pull, and push.
• Set up Windows-Builder as the Unreal/Visual Studio build VM.
• Install Unreal Engine 5.7 on Windows-Builder.
• Install Visual Studio 2026 for interactive development tools.
• Install VS 2022 Build Tools for Unreal 5.7 compiler compatibility.
• Confirm Codex can launch Windows headless build commands without RDP.
• Confirm headless editor target build succeeds.
• Set up Parsec or equivalent real-GPU remote access for occasional Codex visual inspection.
• Stabilize Windows-Builder network/RDP behavior under GPU passthrough.
• Decide and document VM snapshot cadence before major engine/tool changes.
• Define Unraid share backup policy.
• Implement Linastorage incremental project backup job with deleted-file retention.
• Implement quiesced VM backup job for Windows-Builder and Ubuntu-Codex.
• Add recurring restore-test log for project and VM backups.
• Define GitHub branch protection and review rules.
• Add a build log retention policy.
• Add a simple operational runbook for rebooting/recovering Windows-Builder, Ubuntu-Codex, and DevBox.

0.7 Earth-Scale Terrain Architecture

Long-term goal: Agrarian can eventually expand toward an Earth-scale world made from real terrain and ocean data. The intended unit is a 1 km x 1 km tile. At full Earth scale this implies roughly 510-520 million possible tiles, added over many years, streamed from servers, cached locally, scrubbed when unused, and redownloaded when a player returns to a region.

• Define canonical tile coordinate system for 1 km x 1 km world tiles.
• Decide how latitude/longitude maps to Unreal coordinates and World Partition cells.
• Decide how to handle projection distortion, poles, and dateline crossing.
• Define authoritative tile manifest schema.
• Define tile status states: unknown, queued, source-data-found, generated, validated, packaged, published, deprecated.
• Define tile adjacency and stitching rules.
• Define tile versioning rules so terrain can improve without corrupting player state.
• Define server-side tile delivery protocol.
• Launch a near-term MVP tile-serving cloud server on Ubuntu or another Linux distro.
• Publish a tiny Ground Zero tile manifest and package from the tile server.
• Prove client/server tile lookup, download, local cache, and redownload flow with the Ground Zero tile and immediate-neighbor metadata.
• Add tile-serving server cost controls and shutdown/runbook notes so MVP testing stays free or near-free.
• Define client local tile cache layout.
• Define local cache retention policy for old or unused tiles.
• Define local cache redownload/revalidation behavior.
• Define minimum metadata per tile: coordinates, biome, elevation range, water coverage, source datasets, generation version, neighbors, and publish status.
• Evaluate real terrain/elevation data sources.
• Evaluate bathymetry/ocean-depth data sources.
• Evaluate river, lake, coastline, road, and land-cover data sources.
• Define automated terrain import pipeline for a single 1 km tile.
• Define automated biome and natural resource inference pipeline.
• Define QA checks for terrain seams, water edges, slope extremes, and missing source data.
• Build a small tile-tracking database prototype before scaling beyond MVP.
• Build an MVP tile registry table for the Ground Zero tile and immediate neighbors.
• Keep World Partition compatibility as a hard requirement for all terrain decisions.

Phase 1 - Foundational Survival MVP

Goal: Build a small playable multiplayer prototype that proves survival, weather, inventory, gathering, crafting, shelter, and basic persistence can work together.

Target deliverable: A small group can join a server, spawn into one biome, gather resources, survive weather, craft primitive tools, build simple shelter, manage hunger/thirst/injury, and return later to find basic world state preserved.

1.1 Core Player Foundation

• Create base player character class.
• Create player controller.
• Create camera setup.
• Decide first-person, third-person, or hybrid camera.
• Implement movement.
• Implement sprinting.
• Define real-world baseline walking speed.
• Define real-world baseline running speed.
• Connect movement speed to age, condition, strength, endurance, hunger, thirst, injury, carried weight, and terrain.
• Implement crouching if needed.
• Implement jumping if needed.
• Implement interaction trace.
• Implement interact prompt.
• Implement basic animation blueprint.
• Implement placeholder character mesh.
• [~] Add replication for player movement and core state.
• [~] Add developer debug overlay for player status.

1.2 Character Stats

• Create stat component.
• Add health.
• Add stamina.
• Add hunger.
• Add thirst.
• Add body temperature.
• Add exhaustion.
• Add injury state.
• Add infection or sickness placeholder.
• Add stat regeneration rules.
• Add stat decay rules.
• Add stat replication.
• Add stat save/load support.
• Add debug commands for modifying stats.
• [~] Add HUD display for critical stats.

1.3 Time, Weather, And Environment Pressure

• Create world time system.
• Add day/night cycle.
• Add configurable time scale.
• Set default server time scale to 4 real hours = 1 in-game day.
• Add Agrarian calendar conversion helpers for days, seasons, crop cycles, livestock maturity, spoilage, and long-running tasks.
• Add temperature curve by time of day.
• Add simple weather states.
• Add clear weather.
• Add rain.
• Add cold/wind state.
• Add storm placeholder.
• Add weather transition rules.
• Add weather replication.
• Add real-world weather provider adapter for Ground Zero by latitude/longitude.
• Use Open-Meteo as the first global MVP weather source.
• Add NOAA/NWS fallback or enrichment for US tiles where useful.
• Cache real-weather snapshots server-side so clients never call public weather APIs directly.
• Map real weather inputs into Agrarian weather states: temperature, precipitation, wind, cloud cover, humidity, pressure, visibility, and weather code.
• Add deterministic fallback weather simulation when external weather data is unavailable.
• Store weather source, provider timestamp, tile coordinate, and applied in-game weather state for debugging and persistence.
• Add weather save/load support.
• Connect weather to body temperature.
• [~] Connect shelter to weather protection.
• Add first-pass sky and lighting.
• Add audio cues for weather.

1.4 Single Biome MVP Map

• Choose Ground Zero real-world 1 km x 1 km MVP tile.
• Choose MVP biome based on Ground Zero location.
• Link Ground Zero tile coordinates to real-world weather lookup coordinates.
• [~] Create playable test map.
• Add terrain base from real elevation data.
• Add first-pass water depth/shoreline handling if applicable.
• Add first-pass hill, mountain, river, stream, lake, and coastline handling if present in Ground Zero.
• Add source metadata record for the MVP tile.
• Add generated tile metadata record for the MVP tile.
• Verify terrain scale is 1 km x 1 km in Unreal.
• Verify terrain tile origin and centered Unreal bounds for the Ground Zero test map.
• Verify neighboring tile edge coordinates against the registry before multi-tile stitching.
• Add foliage pass.
• [~] Add resource nodes.
• Add biome-appropriate natural resources based on Ground Zero.
• Add water source.
• Add weather exposure zones if needed.
• Add landmark or ruin placeholder.
• Add spawn area.
• Add performance profiling markers.
• Add navigation support for wildlife.
• Add map boundaries or soft limits.
• Add developer travel command.

1.5 Inventory System

• Design inventory data model.
• Create item definition data asset.
• Create item stack structure.
• Create inventory component.
• Add item pickup.
• Add item drop.
• Add stack splitting.
• Add item use.
• Add equipment slots if needed.
• Add weight or carry capacity placeholder.
• Add inventory UI.
• Add replication for inventory changes.
• Add persistence for inventory.
• Add debug item spawn command.

1.6 Gathering And Resources

• Create resource node base class.
• Add wood resource.
• Add stone resource.
• Add fiber resource.
• Add edible plant resource.
• Add water gathering interaction.
• Add resource depletion.
• Add respawn rules for MVP.
• Add tool requirement rules.
• Add bare-hand gathering fallback.
• Add resource node persistence.
• Add replicated gathering feedback.

1.7 Primitive Crafting

• Design recipe data model.
• Create recipe data assets.
• Implement recipe validation.
• Implement crafting queue or instant crafting.
• Add primitive tool recipe.
• Add campfire recipe.
• Add shelter recipe.
• Add recipes or gather paths for primitive shelter structure parts.
• Add simple container recipe.
• Add bandage or basic treatment recipe.
• Add crafting UI.
• Add multiplayer authority checks.
• [~] Add crafting debug tools.

1.8 Fire System

• Create fire actor.
• Add fuel amount.
• Add ignition interaction.
• Add extinguish logic.
• Add warmth radius.
• Add light source.
• Add cooking placeholder if needed.
• Add smoke/visual effect placeholder.
• Add replication.
• Add persistence.
• Connect fire to body temperature.
• Connect rain/weather to fire behavior.

1.9 Shelter Building

• Decide MVP building style.
• Create build placement mode.
• [~] Add ghost preview.
• Add placement validation.
• Add basic shelter piece.
• Add wall piece if needed.
• Add roof piece if needed.
• Add door/opening if needed.
• Add resource cost validation.
• Add construction interaction.
• Add shelter protection volume.
• Add shelter persistence.
• Add shelter replication.
• Add deconstruction or damage placeholder.

1.10 Injury And Basic Survival Consequences

• Add generic injury state.
• Add bleeding placeholder.
• Add sprain or movement penalty placeholder.
• Add cold exposure damage.
• Add starvation damage.
• Add dehydration damage.
• Add treatment item.
• Add death state.
• Add respawn rules for MVP.
• Add corpse/backpack placeholder if needed.
• Add replicated death feedback.

1.11 Wildlife Prototype

• Choose MVP wildlife species.
• Create wildlife base pawn.
• Add simple AI wander.
• Add flee behavior.
• Add aggression behavior if needed.
• Add health.
• Add damage.
• Add harvesting interaction.
• Add meat/hide resources.
• Add spawn manager.
• Add replication.
• Add performance limits.

1.12 Basic Multiplayer

• Confirm listen server vs dedicated server for MVP.
• Create dedicated server build target if needed.
• Add server travel flow.
• Define server authority over streamed terrain tiles.
• Define server response when a client requests a missing tile.
• Add player join flow.
• Add player spawn flow.
• Add replicated player stats.
• Add replicated inventory.
• Add replicated world time.
• Add replicated weather.
• Add replicated resource nodes.
• Add replicated build pieces.
• Add network relevancy rules.
• Add basic latency testing.
• Add disconnect/reconnect handling.

1.13 Persistence MVP

• Decide MVP persistence scope.
• Decide what tile metadata is stored in save data vs external tile registry.
• Save player identity.
• Save player stats.
• Save player inventory.
• Save placed structures.
• Save resource depletion state if needed.
• Save world time.
• Save weather seed/state.
• Save containers.
• Add server-side save interval.
• Add manual admin save command.
• Add load-on-server-start.
• Add initial tile registry persistence for Ground Zero.
• Add backup-before-save option.
• Add recovery plan for corrupted save.
• Document persistence limitations.

1.14 MVP UI And UX

• Add main menu placeholder.
• Add join server screen.
• Add loading screen.
• [~] Add HUD.
• Add inventory UI.
• Add crafting UI.
• Add interaction prompts.
• Add death/respawn UI.
• Add debug/dev menu.
• Add accessibility basics.
• Ensure UI scales on common resolutions.

1.15 MVP Audio And Atmosphere

• Add ambient biome audio.
• Add footstep placeholders.
• Add gathering sounds.
• Add fire sounds.
• Add weather sounds.
• Add wildlife sounds.
• Add UI sounds.
• Add mix settings.
• Add volume sliders.

1.16 MVP QA Gates

• Can launch packaged client.
• Can launch server.
• Can connect two clients.
• Can gather resources.
• Can craft a fire.
• Can craft a shelter.
• Can survive one full day/night cycle.
• Can die from survival pressure.
• Can reconnect and retain state.
• Can restart server and retain placed shelter.
• No critical log spam during 30-minute test.
• Server remains stable with target test player count.

---

Phase 2 - Persistent Homesteading

Goal: Transition from temporary survival into lasting settlement and land stewardship.

2.1 Land And Claiming

• Design land claim philosophy.
• Define claim size limits.
• Define claim cost or effort.
• Implement claim marker.
• Implement claim ownership.
• Implement claim permissions.
• Add claim UI.
• Add claim persistence.
• Add claim conflict rules.
• Add abandoned claim decay rules.

2.2 Farming

• Design soil model.
• Add basic soil quality.
• Add moisture.
• Add crop data assets.
• Add planting interaction.
• Add growth stages.
• Add watering or rainfall impact.
• Add harvest interaction.
• Add crop yield rules.
• Add crop failure rules.
• Add seed recovery.
• Add crop persistence.

2.3 Domestication

• Choose first domestic animal.
• Add taming concept.
• Add feeding.
• Add containment.
• Add animal health.
• Add breeding placeholder.
• Add animal products.
• Add ownership.
• Add persistence.

2.4 Storage And Preservation

• Add storage containers.
• Add container permissions.
• Add spoilage timer.
• Add preserved food item.
• Add drying/smoking/salting placeholder.
• Add storage persistence.
• Add storage UI.

2.5 Permanent Structures

• Expand building pieces.
• Add foundation.
• Add walls.
• Add roof.
• Add door.
• Add basic furniture.
• Add structure health.
• Add repair.
• Add decay rules.
• Add permissions.
• Add persistence optimizations.

2.6 Simple Economy

• Add barter container.
• Add simple trade UI.
• Add ownership transfer.
• Add local price notes if needed.
• Add AGR placeholder integration planning.
• Add transaction logging.

---

Phase 3 - Social Civilization Systems

Goal: Let player communities form organically through trade, trust, conflict, law, and local coordination.

3.1 Identity And Reputation

• Add player display identity.
• Add household/family name placeholder.
• Add reputation records.
• Add local reputation display.
• Add reputation event logging.
• Add positive reputation events.
• Add negative reputation events.
• Add reputation decay or locality rules.

3.2 Trade And Contracts

• Design direct trade flow.
• Add secure trade window.
• Add barter offer records.
• Add basic contract data model.
• Add delivery contract.
• Add labor contract.
• Add rental contract placeholder.
• Add contract completion rules.
• Add dispute placeholder.

3.3 Crime And Consequences

• Define theft rules.
• Define trespassing rules.
• Define property damage rules.
• Add crime event logs.
• Add witness/local knowledge concept.
• Add basic lock system.
• Add punishment placeholder.
• Add moderation/admin review tools.

3.4 Local Governance

• Add group/settlement entity.
• Add membership.
• Add roles.
• Add permissions.
• Add voting placeholder.
• Add tax placeholder.
• Add shared storage.
• Add settlement notice board.

3.5 Migration And Frontier

• Design migration pressure model.
• Add spawn region variation.
• Add new frontier spawn logic.
• Add abandoned settlement discovery.
• Add map hints for settlement density.
• Add travel risk/reward systems.

---

Phase 4 - Generational Gameplay

Goal: Introduce mortality, inheritance, lineage, family knowledge, and the emotional heart of Agrarian.

4.1 Aging And Lifespan

• Define time scale for aging.
• Add character age.
• Add age categories.
• Add stat changes by age.
• Add skill efficiency changes by age.
• Add mortality rules.
• Add death by old age.
• Add UI for age and legacy.

4.2 Family And Relationships

• Add relationship model.
• Add household model.
• Add spouse/partner placeholder.
• Add children system design.
• Add NPC vs player descendant decision.
• Add family tree UI.
• Add family persistence.

4.3 Knowledge Inheritance

• Define knowledge categories.
• Add knowledge acquisition.
• Add teaching interaction.
• Add apprenticeship.
• Add inherited knowledge rules.
• Add knowledge loss if lineage collapses.
• Add written records or books.
• Add library/archives concept.

4.4 Inheritance

• Add estate model.
• Add property inheritance rules.
• Add item inheritance rules.
• Add claim inheritance.
• Add settlement role inheritance.
• Add will/testament placeholder.
• Add no-heir fallback rules.

---

Phase 5 - Governments And Civilization

Goal: Enable cities, citizenship, taxation, diplomacy, organized law, warfare, and territorial control.

5.1 Settlements To Cities

• Add settlement progression metrics.
• Add population tracking.
• Add infrastructure tracking.
• Add settlement services.
• Add city designation.
• Add city management UI.

5.2 Citizenship And Law

• Add citizenship model.
• Add legal code records.
• Add local laws.
• Add permissions by law.
• Add court/dispute placeholder.
• Add fines or penalties.

5.3 Taxation And Public Works

• Add treasury model.
• Add tax rules.
• Add public storage.
• Add road funding.
• Add public building funding.
• Add treasury audit logs.

5.4 Diplomacy

• Add settlement relations.
• Add alliances.
• Add trade agreements.
• Add non-aggression pacts.
• Add war declaration.
• Add treaty records.

5.5 Warfare

• Define combat scale.
• Add weapon progression.
• Add armor progression.
• Add siege placeholder.
• Add territory conflict rules.
• Add war consequences.
• Add anti-griefing protections.

---

Phase 6 - Dynamic Civilization Cycles

Goal: Keep the world alive for future generations through change, decay, scarcity, collapse, and renewal.

6.1 Environmental Sustainability

• Add soil exhaustion.
• Add crop rotation benefits.
• Add deforestation tracking.
• Add wildlife population tracking.
• Add water stress.
• Add resource depletion.
• Add environmental recovery.

6.2 Disease And Hardship

• Add disease model.
• Add spread rules.
• Add sanitation concept.
• Add medicine progression.
• Add famine conditions.
• Add disaster events.

6.3 Infrastructure Decay

• Add road decay.
• Add building decay.
• Add bridge decay.
• Add maintenance actions.
• Add ruin state.
• Add rediscovery value for ruins.

6.4 Collapse And Frontier Renewal

• Add settlement instability metrics.
• Add migration waves.
• Add abandoned settlement transformation.
• Add frontier emergence rules.
• Add new player frontier assignment.

---

Phase 7 - Earth-Scale Expansion

Goal: Expand from a small test world toward a huge, regionally diverse, persistent world that can eventually approach Earth scale through staged 1 km x 1 km real-terrain tiles.

7.1 Terrain And World Partition

• Evaluate Unreal World Partition.
• Define real terrain generation pipeline.
• Define real bathymetry/ocean-depth generation pipeline.
• Define hand-authored vs procedural balance.
• Define 1 km tile package format.
• Define 1 km tile World Partition placement rules.
• Define tile edge stitching and seam repair pipeline.
• Define terrain vertical scale policy for mountains, hills, and ocean depth.
• Define river, lake, coastline, and wetland generation rules.
• Define missing/low-quality source data fallback rules.
• Add streaming tests.
• [~] Add server-delivered tile streaming prototype. Near-term MVP proof is tracked in Phase 0.7.
• [~] Add client local tile cache prototype. Near-term MVP proof is tracked in Phase 0.7.
• Add stale tile scrubber prototype.
• Add tile redownload and version update prototype.
• Add biome boundaries.
• Add region metadata.
• Add server scaling plan.

7.2 Biome Diversity

• Derive biome candidates from real-world land-cover, climate, elevation, and water data.
• Add forest biome.
• Add plains biome.
• Add mountain biome.
• Add wetland biome.
• Add desert/dryland biome.
• Add cold biome.
• Add biome-specific resources.
• Map natural resources to likely real-world geology, flora, water, and climate.
• Add biome-specific survival pressure.

7.3 Logistics And Transportation

• Keep walking and running speeds close to real-world human pace.
• Keep animal travel speeds close to real-world animal pace.
• Define terrain slope, vegetation, mud, snow, water, injury, fatigue, age, strength, endurance, hunger, thirst, and carried weight modifiers for travel speed.
• Add roads.
• Add carts.
• Add pack animals.
• Add horses.
• Add tractors.
• Add cars.
• Add boats.
• Add shipping routes.
• Add regional trade value.
• Add distance-based economy pressure.

7.4 Continental Economy

• Add regional scarcity.
• Add market hubs.
• Add transport contracts.
• Add tariffs or taxes.
• Add price history.
• Add economic dashboards.

7.5 Tile Operations At Scale

• Define tile generation queue.
• Define tile publish queue.
• Define tile validation dashboard.
• Define operator tools for seeing generated, missing, stale, and failed tiles.
• Define player-demand driven tile prioritization.
• Define prefetch rules around active player regions.
• Define storage and CDN strategy for millions of generated tile packages.
• Define cost controls for serving and regenerating terrain content.
• Define long-term archival strategy for superseded tile versions.

---

Phase 8 - Industrial And Automation Era

Goal: Let player civilizations advance into mechanization, energy, automation, and large-scale production.

8.1 Industrial Materials

• Add mining progression.
• Add ore processing.
• Add metallurgy.
• Add machine parts.
• Add fuel types.
• Add industrial storage.

8.2 Power Systems

• Add mechanical power.
• Add water power.
• Add steam power.
• Add electrical power.
• Add power grid rules.
• Add maintenance/failure.

8.3 Production Chains

• Add workshops.
• Add factories.
• Add production queues.
• Add labor requirements.
• Add logistics bottlenecks.
• Add quality tiers.

8.4 Automation And Robotics

• Add automation control concept.
• Add basic machine workers.
• Add robotics progression.
• Add AI-assisted labor.
• Add safety/failure risks.

---

Phase 9 - Orbital Foundations

Goal: Make space feel earned by centuries of civilization, science, industry, and infrastructure.

9.1 Astronomy And Knowledge

• Add astronomy observations.
• Add observatory building.
• Add star charts.
• Add orbital mechanics knowledge.
• Add education requirements.

9.2 Launch Infrastructure

• Add advanced materials.
• Add fuel production.
• Add launch site construction.
• Add rocket components.
• Add launch preparation.
• Add launch failure risk.

9.3 Orbital Gameplay

• Add orbital object model.
• Add satellites.
• Add communications benefits.
• Add navigation benefits.
• Add orbital maintenance.

---

Phase 10 - Interplanetary Frontier

Goal: Expand civilization beyond Earth while keeping Earth emotionally and mechanically central.

10.1 Interplanetary Travel

• Add spacecraft design.
• Add fuel logistics.
• Add life support.
• Add navigation.
• Add travel windows.
• Add travel risk.

10.2 Colony Logistics

• Add colony founding.
• Add supply chains.
• Add habitat construction.
• Add resource extraction.
• Add communication delay if desired.
• Add political connection to Earth.

10.3 Multi-World Persistence

• Add planetary world records.
• Add orbital economy.
• Add interplanetary trade.
• Add settlement history across worlds.
• Add long-term expansion governance.

---

Cross-Cutting Technical Tracks

These tracks run across all phases and must not be left as afterthoughts.

A. Networking

• Define server authority rules.
• Define replication ownership rules.
• Define relevancy strategy.
• Define bandwidth budget.
• Create multiplayer test maps.
• Add network profiling routine.
• Add replication tests for each gameplay system.
• Add disconnect/reconnect tests.
• Add high latency tests.
• Add server crash recovery tests.

B. Persistence And Database

• Define what lives in Unreal save files.
• Define what lives in external database.
• Define player account model.
• Define world state model.
• Define global tile registry data model for roughly 510-520 million potential 1 km tiles.
• Define tile coordinate primary key strategy.
• Define tile metadata tables.
• Define tile generation job tables.
• Define tile package/version tables.
• Define player/world-state anchoring to tile coordinates.
• Define terrain tile state vs player-made world state separation.
• Define backup policy.
• Define rollback policy.
• Define migration policy.
• Add automated save validation.
• Add schema/version tracking.
• Add admin restore workflow.

C. Accounts And Authentication

• Decide account provider.
• Decide Steam account integration timing.
• Add local dev auth placeholder.
• Add account identity model.
• Add character ownership model.
• Add ban/moderation hooks.
• Add privacy policy requirements.

D. AGR Integration

• Define what AGR does in MVP.
• Define what AGR does not do in MVP.
• Decide custodial vs non-custodial game wallet approach.
• Define testnet/devnet flow.
• Define transaction confirmation rules.
• Define in-game ledger rules.
• Define anti-fraud rules.
• Define market transaction logs.
• Define bridge between web wallet and game account.
• Define legal/compliance review points.

E. Admin And Moderation

• Add admin login/auth.
• Add server console commands.
• Add teleport command.
• Add item grant command.
• Add player kick/ban command.
• Add world save command.
• Add world rollback command.
• Add player report system.
• Add audit logs.
• Add moderation dashboard plan.

F. Security And Abuse Prevention

• Define trust boundaries.
• Keep server authoritative.
• Validate all client requests.
• Add rate limits where needed.
• Add anti-cheat research track.
• Add exploit report workflow.
• Add log retention policy.
• Add account recovery policy.
• Add economy abuse monitoring.

G. Performance

• Define minimum target hardware.
• Define client FPS targets.
• Define server tick targets.
• Define memory budgets.
• Define actor count budgets.
• Define World Partition streaming budgets.
• Define tile download bandwidth budget.
• Define local tile cache size budget.
• Define cache cleanup rules for unused terrain tiles.
• Add profiling checklist.
• Add asset size budgets.
• Add LOD strategy.
• Add foliage performance strategy.
• Add save/load performance benchmarks.

H. Art Direction

• Define visual tone.
• Define early survival era look.
• Define old-world ruin look.
• Define agrarian settlement look.
• Define UI visual language.
• Define color palette.
• Define material style.
• Define lighting style.
• Define character style.
• Define icon style.

I. Audio Direction

• Define ambient audio style.
• Define weather audio style.
• Define wildlife audio style.
• Define UI sound style.
• Define music philosophy.
• Define silence/space usage.
• Define settlement soundscape.
• Define industrial era sound progression.

J. QA And Testing

• Create smoke test checklist.
• Create multiplayer test checklist.
• Create persistence test checklist.
• Create terrain tile import QA checklist.
• Create terrain seam QA checklist.
• Create biome/resource plausibility QA checklist.
• Create tile cache/download QA checklist.
• Create performance test checklist.
• Create release candidate checklist.
• Add bug triage workflow.
• Add crash reporting plan.
• Add automated build validation.
• Add test server reset process.

K. Build And Release Pipeline

• Define dev editor build process.
• Define internal test build process.
• Add repository storage policy and local storage audit script.
• Define closed alpha build process.
• Define dedicated server packaging.
• Define patch distribution.
• Define version numbering.
• Define changelog format.
• Define rollback process.
• Define release approval checklist.
• Add one-command Codex build wrapper for AgrarianGameEditor.
• Store editor build logs under Saved/BuildLogs/BuildEditor-Windows.log.
• Add one-command packaged client build wrapper.
• Add one-command Linux dedicated server build wrapper.
• Define investor-demo build trigger at version milestone completion.
• Add smoke-test command for build artifacts.

L. Storefront Development Distribution

• Decide Steam development launch timing.
• Decide Epic Games Store development launch timing.
• Create Steamworks partner setup checklist.
• Create Epic Developer Portal setup checklist.
• Define internal, investor, closed tester, and public playtest build channels.
• Decide whether early development versions use Steam Playtest, Epic private artifacts, direct installer delivery, or a combination.
• Define store build upload/package process.
• Define store branch naming: internal, investor-demo, closed-alpha, public-demo, release-candidate.
• Define build metadata requirements for store uploads: version, changelog, commit, map, server compatibility, and known issues.
• Define entitlement/account linking requirements before external tester distribution.
• Add legal/storefront checklist: company name, tax/payment setup, privacy policy, EULA, content rating, screenshots, trailer, capsule art, and support email.
• Decide when agrariangame.com links to Steam/Epic pages.
• Add release checklist for pushing a development build to Steam or Epic.

M. Community And Marketing

• Keep agrariangame.com updated.
• Publish development updates.
• Collect launch list signups.
• Create Discord plan.
• Create devlog schedule.
• Create Steam page checklist.
• Create press kit.
• Create creator outreach list.
• Create early tester application.
• Create public roadmap page later.

---

Six-Month MVP Calendar

Month 1 - Foundation

• [~] Clean project structure.
• Confirm engine version.
• Set source control.
• Create base character.
• Create interaction system.
• Create first test map.
• Create stat component.
• Create inventory prototype.
• Create networking baseline.
• Create build instructions.
• Create operational build lane for Codex.
• Choose Ground Zero candidate tile.
• Define first tile registry schema.

Month 2 - Survival Loop

• Add hunger.
• Add thirst.
• Add health.
• Add stamina.
• Add weather.
• Add body temperature.
• [~] Add gatherable resources.
• Add campfire.
• Add basic crafting.
• [~] Add basic HUD.
• Import first real terrain MVP tile if feasible.

Month 3 - Shelter And Persistence

• Add building placement.
• Add primitive shelter.
• Add storage container.
• Add save/load for players.
• Add save/load for structures.
• Add save/load for containers.
• Add server restart persistence test.
• Add one full day/night survival test.
• Persist MVP tile metadata and generated package version.

Month 4 - Multiplayer And Wildlife

• Add dedicated server build.
• Add join flow.
• Add replicated inventory validation.
• Add replicated building validation.
• Add wildlife prototype.
• Add harvesting.
• Add injury placeholder.
• Add reconnect test.
• Add 2-4 player internal test.

Month 5 - Homestead Seeds And Economy Planning

• Add land claim prototype.
• Add farming prototype if feasible.
• Add simple barter placeholder if feasible.
• Define AGR integration design.
• Define account/wallet bridge design.
• Add admin commands.
• Add test feedback form/process.
• Improve UI clarity.

Month 6 - Closed MVP Readiness

• Stabilize server.
• Fix critical bugs.
• Optimize core map.
• Improve first 30 minutes of play.
• Add onboarding prompts.
• Add settings menu.
• Package client build.
• Package server build.
• Run closed internal test.
• Prepare external tester plan.
• Update website with progress.

---

Definition Of Done For The First Playable MVP

The first playable MVP is not complete until:

• Two or more players can join the same server.
• Players can gather resources.
• Players can craft at least one tool.
• Players can create fire.
• Players can build a primitive shelter.
• Weather and time affect survival.
• Hunger and thirst matter.
• Injury or damage can create meaningful risk.
• [~] At least one wildlife system exists.
• Inventory works and replicates.
• Server restart preserves core state.
• The game communicates what to do without hand-holding too much.
• The experience feels like the beginning of Agrarian, not a generic survival template.

---

Near-Term Next Actions

Use this list to restart from the top of the roadmap before continuing into newer gameplay and weather work.

Current version: 0.01 Foundation Baseline

Earliest incomplete foundation items:

• [!] Create protected main branch. Blocked while the repo remains private on the current GitHub plan; GitHub API reports this requires GitHub Pro or making the repository public.
• Decide whether to create/use a long-lived dev branch. Decision: no long-lived dev branch yet.
• Finish branch naming conventions.
• Finish commit message conventions.
• Define GitHub/LFS free-tier storage guardrails.
• Define backup expectations for NAS and repository.
• Implement Linastorage incremental project backup job.
• Implement quiesced VM backup job for Windows-Builder and Ubuntu-Codex.
• Create repeatable dedicated server build instructions.
• [~] Finish required plugin documentation.
• Confirm project opens cleanly from a fresh checkout.
• Create the core design document.
• Create the technical design document.
• Create the multiplayer/networking design document.
• Create the persistence design document.
• Create the Earth-scale terrain/tile streaming design document.
• Launch near-term MVP map-tile serving cloud VM and prove Ground Zero tile lookup/download/cache flow.
• Create economy and AGR design document.
• Create art direction, UX/HUD direction, coding standards, Blueprint standards, and asset/folder naming standards.
• Organize Content/Agrarian/ root folder and move starter/prototype assets into clear prototype folders.
• Define what qualifies as the 6-month MVP and what is explicitly excluded.
• Define MVP day/night length, survival pressure target, success loop, failure conditions, first playable internal milestone, and closed-test readiness criteria.

Immediate next item:

• Implement Linastorage incremental project backup job.