786 lines
25 KiB
C#
786 lines
25 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class handleVehicleAIBehavior : AIBehaviorInfo
|
|
{
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public bool characterOnVehicle;
|
|
|
|
[Space]
|
|
[Header ("Custom Driver Settings")]
|
|
[Space]
|
|
|
|
public bool searchVehicleEnabled = true;
|
|
|
|
public bool startGameSearchingForVehicle;
|
|
|
|
public bool setVehicleToStart;
|
|
public GameObject vehicleToStart;
|
|
|
|
[Space]
|
|
|
|
public bool useMaxDistanceToGetVehicle;
|
|
|
|
public float maxDistanceToGetVehicle;
|
|
|
|
public float minDistanceToGetOnCurrentVehicle = 3.5f;
|
|
|
|
public bool ignoreCheckVehicleIfTargetToAttackFound;
|
|
|
|
[Space]
|
|
|
|
public bool stopBehaviorUpdateOnGetOffFromVehicle = true;
|
|
public bool stopBehaviorUpdateOnVehicleReached = true;
|
|
|
|
[Space]
|
|
[Header ("AI Driver Debug Info")]
|
|
[Space]
|
|
|
|
public bool searchingVehicle;
|
|
public bool vehicleToReachFound;
|
|
|
|
public bool currentVehicleAINavmeshLocated;
|
|
|
|
public bool getOffFromVehicleOnDestinyReached;
|
|
|
|
[Space]
|
|
|
|
public Transform currentVehicleToGet;
|
|
public vehicleAINavMesh currentVehicleAINavMesh;
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public bool useEventOnNoVehicleToPickFromScene;
|
|
public UnityEvent eventOnNoVehicleToPickFromScene;
|
|
|
|
[Space]
|
|
[Space]
|
|
|
|
[Space]
|
|
[Header ("Custom Passenger Settings")]
|
|
[Space]
|
|
|
|
public bool checkAIPassengerStateEnabled = true;
|
|
|
|
public bool ignoreCheckPartnerOnVehicle;
|
|
|
|
[Space]
|
|
[Header ("AI Passenger Debug Info")]
|
|
[Space]
|
|
|
|
public vehicleHUDManager currentVehicleHUDManager;
|
|
public vehicleHUDManager currentVehicleToAttack;
|
|
public GameObject currentVehicle;
|
|
public playerController playerControllerPartner;
|
|
|
|
public bool AICharacterWasntAbleToEnterOnPartnerVehicle;
|
|
public bool partnerFound;
|
|
|
|
public bool followingPartnerDrivingOnFoot;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public Transform AITransform;
|
|
public findObjectivesSystem mainFindObjectivesSystem;
|
|
public AINavMesh mainAINavmeshManager;
|
|
public playerController mainPlayerController;
|
|
public usingDevicesSystem usingDevicesManager;
|
|
|
|
|
|
Coroutine updateCoroutine;
|
|
|
|
bool followingTargetPreviously;
|
|
|
|
bool isVehicleFull = false;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
if (searchVehicleEnabled) {
|
|
if (startGameSearchingForVehicle) {
|
|
StartCoroutine (startGameSearchingForVehicleCoroutine ());
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------
|
|
//DRIVER FUNCTIONS
|
|
//------------------------------------------------------------
|
|
|
|
IEnumerator startGameSearchingForVehicleCoroutine ()
|
|
{
|
|
yield return new WaitForSeconds (0.3f);
|
|
|
|
activateAIBehavior ();
|
|
}
|
|
|
|
public override void activateAIBehavior ()
|
|
{
|
|
if (searchVehicleEnabled) {
|
|
updateCoroutine = StartCoroutine (updateSystemCoroutine ());
|
|
}
|
|
}
|
|
|
|
public override void deactivateAIBehavior ()
|
|
{
|
|
if (searchVehicleEnabled) {
|
|
stopUpdateCoroutine ();
|
|
}
|
|
}
|
|
|
|
public void stopUpdateCoroutine ()
|
|
{
|
|
if (updateCoroutine != null) {
|
|
StopCoroutine (updateCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator updateSystemCoroutine ()
|
|
{
|
|
var waitTime = new WaitForSecondsRealtime (0.0001f);
|
|
|
|
while (true) {
|
|
updateSystem ();
|
|
|
|
yield return waitTime;
|
|
}
|
|
}
|
|
|
|
public void setGetOffFromVehicleOnDestinyReachedState (bool state)
|
|
{
|
|
getOffFromVehicleOnDestinyReached = state;
|
|
}
|
|
|
|
void updateSystem ()
|
|
{
|
|
if (characterOnVehicle) {
|
|
if (currentVehicleAINavmeshLocated) {
|
|
if (currentVehicleAINavMesh.isFollowingTarget ()) {
|
|
followingTargetPreviously = true;
|
|
} else {
|
|
if (followingTargetPreviously) {
|
|
getOffFromVehicle ();
|
|
|
|
if (stopBehaviorUpdateOnGetOffFromVehicle) {
|
|
stopUpdateCoroutine ();
|
|
}
|
|
|
|
setCharacterOnVehicleState (false);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (searchingVehicle) {
|
|
bool vehicleReached = false;
|
|
|
|
if (currentVehicleToGet != null) {
|
|
if (GKC_Utils.distance (mainAINavmeshManager.transform.position, currentVehicleToGet.position) < minDistanceToGetOnCurrentVehicle) {
|
|
if (showDebugPrint) {
|
|
print ("picking vehicle " + currentVehicleToGet.name);
|
|
}
|
|
|
|
vehicleHUDManager currentVehicleHUDManager = currentVehicleToGet.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
IKDrivingSystem currentIKDrivingSystem = currentVehicleHUDManager.getIKDrivingSystem ();
|
|
|
|
if (currentIKDrivingSystem != null) {
|
|
currentIKDrivingSystem.setDriverExternally (AITransform.gameObject);
|
|
|
|
if (showDebugPrint) {
|
|
print ("sending character to vehicle");
|
|
}
|
|
|
|
mainAINavmeshManager.removeTarget ();
|
|
}
|
|
} else {
|
|
GKCSimpleRiderSystem currentGKCSimpleRiderSystem = currentVehicleToGet.GetComponent<GKCSimpleRiderSystem> ();
|
|
|
|
if (currentGKCSimpleRiderSystem != null) {
|
|
currentGKCSimpleRiderSystem.setDriverExternally (AITransform.gameObject);
|
|
|
|
if (showDebugPrint) {
|
|
print ("sending character to vehicle");
|
|
}
|
|
}
|
|
}
|
|
|
|
vehicleReached = true;
|
|
}
|
|
} else {
|
|
vehicleReached = true;
|
|
}
|
|
|
|
if (vehicleReached) {
|
|
mainFindObjectivesSystem.setSearchingObjectState (false);
|
|
|
|
searchingVehicle = false;
|
|
|
|
currentVehicleToGet = null;
|
|
|
|
mainFindObjectivesSystem.setIgnoreVisionRangeActiveState (true);
|
|
|
|
mainFindObjectivesSystem.resetAITargets ();
|
|
|
|
mainFindObjectivesSystem.setIgnoreVisionRangeActiveState (false);
|
|
|
|
mainFindObjectivesSystem.setOriginalWanderEnabled ();
|
|
|
|
setCharacterOnVehicleState (true);
|
|
|
|
if (showDebugPrint) {
|
|
print ("vehicle picked, resuming state on AI");
|
|
}
|
|
|
|
if (stopBehaviorUpdateOnVehicleReached) {
|
|
stopUpdateCoroutine ();
|
|
}
|
|
}
|
|
} else {
|
|
checkToFindVehicle ();
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkToFindVehicle ()
|
|
{
|
|
if (characterOnVehicle) {
|
|
|
|
return;
|
|
}
|
|
|
|
if (ignoreCheckVehicleIfTargetToAttackFound) {
|
|
if (mainFindObjectivesSystem.isOnSpotted ()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
setCharacterOnVehicleState (false);
|
|
|
|
bool vehicleFound = false;
|
|
|
|
bool ignoreSearchVehicleResult = false;
|
|
|
|
if (setVehicleToStart) {
|
|
if (vehicleToStart != null) {
|
|
Transform vehicleToStartTransform = null;
|
|
|
|
vehicleHUDManager currentVehicleHUDManager = vehicleToStart.GetComponentInChildren<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
vehicleToStartTransform = currentVehicleHUDManager.transform;
|
|
|
|
if (mainAINavmeshManager.updateCurrentNavMeshPath (vehicleToStartTransform.position)) {
|
|
setVehicleToReachToDrive (vehicleToStartTransform);
|
|
|
|
ignoreSearchVehicleResult = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!ignoreSearchVehicleResult) {
|
|
vehicleHUDManager [] vehicleHUDManagerList = FindObjectsOfType (typeof (vehicleHUDManager)) as vehicleHUDManager [];
|
|
|
|
List<Transform> vehiclesDetected = new List<Transform> ();
|
|
|
|
if (vehicleHUDManagerList.Length > 0) {
|
|
for (int i = 0; i < vehicleHUDManagerList.Length; i++) {
|
|
bool checkObjectResult = true;
|
|
|
|
if (vehicleHUDManagerList [i].getCurrentDriver () != null) {
|
|
checkObjectResult = false;
|
|
}
|
|
|
|
if (useMaxDistanceToGetVehicle) {
|
|
float distance = GKC_Utils.distance (vehicleHUDManagerList [i].transform.position, AITransform.position);
|
|
|
|
if (distance > maxDistanceToGetVehicle) {
|
|
checkObjectResult = false;
|
|
}
|
|
}
|
|
|
|
if (checkObjectResult) {
|
|
vehiclesDetected.Add (vehicleHUDManagerList [i].transform);
|
|
}
|
|
}
|
|
}
|
|
|
|
GKCSimpleRiderSystem [] GKCSimpleRiderSystemList = FindObjectsOfType (typeof (GKCSimpleRiderSystem)) as GKCSimpleRiderSystem [];
|
|
|
|
if (GKCSimpleRiderSystemList.Length > 0) {
|
|
for (int i = 0; i < GKCSimpleRiderSystemList.Length; i++) {
|
|
bool checkObjectResult = true;
|
|
|
|
if (GKCSimpleRiderSystemList [i].getCurrentDriver () != null) {
|
|
checkObjectResult = false;
|
|
}
|
|
|
|
if (useMaxDistanceToGetVehicle) {
|
|
float distance = GKC_Utils.distance (GKCSimpleRiderSystemList [i].transform.position, AITransform.position);
|
|
|
|
if (distance > maxDistanceToGetVehicle) {
|
|
checkObjectResult = false;
|
|
}
|
|
}
|
|
|
|
if (checkObjectResult) {
|
|
vehiclesDetected.Add (GKCSimpleRiderSystemList [i].transform);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (vehiclesDetected.Count == 0) {
|
|
if (showDebugPrint) {
|
|
print ("no vehicles detected");
|
|
}
|
|
|
|
stopUpdateCoroutine ();
|
|
}
|
|
|
|
if (vehiclesDetected.Count > 0) {
|
|
|
|
vehiclesDetected.Sort (delegate (Transform a, Transform b) {
|
|
return Vector3.Distance (AITransform.position, a.transform.position).CompareTo (Vector3.Distance (AITransform.position, b.transform.position));
|
|
});
|
|
|
|
if (showDebugPrint) {
|
|
print ("vehicles found on scene " + vehiclesDetected.Count);
|
|
}
|
|
|
|
for (int i = 0; i < vehiclesDetected.Count; i++) {
|
|
if (!vehicleFound) {
|
|
|
|
if (showDebugPrint) {
|
|
vehicleHUDManager currentVehicleHUDManager = vehiclesDetected [i].GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
print ("checking if vehicle with name " + currentVehicleHUDManager.getVehicleName () + " can be used");
|
|
} else {
|
|
GKCSimpleRiderSystem currentGKCSimpleRiderSystem = vehiclesDetected [i].GetComponent<GKCSimpleRiderSystem> ();
|
|
|
|
if (currentGKCSimpleRiderSystem != null) {
|
|
print ("checking if vehicle with name " + currentGKCSimpleRiderSystem.getVehicleName () + " can be used");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mainAINavmeshManager.updateCurrentNavMeshPath (vehiclesDetected [i].transform.position)) {
|
|
setVehicleToReachToDrive (vehiclesDetected [i]);
|
|
|
|
vehicleFound = true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("no vehicles found");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!vehicleFound) {
|
|
if (showDebugPrint) {
|
|
print ("vehicles found can't be reached, cancelling search");
|
|
}
|
|
|
|
stopUpdateCoroutine ();
|
|
|
|
if (useEventOnNoVehicleToPickFromScene) {
|
|
eventOnNoVehicleToPickFromScene.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
void setVehicleToReachToDrive (Transform vehicleTransform)
|
|
{
|
|
if (showDebugPrint) {
|
|
print ("vehicle to reach found ");
|
|
}
|
|
|
|
mainFindObjectivesSystem.setDrawOrHolsterWeaponState (false);
|
|
|
|
mainFindObjectivesSystem.setSearchingObjectState (true);
|
|
|
|
mainFindObjectivesSystem.setWanderEnabledState (false);
|
|
|
|
currentVehicleToGet = vehicleTransform;
|
|
|
|
vehicleHUDManager currentVehicleHUDManager = currentVehicleToGet.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
currentVehicleAINavMesh = currentVehicleHUDManager.getAIVehicleNavmesh ();
|
|
|
|
currentVehicleAINavmeshLocated = currentVehicleAINavMesh != null;
|
|
}
|
|
|
|
mainAINavmeshManager.setTarget (vehicleTransform);
|
|
|
|
mainAINavmeshManager.setTargetType (false, true);
|
|
|
|
followingTargetPreviously = false;
|
|
|
|
mainAINavmeshManager.lookAtTaget (false);
|
|
|
|
if (showDebugPrint) {
|
|
print ("vehicle to use located, setting searching vehicle state on AI");
|
|
}
|
|
|
|
searchingVehicle = true;
|
|
}
|
|
|
|
public override void updateAI ()
|
|
{
|
|
if (!behaviorEnabled) {
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public override void updateAIBehaviorState ()
|
|
{
|
|
if (!behaviorEnabled) {
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public override void updateAIAttackState (bool canUseAttack)
|
|
{
|
|
if (!behaviorEnabled) {
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public override void setSystemActiveState (bool state)
|
|
{
|
|
if (!behaviorEnabled) {
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public override void setWaitToActivateAttackActiveState (bool state)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------
|
|
//PASSENGER FUNCTIONS
|
|
//------------------------------------------------------------
|
|
|
|
public override void updateAIPassengerBehavior ()
|
|
{
|
|
if (!checkAIPassengerStateEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (!partnerFound) {
|
|
return;
|
|
}
|
|
|
|
if (playerControllerPartner == null) {
|
|
return;
|
|
}
|
|
|
|
if (!mainAINavmeshManager.isCharacterWaiting ()) {
|
|
if (ignoreCheckPartnerOnVehicle) {
|
|
if (playerControllerPartner.isPlayerDriving ()) {
|
|
if (!followingPartnerDrivingOnFoot) {
|
|
currentVehicle = playerControllerPartner.getCurrentVehicle ();
|
|
|
|
vehicleHUDManager currentVehicleHUDManagerToGetOn = currentVehicle.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManagerToGetOn != null) {
|
|
mainFindObjectivesSystem.setExtraMinDistanceState (true, currentVehicleHUDManagerToGetOn.getVehicleRadius ());
|
|
|
|
mainAINavmeshManager.setExtraMinDistanceState (true, currentVehicleHUDManagerToGetOn.getVehicleRadius ());
|
|
} else {
|
|
GKCSimpleRiderSystem currentGKCSimpleRiderSystemToGetOn = currentVehicle.GetComponent<GKCSimpleRiderSystem> ();
|
|
|
|
if (currentGKCSimpleRiderSystemToGetOn != null) {
|
|
|
|
mainFindObjectivesSystem.setExtraMinDistanceState (true, currentGKCSimpleRiderSystemToGetOn.getVehicleRadius ());
|
|
|
|
mainAINavmeshManager.setExtraMinDistanceState (true, currentGKCSimpleRiderSystemToGetOn.getVehicleRadius ());
|
|
}
|
|
}
|
|
|
|
followingPartnerDrivingOnFoot = true;
|
|
} else {
|
|
if (mainAINavmeshManager.isCharacterAttacking ()) {
|
|
removeStateOnVehicle ();
|
|
}
|
|
}
|
|
} else {
|
|
if (followingPartnerDrivingOnFoot) {
|
|
removeStateOnVehicle ();
|
|
}
|
|
}
|
|
} else {
|
|
if (playerControllerPartner.isPlayerDriving ()) {
|
|
if (!characterOnVehicle && !mainAINavmeshManager.isCharacterAttacking ()) {
|
|
|
|
if (currentVehicle == null) {
|
|
|
|
isVehicleFull = false;
|
|
|
|
currentVehicle = playerControllerPartner.getCurrentVehicle ();
|
|
|
|
vehicleHUDManager currentVehicleHUDManagerToGetOn = currentVehicle.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManagerToGetOn != null) {
|
|
|
|
mainFindObjectivesSystem.setExtraMinDistanceState (true, currentVehicleHUDManagerToGetOn.getVehicleRadius ());
|
|
|
|
mainAINavmeshManager.setExtraMinDistanceState (true, currentVehicleHUDManagerToGetOn.getVehicleRadius ());
|
|
|
|
mainFindObjectivesSystem.addNotEnemy (playerControllerPartner.gameObject);
|
|
|
|
isVehicleFull = currentVehicleHUDManagerToGetOn.isVehicleFull ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("partner is driving a GKC vehicle and the vehicle full result is " + isVehicleFull);
|
|
}
|
|
} else {
|
|
GKCSimpleRiderSystem currentGKCSimpleRiderSystemToGetOn = currentVehicle.GetComponent<GKCSimpleRiderSystem> ();
|
|
|
|
print (currentGKCSimpleRiderSystemToGetOn != null);
|
|
|
|
if (currentGKCSimpleRiderSystemToGetOn != null) {
|
|
|
|
mainFindObjectivesSystem.setExtraMinDistanceState (true, currentGKCSimpleRiderSystemToGetOn.getVehicleRadius ());
|
|
|
|
mainAINavmeshManager.setExtraMinDistanceState (true, currentGKCSimpleRiderSystemToGetOn.getVehicleRadius ());
|
|
|
|
mainFindObjectivesSystem.addNotEnemy (playerControllerPartner.gameObject);
|
|
|
|
isVehicleFull = currentGKCSimpleRiderSystemToGetOn.isVehicleFull () ||
|
|
currentGKCSimpleRiderSystemToGetOn.isVehicleOnlyForOnePlayerActive ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("partner is driving a GKC rider and the vehicle full result is " + isVehicleFull);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mainAINavmeshManager.isFollowingTarget ()) {
|
|
if (!AICharacterWasntAbleToEnterOnPartnerVehicle) {
|
|
if (mainPlayerController.canCharacterGetOnVehicles ()) {
|
|
if (isVehicleFull) {
|
|
AICharacterWasntAbleToEnterOnPartnerVehicle = true;
|
|
} else {
|
|
enterOnVehicle (currentVehicle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (mainAINavmeshManager.isCharacterAttacking ()) {
|
|
getOffFromVehicle ();
|
|
}
|
|
}
|
|
} else {
|
|
if (characterOnVehicle) {
|
|
getOffFromVehicle ();
|
|
} else if (AICharacterWasntAbleToEnterOnPartnerVehicle) {
|
|
removeStateOnVehicle ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setIgnoreCheckPartnerOnVehicleState (bool state)
|
|
{
|
|
ignoreCheckPartnerOnVehicle = state;
|
|
}
|
|
|
|
public void setCheckAIPassengerStateEnabledState (bool state)
|
|
{
|
|
checkAIPassengerStateEnabled = state;
|
|
}
|
|
|
|
public void enterOnVehicle (GameObject newVehicleObject)
|
|
{
|
|
if (AICharacterWasntAbleToEnterOnPartnerVehicle) {
|
|
if (showDebugPrint) {
|
|
print ("AI wasn't able to enter on vehicle, cancelling");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("characterOnVehicle " + true);
|
|
}
|
|
|
|
mainAINavmeshManager.pauseAI (true);
|
|
|
|
usingDevicesManager.addDeviceToList (newVehicleObject);
|
|
|
|
usingDevicesManager.getclosestDevice (false, false);
|
|
|
|
usingDevicesManager.setCurrentVehicle (newVehicleObject);
|
|
|
|
usingDevicesManager.useCurrentDevice (newVehicleObject);
|
|
|
|
if (mainPlayerController.isPlayerDriving ()) {
|
|
setCharacterOnVehicleState (true);
|
|
|
|
AICharacterWasntAbleToEnterOnPartnerVehicle = false;
|
|
} else {
|
|
setCharacterOnVehicleState (false);
|
|
|
|
AICharacterWasntAbleToEnterOnPartnerVehicle = true;
|
|
|
|
mainAINavmeshManager.pauseAI (false);
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print (gameObject.name + " " + mainPlayerController.isPlayerDriving () + " " + characterOnVehicle);
|
|
}
|
|
}
|
|
|
|
public override void getOffFromVehicle ()
|
|
{
|
|
if (showDebugPrint) {
|
|
print ("getOffFromVehicle " + gameObject.name);
|
|
}
|
|
|
|
if (characterOnVehicle) {
|
|
if (mainPlayerController.canCharacterGetOnVehicles ()) {
|
|
if (currentVehicle != null) {
|
|
usingDevicesManager.clearDeviceList ();
|
|
|
|
usingDevicesManager.addDeviceToList (currentVehicle);
|
|
|
|
usingDevicesManager.getclosestDevice (false, false);
|
|
|
|
usingDevicesManager.setCurrentVehicle (currentVehicle);
|
|
|
|
usingDevicesManager.useCurrentDevice (currentVehicle);
|
|
} else {
|
|
usingDevicesManager.useDevice ();
|
|
}
|
|
|
|
mainAINavmeshManager.pauseAI (false);
|
|
}
|
|
|
|
removeStateOnVehicle ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("remove AI from vehicle " + gameObject.name);
|
|
}
|
|
} else {
|
|
if (AICharacterWasntAbleToEnterOnPartnerVehicle) {
|
|
removeStateOnVehicle ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("remove state on vehicle " + gameObject.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void setCharacterOnVehicleState (bool state)
|
|
{
|
|
characterOnVehicle = state;
|
|
|
|
if (showDebugPrint) {
|
|
print (gameObject.name + " " + mainPlayerController.isPlayerDriving () + " " + characterOnVehicle);
|
|
}
|
|
}
|
|
|
|
public override void removeStateOnVehicle ()
|
|
{
|
|
currentVehicle = null;
|
|
|
|
setCharacterOnVehicleState (false);
|
|
|
|
followingPartnerDrivingOnFoot = false;
|
|
|
|
mainFindObjectivesSystem.setExtraMinDistanceState (false, 0);
|
|
|
|
mainAINavmeshManager.setExtraMinDistanceState (false, 0);
|
|
|
|
AICharacterWasntAbleToEnterOnPartnerVehicle = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("removeStateOnVehicle " + gameObject.name);
|
|
}
|
|
}
|
|
|
|
public override void setAICharacterOnVehicle (GameObject newVehicle)
|
|
{
|
|
if (characterOnVehicle) {
|
|
return;
|
|
}
|
|
|
|
currentVehicle = newVehicle;
|
|
|
|
bool isVehicleFull = false;
|
|
|
|
float vehicleRadius = 0;
|
|
|
|
vehicleHUDManager currentVehicleHUDManagerToGetOn = currentVehicle.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManagerToGetOn != null) {
|
|
isVehicleFull = currentVehicleHUDManagerToGetOn.isVehicleFull ();
|
|
|
|
vehicleRadius = currentVehicleHUDManagerToGetOn.getVehicleRadius ();
|
|
} else {
|
|
GKCSimpleRiderSystem currentGKCSimpleRiderSystem = currentVehicle.GetComponent<GKCSimpleRiderSystem> ();
|
|
|
|
if (currentGKCSimpleRiderSystem != null) {
|
|
isVehicleFull = currentGKCSimpleRiderSystem.isVehicleFull () ||
|
|
currentGKCSimpleRiderSystem.isVehicleOnlyForOnePlayerActive ();
|
|
|
|
vehicleRadius = currentGKCSimpleRiderSystem.getVehicleRadius ();
|
|
}
|
|
}
|
|
|
|
mainFindObjectivesSystem.setExtraMinDistanceState (true, vehicleRadius);
|
|
|
|
mainAINavmeshManager.setExtraMinDistanceState (true, vehicleRadius);
|
|
|
|
if (!isVehicleFull) {
|
|
if (mainPlayerController.canCharacterGetOnVehicles ()) {
|
|
enterOnVehicle (currentVehicle);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool isCharacterOnVehicle ()
|
|
{
|
|
return characterOnVehicle;
|
|
}
|
|
|
|
public override void setCurrentPlayerControllerPartner (playerController newPlayerController)
|
|
{
|
|
playerControllerPartner = newPlayerController;
|
|
|
|
partnerFound = playerControllerPartner != null;
|
|
}
|
|
}
|