#smartenemy

Welcome to Part 4 in our series of developing a smart enemy character using Unity3D.

Here are links to the full series. 

1) Patrol their region and have some fun

2) Be self-aware and determine proximity to main player

3) Run to main player

4) Attack main player

5) Manage health & die beautifully

In this blog post we will cover how to create some fun weapons and attack our player. An enemy usually has one or more of these weapons: laser, bomb, sniper gun, arrow, sword, punch, etc.

For the purpose of this tutorial we will create few such weapons:

> A simple laser gun, and

> A bomb

> A rocket gun

Laser Guns are cool

Laser guns are created using a simple line renderer. 

All we need to do is create a straight line from the tip of the gun (aka muzzle) to the player position and if you draw it fast enough it will look like a laser. Here's roughly how we will draw that laser line. 

// Reference to the gun muzzle tip. private var muzzleTip : GameObject; ...... // Set the initial position of the line renderer to the tip of the gun. laserShotLine.SetPosition(0, muzzleTip.transform.position); // Set the end position of the player's position. laserShotLine.SetPosition(1, player.position); ......

Let's start by creating an image that will eventually be used to create the laser effect. 

1) Create a simple laser like gradient image as shown below using Photoshop (or similar tool), so that it looks similar to a star wars type laser as shown below

Dimensions: 32x32

Type: png

All you need to do is add a gradient with white in the middle

Here's a star wars robot shooting a laser, see the resemblance :)

Once the png file is ready simply drag it into your Assets folder. 

2) Next create a new material to hold the image we just created. 

This material will be used to shoot the laser. Let's start by applying the previously created png file to this material by clicking on "Select" and then picking the png texture that we created in Photoshop.

Once the texture is selected go ahead and save the project. 

3) Create an empty gameobject and call it "lasereffect". 

Then drag the material you just created and drop it on top of the "lasereffect" gameobject that we created in earlier step. 

4) Assign a "Light Renderer" component to the "LaserPreFab" game object 

5) Assign a "Line Renderer" component to the "LaserPreFab" game object

4) Next let's import a 3D laser gun (.fbx) file and drop it on your scene. For the purpose of this project I found one online and used it for the demo. Let's call this object, "lasergun".

5) Create an empty gameobject, let's call it "MuzzleTip".

Now position this muzzletip empty gameobject at the tip of your laser gun. You might need to use  [Ctrl +v] to move the empty gameobject so that you can easily snap the empty gameobject to the exact tip.

Now since we want the laser to shoot away from the gun and towards our player we probably need to adjust the MuzzleTip z-axis (shown in blue) pointing away from the gun in positive direction. 

Let's rotate the gamebject along it's y-axis by 270 deg. so that the z-axis are pointing outwards as shown below.

Then we can use the Transform.forward method to push our laser object and it will translate it along the z-axis as shown above. 

Transform.forward is short-form for Vector3(0, 0, 1).

6) Let's put the lasergun in our enemy's hand. 

Locate the enemy's hand and make the "lasergun" gameobject a child of the enemy's right hand. 

7) Next add a script to the "LaserPreFab" -- this is where we will detect mouse press and create an instance of the Let's put the lasergun in our enemy's hand. 

Locate the enemy's hand and make the "lasergun" gameobject a child of the enemy's right hand. 

#pragma strict public var muzzleTipTransform : Transform; public var laserPrefab: GameObject; function Update () { // Mouse was pressed, create laser if (Input.GetButton("Fire1")) { // create the laser instance var laserInstance:GameObject = Instantiate(laserPrefab); // position the laser at the muzzletip of the gun laserInstance.transform.position = muzzleTipTransform.position; } }

Let's summarize what we've completed so far:

a) We've got an enemy in our scene (called "enemy")

b) This enemy has a laser gun (called "lasergun")

c) We've marked the tip of the laser gun by placing an empty game object (called "muzzletip")

d) We will create the laser effect by using the gameobject (called "laserguneffect" which has a line renderer and light component attached to it

7) Finally attach an audio clip so that when the laser fires it plays an interesting audio clip. 

Start by importing the audio file into your Assets folder. 

Next click the LaserPreFab object and add a new component "Audio Source" to it.

Now drag the audio clip you just imported onto this component. 

8) Next create a new script and attach it to your "LaserPrefab" object.

#pragma strict public var speed = 5f; function Start () { } function Update () { // this will move the laser in the forward direction // as soon as it is instantiated transform.position += transform.forward * speed * Time.deltaTime; // this will destroy the gameobject in 2 seconds Destroy(gameObject, 2f); }

Rocket Guns are also fun

The mechanics of rocket gun are exactly the same as the laser gun. 

You would instantiate a rocket prefab at the muzzletip of the gun. 

Now because it is a rocket gun you could benefit by applying a rigidbody component to the prefab and let gravity act on it. 

public var rocketPrefab : Rigidbody; public var muzzleTipTransform : Transform; function Update () { if(Input.GetButtonDown("Fire1")) { var rocketInstance : Rigidbody; rocketInstance = Instantiate(rocketPrefab, muzzleTipTransform.position, muzzleTipTransform.rotation); rocketInstance.AddForce(muzzleTipTransform.forward * 5000); } }

This completes Part 4 of our tutorial series on creating an interesting game.

Welcome to Part 3 in our series of developing a smart enemy character using Unity3D.

Enemy characters play a very important role in any game. As a developer it is your responsibility to make them as smart as you possibly can. There are numerous AI packages available at the Unity store that can make your characters super smart. 

However, for the purpose of this article we will use simple code to make the enemy behave smartly. 

There are five aspects of a smart enemy. They should:

1) Patrol their region and have some fun

2) Be self-aware and determine proximity to main player

3) Run to main player

4) Attack main player

5) Manage health & die beautifully

We will dedicate an entire blog post for each aspect of creating an enemy. 

In this blog post we will cover how our enemy can chase our player. 

Chasing is achieved by rotating and moving our enemy character towards our player. This is similar to Part 1 of our blog series where we guided our enemy towards the next waypoint along the patrolling route using the character controller on the enemy object.

The only difference in this case is that if the player goes beyond a certain chase distance we will give up (i.e. if you want to play nice :)

Once the enemy stops chasing the player it will stop right there. In your final game you can have it return to the nearest waypoint and continue patrolling.

#pragma strict // The walking speed towards the player public var patrolSpeed : float = 6; // How slowly to turn public var dampingLook = 4; // declare a public variable for the player transform, so // that it can associate this with the player from the inspector public var playerTransform : Transform; // this defines when to stop chasing the player public var MaxChaseDistance:float = 25f; // this defines when to stop in front of the player public var StopChaseDistance:float = 3f; private var character : CharacterController; function Start(){ character = GetComponent(CharacterController); } function Update(){ chase(); } function chase(){ var playerPosition : Vector3 = playerTransform.position; // Keep waypoint at character's height playerPosition.y = transform.position.y; // Get the direction we need to move to // reach the next waypoint var moveDirection : Vector3 = playerPosition - transform.position; if(moveDirection.magnitude < StopChaseDistance) { Debug.Log("Player is close to the enemy, we can stop now"); } else { if (moveDirection.magnitude < MaxChaseDistance) { Debug.Log("Player is still within chasing distance - keep running after it"); // This code gets called every time update is called // while the enemy if moving towards the player. // so it gets called 100's of times in a few seconds // Now we need to do two things // 1) Start rotating in the desired direction // 2) Start moving in the desired direction // 1) Let's calculate desired rotation by looking at playerposition // and comparing with current position var desiredRotation = Quaternion.LookRotation(playerPosition - transform.position); // A slerp function allow us to slowly start rotating // towards our next waypoint transform.rotation = Quaternion.Slerp(transform.rotation, desiredRotation, Time.deltaTime * dampingLook); // 2) Now also let's start moving towards our waypoint character.Move(moveDirection.normalized * patrolSpeed * Time.deltaTime); } else { Debug.Log("Player is too far away - stop chasing"); } } }

Here's the completed project on github

Here's a video of the final program. 

Enemy characters play a very important role in any game. As a developer it is your responsibility to make them as smart as you possibly can. There are numerous AI packages available at the Unity store that can make your characters super smart. 

However, for the purpose of this article we will use simple code to make the enemy behave smartly. 

There are five aspects to consider in developing a smart enemy. They should:

1) Patrol their region and have some fun

2) Be self-aware and determine proximity to main player

3) Run to main player

4) Attack main player

5) Manage health & die beautifully

We will dedicate an entire blog post for each aspect of creating an enemy. 

This blog post will cover enemy patrolling. 

Patrol their region and have some fun

  Let's create a simple project so that we can demonstrate how patrolling works. 

Here are the steps:

a) Create a new Unity Project

b) Create an empty plane 

> Game Object -> Create Other -> Plane

Make it large enough to cover a playable area so that the enemy can move around

c) Next let's create our enemy character

> Game Object -> Create Other -> Cylinder

Now that you have a cylinder on the screen, position it so that it is visible from your view.

d) Next create a directional light so that you can view the cylinder in the plane. 

> Game Object -> Create Other -> Directional Light

This establishes the basic framework that we will use for our enemy character development.

The way patrolling works in most games is that the enemies mostly have a pre-defined path that they traverse in a loop. This keeps them looking alive and it gives them a chance to discover our player. It is also a good idea to give them some animation & audio clip so that they are fun to watch.

A pre-defined path is created by setting waypoints. Waypoints are simple GameObjects that are placed long the way, then a script is used to make the enemy rotate and move towards the next waypoint.

e) Let's start putting some waypoints. You can pick any object, even an empty gameobject would work, but since we are just learning let's use a spheres to create our waypoints, they will be easy to see from all angles.

> Game Object -> Create Other -> Sphere

Rename the sphere as "waypoint 1"

Copy the same sphere multiple times and place them around on the plane -- naming them "waypoint 2", "waypoint 3", "waypoint 4", etc.

Now you should have multiple waypoints on your screen and they are named correctly. 

f) Next add a character controller component to the enemy gameobject. This will help move the enemy gameobject along the waypoint route. 

> Click on Enemy > Inspector Panel

       > Add Component

       > Character Controller

g) Next create a new script and attach it to our enemy. 

Click on Enemy -> Assets -> Create -> Javascript

This will create a new script and attach it to our enemy. Let's rename this script and call it, "Waypoints"

This script will help traverse our enemy across the various waypoints. 

Let's start by creating a public variable that we will use to create an array of waypoints. 

#pragma strict // The list of Waypoint you want the enemy to traverse public var waypoint : Transform[];

The waypoints array is declared as a public variable so that you can associate the actual waypoint GameObjects with the script.

Next drag each waypoint and drop it on this variable in the Inspector Panel. 

Now you have all of these waypoints available to you in your javascript code. 

Next we need to figure out the direction we want the player to move. This is achieved by calculating a direction vector as shown below:

var nextWayPoint : Vector3 = waypoint[currentWaypoint].position; // Keep waypoint at character's height nextWayPoint.y = transform.position.y; // Get the direction we need to move to // reach the next waypoint var moveDirection : Vector3 = nextWayPoint - transform.position;

Once you have access to the direction you should start rotating and moving the enemy towards the new waypoint location. You should use Unity's slerp functions to move and rotate slowly towards the desired waypoint. 

// Now we need to do two things // 1) Start rotating in the desired direction // 2) Start moving in the desired direction // 1) Let' calculate rotation need to look at waypoint // by simply comparing the desired waypoint & current transform var rotation = Quaternion.LookRotation(nextWayPoint - transform.position); // A slerp function allow us to slowly start rotating // towards our next waypoint transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * dampingLook); // 2) Now also let's start moving towards our waypoint character.Move(moveDirection.normalized * patrolSpeed * Time.deltaTime);

Here's the complete code from the beginning:

#pragma strict // The list of Waypoint you want the enemy to traverse public var waypoint : Transform[]; // The walking speed between Waypoints public var patrolSpeed : float = 6; // Do you want to keep repeating the Waypoints public var loop : boolean = true; // How slowly to turn public var dampingLook = 4; // How long to pause at a Waypoint= 0; public var pauseDuration : float; private var curTime : float; private var currentWaypoint : int = 0; private var character : CharacterController; function Start(){ character = GetComponent(CharacterController); } function Update(){ if(currentWaypoint < waypoint.length){ patrol(); }else{ if(loop){ currentWaypoint=0; } } } function patrol(){ var nextWayPoint : Vector3 = waypoint[currentWaypoint].position; // Keep waypoint at character's height nextWayPoint.y = transform.position.y; // Get the direction we need to move to // reach the next waypoint var moveDirection : Vector3 = nextWayPoint - transform.position; if(moveDirection.magnitude < 1.5){ Debug.Log("enemy is close to nextwaypoint"); // This section of code is called only whenever the enemy // is very close to the new waypoint // so it is called once after 4-5 seconds. if (curTime == 0) // Pause over the Waypoint curTime = Time.time; if ((Time.time - curTime) >= pauseDuration){ Debug.Log("increasing waypoint"); currentWaypoint++; curTime = 0; } } else { Debug.Log("reaching in rotation " + moveDirection.magnitude); // This code gets called every time update is called // while the enemy if moving from point 1 to point 2. // so it gets called 100's of times in a few seconds // Now we need to do two things // 1) Start rotating in the desired direction // 2) Start moving in the desired direction // 1) Let' calculate rotation need to look at waypoint // by simply comparing the desired waypoint & current transform var rotation = Quaternion.LookRotation(nextWayPoint - transform.position); // A slerp function allow us to slowly start rotating // towards our next waypoint transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * dampingLook); // 2) Now also let's start moving towards our waypoint character.Move(moveDirection.normalized * patrolSpeed * Time.deltaTime); } }

The completed project for this post can be found here