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.

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

---

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.
• [?] Create dev branch if we want staging before main.
• [~] Define branch naming conventions.
• [~] Define commit message conventions.
• 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.
• 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.
• 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.
• 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.

---

Version .01 / 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.

Completed in version .01:

• 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 component.
• Added replicated inventory component.
• Added interaction interface and server-authoritative interaction path.
• Added resource node actor.
• Added campfire actor.
• Added primitive shelter actor.
• Added world time/weather game state.
• Added crafting component.
• Added item definition and recipe data asset classes.
• Added building placement component.
• Added save game structures and persistence subsystem scaffold.
• Added persistent actor component and placed actor save/restore foundation.
• Added admin/dev console commands.
• Added replicated wildlife base actor.
• Built AgrarianGameEditor Win64 Development successfully on Windows-Builder.
• Added a Codex headless Windows build lane through /home/nathan/bin/agrarian-build-editor.
• Added a project-local Unreal Python execution wrapper for headless editor asset updates.
• Installed VS 2022 Build Tools MSVC 14.44.35207 for Unreal 5.7 compatibility.
• Fixed AAgrarianDebugHUD compile issue caused by const HUD helper methods calling non-const AHUD::DrawText.
• Confirmed the project loads through Unreal Editor command mode and the default test map passes map check.
• Created IA_Interact input action.
• Bound IA_Interact to E and Gamepad_FaceButton_Left.
• Assigned IA_Interact to the character Blueprint's InteractAction.
• Created item definition assets for wood, stone, fiber, food, meat, hide, and primitive structure parts.
• Created recipe data assets for campfire, primitive shelter, basic tool, and bandage.
• Created item definition assets for craft result items: campfire, primitive shelter, basic tool, and bandage.
• Created Blueprint child actors for wood resource, campfire, primitive shelter, and first wildlife species.
• Placed and verified wood resource, campfire, primitive shelter, and rabbit wildlife Blueprints in the test map.
• Added command-mode smoke verification for wildlife damage/death/harvest loop.
• Added automation coverage for live GameInstance persistence save/restore through UAgrarianPersistenceSubsystem.
• Selected Ground Zero MVP terrain tile and added first tile registry schema.
• Prototyped real elevation import for the Ground Zero tile using USGS EPQS samples.
• Acquired and extracted final USGS 3DEP 1-meter DEM source for the Ground Zero tile.
• Converted extracted 1-meter DEM subset into an Unreal Landscape-ready R16 heightmap and import plan.
• Imported the Ground Zero R16 heightmap into /Game/Agrarian/Maps/L_GroundZeroTerrain_Test.
• 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 first Agrarian Studio splash screen and investor demo legal notices.
• Built a Windows Development packaged demo and smoke-tested launch into Ground Zero.

Open version .01 tasks:

• Confirm the project opens cleanly in Unreal Editor after the latest wildlife commit.
• Create IA_Interact input action.
• Bind IA_Interact to E and a gamepad button.
• Assign IA_Interact to the character Blueprint's InteractAction.
• Create item definition assets for wood, stone, fiber, food, meat, hide, and primitive structure parts.
• Create recipe data assets for campfire, primitive shelter, basic tool, and bandage.
• Create item definition assets for craft result items: campfire, primitive shelter, basic tool, and bandage.
• Create Blueprint child actors for wood resource, campfire, primitive shelter, and first wildlife species.
• Place resource nodes, campfire, shelter, and wildlife in the test map.
• Added command-mode smoke verification for gather -> inventory -> craft -> place shelter -> save/load data loop.
• Added fiber gathering and primitive shelter part recipes so shelter ingredients are naturally obtainable.
• [~] Add a simple HUD/debug display for survival and inventory.
• Test gather -> inventory -> craft -> place shelter -> save/load loop.
• Make primitive shelter ingredients naturally obtainable in normal play instead of smoke-test seeded.
• Add a PIE/server persistence test that exercises UAgrarianPersistenceSubsystem with a live GameInstance.
• Test wildlife damage/death/harvest loop.
• Decide whether to keep the current template variants or remove unused starter variants.
• Choose Ground Zero 1 km MVP tile.
• Build first tile metadata/registry prototype for Ground Zero.
• Prove automated import of real terrain data into the MVP tile.
• Define acceptable real terrain accuracy and final DEM/lidar source requirements for the MVP tile.
• Acquire or extract the final USGS 3DEP DEM/lidar source for the Ground Zero tile.
• Convert the extracted 1-meter DEM subset into an Unreal Landscape-ready heightmap and import plan.
• Import the Ground Zero R16 heightmap into an Unreal terrain test map.
• Package a Windows Development investor demo that starts on the Ground Zero map.

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.
• 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 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.
• [~] 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.
• Add client local tile cache prototype.
• 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.
• 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. 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

• Mount or create reliable local access path to the NAS shared_drive project.
• Decide whether to create a Git repository for the Unreal project.
• Inspect Source/ and current Unreal project structure.
• Confirm Unreal Engine version.
• Confirm whether existing project opens cleanly.
• Confirm whether it compiles cleanly.
• Create Phase 0 task board from this roadmap.
• Start with base character, interaction, stats, inventory, and test map.
• Set up Ubuntu-Codex source-control lane.
• Set up Windows-Builder headless Unreal build lane.
• Fix current C++ compile break and verify AgrarianGameEditor build.

Next version .01 priorities:

• Confirm latest C++ build succeeds on Windows-Builder.
• Open the project in Unreal Editor from the shared project path.
• Create IA_Interact and bind it to E plus a gamepad button.
• Assign IA_Interact to the Agrarian character Blueprint.
• Create the first editor assets needed for the playable loop.
• Place and test the wood resource node.
• Place and test the campfire.
• Place and test the primitive shelter.
• Place and test the rabbit wildlife Blueprint.
• [~] Add simple survival/inventory HUD feedback.
• Run the first full gather -> craft -> place -> save -> load smoke test.
• Test wildlife damage/death/harvest loop.
• Make all primitive shelter ingredients obtainable through normal play.
• Choose Ground Zero 1 km MVP tile.
• Define first tile registry schema.
• Prototype real terrain import for the selected MVP tile.

Immediate next item:

• Add first-pass water depth/shoreline handling if applicable.