Tower Shooting

To make the towers fire, I used a simple pursuit algorithm so that the bullets would always hit their intended target, similar to a homing missile. Each tower has a capsule collider attached to it. The collider has a height of 2, and a radius that is equal to that particular tower’s range. This collider is set as a Trigger, and has the following script attached to it.

var bullet : GameObject;
var shotsPerSecond : float = 1.0;
private var secondsSinceLastShot : float = 0.0;

function Update() {
    secondsSinceLastShot += Time.deltaTime;
}

function OnTriggerStay (enemy : Collider) {
    if(secondsSinceLastShot >= 1.0 / shotsPerSecond) {
        var newBullet = Instantiate(bullet,
            transform.position, Quaternion.identity);
        secondsSinceLastShot = 0.0;
        // Set the enemy for the bullet to home on
        newBullet.transform.GetComponent(BulletScript).enemy =
            enemy.gameObject;
    }
}

That script will cause each tower to create a new instance of its bullet type shotsPerSecond times every second.  Bullets are implemented as a Unity PreFab that contains a small sphere with the following script attached.  It is the pursuit algorithm.  You can set how many frames it takes for the bullet to hit its intended target, and then each frame it will move a fraction of the distance toward the enemy.

var enemy : GameObject;
var numFramesToHit : int = 40;
var damage : int = 4;
private var frames : int = 0;

function Update () {
    if(enemy && frames <= numFramesToHit) {
        var mult = 1.0 / (numFramesToHit - frames);
        var diff : Vector3 = mult * (transform.position -
          enemy.transform.position);
        transform.position = transform.position - diff;
        frames++;
    }
    if(frames == numFramesToHit) {
        enemy.transform.GetComponent(EnemyScript).hit(damage);
        // Destroy the bullet object
        Destroy(gameObject);
    }
}

Splash Damage

I implemented splash damage using a simple technique that involved an empty GameObject and a spherical collider.  Similar to the way a tower decides who to shoot.  When a player is hit by a bullet that causes splash damage, an invisible spherical collider is created at the player’s current location.  Then, any players who are in range of the collider will be dealt damage, and finally the collider will destroy itself after a single frame.

Status Effects

To implement a status effect, all you need is a simple boolean value to indicate whether an enemy is affected, and a timer to keep track of the effect’s duration.  Make sure to have a separate boolean and timer for each type of status effect so that enemies can be slowed down and on fire at the same time!

if(aflame) {
    if(fireEffectTime < maxFireEffectTime) {
        health -= 1;
        fireEffectTime++;
    }
    else {
        aflame = false;
        fireEffectTime = 0;
    }
}

That’s all for today.  I may need to rework the damage code a bit when I start making the towers upgradable, but it’s working great for now.  Screen shots will be coming soon once we get to a post that actually has something interesting to look at.

It’s been one day and the game is still on schedule!  This series of posts will be a detailed tutorial on creating a tower defense style game using the Unity engine.  Today, I completed the first few steps:

• Design
• Title Screen / Menus
• In Game GUI
• Enemies Follow Paths
• Player can Place Towers on Grid

Design

The game will be a standard tower defense game with towers and enemies based on different elements.  I slightly altered the elemental types from Pokemon for this game.  There will be 6 different types: normal, flying, fire, water, rock, and ghost.  Each enemy can be more susceptible to, more armored against, or totally immune to the different tower types.

The towers will each have different firing speeds, ranges, and damage amounts.  Some towers will also have a special ability such as splash damage.  Each tower can be repeatedly upgraded, increasing its stats by 10-50% per upgrade.  The following table lists the stats of each level 1 tower, along with its special ability.

The enemies also have specialized stats including health and speed.  The stats will increase by 3-5% per level.

The simulation part of the game comes in choosing the enemies that will attack each level.  The first 3 levels consist of a group of 20 enemies of the same type.  Level 1 is a group of normal enemies, followed by fire enemies in the second level, and then rock enemies.  The following rounds will consist of 20 enemies that are randomly chosen by an AI script.  At the beginning of each round, the script will simulate how the player would fare against 10 different randomly chosen groups of enemies.  These groups will be ranked by the player’s performance, and then the one chosen will depend on the difficulty setting.

Title Screen

Unity now has a GUI class that helps you create GUIs quickly and easily.  I made all of the GUI objects sizes relative to the screen resolution, so that the GUI will be proportionally similar on every player’s screen.  In an RPG or action/adventure type game, you may not want to do this.  Instead you could have all GUI elements be fixed width/height, and then if someone has a higher resolution, they can see more of the in game graphics because the GUI elements take up less screen real estate.

The following is a simple example that creates a box with two buttons inside of it in the middle of the screen.

function OnGUI () {
    var w : int = Screen.width;
    var h : int = Screen.height;
    GUI.Box (Rect (w / 3, h / 2, w / 3, h / 6 + 30), "");
    if(GUI.Button (Rect (w / 3 + 10, h / 2 + 10, w / 3 - 20, h / 12),
        "New Game")) {
        Application.LoadLevel (1);
    }
    if (GUI.Button (Rect (w / 3 + 10, 7 * h / 12 + 20, w / 3 - 20, h / 12),
        "Help")) {
        Application.LoadLevel (2);
    }
}

Path Following

Since the enemies in my game walk along a very simple path, I was able to come up with a simple solution that relies on triggers placed along the path.  Each enemy will have a velocity set on its rigidbody component, and will walk in a straight line.  Each corner on the path will have a capsule collider that is tagged either “Left” or “Right.”  This collider is set as a trigger so that the physics engine will report collisions, but ignore calculating interactions based on that collision.  The following piece of code will cause the enemies to turn properly based on the trigger’s tag when they run into it.

function OnTriggerEnter (other : Collider) {
    var oldZ = rigidbody.velocity.z;
    if(other.tag == "Right") {
       rigidbody.velocity.z = -rigidbody.velocity.x;
       rigidbody.velocity.x = oldZ;
    }
    else if(other.tag == "Left") {
       rigidbody.velocity.z = rigidbody.velocity.x;
       rigidbody.velocity.x = -oldZ;            
    }
}

Tower Placement

Placing towers involves converting mouse co-ordinates into 3D world co-ordinates.  This is not an intuitive thing to do.  At first, I tried just using the X and Y values reported by the mouse location.  This doesn’t work at all.  Instead, I found that you should cast a ray from the camera’s location, through the mouse’s location.  Then, you have a plane with an upward normal located at Z=0.  You calculate where the casted ray intersects with this plane, and that is the location that you should use as your 3D mouse location.  The following code will do this for you.

// Generate a plane that intersects the transform's
// position with an upwards normal.
var playerPlane = new Plane(Vector3.up, transform.position);

// Generate a ray from the cursor position
var ray = Camera.main.ScreenPointToRay (Input.mousePosition);

var hitdist = 0.0;

// If the ray is parallel to the plane, Raycast will
// return false. Otherwise, it sets hitdist to the
// distance along the ray that it intersects the plane
if (playerPlane.Raycast (ray, hitdist)) {
    // Get the point along the ray at the calculated distance.
    var targetPoint = ray.GetPoint(hitdist);
    transform.position = Vector3(Mathf.Round(targetPoint.x),
      Mathf.Round(targetPoint.y), Mathf.Round(targetPoint.z));
}

I have a final project due in Simulation class after the Thanksgiving break, so in the next 10 days I’ll be making a fully functioning tower defense strategy game that uses simulation techniques to randomly generate enemy groups according to a player’s difficulty setting and current progress. The project will be developed in Unity, and there will be a daily post detailing my progress.

Drop by all next week to see how quickly a game prototype can be developed in Unity. Each post will contain screen shots of the game’s progress, and the final post will contain a YouTube trailer demonstrating game play.  Here’s a quick run down of my goals for each day:

1. Saturday
   • Game Design
   • Rough Graphics – Splash Screen & Menus
   • Rough Graphics – In Game GUI
   • Enemies (Colored Spheres) Follow Designated Paths
   • Player can Place Selected Tower (Cones) On Grid
2. Sunday
   • Towers Shoot at Enemies in Range
   • Splash Damage
   • Slowing Damage
   • Fire Damage
   • Rock Enemies Actually Split
3. Monday
   • 1st 3 Levels Have Proper Groups
   • Add Particle Effects and Lighting to Fire
   • Implement Monetary System
4. Tuesday
   • Towers are Upgradeable
   • Enemies Get Stronger Each Level
   • Fire Enemies Special Ability Working
5. Wednesday
   • Improve GUI Graphics
   • Begin Simulation AI
6. Thursday
   • Continue Simulation AI
   • Improve Tower Graphics
7. Friday
   • Finish Simulation AI
   • Boss Levels
   • Improve Bullet Graphics
   • Improve Level Graphics
8. Saturday
   • Improve Enemy Graphics
9. Sunday
   • Continue Graphics & Animation Work
10. Monday
    • Finalize Graphics
    • Final Testing
    • YouTube Demo Video
    • Playable Web Version??
    • Fake Marketing on Site