public void GenerateRandomDestination(ActorAI actor)
{
for (int i = 0; i < MaxValidRandomDestinationTryPerUpdate; i++)
{
Vector3 newDestination = actor.transform.position;
float xOffset = Random.Range(0.0f, RandomRadiusMoveRange);
float zOffset = RandomRadiusMoveRange - xOffset;
float signXOffset = (Random.Range(0, 2) * 2) - 1;
float signYOffset = (Random.Range(0, 2) * 2) - 1;
//
newDestination.x += signXOffset * xOffset;
newDestination.z += signYOffset * zOffset;
newDestination.y = FloorYOffset;
MapDestination = newDestination;
if (IsDestinationOutOfMap(newDestination))
{
newDestination.x = -newDestination.x;
newDestination.z = -newDestination.z;
MapDestination = newDestination;
}
if (!actor.Brain.DestinationOutsideDeathCircle(MapDestination))
{
MapDestinationIsKnown = true;
break;
}
else
{
MapDestinationIsKnown = false;
}
}
}
public override void Execute(ActorAI actor)
{
currentAIState = AIState.Loot;
AIController aiController = actor.ActorController;
if (aiController.GetAIControllerMode() != AIController.ControllerMode.Loot)
{
aiController.SetAIControllerMode(AIController.ControllerMode.Loot);
}
if (!aiController.ItemTargetDestinationIsKnown)
{
aiController.FindTargetItemMapDestination(actor);
}
if (aiController.ItemTargetDestinationIsKnown)
{
aiController.AIMoveTarget = AIController.MoveTarget.Item;
actor.ActorController.Move(actor);
if (aiController.HasReachedItemTargetDestination(actor))
{
aiController.ItemTargetDestinationIsKnown = false;
if (actor.Brain.ItemInPerceptionRange != null)
{
actor.Brain.ItemInPerceptionRange.gameObject.layer = LayerMask.NameToLayer(AIRadar.LayerNames[(int)AIRadar.LayerType.EquippedItem]);
actor.AIInventory.Add(actor.Brain.ItemInPerceptionRange.gameObject);
actor.Brain.ItemInPerceptionRange.gameObject.SetActive(false);
actor.ServerSetActive(actor.Brain.ItemInPerceptionRange.gameObject, false);
}
}
}
}
public void FindTargetOpponnentMapDestination(ActorAI actor)
{
PlayerController opponentPlayer = null;
ActorAI opponentAI = null;
opponentPlayer = actor.Sensor.NeareastGameObject <PlayerController>(actor.transform.position, AIRadar.LayerType.Player);
opponentAI = actor.Sensor.NeareastNonAllyAI(actor);
actor.Brain.UpdateOpponentOnMapKnowledge(opponentPlayer, opponentAI);
Vector3 newDestination = Vector3.zero;
newDestination.y = FloorYOffset;
if (opponentPlayer != null)
{
newDestination.x = opponentPlayer.transform.position.x;
newDestination.z = opponentPlayer.transform.position.z;
OpponentTargetDestination = newDestination;
OpponentTargetDestinationIsKnown = true;
actor.Brain.CurrentOpponentType = AIBrain.OpponentType.Player;
}
else if (opponentAI != null)
{
newDestination.x = opponentAI.transform.position.x;
newDestination.z = opponentAI.transform.position.z;
OpponentTargetDestination = newDestination;
OpponentTargetDestinationIsKnown = true;
actor.Brain.CurrentOpponentType = AIBrain.OpponentType.AI;
}
else
{
OpponentTargetDestinationIsKnown = false;
}
}
public ActorAI NeareastNonAllyAI(ActorAI selfAI)
{
Vector3 position = selfAI.transform.position;
ActorAI nearestNonAllyAI = default(ActorAI);
RaycastHit[] inRangeObjects;
LayerType layerType = LayerType.AI;
LayerMask layerMask = GetLayerMask(layerType);
inRangeObjects = Physics.SphereCastAll(position, currentPerceptionRange, circleCastDirection, circleCastDistance, layerMask);
int neareastItemIndex = -1;
float smallestDistance = float.MaxValue;
if (inRangeObjects != null)
{
for (int i = 0; i < inRangeObjects.Length; i++)
{
if (inRangeObjects[i].distance < smallestDistance && !(Object.ReferenceEquals(selfAI, inRangeObjects[i].collider.gameObject.GetComponentInParent <ActorAI>())))
{
smallestDistance = inRangeObjects[i].distance;
neareastItemIndex = i;
}
}
}
if (neareastItemIndex != -1)
{
nearestNonAllyAI = inRangeObjects[neareastItemIndex].collider.gameObject.GetComponentInParent <ActorAI>();
}
return(nearestNonAllyAI);
}
public bool HasReachedOpponentTargetDestination(ActorAI actor)
{
if (actor.Brain.IsOpponentInWeaponRange())
{
return(true);
}
return(false);
}
public AIController(ActorAI actor)
{
this.Actor = actor;
MapDestinationIsKnown = false;
OpponentTargetDestinationIsKnown = false;
ItemTargetDestinationIsKnown = false;
SetAIControllerMode(ControllerMode.None);
RandomSpeedFactor = Random.Range(RandomSpeedMinRange, RandomSpeedMaxRange);
}
public bool HasReachedItemTargetDestination(ActorAI actor)
{
float distance = Vector3.Distance(ItemTargetDestination, actor.transform.position);
if (distance < ErrorPositionTolerance)
{
return(true);
}
return(false);
}
public void SetFleeDestination(ActorAI actor)
{
if (FoundFleeDestination(actor))
{
MapDestinationIsKnown = true;
}
else
{
MapDestinationIsKnown = false;
}
}
public override void Execute(ActorAI actor)
{
currentAIState = AIState.Hunt;
AIController aiController = actor.ActorController;
if (aiController.GetAIControllerMode() != AIController.ControllerMode.Hunt)
{
aiController.SetAIControllerMode(AIController.ControllerMode.Hunt);
}
if (!aiController.OpponentTargetDestinationIsKnown)
{
aiController.FindTargetOpponnentMapDestination(actor);
}
if (!aiController.ItemTargetDestinationIsKnown)
{
aiController.FindTargetItemMapDestination(actor);
}
float lootGoalLevel = actor.Brain.goalEvaluator.EvaluateLootGoal();
float trackGoalLevel = actor.Brain.goalEvaluator.EvaluateTrackGoal();
if ((lootGoalLevel > trackGoalLevel) && aiController.ItemTargetDestinationIsKnown)
{
aiController.AIMoveTarget = AIController.MoveTarget.Item;
actor.ActorController.Move(actor);
if (aiController.HasReachedItemTargetDestination(actor))
{
aiController.ItemTargetDestinationIsKnown = false;
if (actor.Brain.ItemInPerceptionRange != null)
{
actor.Brain.ItemInPerceptionRange.gameObject.layer = LayerMask.NameToLayer(AIRadar.LayerNames[(int)AIRadar.LayerType.EquippedItem]);
actor.AIInventory.Add(actor.Brain.ItemInPerceptionRange.gameObject);
actor.Brain.ItemInPerceptionRange.gameObject.SetActive(false);
}
}
}
else
{
if (aiController.OpponentTargetDestinationIsKnown)
{
if (aiController.HasReachedOpponentTargetDestination(actor))
{
aiController.OpponentTargetDestinationIsKnown = false;
}
else
{
aiController.AIMoveTarget = AIController.MoveTarget.Opponent;
actor.ActorController.Move(actor);
}
}
}
}
public AIBrain(ActorAI actor)
{
this.Actor = actor;
this.goalEvaluator = new GoalEvaluator(actor);
this.decisionManager = new AIDecisionManager(actor, this);
LifeFleeThreshold = actor.AIHealth.MaxHealthPoints * LifeFleeThresholdFactor;
lastLifePointLevel = actor.AIHealth.MaxHealthPoints;
ResetActualPerception();
currentOpponentType = OpponentType.None;
InjuredByDeathCircle = false;
DeathCircleIsClosing = false;
}
//Nécessaire pour disinguer AI opponent et AI ally research vs player
//plus rapide à cause du ou dans le if de décision ailleurs d'avaoir deux fonctions
//Évite aussi des vérification de type et casting lents
public bool IsGameObjectHasLineOfSightToAI(Vector3 position, ActorAI target)
{
LayerMask layerMask = GetLayerMask(LayerType.Building);
if (target != null)
{
Vector3 direction = Vector3.zero;
direction = target.transform.position - position;
return(Physics.Raycast(position, direction, currentPerceptionRange, ~layerMask));
}
return(false);
}
private void MoveDestination(MoveTarget moveTarget, ActorAI actor)
{
float pas = this.currentSpeedLevel * RandomSpeedFactor * Time.deltaTime;
Vector3 destination = Vector3.zero;
switch (moveTarget)
{
case MoveTarget.Item:
destination = ItemTargetDestination;
break;
case MoveTarget.Map:
destination = MapDestination;
break;
case MoveTarget.Opponent:
destination = OpponentTargetDestination;
break;
default:
break;
}
destination.y = FloorYOffset;
NavMeshPath path = new NavMeshPath();
NavMesh.CalculatePath(actor.transform.position, destination, NavMesh.AllAreas, path);
Vector3[] pathpoints;
if (path.status == NavMeshPathStatus.PathComplete)
{
pathpoints = new Vector3[path.corners.Length];
int nbr = path.GetCornersNonAlloc(pathpoints);
if (nbr > PathVectorIndex)
{
destination = pathpoints[PathVectorIndex];
}
}
destination.y = FloorYOffset;
Vector3 nouvellePosition = Vector3.MoveTowards(actor.transform.position, destination, pas);
Vector3 mouvement = new Vector3(nouvellePosition.x - actor.transform.position.x, nouvellePosition.y - actor.transform.position.y, nouvellePosition.z - actor.transform.position.z);
float angle = Mathf.Atan2(mouvement.x, mouvement.z) * Mathf.Rad2Deg;
actor.transform.position = nouvellePosition;
actor.transform.rotation = Quaternion.AngleAxis(angle, Vector3.up);
}
public bool FoundAIInPerceptionRange()
{
ActorAI opponentAI = Actor.Sensor.NeareastNonAllyAI(Actor);
if (opponentAI != null)
{
if (AIOutsideDeathCircle(opponentAI))
{
opponentAI = null;
return(false);
}
aiInPerceptionRange = opponentAI;
return(true);
}
return(false);
}
private bool AIOutsideDeathCircle(ActorAI aiActor)
{
bool isOutsideDeathCircle = false;
Vector2 aiActorPosition = Vector2.zero;
Vector2 deathCirclePosition = Vector2.zero;
aiActorPosition.x = aiActor.transform.position.x;
aiActorPosition.y = aiActor.transform.position.z;
deathCirclePosition.x = DeathCircleCenterPosition.x;
deathCirclePosition.y = DeathCircleCenterPosition.z;
float aiActorDistanceOutsideDeathCircle = Vector2.Distance(aiActorPosition, deathCirclePosition) - DeathCircleRadius;
if (aiActorDistanceOutsideDeathCircle > 0.0f)
{
isOutsideDeathCircle = true;
}
return(isOutsideDeathCircle);
}
public void FindTargetItemMapDestination(ActorAI actor)
{
Item item = actor.Sensor.NeareastNonEquippedItem(actor.transform.position);
actor.Brain.UpdateItemOnMapKnowledge(item);
if (item != null)
{
Vector3 newDestination = Vector3.zero;
newDestination.x = item.transform.position.x;
newDestination.z = item.transform.position.z;
newDestination.y = FloorYOffset;
ItemTargetDestination = newDestination;
ItemTargetDestinationIsKnown = true;
}
else
{
ItemTargetDestinationIsKnown = false;
}
}
public void Move(ActorAI actor)
{
MoveDestination(AIMoveTarget, actor);
}
public EquipmentManager(ActorAI actor)
{
this.Actor = actor;
}
public GoalEvaluator(ActorAI actor)
{
this.actor = actor;
}
private bool FoundFleeDestination(ActorAI actor)
{
Vector3 fleeDirection = Vector3.zero;
Vector3 aiCurrentPosition = actor.transform.position;
Vector3 fleeDestination = aiCurrentPosition;
if (actor.Brain.PlayerInPerceptionRange != null && aiCurrentPosition != null)
{
fleeDirection = -(actor.Brain.PlayerInPerceptionRange.transform.position - aiCurrentPosition);
fleeDirection.Normalize();
fleeDirection *= FleeRange;
fleeDestination.x += fleeDirection.x;
fleeDestination.z += fleeDirection.z;
}
else if (actor.Brain.AiInPerceptionRange != null && aiCurrentPosition != null)
{
fleeDirection = -(actor.Brain.AiInPerceptionRange.transform.position - aiCurrentPosition);
fleeDirection.Normalize();
fleeDirection *= FleeRange;
fleeDestination.x += fleeDirection.x;
fleeDestination.z += fleeDirection.z;
}
else
{
return(false);
}
fleeDestination.y = FloorYOffset;
if (ValidateMapDestination(fleeDestination))
{
MapDestination = fleeDestination;
return(true);
}
else
{
Vector3 actualInvalideFleeDirection = fleeDestination - aiCurrentPosition;
Vector3 up = new Vector3(0, 1, 0);
Vector3 down = new Vector3(0, -1, 0);
Vector3 upPerpendicularFleeDirection = Vector3.Cross(actualInvalideFleeDirection, up);
Vector3 downPerpendicularFleeDirection = Vector3.Cross(actualInvalideFleeDirection, down);
upPerpendicularFleeDirection.Normalize();
upPerpendicularFleeDirection *= FleeRange;
downPerpendicularFleeDirection.Normalize();
downPerpendicularFleeDirection *= FleeRange;
Vector3 fleeDestinationUp = aiCurrentPosition;
fleeDestinationUp.x += upPerpendicularFleeDirection.x;
fleeDestinationUp.z += upPerpendicularFleeDirection.z;
fleeDestinationUp.y = FloorYOffset;
Vector3 fleeDestinationDown = aiCurrentPosition;
fleeDestinationDown.x += downPerpendicularFleeDirection.x;
fleeDestinationDown.z += downPerpendicularFleeDirection.z;
fleeDestinationDown.y = FloorYOffset;
if (ValidateMapDestination(fleeDestinationDown))
{
MapDestination = fleeDestinationDown;
return(true);
}
else if (ValidateMapDestination(fleeDestinationUp))
{
MapDestination = fleeDestinationUp;
return(true);
}
}
return(false);
}
public void SetDeathCircleFleeDestination(ActorAI actor)
{
if (actor.Brain.ExistVisibleOpponent() && FoundFleeDestination(actor))
{
//Safe circle flee direction
Vector3 fleeDirection = Vector3.zero;
Vector3 aiCurrentPosition = actor.transform.position;
Vector3 fleeDestination = aiCurrentPosition;
fleeDirection = actor.Brain.SafeCircleCenterPosition - aiCurrentPosition;
fleeDirection.y = FloorYOffset;
fleeDirection.Normalize();
Vector3 opponentEscapingDirection = MapDestination;
opponentEscapingDirection.y = FloorYOffset;
opponentEscapingDirection.Normalize();
float scalarProduct = Vector3.Dot(fleeDirection, opponentEscapingDirection);
float opponentPositionFactor = 1.0f;
if (actor.Brain.CurrentDistanceOutsideSafeCircle > 0.0f)
{
float expectedLifePointLoss = (actor.Brain.CurrentDistanceOutsideSafeCircle / currentSpeedLevel) * actor.Brain.CurrentDeathCircleHurtPoints;
opponentPositionFactor = (actor.AIHealth.HealthPoints - expectedLifePointLoss) / actor.AIHealth.HealthPoints;
if (opponentPositionFactor < 0.0f)
{
opponentPositionFactor = 0.0f;
}
}
if (scalarProduct > 0.0f)
{
fleeDirection = opponentPositionFactor * opponentEscapingDirection + fleeDirection;
}
else
{
opponentEscapingDirection = -opponentEscapingDirection;
Vector3 yPerpendicularVector = Vector3.Cross(fleeDirection, opponentEscapingDirection);
yPerpendicularVector.Normalize();
opponentEscapingDirection = Vector3.Cross(fleeDirection, yPerpendicularVector);
opponentEscapingDirection.y = FloorYOffset;
opponentEscapingDirection.Normalize();
fleeDirection = opponentPositionFactor * opponentEscapingDirection + fleeDirection;
fleeDirection.y = FloorYOffset;
}
fleeDirection.Normalize();
fleeDirection *= FleeRange;
fleeDestination.x += fleeDirection.x;
fleeDestination.z += fleeDirection.z;
MapDestination = fleeDestination;
}
else
{
Vector3 fleeDirection = Vector3.zero;
Vector3 aiCurrentPosition = actor.transform.position;
Vector3 fleeDestination = aiCurrentPosition;
fleeDirection = actor.Brain.SafeCircleCenterPosition - aiCurrentPosition;
fleeDirection.y = FloorYOffset;
fleeDirection.Normalize();
fleeDirection *= FleeRange;
fleeDestination.x += fleeDirection.x;
fleeDestination.z += fleeDirection.z;
MapDestination = fleeDestination;
}
MapDestinationIsKnown = true;
}
private void ResetActualPerception()
{
aiInPerceptionRange = null;
playerInPerceptionRange = null;
itemInPerceptionRange = null;
}
public void UpdateOpponentOnMapKnowledge(PlayerController opponentPlayer, ActorAI opponnentAI)
{
playerInPerceptionRange = opponentPlayer;
aiInPerceptionRange = opponnentAI;
}
public HealthManager(ActorAI actor)
{
this.Actor = actor;
}
