garden_client/Assets/Script/Manage/EnterMinigamePanelManager.cs

using System.Collections;
using System.Collections.Generic;
using System.Xml;
using UnityEngine;
using UnityEngine.UI;

public class EnterMinigamePanelManager : Regist
{
    #region Config

    private static Text Title;
    private static Text CostText;
    private static Text ChangeButtonTitle;
    private static Text ConfirmButtonTitle;
    private static Text MinigameTypeText0;
    private static Text MinigameTypeText1;
    private static Button ChangeButton;
    private static Button CloseButton;
    private static Button ConfirmButton;
    private static Transform PanelMask;
    private static Transform ScrollPos0;
    private static Transform ScrollPos1;
    private static Transform ScrollPos2;

    private static string ChangeGameTypeCostFormula;
    private static double ChangeGameTypeCost;

    private static bool IsChangingGameType;
    private static float ScrollTime = 3f;
    private static float ScrollTimer;
    private static float CurrentScrollDuration;
    private static float MaxScrollDecreaseRatio = 0.05f;
    private static float CurrentScrollDecreaseRatio;
    private static TweenVec MinigameTypeTextTween0;
    private static TweenVec MinigameTypeTextTween1;
    private static MiniGameType ScrollMiniGameType;
    private static List<MiniGameType> AvailableGameTypes = new List<MiniGameType>();

    public static MiniGameType CurrentMiniGameType;

    #endregion

    private void Init()
    {
        XmlDocument document = ConfigManager.GetXmlDocument(ResourceLabel.MinigameConfig);
        ChangeGameTypeCostFormula = document.SelectSingleNode(ConfigLabel.RootNode).SelectSingleNode(ConfigLabel.ChildNode).Attributes[1].Value;
    }

    public override void RegistReference()
    {
        Title = ResourceManager.Get<Text>(CanvasLabel.AC_Title);
        CostText = ResourceManager.Get<Text>(CanvasLabel.AC_CostText);
        ChangeButtonTitle = ResourceManager.Get<Text>(CanvasLabel.AC_ChangeButtonTitle);
        ConfirmButtonTitle = ResourceManager.Get<Text>(CanvasLabel.AC_ConfirmButtonTitle);
        MinigameTypeText0 = ResourceManager.Get<Text>(CanvasLabel.AC_GamaTypeText0);
        MinigameTypeText1 = ResourceManager.Get<Text>(CanvasLabel.AC_GamaTypeText1);
        ChangeButton = ResourceManager.Get<Button>(CanvasLabel.AC_ChangeButton);
        CloseButton = ResourceManager.Get<Button>(CanvasLabel.AC_CloseButton);
        ConfirmButton = ResourceManager.Get<Button>(CanvasLabel.AC_ConfirmButton);
        PanelMask = ResourceManager.Get(CanvasLabel.AC_EnterMinigamePanelMask);
        ScrollPos0 = ResourceManager.Get(CanvasLabel.AC_ScrollPos0);
        ScrollPos1 = ResourceManager.Get(CanvasLabel.AC_ScrollPos1);
        ScrollPos2 = ResourceManager.Get(CanvasLabel.AC_ScrollPos2);

        LanguageManager.Add(Title, new MulLanStr(LanguageLabel.UI__AC_Title));
        LanguageManager.Add(ChangeButtonTitle, new MulLanStr(LanguageLabel.UI__AC_ChangeButtonTitle));
        LanguageManager.Add(ConfirmButtonTitle, new MulLanStr(LanguageLabel.UI__AC_ConfirmButtonTitle));

        PanelMask.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
        CloseButton.onClick.AddListener(ClosePanel);
        ChangeButton.onClick.AddListener(() => Manager.Pay("", ChangeGameTypeCost, Current.Coin, ChangeGameType, StaticsManager.ItemID.更换小游戏类型, StaticsManager.ConsumeModule.Charge, false));
        ConfirmButton.onClick.AddListener(EnterGame);

        Init();
    }


    private void Update()
    {
        if (!IsChangingGameType)
        {
            return;
        }

        ScrollTimer += Time.deltaTime;
        CurrentScrollDecreaseRatio = Mathf.Lerp(CurrentScrollDecreaseRatio, MaxScrollDecreaseRatio, Time.deltaTime*3.5f);
        CurrentScrollDuration += Time.deltaTime * CurrentScrollDecreaseRatio;
        MinigameTypeTextTween0.Duration = CurrentScrollDuration;
        MinigameTypeTextTween1.Duration = CurrentScrollDuration;
    }


    public static void TryOpenPanel()
    {
        if (TutorialManager.NewplayerTutorial)
        {
            MinigameAward.UnlockFlowerID = 1;
            MinigameAward.HaveNewFlowerFlag = true;
            CurrentMiniGameType = MiniGameType.Punch;
            MiniGameManager.GameEnter(CurrentMiniGameType);
        }
        else if (TutorialManager.MemoryMinigameTutorial)
        {
            CurrentMiniGameType = MiniGameType.Memory;
            MiniGameManager.GameEnter(CurrentMiniGameType);
        }
        else if (TutorialManager.FindSoloMinigameTutorial)
        {
            CurrentMiniGameType = MiniGameType.FindSolo;
            MiniGameManager.GameEnter(CurrentMiniGameType);
        }
        else if (TutorialManager.FindMissingMinigameTutorial)
        {
            CurrentMiniGameType = MiniGameType.FindMissing;
            MiniGameManager.GameEnter(CurrentMiniGameType);
        }
        else
        {
            AvailableGameTypes = new List<MiniGameType>();
            CurrentMiniGameType = (MiniGameType)ConfigManager.GetIntFormConfig(PlayerConfigLabel.CurrentMinigameType);
            if (CurrentMiniGameType == MiniGameType.None)
            {
                CurrentMiniGameType = MiniGameManager.SelectMinigameType(AvailableGameTypes);
                ConfigManager.SaveIntToConfig(PlayerConfigLabel.CurrentMinigameType, CurrentMiniGameType.GetHashCode());
            }
            else
            {
                MiniGameManager.SelectMinigameType(AvailableGameTypes);
            }
            if (AvailableGameTypes.Count == 1)
            {
                MiniGameManager.GameEnter(CurrentMiniGameType);
            }
            else
            {
                OpenPanel();
            }
        }
    }

    public static void OpenPanel()
    {
        string languageLabel = LanguageLabel.CombineLanguageLabel(LanguageLabel.MinigameName, CurrentMiniGameType.ToString());
        MinigameTypeText0.text = Language.GetStr(languageLabel);
        MinigameTypeText1.text = Language.GetStr(languageLabel);
        ChangeGameTypeCost = Auxiliary.FmlParse(ChangeGameTypeCostFormula, "i", Manager.CircleIncome.ToString());
        CostText.text = $"{TransferLabel.CoinSprite}{Auxiliary.ShrinkNumberStr(ChangeGameTypeCost)}";
        PanelMask.TweenForCG();
    }

    public static void ClosePanel()
    {
        AudioManager.PlayClip(ResourceLabel.CloseClip);
        PanelMask.TweenBacCG();
    }

    public static void ChangeGameType()
    {
        AudioManager.PlayClip(ResourceLabel.BtnClip);

        ResetScrollStatus();

        if (MinigameTypeTextTween0 == null || MinigameTypeTextTween1 == null)
        {
            MinigameTypeText0.transform.position = ScrollPos0.position;
            MinigameTypeTextTween0 = MinigameTypeText0.CreateTweenVec2D(ScrollPos1.position, CurrentScrollDuration, false, true, true, Curve.Linear);
            MinigameTypeTextTween0.AddEventOnetime(EventType.ForwardFinish, () => OnArriveScrollPos1(MinigameTypeTextTween0));

            MinigameTypeText1.transform.position = ScrollPos1.position;
            MinigameTypeTextTween1 = MinigameTypeText1.CreateTweenVec2D(ScrollPos2.position, CurrentScrollDuration, false, true, true, Curve.Linear);
            MinigameTypeTextTween1.AddEventOnetime(EventType.ForwardFinish, () => OnArriveScrollPos2(MinigameTypeTextTween1));
        }

        MinigameTypeTextTween0.StartForward();
        MinigameTypeTextTween1.StartForward();
    }

    private static void ResetScrollStatus()
    {
        ScrollTimer = 0;
        CurrentScrollDuration = 0.1f;
        CurrentScrollDecreaseRatio = 0;
        ChangeButton.interactable = false;
        ConfirmButton.interactable = false;
        IsChangingGameType = true;
    }

    private static void OnArriveScrollPos1(TweenVec tween)
    {
        tween.Origin = ScrollPos1.position;
        tween.Destination = ScrollPos2.position;
        tween.InOrigin = true;
        tween.AddEventOnetime(EventType.ForwardFinish, () => OnArriveScrollPos2(tween));

        if (ScrollTimer + CurrentScrollDuration >= ScrollTime)
        {
            return;
        }
        else
        {
            tween.StartForward();
        }
    }

    private static void OnArriveScrollPos2(TweenVec tween)
    {
        tween.Origin = ScrollPos0.position;
        tween.Destination = ScrollPos1.position;
        tween.InOrigin = true;
        tween.AddEventOnetime(EventType.ForwardFinish, () => OnArriveScrollPos1(tween));

        //ScrollMiniGameType = AvailableGameTypes.Random()[0];
        //string languageLabel = LanguageLabel.CombineLanguageLabel(LanguageLabel.MinigameName, ScrollMiniGameType.ToString());
        //tween.Target.GetComponent<Text>().text = Language.GetStr(languageLabel);

        if (ScrollTimer + CurrentScrollDuration >= ScrollTime)
        {
            FinishScroll();
        }
        else
        {
            ScrollMiniGameType = AvailableGameTypes.Random()[0];
            string languageLabel = LanguageLabel.CombineLanguageLabel(LanguageLabel.MinigameName, ScrollMiniGameType.ToString());
            tween.Target.GetComponent<Text>().text = Language.GetStr(languageLabel);
            tween.StartForward();
        }
    }

    private static void FinishScroll()
    {
        ChangeButton.interactable = true;
        ConfirmButton.interactable = true;
        IsChangingGameType = false;
        CurrentMiniGameType = ScrollMiniGameType;
        ConfigManager.SaveIntToConfig(PlayerConfigLabel.CurrentMinigameType, ScrollMiniGameType.GetHashCode());
    }

    public static void EnterGame()
    {
        ClosePanel();
        MiniGameManager.GameEnter(CurrentMiniGameType);
    }
}