Before writing the script for our player's tank, let's take a look at how we set up the PlayerTank game object. Our Tank object is a simple Mesh with the Rigidbody and Box Collider components. The Tank object is composed of two separate meshes, Tank and Turret, such that Turret is a child of Tank. This structure allows for the independent rotation of the Turret object using the mouse movement and, at the same time, will follow automatically the Tank body wherever it goes. Then, we create an empty game object for our SpawnPoint transform. We use it as a reference position point when shooting a bullet. Finally, for the player's Tank, we need to assign the Player tag to our Tank object. Now let's take a look at the controller class:

The player's Tank is controlled by the PlayerTankController class. We are using the...

Next, we set up our Bullet prefab with two orthogonal planes using a laser-like material and a Particles/Additive property in the Shader field:

The code in the Bullet.cs file is as follows:

using UnityEngine; 
using System.Collections; 
 
public class Bullet : MonoBehaviour 
{ 
    //Explosion Effect
    [SerializeField]
    private GameObject Explosion; 
    [SerializeField]
    private float Speed = 600.0f;
    [SerializeField]
    private float LifeTime = 3.0f; 
    
    public int damage = 50; 
 
    void Start() 
    { 
      Destroy(gameObject, LifeTime); 
    } 
 
    void Update() 
    { 
      transform.position +=  
      transform.forward * Speed * Time.deltaTime; 
    } 
 
    void OnCollisionEnter(Collision collision) 
    { 
      ContactPoint contact = collision.contacts[0]; 
      Instantiate(Explosion, contact.point,  
      Quaternion...

Next, we will put four Cube game objects at random places. They represent waypoints inside our scene and, therefore, we name them WandarPoints:

Here is what our WandarPoint object will look like:

Note that we need to tag those points with a tag called WandarPoint. Later, we use this tag when we try to find the waypoints from our tank AI. As you can see in its properties, a waypoint is just a Cube game object with the Mesh Renderer checkbox disabled, and the Box Collider object removed.

We could even use an empty object with a gizmo icon since all we need from a waypoint is its position and the transformation data. However, we're using the Cube objects here so that waypoints are easier to visualize.

Next, we implement a generic abstract class to define the methods that our enemy tank AI class has to implement.

The code in the FSM.cs file is as follows:

using UnityEngine; 
using System.Collections; 
 
public class FSM : MonoBehaviour  
{ 
    //Player Transform 
    protected Transform playerTransform; 
 
    //Next destination position of the NPC Tank 
    protected Vector3 destPos; 
 
    //List of points for patrolling 
    protected GameObject[] pointList; 
 
    //Bullet shooting rate 
    protected float shootRate; 
    protected float elapsedTime; 
 
    //Tank Turret 
    public Transform turret { get; set; } 
    public Transform bulletSpawnPoint { get; set; } 
 
    protected virtual void Initialize() { } 
    protected virtual void FSMUpdate() { } 
    protected virtual void FSMFixedUpdate() { } 
 
    // Use this for initialization 
    void...

Let's look at the real code for our AI tanks. Let's create a new class, called SimpleFSM, which inherits from our FSM abstract class.

The code in the SimpleFSM.cs file is as follows:

using UnityEngine; 
using System.Collections; 
 
public class SimpleFSM : FSM  
{ 
 
    public enum FSMState 
    { 
      None, 
      Patrol, 
      Chase, 
      Attack, 
      Dead, 
    } 
 
    //Current state that the NPC is reaching 
    public FSMState curState; 
 
    //Speed of the tank 
    private float curSpeed; 
 
    //Tank Rotation Speed 
    private float curRotSpeed; 
 
    //Bullet 
    [SerializeField]
    private GameObject Bullet; 
 
    //Whether the NPC is destroyed or not 
    private bool bDead; 
    private int health; 

    // We overwrite the deprecated built-in `rigidbody` variable.
    new private Rigidbody rigidbody;

Here, we declare a few...

The FSM framework we're going to use here is adapted from the C# FSM framework, which can be found at https://wiki.unity3d.com/index.php?title=Finite_State_Machine. That framework is again a part of the Deterministic Finite State Machine framework, based on Chapter 3.1 of Game Programming Gems 1, by Eric Dybsend. We'll only be looking at the differences between this FSM and the one we made earlier. The complete FSM can be found with the assets that come with the book. We'll now study how the framework works and how we can use it to implement our tank AI.

AdvanceFSM and FSMState are the two main classes of our framework. Let's take a look at them first.

The AdvanceFSM...

In this chapter, we learned how to implement state machines in Unity3D based on a simple tank game. We first looked at how to implement FSM in the most direct way by using the switch statements. Then we studied how to use a framework to make the AI implementation easier to manage and extend.

In the next chapter, we will take a look at randomness and probability, and see how we can use it to make the outcome of our games more unpredictable.