Simple RTS Tool

Pixit Simple RTS is a focused starter kit for building classic economy-driven RTS games: place buildings, assign workers, produce resources and units, and grow your town using a clean, data-driven architecture.
The package includes both the core gameplay systems and a large set of stylized low-poly buildings so you can prototype quickly and still ship-worthy visuals later if you want.
Key Features
✔ Grid-based building placement
Smooth mouse-driven placement with a configurable grid.
Ghost preview with valid/invalid material feedback.
Ground layer checks & placement rules (allowed ground types, overlap checks, etc.).
Simple build-mode controller you can easily extend (rotation, hotkeys, categories…).

✔ Construction stages
Each building can define multiple construction stages via ScriptableObjects.
Global construction prefab logic with per-building final prefab.
Buildings spawn, progress through visual stages, then convert into the final structure automatically.

✔ Resource system & storage
Central ResourceManager that tracks current & maximum amounts per resource type.
Scriptable resource definitions (wood, stone, gold, etc.).
Buildings can add storage capacity bonuses when completed.
Simple, readable C# API to query, spend or add resources.

✔ Worker & resource production
Buildings can require and assign workers.
Worker count directly drives per-worker resource production.
Accumulates fractional production over time and adds whole units to the resource pool.Clean ResourceProducer logic that:
Uses building’s data (per-worker income values).
Easy to plug in your own worker AI / animations.

✔ Unit production & generic action buttons
UnitProducer component to create units from buildings.
Scriptable unit definitions (cost, prefab, icon, name, etc.).
Producing units or triggering any custom building action becomes a one-line callback.Generic BuildingActionButton system:
UI buttons are completely generic.
At runtime, the selected building feeds actions (delegates) into buttons.

✔ Building selection & UI
Single selection system for buildings.
Dynamically populates action buttons based on the selected building’s data.Centralized BuildingUIManager:
Only one building UI is visible at a time.
Automatically spawns action buttons for producible units.
Clean separation between gameplay logic and UI presentation.

Included 3D Content
To help you prototype real RTS maps quickly, the package includes a sizeable building library:
127+ building models in a consistent low-poly style.
3 upgrade levels per building (progressive visual upgrades).Most buildings feature:
2 different age / era variants (for early / advanced tech levels).
Buildings are designed to work well from a top-down / isometric camera.
Additional small props and resource piles (logs, rocks, gold, etc.) to dress your maps.

You can use these models directly or treat them as placeholders while you plug in your own art.
Data-driven architecture
Almost everything is driven by ScriptableObjects:
Unit production configuration, etc.BuildingType
Final prefab
Construction stages
Build cost
Resource production settings
Storage bonuses
Perfect for designers: change values without touching code.ResourceType, UnitType, and other data assets
Keeps prefabs and code clean and easy to extend.

Code & Project Structure
Organized under clear namespaces (PixitGames / RTS).
Readable, commented C# scripts.
Uses standard Unity components & built-in systems (no heavy third-party dependencies).
Easy to strip or replace individual systems (placement, UI, production, etc.) if you only need part of the kit.

What you can build with it
Pixit Simple RTS is a great starting point for:
Classic town-builder RTS games.
Survival / colony management hybrids with workers and resource chains.
Prototype projects where you want an RTS economy up and running in minutes.
Learning projects for understanding how to structure RTS-style systems in Unity.