710 lines
23 KiB
C#
710 lines
23 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Audio;
|
|
using UnityEngine.Localization;
|
|
using UnityEngine.Localization.Settings;
|
|
|
|
namespace InfallibleCode
|
|
{
|
|
public class DoorBehaviour : MonoBehaviour, /*IDraggable*/IInteractable
|
|
{
|
|
public Transform door;
|
|
//public Rigidbody doorRb;
|
|
public bool DoorRequiresKey;
|
|
public bool DoorIsOpen;
|
|
public float RotationSpeed = 2;
|
|
|
|
[Range(0, -90)]
|
|
public float DoorStartAngle = -90f;
|
|
|
|
[Header("!DEBUGGING!")]
|
|
[HideInInspector] public bool CanOpenDoor = true;
|
|
//[SerializeField] public Transform _player;
|
|
public int doorSide;
|
|
private float doorLerp;
|
|
[HideInInspector] public float _doorLerpOpenAngle = 0f;
|
|
[HideInInspector] public float _doorLerpSpeed = 0.5f;
|
|
//[HideInInspector] public float _doorLerpCloseAngle;
|
|
private Quaternion _OpenPos;
|
|
private Quaternion _ClosedPos;
|
|
private Quaternion _OpenPos90Degrees;
|
|
|
|
public bool doorIsOpeningOrClosing;
|
|
public AudioClip doorOpenSoundEffect;
|
|
public AudioClip doorCloseSoundEffect;
|
|
public AudioSource doorAudioSource;
|
|
public AudioMixer audioMixer;
|
|
private bool doorCloseAudioPlayed;
|
|
|
|
[HideInInspector] public bool enemyIsTryingToOpenDoor;
|
|
|
|
public EventDelegateTrigger eventDelegateTriggerOnDoorClosed;
|
|
|
|
public delegate void OnActionHappened();
|
|
public event OnActionHappened onDoorClosed;
|
|
|
|
public LocalizedString localizedLockedMessage;
|
|
|
|
DoorAnimationableExtension doorAnimationableExtension;
|
|
|
|
|
|
void Awake()
|
|
{
|
|
if (door == null)
|
|
{
|
|
door = GetComponent<Transform>();
|
|
}
|
|
|
|
if (gameObject.GetComponent<AudioSource>() == null)
|
|
{
|
|
doorAudioSource = gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
|
|
// Assign the Audio Mixer to the AudioSource
|
|
doorAudioSource.outputAudioMixerGroup = audioMixer.FindMatchingGroups("SFX")[0];
|
|
}
|
|
|
|
doorOpenSoundEffect = Resources.Load<AudioClip>("DoorSounds/DoorOpenSoundEffect");
|
|
doorCloseSoundEffect = Resources.Load("DoorSounds/DoorCloseSoundEffect") as AudioClip;
|
|
|
|
if (TryGetComponent<DoorAnimationableExtension>(out DoorAnimationableExtension doorAnimationableExtension))
|
|
{
|
|
this.doorAnimationableExtension = doorAnimationableExtension;
|
|
}
|
|
}
|
|
|
|
void Start()
|
|
{
|
|
if (DoorRequiresKey)
|
|
{
|
|
CanOpenDoor = false;
|
|
}
|
|
|
|
if (doorAnimationableExtension == null)
|
|
{
|
|
door.transform.localRotation = Quaternion.Euler(door.localEulerAngles.x, DoorStartAngle, door.localEulerAngles.z);
|
|
|
|
_OpenPos = Quaternion.Euler(door.localEulerAngles.x, -90f, door.localEulerAngles.z);
|
|
_OpenPos90Degrees = Quaternion.Euler(door.localEulerAngles.x, 90f, door.localEulerAngles.z);
|
|
_ClosedPos = Quaternion.Euler(door.localEulerAngles.x, 0f, door.localEulerAngles.z);
|
|
if (DoorStartAngle >= 0f)
|
|
{
|
|
DoorIsOpen = false;
|
|
}
|
|
if (DoorStartAngle <= -90f)
|
|
{
|
|
DoorIsOpen = true;
|
|
}
|
|
}
|
|
|
|
doorAudioSource = GetComponent<AudioSource>();
|
|
doorAudioSource.loop = false;
|
|
doorAudioSource.spatialBlend = 1f;
|
|
doorAudioSource.maxDistance = 100f;
|
|
}
|
|
|
|
public void StopDoorCoroutines()
|
|
{
|
|
StopAllCoroutines();
|
|
}
|
|
|
|
public void DragDoor()
|
|
{
|
|
#region Door Drag
|
|
if (CanOpenDoor && !doorIsOpeningOrClosing)
|
|
{
|
|
if (DoorIsOpen)
|
|
{
|
|
if (doorAnimationableExtension == null)
|
|
{
|
|
CloseDoor(0.5f);
|
|
}
|
|
else
|
|
{
|
|
doorAnimationableExtension.DoorClose();
|
|
DoorIsOpen = false;
|
|
}
|
|
|
|
|
|
StartCoroutine(DoorOpenFalse());
|
|
doorIsOpeningOrClosing = true;
|
|
}
|
|
else
|
|
{
|
|
if (doorAnimationableExtension == null)
|
|
{
|
|
OpenDoor(0.5f);
|
|
}
|
|
else
|
|
{
|
|
doorAnimationableExtension.DoorOpen();
|
|
DoorIsOpen = true;
|
|
}
|
|
|
|
StartCoroutine(DoorOpenTrue());
|
|
doorIsOpeningOrClosing = true;
|
|
}
|
|
|
|
|
|
}
|
|
else if (DoorRequiresKey)
|
|
{
|
|
RandomSoundsManager.GetInstance().PlayLockDoorSound(doorAudioSource);
|
|
string localizedText = LocalizationSettings.StringDatabase.GetLocalizedString("Messages", "lockedMessage");
|
|
UIManager.GetInstance().StartCoroutine(UIManager.GetInstance().DisplayMessage(localizedLockedMessage));
|
|
Debug.Log("Door is locked");
|
|
}
|
|
else
|
|
{
|
|
//UIManager.GetInstance().StartCoroutine(UIManager.GetInstance().DisplayMessage("Jammed"));
|
|
Debug.Log("Door is jammed");
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
IEnumerator DoorOpenFalse()
|
|
{
|
|
while (doorLerp >= 1f)
|
|
{
|
|
DoorIsOpen = false;
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
IEnumerator DoorOpenTrue()
|
|
{
|
|
while (doorLerp >= 1f)
|
|
{
|
|
DoorIsOpen = true;
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
IEnumerator DoorAnglesUpdate()
|
|
{
|
|
while (doorLerp <= 1f)
|
|
{
|
|
float DoorAngle = door.transform.localEulerAngles.y;
|
|
DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
|
|
if (DoorAngle <= -90f)
|
|
{
|
|
print("Door Rotation.Y is -90f (Door Angle -90f)");
|
|
DoorIsOpen = true;
|
|
doorLerp = 0f;
|
|
}
|
|
if (DoorAngle < -0.01f)
|
|
{
|
|
//CloseDoor(1f);
|
|
print("Door Rotation.Y is -90f (Door Angle -0.01f)");
|
|
DoorIsOpen = true;
|
|
doorLerp = 0f;
|
|
}
|
|
if (DoorAngle >= 0f)
|
|
{
|
|
print("Door Rotation.Y is 0f (Door Angle 0f)");
|
|
DoorIsOpen = false;
|
|
doorLerp = 0f;
|
|
}
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
|
|
public void Interact()
|
|
{
|
|
if (!enemyIsTryingToOpenDoor)
|
|
{
|
|
DragDoor();
|
|
}
|
|
}
|
|
|
|
|
|
public void LockDoor()
|
|
{
|
|
DoorRequiresKey = true;
|
|
CanOpenDoor = false;
|
|
}
|
|
|
|
public void UnlockDoor()
|
|
{
|
|
DoorRequiresKey = false;
|
|
CanOpenDoor = true;
|
|
}
|
|
|
|
#region Open Door
|
|
public void OpenDoor(float doorLerpSpeed)
|
|
{
|
|
doorLerp = 0f;
|
|
DoorIsOpen = true;
|
|
//doorAudioSource.PlayOneShot(doorOpenSoundEffect);
|
|
//doorAudioSource.PlayOneShot()
|
|
RandomSoundsManager.GetInstance().PlayRandromOpenSound(doorAudioSource);
|
|
StartCoroutine(OpenDoorCoroutine(doorLerpSpeed));
|
|
doorCloseAudioPlayed = false;
|
|
}
|
|
|
|
public void OpenDoor90Degrees(float doorLerpSpeed)
|
|
{
|
|
doorLerp = 0f;
|
|
DoorIsOpen = true;
|
|
//doorAudioSource.PlayOneShot(doorOpenSoundEffect);
|
|
RandomSoundsManager.GetInstance().PlayRandromOpenSound(doorAudioSource);
|
|
StartCoroutine(OpenDoor90DegreesCoroutine(doorLerpSpeed));
|
|
doorCloseAudioPlayed = false;
|
|
}
|
|
|
|
IEnumerator OpenDoorCoroutine(float doorLerpSpeed)
|
|
{
|
|
float transitionTime = 1;
|
|
while (doorLerp <= transitionTime) /*(door.localEulerAngles.y <= -90f)*/
|
|
{
|
|
if (Time.timeScale > 0f) // Check if time is not paused
|
|
{
|
|
doorLerp += doorLerpSpeed * Time.deltaTime;
|
|
float normalizedTime = Mathf.Clamp01(doorLerp / transitionTime);
|
|
door.localRotation = Quaternion.Slerp(door.localRotation, _OpenPos, normalizedTime);
|
|
print("Door opens");
|
|
|
|
float DoorAngle = door.transform.localEulerAngles.y;
|
|
DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
|
|
if (DoorAngle <= -90f)
|
|
{
|
|
if (doorIsOpeningOrClosing)
|
|
{
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
StopAllCoroutines();
|
|
}
|
|
}
|
|
yield return null;
|
|
}
|
|
if (doorIsOpeningOrClosing)
|
|
{
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
}
|
|
|
|
IEnumerator OpenDoor90DegreesCoroutine(float doorLerpSpeed)
|
|
{
|
|
float transitionTime = 1;
|
|
while (doorLerp <= transitionTime) /*(door.localEulerAngles.y <= -90f)*/
|
|
{
|
|
if (Time.timeScale > 0f) // Check if time is not paused
|
|
{
|
|
doorLerp += doorLerpSpeed * Time.deltaTime;
|
|
float normalizedTime = Mathf.Clamp01(doorLerp / transitionTime);
|
|
door.localRotation = Quaternion.Slerp(door.localRotation, _OpenPos90Degrees, normalizedTime);
|
|
print("Door opens");
|
|
|
|
float DoorAngle = door.transform.localEulerAngles.y;
|
|
DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
|
|
if (DoorAngle >= 90f)
|
|
{
|
|
if (doorIsOpeningOrClosing)
|
|
{
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
StopAllCoroutines();
|
|
}
|
|
}
|
|
yield return null;
|
|
}
|
|
if (doorIsOpeningOrClosing)
|
|
{
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Close Door
|
|
public void CloseDoor(float doorLerpSpeed)
|
|
{
|
|
doorLerp = 0f;
|
|
DoorIsOpen = false;
|
|
StartCoroutine(CloseDoorCoroutine(doorLerpSpeed));
|
|
}
|
|
|
|
|
|
IEnumerator CloseDoorCoroutine(float doorLerpSpeed)
|
|
{
|
|
float transitionTime = 1;
|
|
while (doorLerp <= transitionTime)/*(door.localEulerAngles.y >= 0f)*/
|
|
{
|
|
if (Time.timeScale > 0f) // Check if time is not paused
|
|
{
|
|
doorLerp += doorLerpSpeed * Time.deltaTime;
|
|
float normalizedTime = Mathf.Clamp01(doorLerp / transitionTime);
|
|
door.localRotation = Quaternion.Slerp(door.localRotation, _ClosedPos, normalizedTime);
|
|
print("Door closes");
|
|
|
|
float DoorAngle = door.transform.localEulerAngles.y;
|
|
DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
|
|
if (DoorAngle >= -0.001f)
|
|
{
|
|
if (doorIsOpeningOrClosing)
|
|
{
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
|
|
print("stop");
|
|
if (eventDelegateTriggerOnDoorClosed != null)
|
|
{
|
|
eventDelegateTriggerOnDoorClosed?.OnEventInvoke();
|
|
}
|
|
onDoorClosed?.Invoke();
|
|
StopAllCoroutines();
|
|
yield break; // exit the coroutine here
|
|
}
|
|
if (DoorAngle >= -10f && !doorCloseAudioPlayed)
|
|
{
|
|
//doorAudioSource.PlayOneShot(doorCloseSoundEffect);
|
|
RandomSoundsManager.GetInstance().PlayRandomCloseSound(doorAudioSource);
|
|
doorCloseAudioPlayed = true;
|
|
}
|
|
}
|
|
yield return null;
|
|
}
|
|
if (doorIsOpeningOrClosing)
|
|
{
|
|
ForceDoorToClosePosition();
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
if (eventDelegateTriggerOnDoorClosed != null)
|
|
{
|
|
eventDelegateTriggerOnDoorClosed?.OnEventInvoke();
|
|
}
|
|
onDoorClosed?.Invoke();
|
|
}
|
|
#endregion
|
|
|
|
public void ForceDoorToClosePosition()
|
|
{
|
|
DoorIsOpen = false;
|
|
door.localRotation = _ClosedPos;
|
|
doorLerp = 0f;
|
|
}
|
|
|
|
public void DoorIsNoLongerOpeningOrClosing()
|
|
{
|
|
doorIsOpeningOrClosing = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region OLD DraggableCode
|
|
// #region Layers of fear
|
|
// //[Header("Door are close?")]
|
|
// //public bool C_AreClosed;
|
|
|
|
// //[Header("Curent hinde joint angle")]
|
|
// //public float C_CurrentAngle;
|
|
|
|
// //[Header("Event sent every time door is closed fast")]
|
|
// //public string E_FastCloseEvent = string.Empty;
|
|
|
|
// //[Header("Fast closing, force threshold ")]
|
|
// //public float E_FastCloseThreshold = 0.65f;
|
|
|
|
// //[Header("Handle used to position hud")]
|
|
// //public GameObject E_HudForwardDirHandle;
|
|
|
|
// //[Header("Handle used to position hud")]
|
|
|
|
// //public GameObject E_HudInverseForwardDirHandle;
|
|
|
|
// //public float E_StopTutorialHudAngle = 45f;
|
|
|
|
// //public Sprite E_LockedDoorIcon;
|
|
|
|
// //public Sprite E_LoadingDoorIcon;
|
|
|
|
// //private bool _AreClosed;
|
|
|
|
// //private bool m_IsInteractedWith;
|
|
|
|
// //private bool m_IsPickupSelected;
|
|
|
|
// //private bool m_FreezeDoor = true;
|
|
|
|
// //private float m_StartMaxLimit = 45f;
|
|
|
|
// //private float m_StartMinLimit = -45f;
|
|
|
|
// //private bool m_CanFreeze = true;
|
|
|
|
// //private HingeJoint m_HingeJoint;
|
|
|
|
// //private GameObject m_CloseDoorSound;
|
|
|
|
// //private GameObject m_OpenSound;
|
|
|
|
// //private GameObject m_ClosingSound;
|
|
|
|
// //private GameObject m_FastClosingSound;
|
|
|
|
// //private bool m_StopCloseAndLockerSounds;
|
|
|
|
// //private bool m_AreCloseLate = true;
|
|
|
|
// //private bool m_IsOpenDoorCoroutineRunning;
|
|
// #endregion
|
|
|
|
// void Awake()
|
|
// {
|
|
// #region Layers Of Fear
|
|
// //m_HingeJoint = GetComponent<HingeJoint>();
|
|
// //if (m_HingeJoint)
|
|
// //{
|
|
// // JointLimits limits = m_HingeJoint.limits;
|
|
// // m_StartMaxLimit = limits.max;
|
|
// // m_StartMinLimit = limits.min;
|
|
// //}
|
|
// #endregion
|
|
|
|
// if(door == null)
|
|
// {
|
|
// door = GetComponent<Transform>();
|
|
// }
|
|
// }
|
|
|
|
// void Start()
|
|
// {
|
|
// if (DoorRequiresKey)
|
|
// {
|
|
// CanOpenDoor = false;
|
|
// }
|
|
|
|
// door.transform.localRotation = Quaternion.Euler(door.localEulerAngles.x, DoorStartAngle, door.localEulerAngles.z);
|
|
|
|
// _OpenPos = Quaternion.Euler(door.localEulerAngles.x, _doorLerpOpenAngle, door.localEulerAngles.z);
|
|
// _ClosedPos = Quaternion.Euler(door.localEulerAngles.x, 0f, door.localEulerAngles.z);
|
|
// }
|
|
|
|
// private float GetAngleBetweenPlayerAndDoor()
|
|
// {
|
|
// if (door != null)
|
|
// {
|
|
// return Vector3.Angle(door.forward,PlayerManager.GetInstance().playerGameObj.transform.forward);
|
|
// }
|
|
// return 0f;
|
|
// }
|
|
|
|
// private void MouseVectorUpdate()
|
|
// {
|
|
// if (DraggablesManager.GetInstance().IsDragging)
|
|
// {
|
|
// float angleBetweenPlayerAndDoor = GetAngleBetweenPlayerAndDoor();
|
|
// if (angleBetweenPlayerAndDoor > 90f)
|
|
// {
|
|
// doorSide = -1;
|
|
|
|
// }
|
|
// else if( angleBetweenPlayerAndDoor < 90f)
|
|
// {
|
|
// doorSide = 1;
|
|
// //if (angleBetweenPlayerAndDoor == 90f)
|
|
// //{
|
|
// // doorSide = 1;
|
|
// //}
|
|
// }
|
|
// //else if (angleBetweenPlayerAndDoor == 90f)
|
|
// //{
|
|
// // doorSide = 0;
|
|
// //}
|
|
// print(doorSide);
|
|
// }
|
|
// }
|
|
|
|
// #region Layers Of Fear
|
|
// //public override void UpdateInternal(Vector2 inputVector, Vector3 playerForward)
|
|
// //{
|
|
// // float d = Vector3.Dot(inputVector, this.E_MouseMovementVector) * -1f;
|
|
// // Vector3 force = (!this.E_SetMoveDirection) ? (playerForward * d) : (base.GetMoveDirection() * d);
|
|
// // if (this.IsDragged && this.m_Rigidbody)
|
|
// // {
|
|
// // if (!this.E_OnlyRotation && this.m_Rigidbody.velocity.magnitude < this.E_MaxForce && force.magnitude > this.E_MinForce)
|
|
// // {
|
|
// // base.AddForce(force);
|
|
// // if (this.E_UniqueID != 0)
|
|
// // {
|
|
// // GameStatistics.Instance.OpenableMoved(base.OwnerRoom.Owner.Scene.UniqueID, this.E_OpenableType, this.E_UniqueID);
|
|
// // }
|
|
// // }
|
|
// // if (this.E_SetRotationDirection)
|
|
// // {
|
|
// // this.m_Rigidbody.transform.Rotate(this.E_RotationDirection, force.magnitude * this.E_ForceMultiplier, this.E_Space);
|
|
// // }
|
|
// // }
|
|
// // this.PlaySounds(inputVector);
|
|
// // this.UpdateMoveSounds();
|
|
// //}
|
|
// #endregion
|
|
|
|
|
|
// //private void OnTriggerStay(Collider col)
|
|
// //{
|
|
// // //if(col.gameObject.tag == "Player")
|
|
// // //{
|
|
// // // if (Input.GetKeyDown(KeyCode.Mouse0))
|
|
// // // {
|
|
// // // if (CanOpenDoor)
|
|
// // // {
|
|
// // // if (!DoorIsOpen)
|
|
// // // {
|
|
// // // DoorOpen();
|
|
// // // }
|
|
// // // else
|
|
// // // {
|
|
// // // DoorClose();
|
|
// // // }
|
|
// // // }
|
|
// // // else if(DoorRequiresKey)
|
|
// // // {
|
|
// // // Debug.Log("Door is locked");
|
|
// // // }
|
|
// // // else
|
|
// // // {
|
|
// // // Debug.Log("Door is jammed");
|
|
// // // }
|
|
// // // }
|
|
// // //}
|
|
|
|
// //}
|
|
// public void DragDoor()
|
|
// {
|
|
// #region Door Drag
|
|
// if (CanOpenDoor)
|
|
// {
|
|
// DraggablesManager.GetInstance().IsDragging = true;
|
|
// //#region Player Camera
|
|
// //CameraMovement.GetInstance()._mouseSensitivity = 0.5f;
|
|
// //#endregion
|
|
|
|
// float rotX = Input.GetAxis("Mouse X") * RotationSpeed * Mathf.Deg2Rad;
|
|
|
|
// //float rotY = Input.GetAxis("Mouse Y") * RotationSpeed * Mathf.Deg2Rad;
|
|
|
|
// //if (Input.GetMouseButton(0)) //While you are holding down the left mouse:
|
|
// //{
|
|
// #region fml
|
|
// //if (Mathf.Approximately(door.rotation.z, _player.rotation.z))
|
|
// //{
|
|
// // door.RotateAroundLocal(Vector3.up, -rotX);
|
|
// // print("I work normmaly");
|
|
// //}
|
|
// //else
|
|
// //{
|
|
// // door.RotateAroundLocal(Vector3.down, -rotXReverse);
|
|
// // print("I work gay");
|
|
// //}
|
|
// #endregion
|
|
// GetAngleBetweenPlayerAndDoor();
|
|
// MouseVectorUpdate();
|
|
// if (doorSide == 1f)
|
|
// {
|
|
// door.RotateAroundLocal(Vector3.up, -rotX);
|
|
|
|
// }
|
|
// else if( doorSide == -1)
|
|
// {
|
|
// door.RotateAroundLocal(Vector3.up, rotX);
|
|
|
|
// }
|
|
// //else if (doorSide == 0)
|
|
// //{
|
|
|
|
// //}
|
|
|
|
// //door.RotateAroundLocal(Vector3.up, -rotX);
|
|
// //door.RotateAroundLocal(Vector3.right, rotY);
|
|
// float DoorAngle = door.transform.localEulerAngles.y;
|
|
// DoorAngle = (DoorAngle > 180) ? DoorAngle - 360 : DoorAngle;
|
|
// if (DoorAngle <= -90f)
|
|
// {
|
|
// print("Door Rotation.Y is -90f");
|
|
// door.localEulerAngles = new Vector3(0f, -90f, 0f);
|
|
// DoorIsOpen = true;
|
|
// }
|
|
// if (DoorAngle < -0.01f)
|
|
// {
|
|
// print("Door Rotation.Y is -90f");
|
|
// DoorIsOpen = true;
|
|
// }
|
|
// if (door.localRotation.y >= 0f)
|
|
// {
|
|
// print("Door Rotation.Y is 0f");
|
|
// door.localEulerAngles = new Vector3(0f, 0f, 0f);
|
|
// DoorIsOpen = false;
|
|
// }
|
|
// //}
|
|
// }
|
|
// else if (DoorRequiresKey)
|
|
// {
|
|
// Debug.Log("Door is locked");
|
|
// }
|
|
// else
|
|
// {
|
|
// Debug.Log("Door is jammed");
|
|
// }
|
|
// }
|
|
// #endregion
|
|
|
|
// public void Drag()
|
|
// {
|
|
// DragDoor();
|
|
// }
|
|
|
|
|
|
// public void LockDoor()
|
|
// {
|
|
// DoorRequiresKey = true;
|
|
// CanOpenDoor = false;
|
|
// }
|
|
|
|
// public void UnlockDoor()
|
|
// {
|
|
// DoorRequiresKey = false;
|
|
// CanOpenDoor = true;
|
|
// }
|
|
|
|
// #region Open Door
|
|
// public void OpenDoor(float doorLerpSpeed)
|
|
// {
|
|
// doorLerp = 0f;
|
|
// StartCoroutine(OpenDoorCoroutine(doorLerpSpeed));
|
|
// }
|
|
|
|
// IEnumerator OpenDoorCoroutine(float doorLerpSpeed)
|
|
// {
|
|
// while(doorLerp <= 1f)
|
|
// {
|
|
// doorLerp += doorLerpSpeed * Time.deltaTime;
|
|
// door.localRotation = Quaternion.Slerp(door.localRotation, _OpenPos, doorLerp);
|
|
// //transform.localEulerAngles = Quaternion.Lerp(door.transform.localRotation, _OpenPos, doorLerp);
|
|
|
|
// yield return null;
|
|
// }
|
|
// }
|
|
// #endregion
|
|
|
|
// #region Close Door
|
|
// public void CloseDoor(float doorLerpSpeed)
|
|
// {
|
|
// doorLerp = 0f;
|
|
// StartCoroutine(CloseDoorCoroutine(doorLerpSpeed));
|
|
// }
|
|
|
|
|
|
// IEnumerator CloseDoorCoroutine(float doorLerpSpeed)
|
|
// {
|
|
// while (doorLerp <= 1f)
|
|
// {
|
|
// doorLerp += doorLerpSpeed * Time.deltaTime;
|
|
// door.localRotation = Quaternion.Slerp(door.localRotation, _ClosedPos, doorLerp);
|
|
// yield return null;
|
|
// }
|
|
// }
|
|
// #endregion
|
|
// }
|
|
//}
|
|
#endregion |