plantilla base para movimiento básico
This commit is contained in:
Robii Aragon
2026-02-05 05:07:55 -08:00
parent ed7b223c04
commit fd87a6ffd5
14441 changed files with 13711084 additions and 20 deletions

View File

@@ -0,0 +1,785 @@
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;
}
}