InteractableDebug.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using PixoVR.Core;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
 
namespace PixoVR.Event
{
    public class InteractableDebug : MonoBehaviour
    {
        //steps
        [SerializeField] private Dropdown _dropdownSteps;
        
        [SerializeField] private Button _skipStepButton;
        [SerializeField] private Button _goToStepButton;
        
        [SerializeField] private TMP_Text _currentStepText;
        [SerializeField] private TMP_Text _currentFunctionText;
        
        //items
        [SerializeField] private Dropdown _dropdownItems;
        [SerializeField] private Toggle _isActive;
        [SerializeField] private Toggle _isBroken;
        [SerializeField] private Toggle _isInspected;
        
        [SerializeField] private Button _activateButton;
        [SerializeField] private Button _deactivateButton;
        
        [SerializeField] private Button _highlightOnButton;
        [SerializeField] private Button _highlightOffButton;
        
        [SerializeField] private Button _turnOnButton;
        [SerializeField] private Button _turnOffButton;
        
        [SerializeField] private Button _repairOnButton;
        [SerializeField] private Button _breakDownButton;
        
        [SerializeField] private Button _closeButton;
        
        //
        
        private bool isActive;
        private bool isBroken;
        private bool isInspected;
 
        private string _selectedStep;
        private InteractableClass _currentItem;
        private StepManager _stepManager;
        private StepsData _stepsData;
        private List<string> _listOfSteps;
 
        private Dictionary<ItemsEnum, InteractableClass> _ItemsDictionary;
        private Dictionary<string, InteractableClass> _StringItemsDictionary;
 
        
        public event Action CloseDebugUI;
        
        void Start()
        {
            // _pointerSwitchButtons.Any(button => _thisHand.ButtonPressed(button));
            _stepManager = ServiceLocator.Resolve<StepManager>();
            
            var stepsData = StatesService.GetState<StepsData>();
            if (stepsData != null)
            {
                _stepsData = stepsData;
            }
            
            _dropdownSteps.onValueChanged.AddListener(delegate {StepSelected(_dropdownSteps);});
            
            _dropdownItems.onValueChanged.AddListener(delegate {ItemSelected(_dropdownItems);});
            
            StartCoroutine(StartInit());
            
            
            _stepManager.StepInformationUpdated += UpdateStepInfo;
            
            _activateButton.onClick.AddListener(ActivateObject);
            _deactivateButton.onClick.AddListener(DeactivateObject);
            
            _highlightOnButton.onClick.AddListener(HighlightOnObject);
            _highlightOffButton.onClick.AddListener(HighlightOffObject);
            
            _turnOnButton.onClick.AddListener(TurnOnObject);
            _turnOffButton.onClick.AddListener(TurnOffObject);
            
            _repairOnButton.onClick.AddListener(RepairObject);
            _breakDownButton.onClick.AddListener(BreakDownObject);
 
            _skipStepButton.onClick.AddListener(SkipStep);
            _goToStepButton.onClick.AddListener(GoToSelectedStep);
 
            _closeButton.onClick.AddListener(() => CloseDebugUI?.Invoke());
 
            // _currentItem = _stepManager.GetGameObjectByID(ItemsEnum.GAME_MENU);
        }
 
        private void OnDestroy()
        {
            _stepManager.StepInformationUpdated -= UpdateStepInfo;
            _dropdownSteps.onValueChanged.RemoveListener(delegate {StepSelected(_dropdownSteps);});
            
            _activateButton.onClick.RemoveListener(ActivateObject);
            _deactivateButton.onClick.RemoveListener(DeactivateObject);
            
            _highlightOnButton.onClick.RemoveListener(HighlightOnObject);
            _highlightOffButton.onClick.RemoveListener(HighlightOffObject);
            
            _turnOnButton.onClick.RemoveListener(TurnOnObject);
            _turnOffButton.onClick.RemoveListener(TurnOffObject);
            
            _repairOnButton.onClick.RemoveListener(RepairObject);
            _breakDownButton.onClick.RemoveListener(BreakDownObject);
            
            _skipStepButton.onClick.RemoveListener(SkipStep);
            _goToStepButton.onClick.RemoveListener(GoToSelectedStep);
            
            _closeButton.onClick.RemoveListener(() => CloseDebugUI?.Invoke());
 
        }
        
        private void StepSelected(Dropdown dropdownSteps)
        {
            int index = dropdownSteps.value;
            _selectedStep = _listOfSteps[index];
        }
        
        private void ItemSelected(Dropdown dropdownItems)
        {
            _currentItem = _StringItemsDictionary[dropdownItems.itemText.ToString()];
        }
        
        private void GoToSelectedStep()
        {
            _stepManager.GoToStep(_selectedStep);
        }
 
        private void SkipStep()
        {
            EventBetter.Raise(new TriggeredItemEvent()
            {
                item = ItemsEnum.SKIP_STEP
            });
        }
        
        private void UpdateStepInfo(string step, int function)
        {
            _currentStepText.SetText(step);
            _currentFunctionText.SetText(function.ToString());
        }
 
        public void InitDebugUI()
        {
            _StringItemsDictionary.Clear();
            _ItemsDictionary = _stepManager.GetDictionary();
            _dropdownItems.options.Clear();
 
            foreach (var item in _ItemsDictionary)
            {
                var itemName = item.Key.ToString();
                var option = new Dropdown.OptionData(itemName, null);
                _StringItemsDictionary.Add(itemName, item.Value);
                _dropdownItems.options.Add(option);
            }
            
            _dropdownSteps.options.Clear();
            foreach (var step in _stepsData.listOfSteps)
            {
                var option = new Dropdown.OptionData(step.stepID, null);
                _listOfSteps.Add(step.stepID);
                _dropdownSteps.options.Add(option);
            }
            
            _ItemsDictionary.Clear();
        }
        
        private void BreakDownObject()
        {
            _currentItem.GenerateBreakdown(100);
        }
 
        private void RepairObject()
        {
            _currentItem.GenerateBreakdown(0);
        }
 
        private void TurnOffObject()
        {
            _currentItem.TurnOnOffState(false);
        }
 
        private void TurnOnObject()
        {
            _currentItem.TurnOnOffState(true);
        }
 
        private void HighlightOffObject()
        {
            _currentItem.Highlight(false);
        }
 
        private void HighlightOnObject()
        {
            _currentItem.Highlight(false);
        }
 
        private void ActivateObject()
        {
            _currentItem.Active(true);
        }
        
        private void DeactivateObject()
        {
            _currentItem.Active(false);
        }
        
 
        public void ApplyChanges()
        {
            var item = _stepManager.GetGameObjectByID(ItemsEnum.GAME_MENU);
            item.IsActive = _isActive.isOn;
            item.IsBroken = _isBroken.isOn;
            item.isInspected = _isInspected.isOn;
        }
 
 
        IEnumerator StartInit()
        {
            yield return new WaitForSeconds(2f);
            InitDebugUI();
        }
    }
}