Game Devs Unleash Artificial Intelligence: Flocking Agents

Carefully and analytically observe our Earthly flocking birds in their natural habitat

Homework: You must write at least 6 observations

1. They repeatedly separate and combine...like quicksilver
2. They move like a wave or a fluid

Questions Answers Insights

Why do you think some birds fly together?

Their movement seems orchestrated somewhat. Does each bird have a sheet music telling it where to go?

Does this behavior seem completely random or do some patterns exist?

Can you think of other animals that are not birds but still "flock" as well?

Relevant questions for our hypothesis:

Does a bird look at all the other birds or just at a few of its nearby neighbors?

Do birds bump into each when they fly or are they separated?

Do birds in the same group or cluster fly in the same direction and with an approximately same speed?

Scientific method:

1. Have a Problem
2. Gather Relevant Data
3. Formulate Hypothesis
4. Empirically Test

1. Neighborhood radius = abstraction of vision / interest radius
2. Cohesion Behavior = form a whole
3. Separation Behavior = avoid collisions
4. Alignment Behavior = match heading and speed to stay in the flock
5. Combine all Behaviors in different proportions

Structure our Project in a simple text file using Pseudocode

class Agent{

1. position vector2 or vector3
2. rotation vector or quaternion
3. velocity
4. acceleration
5. world reference

• void update(float t)
• void render()
• Vector cohesion() // cohesion behavior
• Vector separation()
• Vector alignment()
• Vector combine() // combine behaviors

}

class World{

1. List<Agent> agents

• void init(int n)
• void update(float t)
• List<Agent> getNeighbors(Agent agent, float radius)// neighbors of agent inside radius

}

class AgentConfig{

1. float maxV// maximum velocity
2. float maxA
3. float Rc, Rs, Ra
4. float Kc, Ks, Ka

}

Create a new project in Unity

Write a simple Move script

Add script statically or dynamically to object

Prefabs in Unity = template, blue print

Agent

World

AgentConfig

Spawn Function

Equations of motion

time

acceleration

velocity

position

trucate acceleration

trucate velocity

Euler forward integration

Rocket science

Stable integration methods, Runge-Kutta

Unity uses the metric system

Go towards the center of mass of all nearby neighbors

Vector cohesion(){

1. // cohesion behavior
2. // return a vector that will steer our curent velocity
3. // towards the center of mass of all nearby neighbors
4. // get all my nearby neighbors inside radius Rc of this current agent
5. // no neighbors means no cohesion desire
6. // find the center of mass of all neighbors
7. // steer our velocity towards the COM
8. // make r have the length 1

}

Individual separation forces combine to give the resultant force

Vector separation(){

1. // separation behavior
2. // steer in the opposite direction from each of our nearby neigbhors
3. // get all my neighbors
4. // no neighbors no separation desire
5. // add the contribution of each neighbor towards me
6. // force contribution will vary inversly proportional
7. // to distance or even the square of the distance

}

Match heading and speed in order to stay withing the flock

Update Prefab

Warning!

Tokyo Drift

LookAt function

Vector alignment(){

1. // alignment behavior
2. // steer agent to match the direction and speed of neighbors
3. // get all neigbhors
4. // no neighbors means no one to align to
5. // match direction and speed == match velocity
6. // do this for all neighbors

}

Combine all forces at the same time in different proportions

Wrap around to keep inside the view

Structure problem

Update loop, Euler integration

Pseudocode + Unity = perfect match, best learning

Cohesion, Separation, Alignment

Tweek Parameters

Ideas=Lines of Code=Simulation

Think it! Build it!

Emergence, split, merge, dance

Complex->Pieces->Recombine

Playground to experiment aspects of Flocking

360 degrees default

180 degrees realistic

angle between 2 vectors

add the refinement to all behaviors

They move closely together

They are moving like a wave

A solo creature or a small flock that wanders purposefully on the map

Jitter vs Smooth = Dumb vs Purpose

Generate a small random target that moves on a circle in from of the agent

Project the target from local space to world space

Update prefab to have a Default Transform

Warning ! the transform scale influences the projection from local space to world space

Extend the Agent Class to make a Predator Class

Avoid Enemies Behavior

Flee Behavior

GetPredators Function

https://aiception.com/ deep learning platform that offers AI as a service

http://www.aicrafters.com/ educational Artificial Intelligence courses