beyond/Assets/Scripts/Effects/SilentPeekController.cs

using System;
using System.Collections;
using System.Collections.Generic;
using PixelCrushers.DialogueSystem;
using RootMotion;
using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.Events;

namespace Beyond
{
    public class SilentPeekController : Singleton<SilentPeekController>
    {
        public enum State
        {
            DISABLED,
            FADING_IN,
            ON,
            FADING_OUT
        }

        [SerializeField] private Renderer m_renderer;
        [SerializeField] private float m_fadeTime = 3f;
        private Material m_material;
        private State m_state;
        private float m_timer = 0f;
        public float m_faithCostPerSecond = 1f;

        private int m_thresholID = Shader.PropertyToID("_CutoutTh");
        public UnityEvent<bool> m_OnStateChanged;
        private bItem m_itemToRemove;
        private bInventory m_inventory;

        private void SetTh(float th)
        {
            m_material.SetFloat(m_thresholID, th);
        }

        public State GetState()
        {
            return m_state;
        }

        [Button]
        public void SetActive(bool active, bItem itemToRemove = null)
        {
            if (itemToRemove)
                m_itemToRemove = itemToRemove;
            SetState(active ? State.FADING_IN : State.FADING_OUT);
            if (!active && m_itemToRemove)
            {
                m_inventory.OnUseItem(m_itemToRemove);
                m_itemToRemove = null;
            }

            m_OnStateChanged?.Invoke(active);
        }

        public bool IsActive()
        {
            return m_state == State.ON || m_state == State.FADING_IN;
        }

        public void SetState(State s)
        {
            switch (s)
            {
                case State.ON:
                    SetTh(1f);
                    break;
                case State.DISABLED:
                    SetTh(0f);
                    m_renderer.enabled = false;
                    break;
                case State.FADING_IN:
                    m_renderer.enabled = true;
                    break;
                case State.FADING_OUT:
                    break;
            }

            m_state = s;
            m_timer = 0f;
        }

        // Start is called before the first frame update
        void Start()
        {
            if (m_renderer == null)
            {
                m_renderer = GetComponent<Renderer>();
            }

            if (m_renderer == null)
            {
                Debug.LogError("Silent Peek controller: no renderer found! disabling...");
                enabled = false;
            }

            m_material = m_renderer.material;
            SetState(State.DISABLED);
            m_inventory = FindObjectOfType<bInventory>();
        }

        private void OnDestroy()
        {
            Clear(gameObject);
        }

        // Update is called once per frame
        void Update()
        {
            switch (m_state)
            {
                case State.ON:
                    var attr = Player.Instance.GetAttribute(("Faith"));

                    if (attr != null)
                    {
                        attr.AttributeCurrentValue -= m_faithCostPerSecond * Time.deltaTime;
                        if (attr.AttributeCurrentValue < attr.AttributeMinValue)
                        {
                            attr.AttributeCurrentValue = attr.AttributeMinValue;
                            SetActive(false);
                        }
                    }

                    break;
                case State.DISABLED:
                    break;
                case State.FADING_IN:
                    if (m_timer > m_fadeTime)
                    {
                        SetState(State.ON);
                        break;
                    }
                    else
                    {
                        SetTh(m_timer / m_fadeTime);
                    }
                    
                    DialogueLua.SetVariable("CovertGaze", true);
                    break;
                case State.FADING_OUT:
                    if (m_timer > m_fadeTime)
                    {
                        SetState(State.DISABLED);
                        break;
                    }
                    else
                    {
                        SetTh(1f - m_timer / m_fadeTime);
                    }
                    
                    DialogueLua.SetVariable("CovertGaze", false);

                    break;
            }

            m_timer += Time.deltaTime;
        }
    }
}