Projects

RTS: AI & Gameplay Systems

Itch.io (Key: RTSGAME)

GitHub Project

A solo-developed RTS built in Unity, featuring custom behavior tree AI, coroutine-based unit logic, grid-based building, and a fully functional gameplay loop, all designed for scalable, systems-driven strategy.

The Challenge

Develop an RTS game featuring intelligent enemy AI, complex unit management, real-time player interactions, and scalable building systems. The AI needed to make strategic decisions across multiple priorities while maintaining 60+ FPS performance with hundreds of active units and real-time player commands.

What I Built

Programmed RTS game with 6-layer behavior tree AI managing strategic decisions
Built modular unit system with state-pattern behaviors for mobile/stationary units
Implemented player controls with multi-selection and context-sensitive commands
Created AI managing simultaneous defense, resources, and unit production
Developed complete game with UI integration, NavMesh pathfinding, and building systems

Watch it in action

See the core systems working together in real time, from worker AI and grid-based placement to enemy behavior.

My Technical Contributions

1. Multi-Layer Behavior Tree Architecture with Strategic AI

Problem:

Create intelligent enemy AI that can simultaneously manage defense, economy, unit production, and strategic planning without conflicts, while making decisions that challenge players but remain fair and engaging.

Solution:

Built a sophisticated 6-layer behavior tree system with 20+ specialized nodes handling hierarchical decision-making from high-level strategy down to individual unit commands.

// Core AI system with clean singleton architecture
public class EnemyAI : MonoBehaviour {
    private BehaviorTree behaviorTree;
    private SequenceNode rootNode = new SequenceNode();
    
    private void InitBehaviorTree() {
        behaviorTree = new BehaviorTree(rootNode);
        
        // Layer 1: Strategic priorities
        checkIfUnderAttackNode = new CheckIfUnderAttackNode(behaviorTree);
        checkUnitSpacesNode = new CheckUnitSpacesNode(behaviorTree);
        checkRecolectionUnitsNode = new CheckRecolectionUnitsNode(behaviorTree);
        
        // Build hierarchical decision tree through 6 layers
        behaviorTree.AddNode(behaviorTree.GetRoot(), checkIfUnderAttackNode);
        behaviorTree.AddNode(checkIfUnderAttackNode, countEnemyUnitsNode);
        // ... continues through 6 complete decision layers
    }
    
    private void Update() {
        behaviorTree.Update(); // Processes entire decision tree each frame
    }
}

// Smart resource allocation with threat assessment
public class CheckResourcesForRecolectionUnits : ConditionNode {
    public override bool Condition() {
        return EnemyAI.Instance.GetMoney() >= 40 && 
               EnemyAI.Instance.GetMobileUnits().Count < EnemyAI.Instance.GetCurrentUnitSpaces

Result:

AI successfully manages up to 15 resource collectors, 725 defensive walls, and multiple unit production facilities while adapting strategy based on player actions.

2. Advanced State Pattern Implementation for Unit Behaviors

Problem:

Design a flexible system supporting diverse unit types (mobile/stationary) with complex behaviors that can transition seamlessly between states while maintaining performance with 100+ active units.

Solution:

Implemented comprehensive state pattern with abstract base classes supporting multiple unit inheritance hierarchies and clean state transitions.

// Flexible state pattern supporting multiple unit types
public abstract class State {
    protected MobileUnit mobileUnit;
    protected Intern intern;
    protected EnemyRecolectors enemyRecolector;
    
    public State(MobileUnit mu) { mobileUnit = mu; }
    public State(Intern i) { intern = i; }
    public State(EnemyRecolectors er) { enemyRecolector = er; }
    
    public abstract void Update();
    public virtual void OnStateEnter() {}
    public virtual void OnStateExit() {}
}

// Clean state management with NavMesh integration
public abstract class MobileUnit : Unit {
    protected State currentState;
    protected NavMeshAgent agent;
    
    public void SetState(State state) {
        if (currentState != null) {
            currentState.OnStateExit(); // Clean exit from previous state
        }
        currentState = state;
        if (currentState != null) {
            currentState.OnStateEnter(); // Initialize new state
        }
    }
    
    protected override void Update() {
        base.Update();
        currentState.Update(); // Execute current behavior

Result:

Scalable architecture supporting unlimited unit types with shared base functionality, reducing code duplication by 70% while enabling complex unit behaviors and smooth state transitions.

3. RTS Player Interaction System

Problem:

Create intuitive RTS controls supporting multi-unit selection, context-sensitive commands, and real-time feedback while preventing UI conflicts and maintaining responsive gameplay.

Solution:

Developed comprehensive interaction system with advanced selection methods, smart command interpretation, and dynamic UI integration.

// Multi-modal selection system with context-sensitive commands
public class UnitController : MonoBehaviour {
    private void ClickOnUnit() {
        Ray ray = mainCam.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        
        if (Input.GetMouseButtonDown(0)) {
            if (Input.GetKey(KeyCode.LeftControl)) {
                // Multi-select mode with smart filtering
                MobileUnit mobileUnit_Script = hit.collider.GetComponent<MobileUnit>();
                if (mobileUnit_Script != null) {
                    if (!Player.Instance.GetSelectedUnits().Contains(hit.collider.gameObject)) {
                        mobileUnit_Script.Select();
                        Player.Instance.GetSelectedUnits().Add(hit.collider.gameObject);
                    }
                }
            }
        }
        else if (Input.GetMouseButtonDown(1)) {
            // Context-sensitive right-click commands
            foreach (GameObject unit in Player.Instance.GetSelectedUnits()) {
                MobileUnit mobileUnit_Script = unit.GetComponent<MobileUnit>();
                if (mobileUnit_Script != null) {
                    if (hit.collider.tag == "Resource") {
                        // Auto-assign resource gathering
                        Intern intern_Script = unit.GetComponent<Intern>();
                        intern_Script.SetState(new GoingToFarm_State(intern_Script, 
                            hit.collider.GetComponent<StationaryResource>()));
                    }
                    else if (hit.collider.tag == "EnemyUnit") {
                        // Auto-assign combat
                        mobileUnit_Script.SetState(new ApproachingEnemy_State(mobileUnit_Script, 
                            hit.collider.GetComponent<Unit>()));
                    }
                    else {
                        // Standard movement
                        mobileUnit_Script.SetState(new Walking_State(mobileUnit_Script, hit.point));
                    }
                }
            }
        }
    }
    
    // Real-time selection box with screen-space calculations
    private void ReleaseSelectionBox() {
        Vector2 min = selectionBox.anchoredPosition - (selectionBox.sizeDelta / 2);
        Vector2 max = selectionBox.anchoredPosition + (selectionBox.sizeDelta / 2);
        foreach (GameObject unit in Player.Instance.GetMobileUnits()) {
            Vector3 screenPos = mainCam.WorldToScreenPoint(unit.transform.position);
            if (screenPos.x > min.x && screenPos.x < max.x && screenPos.y > min.y && screenPos.y < max.y) {
                unit.GetComponent<MobileUnit>().Select();
                Player.Instance.GetSelectedUnits().Add(unit

Result:

Intuitive RTS controls supporting single-click, multi-select, and drag-box selection with context-aware commands that automatically assign appropriate behaviors based on target type.

4. Real-Time Building System with Grid-Based Placement

Problem:

Implement responsive building mechanics with grid snapping, rotation controls, and NavMesh integration while providing visual feedback and preventing invalid placements.

Solution:

Created dynamic building system with real-time preview, mouse tracking, and automatic navigation mesh updates.

// Real-time building system with grid integration
public class BuildManager : MonoBehaviour {
    private GameObject placeableObj;
    private GameObject placeableObjPreview;
    private bool initBuilding;
    
    private void TrackMouse() {
        Ray ray = mainCam.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        if (Physics.Raycast(ray, out hit)) {
            // Snap to grid with Y-axis preservation
            float prefabYpos = placeableObj.transform.position.y;
            placeableObj.transform.position = Grid.Instance.GetGridPoint(hit.point);
            placeableObj.transform.position = new Vector3(
                placeableObj.transform.position.x, 
                prefabYpos, 
                placeableObj.transform.position.z
            );
            
            // Real-time rotation controls
            if (Input.GetKeyDown(KeyCode.R)) {
                placeableObj.transform.Rotate(0, 90f, 0);
            }
        }
    }
    
    private void Build() {
        if (Input.GetMouseButtonDown(0)) {
            placeableObj.layer = prefabLayer; // Finalize placement
            placeableObj = null;
            initBuilding = false

Result:

Responsive building system with grid-snapped placement, real-time rotation, and integrated pathfinding updates enabling strategic base construction.

5. Modular Behavior Tree Framework with Custom Node Types

Problem:

Create a reusable, extensible behavior tree system that supports different node types while maintaining clean architecture and easy debugging capabilities.

Solution:

Built comprehensive behavior tree framework with abstract base classes and specialized node implementations.

// Core behavior tree architecture
public class BehaviorTree {
    private Node root;
    private List<Node> children = new List<Node>();
    private Node currentNode;
    
    public BehaviorTree(Node root) {
        this.root = root;
        currentNode = root;
    }
    
    public void Update() {
        currentNode.Update(); // Execute current decision branch
    }
    
    public void AddNode(Node father, Node newNode) {
        newNode.SetFather(father);
        children.Add(newNode);
    }
}

// Abstract node base with clean inheritance
public abstract class Node {
    protected Node father;
    protected List<Node> children = new List<Node>();
    protected BehaviorTree behaviorTree;
    
    public Node(BehaviorTree behaviorTree) {
        this.behaviorTree = behaviorTree;
    }
    
    public abstract void Update();
    
    public void SetFather(Node node) {
        father = node;
        father.AddChild(this

Result:

Flexible behavior tree framework supporting Condition, Action, Decorator, and Sequence nodes with clean inheritance and easy expansion for new AI behaviors.

6. Performance Optimized Game Architecture

Problem:

Maintain 60+ FPS with complex AI calculations, real-time player input, building systems, and 100+ active units while keeping code maintainable and extensible.

Solution:

Implemented singleton patterns, efficient update cycles, and modular architecture with clear separation of concerns.

// Clean unit architecture with proper inheritance
public abstract class Unit : MonoBehaviour {
    protected bool aiUnit;
    protected int currentHP, maxHP;
    protected int attackDamage;
    
    public void TakeDamage(int dmg, Unit attacker) {
        currentHP -= dmg;
        if (aiUnit) {
            EnemyAI.Instance.IsBeingAttacked(attacker); // Notify AI system
        }
    }
    
    protected virtual void Die() {
        // Clean resource management
        if (aiUnit == false) {
            Player.Instance.GetSelectedUnits().Remove(gameObject);
            EnemyAI.Instance.GetCurrentAttackers().Remove(gameObject);
        }
        Destroy(gameObject);
    }
}

// Efficient singleton pattern for system coordination
public class EnemyAI : MonoBehaviour {
    private static EnemyAI instance;
    public static EnemyAI Instance { get { return instance; } }
    
    private void Awake() {
        if (instance == null) {
            instance = this;
        } else {
            Destroy(this

Result:

Stable 60+ FPS performance with complex systems running simultaneously, clean memory management, and maintainable architecture supporting rapid feature development.

Results & Impact

AI Performance: 6-layer behavior tree processes 20+ decisions per frame while maintaining strategic coherence across defense, economy, and offense
System Integration: Successfully coordinated behavior trees, state patterns, building systems, and player controls without conflicts
Scalability: Architecture supports unlimited unit types and AI behaviors with 70% code reuse across systems
Performance: Maintained 60+ FPS with 100+ active units, complex AI calculations, and real-time player interactions
Code Quality: Clean architecture with proper inheritance, singleton patterns, and separation of concerns enabling easy maintenance and expansion

Lessons Learned

Behavior trees excel for complex AI but require careful balancing between decision layers to maintain strategic coherence
State patterns are essential for managing complex unit behaviors while keeping code maintainable and extensible
Performance optimization must be architectural - efficient patterns from the beginning prevent bottlenecks better than retrofitting
Player interaction systems require careful event handling to prevent UI conflicts while maintaining responsive gameplay
Modular design patterns pay significant dividends when integrating multiple complex systems and debugging interactions between them