722 lines
24 KiB
C#
722 lines
24 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.UIElements;
|
|
|
|
public class playerTeleportSystem : abilityInfo
|
|
{
|
|
[Header ("Custom Settings")]
|
|
[Space]
|
|
|
|
//Teleport ability variables
|
|
public bool teleportingEnabled;
|
|
public LayerMask teleportLayerMask;
|
|
|
|
[Space]
|
|
|
|
public float maxDistanceToTeleport = 100;
|
|
public bool useTeleportIfSurfaceNotFound = true;
|
|
public float maxDistanceToTeleportAir = 10;
|
|
|
|
[Space]
|
|
|
|
public float holdButtonTimeToActivateTeleport = 0.4f;
|
|
public bool stopTeleportIfMoving;
|
|
public bool addForceIfTeleportStops;
|
|
public float forceIfTeleportStops;
|
|
|
|
public bool canTeleportOnZeroGravity;
|
|
|
|
public bool teleportInstantlyToPosition;
|
|
|
|
public bool useFixedTeleportHookPointsEnabled = true;
|
|
|
|
[Space]
|
|
[Header ("Capsule Cast Settings")]
|
|
[Space]
|
|
|
|
public bool useCapsuleCastToCheckTargetReached = true;
|
|
public float capsuleCastRadius = 0.5f;
|
|
public float maxCapsuleCastDistance = 1.3f;
|
|
|
|
[Space]
|
|
[Header ("Camera Settings")]
|
|
[Space]
|
|
|
|
public bool useSmoothCameraFollowStateOnTeleport = true;
|
|
public float smoothCameraFollowDuration = 3;
|
|
|
|
[Space]
|
|
|
|
public bool allowQuickTeleportIfLockonTargetActive;
|
|
|
|
public LayerMask checkLockonTargetsLayermask;
|
|
|
|
[Space]
|
|
[Header ("Movement/Rotation Settings")]
|
|
[Space]
|
|
|
|
public float teleportSpeed = 10;
|
|
|
|
public bool rotateTowardTeleportPosition;
|
|
|
|
public float teleportRotationSpeed = 5;
|
|
public float minAngleToRotateTowardTeleportDirection = 15;
|
|
|
|
[Space]
|
|
[Header ("Effect Settings")]
|
|
[Space]
|
|
|
|
public bool useBulletTimeOnTeleport;
|
|
public float bulletTimeScaleOnTeleport = 0.5f;
|
|
|
|
public bool useTeleportMark;
|
|
|
|
public bool changeCameraFovOnTeleport;
|
|
public float cameraFovOnTeleport;
|
|
public float cameraFovOnTeleportSpeed;
|
|
|
|
[Space]
|
|
[Header ("Animation Settings")]
|
|
[Space]
|
|
|
|
public bool useActionSystemOnTeleport = true;
|
|
public string actionNameUsedOnTeleport = "Teleport Pose";
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool teleportCanBeExecuted;
|
|
public bool searchingForTeleport;
|
|
|
|
public bool teleportSurfaceFound;
|
|
public bool teleportInProcess;
|
|
|
|
public Transform currentTeleportHookTarget;
|
|
|
|
public bool teleportActivateByHookTarget;
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public bool useEventsOnStartTeleport;
|
|
public UnityEvent eventsOnStartTeleport;
|
|
public bool useEventsOnEndTeleport;
|
|
public UnityEvent eventsOnEndTeleport;
|
|
|
|
[Space]
|
|
[Header ("Component Elements")]
|
|
[Space]
|
|
|
|
public GameObject teleportMark;
|
|
public Transform playerControllerTransform;
|
|
public Transform mainCameraTransform;
|
|
public gravitySystem mainGravitySystem;
|
|
public playerController mainPlayerController;
|
|
public timeBullet mainTimeBullet;
|
|
public playerCamera mainPlayerCamera;
|
|
|
|
|
|
float lastTimeTeleportButtonPressed;
|
|
Coroutine teleportCoroutine;
|
|
Vector3 currentTeleportPosition;
|
|
Vector3 teleportMarkDirection;
|
|
Vector3 currentTeleportPositionNormal;
|
|
|
|
RaycastHit hit;
|
|
|
|
|
|
public override void updateAbilityState ()
|
|
{
|
|
if (teleportingEnabled && !mainGravitySystem.isSearchingSurface () && (!mainPlayerController.isPlayerOnZeroGravityMode () || canTeleportOnZeroGravity)) {
|
|
if (searchingForTeleport) {
|
|
bool activateTeleportResult = false;
|
|
|
|
if (!teleportCanBeExecuted) {
|
|
if (Time.time > lastTimeTeleportButtonPressed + holdButtonTimeToActivateTeleport || teleportInProcess) {
|
|
activateTeleportResult = true;
|
|
}
|
|
|
|
if (!teleportInProcess && currentTeleportHookTarget != null) {
|
|
activateTeleportResult = true;
|
|
|
|
teleportActivateByHookTarget = true;
|
|
}
|
|
}
|
|
|
|
if (activateTeleportResult) {
|
|
teleportCanBeExecuted = true;
|
|
|
|
if (useTeleportMark) {
|
|
teleportMark.SetActive (true);
|
|
}
|
|
|
|
bool canActivateTeleportOnAir = teleportInProcess || !mainPlayerController.isPlayerOnGround ();
|
|
|
|
if (canActivateTeleportOnAir) {
|
|
stopTeleporting ();
|
|
}
|
|
|
|
if (useBulletTimeOnTeleport) {
|
|
mainTimeBullet.setBulletTimeState (true, bulletTimeScaleOnTeleport);
|
|
}
|
|
|
|
if (canActivateTeleportOnAir) {
|
|
setPlayerControlState (false);
|
|
}
|
|
}
|
|
|
|
if (teleportCanBeExecuted && useTeleportMark) {
|
|
Vector3 raycastDirection = Vector3.zero;
|
|
Vector3 raycastPosition = Vector3.zero;
|
|
|
|
bool isCameraTypeFree = mainPlayerCamera.isCameraTypeFree ();
|
|
|
|
if (currentTeleportHookTarget != null) {
|
|
raycastPosition = playerControllerTransform.position + playerControllerTransform.up;
|
|
|
|
raycastDirection = currentTeleportHookTarget.position - raycastPosition;
|
|
|
|
raycastDirection.Normalize ();
|
|
} else {
|
|
if (isCameraTypeFree) {
|
|
raycastDirection = mainCameraTransform.TransformDirection (Vector3.forward);
|
|
|
|
raycastPosition = mainCameraTransform.position;
|
|
} else {
|
|
raycastDirection = playerControllerTransform.forward;
|
|
|
|
raycastPosition = playerControllerTransform.position + playerControllerTransform.up;
|
|
}
|
|
}
|
|
|
|
if (Physics.Raycast (raycastPosition, raycastDirection, out hit, maxDistanceToTeleport, teleportLayerMask)) {
|
|
currentTeleportPosition = hit.point + hit.normal * 0.4f;
|
|
teleportMark.transform.position = hit.point + hit.normal * 0.1f;
|
|
|
|
currentTeleportPositionNormal = hit.normal;
|
|
|
|
teleportSurfaceFound = true;
|
|
} else {
|
|
teleportSurfaceFound = false;
|
|
|
|
if (isCameraTypeFree) {
|
|
currentTeleportPosition = mainCameraTransform.position + mainCameraTransform.forward * maxDistanceToTeleportAir;
|
|
} else {
|
|
currentTeleportPosition = playerControllerTransform.position + playerControllerTransform.forward * maxDistanceToTeleportAir;
|
|
}
|
|
|
|
teleportMark.transform.position = currentTeleportPosition;
|
|
|
|
currentTeleportPositionNormal = Vector3.up;
|
|
}
|
|
|
|
if (useTeleportIfSurfaceNotFound || (!useTeleportIfSurfaceNotFound && teleportSurfaceFound)) {
|
|
Quaternion teleportMarkTargetRotation = Quaternion.LookRotation (currentTeleportPositionNormal);
|
|
|
|
teleportMark.transform.rotation = teleportMarkTargetRotation;
|
|
|
|
if (!teleportMark.activeSelf) {
|
|
teleportMark.SetActive (true);
|
|
}
|
|
} else {
|
|
if (teleportMark.activeSelf) {
|
|
teleportMark.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mainPlayerAbilitiesSystem.isPlayerCurrentlyBusy () ||
|
|
(stopTeleportIfMoving && mainPlayerController.isPlayerUsingInput () && !teleportActivateByHookTarget)) {
|
|
|
|
stopTeleportInProcess ();
|
|
}
|
|
}
|
|
|
|
if (teleportInProcess && stopTeleportIfMoving && mainPlayerController.isPlayerUsingInput () && !teleportActivateByHookTarget) {
|
|
stopTeleporting ();
|
|
|
|
setTeleportEndState ();
|
|
|
|
if (addForceIfTeleportStops) {
|
|
Vector3 targetPositionDirection = currentTeleportPosition - playerControllerTransform.position;
|
|
|
|
targetPositionDirection = targetPositionDirection / targetPositionDirection.magnitude;
|
|
|
|
mainPlayerController.addExternalForce (targetPositionDirection * forceIfTeleportStops);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopTeleportInProcess ()
|
|
{
|
|
if (teleportInProcess || searchingForTeleport) {
|
|
teleportCanBeExecuted = false;
|
|
|
|
if (useBulletTimeOnTeleport) {
|
|
mainTimeBullet.disableTimeBulletTotally ();
|
|
}
|
|
|
|
teleportActivateByHookTarget = false;
|
|
|
|
searchingForTeleport = false;
|
|
|
|
if (useTeleportMark) {
|
|
teleportMark.SetActive (false);
|
|
}
|
|
|
|
stopTeleporting ();
|
|
}
|
|
}
|
|
|
|
public void teleportPlayer (Transform objectToMove, Vector3 teleportPosition, bool checkPositionAngle, bool changeFov,
|
|
float newFovValue, float fovChangeSpeed, float teleportSpeed, bool rotatePlayerTowardPosition,
|
|
bool teleportInstantlyToPositionValue, bool useActionSystemOnTeleportValue,
|
|
bool useSmoothCameraFollowStateOnTeleportValue, float smoothCameraFollowDurationValue,
|
|
float teleportDistanceOffsetValue, LayerMask layermaskToDetect, bool checkPlayerHeightToTeleportPosition)
|
|
{
|
|
stopTeleporting ();
|
|
|
|
teleportCoroutine = StartCoroutine (teleportPlayerCoroutine (objectToMove, teleportPosition, checkPositionAngle,
|
|
changeFov, newFovValue, fovChangeSpeed, teleportSpeed, rotatePlayerTowardPosition, teleportInstantlyToPositionValue,
|
|
useActionSystemOnTeleportValue, useSmoothCameraFollowStateOnTeleportValue, smoothCameraFollowDurationValue,
|
|
teleportDistanceOffsetValue, layermaskToDetect, checkPlayerHeightToTeleportPosition));
|
|
}
|
|
|
|
public void stopTeleporting ()
|
|
{
|
|
if (teleportCoroutine != null) {
|
|
StopCoroutine (teleportCoroutine);
|
|
}
|
|
|
|
setPlayerControlState (true);
|
|
}
|
|
|
|
public void resumeIfTeleportActive ()
|
|
{
|
|
if (teleportInProcess) {
|
|
stopTeleporting ();
|
|
|
|
setTeleportEndState ();
|
|
}
|
|
}
|
|
|
|
bool currentUseActionSystemOnTeleportValue;
|
|
|
|
public void setTeleportEndState ()
|
|
{
|
|
if (teleportInProcess) {
|
|
teleportInProcess = false;
|
|
|
|
if (currentUseActionSystemOnTeleportValue && actionNameUsedOnTeleport != "") {
|
|
mainPlayerController.stopCustomAction (actionNameUsedOnTeleport);
|
|
}
|
|
|
|
if (changeCameraFovOnTeleport) {
|
|
mainPlayerCamera.setOriginalCameraFov ();
|
|
}
|
|
|
|
checkEventOnTeleport (false);
|
|
}
|
|
}
|
|
|
|
public void setPlayerControlState (bool state)
|
|
{
|
|
if (state) {
|
|
mainPlayerController.setFallDamageCheckPausedState (true);
|
|
}
|
|
|
|
mainPlayerController.changeScriptState (state);
|
|
|
|
mainPlayerController.setGravityForcePuase (!state);
|
|
|
|
mainPlayerController.setRigidbodyVelocityToZero ();
|
|
|
|
mainPlayerController.setPhysicMaterialAssigmentPausedState (!state);
|
|
|
|
mainPlayerController.setUsingAbilityActiveState (!state);
|
|
|
|
mainPlayerController.setCheckOnGroungPausedState (!state);
|
|
|
|
if (!state) {
|
|
mainPlayerController.setZeroFrictionMaterial ();
|
|
|
|
mainPlayerController.setPlayerOnGroundState (false);
|
|
|
|
mainPlayerController.setLastTimeFalling ();
|
|
|
|
mainPlayerController.setFallDamageCheckPausedState (false);
|
|
}
|
|
}
|
|
|
|
IEnumerator teleportPlayerCoroutine (Transform objectToMove, Vector3 targetPosition, bool checkPositionAngle,
|
|
bool changeFov, float newFovValue, float fovChangeSpeed, float currentTeleportSpeed,
|
|
bool rotatePlayerTowardPosition, bool teleportInstantlyToPositionValue, bool useActionSystemOnTeleportValue,
|
|
bool useSmoothCameraFollowStateOnTeleportValue, float smoothCameraFollowDurationValue,
|
|
float teleportDistanceOffsetValue, LayerMask layermaskToDetect, bool checkPlayerHeightToTeleportPosition)
|
|
{
|
|
teleportInProcess = true;
|
|
|
|
checkEventOnTeleport (true);
|
|
|
|
currentUseActionSystemOnTeleportValue = useActionSystemOnTeleportValue;
|
|
|
|
if (currentUseActionSystemOnTeleportValue && actionNameUsedOnTeleport != "") {
|
|
mainPlayerController.activateCustomAction (actionNameUsedOnTeleport);
|
|
}
|
|
|
|
if (useSmoothCameraFollowStateOnTeleportValue) {
|
|
mainPlayerCamera.activateUseSmoothCameraFollowStateDuration (smoothCameraFollowDurationValue);
|
|
}
|
|
|
|
setPlayerControlState (false);
|
|
|
|
if (changeCameraFovOnTeleport && changeFov) {
|
|
mainPlayerCamera.setMainCameraFov (newFovValue, fovChangeSpeed);
|
|
}
|
|
|
|
if (checkPlayerHeightToTeleportPosition) {
|
|
Vector3 currentNormal = mainGravitySystem.getCurrentNormal ();
|
|
|
|
Vector3 raycastDirection = targetPosition - currentNormal * 0.5f;
|
|
Vector3 raycastPosition = targetPosition;
|
|
|
|
float raycastDistance = mainPlayerController.getCharacterHeight () + 0.2f;
|
|
|
|
//Debug.DrawRay (raycastPosition, raycastDirection * 2, Color.green, 10);
|
|
|
|
if (Physics.Raycast (raycastPosition, raycastDirection, out hit, raycastDistance, layermaskToDetect)) {
|
|
targetPosition -= currentNormal * raycastDistance;
|
|
|
|
// print ("adjusting teleport position to player height");
|
|
} else {
|
|
raycastDirection = targetPosition + currentNormal * 0.5f;
|
|
|
|
if (Physics.Raycast (raycastPosition, raycastDirection, out hit, raycastDistance, layermaskToDetect)) {
|
|
targetPosition -= currentNormal * raycastDistance;
|
|
|
|
// print ("adjusting teleport position to player height");
|
|
}
|
|
}
|
|
}
|
|
|
|
float dist = GKC_Utils.distance (objectToMove.position, targetPosition);
|
|
float duration = dist / currentTeleportSpeed;
|
|
float t = 0;
|
|
|
|
Vector3 targetPositionDirection = targetPosition - objectToMove.position;
|
|
targetPositionDirection = targetPositionDirection / targetPositionDirection.magnitude;
|
|
|
|
if (checkPositionAngle) {
|
|
float targetNormalAngle = Vector3.Angle (objectToMove.up, currentTeleportPositionNormal);
|
|
|
|
if (targetNormalAngle > 150) {
|
|
targetPosition += currentTeleportPositionNormal * 2;
|
|
}
|
|
}
|
|
|
|
float targetEulerRotation = 0;
|
|
|
|
bool targetReached = false;
|
|
|
|
float movementTimer = 0;
|
|
|
|
float positionDifference = 0;
|
|
|
|
float positionDifferenceAmount = 0.01f;
|
|
|
|
if (teleportDistanceOffsetValue > 0) {
|
|
positionDifferenceAmount = teleportDistanceOffsetValue;
|
|
}
|
|
|
|
float lastTimeDistanceChecked = 0;
|
|
|
|
bool isPlayerMovingOn3dWorld = mainPlayerController.isPlayerMovingOn3dWorld ();
|
|
|
|
if (teleportInstantlyToPositionValue) {
|
|
if (positionDifferenceAmount > 0) {
|
|
targetPosition -= targetPositionDirection * positionDifferenceAmount;
|
|
}
|
|
|
|
objectToMove.position = targetPosition;
|
|
|
|
if (rotatePlayerTowardPosition && isPlayerMovingOn3dWorld) {
|
|
|
|
Vector3 teleportDirection = targetPositionDirection;
|
|
|
|
teleportDirection = teleportDirection - objectToMove.up * objectToMove.InverseTransformDirection (teleportDirection).y;
|
|
|
|
targetEulerRotation = Vector3.SignedAngle (objectToMove.forward, teleportDirection, objectToMove.up);
|
|
|
|
objectToMove.Rotate (0, targetEulerRotation, 0);
|
|
}
|
|
|
|
yield return null;
|
|
} else {
|
|
|
|
while (!targetReached) {
|
|
t += Time.deltaTime / duration;
|
|
|
|
objectToMove.position = Vector3.Lerp (objectToMove.position, targetPosition, t);
|
|
|
|
if (rotatePlayerTowardPosition && isPlayerMovingOn3dWorld) {
|
|
|
|
Vector3 teleportDirection = targetPosition - objectToMove.position;
|
|
teleportDirection = teleportDirection / teleportDirection.magnitude;
|
|
|
|
teleportDirection = teleportDirection - objectToMove.up * objectToMove.InverseTransformDirection (teleportDirection).y;
|
|
|
|
targetEulerRotation = Vector3.SignedAngle (objectToMove.forward, teleportDirection, objectToMove.up);
|
|
|
|
if (Mathf.Abs (targetEulerRotation) > minAngleToRotateTowardTeleportDirection) {
|
|
objectToMove.Rotate (0, (targetEulerRotation / 2) * teleportRotationSpeed * Time.deltaTime, 0);
|
|
}
|
|
}
|
|
|
|
positionDifference = GKC_Utils.distance (objectToMove.position, targetPosition);
|
|
|
|
if (lastTimeDistanceChecked == 0) {
|
|
if (positionDifference < 1) {
|
|
lastTimeDistanceChecked = Time.time;
|
|
}
|
|
} else {
|
|
if (Time.time > lastTimeDistanceChecked + 0.5f) {
|
|
// print ("too much time without moving");
|
|
|
|
targetReached = true;
|
|
}
|
|
}
|
|
|
|
movementTimer += Time.deltaTime;
|
|
|
|
if (positionDifference < positionDifferenceAmount || movementTimer > (duration + 0.5f)) {
|
|
targetReached = true;
|
|
}
|
|
|
|
if (useCapsuleCastToCheckTargetReached) {
|
|
if (movementTimer > 0.7f) {
|
|
Vector3 currentObjectPosition = objectToMove.position;
|
|
|
|
Vector3 point1 = currentObjectPosition;
|
|
Vector3 point2 = currentObjectPosition + objectToMove.up * 2;
|
|
|
|
if (Physics.CapsuleCast (point1, point2, capsuleCastRadius, targetPositionDirection, out hit, maxCapsuleCastDistance, teleportLayerMask)) {
|
|
// print ("surface detected");
|
|
|
|
targetReached = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
setPlayerControlState (true);
|
|
|
|
setTeleportEndState ();
|
|
}
|
|
|
|
public void holdTeleport ()
|
|
{
|
|
if (!mainPlayerAbilitiesSystem.isPlayerCurrentlyBusy () &&
|
|
teleportingEnabled &&
|
|
(!mainPlayerController.isPlayerUsingInput () || currentTeleportHookTarget != null) &&
|
|
!mainGravitySystem.isSearchingSurface () &&
|
|
(!mainPlayerController.isPlayerOnZeroGravityMode () || canTeleportOnZeroGravity)) {
|
|
|
|
searchingForTeleport = true;
|
|
|
|
lastTimeTeleportButtonPressed = Time.time;
|
|
}
|
|
}
|
|
|
|
LayerMask currentLayermask;
|
|
|
|
public void releaseTeleport ()
|
|
{
|
|
if (!mainPlayerAbilitiesSystem.isPlayerCurrentlyBusy () && teleportingEnabled) {
|
|
currentLayermask = teleportLayerMask;
|
|
|
|
bool checkPositionAngleValue = true;
|
|
|
|
if (allowQuickTeleportIfLockonTargetActive) {
|
|
if (mainPlayerCamera.isPlayerLookingAtTarget ()) {
|
|
Transform currentTargetToLook = mainPlayerCamera.getLastCharacterToLook ();
|
|
|
|
Vector3 raycastDirection = Vector3.zero;
|
|
Vector3 raycastPosition = Vector3.zero;
|
|
|
|
Vector3 targetPositionDirection = currentTargetToLook.position - mainCameraTransform.position;
|
|
|
|
targetPositionDirection = targetPositionDirection / targetPositionDirection.magnitude;
|
|
|
|
raycastDirection = targetPositionDirection;
|
|
|
|
raycastPosition = mainCameraTransform.position;
|
|
|
|
if (Physics.Raycast (raycastPosition, raycastDirection, out hit, maxDistanceToTeleport, checkLockonTargetsLayermask)) {
|
|
bool checkResult = false;
|
|
|
|
if (hit.collider.transform == currentTargetToLook) {
|
|
checkResult = true;
|
|
}
|
|
|
|
if (!checkResult) {
|
|
Transform [] children = hit.collider.transform.GetComponentsInChildren<Transform> ();
|
|
|
|
if (children.Contains (currentTargetToLook)) {
|
|
checkResult = true;
|
|
}
|
|
}
|
|
|
|
if (checkResult) {
|
|
Vector3 currentPosition = playerControllerTransform.position;
|
|
|
|
Vector3 targetToUsePosition = hit.collider.transform.position;
|
|
|
|
float distanceToTarget = GKC_Utils.distance (targetToUsePosition, currentPosition);
|
|
|
|
Vector3 direction = targetToUsePosition - currentPosition;
|
|
|
|
direction = direction / direction.magnitude;
|
|
|
|
Vector3 targetPosition = currentPosition + direction * (distanceToTarget - 1);
|
|
|
|
currentTeleportPosition = targetPosition;
|
|
|
|
|
|
currentTeleportPositionNormal = hit.collider.transform.up;
|
|
|
|
teleportCanBeExecuted = true;
|
|
|
|
currentLayermask = checkLockonTargetsLayermask;
|
|
|
|
checkPositionAngleValue = false;
|
|
|
|
//Debug.DrawLine (currentPosition, currentTeleportPosition, Color.green, 10);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (teleportCanBeExecuted) {
|
|
if (useTeleportIfSurfaceNotFound || (!useTeleportIfSurfaceNotFound && teleportSurfaceFound)) {
|
|
teleportPlayer (playerControllerTransform, currentTeleportPosition, checkPositionAngleValue, true, cameraFovOnTeleport,
|
|
cameraFovOnTeleportSpeed, teleportSpeed, rotateTowardTeleportPosition, teleportInstantlyToPosition,
|
|
useActionSystemOnTeleport, useSmoothCameraFollowStateOnTeleport, smoothCameraFollowDuration, 0,
|
|
currentLayermask, false);
|
|
|
|
mainPlayerController.setCheckOnGroungPausedState (true);
|
|
|
|
mainPlayerController.setPlayerOnGroundState (false);
|
|
|
|
} else {
|
|
stopTeleporting ();
|
|
}
|
|
|
|
if (useBulletTimeOnTeleport) {
|
|
mainTimeBullet.setBulletTimeState (false, 1);
|
|
}
|
|
}
|
|
|
|
teleportCanBeExecuted = false;
|
|
|
|
searchingForTeleport = false;
|
|
|
|
if (useTeleportMark) {
|
|
teleportMark.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setTeleportingEnabledState (bool state)
|
|
{
|
|
teleportingEnabled = state;
|
|
}
|
|
|
|
public bool isTeleportInProcess ()
|
|
{
|
|
return teleportInProcess;
|
|
}
|
|
|
|
public bool isSearchingForTeleport ()
|
|
{
|
|
return searchingForTeleport;
|
|
}
|
|
|
|
public bool getTeleportCanBeExecutedState ()
|
|
{
|
|
return teleportCanBeExecuted;
|
|
}
|
|
|
|
public override void enableAbility ()
|
|
{
|
|
|
|
}
|
|
|
|
public override void disableAbility ()
|
|
{
|
|
stopTeleportInProcess ();
|
|
|
|
teleportingEnabled = false;
|
|
}
|
|
|
|
public override void deactivateAbility ()
|
|
{
|
|
stopTeleportInProcess ();
|
|
}
|
|
|
|
public override void activateSecondaryActionOnAbility ()
|
|
{
|
|
|
|
}
|
|
|
|
public override void useAbilityPressDown ()
|
|
{
|
|
holdTeleport ();
|
|
|
|
checkUseEventOnUseAbility ();
|
|
}
|
|
|
|
public override void useAbilityPressHold ()
|
|
{
|
|
|
|
}
|
|
|
|
public override void useAbilityPressUp ()
|
|
{
|
|
releaseTeleport ();
|
|
|
|
disableAbilityCurrentActiveFromPressState ();
|
|
}
|
|
|
|
void checkEventOnTeleport (bool state)
|
|
{
|
|
if (state) {
|
|
if (useEventsOnStartTeleport) {
|
|
eventsOnStartTeleport.Invoke ();
|
|
}
|
|
} else {
|
|
if (useEventsOnEndTeleport) {
|
|
eventsOnEndTeleport.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setTeleportHookTarget (Transform newTarget)
|
|
{
|
|
if (!useFixedTeleportHookPointsEnabled) {
|
|
return;
|
|
}
|
|
|
|
currentTeleportHookTarget = newTarget;
|
|
}
|
|
|
|
}
|