beyond/Assets/Scripts/Respawner.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Invector;
using Invector.vCharacterController;
using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.Events;

namespace Beyond
{
    public class Respawner : MonoBehaviour
    {
        private Vector3 respawnPos;
        private int respawnersLayer;
        private int dethLayer;
        public float m_playerRespawnDelay = 2f;
        public float m_playerRespawnFadeTime = 2f;
        private vThirdPersonController m_player;
        private bool m_isRespawning;
        public CutScene m_testCutscene;
        public UnityEvent m_onRespawned, m_onRespawnedStart;

        // Start is called before the first frame update
        private void Start()
        {
            respawnPos = transform.position;
            respawnersLayer = LayerMask.NameToLayer("Respawners");
            dethLayer = LayerMask.NameToLayer("Death");
            if (m_player == null)
                m_player = GetComponent<vThirdPersonController>();
            if (m_player != null)
            {
                if (m_player)
                {
                    m_player.onDead.AddListener(OnDead);
                }
            }
        }

        private IEnumerator RespawnCoroutine()
        {
            m_isRespawning = true;
            yield return new WaitForSeconds(m_playerRespawnDelay);
            FadeCanvasGroup.Instance.FadeOut(1f);
            yield return new WaitForSeconds(m_playerRespawnFadeTime);
            m_onRespawnedStart?.Invoke();
            Respawn();
            yield return new WaitForSeconds(1f);
            FadeCanvasGroup.Instance.FadeIn(1f);
            yield return new WaitForSeconds(m_playerRespawnFadeTime);
        }

        private void OnDisable()
        {
            StopAllCoroutines();
        }

        private void OnEnable()
        {
            if (m_isRespawning)
            {
                Respawn();
            }
        }

        private void OnDead(GameObject obj)
        {
            StartCoroutine(RespawnCoroutine());
        }

        public void SaveRespawnPoint(Vector3 point)
        {
            respawnPos = point;
        }

        public void SaveRespawnPoint()
        {
            SaveRespawnPoint(transform.position);
        }

        // Update is called once per frame
        private void Update()
        {
        }

        [Button]
        private void TestKill()
        {
            if (m_player)
            {
                var tp = m_player.GetComponent<vThirdPersonController>();
                tp.TakeDamage(new vDamage(1000000));
                if (m_testCutscene)
                {
                    if (!m_testCutscene.gameObject.activeSelf)
                        m_testCutscene.gameObject.SetActive(true);
                    m_testCutscene.PlayTimeline();
                }
            }
        }

        private void OnTriggerEnter(Collider other)
        {
            if (other.gameObject.layer == respawnersLayer)
            {
                respawnPos = transform.position;
            }
            else if (other.gameObject.layer == dethLayer)
            {
                Respawn();
            }
        }

        private void OnCollisionEnter(Collision collision)
        {
            //
            if (collision.gameObject.layer == respawnersLayer)
            {
                respawnPos = transform.position;
            }
            else if (collision.gameObject.layer == dethLayer)
            {
                Respawn();
            }
        }

        [Button]
        private void Respawn()
        {
            transform.position = respawnPos;
            if (m_player)
            {
                m_player.Respawn();
            }
            m_onRespawned?.Invoke();
            m_isRespawning = false;
        }
    }
}