For now, we will keep things simple and just create a new scene and then configure it as our battle area. So, add a new scene called Battle to the project and make it look pretty with some additional background scene elements.

For this example, I have used the Fantasy background (EnvironmentsFantasyBackground01.png) with some of the environmental assets from our asset pack to create the following screenshot:

We need to create a prefab for our first enemy. Doing so is simple. First, let's start with the goblin character in the asset pack (Fantasy_Pack1_Characters5.png), split its sprite up using Sprite Editor, drag sprite image 05_03 on to the scene, and then rename the new game object to Goblin. The enemy would look as the following diagram:

With the character in place, it's time to give the nasty little fellow some logic; we won't use this just yet in this chapter but it's good to have it from the beginning (see Chapter 10, The Battle Begins, for the applied AI).

So create a new AnimatorController called GoblinAI.controller and place it in AssetsAnimationControllers, which gives us the basic Animator view, as shown in the following screenshot:

Next, we need some parameters to control the state machine, so add the following parameters to the controller by clicking on the + symbol on the parameters bar and selecting the correct data type, as shown in the following screenshot:

The parameters to be added and their data types are as follows:

Now that we have some input parameters, next up we need our states. So, create the states shown in the following screenshot on the current animation layer by right-clicking and navigating to Create State | Empty:

The states to be added are as follows:

So with the parameters and states in place, all that is left is to connect everything up and finalize the state machine. So as we did in Chapter 3, Getting Animated, we need to create some transitions between the states along with the conditions for those transitions, as shown in the following screenshot:

As seen in the previous screenshot, the states and their transitions are as follows:

Now that we have our AI state machine for our Goblin, select the Goblin game object in the Scene hierarchy and add a new Animator Component in the Inspector menu and drag the newly created animator to it, which should now look like the following screenshot:

Now that we have our Goblin set up, we just need to create a prefab from it. So drag the Goblin game object from the Scene hierarchy and place it in AssetsPrefabsCharacters. You can now delete the original in the scene as we don't need it anymore.

Now that we have our Goblin enemy, we need to be able to randomly drop some into the battle. For this, we need to set up some spawning points (because we don't want them to appear just anywhere) and a script to manage them.

So first create a new empty game object in the scene and call it SpawnPoints. This is just a container to keep the spawn points all together. Next, create nine more empty game objects, make them children of the SpawnPoints game object, and then name them Spawn1, Spawn2, and so on, as shown in the following screenshot:

Now, position each Goblin in the scene where you want it to appear.

After a bit of tinkering, I ended up with the following (I also added a hero character for effect) screenshot:

Now we know where the Goblins are going to appear; we just need to get them there, so we'll manage this with a BattleManager script.

The purpose of this script is to manage the life cycle of the battle scene, from setting up the battle scene to taking turns to attack and finalizing the battle once complete.

We start off by creating a new BattleManager C# script and placing it at the top of the project Assets folder along with the other managers (if you wish, you can create a separate Managers folder and organize them there). As this script only works when we are in a battle, there is no need to make it a singleton. Battles come and go and they should only last for the length of the current battle.

First, we'll add some variables that we can configure from the scene using the following code:

    public GameObject[] EnemySpawnPoints;
    public GameObject[] EnemyPrefabs;
    public AnimationCurve SpawnAnimationCurve;

These lines maintain the spawn points the battle manager knows about, the possible enemy prefabs it can spawn into the scene, and a curve that we can use later to control how we animate the Goblins. More on this later.

Next, we have some control variables to manage the battle as it ensues. This is done using the following code:

    private int enemyCount;
    
    enum BattlePhase
    {
        PlayerAttack,
        EnemyAttack
    }
    private BattlePhase phase;
    

We keep a count of how many enemies are active in the scene as well as what phase the battle is in at the moment (along with our own enumeration of the states the battle can be in; you can always add more). Finally, we have a flag to monitor whether the enemy characters have actually started fighting.

Now when the script is run, it needs to initialize the battle arena; so add the following code to the Start method:

    void Start () {
        // Calculate how many enemies
        enemyCount = Random.Range(1, EnemySpawnPoints.Length);
        // Spawn the enemies in
        StartCoroutine(SpawnEnemies);
        // Set the beginning battle phase
        phase = BattlePhase.PlayerAttack;
    }

Keeping things simple for now, we generate a random number of Goblins who will attack (or be found wandering round the wood waiting to be chopped). Then, we spawn them in using a coroutine and start battle with the player going first.

Now that we know how many Goblins we need in the battle, we can spawn them in. I've used a coroutine here so we can animate them one by one as follows:

    IEnumerator SpawnEnemies()
    {
        // Spawn enemies in over time
        for (int i = 0; i < enemyCount; i++)
        {
            var newEnemy =
                (GameObject)Instantiate(EnemyPrefabs[0]);
            newEnemy.transform.position = new Vector3(10, -1, 0);

            yield return StartCoroutine(
                MoveCharacterToPoint(
                    EnemySpawnPoints[i], newEnemy));

            newEnemy.transform.parent =
                EnemySpawnPoints[i].transform;
        }
    }

Here, we loop through how many Goblins we'll need, create a new instance using the prefab we created earlier, set its position off screen, and then animate it on to the screen using yet another coroutine (shown in the following code). When the coroutine finishes animating, we anchor it to the spawn point it was meant for.

So that the Goblins don't appear, we use the AnimationCurve parameter we added to the script and a coroutine to move the Goblin from off screen to its intended spawn point, as follows:

IEnumerator MoveCharacterToPoint(GameObject destination, 
GameObject character)
{
    float timer = 0f;
    var StartPosition = character.transform.position;
    if (SpawnAnimationCurve.length > 0)
    {
        while (timer < SpawnAnimationCurve.keys[
            SpawnAnimationCurve.length - 1].time)
        {
            character.transform.position = 
                Vector3.Lerp(StartPosition, 
                    destination.transform.position, 
                        SpawnAnimationCurve.Evaluate(timer));

            timer += Time.deltaTime;
            yield return new WaitForEndOfFrame();
        }
    }
    else
    {
        character.transform.position = 
            destination.transform.position;
    }
}

Using the same logic we used in the previous chapter when moving the character on the map, we work out where the game object is starting from and then use a while loop to keep the game object moving until it finally reaches its destination. However, to improve things, this time we base the loop on the length of the AnimationCurve parameter we have defined for this transition.

This allows greater flexibility and allows us to have more complex and longer animations.

Then within the loop, we use Lerp for the position of the object from start to finish using the animation curve to control its time and rate.

Next, we need to give the player a way to interact with the battle scene, so we'll add some GUI buttons that only appear if we are in the player's battle phase. We need the following code to do this:

void OnGUI()
{
    if (phase == BattlePhase.PlayerAttack)
    {
        if (GUI.Button(new Rect(10, 10, 100, 50), "Run Away"))
        {
            NavigationManager.NavigateTo("World");
        }
    }
}

Now, add a new empty game object to the battle scene, name it BattleManager, and then attach the new script to it. Once there, we can configure it by adding the spawn points we created earlier to EnemySpawnPoints and the Goblin prefab to the EnemyPrefabs parameter along with the Spawn Animation Curve, as shown in the following screenshot:

using System.Collections.Generic;
using UnityEngine;

public static class GameState {

    public static Player CurrentPlayer = ScriptableObject.CreateInstance<Player>();
    public static bool PlayerReturningHome;
    public static Dictionary<string, Vector3> LastScenePositions = new Dictionary<string, Vector3>();
}

    public static Vector3 GetLastScenePosition(string sceneName)
    {
        if (GameState.LastScenePositions.ContainsKey(sceneName))
        {
            var lastPos = GameState.LastScenePositions[sceneName];
            return lastPos;
        }
        else
        {
            return Vector3.zero;
        }
    }

    public static void SetLastScenePosition(
        string sceneName, Vector3 position)
    {
        if (GameState.LastScenePositions.ContainsKey(sceneName))
        {
            GameState.LastScenePositions[sceneName] = position;
        }
        else
        {
            GameState.LastScenePositions.Add(sceneName, position);
        }
    }

void Awake()
{
    this.collider2D.enabled = false;
    var lastPosition =
      GameState.GetLastScenePosition(Application.loadedLevelName);

    if (lastPosition != Vector3.zero)
    {
        transform.position = lastPosition;
    }
}

void OnDestroy()
{
    GameState.SetLastScenePosition(
        Application.loadedLevelName, transform.position);
}

public static void NavigateTo(string destination)
{
    if (destination == "Home")
    {
        GameState.playerReturningHome = false;
    }
    FadeInOutManager.FadeToLevel(destination); 
}

We have our battle scene up and running, and when the player runs away he/she will still be at the place on the map where the battle occurred. Wouldn't it be nice to also enter the battle scene? So let's add that.

To keep things simple (you can always extend it later), we will just use a simple probability to work out whether the player is likely to enter a battle while travelling. If a battle is going to occur, we just figure out then where on the player's journey the battle will take place. This way it looks random and catches the player off guard when it happens (if it does, there's always a chance it won't).

So to start off, we will add a couple of extra parameters to control the battle event probability in the MapMovement script, as follows:

int EncounterChance = 100;
float EncounterDistance = 0;

Next, in the FixedUpdate method where we track when a player taps or clicks on the map to move, we check the probability of an event occurring. If that event occurs, then set the EncounterDistance property as follows to denote when the event will occur along the player's journey:

if (inputActive && Input.GetMouseButtonUp(0))
{
    StartLocation = transform.position.ToVector3_2D();
    timer = 0;
    TargetLocation =
     WorldExtensions.GetScreenPositionFor2D(Input.mousePosition);

    startedTravelling = true;

    //Work out if a battle is going to happen and if it's likely 
    //then set the distance the player will travel before it 
    //happens
    var EncounterProbability = Random.Range(1, 100);
    if (EncounterProbability < EncounterChance && 
        !GameState.playerReturningHome)
    {
        EncounterDistance = (Vector3.Distance(StartLocation,
        TargetLocation) / 100) * Random.Range(10, 100);
    }
    else
    {
        EncounterDistance = 0;
    }
}

We know that if an event occurs and when it does, all that is left is to act on it. So, in the Update method where we animate the player across the screen, we simply need an additional check to see whether we have travelled to the event and if so, stop and enter the battle. We can do so using the following code:

void Update()
{
    if (TargetLocation != Vector3.zero && TargetLocation !=
    transform.position && TargetLocation != StartLocation)
    {
        transform.position = 
            Vector3.Lerp(StartLocation, 
                TargetLocation, 
        MovementCurve.Evaluate(timer));
        timer += Time.deltaTime;
    }
    if (startedTravelling && Vector3.Distance(StartLocation,
        transform.position.ToVector3_2D()) > 0.5)
    {
        this.collider2D.enabled = true;
        startedTravelling = false;
    }

    //If there is an encounter distance, then a battle must occur. 
    //So when the player has travelled far enough, 
    //stop and enter the battle scene
    if (EncounterDistance > 0)
    {
        if (Vector3.Distance(StartLocation, 
            transform.position) > EncounterDistance)
        {
            TargetLocation = Vector3.zero;
            NavigationManager.NavigateTo("Battle");
        }
    }
}

Now that the player has left home, found some nasty goblins, and run away, it would be nice if he didn't encounter anymore until he next leaves home.

So using the additional flag playerReturningHome we set in the GameState class, we can set this in the battle manager when the player hits the button. We also then need to unset this when the player leaves home again. So, update the OnGUI method in the battle manager to set the playerReturningHome flag to true.

Then for the home scene, set the flag to false when the player leaves. This can be achieved by either editing an existing script in the home scene or adding a new one to change the flag state in the OnDestroy method mentioned earlier, or update the NavigationManager script to set the flag when the player travels home. It is your choice. In the sample code, I have added this to the NavigationManager script.

It is up to you and your game's design whether this is true for all battles or just for the first; it all depends on the style of the game you are building.