1. Building an RTS game in Unity - Basic Unit Navigation and selection tool

Alexey — Fri, 26 Jan 2024 14:46:21 +0000

Introduction

Devlog Part 1:
In my previous article, I introduced the Hot Heads project and discussed the fundamental need for a unit navigation system in RTS games. I opted for Unity's NavMesh system, a well-established solution. In this article, I'll share my experience with Unity's NavMesh system.

Unity NavMesh

Unity's NavMesh, based on the A* algorithm, provides a comprehensive pathfinding system. All you need in your scene is a NavMesh Surface and some NavMesh Agents.

NavMesh example from Unity Documentation

NavMeshAgent components assist in creating characters that navigate while avoiding collisions with each other. Agents leverage the NavMesh to navigate and intelligently avoid both static and dynamic obstacles. Pathfinding and spatial reasoning are handled using the scripting API of the NavMesh Agent.

To accommodate different unit types, ranging from small infantry units to large tanks, I decided to incorporate NavMesh Components into my project.

Components for Runtime NavMesh Building

Building a Navigation System

I attached the NavMesh Agent to my unit and implemented the movement logic in the following code within my UnitBase class.



private void MoveToClickPoint(Vector3 mouseClickPosition)
{
    Ray ray = mainCamera.ScreenPointToRay(mouseClickPosition);
    RaycastHit hit;
    if (Physics.Raycast(ray, out hit, 1000f, mask))
    {
        agent.SetDestination(hit.point);
    }
}

Here, mask represents the LayerMask for the Ground layer in the game. The line if (Physics.Raycast(ray, out hit, 1000f, mask)) ensures that the hit point is obtained only from objects on the Ground layer.

This function is called when the mouse0 button is pressed and is checked in the Update function.



if (Selected)
{
    // Movement

    if (Input.GetKeyDown(KeyCode.Mouse1))
    {
        // Compute onTerrain position;

        MoveToClickPoint(Input.mousePosition);
    }
}

Selection tool

One of the most important RTS mechanics is the ability to select one or multiple units. Currently, the game lacks this mechanic. Let's add the selection tool.

Firstly, I added a Canvas gameObject to my scene and an Image object to it.

Initial settings for the selection box

Now, with a selection box in place, it's time to add some logic. I created the ISelectable interface and the Selection class to control the selection box and the selectable items.



public interface ISelectable
{
    Vector3 WorldPosition { get; }

    void Register();

    void ToggleSelection(bool state);
}

The ISelectable interface is implemented by every class that can be selected by an on-screen box. It includes methods for obtaining the world position, registering a unit upon spawn, and toggling the selection state.

Now, let's discuss the Selection class. It has references to the selection tool's RectTransform component and a delta value that defines the delta position of the mouse cursor while the mouse0 button is being held to initiate a selection.



[SerializeField, Range(0f, 40f)] private float delta;
[SerializeField] private RectTransform selection;

The core logic involves updating two main parameters, position and sizeDelta, when a mouse drag is detected.



private void UpdateSelectionBox(Vector2 curMousePos)
{
    if (!selection.gameObject.activeInHierarchy)
        selection.gameObject.SetActive(true);
    float width = curMousePos.x - startPos.x;
    float height = curMousePos.y - startPos.y;
    selection.sizeDelta = new Vector2(Mathf.Abs(width), Mathf.Abs(height));
    selection.position = startPos + new Vector2(width / 2, height / 2);
}

In the ReleaseSelectionBox method, every selectable object within the selection box is tracked and selected.



void ReleaseSelectionBox()
{
    selection.gameObject.SetActive(false);
    Vector2 min = selection.anchoredPosition - (selection.sizeDelta / 2);
    Vector2 max = selection.anchoredPosition + (selection.sizeDelta / 2);

    foreach (ISelectable _selectable in selectables)
    {
        Vector2 screenPosition = mainCamera.WorldToScreenPoint(_selectable.WorldPosition);
        if (
            (screenPosition.x > min.x && screenPosition.y > min.y) &&
            (screenPosition.x < max.x && screenPosition.y < max.y)
            )
        {
            _selectable.ToggleSelection(true);
        }
        else _selectable.ToggleSelection(false);
    }
}

This code disables the selection box, retrieves box borders, and selects every ISelectable item within the screen region.

The complete code is provided below:



public class Selection : MonoBehaviour
{
    [SerializeField, Range(0f, 40f)] private float delta;
    [SerializeField] private RectTransform selection;

    private Camera mainCamera;
    private bool isSelection = false;
    private bool selectionEnabled = true;
    private Vector2 startPos, endPos;

    private static List<ISelectable> selectables = new List<ISelectable>();
    public static void RegisterNewSelectable(ISelectable selectable)
    {
        if (!selectables.Contains(selectable))
            selectables.Add(selectable);
    }

    public static void RemoveSelectable(ISelectable selectable)
    {
        if (selectables.Contains(selectable))
            selectables.Remove(selectable);
    }

    // Start is called before the first frame update
    void Start()
    {
        mainCamera = Camera.main;
    }

    // Update is called once per frame
    void Update()
    {
        if (selectionEnabled)
        {
            Vector2 mousePos = Input.mousePosition;
            if (Input.GetKeyDown(KeyCode.Mouse0))
            {
                startPos = mousePos;
            }
            if (Input.GetKey(KeyCode.Mouse0))
            {
                if (
                    Vector2.Distance(mousePos, startPos) > delta
                    )
                {
                    isSelection = true;
                    UpdateSelectionBox(mousePos);
                }
            }
            if (Input.GetKeyUp(KeyCode.Mouse0) && isSelection)
            {
                ReleaseSelectionBox();
                isSelection = false;
            }
        }

        if (Input.GetKeyDown(KeyCode.Escape)) selectionEnabled = !selectionEnabled;
    }

    private void UpdateSelectionBox(Vector2 curMousePos)
    {
        if (!selection.gameObject.activeInHierarchy)
            selection.gameObject.SetActive(true);
        float width = curMousePos.x - startPos.x;
        float height = curMousePos.y - startPos.y;
        selection.sizeDelta = new Vector2(Mathf.Abs(width), Mathf.Abs(height));
        selection.position = startPos + new Vector2(width / 2, height / 2);
    }

    void ReleaseSelectionBox()
    {
        selection.gameObject.SetActive(false);
        Vector2 min = selection.anchoredPosition - (selection.sizeDelta / 2);
        Vector2 max = selection.anchoredPosition + (selection.sizeDelta / 2);

        foreach (ISelectable _selectable in selectables)
        {
            Vector2 screenPosition = mainCamera.WorldToScreenPoint(_selectable.WorldPosition);
            if (
                (screenPosition.x > min.x && screenPosition.y > min.y) &&
                (screenPosition.x < max.x && screenPosition.y < max.y)
                )
            {
                _selectable.ToggleSelection(true);
            }
            else _selectable.ToggleSelection(false);
        }
    }
}

I followed this tutorial while implementing this, making a few modifications to the code.

This marks the second part of my devlog; stay tuned for more updates on my project. Feel free to share your thoughts and suggestions in the comments.

I started an RTS game project - Hot Heads: In the Firefight

Alexey — Sat, 20 Jan 2024 22:16:39 +0000

I haven't really written blogs, community posts, or anything of the sort before. Also, I consider myself not particularly talkative in real life, so it might be a challenge for me to write something for this initial article. Let's think of it as just my own notes.

(Thanks ChatGPT for redacting my article)

So, hello dev.to! I believe this will be my first post, and I want to share the story of my personal project.

Backstory

I'm currently in my final year at the Belarusian State University of Informatics and Radioelectronics. I've spent four years studying here, and now it's almost time to graduate. My specialization is "Information Systems and Technologies in Gamedev Industry," so for my final project, I decided to create a game using the Unity engine.

To be honest, I really like strategy games, and sometimes I spend my free time playing Company of Heroes, Hearts of Iron, or Civilization. So, it was obvious to me how my game should look.

Start of Development

Alright, I found the genre that, in my opinion, is perfect for my game. Now it's time to choose a game engine. There were several options:

Unity engine. The most obvious choice because I've already worked with Unity quite a lot. I've completed several personal projects and participated in hackathons on my own and in several development teams. Also, C# seems really familiar. I have some experience writing code in C/C++ and Java, so learning C# wasn't really hard for me.
Unreal Engine. An extremely beautiful engine that works with my favorite language, C++. The main problem is game optimization and a lack of knowledge. I've never worked with UE4 or UE5 before, so it would take a lot of time to acquire the required skills.
I had some ideas about writing my own game engine in C++ using Direct3D or OpenGL. Alternatively, I thought about using the Valve's Source Engine. It can be done for sure, but it would take an irrational amount of time to code things that already exist in other engines. That's the challenge I've left for my future projects.

The choice fell on Unity for obvious reasons. So, I started developing my first version of Hot Heads Game.

Setting and Plot

I really love wargames such as Company of Heroes or Hearts of Iron. The main problem is that I couldn't find projects about modern war conflicts. Sure, we have the Wargame series (Wargame: Red Dragon), Warno and Red Alert, but none of those games are perfect for me.
So I started developing my own universe with fictional countries but with real prototypes for weapons and vehicles. I decided to set all the actions in the desert, referring to some events of the past.

Company of Heroes by Relic Entertainment was released in 2006

Key Features

Combining RTS and FPS genres. Players can take control of any controllable unit in the first-person shooter format. This feature adds more micro-control to the game, allowing a complete change in the gaming process.
Multiple game modes. Besides the classic RTS game format of "capture and control," I want to add some more game modes. Currently, I'm thinking of adding a tower defense mode and a unit spam mode.
Some specific unit types and an ammunition system. Every single unit has its own inventory with ammo and grenades. If a unit runs out of ammunition in a fight, it will stop shooting, so the player should use supply vehicles. This type of unit stores an infinite amount of different ammunition and can supply nearby units.
Toon style. All 3D models are toon-stylized. Currently, I'm using damianb's 3D models of soldiers, but I'm planning to create my own models in the future (I've already made a similar model of a jet pilot for one of my promo videos).

A-10 Thunderbolt II stylized model

Okay, so I guess that's enough for the initial article. Share your thoughts in the comments, and feel free to leave any ideas on how I can improve both my articles and the game.

GitHub Profile | Hot Heads Repository

DEV Community: Alexey