Predator and Prey
Implementing a Predator Brain
We want the predators to do the following:
1. Find the nearest not-stunned prey and chase it and stun it.
2. Avoid Obstacles along the way
3. Not run into other predators
We implement helper methods in a new file called NavUtils.py:
findNearestUnstunned(team) : Find's the nearest not-stunned agent in the provided team
getObstacleAvoidance(obstacles) : Uses the "Field" technique in BOIDS algorithm to provide a vector which points away from the obstacle, this vector grows as the agent gets closer to the obstacle.
getTeamAvoidance(team) : To avoid members ob my own team, checks in a specific radius around agent and returns a vector which makes the agent move away.
total movement = 1.5*stunMovement + 0.5*avoidObstacleMovement + 0.5*avoidTeamMovement
We then implement the following predator brain:
from Agent import Agent from Ball import Ball from Obstacle import Obstacle from LinearAlegebraUtils import * import numpy as np from Action import Stun, Kick import random from NavUtils import getObstacleAvoidance, findNearestUnstunned, getTeamAvoidance class PredatorBrain(object): ''' classdocs ''' def __init__(self): pass def takeStep(self, myTeam=, enemyTeam=, balls=, obstacles=): actions =  deltaPos = np.array([1, 0, 0]) nearestUnstunnedAgent = findNearestUnstunned(enemyTeam) stunMovement = array([0, 0, 0]) if nearestUnstunnedAgent.isStunned: stunMovement = array([0, 0, 0]) else: stunMovement = nearestUnstunnedAgent.position avoidObstacleMovement = getObstacleAvoidance(obstacles) avoidTeamMovement = getTeamAvoidance(myTeam) movement = normalize(1.5*stunMovement + 0.5*avoidObstacleMovement + 0.5*avoidTeamMovement) deltaRot = getYPRFromVector(movement) actions.append(Stun(nearestUnstunnedAgent, 5)) return deltaPos, deltaRot, actions
After calculating the weighted sum of the various movements, we tell the agent to rotate and align with the required movement.
Implementing a Prey Brain
We want prey agents to to be restricted so that they do not run away indefinitely outside of the world bounds.
To do this we use a different type of agent called RestrictedAgent, this agents constructor also accepts distance, if the restricted agent goes farther than this distance from the world origin it will stop moving.
We want prey to obey the following rules:
1. Run away from nearest predator
2. Avoid Obstacles
3. Avoid hitting the virtual boundary and turn when you get close two it.
We implement two additional helper methods in NavUtils.py:
getTeamNearestAvoidance(team) : Returns a vector which points away from the nearest agent in team, this vector grows as the nearest agent gets closer
getRestrictionField(originObject, restrictionRange) : Creates a vector what pushes the agent away as it get closer to the restriction range, it needs an object placed at the origin and the restriction range.
Using the above helper methods, we implement the following prey logic.
from Agent import Agent from Ball import Ball from Obstacle import Obstacle from LinearAlegebraUtils import getYPRFromVector import numpy as np from Action import Stun, Kick from NavUtils import getObstacleAvoidance, getTeamNearestAvoidance, getRestrictionField class PreyBrain(object): ''' classdocs ''' def __init__(self): pass def takeStep(self, myTeam=, enemyTeam=, balls=, obstacles=): actions =  deltaPos = np.array([1, 0, 0]) avoidMovement = getObstacleAvoidance(obstacles) avoidEnemyMovement = getTeamNearestAvoidance(enemyTeam) fenceAvoidMovement = getRestrictionField(obstacles, 200) movement = 1.5*avoidMovement + 2.0 * avoidEnemyMovement + 1.5*fenceAvoidMovement deltaRot = getYPRFromVector(movement) return deltaPos, deltaRot, actions
Similar to predator, we implement a weighted sum of the various rules and instruct the agent to rotate according to the movement.
If we use the above brains, with restricted agents with restriction range of 200. We get the following result.