RTSKit is a real-time strategy game template for Unreal Engine 5: select units, give orders, gather resources, place buildings, raise walls, train an army, fight an AI opponent and save the match. Drop three actors into a level, press Populate, and you have a playable RTS. Use it for a medieval RTS, a base-building or colony game, a city builder with combat, or any top-down strategy game.

Use it as the template for your own RTS: start from the demo, swap in your art, edit the tables, and build your game on top instead of rebuilding the basics. Because it ships as a plugin rather than a project, it also drops into a game you already have. Entities are DataTable rows, not classes: a Villager, a Town Centre and a berry bush are all rows in one table, so adding a unit type is a row edit and not a new Blueprint. Every order - human or AI - goes through one validated command path, so the ownership and price checks cannot drift apart between the player and the machine.

Includes a full medieval village art set - town centre, house, mill, lumber and mining camps, barracks, archery range, blacksmith, watch tower, walls with corner/T/cross/end pieces, gates, scaffolds, rubble, trees, mines, berry bushes, farms, characters and wildlife - so the demo map is a game and not a box of grey cubes.

Preview V1.0 | Playable Demo | Documentation

Learn to build an RTS from scratch: C++ tutorial series | Blueprint tutorial series

──────────────────────────────

WHAT YOU GET

──────────────────────────────

▸ RTS Camera — spring-arm pivot, WASD and screen-edge pan with an eased ramp, wheel zoom that scales pan speed and auto-pitches toward overhead, zoom-toward-cursor, Alt+RMB orbit, MMB drag, ground-clamped. Perspective or orthographic, switchable at runtime for a classic isometric look.

▸ Selection and Orders — click, drag-marquee, click a portrait to narrow to one, shift-click to narrow to that type. Right-click is the universal verb: move, gather, help build, attack, rally. Enemy buildings can be clicked for inspection without offering their commands. Context cursors switch to an axe over trees, a pickaxe over mines, a sword over enemies.

▸ Economy — resource nodes with finite stock, depletion stage meshes, and the AoE farm cycle (auto-replant at a cost). Gatherers walk, harvest, carry a visible load with the right tool in hand, and deliver to the nearest building whose row accepts that resource.

▸ Building and Placement — a 200 cm placement grid with footprints read from the mesh, a ghost that tints by validity, and ONE shared check for ground, slope, water and overlap, so a green ghost is never refused when you place it. Scaffolds, villager-seconds of construction, several builders, builders that roll on to the next site.

▸ Walls and Gates — drag a wall run, hold shift to keep placing. Pieces autotile straight, corner, T, cross and end from their neighbours, and re-form when a hole is knocked in the line. Gates drop onto an existing wall, claim the pieces they cover, open for friendly units and stay open to the navmesh so paths route through the gateway.

▸ Training and Population — producer queues with progress bars, population provided by buildings and spent by train actions, rally points, and trainees that gather on clear ground beside the building when no rally is set.

▸ Combat — free-form stats (Health, Attack, Armor, Range, or your own), attack orders, aggro radius for idle soldiers, attack and death animations, corpses, buildings that leave rubble and hand their population back.

▸ AI Opponent — plays the same game through the same command interface, with no cheating. Gathers, balances its workforce against its own stockpile, builds camps at the gathering frontier when the local forest runs out, walks a build ladder and saves up for the next rung, raises houses on population pressure, lays its town out in city blocks with streets between building types, walls itself in with gates and watchtowers, pushes the wall outward a block at a time as the town grows, and keeps a mixed army trained to defend its ground.

▸ Map Authoring — one Map Definition actor per level for size, water line and minimap. Faction Start markers with a Populate button that rolls a whole starting village onto the terrain, seeded and reproducible. A Resource Scatter actor for forests in clumps, mines as lone finds and berry patches between. All of it works in the editor, before you press play.

▸ HUD — a widget base class that solves the RTS HUD's real problem: your Blueprint events fire with real numbers whichever order the faction, player state and game state initialise in. Command card built from the selection's shared actions with affordability, population and tag gating, formatted hover tooltips, resource counters driven by the resource table, match clock, and a minimap with live blips, camera frustum, click-to-jump and right-click orders, square or AoE-style diamond. A faction banner in your team colour that cycles the camera through your town centres, and a pause menu base with resume, restart, reload, save and quit.

▸ Movement You Can Leave Running — navmesh corridors with local slide-and-detour avoidance, shoreline avoidance, and a stuck watchdog that notices a unit going nowhere and recovers it in steps: replan, walk out to open ground, snap back onto the navmesh, drop the order. This is the difference between a demo that survives twenty minutes unattended and one that does not.

▸ Save and Load — the whole match, in place: stockpiles, diplomacy, every unit with its cargo and job, buildings mid-construction with their train queues and rally points, node stock, and the camera. F5 and F9 wired up, plus save and reload in the pause menu.

──────────────────────────────

DATA-DRIVEN BY DESIGN

──────────────────────────────

Four DataTables define the game, and the row name is always the ID.

▸ DT_Units — units, buildings and resource nodes in one table, separated by Kind. Meshes, footprints, build time, stats, drop-off rules, gate behaviour, node stock, wall variants, the action list.

▸ DT_Actions — the command card: cost, population, train time, what it produces, which slot it occupies, whether it places as a line, what faction tags it needs.

▸ DT_Resources — icon, colour, HUD order, and the presentation of gathering it: the cursor, the carried load, the tool, the work animation.

▸ DT_Factions — colours, controller type, starting resources and population cap, faction tags.

Adding a new soldier is two rows and a name in a list. No C++, no new Blueprint.

──────────────────────────────

WHAT IT IS NOT

──────────────────────────────

Stated plainly, so nobody buys the wrong thing.

▸ No fog of war - the vision state is a stub that reveals everything.

▸ No tech tree or upgrades - the gating hooks exist, the research system does not.

▸ No formations or stances.

▸ No naval units or transports.

▸ No multiplayer in V1.0 - it is you against the AI. No lobby, matchmaking or campaign flow either.

▸ The AI is a solid demo opponent, not a competitive one: it defends its ground, it does not scout or time attacks.

──────────────────────────────

TECHNICAL DETAILS

──────────────────────────────

▸ Modules: RTSKit (Runtime, C++) and RTSKitEditor (Editor, details-panel niceties).

▸ Engines: UE 5.4, 5.5, 5.6, 5.7, 5.8. No third-party code.

▸ Platforms: Win64, Mac, Linux.

▸ Dependencies: Enhanced Input (ships with UE5). Navigation uses runtime generation with invokers; the demo project's settings are included.

▸ Blueprint-exposed throughout: every system has Blueprint events (construction completed, unit trained, gate opened, node depleted, selection changed, placement state changed) and function libraries for commands, selection, actions, factions, resources and saves.

▸ Content: 1 demo map, 4 DataTables filled with a playable roster, 4 gameplay Blueprints, 5 game-framework Blueprints, 10 UI widgets, an Enhanced Input set, and a full low-poly village art set with characters and wildlife.

▸ Source included. Every class carries a header comment explaining why it is built the way it is, not only what it does.

──────────────────────────────

WORKS WITH WORLDGEN

──────────────────────────────

RTSKit needs no particular terrain. On a fixed map it spawns its own water plane and photographs the level for the minimap. Dropped into a WorldGen world it ground-traces onto streaming chunks, re-photographs as new terrain appears, and rides the camera on an infinite map - so the same village, the same AI and the same wall-building play out on procedurally generated, endless terrain.