How To Make A Cover System In Unity: Similar to Dawn Of War

Dawn Of War 2 is one of my favorite games of all time. I love the cover system and how you can hide behind walls, debris, or other obstacles and boos your defensive stats. The Cover system in games like Dawn of War adds tactical depth and strategy. But here’s the kicker: How to make A cover system In Unity?

If you’re nodding your head, thinking, “Yeah, I’ve wondered about that,” then you’re in luck! Today, we will build our own Dawn of War-style cover system in Unity 3D. And guess what? It’s not as complicated as you might think.

What You’ll Learn

By the end of this tutorial, you’ll understand how to build a basic cover system and have a fully functional prototype to implement in your game. We’ll dive deep into Unity and C# code and enjoy bringing this tactical feature to life.

Prerequisites

Before we march on, make sure you have:

1. Basic understanding of Unity 3D and its interface.
2. Some experience with C# programming.
3. A knack for strategy games (okay, this one’s optional, but it makes things more fun, right?)

So, are you ready to up the ante on your game development journey? Let’s dig in and start building a cover system that even a Space Marine would envy!

Core Concepts

The cover system is designed to provide entities, like game characters, with places to take cover from enemy fire. This system comprises four major components:

1. CoverManager: This is the overseer for all the cover spots available in the scene. It maintains two lists: one for unoccupied cover spots and another for occupied ones. The manager has methods to allocate, deallocate, and search for cover spots based on certain conditions.
2. CoverController: It manages individual ‘cover’ game objects, holding multiple cover spots. The CoverController class keeps track of information like occupancy and has methods to show or hide indicators, giving the player visual cues.
3. CoverSpot: This is the individual location where an entity will be positioned when taking cover. A CoverSpot knows if it’s occupied, who is occupying it, and whether it offers protection from a specific direction.
4. CoverSpotConfigSO: This is a ScriptableObject that stores configuration data for a cover spot. This data could be things like accuracy modifiers or damage multipliers when an entity is in cover.

When an entity decides it needs to take cover, it can ask the CoverManager to find the best available cover spot based on factors like proximity to the enemy, distance, and safety. Once a suitable CoverSpot is found, its status is updated to ‘occupied,’ and the entity moves to that location. Additionally, the CoverSpotConfigSO allows for flexibility in gameplay by offering different bonuses or penalties for using certain cover spots.

Step By Step Guide

Part 1: The CoverSpot Class

Before we dive into the nitty-gritty of code and Unity editor, let’s first understand what a CoverSpot is. In our cover system, a CoverSpot represents an individual location where an entity (like our game’s hero) can take cover. It knows whether it’s occupied, who’s occupying it, and if it provides protection from a specific direction. Ready to code? Let’s get started!

Step 1: Setting Up Your Unity Project

1. Open Unity Hub and create a new 3D project.
2. Create a new folder called Scripts in your Assets directory.
3. Inside Scripts, create a new C# script and name it CoverSpot.

Step 2: Define Basic Variables

Open the CoverSpot script and start by declaring some basic variables.

public class CoverSpot : MonoBehaviour
{
    bool occupied = false;
    Transform occupier;
    Transform cover;
}

Here, we have:

• occupied: A boolean flag that tells us whether the spot is occupied.
• occupier: A Transform object that will hold the entity taking cover.
• cover: A Transform object that represents the cover itself, in relation to the spot.

Step 3: Initialize Cover Variable

In the Start() method, initialize the cover variable to be the parent Transform of our CoverSpot.

private void Start()
{
    cover = transform.parent;
}

Step 4: Occupancy Methods

Next, let’s write methods to manage occupancy.

public void SetOccupier(Transform occupier)
{
    this.occupier = occupier;
    occupied = occupier != null;
}

public Transform GetOccupier()
{
    return occupier;
}

public bool IsOccupied()
{
    return occupied;
}

Step 5: Checking for Cover

To check if the CoverSpot provides cover from a specific direction, we implement the AmICoveredFrom() method.

Before diving into the code, let’s discuss how the AmICoveredFrom method works. This method is the backbone for deciding whether a cover spot is effective against an enemy at a given target position.

The function takes the position of a target (let’s say, an enemy shooter) as an argument. It then calculates two vectors:

1. targetDirection: This points from the cover spot to the enemy.
2. coverDirection: This points from the cover spot to the main cover object.

We normalize these vectors to turn them into unit vectors, which makes them easier to work with. Then, we find the dot product of these vectors.

The dot product gives us a measure of how aligned these vectors are. If the dot product is greater than 0.9, it means the cover is effective against shots coming from the enemy’s position.

public bool AmICoveredFrom(Vector3 targetPosition)
{
    Vector3 targetDirection = (targetPosition - transform.position).normalized;
    Vector3 coverDirection = (cover.position - transform.position).normalized;

    return Vector3.Dot(coverDirection, targetDirection) > 0.9f;
}

And that wraps up the CoverSpot class! This class will serve as the foundational piece of our more complex cover system components, which we’ll dive into next.

Optional: Visual Debugging with OnDrawGizmos

he OnDrawGizmos method will draw a wireframe sphere at the position of each cover spot in the Unity Editor.

If a cover spot is occupied, the sphere will appear red. If it’s unoccupied, it will be green. This way, you can easily see the status of each cover spot while testing your game.

Here’s the code:

private void OnDrawGizmos()
{
    if (IsOccupied())
    {
        Gizmos.color = Color.red;
    }
    else
    {
        Gizmos.color = Color.green;
    }

    Gizmos.DrawWireSphere(transform.position, 0.5f);
}

Feel free to use this as an optional debugging aid. It can be a lifesaver when trying to identify issues!

Wrapping Up and What’s Next

Today, we explored the heart of our cover system, focusing on the CoverSpot class. We discussed its responsibilities, dissected its methods, and even threw in some optional debugging. You should now have a solid understanding of cover spots work.

In our next post, we’ll shift our attention to the CoverController, the brains that manage these individual cover spots.

So, grab a cup of coffee, take a well-deserved break, and stay tuned for the next installment of our Dawn Of War style cover system series.

See you in the next post!

If you’re interested in the resources I use in my game dev journey, this post may interest you: 70+ Excellent Game Development Resources You Must Have.