public override BehaviourStatus OnBehave(BehaviourState state)
{
BehaviourContext enemyContext = (BehaviourContext)state;
if (!enemyContext.enemyInRange(0.5f))
{
if (enemyContext.enemyAnimation.GetCurrentAnimatorStateInfo(0).IsName("attack"))
{
enemyContext.enemyAnimation.Play("walk");
}
return(BehaviourStatus.FAILURE);
}
if (GameObject.FindGameObjectWithTag("Player") != null)
{
playerPosition = GameObject.FindGameObjectWithTag("Player").transform.position;
}
else
{
return(BehaviourStatus.SUCCESS);
}
enemyContext.enemyPhysics.enemyRotation(playerPosition);
if (enemyContext.enemyAnimation.GetCurrentAnimatorStateInfo(0).IsName("idle") ||
enemyContext.enemyAnimation.GetCurrentAnimatorStateInfo(0).IsName("walk"))
{
enemyContext.enemyAnimation.Play("attack");
}
enemyContext.enemyPhysics.enemyMovement(playerPosition, angle);
return(BehaviourStatus.RUNNING);
}
public override void Finish(Status status, BehaviourContext context)
{
RandomContext tmpContext = (RandomContext)context;
Debug.Log("Status: " + _status);
Debug.Log("Current number: " + tmpContext.currentNumber);
}
public override Status Run(float dt, BehaviourContext context)
{
WanderContext _context = (WanderContext)context;
Vector2 center = _context.go.transform.position;
Collider2D[] entities = Physics2D.OverlapCircleAll(center, radius);
if (entities.Length <= 1)
{
return(Status.FAIL);
}
else
{
for (int i = 0; i < entities.Length; i++)
{
if (entities[i].gameObject.CompareTag(tag))
{
colliders.Add(entities[i]);
}
}
if (colliders.Count > 0)
{
GameObject entity = colliders[Random.Range(0, colliders.Count)].gameObject;
_context.aroundGO = entity;
_context.moveToTarget = _context.aroundGO.transform.position;
return(Status.SUCCESS);
}
return(Status.FAIL);
}
}
public RotationBehaviour(
BehaviourContext context,
WorldPointProperties worldPointProperties,
SwitchPoint switchPoint,
Transform target)
: base(context, worldPointProperties, switchPoint, target, Behaviour.Rotation)
{
}
public override void Start(BehaviourContext context)
{
WanderContext _context = (WanderContext)context;
_context.timer.After(duration, () => {
done = true;
});
}
public MovementBehaviour(
BehaviourContext context,
WorldPointProperties worldPointProperties,
SwitchPoint switchPoint,
Transform target)
: base(context, worldPointProperties, switchPoint, target, Behaviour.Movement)
{
}
//Method for calling the functions for rotating and moving the enemy
private void rotateAndMove(BehaviourContext context, Vector3 position)
{
context.enemyPhysics.enemyRotation(position);
if (context.enemyAnimation.GetCurrentAnimatorStateInfo(0).IsName("idle"))
{
context.enemyAnimation.Play("walk");
}
context.enemyPhysics.enemyMovement(position, angle);
}
public override Status Run(float dt, BehaviourContext context)
{
RandomContext tmpContext = (RandomContext)context;
int currentValue = Random.Range(min, max);
tmpContext.currentNumber = currentValue;
_status = Status.FAIL;
return(_status);
}
public override void Start(BehaviourContext context)
{
Debug.Log("Starting After behaviour: " + name);
readyToRun = false;
timer.After(duration, () =>
{
readyToRun = true;
}, false, name);
}
public override void Finish(Status status, BehaviourContext context)
{
for (int i = 0; i < behaviours.Count; i++)
{
if (behaviours[i].status == Status.RUNNING)
{
behaviours[i].Finish(status, context);
}
}
}
void Start()
{
this.enemy = this.GetComponent <CharacterController> ();
this.enemyPhysics = this.GetComponent <EnemyController>();
this.enemyAnimation = this.GetComponent <Animator> ();
this.enemySight = this.GetComponent <Sight>();
this.behaviourTree = createBehaviourTree();
this.behaviourState = new BehaviourContext(enemy, enemyPhysics, enemyAnimation,
enemySight, enemyRange, null, 0.0f);
}
public override Status Run(float dt, BehaviourContext context)
{
if (done)
{
return(Status.SUCCESS);
}
else
{
return(Status.RUNNING);
}
}
public override Status Run(float dt, BehaviourContext context)
{
float angle = Random.Range(0, 2 * Mathf.PI);
float distance = Random.Range(0, radius);
WanderContext _context = (WanderContext)context;
_context.moveToTarget = new Vector2(this.x + distance * Mathf.Cos(angle), this.y + distance * Mathf.Sin(angle));
_status = Status.SUCCESS;
return(_status);
}
public void TestsMemoryPoolForceMappingEnabled()
{
BehaviourContext behaviourContext = new BehaviourContext();
behaviourContext.SetUserRevision(BehaviourContext.BaseRevisionMagic + BehaviourContext.Revision1);
Assert.IsFalse(behaviourContext.IsMemoryPoolForceMappingEnabled());
behaviourContext.UpdateFlags(0x1);
Assert.IsTrue(behaviourContext.IsMemoryPoolForceMappingEnabled());
}
public void TestCheckFeature()
{
int latestRevision = BehaviourContext.BaseRevisionMagic + BehaviourContext.LastRevision;
int previousRevision = BehaviourContext.BaseRevisionMagic + (BehaviourContext.LastRevision - 1);
int invalidRevision = BehaviourContext.BaseRevisionMagic + (BehaviourContext.LastRevision + 1);
Assert.IsTrue(BehaviourContext.CheckFeatureSupported(latestRevision, latestRevision));
Assert.IsFalse(BehaviourContext.CheckFeatureSupported(previousRevision, latestRevision));
Assert.IsTrue(BehaviourContext.CheckFeatureSupported(latestRevision, previousRevision));
// In case we get an invalid revision, this is supposed to auto default to REV1 internally.. idk what the hell Nintendo was thinking here..
Assert.IsTrue(BehaviourContext.CheckFeatureSupported(invalidRevision, latestRevision));
}
public QueryFullPipeline(
IQueryBehaviour <TQuery, TResult>[] behaviours,
IQueryPreProcessor <TQuery, TResult>[] preProcessors,
IQueryProcessor <TQuery, TResult> processor,
IQueryPostProcessor <TQuery, TResult>[] postProcessors)
{
_behaviours = new BehaviourContext(this, behaviours);
_preProcessors = preProcessors;
_processor = processor;
_postProcessors = postProcessors;
}
public override BehaviourStatus OnBehave(BehaviourState state)
{
BehaviourContext enemyContext = (BehaviourContext)state;
if (enemyContext.enemyInSight())
{
playerPosition = GameObject.FindGameObjectWithTag("Player").transform.position;
}
if ((!enemyContext.enemyInRange(0.5f) && !enemyContext.enemyTooClose()))
{
enemyContext.enemyWeaponController.isFiring = false;
return(BehaviourStatus.FAILURE);
}
if ((!enemyContext.enemyTooClose() && enemyContext.enemyInSight()))
{
enemyContext.enemyWeaponController.isFiring = false;
return(BehaviourStatus.SUCCESS);
}
/////////////////////////////////////////////////////////////
if (closestNode == null)
{
closestNode = PathFinder.getRetreatNode(enemyContext.pathNodes, enemyContext.enemyPhysics.transform, playerPosition);
}
if (PathFinder.atDestination(enemyContext.enemy.transform, closestNode.transform.position))
{
closestNode = PathFinder.getRetreatNeighbor(closestNode, enemyContext.enemy.transform, playerPosition);
if (closestNode == null)
{
closestNode = PathFinder.getRetreatNode(enemyContext.pathNodes, enemyContext.enemyPhysics.transform, playerPosition);
}
}
enemyContext.enemyPhysics.enemyRotation(playerPosition);
if (enemyContext.enemyAnimation.GetCurrentAnimatorStateInfo(0).IsName("idle") ||
enemyContext.enemyAnimation.GetCurrentAnimatorStateInfo(0).IsName("attack"))
{
enemyContext.enemyAnimation.Play("walk");
}
enemyContext.enemyPhysics.enemyMovement(closestNode.transform.position, angle);
if (!enemyContext.enemyWeaponController.isFiring)
{
enemyContext.enemyWeaponController.isFiring = true;
}
////////////////////////////////////////////////////////////////
return(BehaviourStatus.RUNNING);
}
public CommandFullPipeline(
ICommandBehaviour <TCommand>[] behaviours,
ICommandPreProcessor <TCommand>[] preProcessors,
ICommandProcessor <TCommand> processor,
ICommandPostProcessor <TCommand>[] postProcessors)
{
_behaviours = new BehaviourContext(this, behaviours);
_preProcessors = preProcessors;
_processor = processor;
_postProcessors = postProcessors;
_disposed = false;
}
public override Status Run(float dt, BehaviourContext context)
{
WanderContext _context = (WanderContext)context;
GameObject obj = ((WanderContext)context).go;
float distance = Vector2.Distance(obj.transform.position, _context.moveToTarget);
if (distance < 0.1)
{
return(Status.SUCCESS);
}
obj.transform.position = Vector2.MoveTowards(obj.transform.position, _context.moveToTarget, speed * dt);
return(Status.RUNNING);
}
public override Status Run(float dt, BehaviourContext context)
{
if (readyToRun)
{
Status tmp = behaviour.Update(dt, context);
_status = tmp;
}
else
{
_status = Status.RUNNING;
}
return(_status);
}
public override Status Run(float dt, BehaviourContext context)
{
for (int i = 0; i < behaviours.Count; i++)
{
Status tmp = behaviours[i].Update(dt, context);
if (tmp != Status.FAIL)
{
_status = tmp;
return(_status);
}
}
_status = Status.FAIL;
return(_status);
}
public Status Update(float dt, BehaviourContext context)
{
if (_status != Status.RUNNING)
{
Start(context);
}
_status = Run(dt, context);
if (_status != Status.RUNNING)
{
Finish(_status, context);
}
return(_status);
}
public override Status Run(float dt, BehaviourContext context)
{
RandomContext tmpContext = (RandomContext)context;
if (tmpContext.currentNumber == tmpContext.targetNumber)
{
_status = Status.SUCCESS;
}
else
{
_status = Status.FAIL;
}
return(_status);
}
public BaseBehaviour(
BehaviourContext context,
WorldPointProperties worldPointProperties,
SwitchPoint switchPoint,
Transform target,
Behaviour behaviour)
{
_context = context;
_worldPointProperties = worldPointProperties;
_target = target;
_behaviour = behaviour;
OnSwitchPoint = switchPoint;
}
public override Status Run(float dt, BehaviourContext context)
{
Status st = behaviour.Update(dt, context);
if (st != Status.FAIL)
{
st = Status.RUNNING;
}
else
{
st = Status.SUCCESS;
}
_status = st;
return(_status);
}
public void Dispose()
{
if (_disposed)
{
return;
}
_behaviours.Dispose();
_behaviours = null !;
_preProcessors = null !;
_processor = null !;
_postProcessors = null !;
_disposed = true;
}
public override Status Run(float dt, BehaviourContext context)
{
Status tmpStatus = behaviours[currentIndex].Update(dt, context);
if (tmpStatus != Status.SUCCESS)
{
_status = tmpStatus;
return(_status);
}
currentIndex++;
if (currentIndex == behaviours.Count)
{
_status = Status.SUCCESS;
}
return(_status);
}
public override void Start(BehaviourContext context)
{
WanderContext _context = (WanderContext)context;
Timer timer = _context.timer;
GameObject _target = _context.aroundGO;
SpriteRenderer renderer = _target.GetComponent <SpriteRenderer>();
renderer.color = color;
timer.After(2, () =>
{
renderer.color = Color.white;
done = true;
});
}
//Leaf node that checks whether or not the target is not seen or heard so it can patrol.
public override BehaviourStatus OnBehave(BehaviourState state)
{
BehaviourContext enemyContext = (BehaviourContext)state;
if (!enemyContext.enemyInSight() && !enemyContext.enemyInRange(0.5f) && !enemyContext.playerHeard)
{
if (enemyContext.enemySight.enableDebug)
{
Debug.Log("Player Not Found");
}
return(BehaviourStatus.SUCCESS);
}
return(BehaviourStatus.FAILURE);
}
private void Start()
{
Agent = GetComponent <Agent>();
var target = FindObjectOfType <Player>().GetComponent <Agent>();
ProxyObject = Instantiate(ProxyObjectPrefab, transform.position, transform.rotation);
Context = new BehaviourContext {
Agent = Agent, AiAgent = this, Target = target
};
if (States.Count > 0)
{
CurrentState = States.First().CreateInstance(Context);
}
}
