InteractableClass.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using Autohand;
using JJKeller;
using PixoVR.Core;
using UnityEngine;
using Random = UnityEngine.Random;
 
namespace PixoVR.Event
{
    [RequireComponent(typeof(RegisterItem))]
    public abstract class InteractableClass : MonoBehaviour
    {
        public ItemsEnum ItemId;
        public bool IsActive;
        public bool IsBroken;
        public int BrokenId = 0;
        public bool isInspected = false;
        public ItemsEnum[] StepsId;
        [SerializeField] protected GameObject[] correctModels;
        [SerializeField] protected GameObject[] brokenModels;
        [SerializeField] private Outline _outline;
        [SerializeField] private Outline[] _additionalOutlines;
        [SerializeField] protected DistanceGrabbable _distanceGrabbable;
 
        private const int MinValue = 1;
        private const int MaxValue = 100;
 
        protected Grabbable[] _grabbables;
        private bool _waitingForSelection;
 
        private Coroutine _timerCoroutine;
 
        public virtual void Interactive(bool state)
        {
            IsActive = state;
            ShowModels();
        }
 
        public virtual void Awake()
        {
            _grabbables = GetComponentsInChildren<Grabbable>();
        }
 
        public virtual void Active(bool state)
        {
            IsActive = state;
        }
 
        protected void ShowModels()
        {
            if (correctModels.Length > 0)
            {
                correctModels[(int)ModelState.NORMAL].SetActive(true);
            }
 
            if ((IsBroken) && (correctModels.Length > 1))
            {
                correctModels[(int)ModelState.NORMAL].SetActive(false);
 
                int randIndex = Random.Range(1, correctModels.Length);
 
                for (int i = 1; i < correctModels.Length; i++)
                {
                    correctModels[i].SetActive(i == randIndex);
                }
            }
        }
 
        public virtual void Highlight(bool state)
        {
            if (_outline == null)
            {
                Debug.LogWarning("Outline is not exist");
            }
            else
            {
                _outline.enabled = state;
            }
 
 
            if (_additionalOutlines != null)
            {
                foreach (var outline in _additionalOutlines)
                {
                    outline.enabled = state;
                }
            }
        }
 
        public virtual void WaitForSelection()
        {
            if (!_waitingForSelection)
            {
                _waitingForSelection = true;
 
                if (_distanceGrabbable == null && _grabbables == null)
                {
                    Debug.LogWarning("Grabbable is not exist");
 
                    return;
                }
 
                _distanceGrabbable?.StartTargeting.AddListener(OnStartTargeting);
 
                _distanceGrabbable?.StopTargeting.AddListener(OnStopTargeting);
 
                for (int i = 0; i < _grabbables?.Length; i++)
                {
                    _grabbables[i].onHighlight.AddListener(OnStartTargeting);
                    _grabbables[i].onUnhighlight.AddListener(OnStopTargeting);
                }
            }
        }
 
        public virtual void TurnOffWaitForSelection()
        {
            if (_waitingForSelection)
            {
                _waitingForSelection = false;
 
                if (_distanceGrabbable == null && _grabbables == null)
                {
                    Debug.LogWarning("Grabbable is not exist");
 
                    return;
                }
 
                _distanceGrabbable?.StartTargeting.RemoveListener(OnStartTargeting);
 
                _distanceGrabbable?.StopTargeting.RemoveListener(OnStopTargeting);
 
                for (int i = 0; i < _grabbables?.Length; i++)
                {
                    _grabbables[i].onHighlight.RemoveListener(OnStartTargeting);
                    _grabbables[i].onUnhighlight.RemoveListener(OnStopTargeting);
                }
            }
        }
 
        private void OnStartTargeting(Hand hand, Grabbable grabbable)
        {
            Highlight(true);
        }
 
        private void OnStopTargeting(Hand hand, Grabbable grabbable)
        {
            Highlight(false);
        }
 
        public virtual void OpenInspectionMenu(string quizId)
        {
        }
 
        public virtual void ShowModel()
        {
            foreach (var model in correctModels)
            {
                model.SetActive(!IsBroken);
            }
 
            foreach (var model in brokenModels)
            {
                model.SetActive(IsBroken);
            }
        }
 
        public virtual void HideModel()
        {
            foreach (var model in correctModels)
            {
                model.SetActive(false);
            }
 
            foreach (var model in brokenModels)
            {
                model.SetActive(false);
            }
        }
 
        public virtual void PrepareInspectionReport(List<InteractableClass> interactables)
        {
        }
 
        public virtual void SetParametersForItem(string value, string[] additionalValues)
        {
            
        }
 
        public virtual void SetDefaultState()
        {
        }
 
        public virtual void GenerateBreakdown(int percentBroke)
        {
            IsBroken = Random.Range(MinValue, MaxValue) <= percentBroke;
        }
 
        public virtual void PlayForwardAnimation(bool playForward, Action callback)
        {
            callback?.Invoke();
        }
 
        public virtual void Execute()
        {
            EventBetter.Raise(
                new TriggeredItemEvent()
                {
                    item = ItemId
                }
            );
        }
 
        public virtual void ActivateSetCallback(Action callback)
        {
        }
 
        public virtual void TurnOnOffState(bool turnOn)
        {
        }
 
        public virtual void RepairElement()
        {
            IsBroken = false;
            isInspected = true;
            ShowModels();
        }
 
        public virtual void SetInspected()
        {
            isInspected = true;
        }
 
        protected void SetGrabEnabled(bool isEnabled)
        {
            if (_distanceGrabbable != null)
            {
                _distanceGrabbable.enabled = isEnabled;
            }
 
            if (_grabbables != null)
            {
                for (int i = 0; i < _grabbables.Length; i++)
                {
                    _grabbables[i].enabled = isEnabled;
                }
            }
        }
 
        public virtual void CheckInspectionStatus()
        {
            if (isInspected)
            {
                Execute();
            }
            else
            {
                EventBetter.Raise(
                    new TriggeredItemEvent()
                    {
                        item = ItemsEnum.NONE
                    }
                );
            }
        }
 
        public void SetTimer(float timer)
        {
            if (_timerCoroutine != null)
            {
                Debug.LogWarning("Stopped previous timer manually");
                
                StopTimer();
            }
 
            _timerCoroutine = StartCoroutine(StartTimer(timer));
        }
 
        public void StopTimer()
        {
            if (_timerCoroutine != null)
            {
                StopCoroutine(_timerCoroutine);
 
                _timerCoroutine = null;
            }
        }
 
        private IEnumerator StartTimer(float timer)
        {
            while (true)
            {
                yield return new WaitForSeconds(timer);
 
                OnTimerExpired();
            }
        }
 
        public virtual void OnTimerExpired()
        {
            
        }
    }
 
    public enum ModelState
    {
        NORMAL = 0,
        BROKEN
    }
}