garden_client/Assets/Script/Manage/ManaData.cs

using LitJson;

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using UnityEngine.EventSystems;

using System;
using System.Xml;
using System.Collections;
using System.Collections.Generic;

public class ManaData : Regist 
{
    #region 变量

    #region 成就

    public static double TotalPerson
    {
        get { return TotalPerson_; }
        set
        {
            TotalPerson_ = value;

            ManaAchieve.UpdateStatus(AchieveType.TotalPerson, TotalPerson_);
        }
    }
    public static double ElfLevel
    {
        get { return ElfLevel_; }
        set
        {
            ElfLevel_ = value;

            ManaAchieve.UpdateStatus(AchieveType.ElfLevel, ElfLevel_);
        }
    }
    public static double AdAmt
    {
        get { return AdAmt_; }
        set
        {
            AdAmt_ = value;

            ManaAchieve.UpdateStatus(AchieveType.AdAmt, AdAmt_);
        }
    }
    public static double SkillAmt
    {
        get { return SkillAmt_; }
        set
        {
            SkillAmt_ = value;

            ManaAchieve.UpdateStatus(AchieveType.SkillAmt, SkillAmt_);
        }
    }
    public static double SignAmt
    {
        get { return SignAmt_; }
        set
        {
            SignAmt_ = value;

            ManaAchieve.UpdateStatus(AchieveType.SignAmt, SignAmt_);
        }
    }
    public static double ShareAmt
    {
        get { return ShareAmt_; }
        set
        {
            ShareAmt_ = value;

            ManaAchieve.UpdateStatus(AchieveType.ShareAmt, ShareAmt_);
        }
    }
    public static double TotalCoin
    {
        get { return TotalCoin_; }
        set
        {
            TotalCoin_ = value;

            ManaAchieve.UpdateStatus(AchieveType.TotalCoin, TotalCoin_);
        }
    }
    public static double MiniGameAmt
    {
        get { return MiniGameAmt_; }
        set
        {
            MiniGameAmt_ = value;

            ManaAchieve.UpdateStatus(AchieveType.MiniGameAmt, MiniGameAmt_);
        }
    }
    public static double FlowerCoin
    {
        get { return FlowerCoin_; }
        set
        {
            FlowerCoin_ = value;
            
            ManaAchieve.UpdateStatus(AchieveType.FlowerCoin, FlowerCoin_);
        }
    }

    private static double TotalPerson_;
    private static double ElfLevel_;
    private static double AdAmt_;
    private static double SkillAmt_;
    private static double SignAmt_;
    private static double ShareAmt_;
    private static double MiniGameAmt_;
    private static double TotalCoin_;
    private static double FlowerCoin_;

    #endregion

    public static int Level
    {
        get { return Level_; }
        set
        {
            Level_ = value;
            
            ManaDebug.Log(string.Format("已升级 花园等级 : <color=red>{0}</color>", Level_));

            ManaAchieve.UpdateStatus(AchieveType.GardenLevel, Level_);

            for (int i = 0; i < SkillList.Count; i++)
            {
                SkillList[i].UpdateStatus();
            }

            if (TabBtnValid == false)
            {
                if (Level_ >= 1)
                {
                    TabBtnValid = true;

                    ManaReso.Get<Graphic>("F_Elf").material = null;
                    ManaReso.Get<Graphic>("F_Store").material = null;
                    ManaReso.Get<Graphic>("F_Magic").material = null;

                    ManaReso.Get<Graphic>("F_ElfLab").material = null;
                    ManaReso.Get<Graphic>("F_StoreLab").material = null;
                    ManaReso.Get<Graphic>("F_MagicLab").material = null;

                    ManaReso.Get<Button>("F_Elf").interactable = true;
                    ManaReso.Get<Button>("F_Store").interactable = true;
                    ManaReso.Get<Button>("F_Magic").interactable = true;
                }
            }

            if (Level_ >= 20)
            {
                if (ManaTutorial.TutorialC_)
                {
                    ManaTutorial.PrepareStepC1();
                }
                else
                {
                    ManaReso.SetActive("C_Visit", true);
                }
            }

            //if (Level_ >= 200)
            //{
            //    if (ManaTutorial.TutorialB_)
            //    {
            //        ManaTutorial.TutorialB = true;

            //        ManaTutorial.PrepareStepB1();
            //    }
            //}
        }
    }
    public static bool Pause
    {
        get { return Pause_; }
        set
        {
            Pause_ = value;

            if (Pause_)
            {
                Time.timeScale = 0;

                ManaDebug.Log("<color=red>游戏暂停</color>");
            }
            else
            {
                Time.timeScale = 1;

                ManaDebug.Log("<color=red>游戏继续</color>");
            }
        }
    }
    public static float Person
    {
        get { return Person_; }
        set
        {
            Person_ = value;

            ManaReso.SetText("F_PersonLab", Mathf.FloorToInt(60*(Person_ * (1 + SkillPersonBuff_) + SkillPerson_)).ToString());
        }
    }
    public static float SkillPerson
    {
        get { return SkillPerson_; }
        set
        {
            SkillPerson_ = value;
           
            if (SkillPerson_.Equal(0))
            {
                ManaReso.Get("F_PersonLab").GetTweenOutline().Pause();

                ManaReso.Get<Outline>("F_PersonLab").enabled = false;
            }
            else
            {
                Tween tween = ManaReso.Get("F_PersonLab").GetTweenOutline();

                if (tween.InForward)
                {
                    tween.StartForward();
                }
                else if (tween.InBackward)
                {
                    tween.StartBackward();
                }
                else
                {
                    tween.StartForward();
                }
            }

            ManaReso.SetText("F_PersonLab", Mathf.FloorToInt(60*(Person_ * (1 + SkillPersonBuff_) + SkillPerson_)).ToString());
        }
    }
    public static float CoinPerson
    {
        get { return CoinPerson_; }
        set
        {
            CoinPerson_ = value;

            ManaReso.SetText("F_CoinPersonLab", Mathf.FloorToInt(CoinPerson_ + SkillCoinPerson_).ToString());
        }
    }
    public static float SkillPersonBuff
    {
        get { return SkillPersonBuff_; }
        set
        {
            SkillPersonBuff_ = value;

            ManaReso.SetText("F_PersonLab", Mathf.FloorToInt(60 * (Person_ * (1 + SkillPersonBuff_) + SkillPerson_)).ToString());
        }
    }
    public static float SkillCoinPerson
    {
        get { return SkillCoinPerson_; }
        set
        {
            SkillCoinPerson_ = value;

            if (SkillCoinPerson_.Equal(0))
            {
                ManaReso.Get("F_CoinPersonLab").GetTweenOutline().Pause();

                ManaReso.Get<Outline>("F_CoinPersonLab").enabled = false;
            }
            else
            {
                Tween tween = ManaReso.Get("F_CoinPersonLab").GetTweenOutline();

                if (tween.InForward)
                {
                    tween.StartForward();
                }
                else if (tween.InBackward)
                {
                    tween.StartBackward();
                }
                else
                {
                    tween.StartForward();
                }
            }

            ManaReso.SetText("F_CoinPersonLab", Mathf.FloorToInt(CoinPerson_ + SkillCoinPerson_).ToString());
        }
    }
    public static double Coin
    {
        get { return Coin_; }
        set
        {
            if (value - Coin_ > 0)
            {
                TotalCoin += value - Coin_;
            }

            Coin_ = value;
            
            ManaReso.SetText("F_CoinLab", Auxiliary.ShrinkNumberStr(Coin_, 0));
            ManaReso.SetText("C_CoinLab", Auxiliary.ShrinkNumberStr(Coin_, 0));
            
            ManaAchieve.UpdateStatus(AchieveType.CurrentCoin, Coin_);
        }
    }
    public static double Diamond
    {
        get { return Diamond_; }
        set
        {
            Diamond_ = value;

            ManaReso.SetText("F_DiamondLab", Auxiliary.ShrinkNumberStr(Diamond_, 0));
        }
    }

    private static int Level_;
    private static bool Pause_;
    private static float Person_;
    private static float CoinPerson_;
    private static double Coin_;
    private static double Diamond_;

    public static bool Reset;
    public static bool MiniValid;
    public static bool FirstFrame = true;
    public static bool OfflineValid;
    public static bool TabBtnValid;
    public static bool ReactiveRequest;
    public static bool InitiateComplete;
    public static float Elapse;
    public static float OpTimer;
    public static float MiniTimer;
    public static float SaveTimer;
    public static float LoginTimer;
    public static float CircleTime = 10;
    public static float CircleTimer;
    public static float NewPerson;
    public static float NewCoinPerson;
    public static string OfflineFml;
    public static double MaxCoin;
    public static double MaxTime;

    public static float SkillPlus;
    public static float SkillPerson_;
    public static float SkillPersonBuff_;
    public static float SkillCoinPerson_;

    public static DateTime QuitTime;
    public static ManaData Instance;
    public static List<Skill> UseList = new List<Skill>();
    public static List<Skill> CoolList = new List<Skill>();
    public static List<Skill> FFCoolList = new List<Skill>();
    public static List<SkillRoot> SkillList = new List<SkillRoot>();
    public static List<List<Skill>> FFUseList = new List<List<Skill>>();
    public static Dictionary<string, SkillRoot> SkillDic = new Dictionary<string, SkillRoot>();

    #endregion

    private void Update()
    {
        if (ManaTutorial.TutorialA)
        {
            return;
        }

        OperateThread();
    }

    private void FixedUpdate()
    {
        if (ManaTutorial.TutorialA)
        {
            LoginThread();

            return;
        }

        SkillThread();

        MiniThread();

        MiniThread();

        SaveThread();

        LoginThread();

        IncomeThread();
    }


    private void SkillThread()
    {
        for (int i = 0; i < UseList.Count; i++)
        {
            if (UseList[i].DoUse())
            {
                UseList.RemoveAt(i--);
            }
        }

        for (int i = 0; i < CoolList.Count; i++)
        {
            if (CoolList[i].DoCool())
            {
                CoolList.RemoveAt(i--);
            }
        }
    }

    private void MiniThread()
    {
        if (Pause)
        {
            return;
        }

        if (MiniValid == false)
        {
            MiniTimer -= Time.deltaTime;

            if (MiniTimer < 0)
            {
                MiniValid = true;
                
                ManaReso.Get("C_MiniGame").TweenForCG();
            }
        }
    }

    private void SaveThread()
    {
        SaveTimer += Time.fixedDeltaTime;

        if (SaveTimer >= 60)
        {
            SaveTimer = 0;

            ManaServer.Save();
        }
    }

    private void LoginThread()
    {
        LoginTimer += Time.fixedDeltaTime;

        if (LoginTimer >= 10)
        {
            LoginTimer = 0;

            ManaServer.Login();
        }
    }

    private void IncomeThread()
    {
        CircleTimer -= Time.deltaTime;
        
        if (CircleTimer < 0)
        {
            CircleTimer = CircleTime;

            NewPerson = Person * (1 + SkillPersonBuff) + SkillPerson;
            NewCoinPerson = CoinPerson + SkillCoinPerson;

            TotalPerson += NewPerson * CircleTime;

            float temp = (NewPerson * NewCoinPerson * CircleTime) * (1 + SkillPlus);

            Coin += temp;

            ManaReso.Get("C_IncomeLab").TweenForGra();
            ManaReso.Get("C_IncomeLab").TweenForVec();
            ManaReso.SetText("C_IncomeLab", "+" + temp.ToString("0.0"));

            ManaDebug.Log(string.Format("参观收益<color=red>{0:0.0}</color> = <color=red>{1}</color> * <color=red>{2}</color> * <color=red>{3}</color> * <color=red>{4}</color> (人次*金币*时间*加成)", temp, NewPerson, NewCoinPerson, CircleTime, 1 + SkillPlus));
        }
    }

    private void OperateThread()
    {
        if (Pause)
        {
            return;
        }
        
        if (Auxiliary.AnyKeyUp)
        {
            OpTimer = 0;

            ManaReso.Get("C_Group").TweenForCG();
        }
        else
        {
            OpTimer += Time.deltaTime;

            if (OpTimer >= 60)
            {
                OpTimer = 0;

                ManaReso.Get("C_Group").TweenBacCG();
            }
        }
    }


    public static void Reload()
    {
        Reset = false;
        TabBtnValid = false;

        Person = 0;
        CoinPerson = 0;

        SkillPlus = 0;
        SkillPerson = 0;
        SkillPersonBuff_ = 0;
        SkillCoinPerson = 0;

        SaveTimer = 0;

        UseList = new List<Skill>();
        CoolList = new List<Skill>();
        
        Instance.RegistValueB();

        ManaTutorial.TutorialB_ = Data.GetPlayerBool("TutorialB");
        ManaTutorial.TutorialIndexB = Data.GetPlayerInt("TutorialIndexB");

        for (int i = 0; i < SkillList.Count; i++)
        {
            Ability ability = SkillList[i] as Ability;

            if (ability != null)
            {
                ability.ValidSlot = true;
            }
        }

        RegistSkill();
        RegistIncome();

        if (ManaServer.Connect)
        {
            if (!ManaTutorial.TutorialA && !ManaTutorial.TutorialB)
            {
                ManaReso.Get("B_SignIn").TweenForCG();
            }
        }
    }

    public override void Reactive()
    {
        foreach (var kv in SkillDic)
        {
            kv.Value.Reactive();
        }

        RegistSkill();
        RegistIncome();
        
        if (OfflineValid)
        {
            if (!ManaTutorial.TutorialA && !ManaTutorial.TutorialB)
            {
                ManaReso.Get("C_Group").TweenBacCG();

                ManaReso.Get("B_SignIn").TweenForCG();
                ManaReso.Get("Ba_Notice").TweenForCG();
            }
        }
    }

    public override void Instantiate()
    {
        #region 生成技能条

        #region 读技能配置

        List<XmlAttributeCollection> attributeList = Data.GetSkillConfig();

        for (int i = 0; i < attributeList.Count; i++)
        {
            SkillRoot skillRoot;

            #region MyRegion

            if (attributeList[i].Count == 17)
            {
                skillRoot = new Pack(attributeList[i]);
            }
            else if (attributeList[i].Count == 23)
            {
                skillRoot = new Ability(attributeList[i]);
            }
            else if (attributeList[i].Count == 33)
            {
                if (string.IsNullOrEmpty(attributeList[i][4].Value))
                {
                    skillRoot = new Skill(attributeList[i]);
                }
                else
                {
                    skillRoot = new BigSkill(attributeList[i]);
                }
            }
            else
            {
                throw new Exception(attributeList[i].Count.ToString());
            }

            #endregion

            SkillDic.Add(skillRoot.ID, skillRoot);
            SkillList.Add(skillRoot);
        }

        SkillList.Sort(SkillRoot.Sort);

        #endregion

        for (int i = 0; i < SkillList.Count; i++)
        {
            if (SkillList[i].SkillTab != SkillTab.Null)
            {
                ManaReso.GetSkillItem(SkillList[i]);
            }
        }

        #endregion
    }

    public override void RegistValueB()
    {
        Instance = this;

        ManaReso.Get<Graphic>("F_Elf").material = ManaReso.Load<Material>("GrayMat", Folder.Effect);
        ManaReso.Get<Graphic>("F_Store").material = ManaReso.Load<Material>("GrayMat", Folder.Effect);
        ManaReso.Get<Graphic>("F_Magic").material = ManaReso.Load<Material>("GrayMat", Folder.Effect);

        ManaReso.Get<Graphic>("F_ElfLab").material = ManaReso.Load<Material>("GrayMat", Folder.Effect);
        ManaReso.Get<Graphic>("F_StoreLab").material = ManaReso.Load<Material>("GrayMat", Folder.Effect);
        ManaReso.Get<Graphic>("F_MagicLab").material = ManaReso.Load<Material>("GrayMat", Folder.Effect);

        ManaReso.Get<Button>("F_Elf").interactable = false;
        ManaReso.Get<Button>("F_Store").interactable = false;
        ManaReso.Get<Button>("F_Magic").interactable = false;

        Coin = Data.GetPlayerDouble("Coin");
        Diamond = Data.GetPlayerDouble("Diamond");
        MiniTimer = Data.GetPlayerFloat("MiniTimer");
        CircleTimer = Data.GetPlayerFloat("CircleTimer");

        ManaServer.ID = Data.GetPlayerString("ID");

        ManaDebug.Log(string.Format("<color=red>{0:0}</color>秒后激活小游戏", MiniTimer));


        List<string> offlineList = Data.GetOfflineConfig();

        MaxCoin = Auxiliary.LongParse(offlineList[2], 999999999999999999);
        MaxTime = Auxiliary.LongParse(offlineList[1], 999999999999999999);
        OfflineFml = offlineList[0];

        List<double> dataList = Data.GetAchieveData();

        AdAmt = dataList[0];
        ElfLevel = dataList[4];
        SkillAmt = dataList[1];
        SignAmt = dataList[2];
        ShareAmt = dataList[3];
        FlowerCoin = dataList[6];
        TotalPerson = dataList[7];
        MiniGameAmt = dataList[5];
    }


    public static void RegistSkill()
    {
        OfflineValid = false;

        if (ManaServer.Connect && Data.GetPlayerBool("QuitFlag"))
        {
            QuitTime = DateTime.Parse(Data.GetPlayerString("QuitTime"));

            Elapse = (float)ManaServer.Time.Subtract(QuitTime).TotalSeconds;

            ManaDebug.Log(string.Format("真实离线时间<color=red>{0}</color>", Elapse));

            if (Elapse <= 120)
            {
                Elapse = 0;
            }
            else
            {
                OfflineValid = true;
            }

            if (Elapse > MaxTime)
            {
                Elapse = (long)MaxTime;
            }
        }

        ManaDebug.Log(string.Format("计算离线时间<color=red>{0}</color>", Elapse));

        FFUseList = new List<List<Skill>>();
        FFCoolList = new List<Skill>();

        if (Elapse > CircleTimer)
        {
            int circle = 1 + Mathf.FloorToInt((Elapse - CircleTimer) / CircleTime);

            for (int i = 0; i < circle; i++)
            {
                FFUseList.Add(new List<Skill>());
            }

            ManaDebug.Log(string.Format("离线周期<color=red>{0}</color>", circle));
        }
        else
        {
            ManaDebug.Log(string.Format("离线周期<color=red>{0}</color>", 0));
        }

        List<XmlAttributeCollection> attributeList = Data.GetSkillList();

        for (int i = 0; i < attributeList.Count; i++)
        {
            SkillRoot skillRoot = SkillDic[attributeList[i][0].Value];

            skillRoot.RegistReference();

            skillRoot.RegistValue(Elapse, FFUseList, attributeList[i]);
        }

        Level = Data.GetPlayerInt("Level");
    }

    public static void RegistIncome()
    {
        double coin = 0;
        
        if (FFUseList.Count > 0)
        {
            for (int i = 0; i < FFUseList.Count; i++)
            {
                for (int j = 0; j < FFCoolList.Count; j++)
                {
                    FFCoolList[j].CoolTimer -= CircleTime;
                }

                for (int j = 0; j < FFUseList[i].Count; j++)
                {
                    FFUseList[i][j].Annul();

                    FFCoolList.Add(FFUseList[i][j]);
                }

                NewPerson = Person * (1 + SkillPersonBuff_) + SkillPerson;
                NewCoinPerson = CoinPerson + SkillCoinPerson;

                TotalPerson += NewPerson * CircleTime;

                coin += (NewPerson * NewCoinPerson * CircleTime) * (1 + SkillPlus);
            }
            
            CircleTimer = (Elapse - CircleTimer) % CircleTime;

            for (int j = 0; j < FFCoolList.Count; j++)
            {
                FFCoolList[j].CoolTimer -= CircleTime - CircleTimer;
            }

            coin = (long) Auxiliary.FmlParse(OfflineFml, "c", coin.ToString());

            if (coin > MaxCoin)
            {
                coin = MaxCoin;
            }

            Coin += coin;

            ManaReso.SetText("Ba_IconLab", coin.ToString("0"));
        }
        else
        {
            CircleTimer = CircleTimer - Elapse;

            ManaReso.SetText("Ba_IconLab", "0");
        }
    }

    public static void SwitchLanguage()
    {
        Coin = Coin;
        Diamond = Diamond;
    }

    public static void Pay(string id, double amt, Current current, UnityAction callback, bool navigate = true)
    {
        if (ManaTutorial.PayExempt)
        {
            callback.Invoke();

            return;
        }

        amt = Auxiliary.ShrinkNumber(amt);

        if (current == Current.Free)
        {
            callback.Invoke();
        }
        else if (current == Current.AD)
        {
            ManaIAP.PlayAd(callback);
        }
        else if (current == Current.Cash)
        {
            ManaIAP.Purchase(id);
        }
        else if (current == Current.Coin)
        {
            #region MyRegion

            if (Coin >= amt)
            {
                Coin -= amt;

                callback.Invoke();
            }
            else
            {
                ManaReso.Get("Fe_Info").TweenBacCG();

                if (navigate)
                {
                    Bubble.Show
                    (
                        Language.GetStr("Common", "ShortCoin"),
                        Language.GetStr("Common", "NavigateCoin"),
                        ManaReso.LoadSprite("金币"),
                        () =>
                        {
                            Tween tween = ManaReso.Get("K_Bubble0").GetTweenScale();

                            tween.AddEventOnetime
                            (
                                EventType.BackwardFinish,
                                () =>
                                {
                                    ManaReso.Get<Button>("F_Magic").onClick.Invoke();

                                    Auxiliary.Instance.DelayCall
                                    (
                                        () =>
                                        {
                                            int index = ManaReso.Get("Fb_Grid").childCount - 1;

                                            ManaReso.Get<ScrollRect>("Fb_Scrr").Locate(index, 0.25f, Curve.EaseOutQuad, LocatePos.Down);
                                        },
                                        1
                                    );
                                }
                            );
                        }
                    );
                }
                else
                {
                    Bubble.Show
                    (
                        Language.GetStr("Common", "ShortCoin"),
                        null,
                        ManaReso.LoadSprite("金币")
                    );
                }
            }

            #endregion
        }
        else if (current == Current.Diamond)
        {
            #region MyRegion

            if (Diamond >= amt)
            {
                Diamond -= amt;

                callback.Invoke();
            }
            else
            {
                ManaReso.Get("Fe_Info").TweenBacCG();

                if (navigate)
                {
                    Bubble.Show
                    (
                        Language.GetStr("Common", "ShortDiamond"),
                        Language.GetStr("Common", "NavigateDiamond"),
                        ManaReso.LoadSprite("钻石"),
                        () =>
                        {
                            Tween tween = ManaReso.Get("K_Bubble0").GetTweenScale();

                            tween.AddEventOnetime
                            (
                                EventType.BackwardFinish,
                                () =>
                                {
                                    ManaReso.Get<Button>("F_Store").onClick.Invoke();

                                    Auxiliary.Instance.DelayCall
                                    (
                                        () =>
                                        {
                                            int index = ManaReso.Get("Fc_Grid").childCount - 1;

                                            ManaReso.Get<ScrollRect>("Fc_Scrr").Locate(index, 0.25f, Curve.EaseOutQuad, LocatePos.Down);
                                        },
                                        1
                                    );
                                }
                            );
                        }
                    );
                }
                else
                {
                    Bubble.Show
                    (
                        Language.GetStr("Common", "ShortDiamond"),
                        null,
                        ManaReso.LoadSprite("钻石")
                    );
                }
            }

            #endregion
        }
        else
        {
            throw new Exception(current.ToString());
        }
    }


    public static void LoginCallbackInitial(JsonData jsonData)
    {
        if (!Initializer.Complete || !ManaServer.Complete)
        {
            return;
        }

        if (ManaServer.Connect)
        {
            if (Data.GetPlayerString("ID") == "Default")
            {
                ManaServer.ID = ManaServer.JsonData["o"].ToString();

                ManaReso.SetText("L_UserLab", ManaServer.ID);
            }
        }

        RegistSkill();
        RegistIncome();

        if (OfflineValid)
        {
            if (!ManaTutorial.TutorialA)
            {
                ManaReso.Get("B_SignIn").TweenForCG();
                ManaReso.Get("Ba_Notice").TweenForCG();
            }
        }
        else
        {
            if (!ManaTutorial.TutorialA)
            {
                int daySpan = ManaServer.Time.Day - ManaSign.SignTime.Day;
                int yearSpan = ManaServer.Time.Year - ManaSign.SignTime.Year;
                int monthSpan = ManaServer.Time.Month - ManaSign.SignTime.Month;

                if (daySpan >= 1 || yearSpan >= 1 || monthSpan >= 1)
                {
                    ManaReso.Get("B_SignIn").TweenForCG();
                    ManaReso.Get("Bb_SignIn").TweenForCG();
                }
            }
        }

        InitiateComplete = true;

        Level = Level;
    }

    public static void LoginCallbackReactive(JsonData jsonData)
    {
        ReactiveRequest = false;

        for (int i = 0; i < Initializer.RegistList.Count; i++)
        {
            Initializer.RegistList[i].Reactive();
        }
    }


    public static void DownloadArchive()
    {
        ManaReso.SetText("La_Lab", "连接中");

        ManaReso.SetActive("La_Lab", true);
        ManaReso.SetActive("La_Mask", true);

        string id = ManaReso.Get<InputField>("La_InputField").text;

        ManaServer.Load(id, DownloadCallback);
    }

    public static void DownloadCallback(JsonData jsonData)
    {
        if (jsonData.Inst_Object.Keys.Contains("l"))
        {
            ManaReso.SetActive("La_Mask", false);

            ManaReso.SetText("La_Lab", Language.GetStr("UI", "La_Lab0"));

            int version = Data.GetPlayerInt("Version");

            Data.PlayerDoc.LoadXml(jsonData["l"].ToString());
            Data.PlayerNode = Data.PlayerDoc.SelectSingleNode("PlayerConfig");

            Data.SavePlayerInt("Version", version);


            ManaReso.SetText("L_UserLab", Data.GetPlayerString("ID"));

            ManaServer.ID = Data.GetPlayerString("ID");

            ManaMiniGame.MiniGameIndex = Data.GetPlayerInt("MiniGameIndex");


            Garden.Reload();

            ManaGarden.Reload();

            Reload();
            
            ManaAchieve.Reload();

            ManaPlayer.Reload();

            ManaSign.Reload();

            ManaReso.Get("La_Info").TweenBacCG();
        }
        else
        {
            ManaReso.SetText("La_Lab", Language.GetStr("UI", "La_Lab1"));

            ManaReso.SetActive("La_Mask", false);
        }
    }


    public void OnApplicationQuit()
    {
        if (Initializer.Complete && !Reset)
        {
            Data.SavePlayerConfig();
            Data.SaveXml();
        }
    }

    public void OnApplicationPause(bool pause)
    {
        if (pause)
        {
            Data.SavePlayerConfig();
            Data.SaveXml();
        }
        else
        {
            if (FirstFrame)
            {
                FirstFrame = false;
            }
            else
            {
                if (!Initializer.Complete)
                {
                    return;
                }

                ManaVisit.DataRecover();

                if (ReactiveRequest)
                {
                    return;
                }

                Auxiliary.DecryptXml(Data.PlayerDoc);

                ReactiveRequest = true;

                ManaServer.Login(LoginCallbackReactive);
            }
        }
    }
}