I have a great AI script which I got from these forums.
I really want to keep using it but when I add a box collider it seems to make it twitch in random directions and when rotating it makes it do all sorts of spins and flips.
I need the collider to be able to use OnTriggerEnter for my melee combat. Has anyone come across this kind of problem before?
The enemy already has a rigidbody and charactercontroller attached. Is there anyway to get around this problem?
SimpleAIBehaviourScript
Code
/*
Copyright 2010 Black Storms Studios, LLC.
@Author - Rob Pearson
@Date - November 2010
@Contact - RIPearson@BlackStormsStudios.com
@Script -
@Connections - requires CharacterController attached to enemy.
@TODO -
*/
using UnityEngine;
using System.Collections;
public class SimpleEnemyAIBehavior : MonoBehaviour {
//Inspector initiated variables. Defaults are set for ease of use.
public bool on = true; //Is the AI active? this can be used to place pre-set enemies in you scene.
public bool canFly = false; //Flying alters float behavior to ignore gravity. The enemy will fly up or down only to sustain floatHeight level.
public float floatHeight = 0.0f; //If it can fly/hover, you need to let the AI know how high off the ground it should be.
public bool runAway = false; //Is it the goal of this AI to keep it's distance? If so, it needs to have runaway active.
public bool runTo = false; //Opposite to runaway, within a certain distance, the enemy will run toward the target.
public float runDistance = 25.0f; //If the enemy should keep its distance, or charge in, at what point should they begin to run?
public float runBufferDistance = 50.0f; //Smooth AI buffer. How far apart does AI/Target need to be before the run reason is ended.
public int walkSpeed = 10; //Standard movement speed.
public int runSpeed = 15; //Movement speed if it needs to run.
public int randomSpeed = 10; //Movement speed if the AI is moving in random directions.
public float rotationSpeed = 20.0f; //Rotation during movement modifier. If AI starts spinning at random, increase this value. (First check to make sure it's not due to visual radius limitations)
public float visualRadius = 100.0f; //How close does the player need to be to be seen by the enemy? Set to 0 to remove this limitation.
public float moveableRadius = 200.0f; //If the player is too far away, the AI will auto-matically shut down. Set to 0 to remove this limitation.
public float attackRange = 10.0f; //How close does the enemy need to be in order to attack?
public float attackTime = 0.50f; //How frequent or fast an enemy can attack (cool down time).
public int stopAttackRange = 2;
public bool useWaypoints = false; //If true, the AI will make use of the waypoints assigned to it until over-ridden by another functionality.
public bool reversePatrol = true; //if true, patrol units will walk forward and backward along their patrol.
public Transform[] waypoints; //define a set path for them to follow.
public bool pauseAtWaypoints = false; //if true, patrol units will pause momentarily at each waypoint as they reach them.
public float pauseMin = 1.0f; //If pauseAtWaypoints is true, the unit will pause momentarily for minmum of this time.
public float pauseMax = 3.0f; //If pauseAtWaypoints is true, the unit will pause momentarily formaximum of this time.
public float huntingTimer = 5.0f; //Search for player timer in seconds. Minimum of 0.1
public bool estimateElevation = false; //This implements a pause between raycasts for heights and guestimates the need to move up/down in height based on the previous raycast.
public float estRayTimer = 1.0f; //The amount of time in seconds between raycasts for gravity and elevation checks.
public bool requireTarget = true; //Waypoint ONLY functionality (still can fly and hover).
public Transform target; //The target, or whatever the AI is looking for.
//private script handled variables
private bool initialGo = false; //AI cannot function until it is initialized.
private bool go = true; //An on/off override variable
private Vector3 lastVisTargetPos; //Monitor target position if we lose sight of target. provides semi-intelligent AI.
CharacterController characterController; //CC used for enemy movement and etc.
private bool playerHasBeenSeen = false; //An enhancement to how the AI functions prior to visibly seeing the target. Brings AI to life when target is close, but not visible.
public bool enemyCanAttack = false; //Used to determine if the enemy is within range to attack, regardless of moving or not.
public bool enemyIsAttacking = false; //An attack interuption method.
private bool executeBufferState = false; //Smooth AI buffer for runAway AI. Also used as a speed control variable.
private bool walkInRandomDirection = false; //Speed control variable.
public float lastShotFired; //Used in conjuction with attackTime to monitor attack durations.
private float lostPlayerTimer; //Used for hunting down the player.
private bool targetIsOutOfSight; //Player tracking overload prevention. Makes sure we do not call the same coroutines over and over.
private Vector3 randomDirection; //Random movement behaviour setting.
private float randomDirectionTimer; //Random movement behaviour tracking.
private float gravity = 20.0f; //force of gravity pulling the enemy down.
private float antigravity = 2.0f; //force at which floating/flying enemies repel
private float estHeight = 0.0f; //floating/flying creatures using estimated elevation use this to estimate height necessities and gravity impacts.
private float estGravityTimer = 0.0f; //floating/flying creatures using estimated elevation will use this to actually monitor time values.
private int estCheckDirection = 0; //used to determine if AI is falling or not when estimating elevation.
private bool wpCountdown = false; //used to determine if we're moving forward or backward through the waypoints.
private bool monitorRunTo = false; //when AI is set to runTo, they will charge in, and then not charge again to after far enough away.
private int wpPatrol = 0; //determines what waypoint we are heading toward.
private bool pauseWpControl; //makes sure unit pauses appropriately.
private bool smoothAttackRangeBuffer = false; //for runAway AI to not be so messed up by their visual radius and attack range.
//---Starting/Initializing functions---//
void Start() {
StartCoroutine(Initialize()); //co-routine is used incase you need to interupt initiialization until something else is done.
}
IEnumerator Initialize() {
if ((estimateElevation) && (floatHeight > 0.0f)) {
estGravityTimer = Time.time;
}
characterController = gameObject.GetComponent<CharacterController>();
initialGo = true;
yield return null;
}
//---Main Functionality---//
void Update () {
if (!on || !initialGo) {
return;
} else {
AIFunctionality();
}
}
void AIFunctionality() {
if ((!target) && (requireTarget)) {
return; //if no target was set and we require one, AI will not function.
}
//Functionality Updates
lastVisTargetPos = target.position; //Target tracking method for semi-intelligent AI
Vector3 moveToward = lastVisTargetPos - transform.position; //Used to face the AI in the direction of the target
Vector3 moveAway = transform.position - lastVisTargetPos; //Used to face the AI away from the target when running away
float distance = Vector3.Distance(transform.position, target.position);
if (go) {
MonitorGravity();
}
if (!requireTarget) {
//waypoint only functionality
Patrol();
} else if (TargetIsInSight ()) {
if (!go) { //useWaypoints is false and the player has exceeded moveableRadius, shutdown AI until player is near.
return;
}
if ((distance > attackRange) && (!runAway) && (!runTo)) {
enemyCanAttack = false; //the target is too far away to attack
MoveTowards (moveToward); //move closer
} else if ((smoothAttackRangeBuffer) && (distance > attackRange+5.0f)) {
smoothAttackRangeBuffer = false;
WalkNewPath();
}else if ((runAway || runTo) && (distance > runDistance) && (!executeBufferState)) {
//move in random directions.
if (monitorRunTo) {
monitorRunTo = false;
}
if (runAway) {
WalkNewPath ();
} else {
MoveTowards (moveToward);
}
} else if ((runAway || runTo) && (distance < runDistance) && (!executeBufferState)) { //make sure they do not get too close to the target
//AHH! RUN AWAY!... or possibly charge :D
enemyCanAttack = false; //can't attack, we're running!
if (!monitorRunTo) {
executeBufferState = true; //smooth buffer is now active!
}
walkInRandomDirection = false; //obviously we're no longer moving at random.
if (runAway) {
MoveTowards (moveAway); //move away
} else {
MoveTowards (moveToward); //move toward
}
} else if (executeBufferState && ((runAway) && (distance < runBufferDistance)) || ((runTo) && (distance > runBufferDistance))) {
//continue to run!
if (runAway) {
MoveTowards (moveAway); //move away
} else {
MoveTowards (moveToward); //move toward
}
} else if ((executeBufferState) && (((runAway) && (distance > runBufferDistance)) || ((runTo) && (distance < runBufferDistance)))) {
monitorRunTo = true; //make sure that when we have made it to our buffer distance (close to user) we stop the charge until far enough away.
executeBufferState = false; //go back to normal activity
}
//start attacking if close enough
if ((distance < attackRange) || ((!runAway && !runTo) && (distance < runDistance))) {
if (runAway) {
smoothAttackRangeBuffer = true;
}
if (Time.time > lastShotFired + attackTime) {
StartCoroutine(Attack());
}
}
} else if ((playerHasBeenSeen) && (!targetIsOutOfSight) && (go)) {
lostPlayerTimer = Time.time + huntingTimer;
StartCoroutine(HuntDownTarget(lastVisTargetPos));
} else if (useWaypoints) {
Patrol();
} else if (((!playerHasBeenSeen) && (go)) && ((moveableRadius == 0) || (distance < moveableRadius))){
//the idea here is that the enemy has not yet seen the player, but the player is fairly close while still not visible by the enemy
//it will move in a random direction continuously altering its direction every 2 seconds until it does see the player.
WalkNewPath();
}
}
//attack stuff...
IEnumerator Attack() {
enemyCanAttack = true;
if (!enemyIsAttacking) {
enemyIsAttacking = true;
while (enemyCanAttack) {
lastShotFired = Time.time;
float distance = Vector3.Distance(target.transform.position, transform.position);
Vector3 dir = (target.transform.position - transform.position).normalized;
float direction = Vector3.Dot(dir, transform.forward);
if(distance < attackRange){
if(direction > 0) {
PlayerHealth ph = (PlayerHealth)target.GetComponent("PlayerHealth");
ph.AdjustCurrentHealth(-10);
enemyIsAttacking = false;
}
}
yield return new WaitForSeconds(attackTime);
}
}
}
//----Helper Functions---//
//verify enemy can see the target
bool TargetIsInSight () {
//determine if the enemy should be doing anything other than standing still
if ((moveableRadius > 0) && (Vector3.Distance(transform.position, target.position) > moveableRadius)) {
go = false;
} else {
go = true;
}
//then lets make sure the target is within the vision radius we allowed our enemy
//remember, 0 radius means to ignore this check
if ((visualRadius > 0) && (Vector3.Distance(transform.position, target.position) > visualRadius)) {
return false;
}
//Now check to make sure nothing is blocking the line of sight
RaycastHit sight;
if (Physics.Linecast(transform.position, target.position, out sight)) {
if (!playerHasBeenSeen && sight.transform == target) {
playerHasBeenSeen = true;
}
return sight.transform == target;
} else {
return false;
}
}
//target tracking
IEnumerator HuntDownTarget (Vector3 position) {
//if this function is called, the enemy has lost sight of the target and must track him down!
//assuming AI is not too intelligent, they will only move toward his last position, and hope they see him
//this can be fixed later to update the lastVisTargetPos every couple of seconds to leave some kind of trail
targetIsOutOfSight = true;
while (targetIsOutOfSight) {
Vector3 moveToward = position - transform.position;
MoveTowards (moveToward);
//check if we found the target yet
if (TargetIsInSight ()) {
targetIsOutOfSight = false;
break;
}
//check to see if we should give up our search
if (Time.time > lostPlayerTimer) {
targetIsOutOfSight = false;
playerHasBeenSeen = false;
break;
}
yield return null;
}
}
void Patrol () {
if (pauseWpControl) {
return;
}
Vector3 destination = CurrentPath();
Vector3 moveToward = destination - transform.position;
float distance = Vector3.Distance(transform.position, destination);
MoveTowards (moveToward);
if (distance <= 1.5f+floatHeight) {// || (distance < floatHeight+1.5f)) {
if (pauseAtWaypoints) {
if (!pauseWpControl) {
pauseWpControl = true;
StartCoroutine(WaypointPause());
}
} else {
NewPath();
}
}
}
IEnumerator WaypointPause () {
yield return new WaitForSeconds(Random.Range(pauseMin, pauseMax));
NewPath();
pauseWpControl = false;
}
Vector3 CurrentPath () {
return waypoints[wpPatrol].position;
}
void NewPath () {
if (!wpCountdown) {
wpPatrol++;
if (wpPatrol >= waypoints.GetLength(0)) {
if (reversePatrol) {
wpCountdown = true;
wpPatrol -= 2;
} else {
wpPatrol = 0;
}
}
} else if (reversePatrol) {
wpPatrol--;
if (wpPatrol < 0) {
wpCountdown = false;
wpPatrol = 1;
}
}
}
//random movement behaviour
void WalkNewPath () {
if (!walkInRandomDirection) {
walkInRandomDirection = true;
if (!playerHasBeenSeen) {
randomDirection = new Vector3(Random.Range(-0.15f,0.15f),0,Random.Range(-0.15f,0.15f));
} else {
randomDirection = new Vector3(Random.Range(-0.5f,0.5f),0,Random.Range(-0.5f,0.5f));
}
randomDirectionTimer = Time.time;
} else if (walkInRandomDirection) {
MoveTowards (randomDirection);
}
if ((Time.time - randomDirectionTimer) > 2) {
//choose a new random direction after 2 seconds
walkInRandomDirection = false;
}
}
//standard movement behaviour
void MoveTowards (Vector3 direction) {
direction.y = 0;
int speed = walkSpeed;
if (walkInRandomDirection) {
speed = randomSpeed;
}
if (executeBufferState) {
speed = runSpeed;
}
//rotate toward or away from the target
transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(direction), rotationSpeed * Time.deltaTime);
transform.eulerAngles = new Vector3(0, transform.eulerAngles.y, 0);
//slow down when we are not facing the target
Vector3 forward = transform.TransformDirection(Vector3.forward);
float speedModifier = Vector3.Dot(forward, direction.normalized);
speedModifier = Mathf.Clamp01(speedModifier);
//actually move toward or away from the target
direction = forward * speed * speedModifier;
if ((!canFly) && (floatHeight <= 0.0f)) {
direction.y -= gravity;
}
if(Vector3.Distance(target.transform.position, this.transform.position) > stopAttackRange)
characterController.Move(direction * Time.deltaTime);
}
//continuous gravity checks
void MonitorGravity () {
Vector3 direction = new Vector3(0, 0, 0);
if ((!canFly) && (floatHeight > 0.0f)) {
//we need to make sure our enemy is floating.. using evil raycasts! bwahahahah!
if ((estimateElevation) && (estRayTimer > 0.0f)) {
if (Time.time > estGravityTimer) {
RaycastHit floatCheck;
if (Physics.Raycast(transform.position, -Vector3.up, out floatCheck)) {
if (floatCheck.distance < floatHeight-0.5f) {
estCheckDirection = 1;
estHeight = floatHeight - floatCheck.distance;
} else if (floatCheck.distance > floatHeight+0.5f) {
estCheckDirection = 2;
estHeight = floatCheck.distance - floatHeight;
} else {
estCheckDirection = 3;
}
} else {
estCheckDirection = 2;
estHeight = floatHeight*2;
}
estGravityTimer = Time.time + estRayTimer;
}
switch(estCheckDirection) {
case 1:
direction.y += antigravity;
estHeight -= direction.y * Time.deltaTime;
break;
case 2:
direction.y -= gravity;
estHeight -= direction.y * Time.deltaTime;
break;
default:
//do nothing
break;
}
} else {
RaycastHit floatCheck;
if (Physics.Raycast(transform.position, -Vector3.up, out floatCheck, floatHeight+1.0f)) {
if (floatCheck.distance < floatHeight) {
direction.y += antigravity;
}
} else {
direction.y -= gravity;
}
}
} else {
//bird like creature! Again with the evil raycasts! :p
if ((estimateElevation) && (estRayTimer > 0.0f)) {
if (Time.time > estGravityTimer) {
RaycastHit floatCheck;
if (Physics.Raycast(transform.position, -Vector3.up, out floatCheck)) {
if (floatCheck.distance < floatHeight-0.5f) {
estCheckDirection = 1;
estHeight = floatHeight - floatCheck.distance;
} else if (floatCheck.distance > floatHeight+0.5f) {
estCheckDirection = 2;
estHeight = floatCheck.distance - floatHeight;
} else {
estCheckDirection = 3;
}
}
estGravityTimer = Time.time + estRayTimer;
}
switch(estCheckDirection) {
case 1:
direction.y += antigravity;
estHeight -= direction.y * Time.deltaTime;
break;
case 2:
direction.y -= antigravity;
estHeight -= direction.y * Time.deltaTime;
break;
default:
//do nothing
break;
}
} else {
RaycastHit floatCheck;
if (Physics.Raycast(transform.position, -Vector3.up, out floatCheck)) {
if (floatCheck.distance < floatHeight-0.5f) {
direction.y += antigravity;
} else if (floatCheck.distance > floatHeight+0.5f) {
direction.y -= antigravity;
}
}
}
}
if ((!estimateElevation) || ((estimateElevation) && (estHeight >= 0.0f))) {
characterController.Move(direction * Time.deltaTime);
}
}
}
Stop spamming!
– jimmyismike