DataStudy/Assets/GameMain/Scripts/UI_Form/EleTrainStudyForm.cs

using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using DG.Tweening;
using GameFramework;
using GameFramework.Event;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityGameFramework.Runtime;

public class EleTrainStudyForm : UIFormLogic
{
    private GameObject _trainPanel;
    private GameObject _learnPanel;
    private GameObject _faultPanel;

    private GameObject _trainDoneTips;
    private GameObject _faultDoneTips;

    private Button _reStartButton;
    private Button _cpuButton;
    private Button _ramButton;
    private Button _fanButton;
    private Button _powerButton;
    private bool cpuDone = false;
    private bool fanDone = false;
    private bool ramDone = false;
    private bool powerDone = false;

    //private GameObject _overHotTips;
    private Button _reStarFaultButton;
    private Button _cpuFaultButton;
    private Button _ramFaultButton;
    private Button _fanFaultButton;
    private Button _powerFaultButton;

    private Image _cpuValueSlider;
    private Text _cpuValueText;
    private Image _ramValueSlider;
    private Text _ramValueText;
    private Slider _hardDiskTemperature;
    private Image _hardDiskColor;
    private Slider _mbTemperature;
    private Image _mbColor;
    private Slider _fanSpeed;

    public Sprite[] learnModelButtonImg;
    public Sprite[] trainModelButtonImg;
    public Sprite[] bugModelButtonImg;

    private Button _learnButton;
    private Button _trainButton;
    private Button _faultButton;

    private IT_TrainModelType _currentType;

    private GameObject messagePanel;
    private Text nameText;
    private Text messageText;

    private const string message1 =
        "UPS整机柜是UPS系统的主体框架，通常采用封闭的金属箱体设计，内含UPS的所有主要组件。这个整机柜的设计目的在于提供良好的散热和物理保护，以确保UPS系统在运行过程中能够正常工作。通常，整机柜的外形设计符合标准机架或机柜的尺寸，以方便在数据中心或其他机房环境中的安装。整机柜不仅提供了电子元件的支撑结构，还有助于维护UPS系统的整体性能。";

    private const string message2 =
        "外置电池模块是连接到UPS系统的可拆卸电池单元。这些电池模块的主要功能是存储电能，以在电网电力中断时提供必要的电力备份，确保设备在与电网断开连接时仍能继续运行。这些模块通常具有较大的电力容量，使得UPS系统能够提供长时间的备份电力。外置电池模块的串联连接能够提供更大的电力容量，并且它们的自由拆卸设计使得电池的更换和维护更加便捷。";

    private const string message3 =
        "UPS配电箱是用于管理和分配电力的设备。这个设备通常包括多个电源输出插口，用于连接到设备，以确保UPS提供的电力能够有效地传递到相应的设备。UPS配电箱还可能包含电力保护和过滤功能，确保连接的设备免受电力波动和干扰的影响。它在维护电力质量方面起到了关键作用，为用户提供可靠的电力输出。";

    private const string message4 =
        "整机柜液晶控制屏是安装在UPS整机柜上的液晶屏幕，用于显示UPS系统的状态信息、电力参数和配置选项。通过这个屏幕，用户可以实时监控UPS的性能，了解电力输入和输出的状况，以及进行必要的配置和设置。整机柜液晶控制屏提供了用户友好的界面，使得UPS系统的监控和管理变得更加直观和方便。";

    private const string message5 =
        "UPS（不间断电源）是整个系统的核心组件，包括电源转换器、逆变器、控制电路等。UPS的主要功能是在电网电力中断时提供临时的电力，以保持连接设备的正常运行。电源转换器将交流电转换为直流电来充电蓄电池，而逆变器将蓄电池的直流电转换为设备所需的交流电。控制电路负责监测电力输入和输出，以确保UPS系统的稳定运行。";

    private const string message6 =
        "一些UPS系统集成了内置蓄电池，用于提供短期的电力备份。这些蓄电池通常设计为维持设备运行一段时间，直到外部电池模块连接或直接供电可以恢复。内置蓄电池通常安装在UPS系统的机箱内部，具有紧凑的设计，以节省空间。它们为UPS系统提供了一种快速响应电力中断的手段，确保设备在关键时刻不会失去电力支持。";

    private float randomUpdateTime = 0;
    private float cpuValue;
    private float ramValue;

    bool haveFixed = false;

    private GameObject tarinList;
    private Button trainB1;
    private Button trainB2;
    private Button trainB3;

    private GameObject faultList;
    private Button faultB1;
    private Button faultB2;

    private Button faultB3;

    //$$$
    public Button[] faultButtons;
    public GameObject faultChoicePanel;
    public GameObject[] faultChoices;

    public GameObject[] fusedFaultTips;
    public GameObject[] uspGoneFaultTips;
    public GameObject[] Fault3_Tips;


    private RectTransform faultTools;
    private GameObject faultSelectButtons;
    private Power_FaultToolList faultToolList;

    private Button upsButton;
    private Button bxsButton;
    private Button dcButton;
    private Button plButton;


    protected override void OnInit(object userData)
    {
        base.OnInit(userData);

        _trainPanel = this.transform.Find("trainPanel").gameObject;
        _learnPanel = this.transform.Find("learnPanel").gameObject;
        _faultPanel = this.transform.Find("faultPanel").gameObject;
        InItUiComponent();
        InitFaultTips();
    }

    protected override void OnOpen(object userData)
    {
        base.OnOpen(userData);
        _trainDoneTips.SetActive(false);
        //_cpuButton.GetComponentInChildren<Text>().text = "CPU";
        //_fanButton.GetComponentInChildren<Text>().text = "风冷";
        //_powerButton.GetComponentInChildren<Text>().text = "电源";
        //_ramButton.GetComponentInChildren<Text>().text = "内存";
        //GameMain.Event.Subscribe(ReStart_IT_TrainStudyEvent.EventId,ReSetTrainUI);
        GameMain.Event.Subscribe(IT_TrainStudyDoneEvent.EventId, OnIT_TrainStudyDone);
        GameMain.Event.Subscribe(Ele_TrainStudyShowTargetInfoEvent.EventId, ChangeTargetMessage);
        GameMain.Event.Subscribe(Power_FaultNextEvent.EventId, OnGetPower_FaultNext);

        _learnPanel.SetActive(true);
        _trainPanel.SetActive(false);
        _learnButton.image.sprite = learnModelButtonImg[1];
        _trainButton.image.sprite = trainModelButtonImg[0];
        _faultButton.image.sprite = bugModelButtonImg[0];

        ChangeToLearn(true, 0.1f);

        tarinList.SetActive(false);
        //_currentType = IT_TrainModelType.learn;
        //GameMain.Event.Fire(this,IT_StartLearnTargetInfoEvent.Create());
    }

    protected override void OnUpdate(float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(elapseSeconds, realElapseSeconds);
    }

    private void InItUiComponent()
    {
        _trainDoneTips = _trainPanel.transform.Find("DoneTips").gameObject;
        _trainDoneTips.SetActive(false);

        messagePanel = _learnPanel.transform.Find("messagePanel").gameObject;
        messagePanel.SetActive(false);
        nameText = messagePanel.transform.Find("nameText").GetComponent<Text>();
        messageText = messagePanel.transform.Find("messageText").GetComponent<Text>();

        _faultDoneTips = _faultPanel.transform.Find("DoneTips").gameObject;
        _faultDoneTips.SetActive(false);

        _faultPanel.SetActive(false);
        _reStartButton = _trainPanel.transform.Find("TrainButton/Verlist/reStartButton").GetComponent<Button>();


        _reStartButton.onClick.AddListener(() => { GameMain.Event.Fire(this, ReStart_IT_TrainStudyEvent.Create()); });


        _learnButton = this.transform.Find("Navi/B1").GetComponent<Button>();
        _learnButton.onClick.AddListener(() => { ChangeToLearn(true, 0.1f); });
        _trainButton = this.transform.Find("Navi/B2").GetComponent<Button>();
        _trainButton.onClick.AddListener(ChangeToTrain);
        _faultButton = this.transform.Find("Navi/B3").GetComponent<Button>();
        _faultButton.onClick.AddListener(() => { ChangeToFault(); });


        tarinList = this.transform.Find("Navi/trainlist").gameObject;
        trainB1 = this.transform.Find("Navi/trainlist/B1").GetComponent<Button>();
        trainB2 = this.transform.Find("Navi/trainlist/B2").GetComponent<Button>();
        trainB3 = this.transform.Find("Navi/trainlist/B3").GetComponent<Button>();

        trainB1.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, Ele_TrainAniEvent.Create(1));
            tarinList.SetActive(false);
        });

        trainB2.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, Ele_TrainAniEvent.Create(2));
            tarinList.SetActive(false);
        });
        
        trainB3.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, Ele_TrainAniEvent.Create(3));
            tarinList.SetActive(false);
        });


        tarinList.SetActive(false);

        faultList = this.transform.Find("Navi/faultlist").gameObject;
        faultB1 = this.transform.Find("Navi/faultlist/B1").GetComponent<Button>();
        faultB2 = this.transform.Find("Navi/faultlist/B2").GetComponent<Button>();

        faultB3 = this.transform.Find("Navi/faultlist/B3").GetComponent<Button>();


        faultB1.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, Power_FaultStartEvent.Create(Power_FaultType.fused));
            faultList.SetActive(false);
        });

        faultB2.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, Power_FaultStartEvent.Create(Power_FaultType.UspGone));
            faultList.SetActive(false);
        });

        faultB3.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, Power_FaultStartEvent.Create(Power_FaultType.dc));
            faultList.SetActive(false);
        });

        //$$$------------------------
        faultChoicePanel = this.transform.Find($"faultChoicePanel").gameObject;
        faultChoices = new GameObject[8];
        for (int i = 0; i < 8; i++)
        {
            faultChoices[i] = this.transform.Find($"faultChoicePanel/BG/Quest_{i + 1}").gameObject;
            faultChoices[i].SetActive(false);
        }

        faultChoicePanel.SetActive(false);

        faultButtons = new Button[7];
        for (int i = 0; i < 7; i++)
        {
            faultButtons[i] = this.transform.Find($"Navi/faultlist/B{i + 4}").GetComponent<Button>();
        }

        faultButtons[0].onClick.AddListener(() => { faultChoicesClick(0); });
        faultButtons[1].onClick.AddListener(() => { faultChoicesClick(1); });
        faultButtons[2].onClick.AddListener(() => { faultChoicesClick(2); });
        faultButtons[3].onClick.AddListener(() => { faultChoicesClick(3); });
        faultButtons[4].onClick.AddListener(() => { faultChoicesClick(4); });
        faultButtons[5].onClick.AddListener(() => { faultChoicesClick(5); });
        faultButtons[6].onClick.AddListener(() => { faultChoicesClick(6); });

        faultChoicePanel.SetActive(false);
        //$$$------------------------

        faultList.SetActive(false);
    }

    //$$$------------------------
    private void faultChoicesClick(int index)
    {
        foreach (var obj in fusedFaultTips)
        {
            obj.SetActive(false);
        }
        foreach (var obj in uspGoneFaultTips)
        {
            obj.SetActive(false);
        }
        foreach (var obj in Fault3_Tips)
        {
            obj.SetActive(false);
        }

        faultList.SetActive(false);

        foreach (var objs in faultChoices)
        {
            objs.SetActive(false);
        }

        GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(index));
        faultChoices[index].SetActive(true);
        faultChoicePanel.SetActive(true);
        faultList.SetActive(false);
    }


    private void InitFaultTips()
    {
        uspGoneFaultTips = new GameObject[6];
        for (int i = 0; i < uspGoneFaultTips.Length; i++)
        {
            uspGoneFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step1_{i}").gameObject;
            uspGoneFaultTips[i].SetActive(false);
        }

        fusedFaultTips = new GameObject[8];
        for (int i = 0; i < fusedFaultTips.Length; i++)
        {
            fusedFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step2_{i}").gameObject;
            fusedFaultTips[i].SetActive(false);
        }

        Fault3_Tips = new GameObject[6];
        for (int i = 0; i < Fault3_Tips.Length; i++)
        {
            Fault3_Tips[i] = _faultPanel.transform.Find($"Doc/BG/Step3_{i}").gameObject;
            Fault3_Tips[i].SetActive(false);
        }

        faultTools = _faultPanel.transform.Find($"Tools").GetComponent<RectTransform>();
        faultTools.localPosition = new Vector3(1120, 0, 0);

        faultSelectButtons = _faultPanel.transform.Find($"FixButton").gameObject;


        upsButton = _faultPanel.transform.Find("FixButton/Verlist/upsButton").GetComponent<Button>();
        bxsButton = _faultPanel.transform.Find("FixButton/Verlist/bxsButton").GetComponent<Button>();
        dcButton = _faultPanel.transform.Find("FixButton/Verlist/dcButton").GetComponent<Button>();
        plButton = _faultPanel.transform.Find("FixButton/Verlist/plButton").GetComponent<Button>();

        upsButton.onClick.AddListener(() => { GameMain.Event.Fire(this, Power_SelectFaultItemEvent.Create(Power_FaultType.UspGone)); });
        bxsButton.onClick.AddListener(() => { GameMain.Event.Fire(this, Power_SelectFaultItemEvent.Create(Power_FaultType.fused)); });
        dcButton.onClick.AddListener(() => { GameMain.Event.Fire(this, Power_SelectFaultItemEvent.Create(Power_FaultType.dc)); });
        plButton.onClick.AddListener(() => { GameMain.Event.Fire(this, Power_SelectFaultItemEvent.Create(Power_FaultType.pl)); });


        faultSelectButtons.SetActive(false);

        faultToolList = faultTools.GetComponent<Power_FaultToolList>();
    }

    protected override void OnClose(bool isShutdown, object userData)
    {
        base.OnClose(isShutdown, userData);
        //GameMain.Event.Unsubscribe(ReStart_IT_TrainStudyEvent.EventId,ReSetTrainUI);
        GameMain.Event.Unsubscribe(IT_TrainStudyDoneEvent.EventId, OnIT_TrainStudyDone);
        GameMain.Event.Unsubscribe(Ele_TrainStudyShowTargetInfoEvent.EventId, ChangeTargetMessage);
        GameMain.Event.Unsubscribe(Power_FaultNextEvent.EventId, OnGetPower_FaultNext);
    }

    private async void ChangeToLearn(bool force = false, float delayTime = 0.0f)
    {
        tarinList.SetActive(false);
        _faultDoneTips.SetActive(false);
        faultList.SetActive(false);
        if (_currentType == IT_TrainModelType.learn && !force)
            return;


        if (SceneManager.GetActiveScene().name != "TrainStudy4_1")
            SceneManager.LoadScene("TrainStudy4_1");


        await Task.Delay((int)(delayTime * 1000));
        //GameMain.Event.Fire(this,IT_TrainStudyStateEvent.Create(false));
        GameMain.Event.Fire(this, Ele_StartLearnTargetInfoEvent.Create());
        _currentType = IT_TrainModelType.learn;
        _learnButton.image.sprite = learnModelButtonImg[1];
        _trainButton.image.sprite = trainModelButtonImg[0];
        _faultButton.image.sprite = bugModelButtonImg[0];
        _trainPanel.SetActive(false);
        _learnPanel.SetActive(true);
        _faultPanel.SetActive(false);
        //$$$------------------------
        faultChoicePanel.SetActive(false);
    }

    private void ChangeToTrain()
    {
        faultList.SetActive(false);
        tarinList.SetActive(true);
        if (_currentType == IT_TrainModelType.train)
            return;
        _learnPanel.SetActive(false);
        _faultPanel.SetActive(false);
        _learnButton.image.sprite = learnModelButtonImg[0];
        _trainButton.image.sprite = trainModelButtonImg[1];
        _faultButton.image.sprite = bugModelButtonImg[0];
        _currentType = IT_TrainModelType.train;

        if (SceneManager.GetActiveScene().name != "TrainStudy4")
            SceneManager.LoadScene("TrainStudy4");
        //_trainPanel.SetActive(true);
        //$$$------------------------
        faultChoicePanel.SetActive(false);
    }


    private void ChangeToFault(bool force = false)
    {
        tarinList.SetActive(false);
        faultList.SetActive(true);
        if (_currentType == IT_TrainModelType.fault && !force)
            return;
        GameMain.Event.Fire(this, Ele_TrainStudyStateEvent.Create(false));
        GameMain.Event.Fire(this, Ele_StartLearnTargetInfoEvent.Create(false));
        _learnButton.image.sprite = learnModelButtonImg[0];
        _trainButton.image.sprite = trainModelButtonImg[0];
        _faultButton.image.sprite = bugModelButtonImg[1];
        _faultPanel.SetActive(true);
        _trainPanel.SetActive(false);
        _learnPanel.SetActive(false);
        _currentType = IT_TrainModelType.fault;
        _faultPanel.transform.Find($"Doc").gameObject.SetActive(false);
        _faultPanel.transform.Find($"FixButton").gameObject.SetActive(false);
        _faultPanel.transform.Find($"Tools").GetComponent<RectTransform>().localPosition = new Vector3(1120, 0, 0);
        if (SceneManager.GetActiveScene().name != "TrainStudy4_2" || force)
            SceneManager.LoadScene("TrainStudy4_2");
        //$$$------------------------
        faultChoicePanel.SetActive(false);
    }

    private void ResetFaultPanel()
    {
        _faultDoneTips.SetActive(false);
        haveFixed = false;
        DOTween.Kill("_fanSpeed");
        DOTween.Kill("_mbTemperature");
        DOTween.Kill("_hardDiskTemperature");
        //_overHotTips.SetActive(true);
        _mbTemperature.value = 9;
        _mbTemperature.DOValue(8, 0.8f).SetLoops(-1, LoopType.Yoyo).SetId("_mbTemperature");
        _hardDiskTemperature.value = 9;
        _hardDiskTemperature.DOValue(8, 1.2f).SetLoops(-1, LoopType.Yoyo).SetId("_hardDiskTemperature");
        _fanSpeed.value = 0;
        _hardDiskColor.color = Color.red;
        _mbColor.color = Color.red;
    }

    private void FixFault(ITHardWaryType type)
    {
        switch (type)
        {
            case ITHardWaryType.cpu:

                break;
            case ITHardWaryType.fan:

                break;
            case ITHardWaryType.ram:

                break;
            case ITHardWaryType.power:

                break;
            case ITHardWaryType.none:
                break;
        }
    }

    private void ChangeTargetMessage(object sender, GameEventArgs e)
    {
        Ele_TrainStudyShowTargetInfoEvent args = (Ele_TrainStudyShowTargetInfoEvent)e;
        switch (args._Type)
        {
            case EleHardWaryType.PDG:
                nameText.text = "UPS整机柜";
                messageText.text = message1;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case EleHardWaryType.DCG:
                nameText.text = "外置电池模块";
                messageText.text = message2;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case EleHardWaryType.PDX:
                nameText.text = "UPS配电箱";
                messageText.text = message3;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case EleHardWaryType.YJP:
                nameText.text = "液晶控制屏";
                messageText.text = message4;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case EleHardWaryType.UPS:
                nameText.text = "UPS";
                messageText.text = message5;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case EleHardWaryType.DC:
                nameText.text = "UPS内置电池";
                messageText.text = message6;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case EleHardWaryType.none:
                messagePanel.SetActive(false);
                break;
        }
    }


    private void ReSetTrainUI(object sender, GameEventArgs e)
    {
        _trainDoneTips.SetActive(false);
        //_cpuButton.GetComponentInChildren<Text>().text = "CPU";
        //_fanButton.GetComponentInChildren<Text>().text = "风冷";
        //_powerButton.GetComponentInChildren<Text>().text = "电源";
        //_ramButton.GetComponentInChildren<Text>().text = "内存";
        //cpuDone = false;
        //fanDone = false;
        //ramDone = false;
        //powerDone = false;
    }

    private void OnIT_TrainStudyDone(object sender, GameEventArgs e)
    {
        //Debug.Log(11111111111);
        _faultDoneTips.SetActive(true);
        ChangeToFault(true);
        //GameMain.UI.OpenUIForm("Tips", "Pop");
    }

    private void OnGetPower_FaultNext(object sender, GameEventArgs e)
    {
        Power_FaultNextEvent args = (Power_FaultNextEvent)e;
        _faultPanel.transform.Find($"Doc").gameObject.SetActive(true);
        switch (args.FaultType)
        {
            case Power_FaultType.fused:
                for (int i = 0; i < uspGoneFaultTips.Length; i++)
                {
                    uspGoneFaultTips[i].SetActive(false);
                }


                uspGoneFaultTips[args.stepIndex].SetActive(true);
                if (args.stepIndex == 0)
                {
                    for (int i = 0; i < fusedFaultTips.Length; i++)
                    {
                        fusedFaultTips[i].SetActive(false);
                    }

                    foreach (var t in Fault3_Tips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(1);
                }
                else
                {
                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
            case Power_FaultType.UspGone:
                for (int i = 0; i < fusedFaultTips.Length; i++)
                {
                    fusedFaultTips[i].SetActive(false);
                }

                fusedFaultTips[args.stepIndex].SetActive(true);

                if (args.stepIndex == 0)
                {
                    for (int i = 0; i < uspGoneFaultTips.Length; i++)
                    {
                        uspGoneFaultTips[i].SetActive(false);
                    }

                    foreach (var t in Fault3_Tips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(0);
                }
                else
                {
                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
            case Power_FaultType.dc:
                for (int i = 0; i < Fault3_Tips.Length; i++)
                {
                    Fault3_Tips[i].SetActive(false);
                }

                Fault3_Tips[args.stepIndex].SetActive(true);
                if (args.stepIndex == 0)
                {
                    for (int i = 0; i < uspGoneFaultTips.Length; i++)
                    {
                        uspGoneFaultTips[i].SetActive(false);
                    }

                    for (int i = 0; i < fusedFaultTips.Length; i++)
                    {
                        fusedFaultTips[i].SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(0);
                }
                else
                {
                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
        }
    }
}