Computer Game Development and Design 2020/21 fall

Tower Defence Game - 3 weeks

Watch the lab Video

This lab is split up over three weeks.

• Lab 6 we will set up most of the basic game mechanics and learn about tile based levels.
• Lab 7 we will focus on creating a functional UI and building mechanics.
• Lab 8 we learn about creating content and balancing the game.

By the end of the three weeks, you should have a minimal functional tower defense game. Should you find the flow too easy or you wish to challenge yourself more, then you are strongly encouraged to try out completing the extra tasks as well. Many of the techniques learned here will also be applicable to RTS games, as TD is very much a simplified RTS subgenre.

Lab 6

All tasks should be completed before the end of lab 7. The work has to be submitted after all 3 practices are completed.

Step 1. Setting up the project

1. Create a new 2D Unity project
2. First, we are going to need tiles. You can make your own tileset, find one, or use one of the following recommended ones:
   • https://kenney.nl/assets/medieval-rts
   • https://kenney.nl/assets/sci-fi-rts
3. Create a graphics folder and import the tiles from the asset pack.
4. Select all the images and set the pixels per unit to match the edge of the tile in pixels. For recommended packs, this is 64.

Step 2. Creating the first level.

We are going to use a new Unity feature called tilemaps for this. The usage of this will be presented in practice. Should you be unable to attend, then you check out the manual or tutorial videos on how to use this.

Unity live training on tilemaps:

• https://unity3d.com/learn/tutorials/topics/2d-game-creation/core-tilemap-concepts?playlist=17093
• There are many great tutorials from content creators on Youtube for this as well.

Once you are finished with the level layout, your map should have:

• A spawn structure where the opponents will appear at. One is required minimally, but you can have more if you wish.
• A base structure the player has to defend.
• A long winding road between the spawn points and the target.

Step 3. Making things move.

For the level itself we used tile based graphics, but that does not mean that our movement logic has to do that. Instead, we will take a more simplified approach that you can also apply to non tile based levels. Our goal is to create two scripts:

• A Waypoint script that we can use to create a path.
• A WaypointFollower script that can make gameobjects move along a path of waypoints.

Waypoint

1. Create a new empty gameobject and call it Waypoint
2. Create and add a new script called Waypoint.
3. In Inspector window set an icon for the gameobject. Click on the thing to the left of the name to open the icon selection box.
4. Turn the gameobject into a prefab.
5. Add GetNextWaypoint method to the waypoint script. The return type should be waypoint.
6. Add a public variable Next of the type Waypoint to the script.
7. Extra: Turn the public variable into a list of waypoints to make it possible for enemies to split to multiple roads.
8. Copy the code down below to your script to better visualize the path. The variable next should match with the name you used in step 6.
9. Place the waypoint prefabs to your scene to create a path from spawn to the goal.
10. NB: Always keep your scene hierarchy organized! Add a common parent object for all the waypoints.

    void OnDrawGizmos()
        {
            if (Next == null) return;
            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(transform.position, Next.transform.position);
        }

WaypointFollower

1. Pick a character sprite from the assets and drag it into the scene.
2. Fix the name of the gameobject.
3. If the sprite isn't properly visible on your terrain then fix the layering order.
4. Add a RigidBody2D component and set its type to kinematic.
5. Create and add a WaypointFollower script.
6. Turn the gameobject into a prefab.
7. Implement the WaypointFollower script:
   1. Add a public Waypoint field for the follower to move towards.
   2. Add a public float field speed to set movement speed.
   3. In the Update method, move the game object towards the waypoint.
   4. In the Update method, if you reach a waypoint, then set a new one using the GetNextWaypoint method.
   5. Add error checking, so the code does not throw exceptions when the waypoint is missing.
   6. Extra: Also change the rotation of your waypoint follower when a waypoint is reached. This is only applicable to top-down sprites!
   7. Add a public static int counter to the script to keep track of how many opponents there are in the game. Increase this counter in Start() and decrease it in OnDestroy()
8. Run your game and test the movement functionality.

Step 4. Spawning enemies

1. Select the first waypoint at the start of the path.
2. Create and add a new Spawn script to it.
3. Rename the GameObject to Spawn.
4. Break the gameobjects link to the current prefab. (GameObject>Unpack Prefab)
5. Turn the gameobject into a new prefab.
6. Modify the Spawn script:
   1. Add a public field for WaypointFollower prefab.
   2. Add public fields for configuration: the number of opponents per wave, time between spawns in a wave, time between waves.
   3. Use private fields to keep track of current spawning status.
   4. In the Update instantiate new enemies until all the enemies for the current wave are spawned.
   5. When instantiating an enemy, set the waypoint to the one attached to the spawn gameobject itself.
   6. Create a public method StartNextWave. Use this to reset all necessary variables.
7. Run the game test it. At this stage, all enemies of a single wave should be spawned and piled up on the last waypoint.

Step 5. Removing enemies

1. Select the last waypoint and name it Base. This will be the object attackers are trying to get to. You can also use a more descriptive name based on your game design or assets.
2. Break the current waypoint prefab instance and create a new one.
3. Add a CircleCollider2D component and set it as trigger.
4. Add a CircleCollider2D component to the enemy prefab. (Waypoint followers)
5. Add a new Base script.
6. Implement the OnTriggerEnter2D method.

    private void OnTriggerEnter2D(Collider2D collision)
    {
        // Check if the collision is with a waypoint follower
        // Destroy the waypoint follower
        // This is also a good place to update the score, but this is a topic for the next lab.
    }

Step 6. Defending with towers.

We will skip the building mechanic for the moment and return to it in the next session. The goal of this session is to have working towers that attack enemies. While the player is not able to build them just yet, you should place them in the scene manually and verify that they do indeed work.

Making units attackable

1. Create a new script named Health.
2. Add the script to WaypointFollower prefab.
3. Add variables to be able to configure the starting health of the unit from the editor and to keep track of the current hp.
4. Add a public Damage method to damage the health value.
5. Destroy the gameobject when health reaches 0.

Targeting enemies

1. Create a new tower prefab. It should have a sprite and a proper name.
2. Add a CircleCollider2D component.
3. Set it as a trigger. This will be the attacking range of the tower. Modify the size accordingly.
4. Add a Tower script and modify it:
   1. Add a public list of type Health to keep track of enemies in range.
   2. Add the methods OnTriggerEnter2D and OnTriggerExit2D to keep track of enemies that are in range.
   3. Test the tower. Any targets currently in range of the tower have to be showing up in the public list visible from the editor.

Next, we need to create a firing method, but before we can get to that, we will need to create something to fire with first. This brings us to projectiles.

Projectiles

1. Create a projectile prefab.
2. Add a new script Projectile to the prefab:
   1. Create public fields for the damage and speed values of this projectile.
   2. Create a public transform field for the target of this projectile.
   3. In the update method make the projectile move towards the target. This is similar to WaypointFollower done earlier.
   4. In the update method, destroy the projectile when it reaches the target. Also, inflict any damage it should do to the health script.

Attacking enemies

1. Add configurable fields for damage, projectile speed, and cooldown.
2. You may also need a private field to keep track of the cooldown later.
3. Create a private Fire method that can instantiate a projectile and set its target.
4. In update method:
   1. Check if it is time to attack.
   2. Pick a target from the targets list.
   3. Use the Fire method to attack the selected target.
   4. Add error handling so that there are no null reference exceptions.
5. Test your game with towers added to the level.
6. This is the end of part 1.