2182 lines
83 KiB
C#
2182 lines
83 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.UI;
|
|
|
|
public class GKCSimpleRiderSystem : mainRiderSystem
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public string vehicleName;
|
|
|
|
public bool playerIsAlwaysDriver = true;
|
|
|
|
public float vehicleRadius = 3;
|
|
|
|
public bool playerVisibleInVehicle = true;
|
|
|
|
public bool resetCameraRotationWhenGetOff;
|
|
|
|
public int resetAnimatorDrivingStateID = 666777;
|
|
|
|
[Space]
|
|
|
|
public LayerMask obstacleLayer;
|
|
|
|
public bool checkIfDriverIsOnGroundOnGetOff;
|
|
|
|
public bool ignoreObstacleCheckOnGetOffEnabled;
|
|
|
|
[Space]
|
|
[Header ("Weapon Settings")]
|
|
[Space]
|
|
|
|
public bool hidePlayerWeaponsWhileDriving;
|
|
|
|
public bool drawFireWeaponIfCarryingPreviously = true;
|
|
public bool drawMeleeWeaponIfCarryingPreviously = true;
|
|
|
|
[Space]
|
|
[Header ("Vehicle Weapon Settings")]
|
|
[Space]
|
|
|
|
public bool useVehicleWeaponsEnabled;
|
|
|
|
public bool vehicleWeaponSystemUseRotationInput;
|
|
public Transform defaultVehicleWeaponSystemCameraTransform;
|
|
|
|
[Space]
|
|
[Header ("UI Settings")]
|
|
[Space]
|
|
|
|
public bool disablePlayerHUDEnabled = true;
|
|
|
|
public bool showVehicleHUD;
|
|
|
|
[Space]
|
|
[Header ("GameObject Settings")]
|
|
[Space]
|
|
|
|
public GameObject vehicleGameObject;
|
|
|
|
public Transform passengerParent;
|
|
|
|
public GameObject customVehicleGameObject;
|
|
|
|
public Transform vehicleCameraDirection;
|
|
|
|
[Space]
|
|
[Header ("Ride Object On Start Settings")]
|
|
[Space]
|
|
|
|
public bool startGameInThisVehicle;
|
|
|
|
public bool setCurrentPlayerManually;
|
|
|
|
public bool searchPlayerOnSceneIfNotAssigned = true;
|
|
|
|
public GameObject playerForVehicle;
|
|
|
|
[Space]
|
|
[Header ("Rider Single Driver Settings")]
|
|
[Space]
|
|
|
|
public IKDrivingSystem.IKDrivingInformation IKRiderInfo;
|
|
|
|
[Space]
|
|
[Header ("Rider Driver And Passengers Settings")]
|
|
[Space]
|
|
|
|
public List<IKDrivingSystem.IKDrivingInformation> IKVehiclePassengersList = new List<IKDrivingSystem.IKDrivingInformation> ();
|
|
|
|
[Space]
|
|
[Header ("Override System Settings")]
|
|
[Space]
|
|
|
|
public bool objectUseOverrideSystem;
|
|
|
|
public objectToOverrideSystem mainObjectToOverrideSystem;
|
|
|
|
[Space]
|
|
[Header ("Gravity Settings")]
|
|
[Space]
|
|
|
|
public bool changeDriverGravityWhenGetsOff = true;
|
|
public Vector3 regularGravity = new Vector3 (0, 1, 0);
|
|
public Vector3 currentNormal = new Vector3 (0, 1, 0);
|
|
|
|
public float minAngleDifferenceToRegularGravityToChangeWhenGetOff = 40;
|
|
|
|
public bool checkVehicleUpDirectionForGravityOnGetOff;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public List<Collider> colliderParts = new List<Collider> ();
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public bool riderActive;
|
|
|
|
public bool destroyed;
|
|
|
|
public GameObject currentRiderGameObject;
|
|
|
|
public bool isBeingDriven;
|
|
|
|
public bool passengerIsGettingOn;
|
|
|
|
public List<GameObject> passengerGameObjectList = new List<GameObject> ();
|
|
|
|
public List<IKDrivingSystem.passengerComponents> passengerComponentsList = new List<IKDrivingSystem.passengerComponents> ();
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventOnDriverGetOn;
|
|
public eventParameters.eventToCallWithGameObject eventOnDriverGetOn;
|
|
|
|
public bool useEventOnDriverGetOff;
|
|
public eventParameters.eventToCallWithGameObject eventOnDriverGetOff;
|
|
|
|
public bool useEventOnStartGame;
|
|
public float delayToActivateEventsOnStart;
|
|
public UnityEvent eventOnStartGame;
|
|
|
|
[Space]
|
|
[Header ("Remote Event Settings")]
|
|
[Space]
|
|
|
|
public bool useRemoteEventsOnPassengers;
|
|
public List<string> remoteEventNameListGetOn = new List<string> ();
|
|
public List<string> remoteEventNameListGetOff = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public inputActionManager mainInputActionManager;
|
|
|
|
public Rigidbody mainVehicleRigidbody;
|
|
public vehicleWeaponSystem mainVehicleWeaponSystem;
|
|
|
|
|
|
IKDrivingSystem.passengerComponents currentPassengerDriverComponents;
|
|
|
|
bool checkIfPlayerStartInVehicle;
|
|
|
|
bool playerAssignedProperly;
|
|
|
|
Vector3 customPassengerPosition = Vector3.zero;
|
|
|
|
bool enteringOnVehicleFromDistance;
|
|
|
|
bool getDriverPosition;
|
|
|
|
bool getOnlyPassengerSeatActive;
|
|
|
|
bool mainVehicleWeaponSystemInitialized;
|
|
|
|
|
|
|
|
void Start ()
|
|
{
|
|
if (useEventOnStartGame) {
|
|
if (delayToActivateEventsOnStart > 0) {
|
|
StartCoroutine (activateEventOnStartCoroutine ());
|
|
} else {
|
|
eventOnStartGame.Invoke ();
|
|
}
|
|
}
|
|
|
|
StartCoroutine (checkStartGameInVehicleCoroutine ());
|
|
}
|
|
|
|
IEnumerator activateEventOnStartCoroutine ()
|
|
{
|
|
yield return new WaitForSeconds (delayToActivateEventsOnStart);
|
|
|
|
eventOnStartGame.Invoke ();
|
|
}
|
|
|
|
IEnumerator checkStartGameInVehicleCoroutine ()
|
|
{
|
|
yield return new WaitForSeconds (0.01f);
|
|
|
|
checkStartGameInVehicle ();
|
|
}
|
|
|
|
void checkStartGameInVehicle ()
|
|
{
|
|
if (!checkIfPlayerStartInVehicle) {
|
|
if (startGameInThisVehicle) {
|
|
if (setCurrentPlayerManually || playerForVehicle == null) {
|
|
if (currentRiderGameObject == null) {
|
|
if (!playerAssignedProperly) {
|
|
findPlayerOnScene ();
|
|
}
|
|
}
|
|
|
|
playerForVehicle = currentRiderGameObject;
|
|
}
|
|
|
|
if (playerForVehicle != null) {
|
|
setDriverExternally (playerForVehicle);
|
|
} else {
|
|
print ("Warning: assign the player to drive this car in the field Player For Vehicle in IK Driving System inspector");
|
|
}
|
|
}
|
|
|
|
checkIfPlayerStartInVehicle = true;
|
|
}
|
|
|
|
}
|
|
|
|
public void setPlayerToStartGameOnThisVehicle (GameObject newPlayer)
|
|
{
|
|
startGameInThisVehicle = true;
|
|
|
|
playerForVehicle = newPlayer;
|
|
|
|
checkIfPlayerStartInVehicle = false;
|
|
}
|
|
|
|
public void setDriverExternally (GameObject currentDriver)
|
|
{
|
|
currentRiderGameObject = currentDriver;
|
|
|
|
if (currentRiderGameObject == null) {
|
|
return;
|
|
}
|
|
|
|
usingDevicesSystem usingDevicesManager = currentDriver.GetComponent<usingDevicesSystem> ();
|
|
|
|
if (usingDevicesManager != null) {
|
|
if (usingDevicesManager.usedByAI) {
|
|
getDriverPosition = true;
|
|
|
|
GKC_Utils.setAICharacterOnVehicle (vehicleGameObject, currentDriver);
|
|
|
|
getDriverPosition = false;
|
|
} else {
|
|
usingDevicesManager.clearDeviceList ();
|
|
|
|
usingDevicesManager.addDeviceToList (vehicleGameObject);
|
|
|
|
usingDevicesManager.updateClosestDeviceList ();
|
|
|
|
usingDevicesManager.setCurrentVehicle (vehicleGameObject);
|
|
|
|
getDriverPosition = true;
|
|
|
|
usingDevicesManager.useCurrentDevice (vehicleGameObject);
|
|
|
|
getDriverPosition = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setPassengerExternally (GameObject currentDriver)
|
|
{
|
|
usingDevicesSystem usingDevicesManager = currentDriver.GetComponent<usingDevicesSystem> ();
|
|
|
|
if (usingDevicesManager != null) {
|
|
if (usingDevicesManager.usedByAI) {
|
|
getDriverPosition = false;
|
|
|
|
getOnlyPassengerSeatActive = true;
|
|
|
|
GKC_Utils.setAICharacterOnVehicle (vehicleGameObject, currentDriver);
|
|
|
|
getOnlyPassengerSeatActive = false;
|
|
} else {
|
|
usingDevicesManager.clearDeviceList ();
|
|
|
|
usingDevicesManager.addDeviceToList (vehicleGameObject);
|
|
|
|
usingDevicesManager.updateClosestDeviceList ();
|
|
|
|
usingDevicesManager.setCurrentVehicle (vehicleGameObject);
|
|
|
|
getDriverPosition = false;
|
|
|
|
getOnlyPassengerSeatActive = true;
|
|
|
|
bool originalPlayerIsAlwaysDriverValue = playerIsAlwaysDriver;
|
|
|
|
playerIsAlwaysDriver = false;
|
|
|
|
usingDevicesManager.useCurrentDevice (vehicleGameObject);
|
|
|
|
playerIsAlwaysDriver = originalPlayerIsAlwaysDriverValue;
|
|
|
|
getOnlyPassengerSeatActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopDriveVehicleExternally ()
|
|
{
|
|
if (isBeingDriven) {
|
|
if (currentPassengerDriverComponents != null) {
|
|
if (currentPassengerDriverComponents.usingDevicesManager != null) {
|
|
currentPassengerDriverComponents.usingDevicesManager.clearDeviceList ();
|
|
|
|
currentPassengerDriverComponents.usingDevicesManager.addDeviceToList (vehicleGameObject);
|
|
|
|
currentPassengerDriverComponents.usingDevicesManager.setCurrentVehicle (vehicleGameObject);
|
|
|
|
currentPassengerDriverComponents.usingDevicesManager.useCurrentDevice (vehicleGameObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void activateDevice ()
|
|
{
|
|
if (isVehicleOnlyForOnePlayerActive ()) {
|
|
return;
|
|
}
|
|
|
|
addOrRemovePassengerToVehicle ();
|
|
}
|
|
|
|
void addOrRemovePassengerToVehicle ()
|
|
{
|
|
if (isVehicleFull () && !passengerGameObjectList.Contains (currentRiderGameObject)) {
|
|
return;
|
|
}
|
|
|
|
|
|
startOrStopVehicle (true);
|
|
|
|
riderActive = isBeingDriven;
|
|
}
|
|
|
|
public void setRiderState (bool state)
|
|
{
|
|
if (riderActive == state) {
|
|
return;
|
|
}
|
|
|
|
if (currentRiderGameObject == null) {
|
|
if (!playerAssignedProperly) {
|
|
findPlayerOnScene ();
|
|
|
|
if (currentRiderGameObject == null) {
|
|
print ("WARNING: no player controller has been assigned to the mission." +
|
|
" Make sure to use a trigger to activate the mission or assign the player manually");
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
riderActive = state;
|
|
|
|
if (showDebugPrint) {
|
|
print ("setting rider active state" + state);
|
|
}
|
|
|
|
if (IKVehiclePassengersList == null || IKVehiclePassengersList.Count == 0) {
|
|
if (!IKVehiclePassengersList.Contains (IKRiderInfo)) {
|
|
IKVehiclePassengersList.Add (IKRiderInfo);
|
|
}
|
|
}
|
|
|
|
if (objectUseOverrideSystem) {
|
|
startOrStopObjectToOverride (riderActive);
|
|
} else {
|
|
startOrStopVehicle (riderActive);
|
|
}
|
|
}
|
|
|
|
public void startOrStopObjectToOverride (bool state)
|
|
{
|
|
setPassengerInfo (IKRiderInfo, currentRiderGameObject);
|
|
|
|
passengerIsGettingOn = false;
|
|
|
|
IKDrivingSystem.IKDrivingInformation currentIKVehiclePassengerInfo = getIKVehiclePassengerInfo (currentRiderGameObject);
|
|
|
|
int currentPassengerIndex = passengerGameObjectList.IndexOf (currentRiderGameObject);
|
|
IKDrivingSystem.passengerComponents currentPassengerComponents = passengerComponentsList [currentPassengerIndex];
|
|
|
|
passengerIsGettingOn = currentIKVehiclePassengerInfo.vehicleSeatInfo.seatIsFree;
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.seatIsFree = !passengerIsGettingOn;
|
|
|
|
currentIKVehiclePassengerInfo.adjustPassengerPositionActive = true;
|
|
currentIKVehiclePassengerInfo.currentDriveIkWeightValue = 1;
|
|
currentIKVehiclePassengerInfo.disableIKOnPassengerSmoothly = false;
|
|
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOnVehicleActiveState (false);
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOffFromVehicleActiveState (false);
|
|
|
|
if (showDebugPrint) {
|
|
print ("passenger is getting on " + passengerIsGettingOn);
|
|
}
|
|
|
|
bool passengerOnDriverSeat = false;
|
|
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.isDriverSeat) {
|
|
passengerOnDriverSeat = true;
|
|
|
|
currentPassengerDriverComponents = currentPassengerComponents;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("is driver seat " + passengerOnDriverSeat);
|
|
}
|
|
|
|
currentPassengerComponents.passengerOnDriverSeat = passengerOnDriverSeat;
|
|
|
|
isBeingDriven = false;
|
|
|
|
if (passengerOnDriverSeat) {
|
|
isBeingDriven = passengerIsGettingOn;
|
|
} else {
|
|
isBeingDriven = false;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print (passengerIsGettingOn + " " + passengerOnDriverSeat + " " + isBeingDriven);
|
|
}
|
|
|
|
bool isPlayer = false;
|
|
|
|
if (!currentPassengerComponents.playerControllerManager.usedByAI) {
|
|
isPlayer = true;
|
|
}
|
|
|
|
if (vehicleCameraDirection == null) {
|
|
vehicleCameraDirection = vehicleGameObject.transform;
|
|
}
|
|
|
|
//set the state driving as the current state of the player
|
|
currentPassengerComponents.playerControllerManager.setDrivingState (passengerIsGettingOn, vehicleGameObject, vehicleName, vehicleCameraDirection);
|
|
|
|
currentPassengerComponents.passengerPhysicallyOnVehicle = true;
|
|
|
|
currentPassengerComponents.playerControllerManager.setUsingDeviceState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.playerControllerManager.setUsingGeneralDriveRiderSystem (passengerIsGettingOn);
|
|
|
|
if (passengerIsGettingOn) {
|
|
if (currentPassengerComponents.carryingMeleeWeaponsPreviously) {
|
|
GKC_Utils.checkIfDropThrownWeaponWhenUsingDevice (currentPassengerComponents.currentPassenger);
|
|
|
|
if (currentPassengerComponents.playerControllerManager.isPlayerUsingMeleeWeapons ()) {
|
|
currentPassengerComponents.statesManager.disableGrabMode ();
|
|
} else {
|
|
currentPassengerComponents.carryingMeleeWeaponsPreviously = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isPlayer) {
|
|
currentPassengerComponents.pauseManager.usingDeviceState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.mainInventoryManager.enableOrDisableWeaponSlotsParentOutOfInventory (!passengerIsGettingOn);
|
|
}
|
|
|
|
if (isPlayer) {
|
|
if (disablePlayerHUDEnabled) {
|
|
//enable and disable the player's HUD and the vehicle's HUD
|
|
currentPassengerComponents.mainPlayerHUDManager.enableOrDisableHUD (!passengerIsGettingOn);
|
|
}
|
|
|
|
if (showVehicleHUD) {
|
|
currentPassengerComponents.mainPlayerHUDManager.enableOrDisableVehicleHUD (isBeingDriven);
|
|
}
|
|
|
|
if (passengerOnDriverSeat) {
|
|
if (passengerIsGettingOn) {
|
|
if (useEventOnDriverGetOn) {
|
|
eventOnDriverGetOn.Invoke (currentPassengerComponents.currentPassenger);
|
|
}
|
|
} else {
|
|
if (useEventOnDriverGetOff) {
|
|
eventOnDriverGetOff.Invoke (currentPassengerComponents.currentPassenger);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
currentPassengerComponents.mainFootStepManager.enableOrDisableFootSteps (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.healthManager.setSliderVisibleState (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.healthManager.setDrivingState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.usingDevicesManager.setUseDeviceButtonEnabledState (true);
|
|
|
|
//if the player is driving it
|
|
if (passengerIsGettingOn) {
|
|
//check the current state of the player, to check if he is carrying an object, aiming, etc... to disable that state
|
|
currentPassengerComponents.statesManager.checkPlayerStates ();
|
|
|
|
if (currentPassengerComponents.mainHideCharacterFixedPlaceSystemPlayerManagement != null) {
|
|
currentPassengerComponents.mainHideCharacterFixedPlaceSystemPlayerManagement.removeCurrentHideFromEnemiesSystem ();
|
|
}
|
|
|
|
//check the current state of the player, to check if he is carrying an object, aiming, etc... to disable that state
|
|
currentPassengerComponents.usingDevicesManager.setDrivingState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.usingDevicesManager.clearDeviceListButOne (vehicleGameObject);
|
|
|
|
currentPassengerComponents.usingDevicesManager.checkIfSetOriginalShaderToPreviousDeviceFound (vehicleGameObject);
|
|
|
|
if (currentIKVehiclePassengerInfo.useAnimationActionIDOnDriveIdle) {
|
|
currentPassengerComponents.mainPlayerActionSystem.setNewActionIDExternally (currentIKVehiclePassengerInfo.animationActionID);
|
|
}
|
|
}
|
|
|
|
//the player gets off from the vehicle
|
|
else {
|
|
currentPassengerComponents.playerControllerManager.setTemporalVehicle (null);
|
|
|
|
if (isPlayer && passengerOnDriverSeat) {
|
|
currentPassengerComponents.mainPlayerHUDManager.setCurrentVehicleHUD (null);
|
|
}
|
|
|
|
if (currentIKVehiclePassengerInfo.useAnimationActionIDOnDriveIdle) {
|
|
currentPassengerComponents.mainPlayerActionSystem.setNewActionIDExternally (resetAnimatorDrivingStateID);
|
|
} else {
|
|
currentPassengerComponents.mainPlayerActionSystem.setNewActionIDExternally (0);
|
|
}
|
|
|
|
if (isPlayer) {
|
|
currentPassengerComponents.playerCameraManager.setFBAPivotCameraTransformParent (null);
|
|
|
|
if (currentPassengerComponents.playerCameraManager.isUpdateFBAPivotCameraTransformInsideHeadPositionActive ()) {
|
|
currentPassengerComponents.playerCameraManager.setUpdateFBAPivotCameraTransformInsideHeadPositionActiveState (true);
|
|
}
|
|
}
|
|
|
|
currentPassengerComponents.usingDevicesManager.setDrivingState (passengerIsGettingOn);
|
|
}
|
|
|
|
if (hidePlayerWeaponsWhileDriving) {
|
|
currentPassengerComponents.playerWeaponManager.enableOrDisableEnabledWeaponsMesh (!passengerIsGettingOn);
|
|
|
|
if (currentPassengerComponents.mainMeleeWeaponsGrabbedManager != null) {
|
|
currentPassengerComponents.mainMeleeWeaponsGrabbedManager.enableOrDisableAllMeleeWeaponMeshesOnCharacterBodyCheckingIfHiddingMeshes (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.mainMeleeWeaponsGrabbedManager.enableOrDisableAllMeleeWeaponShieldMeshesOnCharacterBodyCheckingIfHiddingMeshes (!passengerIsGettingOn);
|
|
}
|
|
}
|
|
|
|
if (!passengerIsGettingOn) {
|
|
removePassengerInfo (currentIKVehiclePassengerInfo);
|
|
}
|
|
|
|
if (!passengerIsGettingOn) {
|
|
currentPassengerComponents.playerCameraManager.updateFBAPivotCameraTransformToPivotCameraTransform ();
|
|
}
|
|
|
|
if (useRemoteEventsOnPassengers) {
|
|
if (currentPassengerComponents.mainRemoteEventSystem != null) {
|
|
if (passengerIsGettingOn) {
|
|
for (int i = 0; i < remoteEventNameListGetOn.Count; i++) {
|
|
currentPassengerComponents.mainRemoteEventSystem.callRemoteEvent (remoteEventNameListGetOn [i]);
|
|
}
|
|
} else {
|
|
for (int i = 0; i < remoteEventNameListGetOff.Count; i++) {
|
|
currentPassengerComponents.mainRemoteEventSystem.callRemoteEvent (remoteEventNameListGetOff [i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mainInputActionManager != null && isPlayer && passengerOnDriverSeat) {
|
|
mainInputActionManager.enableOrDisableInput (isBeingDriven, currentPassengerComponents.currentPassenger);
|
|
}
|
|
|
|
mainObjectToOverrideSystem.setCurrentPlayer (currentPassengerComponents.currentPassenger);
|
|
|
|
mainObjectToOverrideSystem.setOverrideControlExternally (isBeingDriven);
|
|
|
|
if (isPlayer) {
|
|
checkVehicleWeaponsElements (currentPassengerComponents);
|
|
}
|
|
}
|
|
|
|
|
|
//the player is getting in or off from the vehicle
|
|
public void startOrStopVehicle (bool state)
|
|
{
|
|
Vector3 nextPlayerPos = getPassengerGetOffPosition (currentRiderGameObject);
|
|
|
|
IKDrivingSystem.IKDrivingInformation currentIKVehiclePassengerInfo = getIKVehiclePassengerInfo (currentRiderGameObject);
|
|
|
|
int currentPassengerIndex = passengerGameObjectList.IndexOf (currentRiderGameObject);
|
|
|
|
if (currentPassengerIndex < 0) {
|
|
if (showDebugPrint) {
|
|
print ("Warning: the passenger wasn't found on the vehicle when trying to enter and get its index info");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
IKDrivingSystem.passengerComponents currentPassengerComponents = passengerComponentsList [currentPassengerIndex];
|
|
|
|
if (nextPlayerPos == -Vector3.one || nextPlayerPos == Vector3.zero) {
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.getOffPlace == IKDrivingSystem.seatInfo.getOffSide.right) {
|
|
nextPlayerPos = currentIKVehiclePassengerInfo.vehicleSeatInfo.rightGetOffPosition.position;
|
|
} else {
|
|
nextPlayerPos = currentIKVehiclePassengerInfo.vehicleSeatInfo.leftGetOffPosition.position;
|
|
}
|
|
}
|
|
|
|
if (customPassengerPosition != Vector3.zero) {
|
|
nextPlayerPos = customPassengerPosition;
|
|
|
|
customPassengerPosition = Vector3.zero;
|
|
}
|
|
|
|
passengerIsGettingOn = false;
|
|
|
|
passengerIsGettingOn = currentIKVehiclePassengerInfo.vehicleSeatInfo.seatIsFree;
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.seatIsFree = !passengerIsGettingOn;
|
|
|
|
currentIKVehiclePassengerInfo.adjustPassengerPositionActive = true;
|
|
currentIKVehiclePassengerInfo.currentDriveIkWeightValue = 1;
|
|
currentIKVehiclePassengerInfo.disableIKOnPassengerSmoothly = false;
|
|
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOnVehicleActiveState (false);
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOffFromVehicleActiveState (false);
|
|
|
|
if (showDebugPrint) {
|
|
print ("passenger is getting on " + passengerIsGettingOn);
|
|
}
|
|
|
|
bool passengerOnDriverSeat = false;
|
|
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.isDriverSeat) {
|
|
passengerOnDriverSeat = true;
|
|
|
|
currentPassengerDriverComponents = currentPassengerComponents;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("is driver seat " + passengerOnDriverSeat);
|
|
}
|
|
|
|
currentPassengerComponents.passengerOnDriverSeat = passengerOnDriverSeat;
|
|
|
|
if (passengerOnDriverSeat) {
|
|
isBeingDriven = passengerIsGettingOn;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print (passengerIsGettingOn + " " + passengerOnDriverSeat + " " + isBeingDriven);
|
|
}
|
|
|
|
bool isPlayer = false;
|
|
|
|
if (!currentPassengerComponents.playerControllerManager.usedByAI) {
|
|
isPlayer = true;
|
|
}
|
|
|
|
//CHECK IN THE ACTION SYSTEM IS USED TO PLAY AN ANIMATION TO ENTER-EXIT THE VEHICLE
|
|
|
|
bool useActionSystemToEnterExitSeat = currentIKVehiclePassengerInfo.vehicleSeatInfo.useActionSystemToEnterExitSeat;
|
|
|
|
if (enteringOnVehicleFromDistance) {
|
|
useActionSystemToEnterExitSeat = false;
|
|
|
|
enteringOnVehicleFromDistance = false;
|
|
}
|
|
|
|
bool firstCameraEnabled = currentPassengerComponents.playerCameraManager.isFirstPersonActive ();
|
|
|
|
bool canUseActionSystem = false;
|
|
|
|
if (useActionSystemToEnterExitSeat) {
|
|
canUseActionSystem = true;
|
|
}
|
|
|
|
if (passengerIsGettingOn) {
|
|
if (firstCameraEnabled) {
|
|
canUseActionSystem = false;
|
|
}
|
|
}
|
|
|
|
if (canUseActionSystem) {
|
|
stopEnterExitActionSystemOnPassengerCoroutine (currentPassengerComponents.actionSystemCoroutine);
|
|
|
|
bool enterExitActionInProcess = currentIKVehiclePassengerInfo.vehicleSeatInfo.enterExitActionInProcess;
|
|
|
|
currentPassengerComponents.actionSystemCoroutine =
|
|
StartCoroutine (enterExitActionSystemOnPassengerCoroutine (currentPassengerComponents.playerControllerManager.gameObject, passengerParent, nextPlayerPos,
|
|
currentPassengerComponents, currentIKVehiclePassengerInfo, passengerIsGettingOn, isPlayer, passengerOnDriverSeat, isBeingDriven));
|
|
|
|
if (passengerIsGettingOn) {
|
|
return;
|
|
} else {
|
|
if (enterExitActionInProcess) {
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
} else {
|
|
stopEnterExitActionSystemOnPassengerCoroutine (currentPassengerComponents.actionSystemCoroutine);
|
|
|
|
setPassengerOnVehicleState (currentPassengerComponents.playerControllerManager.gameObject, passengerParent, nextPlayerPos, currentPassengerComponents,
|
|
currentIKVehiclePassengerInfo, passengerIsGettingOn, isPlayer, passengerOnDriverSeat, false, isBeingDriven);
|
|
}
|
|
|
|
// return passengerOnDriverSeat;
|
|
}
|
|
|
|
public void stopEnterExitActionSystemOnPassengerCoroutine (Coroutine passengerCoroutine)
|
|
{
|
|
if (passengerCoroutine != null) {
|
|
StopCoroutine (passengerCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator enterExitActionSystemOnPassengerCoroutine (GameObject currentPassenger, Transform passengerParent, Vector3 nextPlayerPos,
|
|
IKDrivingSystem.passengerComponents currentPassengerComponents, IKDrivingSystem.IKDrivingInformation currentIKVehiclePassengerInfo,
|
|
bool passengerIsGettingOn, bool isPlayer, bool passengerOnDriverSeat, bool isBeingDriven)
|
|
{
|
|
bool cancelingEntering = false;
|
|
|
|
bool jumpOffFromVehicleActive = false;
|
|
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.enterExitActionInProcess) {
|
|
if (passengerIsGettingOn) {
|
|
print ("character entering from vehicle already in process");
|
|
} else {
|
|
print ("character was entering on vehicle, but that is going to be cancelled");
|
|
|
|
cancelingEntering = true;
|
|
}
|
|
}
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.enterExitActionInProcess = true;
|
|
|
|
bool actionActive = true;
|
|
|
|
GameObject vehicle = getVehicleGameObject ();
|
|
|
|
if (passengerIsGettingOn) {
|
|
currentPassengerComponents.playerControllerManager.setTemporalVehicle (vehicle);
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.eventOnActionToEnter.Invoke ();
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToEnterVehicle.setPlayerActionActive (currentPassengerComponents.currentPassenger);
|
|
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOnVehicleActiveState (true);
|
|
} else {
|
|
if (!cancelingEntering) {
|
|
if (!passengerIsGettingOn) {
|
|
|
|
float currentVehicleSpeed = 0;
|
|
|
|
if (mainVehicleRigidbody != null) {
|
|
currentVehicleSpeed = Mathf.Abs (mainVehicleRigidbody.linearVelocity.magnitude);
|
|
|
|
}
|
|
|
|
if (currentVehicleSpeed > currentIKVehiclePassengerInfo.vehicleSeatInfo.minSpeedToJumpOffFromVehicle) {
|
|
jumpOffFromVehicleActive = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
currentPassengerComponents.playerControllerManager.setTemporalVehicle (null);
|
|
|
|
if (cancelingEntering) {
|
|
currentPassengerComponents.mainPlayerActionSystem.stopAllActions ();
|
|
} else {
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.eventOnActionToExit.Invoke ();
|
|
|
|
if (jumpOffFromVehicleActive) {
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToJumpOffFromVehicle.setPlayerActionActive (currentPassengerComponents.currentPassenger);
|
|
} else {
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToExitVehicle.setPlayerActionActive (currentPassengerComponents.currentPassenger);
|
|
}
|
|
}
|
|
|
|
currentIKVehiclePassengerInfo.adjustPassengerPositionActive = false;
|
|
currentIKVehiclePassengerInfo.disableIKOnPassengerSmoothly = true;
|
|
|
|
currentPassengerComponents.playerControllerManager.enabled = true;
|
|
|
|
currentPassengerComponents.playerControllerManager.setUsingDeviceState (false);
|
|
|
|
currentPassengerComponents.playerControllerManager.setUsingGeneralDriveRiderSystem (false);
|
|
|
|
currentPassengerComponents.playerControllerManager.setAnimatorState (true);
|
|
|
|
currentPassengerComponents.mainRigidbody.isKinematic = false;
|
|
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOffFromVehicleActiveState (true);
|
|
}
|
|
|
|
bool cancelAction = false;
|
|
|
|
if (!cancelingEntering) {
|
|
if (!passengerIsGettingOn) {
|
|
currentPassengerComponents.usingDevicesManager.setUseDeviceButtonEnabledState (false);
|
|
}
|
|
|
|
currentPassengerComponents.mainPlayerActionSystem.playCurrentAnimation ();
|
|
|
|
bool passengerParentAdjusted = false;
|
|
|
|
float currentDistanceToVehicle = 0;
|
|
|
|
bool actionCanBeCancelled = false;
|
|
|
|
bool cancelActionOutsideVehicle = false;
|
|
|
|
if (jumpOffFromVehicleActive) {
|
|
bool isCurrentPassengerCameraLocked = !currentPassengerComponents.playerCameraManager.isCameraTypeFree ();
|
|
|
|
if (isPlayer && passengerOnDriverSeat) {
|
|
if (!isCurrentPassengerCameraLocked) {
|
|
|
|
float delayToStartJumpOff = currentIKVehiclePassengerInfo.vehicleSeatInfo.delayToStartJumpOff;
|
|
|
|
float timer = 0;
|
|
|
|
bool delayComplete = false;
|
|
|
|
while (!delayComplete) {
|
|
|
|
if (mainVehicleRigidbody != null) {
|
|
currentPassengerComponents.playerControllerManager.setExtraCharacterVelocity (mainVehicleRigidbody.linearVelocity);
|
|
}
|
|
|
|
timer += Time.deltaTime;
|
|
|
|
if (timer >= delayToStartJumpOff) {
|
|
delayComplete = true;
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
currentPassengerComponents.playerControllerManager.setExtraCharacterVelocity (Vector3.zero);
|
|
|
|
currentPassenger.transform.SetParent (null);
|
|
|
|
//change the main camera parent to player's camera
|
|
|
|
Transform playerCameraTransform = currentPassengerComponents.playerCameraGameObject.transform;
|
|
|
|
if (resetCameraRotationWhenGetOff) {
|
|
float angleY = Vector3.Angle (vehicle.transform.forward, playerCameraTransform.forward);
|
|
|
|
angleY *= Mathf.Sign (playerCameraTransform.InverseTransformDirection (
|
|
Vector3.Cross (vehicle.transform.forward, playerCameraTransform.forward)).y);
|
|
|
|
playerCameraTransform.Rotate (0, -angleY, 0);
|
|
} else {
|
|
}
|
|
|
|
currentPassengerComponents.playerCameraManager.setMainCameraParent (currentPassengerComponents.originalCameraParentTransform);
|
|
}
|
|
}
|
|
}
|
|
|
|
while (actionActive) {
|
|
// print ("checking for action " + currentPassengerComponents.playerControllerManager.isActionActive () + " " + currentPassengerComponents.mainPlayerActionSystem.isPlayerWalkingToDirectionActive ());
|
|
|
|
if (!currentPassengerComponents.playerControllerManager.isActionActive () && !currentPassengerComponents.mainPlayerActionSystem.isPlayerWalkingToDirectionActive ()) {
|
|
actionActive = false;
|
|
} else {
|
|
if (currentPassenger != null && passengerParent != null) {
|
|
currentDistanceToVehicle = GKC_Utils.distance (currentPassenger.transform.position, passengerParent.position);
|
|
}
|
|
|
|
if (passengerIsGettingOn) {
|
|
if (!passengerParentAdjusted) {
|
|
if (!currentPassengerComponents.mainPlayerActionSystem.isPlayerWalkingToDirectionActive () &&
|
|
!currentPassengerComponents.mainPlayerActionSystem.isRotatingTowardFacingDirection ()) {
|
|
currentPassenger.transform.SetParent (vehicle.transform);
|
|
|
|
passengerParentAdjusted = true;
|
|
|
|
currentPassengerComponents.usingDevicesManager.setUseDeviceButtonEnabledState (false);
|
|
} else {
|
|
if (currentDistanceToVehicle > 20) {
|
|
cancelActionOutsideVehicle = true;
|
|
actionCanBeCancelled = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (passengerParentAdjusted) {
|
|
if (mainVehicleRigidbody != null) {
|
|
currentPassengerComponents.playerControllerManager.setExtraCharacterVelocity (mainVehicleRigidbody.linearVelocity);
|
|
}
|
|
}
|
|
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.cancelActionEnterExitVehicleIfSpeedTooHigh) {
|
|
|
|
float currentVehicleVelocity = 0;
|
|
|
|
if (mainVehicleRigidbody != null) {
|
|
currentVehicleVelocity = mainVehicleRigidbody.linearVelocity.magnitude;
|
|
}
|
|
|
|
if (Mathf.Abs (currentVehicleVelocity) > currentIKVehiclePassengerInfo.vehicleSeatInfo.minSpeedToCancelActionEnterExitVehicle) {
|
|
actionCanBeCancelled = true;
|
|
|
|
print ("Vehicle too fast, stopping the action");
|
|
}
|
|
|
|
if (passengerParentAdjusted) {
|
|
if (currentDistanceToVehicle > 5) {
|
|
print ("Too far from vehicle, cancelling");
|
|
actionCanBeCancelled = true;
|
|
}
|
|
|
|
cancelActionOutsideVehicle = false;
|
|
} else {
|
|
cancelActionOutsideVehicle = true;
|
|
}
|
|
|
|
if (actionCanBeCancelled) {
|
|
if (passengerParentAdjusted) {
|
|
currentPassenger.transform.SetParent (null);
|
|
}
|
|
print ("CANCELLING");
|
|
|
|
cancelAction = true;
|
|
|
|
actionActive = false;
|
|
|
|
currentPassengerComponents.passengerOnDriverSeat = false;
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.seatIsFree = true;
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.enterExitActionInProcess = false;
|
|
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOnVehicleActiveState (false);
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOffFromVehicleActiveState (false);
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToEnterVehicle.setPlayerActionDeactivate (currentPassengerComponents.currentPassenger);
|
|
|
|
currentPassengerComponents.mainPlayerActionSystem.stopAllActions ();
|
|
|
|
print ("Cancelling action outside of vehicle " + cancelActionOutsideVehicle);
|
|
|
|
if (cancelActionOutsideVehicle) {
|
|
currentPassengerComponents.mainRemoteEventSystem.callRemoteEvent (currentIKVehiclePassengerInfo.vehicleSeatInfo.remoteEventToCancelActionEnterExitOutsideVehicle);
|
|
} else {
|
|
currentPassengerComponents.mainRemoteEventSystem.callRemoteEvent (currentIKVehiclePassengerInfo.vehicleSeatInfo.remoteEventToCancelActionEnterExitInsideVehicle);
|
|
}
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.eventToCancelActionEnterAndExit.Invoke ();
|
|
|
|
removePassengerInfo (currentIKVehiclePassengerInfo);
|
|
|
|
stopEnterExitActionSystemOnPassengerCoroutine (currentPassengerComponents.actionSystemCoroutine);
|
|
}
|
|
}
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
if (!cancelAction) {
|
|
if (passengerIsGettingOn) {
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToEnterVehicle.setPlayerActionDeactivate (currentPassengerComponents.currentPassenger);
|
|
} else {
|
|
if (jumpOffFromVehicleActive) {
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToJumpOffFromVehicle.setPlayerActionDeactivate (currentPassengerComponents.currentPassenger);
|
|
} else {
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.actionSystemToExitVehicle.setPlayerActionDeactivate (currentPassengerComponents.currentPassenger);
|
|
}
|
|
}
|
|
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOnVehicleActiveState (false);
|
|
currentPassengerComponents.playerControllerManager.setActionToGetOffFromVehicleActiveState (false);
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.enterExitActionInProcess = false;
|
|
|
|
if (cancelingEntering) {
|
|
// print ("Cancelling passenger entering on vehicle properly");
|
|
|
|
currentPassenger.transform.SetParent (null);
|
|
|
|
currentPassengerComponents.passengerOnDriverSeat = false;
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.seatIsFree = true;
|
|
|
|
currentIKVehiclePassengerInfo.vehicleSeatInfo.eventToCancelActionEnterAndExit.Invoke ();
|
|
|
|
removePassengerInfo (currentIKVehiclePassengerInfo);
|
|
} else {
|
|
// print ("confirm to enter ");
|
|
|
|
setPassengerOnVehicleState (currentPassenger, passengerParent, nextPlayerPos, currentPassengerComponents,
|
|
currentIKVehiclePassengerInfo, passengerIsGettingOn, isPlayer, passengerOnDriverSeat, true, isBeingDriven);
|
|
}
|
|
}
|
|
}
|
|
|
|
void setPassengerOnVehicleState (GameObject currentPassenger, Transform passengerParent, Vector3 nextPlayerPos,
|
|
IKDrivingSystem.passengerComponents currentPassengerComponents, IKDrivingSystem.IKDrivingInformation currentIKVehiclePassengerInfo,
|
|
bool passengerIsGettingOn, bool isPlayer, bool passengerOnDriverSeat, bool useActionSystemToEnterExitSeat,
|
|
bool isBeingDriven)
|
|
{
|
|
if (vehicleCameraDirection == null) {
|
|
vehicleCameraDirection = vehicleGameObject.transform;
|
|
}
|
|
|
|
//set the state driving as the current state of the player
|
|
currentPassengerComponents.playerControllerManager.setDrivingState (passengerIsGettingOn, vehicleGameObject, vehicleName, vehicleCameraDirection);
|
|
|
|
currentPassengerComponents.playerControllerManager.enabled = !passengerIsGettingOn;
|
|
currentPassengerComponents.passengerPhysicallyOnVehicle = true;
|
|
|
|
currentPassengerComponents.playerControllerManager.changeScriptState (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.playerControllerManager.setPlayerSetAsChildOfParentState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.playerControllerManager.setUsingDeviceState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.playerControllerManager.setUsingGeneralDriveRiderSystem (passengerIsGettingOn);
|
|
|
|
if (isPlayer) {
|
|
currentPassengerComponents.pauseManager.usingDeviceState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.mainInventoryManager.enableOrDisableWeaponSlotsParentOutOfInventory (!passengerIsGettingOn);
|
|
}
|
|
|
|
//enable or disable the collider and the rigidbody of the player
|
|
|
|
currentPassengerComponents.playerControllerManager.setMainColliderState (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.mainRigidbody.isKinematic = passengerIsGettingOn;
|
|
|
|
//get the IK positions of the car to use them in the player
|
|
currentPassengerComponents.IKManager.setDrivingState (passengerIsGettingOn, currentIKVehiclePassengerInfo);
|
|
|
|
//check if the camera in the player is in first or third view, to set the current view in the vehicle
|
|
bool firstCameraEnabled = currentPassengerComponents.playerCameraManager.isFirstPersonActive ();
|
|
|
|
if (passengerIsGettingOn) {
|
|
if (currentPassengerComponents.carryingMeleeWeaponsPreviously) {
|
|
GKC_Utils.checkIfDropThrownWeaponWhenUsingDevice (currentPassengerComponents.currentPassenger);
|
|
|
|
if (currentPassengerComponents.playerControllerManager.isPlayerUsingMeleeWeapons ()) {
|
|
currentPassengerComponents.statesManager.disableGrabMode ();
|
|
} else {
|
|
currentPassengerComponents.carryingMeleeWeaponsPreviously = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isPlayer) {
|
|
if (disablePlayerHUDEnabled) {
|
|
//enable and disable the player's HUD and the vehicle's HUD
|
|
currentPassengerComponents.mainPlayerHUDManager.enableOrDisableHUD (!passengerIsGettingOn);
|
|
}
|
|
|
|
if (showVehicleHUD) {
|
|
currentPassengerComponents.mainPlayerHUDManager.enableOrDisableVehicleHUD (isBeingDriven);
|
|
}
|
|
|
|
if (passengerOnDriverSeat) {
|
|
if (passengerIsGettingOn) {
|
|
if (useEventOnDriverGetOn) {
|
|
eventOnDriverGetOn.Invoke (currentPassengerComponents.currentPassenger);
|
|
}
|
|
} else {
|
|
if (useEventOnDriverGetOff) {
|
|
eventOnDriverGetOff.Invoke (currentPassengerComponents.currentPassenger);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
currentPassengerComponents.mainFootStepManager.enableOrDisableFootSteps (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.healthManager.setSliderVisibleState (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.healthManager.setDrivingState (passengerIsGettingOn);
|
|
|
|
if (passengerIsGettingOn) {
|
|
currentPassengerComponents.playerCameraManager.playOrPauseHeadBob (!passengerIsGettingOn);
|
|
currentPassengerComponents.playerCameraManager.stopAllHeadbobMovements ();
|
|
} else {
|
|
currentPassengerComponents.playerCameraManager.pauseHeadBodWithDelay (0.5f);
|
|
currentPassengerComponents.playerCameraManager.playOrPauseHeadBob (!passengerIsGettingOn);
|
|
}
|
|
|
|
if (passengerIsGettingOn) {
|
|
if (currentIKVehiclePassengerInfo.setNewScaleOnPassenger) {
|
|
currentPassengerComponents.currentPassenger.transform.localScale = currentIKVehiclePassengerInfo.newScaleOnPassenger;
|
|
}
|
|
} else {
|
|
if (currentIKVehiclePassengerInfo.setNewScaleOnPassenger) {
|
|
currentPassengerComponents.currentPassenger.transform.localScale = Vector3.one;
|
|
}
|
|
}
|
|
|
|
//if the first camera was enabled, set the current main camera position in the first camera position of the vehicle
|
|
if (firstCameraEnabled) {
|
|
//enable the player's body to see it
|
|
if (passengerIsGettingOn) {
|
|
currentPassengerComponents.playerControllerManager.setCharacterMeshGameObjectState (true);
|
|
//if the first person was actived, disable the player's body
|
|
} else {
|
|
currentPassengerComponents.playerControllerManager.setCharacterMeshGameObjectState (false);
|
|
}
|
|
|
|
currentPassengerComponents.playerControllerManager.setAnimatorState (passengerIsGettingOn);
|
|
}
|
|
|
|
currentPassengerComponents.usingDevicesManager.setUseDeviceButtonEnabledState (true);
|
|
|
|
//if the player is driving it
|
|
if (passengerIsGettingOn) {
|
|
//check the current state of the player, to check if he is carrying an object, aiming, etc... to disable that state
|
|
currentPassengerComponents.statesManager.checkPlayerStates ();
|
|
|
|
if (currentPassengerComponents.mainHideCharacterFixedPlaceSystemPlayerManagement != null) {
|
|
currentPassengerComponents.mainHideCharacterFixedPlaceSystemPlayerManagement.removeCurrentHideFromEnemiesSystem ();
|
|
}
|
|
|
|
//set the player's position and parent inside the car
|
|
|
|
currentRiderGameObject.transform.SetParent (passengerParent.transform);
|
|
currentRiderGameObject.transform.localPosition = Vector3.zero;
|
|
currentRiderGameObject.transform.localRotation = Quaternion.identity;
|
|
currentRiderGameObject.transform.position = currentIKVehiclePassengerInfo.vehicleSeatInfo.seatTransform.position;
|
|
currentRiderGameObject.transform.rotation = currentIKVehiclePassengerInfo.vehicleSeatInfo.seatTransform.rotation;
|
|
|
|
//get the vehicle camera rotation
|
|
|
|
if (passengerOnDriverSeat) {
|
|
//reset the player's camera rotation input values
|
|
currentPassengerComponents.playerCameraManager.setLookAngleValue (Vector2.zero);
|
|
|
|
//set the player's camera rotation as the same in the vehicle
|
|
currentPassengerComponents.playerCameraGameObject.transform.rotation = transform.rotation;
|
|
}
|
|
|
|
if (isPlayer) {
|
|
if (passengerOnDriverSeat) {
|
|
currentPassengerComponents.playerCameraManager.getPivotCameraTransform ().localRotation = Quaternion.identity;
|
|
|
|
currentPassengerComponents.playerCameraManager.resetMainCameraTransformLocalPosition ();
|
|
|
|
currentPassengerComponents.playerCameraManager.resetPivotCameraTransformLocalPosition ();
|
|
|
|
currentPassengerComponents.playerCameraManager.resetCurrentCameraStateAtOnce ();
|
|
}
|
|
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
currentPassengerComponents.playerCameraManager.setFBAPivotCameraTransformParent (currentPassengerComponents.playerCameraManager.getPivotCameraTransform ());
|
|
}
|
|
}
|
|
|
|
currentPassengerComponents.usingDevicesManager.setDrivingState (passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.usingDevicesManager.clearDeviceListButOne (vehicleGameObject);
|
|
|
|
currentPassengerComponents.usingDevicesManager.checkIfSetOriginalShaderToPreviousDeviceFound (vehicleGameObject);
|
|
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
if (currentIKVehiclePassengerInfo.useAnimationActionIDOnDriveIdle) {
|
|
currentPassengerComponents.mainPlayerActionSystem.setNewActionIDExternally (currentIKVehiclePassengerInfo.animationActionID);
|
|
}
|
|
}
|
|
}
|
|
|
|
//the player gets off from the vehicle
|
|
else {
|
|
currentPassengerComponents.playerControllerManager.setTemporalVehicle (null);
|
|
|
|
if (isPlayer && passengerOnDriverSeat) {
|
|
currentPassengerComponents.mainPlayerHUDManager.setCurrentVehicleHUD (null);
|
|
}
|
|
|
|
//set the parent of the player as null
|
|
currentRiderGameObject.transform.SetParent (null);
|
|
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
//set the player's position at the correct side of the car
|
|
currentRiderGameObject.transform.position = nextPlayerPos;
|
|
}
|
|
|
|
if (currentIKVehiclePassengerInfo.useAnimationActionIDOnDriveIdle) {
|
|
currentPassengerComponents.mainPlayerActionSystem.setNewActionIDExternally (resetAnimatorDrivingStateID);
|
|
} else {
|
|
currentPassengerComponents.mainPlayerActionSystem.setNewActionIDExternally (0);
|
|
}
|
|
|
|
//Set passenger rotation
|
|
|
|
Vector3 targetRotation = vehicleGameObject.transform.eulerAngles;
|
|
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
currentRiderGameObject.transform.eulerAngles = targetRotation;
|
|
}
|
|
|
|
Vector3 currentNormal = currentPassengerComponents.playerGravityManager.getCurrentNormal ();
|
|
|
|
Quaternion currentPlayerRotation = currentRiderGameObject.transform.rotation;
|
|
Vector3 currentPlayerForward = Vector3.Cross (currentRiderGameObject.transform.right, currentNormal);
|
|
Quaternion playerTargetRotation = Quaternion.LookRotation (currentPlayerForward, currentNormal);
|
|
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
currentRiderGameObject.transform.rotation = playerTargetRotation;
|
|
}
|
|
|
|
//set the player's camera position in the correct place
|
|
|
|
Transform playerCameraTransform = currentPassengerComponents.playerCameraGameObject.transform;
|
|
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
playerCameraTransform.position = nextPlayerPos;
|
|
|
|
playerCameraTransform.rotation = currentRiderGameObject.transform.rotation;
|
|
|
|
if (resetCameraRotationWhenGetOff) {
|
|
float angleY = Vector3.Angle (vehicleGameObject.transform.forward, playerCameraTransform.forward);
|
|
|
|
angleY *= Mathf.Sign (playerCameraTransform.InverseTransformDirection (
|
|
Vector3.Cross (vehicleGameObject.transform.forward, playerCameraTransform.forward)).y);
|
|
|
|
playerCameraTransform.Rotate (0, -angleY, 0);
|
|
}
|
|
}
|
|
|
|
if (isPlayer) {
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
currentPassengerComponents.playerCameraManager.setFBAPivotCameraTransformParent (null);
|
|
|
|
if (currentPassengerComponents.playerCameraManager.isUpdateFBAPivotCameraTransformInsideHeadPositionActive ()) {
|
|
currentPassengerComponents.playerCameraManager.setUpdateFBAPivotCameraTransformInsideHeadPositionActiveState (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changeDriverGravityWhenGetsOff) {
|
|
setPassengerGravityState (currentPassengerComponents);
|
|
}
|
|
|
|
if (drawFireWeaponIfCarryingPreviously) {
|
|
if (currentPassengerComponents.carryingFireWeaponsPrevioulsy) {
|
|
currentPassengerComponents.playerWeaponManager.checkIfDrawSingleOrDualWeapon ();
|
|
}
|
|
}
|
|
|
|
if (drawMeleeWeaponIfCarryingPreviously) {
|
|
if (currentPassengerComponents.carryingMeleeWeaponsPreviously) {
|
|
GKC_Utils.drawMeleeWeaponGrabbed (currentPassengerComponents.currentPassenger);
|
|
}
|
|
}
|
|
|
|
currentPassengerComponents.usingDevicesManager.setDrivingState (passengerIsGettingOn);
|
|
}
|
|
|
|
if (!playerVisibleInVehicle) {
|
|
currentPassengerComponents.playerControllerManager.setCharacterMeshGameObjectState (!passengerIsGettingOn);
|
|
enableOrDisablePlayerVisibleInVehicle (passengerIsGettingOn, currentPassengerComponents);
|
|
}
|
|
|
|
if (hidePlayerWeaponsWhileDriving) {
|
|
currentPassengerComponents.playerWeaponManager.enableOrDisableEnabledWeaponsMesh (!passengerIsGettingOn);
|
|
|
|
if (currentPassengerComponents.mainMeleeWeaponsGrabbedManager != null) {
|
|
currentPassengerComponents.mainMeleeWeaponsGrabbedManager.enableOrDisableAllMeleeWeaponMeshesOnCharacterBodyCheckingIfHiddingMeshes (!passengerIsGettingOn);
|
|
|
|
currentPassengerComponents.mainMeleeWeaponsGrabbedManager.enableOrDisableAllMeleeWeaponShieldMeshesOnCharacterBodyCheckingIfHiddingMeshes (!passengerIsGettingOn);
|
|
}
|
|
}
|
|
|
|
if (!passengerIsGettingOn) {
|
|
removePassengerInfo (currentIKVehiclePassengerInfo);
|
|
}
|
|
|
|
if (passengerIsGettingOn) {
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
currentPassengerComponents.playerControllerManager.updateAnimatorExternally ();
|
|
|
|
currentPassengerComponents.playerControllerManager.resetAnimatorEvenIfFullBodyAwarenessActive ();
|
|
}
|
|
} else {
|
|
if (!useActionSystemToEnterExitSeat) {
|
|
currentPassengerComponents.playerCameraManager.updateFBAPivotCameraTransformToPivotCameraTransform ();
|
|
}
|
|
}
|
|
|
|
if (useRemoteEventsOnPassengers) {
|
|
if (currentPassengerComponents.mainRemoteEventSystem != null) {
|
|
if (passengerIsGettingOn) {
|
|
for (int i = 0; i < remoteEventNameListGetOn.Count; i++) {
|
|
currentPassengerComponents.mainRemoteEventSystem.callRemoteEvent (remoteEventNameListGetOn [i]);
|
|
}
|
|
} else {
|
|
for (int i = 0; i < remoteEventNameListGetOff.Count; i++) {
|
|
currentPassengerComponents.mainRemoteEventSystem.callRemoteEvent (remoteEventNameListGetOff [i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mainInputActionManager != null && isPlayer && passengerOnDriverSeat) {
|
|
mainInputActionManager.enableOrDisableInput (isBeingDriven, currentPassengerComponents.currentPassenger);
|
|
}
|
|
|
|
if (isPlayer) {
|
|
checkVehicleWeaponsElements (currentPassengerComponents);
|
|
}
|
|
}
|
|
|
|
public void enableOrDisablePlayerVisibleInVehicle (bool state, IKDrivingSystem.passengerComponents newPassengerComponents)
|
|
{
|
|
if (!newPassengerComponents.playerCameraManager.isFirstPersonActive ()) {
|
|
newPassengerComponents.playerControllerManager.setCharacterMeshesListToDisableOnEventState (!state);
|
|
|
|
newPassengerComponents.playerWeaponManager.enableOrDisableWeaponsMesh (!state);
|
|
} else {
|
|
newPassengerComponents.playerControllerManager.setCharacterMeshGameObjectState (false);
|
|
}
|
|
}
|
|
|
|
public Vector3 getGetOffPosition (IKDrivingSystem.IKDrivingInformation passengerInfo)
|
|
{
|
|
if (passengerInfo.vehicleSeatInfo.getOffPlace == IKDrivingSystem.seatInfo.getOffSide.right) {
|
|
return passengerInfo.vehicleSeatInfo.rightGetOffPosition.position;
|
|
} else {
|
|
return passengerInfo.vehicleSeatInfo.leftGetOffPosition.position;
|
|
}
|
|
}
|
|
|
|
public void removePassengerInfo (IKDrivingSystem.IKDrivingInformation passengerInfo)
|
|
{
|
|
if (passengerGameObjectList.Contains (passengerInfo.vehicleSeatInfo.currentPassenger)) {
|
|
int passengerGameObjecToRemoveIndex = passengerGameObjectList.IndexOf (passengerInfo.vehicleSeatInfo.currentPassenger);
|
|
|
|
IKDrivingSystem.passengerComponents currentPassengerComponents = passengerComponentsList [passengerGameObjecToRemoveIndex];
|
|
|
|
playerController currentPlayerController = currentPassengerComponents.playerControllerManager;
|
|
|
|
currentPlayerController.setPlayerStatusIDValue (currentPassengerComponents.previousPlayerStatusID);
|
|
|
|
currentPlayerController.setCurrentIdleIDValueFloat (currentPassengerComponents.previousIdleID);
|
|
|
|
currentPlayerController.setCurrentStrafeIDValue (currentPassengerComponents.previousStrafeID);
|
|
|
|
currentPlayerController.updatePlayerStatusIDOnAnimator ();
|
|
|
|
currentPlayerController.updateIdleIDOnAnimator ();
|
|
|
|
currentPlayerController.updateStrafeIDOnAnimator ();
|
|
|
|
currentPlayerController.setLastTimeFalling ();
|
|
|
|
if (checkIfDriverIsOnGroundOnGetOff) {
|
|
bool isPlayerOnGrond = currentPlayerController.checkIfPlayerOnGroundWithRaycast ();
|
|
|
|
currentPlayerController.setCheckOnGroungPausedState (false);
|
|
|
|
if (!isPlayerOnGrond) {
|
|
currentPlayerController.setPlayerOnGroundState (false);
|
|
}
|
|
|
|
currentPlayerController.setPlayerOnGroundAnimatorStateOnOverrideOnGroundWithTime (true);
|
|
|
|
currentPlayerController.disableOverrideOnGroundAnimatorValue ();
|
|
|
|
currentPlayerController.setPauseResetAnimatorStateFOrGroundAnimatorState (true);
|
|
|
|
if (isPlayerOnGrond) {
|
|
currentPlayerController.setPlayerOnGroundState (true);
|
|
|
|
currentPlayerController.setOnGroundAnimatorIDValue (true);
|
|
} else {
|
|
currentPlayerController.setOnGroundAnimatorIDValue (false);
|
|
}
|
|
}
|
|
|
|
passengerComponentsList.RemoveAt (passengerGameObjecToRemoveIndex);
|
|
|
|
passengerGameObjectList.Remove (passengerInfo.vehicleSeatInfo.currentPassenger);
|
|
|
|
passengerInfo.vehicleSeatInfo.currentPassenger = null;
|
|
}
|
|
}
|
|
|
|
public Vector3 getPassengerGetOffPosition (GameObject currentPassenger)
|
|
{
|
|
// bool isGettingOn = setPassengerInfo (IKRiderInfo, currentRiderGameObject);
|
|
//
|
|
// if (isGettingOn) {
|
|
// return Vector3.zero;
|
|
// }
|
|
|
|
//search if the current passenger is in the list, to avoid get the closest seat
|
|
int currentPassengerGameObjectIndex = -1;
|
|
|
|
if (passengerGameObjectList.Contains (currentPassenger)) {
|
|
int IKVehiclePassengersListCount = IKVehiclePassengersList.Count;
|
|
|
|
for (int i = 0; i < IKVehiclePassengersListCount; i++) {
|
|
if (IKVehiclePassengersList [i].vehicleSeatInfo.currentPassenger == currentPassenger) {
|
|
currentPassengerGameObjectIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
IKDrivingSystem.IKDrivingInformation currentIKVehiclePassengerInfo;
|
|
|
|
if (currentPassengerGameObjectIndex == -1) {
|
|
|
|
int currentIKVehiclePassengerIndex = -1;
|
|
|
|
//print (currentPassenger.name);
|
|
|
|
bool setDriverPosition = false;
|
|
|
|
playerController currentPlayerController = currentPassenger.GetComponent<playerController> ();
|
|
|
|
if (currentPlayerController != null) {
|
|
if (!currentPlayerController.usedByAI) {
|
|
if (playerIsAlwaysDriver) {
|
|
if (isBeingDriven) {
|
|
if (showDebugPrint) {
|
|
print ("vehicle is already being driven, setting new character as passenger");
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("vehicle is not being driven, setting new character as driver");
|
|
}
|
|
|
|
if (!currentPlayerController.canCharacterGetOnVehicles ()) {
|
|
return -Vector3.one;
|
|
}
|
|
|
|
setDriverPosition = true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
print ("WARNING: player not found");
|
|
}
|
|
|
|
if (getDriverPosition || setDriverPosition) {
|
|
currentIKVehiclePassengerIndex = getDriverSeatPassengerIndex ();
|
|
} else {
|
|
currentIKVehiclePassengerIndex = getClosestSeatToPassengerIndex (currentPassenger);
|
|
}
|
|
|
|
if (currentIKVehiclePassengerIndex > -1) {
|
|
currentIKVehiclePassengerInfo = IKVehiclePassengersList [currentIKVehiclePassengerIndex];
|
|
} else {
|
|
return -Vector3.one;
|
|
}
|
|
|
|
bool isGettingOn = setPassengerInfo (currentIKVehiclePassengerInfo, currentPassenger);
|
|
|
|
if (isGettingOn) {
|
|
return Vector3.zero;
|
|
}
|
|
} else {
|
|
currentIKVehiclePassengerInfo = IKVehiclePassengersList [currentPassengerGameObjectIndex];
|
|
}
|
|
|
|
Transform seatTransform = currentIKVehiclePassengerInfo.vehicleSeatInfo.seatTransform;
|
|
Vector3 getOffPosition = Vector3.zero;
|
|
Vector3 rayDirection = Vector3.zero;
|
|
Vector3 passengerPosition = Vector3.zero;
|
|
Vector3 rayPosition = Vector3.zero;
|
|
float rayDistance = 0;
|
|
|
|
Ray ray = new Ray ();
|
|
|
|
bool canGetOff = false;
|
|
|
|
RaycastHit [] hits;
|
|
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.getOffPlace == IKDrivingSystem.seatInfo.getOffSide.right) {
|
|
getOffPosition = currentIKVehiclePassengerInfo.vehicleSeatInfo.rightGetOffPosition.position;
|
|
rayDirection = seatTransform.right;
|
|
} else {
|
|
getOffPosition = currentIKVehiclePassengerInfo.vehicleSeatInfo.leftGetOffPosition.position;
|
|
rayDirection = -seatTransform.right;
|
|
}
|
|
|
|
rayDistance = GKC_Utils.distance (seatTransform.position, getOffPosition);
|
|
|
|
rayPosition = getOffPosition - rayDirection * rayDistance;
|
|
|
|
//set the ray origin at the vehicle position with a little offset set in the inspector
|
|
ray.origin = rayPosition;
|
|
//set the ray direction to the left
|
|
|
|
ray.direction = rayDirection;
|
|
//get all the colliders in that direction where the yellow sphere is placed
|
|
|
|
hits = Physics.SphereCastAll (ray, 0.1f, rayDistance, obstacleLayer);
|
|
//get the position where the player will be placed
|
|
|
|
passengerPosition = getOffPosition;
|
|
|
|
if (ignoreObstacleCheckOnGetOffEnabled) {
|
|
canGetOff = true;
|
|
} else {
|
|
if (hits.Length == 0) {
|
|
//any obstacle detected, so the player can get off
|
|
canGetOff = true;
|
|
} else {
|
|
if (showDebugPrint) {
|
|
if (hits.Length > 0) {
|
|
print ("Obstacle detected at the " + currentIKVehiclePassengerInfo.vehicleSeatInfo.getOffPlace + " side");
|
|
}
|
|
}
|
|
}
|
|
|
|
//some obstacles found
|
|
for (int i = 0; i < hits.Length; i++) {
|
|
//check the distance to that obstacles, if they are lower that the rayDistance, the player can get off
|
|
if (hits [i].distance > rayDistance) {
|
|
canGetOff = true;
|
|
} else {
|
|
canGetOff = false;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("Obstacle detected is " + hits [i].collider.name + " at a distance of " + hits [i].distance);
|
|
}
|
|
}
|
|
}
|
|
|
|
//if the left side is blocked, then check the right side in the same way that previously
|
|
if (!canGetOff) {
|
|
if (showDebugPrint) {
|
|
print ("Checking the other side to get off");
|
|
}
|
|
|
|
if (currentIKVehiclePassengerInfo.vehicleSeatInfo.getOffPlace == IKDrivingSystem.seatInfo.getOffSide.right) {
|
|
getOffPosition = currentIKVehiclePassengerInfo.vehicleSeatInfo.leftGetOffPosition.position;
|
|
rayDirection = -seatTransform.right;
|
|
} else {
|
|
getOffPosition = currentIKVehiclePassengerInfo.vehicleSeatInfo.rightGetOffPosition.position;
|
|
rayDirection = seatTransform.right;
|
|
}
|
|
|
|
rayDistance = GKC_Utils.distance (seatTransform.position, getOffPosition);
|
|
|
|
rayPosition = getOffPosition - rayDirection * rayDistance;
|
|
|
|
ray.origin = rayPosition;
|
|
|
|
ray.direction = rayDirection;
|
|
|
|
hits = Physics.SphereCastAll (ray, 0.1f, rayDistance, obstacleLayer);
|
|
|
|
passengerPosition = getOffPosition;
|
|
|
|
if (hits.Length == 0) {
|
|
canGetOff = true;
|
|
} else {
|
|
if (showDebugPrint) {
|
|
if (hits.Length > 0) {
|
|
print ("Obstacle detected at the other side");
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < hits.Length; i++) {
|
|
if (hits [i].distance > rayDistance) {
|
|
canGetOff = true;
|
|
} else {
|
|
canGetOff = false;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("Obstacle detected is " + hits [i].collider.name + " at a distance of " + hits [i].distance);
|
|
}
|
|
}
|
|
}
|
|
|
|
//if both sides are blocked, exit the function and the player can't get off
|
|
if (!canGetOff) {
|
|
return -Vector3.one;
|
|
}
|
|
|
|
//if any side is avaliable then check a ray in down direction, to place the player above the ground
|
|
RaycastHit hit;
|
|
|
|
if (Physics.Raycast (getOffPosition, -vehicleGameObject.transform.up, out hit, currentIKVehiclePassengerInfo.vehicleSeatInfo.getOffDistance, obstacleLayer)) {
|
|
Debug.DrawRay (getOffPosition, -vehicleGameObject.transform.up * hit.distance, Color.yellow);
|
|
passengerPosition = hit.point;
|
|
}
|
|
|
|
return passengerPosition;
|
|
}
|
|
|
|
public void setPassengerGravityState (IKDrivingSystem.passengerComponents currentPassengerComponents)
|
|
{
|
|
//set the current gravity of the player's as the same in the vehicle
|
|
if (changeDriverGravityWhenGetsOff) {
|
|
Vector3 gravityDirection = currentNormal;
|
|
|
|
if (checkVehicleUpDirectionForGravityOnGetOff) {
|
|
if (customVehicleGameObject != null) {
|
|
gravityDirection = customVehicleGameObject.transform.up;
|
|
} else {
|
|
gravityDirection = vehicleGameObject.transform.up;
|
|
}
|
|
}
|
|
|
|
if (gravityDirection != regularGravity) {
|
|
Vector3 currentNormal = currentPassengerComponents.playerGravityManager.getCurrentNormal ();
|
|
|
|
if (currentNormal != gravityDirection) {
|
|
float currentAngle = Vector3.Angle (gravityDirection, currentNormal);
|
|
|
|
if (currentAngle > minAngleDifferenceToRegularGravityToChangeWhenGetOff) {
|
|
//if the option to change player's gravity is on, change his gravity direction
|
|
|
|
currentPassengerComponents.playerGravityManager.setNormal (gravityDirection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setChangeDriverGravityWhenGetsOffState (bool state)
|
|
{
|
|
changeDriverGravityWhenGetsOff = state;
|
|
}
|
|
|
|
public void setCurrentNormal (Vector3 newValue)
|
|
{
|
|
currentNormal = newValue;
|
|
}
|
|
|
|
playerHUDManager.vehicleHUDElements currentHUDElements;
|
|
playerHUDManager currentVehicleHUDInfo;
|
|
|
|
Slider vehicleAmmo;
|
|
Text ammoAmountText;
|
|
Text weaponNameText;
|
|
|
|
bool ammoAmountTextAssigned;
|
|
bool weaponNameTextAssigned;
|
|
|
|
public void getHUDBars (playerHUDManager newVehicleHUDInfo, playerHUDManager.vehicleHUDElements hudElements, bool drivingState)
|
|
{
|
|
currentVehicleHUDInfo = newVehicleHUDInfo;
|
|
|
|
currentHUDElements = hudElements;
|
|
|
|
vehicleAmmo = currentHUDElements.vehicleAmmo;
|
|
|
|
ammoAmountText = currentHUDElements.ammoInfo;
|
|
|
|
ammoAmountTextAssigned = ammoAmountText != null;
|
|
|
|
weaponNameText = currentHUDElements.weaponName;
|
|
|
|
weaponNameTextAssigned = weaponNameText != null;
|
|
|
|
|
|
//check also if the vehicle has a weapon system attached, to enable or disable it
|
|
//if the vehicle has not a weapon system, the weapon info of the HUD is disabled
|
|
if (currentHUDElements.ammoContent != null && currentHUDElements.vehicleCursor != null) {
|
|
bool hudElementState = false;
|
|
|
|
if (mainVehicleWeaponSystem != null && mainVehicleWeaponSystem.weaponsEnabled) {
|
|
if (!destroyed) {
|
|
mainVehicleWeaponSystem.changeWeaponState (drivingState);
|
|
|
|
if (drivingState) {
|
|
mainVehicleWeaponSystem.getCameraInfo (defaultVehicleWeaponSystemCameraTransform, vehicleWeaponSystemUseRotationInput);
|
|
}
|
|
}
|
|
|
|
hudElementState = true;
|
|
}
|
|
|
|
if (currentHUDElements.ammoContent.activeSelf != hudElementState) {
|
|
currentHUDElements.ammoContent.SetActive (hudElementState);
|
|
}
|
|
|
|
if (currentHUDElements.vehicleCursor.activeSelf != hudElementState) {
|
|
currentHUDElements.vehicleCursor.SetActive (hudElementState);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setWeaponState (bool state)
|
|
{
|
|
if (mainVehicleWeaponSystem != null && mainVehicleWeaponSystem.isWeaponsEnabled ()) {
|
|
if (!destroyed) {
|
|
mainVehicleWeaponSystem.changeWeaponState (state);
|
|
}
|
|
|
|
if (currentHUDElements != null) {
|
|
if (currentHUDElements.ammoContent != null) {
|
|
|
|
if (currentHUDElements.ammoContent.activeSelf != state) {
|
|
currentHUDElements.ammoContent.SetActive (state);
|
|
}
|
|
|
|
if (currentHUDElements.vehicleCursor.activeSelf != state) {
|
|
currentHUDElements.vehicleCursor.SetActive (state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkVehicleWeaponsElements (IKDrivingSystem.passengerComponents currentPassengerComponents)
|
|
{
|
|
if (!useVehicleWeaponsEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (mainVehicleWeaponSystem != null) {
|
|
mainVehicleWeaponSystem.setVehicleWeaponsComponents ();
|
|
|
|
mainVehicleWeaponSystem.setCurrentDriver (currentPassengerComponents.currentPassenger);
|
|
|
|
mainVehicleWeaponSystem.setVehicleHUDInfoManager (currentPassengerComponents.mainPlayerHUDManager);
|
|
|
|
mainVehicleWeaponSystem.setGKCSimpleRiderSystem (this);
|
|
|
|
getHUDBars (currentPassengerComponents.mainPlayerHUDManager, currentPassengerComponents.mainPlayerHUDManager.getHudElements (), isBeingDriven);
|
|
}
|
|
}
|
|
|
|
public void setVehicleWeaponsComponents ()
|
|
{
|
|
if (mainVehicleWeaponSystemInitialized) {
|
|
return;
|
|
}
|
|
|
|
if (mainVehicleWeaponSystem != null) {
|
|
mainVehicleWeaponSystem.setVehicleWeaponsComponents ();
|
|
|
|
mainVehicleWeaponSystemInitialized = true;
|
|
}
|
|
}
|
|
|
|
public void getAmmo (string ammoName, int amount)
|
|
{
|
|
if (mainVehicleWeaponSystem != null && mainVehicleWeaponSystem.isWeaponsEnabled ()) {
|
|
mainVehicleWeaponSystem.getAmmo (ammoName, amount);
|
|
}
|
|
}
|
|
|
|
public void setDestroyedState (bool state)
|
|
{
|
|
destroyed = state;
|
|
|
|
}
|
|
|
|
public void setWeaponName (string name, int ammoPerClip, int clipSize)
|
|
{
|
|
if (weaponNameTextAssigned) {
|
|
weaponNameText.text = name;
|
|
|
|
vehicleAmmo.maxValue = ammoPerClip;
|
|
|
|
vehicleAmmo.value = clipSize;
|
|
}
|
|
}
|
|
|
|
//the player is shooting while he is driving, so use ammo of the vehicle weapon
|
|
public void useAmmo (int clipSize, int remainAmmo)
|
|
{
|
|
if (ammoAmountTextAssigned) {
|
|
if (remainAmmo == -1) {
|
|
ammoAmountText.text = clipSize + "/Inf";
|
|
} else {
|
|
ammoAmountText.text = clipSize + "/" + remainAmmo;
|
|
}
|
|
|
|
vehicleAmmo.value = clipSize;
|
|
}
|
|
}
|
|
|
|
public void reactivateCollidersIfPossible ()
|
|
{
|
|
int colliderPartsCount = colliderParts.Count;
|
|
|
|
for (int i = 0; i < colliderPartsCount; i++) {
|
|
if (colliderParts [i] != null) {
|
|
colliderParts [i].enabled = false;
|
|
|
|
colliderParts [i].enabled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public IKDrivingSystem.IKDrivingInformation getIKVehiclePassengerInfo (GameObject passenger)
|
|
{
|
|
int IKVehiclePassengersListCount = IKVehiclePassengersList.Count;
|
|
|
|
for (int i = 0; i < IKVehiclePassengersListCount; i++) {
|
|
if (IKVehiclePassengersList [i].vehicleSeatInfo.currentPassenger == passenger) {
|
|
return IKVehiclePassengersList [i];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public bool setPassengerInfo (IKDrivingSystem.IKDrivingInformation passengerInfo, GameObject passenger)
|
|
{
|
|
bool isGettingOn = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("ADD PASSENGER " + passenger.name);
|
|
}
|
|
|
|
if (!passengerGameObjectList.Contains (passenger)) {
|
|
passengerGameObjectList.Add (passenger);
|
|
|
|
passengerInfo.vehicleSeatInfo.currentPassenger = passenger;
|
|
|
|
isGettingOn = true;
|
|
|
|
setPassengerComponents (passenger);
|
|
}
|
|
|
|
return isGettingOn;
|
|
}
|
|
|
|
public void getRiderGameObject (GameObject newRiderGameObject)
|
|
{
|
|
currentRiderGameObject = newRiderGameObject;
|
|
}
|
|
|
|
public void setPassengerComponents (GameObject currentPassenger)
|
|
{
|
|
IKDrivingSystem.passengerComponents newPassengerComponentsList = new IKDrivingSystem.passengerComponents ();
|
|
|
|
newPassengerComponentsList.currentPassenger = currentPassenger;
|
|
|
|
playerComponentsManager mainPlayerComponentsManager = currentPassenger.GetComponent<playerComponentsManager> ();
|
|
|
|
newPassengerComponentsList.mainPlayerComponentsManager = mainPlayerComponentsManager;
|
|
|
|
newPassengerComponentsList.playerControllerManager = mainPlayerComponentsManager.getPlayerController ();
|
|
|
|
newPassengerComponentsList.usingDevicesManager = mainPlayerComponentsManager.getUsingDevicesSystem ();
|
|
|
|
newPassengerComponentsList.playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
|
|
|
|
newPassengerComponentsList.playerCameraGameObject = newPassengerComponentsList.playerCameraManager.gameObject;
|
|
|
|
newPassengerComponentsList.playerGravityManager = mainPlayerComponentsManager.getGravitySystem ();
|
|
|
|
newPassengerComponentsList.playerWeaponManager = mainPlayerComponentsManager.getPlayerWeaponsManager ();
|
|
|
|
newPassengerComponentsList.mainMeleeWeaponsGrabbedManager = mainPlayerComponentsManager.getMeleeWeaponsGrabbedManager ();
|
|
|
|
newPassengerComponentsList.mainCamera = newPassengerComponentsList.playerCameraManager.getMainCamera ();
|
|
newPassengerComponentsList.mainCameraTransform = newPassengerComponentsList.mainCamera.transform;
|
|
|
|
newPassengerComponentsList.mainRigidbody = newPassengerComponentsList.playerControllerManager.getRigidbody ();
|
|
|
|
newPassengerComponentsList.IKManager = mainPlayerComponentsManager.getIKSystem ();
|
|
|
|
newPassengerComponentsList.mainFootStepManager = mainPlayerComponentsManager.getFootStepManager ();
|
|
|
|
newPassengerComponentsList.healthManager = mainPlayerComponentsManager.getHealth ();
|
|
|
|
newPassengerComponentsList.statesManager = mainPlayerComponentsManager.getPlayerStatesManager ();
|
|
|
|
newPassengerComponentsList.mainHideCharacterFixedPlaceSystemPlayerManagement = newPassengerComponentsList.mainPlayerComponentsManager.getHideCharacterFixedPlaceSystemPlayerManagement ();
|
|
|
|
newPassengerComponentsList.pauseManager = mainPlayerComponentsManager.getPauseManager ();
|
|
|
|
newPassengerComponentsList.mainInventoryManager = mainPlayerComponentsManager.getInventoryManager ();
|
|
|
|
newPassengerComponentsList.mainPlayerHUDManager = mainPlayerComponentsManager.getPlayerHUDManager ();
|
|
|
|
newPassengerComponentsList.mapManager = mainPlayerComponentsManager.getMapSystem ();
|
|
|
|
newPassengerComponentsList.mainRagdollActivator = mainPlayerComponentsManager.getRagdollActivator ();
|
|
|
|
newPassengerComponentsList.carryingFireWeaponsPrevioulsy = newPassengerComponentsList.playerWeaponManager.isUsingWeapons ();
|
|
|
|
newPassengerComponentsList.carryingMeleeWeaponsPreviously = newPassengerComponentsList.playerControllerManager.isPlayerUsingMeleeWeapons ();
|
|
|
|
newPassengerComponentsList.mainRemoteEventSystem = mainPlayerComponentsManager.getRemoteEventSystem ();
|
|
|
|
newPassengerComponentsList.mainPlayerActionSystem = mainPlayerComponentsManager.getPlayerActionSystem ();
|
|
|
|
newPassengerComponentsList.mainVehiclePassengerUnderwater = mainPlayerComponentsManager.getVehiclePassengerUnderwater ();
|
|
|
|
newPassengerComponentsList.previousPlayerStatusID = newPassengerComponentsList.playerControllerManager.playerStatusID;
|
|
|
|
newPassengerComponentsList.previousIdleID = newPassengerComponentsList.playerControllerManager.getCurrentIdleID ();
|
|
|
|
newPassengerComponentsList.previousStrafeID = newPassengerComponentsList.playerControllerManager.currentStrafeID;
|
|
|
|
newPassengerComponentsList.playerControllerManager.setPlayerStatusIDValue (0);
|
|
|
|
newPassengerComponentsList.playerControllerManager.setCurrentIdleIDValue (0);
|
|
|
|
newPassengerComponentsList.playerControllerManager.setCurrentStrafeIDValue (0);
|
|
|
|
newPassengerComponentsList.playerControllerManager.setOriginalAirIDValue ();
|
|
|
|
newPassengerComponentsList.playerControllerManager.updatePlayerStatusIDOnAnimator ();
|
|
|
|
newPassengerComponentsList.playerControllerManager.updateIdleIDOnAnimator ();
|
|
|
|
newPassengerComponentsList.playerControllerManager.updateStrafeIDOnAnimator ();
|
|
|
|
newPassengerComponentsList.playerControllerManager.updateAirIDAnimatorID ();
|
|
|
|
newPassengerComponentsList.playerControllerManager.setOnGroundAnimatorIDValue (true);
|
|
|
|
passengerComponentsList.Add (newPassengerComponentsList);
|
|
}
|
|
|
|
public void checkDriverHeadMeshOnCameraViewChange (bool isFirstPersonCamera)
|
|
{
|
|
if (isBeingDriven) {
|
|
if (currentPassengerDriverComponents != null) {
|
|
currentPassengerDriverComponents.playerControllerManager.changeHeadScale (isFirstPersonCamera);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void findPlayerOnScene ()
|
|
{
|
|
if (searchPlayerOnSceneIfNotAssigned) {
|
|
getRiderGameObject (GKC_Utils.findMainPlayerOnScene ());
|
|
|
|
if (currentRiderGameObject != null) {
|
|
playerAssignedProperly = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void killCharacterOnVehicle ()
|
|
{
|
|
if (isBeingDriven) {
|
|
if (currentPassengerDriverComponents != null && currentPassengerDriverComponents.usingDevicesManager != null) {
|
|
customPassengerPosition = passengerParent.position + passengerParent.up * 3;
|
|
|
|
health currentHealthManager = currentPassengerDriverComponents.healthManager;
|
|
|
|
currentPassengerDriverComponents.usingDevicesManager.useCurrentDevice (vehicleGameObject);
|
|
|
|
currentHealthManager.killCharacter ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ejectCharacterFromVehicle ()
|
|
{
|
|
if (isBeingDriven) {
|
|
if (currentPassengerDriverComponents != null && currentPassengerDriverComponents.usingDevicesManager != null) {
|
|
customPassengerPosition = passengerParent.position + passengerParent.up * 3;
|
|
|
|
currentPassengerDriverComponents.usingDevicesManager.useCurrentDevice (vehicleGameObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void getOffFromVehicle ()
|
|
{
|
|
if (isBeingDriven) {
|
|
if (currentPassengerDriverComponents != null) {
|
|
if (currentPassengerDriverComponents.usingDevicesManager != null) {
|
|
currentPassengerDriverComponents.usingDevicesManager.useCurrentDevice (vehicleGameObject);
|
|
|
|
if (showDebugPrint) {
|
|
print ("activating get off input action");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public string getVehicleName ()
|
|
{
|
|
return vehicleName;
|
|
}
|
|
|
|
public bool isVehicleFull ()
|
|
{
|
|
if (passengerGameObjectList.Count == IKVehiclePassengersList.Count) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public int getDriverSeatPassengerIndex ()
|
|
{
|
|
int IKVehiclePassengersListCount = IKVehiclePassengersList.Count;
|
|
|
|
for (int i = 0; i < IKVehiclePassengersListCount; i++) {
|
|
if (IKVehiclePassengersList [i].vehicleSeatInfo.isDriverSeat) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public int getClosestSeatToPassengerIndex (GameObject currentPassenger)
|
|
{
|
|
bool characterCanDrive = false;
|
|
|
|
playerController currentPlayerController = currentPassenger.GetComponent<playerController> ();
|
|
|
|
if (currentPlayerController != null) {
|
|
if (currentPlayerController.canCharacterDrive ()) {
|
|
characterCanDrive = true;
|
|
}
|
|
}
|
|
|
|
if (getOnlyPassengerSeatActive) {
|
|
characterCanDrive = false;
|
|
}
|
|
|
|
int currentIKVehiclePassengerIndex = -1;
|
|
|
|
float maxDistance = Mathf.Infinity;
|
|
|
|
Vector3 currentPassengerPosition = currentPassenger.transform.position;
|
|
|
|
int IKVehiclePassengersListCount = IKVehiclePassengersList.Count;
|
|
|
|
for (int i = 0; i < IKVehiclePassengersListCount; i++) {
|
|
if (IKVehiclePassengersList [i].vehicleSeatInfo.seatIsFree) {
|
|
if (characterCanDrive || (!IKVehiclePassengersList [i].vehicleSeatInfo.isDriverSeat && !characterCanDrive)) {
|
|
|
|
float currentDistance = GKC_Utils.distance (currentPassengerPosition, IKVehiclePassengersList [i].vehicleSeatInfo.seatTransform.position);
|
|
|
|
if (currentDistance < maxDistance) {
|
|
maxDistance = currentDistance;
|
|
currentIKVehiclePassengerIndex = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return currentIKVehiclePassengerIndex;
|
|
}
|
|
|
|
//Override functions
|
|
public override bool checkIfDetectSurfaceBelongToVehicle (Collider surfaceFound)
|
|
{
|
|
if (colliderParts.Contains (surfaceFound)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override Collider getVehicleCollider ()
|
|
{
|
|
int colliderPartsCount = colliderParts.Count;
|
|
|
|
if (colliderPartsCount > 0) {
|
|
for (int i = 0; i < colliderPartsCount; i++) {
|
|
if (colliderParts [i] != null) {
|
|
if (colliderParts [i].GetComponent<characterDamageReceiver> () != null) {
|
|
return colliderParts [i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public override float getVehicleRadius ()
|
|
{
|
|
return vehicleRadius;
|
|
}
|
|
|
|
public override bool isBeingDrivenActive ()
|
|
{
|
|
return isBeingDriven;
|
|
}
|
|
|
|
public override GameObject getCurrentDriver ()
|
|
{
|
|
if (currentPassengerDriverComponents != null) {
|
|
return currentPassengerDriverComponents.currentPassenger;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public override void setPlayerVisibleInVehicleState (bool state)
|
|
{
|
|
playerVisibleInVehicle = state;
|
|
}
|
|
|
|
public override GameObject getVehicleGameObject ()
|
|
{
|
|
return vehicleGameObject;
|
|
}
|
|
|
|
public override Transform getCustomVehicleTransform ()
|
|
{
|
|
if (customVehicleGameObject == null) {
|
|
customVehicleGameObject = vehicleGameObject;
|
|
}
|
|
|
|
return customVehicleGameObject.transform;
|
|
}
|
|
|
|
public override void setEnteringOnVehicleFromDistanceState (bool state)
|
|
{
|
|
enteringOnVehicleFromDistance = state;
|
|
}
|
|
|
|
public override void setCurrentPassenger (GameObject passenger)
|
|
{
|
|
currentRiderGameObject = passenger;
|
|
}
|
|
|
|
public void setPauseDriverGetOffInputActionState (bool state)
|
|
{
|
|
if (isBeingDriven) {
|
|
if (currentPassengerDriverComponents != null && currentPassengerDriverComponents.usingDevicesManager != null) {
|
|
|
|
currentPassengerDriverComponents.usingDevicesManager.setUseDeviceButtonEnabledState (state);
|
|
}
|
|
}
|
|
}
|
|
|
|
//INPUT FUNCTIONS
|
|
public void inputGetOffFromVehicle ()
|
|
{
|
|
if (isBeingDriven) {
|
|
getOffFromVehicle ();
|
|
}
|
|
}
|
|
}
|