861 lines
22 KiB
C#
861 lines
22 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.Events;
|
|
|
|
public class manageAITarget : MonoBehaviour
|
|
{
|
|
[Header ("AI Settings")]
|
|
[Space]
|
|
|
|
public float timeToCheckSuspect;
|
|
|
|
public LayerMask layerMask;
|
|
public LayerMask layerToCheckTargets;
|
|
|
|
public string functionToShoot;
|
|
|
|
public float extraFieldOfViewRadiusOnSpot;
|
|
|
|
public bool checkRaycastToViewTarget = true;
|
|
public LayerMask layerToCheckRaycastToViewTarget;
|
|
|
|
[Space]
|
|
[Header ("Range Vision Settings")]
|
|
[Space]
|
|
|
|
public float visionRange = 90;
|
|
public float minDistanceToAdquireTarget = 2;
|
|
public bool allowDetectionWhenTooCloseEvenNotVisible;
|
|
|
|
public bool ignoreVisionRangeActive;
|
|
public float checkIfTargetIsPhysicallyVisibleRadius = 0.2f;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public string factionToChangeName = "Friend Turrets";
|
|
|
|
public string surprisedCharacterStateName = "Surprised";
|
|
public string wonderingCharacterStateName = "Wondering";
|
|
|
|
public bool alertFactionOnSpotted;
|
|
public float alertFactionRadius = 10;
|
|
|
|
[Space]
|
|
[Header ("AI State")]
|
|
[Space]
|
|
|
|
public bool onSpotted;
|
|
public bool paused;
|
|
public bool hacking;
|
|
public bool checkingThreat;
|
|
public bool targetIsCharacter;
|
|
public bool targetIsVehicle;
|
|
public bool threatInfoStored;
|
|
|
|
public bool seeingCurrentTarget;
|
|
|
|
public GameObject enemyToShoot;
|
|
|
|
public GameObject posibleThreat;
|
|
|
|
public Transform placeToShoot;
|
|
|
|
public bool differentEnemy;
|
|
|
|
public GameObject currentObjectDetectedByRaycast;
|
|
|
|
[Space]
|
|
[Header ("Targets Debug")]
|
|
[Space]
|
|
|
|
public List<GameObject> enemies = new List<GameObject> ();
|
|
public List<GameObject> notEnemies = new List<GameObject> ();
|
|
|
|
public List<GameObject> fullEnemyList = new List<GameObject> ();
|
|
|
|
[Space]
|
|
[Header ("Gizmo Settings")]
|
|
[Space]
|
|
|
|
public bool showGizmo;
|
|
public Color gizmoColor = Color.red;
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventsOnSpotted;
|
|
public UnityEvent eventOnSpotted;
|
|
public UnityEvent eventOnNoTargetsToAttack;
|
|
|
|
[Space]
|
|
[Header ("AI Elements")]
|
|
[Space]
|
|
|
|
public Transform rayCastPosition;
|
|
public SphereCollider fovTrigger;
|
|
|
|
public GameObject hackDevice;
|
|
|
|
public checkCollisionType viewTrigger;
|
|
public characterFactionManager factionManager;
|
|
public characterStateIconSystem characterStateIconManager;
|
|
|
|
RaycastHit hit;
|
|
float originalFOVRadius;
|
|
float timeToCheck = 0;
|
|
float speedMultiplier = 1;
|
|
|
|
bool hackFailed;
|
|
|
|
playerController currentPlayerController;
|
|
vehicleHUDManager currentVehicleHUDManager;
|
|
characterFactionManager characterFactionToCheck;
|
|
|
|
bool hasBeenAttacked;
|
|
Vector3 targetDirection;
|
|
bool enemyAlertActive;
|
|
|
|
float timeWithoutThreatFound;
|
|
|
|
Vector3 currentPosition;
|
|
|
|
bool targetIsDriving;
|
|
|
|
GameObject previousEnemy;
|
|
|
|
float currentDistance;
|
|
|
|
Vector3 targetToCheckDirection;
|
|
Transform temporalPlaceToShoot;
|
|
Vector3 targetToCheckPosition;
|
|
Vector3 targetToCheckRaycastPosition;
|
|
vehicleHUDManager temporalVehicleHUDManagerToCheck;
|
|
|
|
void Start ()
|
|
{
|
|
originalFOVRadius = fovTrigger.radius;
|
|
|
|
if (hackDevice != null) {
|
|
if (tag.Equals ("friend")) {
|
|
if (hackDevice.activeSelf) {
|
|
hackDevice.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
if (!hacking && !paused) {
|
|
|
|
closestTarget ();
|
|
|
|
if (onSpotted) {
|
|
|
|
lootAtTarget (placeToShoot);
|
|
|
|
if (enemyToShoot != null) {
|
|
if (Physics.Raycast (rayCastPosition.position, rayCastPosition.forward, out hit, Mathf.Infinity, layerMask)) {
|
|
if (hit.collider.gameObject == enemyToShoot || hit.collider.gameObject.transform.IsChildOf (enemyToShoot.transform)) {
|
|
targetDirection = enemyToShoot.transform.position - transform.position;
|
|
|
|
float angleWithTarget = Vector3.SignedAngle (rayCastPosition.forward, targetDirection, enemyToShoot.transform.up);
|
|
|
|
if (Mathf.Abs (angleWithTarget) < visionRange / 2 || ignoreVisionRangeActive) {
|
|
shootTarget ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//if the turret detects a target, it will check if it is an enemy, and this will take 2 seconds, while the enemy choose to leave or stay in the place
|
|
else if (checkingThreat) {
|
|
if (posibleThreat != null) {
|
|
if (!placeToShoot) {
|
|
//every object with a health component, has a place to be shoot, to avoid that a enemy shoots the player in his foot, so to center the shoot
|
|
//it is used the gameObject placetoshoot in the health script
|
|
if (applyDamage.checkIfDead (posibleThreat)) {
|
|
cancelCheckSuspect (posibleThreat);
|
|
|
|
return;
|
|
} else {
|
|
placeToShoot = applyDamage.getPlaceToShoot (posibleThreat);
|
|
}
|
|
}
|
|
|
|
if (!threatInfoStored) {
|
|
currentPlayerController = posibleThreat.GetComponent<playerController> ();
|
|
|
|
if (currentPlayerController != null) {
|
|
if (currentPlayerController.isCharacterVisibleToAI ()) {
|
|
setCharacterStateIcon (wonderingCharacterStateName);
|
|
}
|
|
} else {
|
|
setCharacterStateIcon (wonderingCharacterStateName);
|
|
}
|
|
|
|
threatInfoStored = true;
|
|
}
|
|
|
|
if (placeToShoot != null) {
|
|
//look at the target position
|
|
lootAtTarget (placeToShoot);
|
|
}
|
|
|
|
//uses a raycast to check the posible threat
|
|
if (Physics.Raycast (rayCastPosition.position, rayCastPosition.forward, out hit, Mathf.Infinity, layerMask)) {
|
|
if (hit.collider.gameObject == posibleThreat || hit.collider.gameObject.transform.IsChildOf (posibleThreat.transform)) {
|
|
timeToCheck += Time.deltaTime * speedMultiplier;
|
|
} else {
|
|
timeWithoutThreatFound += Time.deltaTime * speedMultiplier;
|
|
}
|
|
|
|
//when the turret look at the target for a while, it will open fire
|
|
if (timeToCheck > timeToCheckSuspect) {
|
|
timeToCheck = 0;
|
|
|
|
checkingThreat = false;
|
|
|
|
addEnemy (posibleThreat);
|
|
|
|
posibleThreat = null;
|
|
|
|
disableCharacterStateIcon ();
|
|
}
|
|
|
|
if (timeWithoutThreatFound > timeToCheckSuspect) {
|
|
resetCheckThreatValues ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void resetCheckThreatValues ()
|
|
{
|
|
placeToShoot = null;
|
|
posibleThreat = null;
|
|
checkingThreat = false;
|
|
timeToCheck = 0;
|
|
timeWithoutThreatFound = 0;
|
|
|
|
disableCharacterStateIcon ();
|
|
}
|
|
|
|
//follow the enemy position, to rotate torwards his direction
|
|
void lootAtTarget (Transform objective)
|
|
{
|
|
if (showGizmo) {
|
|
Debug.DrawRay (rayCastPosition.position, rayCastPosition.forward, Color.red);
|
|
}
|
|
|
|
if (objective != null) {
|
|
Vector3 targetDir = objective.position - rayCastPosition.position;
|
|
Quaternion targetRotation = Quaternion.LookRotation (targetDir, transform.up);
|
|
rayCastPosition.rotation = Quaternion.Slerp (rayCastPosition.rotation, targetRotation, 10 * Time.deltaTime);
|
|
}
|
|
}
|
|
|
|
public bool checkCharacterFaction (GameObject character, bool damageReceived)
|
|
{
|
|
if (fullEnemyList.Contains (character)) {
|
|
return true;
|
|
}
|
|
|
|
characterFactionToCheck = character.GetComponent<characterFactionManager> ();
|
|
|
|
if (characterFactionToCheck != null) {
|
|
bool isEnemy = false;
|
|
|
|
if (damageReceived) {
|
|
isEnemy = factionManager.isAttackerEnemy (characterFactionToCheck.getFactionName ());
|
|
} else {
|
|
isEnemy = factionManager.isCharacterEnemy (characterFactionToCheck.getFactionName ());
|
|
}
|
|
|
|
if (characterFactionToCheck.isIgnoreCharacterFactionEnabled ()) {
|
|
isEnemy = false;
|
|
}
|
|
|
|
return isEnemy;
|
|
} else {
|
|
currentVehicleHUDManager = character.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
if (currentVehicleHUDManager.isVehicleBeingDriven ()) {
|
|
GameObject currentDriver = currentVehicleHUDManager.getCurrentDriver ();
|
|
|
|
if (currentDriver == null) {
|
|
return false;
|
|
}
|
|
|
|
characterFactionToCheck = currentDriver.GetComponent<characterFactionManager> ();
|
|
|
|
if (characterFactionToCheck != null) {
|
|
bool isEnemy = false;
|
|
|
|
if (damageReceived) {
|
|
isEnemy = factionManager.isAttackerEnemy (characterFactionToCheck.getFactionName ());
|
|
} else {
|
|
isEnemy = factionManager.isCharacterEnemy (characterFactionToCheck.getFactionName ());
|
|
}
|
|
|
|
if (characterFactionToCheck.isIgnoreCharacterFactionEnabled ()) {
|
|
isEnemy = false;
|
|
}
|
|
|
|
targetIsDriving = true;
|
|
|
|
return isEnemy;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//check if the object which has collided with the viewTrigger (the capsule collider in the head of the turret) is an enemy checking the tag of that object
|
|
void checkSuspect (GameObject currentSuspect)
|
|
{
|
|
if (canCheckSuspect (currentSuspect.layer)) {
|
|
if (checkCharacterFaction (currentSuspect, false) && !onSpotted && posibleThreat == null) {
|
|
|
|
if (targetIsDriving || applyDamage.isVehicle (currentSuspect)) {
|
|
targetIsDriving = false;
|
|
targetIsVehicle = true;
|
|
}
|
|
|
|
if (!checkRaycastToViewTarget || checkIfTargetIsPhysicallyVisible (currentSuspect, true)) {
|
|
posibleThreat = currentSuspect;
|
|
checkingThreat = true;
|
|
hacking = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//in the object exits from the viewTrigger, the turret rotates again to search more enemies
|
|
void cancelCheckSuspect (GameObject col)
|
|
{
|
|
if (checkCharacterFaction (col, false) && !onSpotted && posibleThreat != null) {
|
|
placeToShoot = null;
|
|
posibleThreat = null;
|
|
checkingThreat = false;
|
|
timeToCheck = 0;
|
|
|
|
SendMessage ("cancelCheckSuspectTurret", SendMessageOptions.DontRequireReceiver);
|
|
|
|
disableCharacterStateIcon ();
|
|
}
|
|
}
|
|
|
|
//the sphere collider with the trigger of the turret has detected an enemy, so it is added to the list of enemies
|
|
void enemyDetected (GameObject col)
|
|
{
|
|
if (checkCharacterFaction (col, false)) {
|
|
addEnemy (col.gameObject);
|
|
}
|
|
}
|
|
|
|
//one of the enemies has left, so it is removed from the enemies list
|
|
void enemyLost (GameObject col)
|
|
{
|
|
//if (onSpotted) {
|
|
removeEnemy (col.gameObject);
|
|
//}
|
|
}
|
|
|
|
void enemyAlert (GameObject target)
|
|
{
|
|
enemyDetected (target);
|
|
|
|
enemyAlertActive = true;
|
|
}
|
|
|
|
//if anyone shoot the turret, increase its field of view to search any enemy close to it
|
|
public void checkShootOrigin (GameObject attacker)
|
|
{
|
|
if (!onSpotted) {
|
|
if (checkCharacterFaction (attacker, true)) {
|
|
addEnemy (attacker);
|
|
|
|
factionManager.addDetectedEnemyFromFaction (attacker);
|
|
|
|
hasBeenAttacked = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//add an enemy to the list, checking that that enemy is not already in the list
|
|
void addEnemy (GameObject enemy)
|
|
{
|
|
if (!enemies.Contains (enemy)) {
|
|
enemies.Add (enemy);
|
|
|
|
if (!fullEnemyList.Contains (enemy)) {
|
|
fullEnemyList.Add (enemy);
|
|
}
|
|
}
|
|
}
|
|
|
|
//remove an enemy from the list
|
|
void removeEnemy (GameObject enemy)
|
|
{
|
|
//remove this enemy from the faction system detected enemies for the faction of this character
|
|
factionManager.removeDetectedEnemyFromFaction (enemy);
|
|
|
|
enemies.Remove (enemy);
|
|
}
|
|
|
|
void addNotEnemey (GameObject notEnemy)
|
|
{
|
|
if (!notEnemies.Contains (notEnemy)) {
|
|
characterFactionToCheck = notEnemy.GetComponent<characterFactionManager> ();
|
|
|
|
if (characterFactionToCheck != null) {
|
|
notEnemies.Add (notEnemy);
|
|
}
|
|
}
|
|
}
|
|
|
|
void removeNotEnemy (GameObject notEnemy)
|
|
{
|
|
if (notEnemies.Contains (notEnemy)) {
|
|
notEnemies.Remove (notEnemy);
|
|
}
|
|
}
|
|
|
|
//when there is one enemy or more, check which is the closest to shoot it.
|
|
void closestTarget ()
|
|
{
|
|
if (enemies.Count > 0) {
|
|
currentPosition = transform.position;
|
|
|
|
float min = Mathf.Infinity;
|
|
int index = -1;
|
|
|
|
int enemiesCount = enemies.Count;
|
|
|
|
for (int i = 0; i < enemiesCount; i++) {
|
|
if (enemies [i] != null) {
|
|
|
|
currentDistance = GKC_Utils.distance (enemies [i].transform.position, currentPosition);
|
|
|
|
if (currentDistance < min) {
|
|
min = currentDistance;
|
|
index = i;
|
|
}
|
|
} else {
|
|
enemies.RemoveAt (i);
|
|
|
|
i = 0;
|
|
|
|
enemiesCount = enemies.Count;
|
|
}
|
|
}
|
|
|
|
if (index < 0) {
|
|
return;
|
|
}
|
|
|
|
enemyToShoot = enemies [index];
|
|
|
|
if (enemyToShoot != previousEnemy) {
|
|
differentEnemy = true;
|
|
} else {
|
|
differentEnemy = false;
|
|
}
|
|
|
|
if (placeToShoot == null || differentEnemy) {
|
|
placeToShoot = applyDamage.getPlaceToShoot (enemyToShoot);
|
|
}
|
|
|
|
if (applyDamage.checkIfDead (enemyToShoot)) {
|
|
removeEnemy (enemyToShoot);
|
|
|
|
return;
|
|
}
|
|
|
|
if (differentEnemy) {
|
|
currentPlayerController = enemyToShoot.GetComponent<playerController> ();
|
|
}
|
|
|
|
if (currentPlayerController != null) {
|
|
if (currentPlayerController.isPlayerDriving ()) {
|
|
removeEnemy (enemyToShoot);
|
|
|
|
targetIsCharacter = false;
|
|
|
|
return;
|
|
} else {
|
|
targetIsCharacter = true;
|
|
targetIsVehicle = false;
|
|
}
|
|
} else {
|
|
if (differentEnemy) {
|
|
currentVehicleHUDManager = enemyToShoot.GetComponent<vehicleHUDManager> ();
|
|
}
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
if (!currentVehicleHUDManager.isVehicleBeingDriven ()) {
|
|
|
|
removeEnemy (enemyToShoot);
|
|
|
|
return;
|
|
} else {
|
|
targetIsCharacter = false;
|
|
targetIsVehicle = true;
|
|
}
|
|
} else {
|
|
targetIsCharacter = false;
|
|
}
|
|
}
|
|
|
|
if (previousEnemy != enemyToShoot) {
|
|
previousEnemy = enemyToShoot;
|
|
}
|
|
|
|
if (!onSpotted) {
|
|
//the player can hack the turrets, but for that he has to crouch, so he can reach the back of the turret and activate the panel
|
|
// if the player fails in the hacking or he gets up, the turret will detect the player and will start to fire him
|
|
//check if the player fails or get up
|
|
|
|
seeingCurrentTarget = false;
|
|
|
|
if (checkRaycastToViewTarget) {
|
|
seeingCurrentTarget = checkIfTargetIsPhysicallyVisible (enemyToShoot, false);
|
|
} else {
|
|
seeingCurrentTarget = true;
|
|
}
|
|
|
|
if (seeingCurrentTarget) {
|
|
//if an enemy is inside the trigger, check its position with respect the AI, if the target is in the vision range, adquire it as target
|
|
targetDirection = enemyToShoot.transform.position - currentPosition;
|
|
|
|
float angleWithTarget = Vector3.SignedAngle (rayCastPosition.forward, targetDirection, enemyToShoot.transform.up);
|
|
|
|
if (Mathf.Abs (angleWithTarget) < visionRange / 2 || hasBeenAttacked || enemyAlertActive || ignoreVisionRangeActive) {
|
|
if (currentPlayerController != null) {
|
|
if ((!currentPlayerController.isCrouching () || hackFailed || checkingThreat || enemyAlertActive || hasBeenAttacked) &&
|
|
currentPlayerController.isCharacterVisibleToAI ()) {
|
|
|
|
hasBeenAttacked = false;
|
|
|
|
enemyAlertActive = false;
|
|
|
|
hackFailed = false;
|
|
targetAdquired ();
|
|
}
|
|
} else {
|
|
//else, the target is a friend of the player, so shoot him
|
|
targetAdquired ();
|
|
}
|
|
} else {
|
|
//else check the distance, if the target is too close, adquire it as target too
|
|
float distanceToTarget = GKC_Utils.distance (enemyToShoot.transform.position, currentPosition);
|
|
|
|
if (distanceToTarget < minDistanceToAdquireTarget && (currentPlayerController.isCharacterVisibleToAI () || allowDetectionWhenTooCloseEvenNotVisible)) {
|
|
targetAdquired ();
|
|
}
|
|
//print ("out of range of vision");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//if there are no enemies
|
|
else {
|
|
if (onSpotted) {
|
|
placeToShoot = null;
|
|
enemyToShoot = null;
|
|
previousEnemy = null;
|
|
|
|
onSpotted = false;
|
|
|
|
fovTrigger.radius = originalFOVRadius;
|
|
|
|
viewTrigger.gameObject.SetActive (true);
|
|
|
|
hackFailed = false;
|
|
|
|
SendMessage ("setOnSpottedState", false, SendMessageOptions.DontRequireReceiver);
|
|
|
|
checkEventsOnSpotted (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool checkIfTargetIsPhysicallyVisible (GameObject targetToCheck, bool checkingSuspect)
|
|
{
|
|
targetToCheckRaycastPosition = transform.position + transform.up;
|
|
|
|
if (placeToShoot != null) {
|
|
targetToCheckDirection = placeToShoot.transform.position - targetToCheckRaycastPosition;
|
|
} else {
|
|
temporalPlaceToShoot = applyDamage.getPlaceToShoot (targetToCheck);
|
|
|
|
if (temporalPlaceToShoot != null) {
|
|
targetToCheckDirection = temporalPlaceToShoot.position - targetToCheckRaycastPosition;
|
|
} else {
|
|
targetToCheckDirection = (targetToCheck.transform.position + targetToCheck.transform.up) - targetToCheckRaycastPosition;
|
|
}
|
|
}
|
|
|
|
targetToCheckPosition = targetToCheckRaycastPosition + checkIfTargetIsPhysicallyVisibleRadius * targetToCheckDirection;
|
|
|
|
if (targetIsVehicle) {
|
|
temporalVehicleHUDManagerToCheck = applyDamage.getVehicleHUDManager (targetToCheck);
|
|
}
|
|
|
|
currentObjectDetectedByRaycast = null;
|
|
|
|
//Debug.DrawRay (targetToCheckPosition, targetToCheckDirection * 0.2f, Color.green);
|
|
if (Physics.Raycast (targetToCheckPosition, targetToCheckDirection, out hit, Mathf.Infinity, layerToCheckRaycastToViewTarget)) {
|
|
//print (hit.collider.gameObject.name + " " + targetIsVehicle);
|
|
//print (hit.collider.name + " " + hit.transform.IsChildOf (targetToCheck.transform) + " " + targetToCheck.name);
|
|
|
|
if ((!targetIsVehicle && (hit.collider.gameObject == targetToCheck || hit.transform.IsChildOf (targetToCheck.transform))) ||
|
|
(targetIsVehicle && temporalVehicleHUDManagerToCheck &&
|
|
((temporalVehicleHUDManagerToCheck.gameObject == targetToCheck && checkingSuspect) || temporalVehicleHUDManagerToCheck.checkIfDetectSurfaceBelongToVehicle (hit.collider)))) {
|
|
|
|
currentObjectDetectedByRaycast = hit.collider.gameObject;
|
|
|
|
if (showGizmo) {
|
|
Debug.DrawRay (rayCastPosition.position, targetToCheckDirection, Color.green, 2);
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
if (showGizmo) {
|
|
Debug.DrawRay (rayCastPosition.position, targetToCheckDirection, Color.red, 2);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
} else {
|
|
if (showGizmo) {
|
|
Debug.DrawRay (rayCastPosition.position, targetToCheckDirection, Color.black, 2);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void targetAdquired ()
|
|
{
|
|
//print ("target adquired");
|
|
|
|
onSpotted = true;
|
|
|
|
fovTrigger.radius = GKC_Utils.distance (enemyToShoot.transform.position, transform.position) + extraFieldOfViewRadiusOnSpot;
|
|
|
|
if (fovTrigger.radius < originalFOVRadius) {
|
|
fovTrigger.radius = originalFOVRadius;
|
|
}
|
|
|
|
viewTrigger.gameObject.SetActive (false);
|
|
|
|
SendMessage ("setOnSpottedState", true, SendMessageOptions.DontRequireReceiver);
|
|
|
|
//send this enemy to faction system for the detected enemies list
|
|
factionManager.addDetectedEnemyFromFaction (enemyToShoot);
|
|
|
|
setCharacterStateIcon (surprisedCharacterStateName);
|
|
|
|
if (alertFactionOnSpotted) {
|
|
factionManager.alertFactionOnSpotted (alertFactionRadius, enemyToShoot, transform.position);
|
|
}
|
|
|
|
checkEventsOnSpotted (true);
|
|
}
|
|
|
|
//active the fire mode
|
|
public void shootTarget ()
|
|
{
|
|
//SendMessage (functionToShoot, true);
|
|
}
|
|
|
|
public void pauseAI (bool state)
|
|
{
|
|
paused = state;
|
|
|
|
//SendMessage ("setPauseState", paused);
|
|
}
|
|
|
|
void OnTriggerEnter (Collider col)
|
|
{
|
|
checkTriggerInfo (col, true);
|
|
}
|
|
|
|
void OnTriggerExit (Collider col)
|
|
{
|
|
checkTriggerInfo (col, false);
|
|
}
|
|
|
|
public void checkPossibleTarget (GameObject objectToCheck)
|
|
{
|
|
Collider currentCollider = objectToCheck.GetComponent<Collider> ();
|
|
|
|
if (currentCollider != null) {
|
|
checkTriggerInfo (currentCollider, true);
|
|
}
|
|
}
|
|
|
|
public void checkTriggerInfo (Collider col, bool isEnter)
|
|
{
|
|
if (canCheckSuspect (col.gameObject.layer)) {
|
|
if (isEnter) {
|
|
if (!paused) {
|
|
if (checkCharacterFaction (col.gameObject, false)) {
|
|
enemyDetected (col.gameObject);
|
|
} else {
|
|
addNotEnemey (col.gameObject);
|
|
}
|
|
}
|
|
} else {
|
|
if (checkCharacterFaction (col.gameObject, false)) {
|
|
enemyLost (col.gameObject);
|
|
} else {
|
|
removeNotEnemy (col.gameObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool canCheckSuspect (int suspectLayer)
|
|
{
|
|
if ((1 << suspectLayer & layerToCheckTargets.value) == 1 << suspectLayer) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void setCorrectlyHackedState ()
|
|
{
|
|
setHackResult (true);
|
|
}
|
|
|
|
public void setIncorrectlyHackedState ()
|
|
{
|
|
setHackResult (false);
|
|
}
|
|
|
|
//check the result of the hacking, true the turret now is an ally, else, the turret detects the player
|
|
public void setHackResult (bool state)
|
|
{
|
|
hacking = false;
|
|
|
|
if (state) {
|
|
enemyHackPanel currentEnemyHackPanel = hackDevice.GetComponent<enemyHackPanel> ();
|
|
|
|
if (currentEnemyHackPanel != null) {
|
|
currentEnemyHackPanel.disablePanelHack ();
|
|
}
|
|
|
|
tag = "friend";
|
|
|
|
factionManager.changeCharacterToFaction (factionToChangeName);
|
|
|
|
//if the turret becomes an ally, change its icon color in the radar
|
|
mapObjectInformation currentMapObjectInformation = GetComponent<mapObjectInformation> ();
|
|
|
|
if (currentMapObjectInformation != null) {
|
|
currentMapObjectInformation.addMapObject ("Friend");
|
|
}
|
|
|
|
//set in the health slider the new name and slider color
|
|
health currentHealth = GetComponent<health> ();
|
|
|
|
if (currentHealth != null) {
|
|
currentHealth.hacked ();
|
|
}
|
|
|
|
enemies.Clear ();
|
|
|
|
notEnemies.Clear ();
|
|
|
|
fullEnemyList.Clear ();
|
|
} else {
|
|
hackFailed = true;
|
|
}
|
|
}
|
|
|
|
//the turret is been hacked
|
|
public void activateHack ()
|
|
{
|
|
hacking = true;
|
|
}
|
|
|
|
public void checkCharactersAroundAI ()
|
|
{
|
|
for (int i = 0; i < notEnemies.Count; i++) {
|
|
enemyDetected (notEnemies [i]);
|
|
}
|
|
}
|
|
|
|
public void setCharacterStateIcon (string stateName)
|
|
{
|
|
if (characterStateIconManager != null) {
|
|
characterStateIconManager.setCharacterStateIcon (stateName);
|
|
}
|
|
}
|
|
|
|
public void disableCharacterStateIcon ()
|
|
{
|
|
if (characterStateIconManager != null) {
|
|
characterStateIconManager.disableCharacterStateIcon ();
|
|
}
|
|
}
|
|
|
|
//disable ai when it dies
|
|
public void setAIStateToDead ()
|
|
{
|
|
enabled = false;
|
|
}
|
|
|
|
public void checkEventsOnSpotted (bool state)
|
|
{
|
|
if (useEventsOnSpotted) {
|
|
if (state) {
|
|
eventOnSpotted.Invoke ();
|
|
} else {
|
|
eventOnNoTargetsToAttack.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo) {
|
|
Gizmos.color = gizmoColor;
|
|
|
|
Gizmos.DrawWireSphere (transform.position, alertFactionRadius);
|
|
}
|
|
}
|
|
#endif
|
|
} |