smart-bow-infrared/Assets/ShotSimulator/Scripts/UI/Train/ExecuteTrainUIView.cs

using ProjectBase.Event;
using ProjectBase.UI;
using ShotSimulator.Event;
using ShotSimulator.Train;
using ShotSimulator.Train.Info;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Localization.Components;
using UnityEngine.UI;

namespace ShotSimulator.UI
{
    public class ExecuteTrainUIView : BaseUIView
    {
        public Sprite[] countdownTex;
        public Image countdownImage;

        public GameObject countDownPanel;
        public GameObject trainingPanel;

        public JumpingNumberTextComponent score_JumpNumComponent;
        public Text precisionText;
        public Text timeText;
        public Text bulletNumsText;

        public GameObject pausePanel;
        public Button pauseButton;
        public Button replayButton;
        public Button continueButton;
        public Button exitButton;

        private GameObject current_ReloadTipObj;
        public GameObject reloadedTipObj;
        public GameObject emptyMagazineTipText;
        public GameObject ChamberEmptyTipObj;
        public GameObject emptyMagazineTipObj;
        public GameObject reloadingTipObj;
        public LocalizeStringEvent ReloadedTipLocalize;

        private BaseTrainHandle m_TrainHandle;

        private int bulletLowNums;

        protected override void InitUIObjects()
        {
            base.InitUIObjects();

            pauseButton.onClick.AddListener(OnPauseButtonClick);
            replayButton.onClick.AddListener(OnReplayButtonClick);
            continueButton.onClick.AddListener(OnContinueButtonClick);
            exitButton.onClick.AddListener(OnExitButtonClick);

            ReloadedTipLocalize.StringReference.Arguments = new object[1];
        }
        protected override void UpdateArguments(params object[] args)
        {
            base.UpdateArguments(args);

            m_TrainHandle = args[0] as BaseTrainHandle;
        }

        protected override void UpdateViewCallBack()
        {
            base.UpdateViewCallBack();

            bulletLowNums = m_TrainHandle.FirearmData.magazineCapacity / 5;

        }

        private void Update()
        {
            if (m_TrainHandle != null)
            {
                if (m_TrainHandle.IsRunning && !m_TrainHandle.IsPause)
                {
                    if (m_TrainHandle.TrainInfo.finishType == TrainTaskFinishType.Time)
                    {
                        timeText.text = SecondToFormattedTime((int)m_TrainHandle.m_TaskTimer.remainingTime);
                    }
                }
            }
        }

        private string SecondToFormattedTime(int seconds)
        {
            TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);

            return timeSpan.ToString(@"mm\:ss");
        }
        protected override void OnShowCallBack()
        {
            base.OnShowCallBack();

            EventCenter.GetInstance().RegisterEvent(EventKey.OnTrainResultMetricsDataUpdated, OnTrainResultMetricsDataUpdated);
            EventCenter.GetInstance().RegisterEvent(EventKey.OnBulletNumsChanged, OnBulletNumsChanged);
            EventCenter.GetInstance().RegisterEvent(EventKey.OnMagazineStateChanged, OnMagazineStateChanged);
            EventCenter.GetInstance().RegisterEvent(EventKey.OnShootWitchEmptyBullets, OnShootWitchEmptyBullets);
            EventCenter.GetInstance().RegisterEvent(EventKey.OnShootWitchChamberEmpty, OnShootWitchChamberEmpty);
            EventCenter.GetInstance().RegisterEvent(EventKey.OnExecutingTrainDataUpdated, OnExecutingTrainDataUpdated);
            EventCenter.GetInstance().RegisterEvent(EventKey.OnChamberStateUpdated, OnChamberStateUpdated);

            replayButton.interactable = true;
            continueButton.interactable = true;
            exitButton.interactable = true;
            pauseButton.interactable = true;

            countdownImage.sprite = countdownTex[countdownTex.Length - 1];

            countDownPanel.SetActive(true);
            trainingPanel.SetActive(true);
            pausePanel.SetActive(false);
            emptyMagazineTipText.SetActive(false);
            ChamberEmptyTipObj.SetActive(false);

            if (current_ReloadTipObj != null)
            {
                current_ReloadTipObj.SetActive(false);
            }

            score_JumpNumComponent.Init();
            precisionText.text = "N / A";
            switch (m_TrainHandle.TrainInfo.finishType)
            {
                case TrainTaskFinishType.Time:
                    timeText.text = SecondToFormattedTime((int)m_TrainHandle.TrainInfo.duration);
                    break;
                case TrainTaskFinishType.Number:
                    timeText.text = string.Format("{0} / {1}", m_TrainHandle.TrainInfo.maxNumber, m_TrainHandle.TrainInfo.maxNumber);
                    break;
                default:
                    timeText.text = "- / -";
                    break;
            }

            if (m_TrainHandle.TrainInfo.m_TrainFirearmConfig.isNeedConsumeBullet)
            {
                bulletNumsText.text = "- / -";
            }
            else
            {
                bulletNumsText.text = "∞";
            }

            StartCoroutine(StartCountdown());
        }

        protected override void OnHideCallBack()
        {
            base.OnHideCallBack();

            EventCenter.GetInstance().UnregisterEvent(EventKey.OnTrainResultMetricsDataUpdated, OnTrainResultMetricsDataUpdated);
            EventCenter.GetInstance().UnregisterEvent(EventKey.OnBulletNumsChanged, OnBulletNumsChanged);
            EventCenter.GetInstance().UnregisterEvent(EventKey.OnMagazineStateChanged, OnMagazineStateChanged);
            EventCenter.GetInstance().UnregisterEvent(EventKey.OnShootWitchEmptyBullets, OnShootWitchEmptyBullets);
            EventCenter.GetInstance().UnregisterEvent(EventKey.OnShootWitchChamberEmpty, OnShootWitchChamberEmpty);
            EventCenter.GetInstance().UnregisterEvent(EventKey.OnExecutingTrainDataUpdated, OnExecutingTrainDataUpdated);
            EventCenter.GetInstance().UnregisterEvent(EventKey.OnChamberStateUpdated, OnChamberStateUpdated);
        }

        private IEnumerator StartCountdown()
        {
            for (int i = countdownTex.Length - 1; i >= 0; i--)
            {
                countdownImage.sprite = countdownTex[i];
                countdownImage.SetNativeSize();
                yield return new WaitForSeconds(1f);
            }

            countDownPanel.SetActive(false);

            TrainTaskLoader.GetInstance().StartTrainTask();
        }

        private void OnTrainResultMetricsDataUpdated(BaseEventData eventData)
        {
            TrainResultEventData data = eventData as TrainResultEventData;
            if (data != null)
            {
                switch (data.type)
                {
                    case MetricsType.Score:
                        OnScoreUpdated(data.value);
                        break;
                    case MetricsType.Precision:
                        OnPrecisionUpdated(data.value);
                        break;
                }
            }
        }
        private void OnScoreUpdated(double value)
        {
            score_JumpNumComponent.SetNum((int)value);
        }
        private void OnPrecisionUpdated(double value)
        {
            precisionText.text = value.ToString("P0");
        }

        private void OnBulletNumsChanged(BaseEventData eventData)
        {
            BulletNumsEventData data = eventData as BulletNumsEventData;
            if (data != null)
            {
                string color = data.magazineBulletNums <= bulletLowNums ? "red" : "white";
                bulletNumsText.text = string.Format("<color={0}>{1}</color> / {2}", color, data.magazineBulletNums, data.magazineCapacity);

                if (current_ReloadTipObj != null)
                {
                    current_ReloadTipObj.gameObject.SetActive(false);
                }
                if (data.magazineBulletNums == 0)
                {
                    current_ReloadTipObj = emptyMagazineTipObj;
                    current_ReloadTipObj.SetActive(true);
                }
            }
        }
        private void OnChamberStateUpdated(BaseEventData eventData)
        {
            ChamberStateEventData data = eventData as ChamberStateEventData;
            if (data != null)
            {
                if (data.IsChambered)
                {
                    ChamberEmptyTipObj.SetActive(false);
                }
            }
        }
        private void OnMagazineStateChanged(BaseEventData eventData)
        {
            MagazineStateEventData data = eventData as MagazineStateEventData;
            if (data != null)
            {
                if (current_ReloadTipObj != null)
                {
                    current_ReloadTipObj.gameObject.SetActive(false);
                }

                switch (data.state)
                {
                    case MagazineState.Separation:
                        current_ReloadTipObj = reloadingTipObj;
                        current_ReloadTipObj.SetActive(true);
                        break;
                    case MagazineState.ReLoad:
                        StartCoroutine(ShowReloadedTip(data.reloadedTime));
                        break;
                }
            }
        }

        private IEnumerator ShowReloadedTip(float reloadTime)
        {
            emptyMagazineTipText.SetActive(false);
            ReloadedTipLocalize.StringReference.Arguments[0] = reloadTime.ToString("F1");
            ReloadedTipLocalize.StringReference.RefreshString();
            current_ReloadTipObj = reloadedTipObj;
            current_ReloadTipObj.SetActive(true);

            yield return new WaitForSeconds(3f);

            current_ReloadTipObj.SetActive(false);
        }

        private void OnShootWitchEmptyBullets(BaseEventData eventData)
        {
            emptyMagazineTipText.SetActive(true);
        }
        private void OnShootWitchChamberEmpty(BaseEventData eventData)
        {
            ChamberEmptyTipObj.SetActive(true);
        }
        private void OnExecutingTrainDataUpdated(BaseEventData eventData)
        {
            ExecutingTrainEventData data = eventData as ExecutingTrainEventData;
            if (data != null)
            {
                if (m_TrainHandle.TrainInfo.finishType == TrainTaskFinishType.Number)
                {
                    timeText.text = string.Format("{0} / {1}", data.currentNumber, data.maxNumber);
                }
            }
        }
        private void OnPauseButtonClick()
        {
            pauseButton.interactable = false;
            TrainTaskLoader.GetInstance().SetContinueOrPauseTrain(true);
            pausePanel.SetActive(true);
        }
        private void OnReplayButtonClick()
        {
            replayButton.interactable = false;
            TrainTaskLoader.GetInstance().ReStartTrain();
        }
        private void OnContinueButtonClick()
        {
            pauseButton.interactable = true;
            continueButton.interactable = false;
            TrainTaskLoader.GetInstance().SetContinueOrPauseTrain(false);
            pausePanel.SetActive(false);
        }
        private void OnExitButtonClick()
        {
            exitButton.interactable = false;
            TrainTaskLoader.GetInstance().FinishTrain();
        }
    }
}