533 lines
16 KiB
C#
533 lines
16 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class hideCharacterFixedPlaceSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool cameraCanRotate = true;
|
|
public float rotationSpeed = 10;
|
|
public Vector2 rangeAngleX = new Vector2 (-90, 90);
|
|
public Vector2 rangeAngleY = new Vector2 (-90, 90);
|
|
public bool useSpringRotation;
|
|
public float springRotationDelay = 1;
|
|
public float smoothCameraRotationSpeed = 5;
|
|
|
|
public bool cameraCanMove = true;
|
|
public float moveCameraSpeed = 10;
|
|
public float smoothMoveCameraSpeed = 5;
|
|
public Vector2 moveCameraLimitsX = new Vector2 (-2, 2);
|
|
public Vector2 moveCameraLimitsY = new Vector2 (-2, 2);
|
|
|
|
public bool useSpringMovement;
|
|
public float springMovementDelay = 1;
|
|
|
|
public bool checkIfDetectedWhileHidden;
|
|
|
|
public bool setHiddenFov;
|
|
public float hiddenFov = 20;
|
|
public bool zoomEnabled;
|
|
public float zoomSpeed = 10;
|
|
public float maxZoom = 10;
|
|
public float minZoom = 90;
|
|
|
|
public Transform cameraTransform;
|
|
public Transform pivotTransform;
|
|
public Transform cameraPositionTransform;
|
|
|
|
public float hideEventDelay;
|
|
public float visibleEventDelay;
|
|
|
|
public bool canResetCameraRotation = true;
|
|
public bool canResetCameraPosition = true;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool useCharacterStateIcon = true;
|
|
public string visibleCharacterStateName = "Visible";
|
|
public string notVisibleCharacterStateName = "Not Visible";
|
|
|
|
public bool activateActionScreen = true;
|
|
public string actionScreenName = "Use Hide System";
|
|
|
|
public bool useMessageWhenUnableToHide;
|
|
[TextArea (1, 10)] public string unableToHideMessage;
|
|
public float showMessageTime;
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public UnityEvent hidenEvent = new UnityEvent ();
|
|
public UnityEvent visbleEvent = new UnityEvent ();
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool hidingCharacter;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public moveCameraToDevice moveCameraManager;
|
|
public electronicDevice electronicDeviceManager;
|
|
|
|
[Space]
|
|
[Header ("Gizmo Settings")]
|
|
[Space]
|
|
|
|
public bool showGizmo;
|
|
public Color gizmoColor;
|
|
public float arcGizmoRadius;
|
|
public float gizmoArrowLength = 1;
|
|
public float gizmoArrowAngle = 20;
|
|
public Color gizmoArrowColor = Color.white;
|
|
|
|
float originalCameraRotationX;
|
|
float originalPivotRotationY;
|
|
Quaternion currentCameraRotation;
|
|
Quaternion currentPivotRotation;
|
|
GameObject currentPlayer;
|
|
|
|
Vector2 currentLookAngle;
|
|
float lastTimeSpringRotation;
|
|
|
|
playerController playerControllerManager;
|
|
playerCamera playerCameraManager;
|
|
|
|
playerInputManager playerInput;
|
|
playerComponentsManager mainPlayerComponentsManager;
|
|
playerStatesManager statesManager;
|
|
|
|
characterFactionManager currentfactionManager;
|
|
usingDevicesSystem devicesManager;
|
|
|
|
Collider currentPlayerCollider;
|
|
|
|
hideCharacterFixedPlaceSystemPlayerManagement hideCharacterFixedPlaceSystemPlayerManager;
|
|
|
|
Vector3 currentMoveCameraPosition;
|
|
Vector3 originalCameraLocalPosition;
|
|
Vector3 currentCameraMovementPosition;
|
|
float lastTimeSpringMovement;
|
|
bool characterIsDetected;
|
|
|
|
float horizontalMouse;
|
|
float verticalMouse;
|
|
float horizontalInput;
|
|
float verticalInput;
|
|
Coroutine eventCoroutine;
|
|
|
|
bool increaseZoom;
|
|
bool decreaseZoom;
|
|
float currentFovValue;
|
|
Camera mainCamera;
|
|
|
|
float lastTimeMouseWheelUsed;
|
|
bool mouseWheelUsedPreviously;
|
|
Vector2 axisValues;
|
|
|
|
bool currentPlayerCameraIsFree;
|
|
|
|
bool characterFoundInsideHidePlace;
|
|
|
|
void Start ()
|
|
{
|
|
originalCameraRotationX = cameraTransform.localRotation.eulerAngles.x;
|
|
originalPivotRotationY = pivotTransform.localRotation.eulerAngles.y;
|
|
|
|
if (electronicDeviceManager == null) {
|
|
electronicDeviceManager = GetComponent<electronicDevice> ();
|
|
}
|
|
|
|
if (moveCameraManager == null) {
|
|
moveCameraManager = GetComponent<moveCameraToDevice> ();
|
|
}
|
|
|
|
originalCameraLocalPosition = pivotTransform.localPosition;
|
|
}
|
|
|
|
void FixedUpdate ()
|
|
{
|
|
if (hidingCharacter) {
|
|
if (checkIfDetectedWhileHidden && !characterFoundInsideHidePlace) {
|
|
characterFoundInsideHidePlace = currentfactionManager.isCharacterDetectedAsEnemyByOtherFaction (currentPlayer);
|
|
|
|
if (characterFoundInsideHidePlace) {
|
|
devicesManager.inputActivateDevice ();
|
|
|
|
characterFoundInsideHidePlace = false;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (currentPlayerCameraIsFree && !moveCameraManager.isCameraMoving ()) {
|
|
axisValues = playerInput.getPlayerMouseAxis ();
|
|
horizontalMouse = axisValues.x;
|
|
verticalMouse = axisValues.y;
|
|
|
|
if (cameraCanRotate) {
|
|
currentLookAngle.x += horizontalMouse * rotationSpeed;
|
|
currentLookAngle.y -= verticalMouse * rotationSpeed;
|
|
|
|
currentLookAngle.x = Mathf.Clamp (currentLookAngle.x, rangeAngleY.x, rangeAngleY.y);
|
|
|
|
currentLookAngle.y = Mathf.Clamp (currentLookAngle.y, rangeAngleX.x, rangeAngleX.y);
|
|
|
|
currentCameraRotation = Quaternion.Euler (originalCameraRotationX + currentLookAngle.y, 0, 0);
|
|
|
|
currentPivotRotation = Quaternion.Euler (0, originalPivotRotationY + currentLookAngle.x, 0);
|
|
}
|
|
|
|
if (useSpringRotation && canResetCameraRotation) {
|
|
if (horizontalMouse != 0 || verticalMouse != 0) {
|
|
lastTimeSpringRotation = Time.time;
|
|
}
|
|
|
|
if (Time.time > lastTimeSpringRotation + springRotationDelay) {
|
|
currentCameraRotation = Quaternion.Euler (originalCameraRotationX, 0, 0);
|
|
currentPivotRotation = Quaternion.Euler (0, originalPivotRotationY, 0);
|
|
currentLookAngle = Vector2.zero;
|
|
}
|
|
}
|
|
|
|
cameraTransform.localRotation = Quaternion.Lerp (cameraTransform.localRotation, currentCameraRotation, Time.deltaTime * smoothCameraRotationSpeed);
|
|
|
|
pivotTransform.localRotation = Quaternion.Lerp (pivotTransform.localRotation, currentPivotRotation, Time.deltaTime * smoothCameraRotationSpeed);
|
|
|
|
axisValues = playerInput.getPlayerMovementAxis ();
|
|
horizontalInput = axisValues.x;
|
|
verticalInput = axisValues.y;
|
|
|
|
if (cameraCanMove) {
|
|
currentMoveCameraPosition.x += horizontalInput * moveCameraSpeed;
|
|
currentMoveCameraPosition.y += verticalInput * moveCameraSpeed;
|
|
|
|
currentMoveCameraPosition.x = Mathf.Clamp (currentMoveCameraPosition.x, moveCameraLimitsX.x, moveCameraLimitsX.y);
|
|
|
|
currentMoveCameraPosition.y = Mathf.Clamp (currentMoveCameraPosition.y, moveCameraLimitsY.x, moveCameraLimitsY.y);
|
|
|
|
Vector3 moveInput = currentMoveCameraPosition.x * Vector3.right + currentMoveCameraPosition.y * Vector3.up;
|
|
|
|
currentCameraMovementPosition = originalCameraLocalPosition + moveInput;
|
|
}
|
|
|
|
if (useSpringMovement && canResetCameraPosition) {
|
|
if (horizontalInput != 0 || verticalInput != 0) {
|
|
lastTimeSpringMovement = Time.time;
|
|
}
|
|
|
|
if (Time.time > lastTimeSpringMovement + springMovementDelay) {
|
|
currentCameraMovementPosition = originalCameraLocalPosition;
|
|
currentMoveCameraPosition = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
pivotTransform.localPosition = Vector3.MoveTowards (pivotTransform.localPosition, currentCameraMovementPosition, Time.deltaTime * smoothMoveCameraSpeed);
|
|
|
|
if (zoomEnabled) {
|
|
|
|
if (mouseWheelUsedPreviously && Time.time > lastTimeMouseWheelUsed + 0.1f) {
|
|
increaseZoom = false;
|
|
decreaseZoom = false;
|
|
mouseWheelUsedPreviously = false;
|
|
}
|
|
|
|
if (increaseZoom) {
|
|
currentFovValue -= Time.deltaTime * zoomSpeed;
|
|
}
|
|
|
|
if (decreaseZoom) {
|
|
currentFovValue += Time.deltaTime * zoomSpeed;
|
|
}
|
|
|
|
currentFovValue = Mathf.Clamp (currentFovValue, maxZoom, minZoom);
|
|
|
|
if (playerCameraManager.isFOVChanging ()) {
|
|
currentFovValue = mainCamera.fieldOfView;
|
|
} else {
|
|
mainCamera.fieldOfView = currentFovValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableHideState ()
|
|
{
|
|
if (characterIsDetected) {
|
|
return;
|
|
}
|
|
|
|
hidingCharacter = !hidingCharacter;
|
|
|
|
if (hidingCharacter) {
|
|
setCurrentPlayer (electronicDeviceManager.getCurrentPlayer ());
|
|
}
|
|
|
|
if (playerCameraManager.isCameraTypeFree ()) {
|
|
if (hidingCharacter) {
|
|
if (setHiddenFov) {
|
|
playerCameraManager.setMainCameraFov (hiddenFov, zoomSpeed);
|
|
}
|
|
} else {
|
|
playerCameraManager.setOriginalCameraFov ();
|
|
}
|
|
|
|
currentPlayerCameraIsFree = true;
|
|
} else {
|
|
currentPlayerCameraIsFree = false;
|
|
}
|
|
|
|
playerControllerManager.setVisibleToAIState (!hidingCharacter);
|
|
|
|
if (hidingCharacter) {
|
|
statesManager.checkPlayerStates ();
|
|
}
|
|
|
|
if (!checkIfDetectedWhileHidden) {
|
|
currentPlayerCollider.enabled = !hidingCharacter;
|
|
}
|
|
|
|
setCharacterState ();
|
|
|
|
callUnityEvents ();
|
|
|
|
resetCameraInputValues ();
|
|
|
|
if (hideCharacterFixedPlaceSystemPlayerManager) {
|
|
hideCharacterFixedPlaceSystemPlayerManager.setPlayerHidingState (hidingCharacter);
|
|
}
|
|
|
|
if (activateActionScreen) {
|
|
playerInput.enableOrDisableActionScreen (actionScreenName, hidingCharacter);
|
|
}
|
|
}
|
|
|
|
public void setCharacterState ()
|
|
{
|
|
if (useCharacterStateIcon) {
|
|
if (hidingCharacter) {
|
|
playerControllerManager.setCharacterStateIcon (notVisibleCharacterStateName);
|
|
} else {
|
|
playerControllerManager.setCharacterStateIcon (visibleCharacterStateName);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void callUnityEvents ()
|
|
{
|
|
if (eventCoroutine != null) {
|
|
StopCoroutine (eventCoroutine);
|
|
}
|
|
|
|
eventCoroutine = StartCoroutine (callUnityEventsCoroutine ());
|
|
}
|
|
|
|
IEnumerator callUnityEventsCoroutine ()
|
|
{
|
|
if (hidingCharacter) {
|
|
yield return new WaitForSeconds (hideEventDelay);
|
|
|
|
if (hidenEvent.GetPersistentEventCount () > 0) {
|
|
hidenEvent.Invoke ();
|
|
}
|
|
} else {
|
|
yield return new WaitForSeconds (visibleEventDelay);
|
|
|
|
if (visbleEvent.GetPersistentEventCount () > 0) {
|
|
visbleEvent.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void resetCameraInputValues ()
|
|
{
|
|
//reset input values and camera and pivot position and rotation
|
|
horizontalMouse = 0;
|
|
verticalMouse = 0;
|
|
currentLookAngle = Vector2.zero;
|
|
currentCameraRotation = Quaternion.identity;
|
|
currentPivotRotation = Quaternion.identity;
|
|
cameraTransform.localRotation = Quaternion.identity;
|
|
pivotTransform.localRotation = Quaternion.identity;
|
|
|
|
horizontalInput = 0;
|
|
verticalInput = 0;
|
|
currentMoveCameraPosition = Vector3.zero;
|
|
currentCameraMovementPosition = Vector3.zero;
|
|
pivotTransform.localPosition = Vector3.zero;
|
|
}
|
|
|
|
public void changeResetCameraTransfrom ()
|
|
{
|
|
canResetCameraRotation = !canResetCameraRotation;
|
|
canResetCameraPosition = !canResetCameraPosition;
|
|
lastTimeSpringRotation = 0;
|
|
lastTimeSpringMovement = 0;
|
|
}
|
|
|
|
public void setCurrentPlayer (GameObject player)
|
|
{
|
|
currentPlayer = player;
|
|
|
|
if (currentPlayer != null) {
|
|
mainPlayerComponentsManager = currentPlayer.GetComponent<playerComponentsManager> ();
|
|
|
|
playerControllerManager = mainPlayerComponentsManager.getPlayerController ();
|
|
|
|
currentPlayerCollider = playerControllerManager.getMainCollider ();
|
|
|
|
statesManager = mainPlayerComponentsManager.getPlayerStatesManager ();
|
|
|
|
currentfactionManager = mainPlayerComponentsManager.getCharacterFactionManager ();
|
|
|
|
devicesManager = mainPlayerComponentsManager.getUsingDevicesSystem ();
|
|
|
|
playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
|
|
|
|
mainCamera = playerCameraManager.getMainCamera ();
|
|
currentFovValue = mainCamera.fieldOfView;
|
|
|
|
playerInput = mainPlayerComponentsManager.getPlayerInputManager ();
|
|
|
|
hideCharacterFixedPlaceSystemPlayerManager = mainPlayerComponentsManager.getHideCharacterFixedPlaceSystemPlayerManagement ();
|
|
|
|
hideCharacterFixedPlaceSystemPlayerManager.setCurrentFixedHideSystem (this);
|
|
}
|
|
}
|
|
|
|
public void checkIfDetected ()
|
|
{
|
|
if (currentPlayer == null) {
|
|
setCurrentPlayer (electronicDeviceManager.getCurrentPlayer ());
|
|
}
|
|
|
|
//check if the current character is being searching by an enemy when the character is trying to hide
|
|
if (currentPlayer != null && !hidingCharacter) {
|
|
characterIsDetected = currentfactionManager.isCharacterDetectedAsEnemyByOtherFaction (currentPlayer);
|
|
|
|
//print ("characterIsDetected " + characterIsDetected);
|
|
if (characterIsDetected) {
|
|
electronicDeviceManager.setDeviceCanBeUsedState (false);
|
|
} else {
|
|
electronicDeviceManager.setDeviceCanBeUsedState (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void showUnableToHideMessage ()
|
|
{
|
|
//show a message that he can't be hidden until none enemy is searching him
|
|
if (useMessageWhenUnableToHide && currentPlayer != null) {
|
|
devicesManager.checkShowObjectMessage (unableToHideMessage, showMessageTime);
|
|
}
|
|
}
|
|
|
|
//GET INPUT FUNCTIONS
|
|
public void inputResetCameraTransform ()
|
|
{
|
|
if (hidingCharacter && !moveCameraManager.isCameraMoving ()) {
|
|
changeResetCameraTransfrom ();
|
|
}
|
|
}
|
|
|
|
public void inputSetIncreaseZoomStateByButton (bool state)
|
|
{
|
|
if (hidingCharacter && !moveCameraManager.isCameraMoving () && zoomEnabled) {
|
|
if (state) {
|
|
increaseZoom = true;
|
|
} else {
|
|
increaseZoom = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputSetDecreaseZoomStateByButton (bool state)
|
|
{
|
|
if (hidingCharacter && !moveCameraManager.isCameraMoving () && zoomEnabled) {
|
|
if (state) {
|
|
decreaseZoom = true;
|
|
} else {
|
|
decreaseZoom = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputSetZoomValueByMouseWheel (bool state)
|
|
{
|
|
if (hidingCharacter && !moveCameraManager.isCameraMoving () && zoomEnabled) {
|
|
if (state) {
|
|
lastTimeMouseWheelUsed = Time.time;
|
|
increaseZoom = true;
|
|
mouseWheelUsedPreviously = true;
|
|
} else {
|
|
lastTimeMouseWheelUsed = Time.time;
|
|
decreaseZoom = true;
|
|
mouseWheelUsedPreviously = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo) {
|
|
Gizmos.color = gizmoColor;
|
|
|
|
GKC_Utils.drawGizmoArrow (cameraTransform.position, cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x), gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
|
|
|
|
GKC_Utils.drawGizmoArrow (cameraTransform.position, -cameraTransform.right * moveCameraLimitsX.y, gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
|
|
|
|
GKC_Utils.drawGizmoArrow (cameraTransform.position, cameraTransform.up * moveCameraLimitsY.y, gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
|
|
|
|
GKC_Utils.drawGizmoArrow (cameraTransform.position, -cameraTransform.up * Mathf.Abs (moveCameraLimitsY.x), gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
|
|
|
|
Gizmos.color = Color.white;
|
|
|
|
Gizmos.DrawLine (cameraTransform.position + cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x),
|
|
cameraTransform.position + cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x) + cameraTransform.up * moveCameraLimitsY.y);
|
|
Gizmos.DrawLine (cameraTransform.position + cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x) + cameraTransform.up * moveCameraLimitsY.y,
|
|
cameraTransform.position + cameraTransform.up * moveCameraLimitsY.y);
|
|
|
|
Gizmos.DrawLine (cameraTransform.position - cameraTransform.right * moveCameraLimitsX.y,
|
|
cameraTransform.position - cameraTransform.right * moveCameraLimitsX.y + cameraTransform.up * moveCameraLimitsY.y);
|
|
Gizmos.DrawLine (cameraTransform.position - cameraTransform.right * moveCameraLimitsX.y + cameraTransform.up * moveCameraLimitsY.y,
|
|
cameraTransform.position + cameraTransform.up * moveCameraLimitsY.y);
|
|
|
|
Gizmos.DrawLine (cameraTransform.position - cameraTransform.right * moveCameraLimitsX.y,
|
|
cameraTransform.position - cameraTransform.right * moveCameraLimitsX.y + cameraTransform.up * moveCameraLimitsY.x);
|
|
Gizmos.DrawLine (cameraTransform.position - cameraTransform.right * moveCameraLimitsX.y + cameraTransform.up * moveCameraLimitsY.x,
|
|
cameraTransform.position + cameraTransform.up * moveCameraLimitsY.x);
|
|
|
|
Gizmos.DrawLine (cameraTransform.position + cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x),
|
|
cameraTransform.position + cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x) + cameraTransform.up * moveCameraLimitsY.x);
|
|
Gizmos.DrawLine (cameraTransform.position + cameraTransform.right * Mathf.Abs (moveCameraLimitsX.x) + cameraTransform.up * moveCameraLimitsY.x,
|
|
cameraTransform.position + cameraTransform.up * moveCameraLimitsY.x);
|
|
}
|
|
}
|
|
}
|