Overview

🧪 Concept prototype (2026) — developed as a pitch demo for a game publisher selection.

A complete turn-based wargame prototype built in Unity 6: hex-grid tactical battles, a campaign layer with regions and reinforcements, AI-driven opponents and an integrated map editor. Developed by a team of three — two game designers and myself as the sole programmer — to demonstrate the core gameplay loop and technical feasibility of the concept.

Demo Video

Technologies Used

  • Unity 6 (URP)
  • C# Scripting
  • Unity Input System
  • Custom Behavior Tree AI (built from scratch)
  • GPU instanced / indirect rendering for large unit counts
  • Custom shaders

Features

Tactical Battle System

  • Hex-grid battlefield with terrain types and tile effects
  • Turn-based combat between regiments with passive abilities and combat log
  • Modular victory conditions (annihilation, retreat thresholds)

Campaign Layer

  • Region-based campaign with turn phases, reinforcements and persistent battalion state
  • Campaign AI opponent and save/load of the full game state

Integrated Map Editor

  • In-game map editor with save/load support, allowing rapid creation and iteration of scenarios

Performance

  • GPU instanced rendering of tiles and units (indirect rendering) to support large maps and unit counts at high frame rates

Architecture & Technical Highlights

  • Decoupled architecture: lightweight service locator and event-driven managers, keeping battle, campaign and UI layers independent and testable.
  • Data-driven design: scenarios, regiments, regions and reinforcement sets are all configured through ScriptableObjects, so new content can be added without touching code.
  • Custom Behavior Tree AI, written from scratch: a reusable BT core with separated libraries of actions and conditions, powering both the tactical battle AI (target selection, positioning) and the campaign-level opponent.
  • Deterministic turn pipeline with explicit phases (deployment, movement, combat, reinforcements) — the foundation for save/load consistency and AI planning.
  • Rendering pipeline for scale: tiles and regiments drawn via GPU instancing with indirect draw calls, shader variants and optimized meshes — large battlefields stay smooth even with high unit counts.
  • Serialization: full game state and map data saved to JSON, with an in-game file browser for loading custom scenarios.
  • Testability: dedicated test scenes for each development phase of the campaign layer, allowing features to be validated in isolation.

Role and Contributions

The team consisted of two game designers and myself as the sole programmer. I developed the entire codebase: game architecture (service locator, data-driven ScriptableObjects), hex-grid system, behavior-tree AI, campaign logic, UI (radial menus, info panels), rendering optimization and the map editor — working closely with the designers to iterate on rules, balancing and scenario design, and building the data-driven setup and map editor that let them work autonomously on content.