public virtual void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
isRunning = true;
ai.SetSpeed(patternType.precedence);
ai.currentPattern = this;
ai.CurrentData = data;
}
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.UpdatePattern(ai, data);
if (ai.DestinationReached(0.1f))
{
if (spotsToCheck > 0)
{
spotsToCheck--;
Vector3 point = GetSurveyPoint(ai);
ai.agent.SetDestination(point);
}
else
{
// remove inspection point
ai.sMF.inspectionPoints.RemoveAt(0);
// exit behaviour if no more inspection points
if (ai.sMF.inspectionPoints.Count < 1)
{
KillPattern(ai);
return;
}
}
}
}
public void StrafeCycle(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
// get target
ai.playerTarget = data.targets[0];
// get destination
Vector3 moveTarget = ai.transform.position + Random.insideUnitSphere * strafeLength;
// choose closer strafe target each time
while (Vector3.Distance(moveTarget, data.targets[0].position) > Vector3.Distance(ai.transform.position, data.targets[0].position))
{
moveTarget = ai.transform.position + Random.insideUnitSphere * strafeLength;
Debug.Log("strafeMoveTargetChanged");
}
// set destination.y
moveTarget.y = moveHeight;
// start height lerp method
ai.HoverHeight(moveTarget.y);
//Debug.Log("Strafing");
//GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//sphere.transform.position = moveTarget;
//sphere.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
ai.agent.SetDestination(moveTarget);
// shoot
ai.ShootAt(data.targets[0]);
}
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
if (ai.DestinationReached(0.5f))
{
if (investigationPoint == ai.sMF.targetLastSeen)
{
Debug.Log("TLS set to Vector3.zero");
ai.sMF.targetLastSeen = Vector3.zero;
KillPattern(ai);
return;
}
else if (investigationPoint == data.inspectionPoints[0])
{
Debug.Log("inspectionPoint removed");
ai.sMF.inspectionPoints.RemoveAt(0);
if (ai.sMF.inspectionPoints.Count < 1)
{
KillPattern(ai);
return;
}
}
else
{
Debug.Log("InvestigationPoint is set to strange value... (InvestigatePattern)");
}
}
}
public override Pattern ChoosePattern(SenseMemoryFactory.SMData senseData)
{
// NOTE: generate random number between 0 and currentHealth * 2;
// this number replaces health.currentHealth in all ifs below
// same for distance
Pattern p = null;
if (health.currentHealth > 85)
{
if (senseData.distance < 20)
{
// Strafe Fire
p = patterns[1];
}
else
{
// Charge Fire
p = patterns[0];
}
}
else if (health.currentHealth > 30)
{
// Cover shoot
p = patterns[2];
}
else
{
// Retreat
p = patterns[3];
}
return(p);
}
public override Pattern ChoosePattern(SenseMemoryFactory.SMData senseData)
{
Pattern p = null;
// Return Patrol Pattern (Only Naive Pattern)
p = patterns[0];
return(p);
}
public override Pattern ChoosePattern(SenseMemoryFactory.SMData senseData)
{
Pattern p = null;
// Randomize investigate and Survey Pattern execution
int random = UnityEngine.Random.Range(0, patterns.Count);
p = patterns[random];
return(p);
}
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
// reset spotcheck count
spotsToCheck = spotChecks;
Vector3 surveyPoint = GetSurveyPoint(ai);
ai.agent.SetDestination(surveyPoint);
}
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
// get target
investigationPoint = data.targetLastSeen != Vector3.zero ? data.targetLastSeen : data.inspectionPoints[0];
// move to position & start coroutine to rotate to player
ai.agent.SetDestination(investigationPoint);
}
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
// stop navMesh from setting rotation
ai.agent.updateRotation = false;
// give target to AI
ai.playerTarget = data.targets[0];
// tell ai to look at target
ai.lookAtTarget = true;
StrafeCycle(ai, data);
}
//Func<Vector3, Vector3> GetDestinationInTotem()
//{
// Func<Vector3, Vector3> fn = (v) =>
// {
// if (!localTotem)
// {
// return v;
// }
// Vector3 totemPos = localTotem.transform.position;
// float destinationDist = Vector3.Distance(totemPos, v);
// if (destinationDist > localTotem.radius)
// {
// // position + direction.normalized * radius 0 shortens destination to point on totem radius
// return totemPos + (v - totemPos).normalized * localTotem.radius;
// }
// return v;
// };
// return fn;
//}
public void TryExecutePattern(Pattern incomingPattern, SenseMemoryFactory.SMData _data)
{
if (ai.debugBehaviour)
{
string debug = _data.inspectionPoints.Count > 0 ? string.Format(BaneTools.ColorString("iPs: " + _data.inspectionPoints.Count + ", tLS: " + _data.targetLastSeen + ", tars: " + _data.targets.Count, Color.yellow)) : "iPs: " + _data.inspectionPoints.Count + ", tLS: " + _data.targetLastSeen + ", tars: " + _data.targets.Count;
Debug.Log(debug);
}
//remove currentPattern if it has stopped
if (currentPattern && !currentPattern.isRunning)
{
currentPattern = null;
}
// if there is no pattern running
if (!currentPattern)
{
if (ai.debugBehaviour)
{
Debug.Log(string.Format(BaneTools.ColorString("NEW Pattern: " + incomingPattern + ", OLD Pattern ended", Color.red)));
}
incomingPattern.StartPatternWith(ai, _data);
currentPattern = incomingPattern;
return;
}
// if incoming pattern is different and current pattern is interuptable
if (incomingPattern != currentPattern && currentPattern.isInteruptable)
{
if (ai.debugBehaviour)
{
Debug.Log(string.Format(BaneTools.ColorString("NEW Pattern: " + incomingPattern + ", OLD Pattern: " + currentPattern, Color.green)));
}
currentPattern.KillPattern(ai);
incomingPattern.StartPatternWith(ai, _data);
currentPattern = incomingPattern;
return;
}
// if precedence matters for current pattern && incoming has higher or equal precedence, run incoming
if (currentPattern.notePrecedence && incomingPattern.patternType.precedence >= currentPattern.patternType.precedence)
{
if (ai.debugBehaviour)
{
Debug.Log(string.Format(BaneTools.ColorString("NEW Pattern: " + incomingPattern + ", OLD Pattern: " + currentPattern, Color.green)));
}
currentPattern.KillPattern(ai);
incomingPattern.StartPatternWith(ai, _data);
currentPattern = incomingPattern;
return;
}
if (ai.debugBehaviour)
{
Debug.Log("Update Pattern: " + currentPattern);
}
currentPattern.UpdatePattern(ai, _data);
}
void CoverShootCycle(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
Transform enemyTarget = data.targets[0];
// get cover point
coverPoint = ai.GetAvoidanceWaypoint(data.targets[0].position);
// move to cover point
ai.agent.SetDestination(coverPoint);
// fire while moving
ai.ShootAt(enemyTarget);
}
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
//ai.Crouch(true);
// look at player while moving
ai.playerTarget = data.targets[0];
ai.agent.updateRotation = false;
ai.lookAtTarget = true;
// Covershoot sequence
CoverShootCycle(ai, data);
}
// Initialisation - runs once when pattern begins
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
if (wayPoints.Count == 0)
{
GetWaypointsFrom(ai);
}
// Transform(s) of the current waypoint in the waypoints array.
Vector3 point = GetRandomEnRoutePos(wayPoints[waypointIndex].position, ai);
// Agent destination (move to current waypoint position).
ai.agent.SetDestination(point);
}
public override Decider DeciderBasedOn(SenseMemoryFactory.SMData data)
{
// if no direct/indirect evidence of adversaries
bool condition = (data.inspectionPoints.Count == 0 && data.targets.Count == 0 && data.targetLastSeen == Vector3.zero);
if (condition)
{
//Debug.Log(this.GetType().Name + ", passed");
return(this);
}
else
{
// return empty set of patterns (basically null state)
return(null);
}
}
override public Decider DeciderBasedOn(SenseMemoryFactory.SMData _data)
{
// if direct evidence of enemies
bool condition = (_data.targets.Count > 0);
if (condition)
{
//Debug.Log(this.GetType().Name + ", passed");
// return set of combat patterns
return(this);
}
else
{
// return empty set of patterns (basically null state)
return(null);
}
}
override public Decider DeciderBasedOn(SenseMemoryFactory.SMData _data)
{
// if no direct evidence but some indirect evidence of enemies
bool condition = (_data.targets.Count == 0 && (_data.inspectionPoints.Count > 0 || (_data.targetLastSeen != Vector3.zero || _data.targetLastSeen != Vector3.zero)));
if (condition)
{
//Debug.Log(this.GetType().Name + ", passed");
// return set of suspicious patterns
return(this);
}
else
{
// return empty set of patterns (basically null state)
return(null);
}
}
// Gets called when pattern is re-called (is cheaper due to if check)
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.UpdatePattern(ai, data);
// If we're close enough to the waypoint...
if (ai.DestinationReached(0.1f))
{
// if agent has reached final destination waypoint pos
if (Vector3.Distance(wayPoints[waypointIndex].position, ai.transform.position) < 0.5f)
{
waypointIndex = Random.Range(0, wayPoints.Count);
}
// Transform(s) of the current waypoint in the waypoints array.
Vector3 point = GetRandomEnRoutePos(wayPoints[waypointIndex].position, ai);
// Agent destination (move to current waypoint position).
ai.agent.SetDestination(point);
}
}
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.UpdatePattern(ai, data);
if (data.targets.Count == 0)
{
switch (playerChecks)
{
// 1st check:
case 0:
ai.agent.SetDestination(data.targetLastSeen); // look for target
Debug.Log("CS check: " + playerChecks);
break;
// 2nd check:
case 1:
ai.agent.SetDestination(coverPoint); // return to cover
Debug.Log("CS check: " + playerChecks);
break;
// 3rd check:
case 2:
ai.agent.SetDestination(data.targetLastSeen); // look for target
Debug.Log("CS check: " + playerChecks);
break;
// 4th/Final check:
case 3:
KillPattern(ai); // End Behaviour
Debug.Log("CS check: " + playerChecks);
return;
default:
KillPattern(ai);
Debug.Log("CS check: " + playerChecks);
return;
}
playerChecks++;
}
else
{
playerChecks = 0;
CoverShootCycle(ai, data);
}
}
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
if (data.targets.Count != 0)
{
retreatPoint = ai.GetAvoidanceWaypoint(data.targets[0].position);
ai.agent.SetDestination(retreatPoint);
}
if (ai.DestinationReached(0.1f))
{
if (!rotated)
{
retreatPoint = ai.transform.position + (data.targetLastSeen - ai.transform.position).normalized;
ai.agent.SetDestination(retreatPoint);
rotated = true;
}
else
{
KillPattern(ai);
rotated = false;
return;
}
}
}
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
// closest target (FoV script orders targets in list)
Transform target = data.targets[0];
// Go toward player target
ai.agent.SetDestination(target.position);
if (ai.isGuard)
{
if (ai.hand)
{
ai.hand.LookAt(target.position);
}
else
{
Debug.Log("You need to asign the AI Hand Transform component to aim the gun");
}
}
// fire
ai.ShootAt(target);
}
// this lambda needs to be passed to pattern being executed (to constrain position to totem radius)
//Func<Vector3, Vector3> GetDestinationInTotem()
//{
// Func<Vector3, Vector3> fn = (v) =>
// {
// if (!localTotem)
// {
// return v;
// }
// Vector3 totemPos = localTotem.transform.position;
// float destinationDist = Vector3.Distance(totemPos, v);
// if (destinationDist > localTotem.radius)
// {
// // position + direction.normalized * radius 0 shortens destination to point on totem radius
// return totemPos + (v - totemPos).normalized * localTotem.radius;
// }
// return v;
// };
// return fn;
//}
// Wrapper Method that allocates data to each of the AI Modes - Conditions for
// execution are defined at the top of each respective Mode class
public void MakeDecisionFrom(SenseMemoryFactory.SMData senseData)
{
// SelectMany() makes 1 list out of all the pattern lists (derived/transformed from deciders) that pass the condition (based on SMData)
//List<Pattern> relevantPatterns = deciders.SelectMany(d => d.DeciderBasedOn(data)).ToList();
Decider relevantDecider = null;
Pattern pattern = null;
// run each decider through it's bool test for relevence based on senses
foreach (Decider d in deciders)
{
if (d.DeciderBasedOn(senseData) != null)
{
relevantDecider = d;
break;
}
}
if (relevantDecider != null)
{
// tell decider to run specific conditions to choose one of it's patterns
pattern = relevantDecider.ChoosePattern(senseData);
}
else
{
Debug.Log("No relevant Decider chosen! (MakeDecisionFrom() method)");
return;
}
//Pattern pattern = pM.SelectPattern(relevantPatterns);
if (pattern)
{
pM.TryExecutePattern(pattern, senseData);
}
//TurnOffDecidersBasedOn(pattern);
}
public override void StartPatternWith(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
base.StartPatternWith(ai, data);
retreatPoint = ai.GetAvoidanceWaypoint(data.targets[0].position);
ai.agent.SetDestination(retreatPoint);
}
public virtual void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
}
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
StartPatternWith(ai, data);
}
public abstract Pattern ChoosePattern(SenseMemoryFactory.SMData senseData);
//public abstract List<Pattern> DeciderBasedOn(SenseMemoryFactory.SMData data); public abstract Decider DeciderBasedOn(SenseMemoryFactory.SMData senseData);
public override void UpdatePattern(BehaviourAI ai, SenseMemoryFactory.SMData data)
{
StrafeCycle(ai, data);
}
