garden_client/Assets/Script/SFS/Manager/ChestMge.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using Sfs2X.Entities.Data;
using UnityEngine;
using UnityEngine.UI;
using Random = UnityEngine.Random;

public class ChestData
{
    #region Config

    public int Value;
    public int Round;
    public int RemainValue;
    public int RemainRound;
    public int DatabaseRoomID;
    public long ID;
    public long Owner;
    public DateTime ActivatedTime;
    public ChestType ChestType;
    public Vector3 Position;

    public static int SystemRoomDatabaseID = 1;

    private static bool Initialized;
    //private static float XMin;
    //private static float XMax;
    //private static float YMin;
    //private static float YMax;
    private static Vector3 DefaultPosition;
    //private static Vector3 ChestDepthOffset = new Vector3(0, 0, 0.98f);
    private static Vector3 ChestDepthOffset = new Vector3(0, 0, 1.040916f);

    #endregion

    public ChestData(ISFSObject arg)
    {
        if (!Initialized)
        {
            Initialize();
        }

        ID = arg.GetLong(gd_chest.ID);
        Value = arg.GetInt(gd_chest.Value);
        Round = arg.GetInt(gd_chest.Round);
        RemainValue = arg.GetInt(gd_chest.RemainValue);
        RemainRound = arg.GetInt(gd_chest.RemainRound);
        DatabaseRoomID = arg.GetInt(gd_chest.DatabaseRoomID);
        Owner = arg.GetLong(gd_chest.Owner);
        ActivatedTime = DateUtil.GetTimeFromSecends(arg.GetLong(gd_chest.ActivatedTime).ToString());
        ChestType = (ChestType) arg.GetInt(gd_chest.Type);

        Vector3 defaultPosition = DefaultPosition + ChestDepthOffset;
        if (arg.ContainsKey(gd_chest.Position))
        {
            string vectorStr = arg.GetUtfString(gd_chest.Position);
            if (vectorStr == "null")
            {
                Position = defaultPosition;
            }
            else
            {
                Position = arg.GetUtfString(gd_chest.Position).StringToVector() + ChestDepthOffset;
            }
        }
        else
        {
            Position = defaultPosition;
        }
    }

    private static void Initialize()
    {
        Initialized = true;
        DefaultPosition = ManaReso.Get("PlazaRoomChestPos").position;
        //XMin = ManaReso.Get("ChestLowerLeft").position.x;
        //YMin = ManaReso.Get("ChestLowerLeft").position.y;
        //XMax = ManaReso.Get("ChestUpperRight").position.x;
        //YMax = ManaReso.Get("ChestUpperRight").position.y;
    }
}

public class ChestOperateData
{
    public long ChestID;
    public bool Received;
    public int DatabaseRoomID;
    public int? RemainGuessAmt;
    public DateTime? LastActivatedTime; //只有系统宝箱才用

    public ChestOperateData(string str)
    {
        string[] strings = str.Split('|');
        ChestID = long.Parse(strings[0]);
        DatabaseRoomID = int.Parse(strings[1]);
        Received = int.Parse(strings[2]).ToBool();
        if (strings.Length > 3)
        {
            RemainGuessAmt = int.Parse(strings[3]);
        }
        if (strings.Length > 4)
        {
            LastActivatedTime = DateTime.Parse(strings[4]);
        }
    }

    public ChestOperateData(bool received, long chestID, int databaseRoomID)
    {
        Received = received;
        ChestID = chestID;
        DatabaseRoomID = databaseRoomID;
    }

    public override string ToString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.Append(ChestID);
        stringBuilder.Append("|" + DatabaseRoomID);
        stringBuilder.Append("|" + Received.ToInt());
        if (RemainGuessAmt != null)
        {
            stringBuilder.Append("|" + RemainGuessAmt);
        }
        if (LastActivatedTime != null)
        {
            stringBuilder.Append("|" + LastActivatedTime);
        }
        return stringBuilder.ToString();
    }
}


public class ChestMge : Regist
{
    #region Config

    public static int PlayerMaxGuessAmt = 3;

    private static Text Desc;
    private static Text BtnLab;
    private static Text SliderValueLab;
    private static Slider Slider;
    private static Button Btn;
    private static Button GuessBtn;
    private static InputField InputField;
    private static InputField GuessInputField;

    private static string RefundNodeName = "Refund";
    private static string ReceivedNodeName = "Received";

    public static List<PlazaRoomChest> PlazaRoomChests = new List<PlazaRoomChest>();

    public static List<int> RefundRoomIDs = new List<int>();
    public static Dictionary<long, ChestOperateData> OperateDataDictionary = new Dictionary<long, ChestOperateData>();

    #endregion

    public override void RegistValueA()
    {
        XmlNodeList RefundNodes = ManaData.PlayerNode.SelectNodes(RefundNodeName);
        XmlNodeList ReceivedNodes = ManaData.PlayerNode.SelectNodes(ReceivedNodeName);
        for (int i = 0; i < RefundNodes.Count; i++)
        {
            RefundRoomIDs.Add(int.Parse(RefundNodes[i].InnerText));
        }
        for (int i = 0; i < ReceivedNodes.Count; i++)
        {
            //Debug.Log(ReceivedNodes[i].InnerText);
            ChestOperateData chestOperateData = new ChestOperateData(ReceivedNodes[i].InnerText);
            OperateDataDictionary.Add(chestOperateData.ChestID, chestOperateData);
        }
        //foreach (var VARIABLE in RefundRoomIDs)
        //{
        //    Debug.LogWarning("refund " + VARIABLE);
        //}
        //foreach (var VARIABLE in ChestRoomDictionary)
        //{
        //    Debug.LogWarning("received " + VARIABLE.Key);
        //}
        CheckRefund();
        GetChestExpireStatus();
    }

    public override void RegistReference()
    {
        Btn = ManaReso.Get<Button>("Yb_Btn");
        GuessBtn = ManaReso.Get<Button>("Y_Btn");
        Desc = ManaReso.Get<Text>("Yb_Desc");
        Slider = ManaReso.Get<Slider>("Yb_Slider");
        BtnLab = ManaReso.Get<Text>("Yb_BtnLab");
        InputField = ManaReso.Get<InputField>("Yb_InputField");
        GuessInputField = ManaReso.Get<InputField>("Y_InputField");
        SliderValueLab = ManaReso.Get<Text>("Yb_SliderValueLab");

        GuessInputField.onValueChanged.AddListener(OnGuessInputValueChange);
        OnGuessInputValueChange(null);
    }


    public static void OnGuessInputValueChange(string value)
    {
        if (string.IsNullOrEmpty(value))
        {
            GuessBtn.image.material = Lib.GrayMat;
            GuessBtn.interactable = false;
        }
        else
        {
            GuessBtn.image.material = null;
            GuessBtn.interactable = true;
        }
    }


    public static void OpenCreatePanel()
    {
        ManaReso.Get("Y_Chest").TweenForCG();
        ManaReso.SetActive("Ya_GetAward", false);
        ManaReso.SetActive("Y_Guess", false);
        ManaReso.SetActive("Yb_CreateChest", true);
        OnSliderValueChange(Slider.value);
        OnInputValueChange(InputField.text);
        Slider.value = 1;
        Slider.maxValue = SFSManager.GardenSmartFox.PlazaRoomManager.CurrentRoomData.MaxPlayer;
    }

    public static void CloseChestPanel()
    {
        ManaReso.Get("Y_Chest").TweenBacCG();
    }

    public static void OnLuckyToggle(bool enable)
    {
        if (enable)
        {
            ChestType = ChestType.Lucky;
            ManaLan.Add(Desc, new LanStr("UI", "Yb_LuckyDesc"));
        }
    }

    public static void OnColorToggle(bool enable)
    {
        if (enable)
        {
            ChestType = ChestType.GuessColor;
            ManaLan.Add(Desc, new LanStr("UI", "Yb_GuessColorDesc"));
        }
    }

    public static void OnNumberToggle(bool enable)
    {
        if (enable)
        {
            ChestType = ChestType.GuessNumber;
            ManaLan.Add(Desc, new LanStr("UI", "Yb_GuessNumberDesc"));
        }
    }

    public static void OnInputValueChange(string value)
    {
        if (string.IsNullOrEmpty(value) || int.Parse(value) < 20)
        {
            Btn.interactable = false;
            Btn.image.material = Lib.GrayMat;
            ManaLan.Add(BtnLab, new LanStr("UI", "Yb_Minimum"));
            return;
        }

        Cost = int.Parse(value);
        ManaReso.SetText("Yb_CostLab", Language.GetStr("UI", "AA_Cost") + "<(钻石)>" + Cost);
        if (ManaCenter.Diamond < Cost)
        {
            Btn.interactable = false;
            Btn.image.material = Lib.GrayMat;
            ManaLan.Add(BtnLab, new LanStr("Common", "ShortDiamond"));
        }
        else
        {
            Btn.interactable = true;
            Btn.image.material = null;
            ManaLan.Add(BtnLab, new LanStr("Common", "Confirm"));
        }
    }

    public static void OnSliderValueChange(float value)
    {
        Round = (int) value;
        SliderValueLab.text = Round + Language.GetStr("UI", "Yb_SliderValueLab");
    }


    private static int Cost;
    private static int Round;
    private static float ChestXMinOffset = 1;
    private static float ChestXMaxOffset = 2;
    private static ChestType ChestType = ChestType.Lucky;
    public static void CreateChest()
    {
        ManaLan.Add(ManaReso.Get<Text>("Y_Tip"), new LanStr("UI", "AA_SendRequest"));
        ManaReso.Get("Y_Tip").TweenForCG();

        int databaseRoomID = SFSManager.GardenSmartFox.PlazaRoomManager.CurrentRoomData.ID;
        long serialNumber = long.Parse(ManaServer.SerialNumber);
        Vector3 position = PlayerPosToChestPos(SFSManager.GardenSmartFox.PlazaRoomManager.SelfInstance.Player.transform.position);
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.CreateChest(Round, Cost, ChestType, databaseRoomID, serialNumber, position);

        ManaReso.Get<CanvasGroup>("Y_Chest").interactable = false;
    }

    public static Vector3 PlayerPosToChestPos(Vector3 playerPos)
    {
        return playerPos + Mathf.Sign(Random.Range(-1f, 1f))*new Vector3(Random.Range(ChestXMinOffset, ChestXMaxOffset), 0, 0);
    }

    public static void OnCreateChestError()
    {
        ManaLan.Add(ManaReso.Get<Text>("Y_Tip"), new LanStr("UI", "AA_CreateError"));
        ManaReso.Get("Y_Tip").TweenBacCG();

        ManaReso.Get<CanvasGroup>("Y_Chest").interactable = true;
    }

    public static void OnCreateChestSucceed()
    {
        ManaCenter.CreateChestAmt++;
        if (ChestType == ChestType.Lucky)
        {
            ManaCenter.CreateLuckyChestAmt++;
        }
        else if (ChestType == ChestType.GuessColor)
        {
            ManaCenter.CreateGuessColorChestAmt++;
        }
        else if (ChestType == ChestType.GuessNumber)
        {
            ManaCenter.CreateGuessNumberChestAmt++;
        }

        ManaLan.Add(ManaReso.Get<Text>("Y_Tip"), new LanStr("UI", "AA_CreateSucceed"));
        ManaReso.Get("Y_Tip").TweenBacCG();

        ManaReso.Get<CanvasGroup>("Y_Chest").interactable = true;

        ManaCenter.AddDiamond(-Cost, StaticsManager.ItemID.创建宝箱, StaticsManager.ConsumeModule.Charge);
        CloseChestPanel();
    }

    public static void OnReceiveNewChest(ChestData chestData)
    {
        if (!SFSManager.GardenSmartFox.PlazaRoomManager.JoinedPlazaRoom)
        {
            return;
        }

        ManaAudio.PlayClip(Clip.BubbleClip);

        InstantiateChest(chestData);

        if (chestData.Owner == long.Parse(ManaServer.SerialNumber))
        {
            if (SFSManager.GardenSmartFox.PlazaRoomManager.CurrentRoomData.ID != ChestData.SystemRoomDatabaseID)
            {
                RefundRoomIDs.UniqueAdd(SFSManager.GardenSmartFox.PlazaRoomManager.CurrentRoomData.ID);
            }
        }
    }

    private static void CheckRefund()
    {
        if (RefundRoomIDs.Count == 0)
        {
            return;
        }
        else
        {
            SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.CheckChestRefund(RefundRoomIDs);
        }
    }


    private static void GetChestExpireStatus()
    {
        if (OperateDataDictionary.Keys.Count == 0)
        {
            return;
        }

        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.GetChestExpireStatus(OperateDataDictionary.Keys.ToList());
    }

    public static void OnReceiveChestExpireStatus(List<long> chestIDs)
    {
        foreach (var chestID in chestIDs)
        {
            //Debug.LogWarning("expire " + chestID);
            OperateDataDictionary.Remove(chestID);
        }
    }


    public static void RetrieveAllChest()
    {
        foreach (var plazaRoomChest in PlazaRoomChests)
        {
            plazaRoomChest.RetriveChest();
        }
        PlazaRoomChests = new List<PlazaRoomChest>();
    }

    private static void InstantiateChest(ChestData chestData)
    {
        if (chestData.ChestType != ChestType.System)
        {
            if (chestData.RemainRound <= 0 || chestData.RemainValue <= 0)
            {
                return;
            }

            ChestOperateData chestOperateData;
            OperateDataDictionary.TryGetValue(chestData.ID, out chestOperateData);

            if (chestOperateData == null || chestOperateData.Received == false)
            {
                PlazaRoomChest chest = ManaReso.GetPlazaRoomChest(chestData.Position);
                chest.Init(chestData);
                PlazaRoomChests.Add(chest);

                if (chestOperateData == null || chestOperateData.RemainGuessAmt == null || chestOperateData.RemainGuessAmt > 0)
                {
                    chest.Active();
                    chest.TurnNormalColor();
                }
                else
                {
                    chest.Deactive();
                    chest.TurnGray();
                }
            }
        }
        else
        {
            PlazaRoomChest chest = ManaReso.GetPlazaRoomChest(chestData.Position);
            chest.SystemChestInit(chestData);
            PlazaRoomChests.Add(chest);
        }
    }

    private static int SystemChestActivateTimespan = 600;
    public static void ReceiveAllChestData(List<ChestData> chestDatas)
    {
        ManaAudio.PlayClip(Clip.BubbleClip);

        foreach (var chestData in chestDatas)
        {
            InstantiateChest(chestData);
        }
    }

    public static void ActivateSystemChest(DateTime activatedTime)
    {
        if (!SFSManager.GardenSmartFox.PlazaRoomManager.JoinedPlazaRoom)
        {
            return;
        }

        if (PlazaRoomChest.SystemChest == null)
        {
            return;
        }

        if (OperateDataDictionary.Keys.Contains(PlazaRoomChest.SystemChest.ChestData.ID))
        {
            if (activatedTime.Subtract(OperateDataDictionary[PlazaRoomChest.SystemChest.ChestData.ID].LastActivatedTime.Value).TotalSeconds >= SystemChestActivateTimespan)
            {
                ReactivateSystemChest(activatedTime);
            }
            return;
        }

        PlazaRoomChest.SystemChest.Active();
        PlazaRoomChest.SystemChest.TurnNormalColor();
        PlazaRoomChest.SystemChest.ChestTimerTransform.TweenBacCG();
    }

    public static void ReactivateSystemChest(DateTime activatedTime)
    {
        if (!SFSManager.GardenSmartFox.PlazaRoomManager.JoinedPlazaRoom)
        {
            return;
        }

        if (PlazaRoomChest.SystemChest == null)
        {
            return;
        }

        OperateDataDictionary.Remove(PlazaRoomChest.SystemChest.ChestData.ID);
        PlazaRoomChest.SystemChest.Active();
        PlazaRoomChest.SystemChest.TurnNormalColor();
        PlazaRoomChest.SystemChest.ChestTimerTransform.TweenBacCG();
        PlazaRoomChest.SystemChest.LastActivatedTime = activatedTime;
    }

    public static void DeactivateSystemChest(long pasttime)
    {
        if (!SFSManager.GardenSmartFox.PlazaRoomManager.JoinedPlazaRoom)
        {
            return;
        }

        if (PlazaRoomChest.SystemChest == null)
        {
            return;
        }

        PlazaRoomChest.SystemChest.Deactive();
        PlazaRoomChest.SystemChest.TurnGray();
        PlazaRoomChest.SystemChest.ChestTimer = PlazaRoomChest.SystemChest.ChestTime - pasttime + 1;
    }

    public static void ReceiveChestAward(int award, long chestID)
    {
        ChestOperateData chestOperateData;
        if (OperateDataDictionary.TryGetValue(chestID, out chestOperateData))
        {
            chestOperateData.Received = true;
        }
        else
        {
            chestOperateData = new ChestOperateData(true, PlazaRoomChest.CurrentChest.ChestData.ID, PlazaRoomChest.CurrentChest.ChestData.DatabaseRoomID);
            OperateDataDictionary.Add(chestOperateData.ChestID, chestOperateData);
        }

        ManaReso.Get<CanvasGroup>("Y_Chest").interactable = true;

        if (award <= 0)
        {
            ManaReso.Get("Y_Chest").TweenBacCG();

            Bubble.Show(null, Language.GetStr("UI", "Y_SoldOut"));
        }
        else
        {
            ManaAudio.PlayClip(Clip.CurrentClip);

            ManaReso.Get("Y_Chest").TweenForCG();
            ManaReso.SetActive("Ya_GetAward", true);
            ManaReso.SetActive("Y_Guess", false);
            ManaReso.SetActive("Yb_CreateChest", false);

            ManaReso.SetText("Ya_Desc", $"x{award}");
            ManaCenter.AddDiamond(award, StaticsManager.ItemID.获得钻石, StaticsManager.ConsumeModule.RoomChestAward);

            ManaCenter.GetChestAwardAmt++;
        }

        for (int i = 0; i < PlazaRoomChests.Count; i++)
        {
            if (PlazaRoomChests[i].ChestData.ID == chestID)
            {
                if (PlazaRoomChests[i].ChestData.ChestType == ChestType.System)
                {
                    PlazaRoomChests[i].ResetChestTimer();
                    OperateDataDictionary[chestID].RemainGuessAmt = 0;
                    OperateDataDictionary[chestID].LastActivatedTime = PlazaRoomChests[i].LastActivatedTime;
                }
                else
                {
                    PlazaRoomChests[i].RetriveChest();
                    PlazaRoomChests.RemoveAt(i--);
                }
            }
        }
    }

    public static void ReceiveChestRefund(int refund, List<int> databaseRoomIDs)
    {
        foreach (var databaseRoomID in databaseRoomIDs)
        {
            RefundRoomIDs.Remove(databaseRoomID);
        }

        if (refund > 0)
        {
            ManaCenter.AddDiamond(refund, StaticsManager.ItemID.获得钻石, StaticsManager.ConsumeModule.RoomChestRefund);
            ManaInfoBox.Show(InfoCategory.Garden, Language.GetStr("UI", "Y_Refund")+refund, 10, Color.white);
        }
    }

    public static void Save()
    {
        ClearRefundAndOperateData(ManaData.PlayerNode);

        foreach (var id in RefundRoomIDs)
        {
            XmlNode node = ManaData.PlayerDoc.CreateNode(XmlNodeType.Element, RefundNodeName, null);
            node.InnerText = id.ToString();
            ManaData.PlayerNode.AppendChild(node);
        }
        foreach (var kv in OperateDataDictionary)
        {
            XmlNode node = ManaData.PlayerDoc.CreateNode(XmlNodeType.Element, ReceivedNodeName, null);
            node.InnerText = kv.Value.ToString();
            ManaData.PlayerNode.AppendChild(node);
            //Debug.LogWarning($"{kv.Key}|{kv.Value}");
        }
    }

    public static void ClearRefundAndOperateData(XmlNode playerConfigNode)
    {
        XmlNode node = playerConfigNode.SelectSingleNode(RefundNodeName);
        while (node != null)
        {
            playerConfigNode.RemoveChild(node);
            node = playerConfigNode.SelectSingleNode(RefundNodeName);
        }
        node = playerConfigNode.SelectSingleNode(ReceivedNodeName);
        while (node != null)
        {
            playerConfigNode.RemoveChild(node);
            node = playerConfigNode.SelectSingleNode(ReceivedNodeName);
        }
    }
}