Book Image

Unity 5.x Game AI Programming Cookbook

By : Jorge Palacios
5 (1)
Book Image

Unity 5.x Game AI Programming Cookbook

5 (1)
By: Jorge Palacios

Overview of this book

Unity 5 comes fully packaged with a toolbox of powerful features to help game and app developers create and implement powerful game AI. Leveraging these tools via Unity’s API or built-in features allows limitless possibilities when it comes to creating your game’s worlds and characters. This practical Cookbook covers both essential and niche techniques to help you be able to do that and more. This Cookbook is engineered as your one-stop reference to take your game AI programming to the next level. Get to grips with the essential building blocks of working with an agent, programming movement and navigation in a game environment, and improving your agent's decision making and coordination mechanisms - all through hands-on examples using easily customizable techniques. Discover how to emulate vision and hearing capabilities for your agent, for natural and humanlike AI behaviour, and improve them with the help of graphs. Empower your AI with decision-making functions through programming simple board games such as Tic-Tac-Toe and Checkers, and orchestrate agent coordination to get your AIs working together as one.
Table of Contents (15 chapters)
Unity 5.x Game AI Programming Cookbook
Credits
About the Author
About the Reviewers
www.PacktPub.com
Preface
Index

Avoiding agents


In crowd-simulation games, it would be unnatural to see agents behaving entirely like particles in a physics-based system. The goal of this recipe is to create an agent capable of mimicking our peer-evasion movement.

Getting ready

We need to create a tag called Agent and assign it to those game objects that we would like to avoid, and we also need to have the Agent script component attached to them.

An example of how should look the Inspector of a dummy agent to avoid

How to do it...

This recipe will require the creation and handling of just one file:

  1. Create the AvoidAgent behavior, which is composed of a collision avoidance radius and the list of agents to avoid:

    using UnityEngine;
    using System.Collections;
    using System.Collections.Generic;
    
    public class AvoidAgent : AgentBehaviour
    {
        public float collisionRadius = 0.4f;
        GameObject[] targets;
    }
  2. Implement the Start function in order to set the list of agents according to the tag we created earlier:

    void Start ()
    {
        targets = GameObject.FindGameObjectsWithTag("Agent");
    }
  3. Define the GetSteering function:

    public override Steering GetSteering()
    {
        // body
    }
  4. Add the following variables to compute distances and velocities from agents that are nearby:

    Steering steering = new Steering();
    float shortestTime = Mathf.Infinity;
    GameObject firstTarget = null;
    float firstMinSeparation = 0.0f;
    float firstDistance = 0.0f;
    Vector3 firstRelativePos = Vector3.zero;
    Vector3 firstRelativeVel = Vector3.zero;
  5. Find the closest agent that is prone to collision with the current one:

    foreach (GameObject t in targets)
    {
        Vector3 relativePos;
        Agent targetAgent = t.GetComponent<Agent>();
        relativePos = t.transform.position - transform.position;
        Vector3 relativeVel = targetAgent.velocity - agent.velocity;
        float relativeSpeed = relativeVel.magnitude;
        float timeToCollision = Vector3.Dot(relativePos, relativeVel);
        timeToCollision /= relativeSpeed * relativeSpeed * -1;
        float distance = relativePos.magnitude;
        float minSeparation = distance - relativeSpeed * timeToCollision;
        if (minSeparation > 2 * collisionRadius)
            continue;
        if (timeToCollision > 0.0f && timeToCollision < shortestTime)
        {
            shortestTime = timeToCollision;
            firstTarget = t;
            firstMinSeparation = minSeparation;
            firstRelativePos = relativePos;
            firstRelativeVel = relativeVel;
        }
    }
  6. If there is one, then get away:

    if (firstTarget == null)
        return steering;
    if (firstMinSeparation <= 0.0f || firstDistance < 2 * collisionRadius)
        firstRelativePos = firstTarget.transform.position;
    else
        firstRelativePos += firstRelativeVel * shortestTime;
    firstRelativePos.Normalize();
    steering.linear = -firstRelativePos * agent.maxAccel;
    return steering;

How it works...

Given a list of agents, we take into consideration which one is closest, and if it is close enough, we make it so the agent tries to escape from the expected route of that first one according to its current velocity so that they don't collide.

There's more

This behavior works well when combined with other behaviors using blending techniques (some are included in this chapter); otherwise it's a starting point for your own collision avoidance algorithms.