garden_client/Assets/Script/Object/PlazaRoomChest.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using DragonBones;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using Random = UnityEngine.Random;
using Transform = UnityEngine.Transform;

public class PlazaRoomChestLabel
{
    public static string Hud = "Hud";
}

public class PlazaRoomChest : MonoBehaviour, IPointerClickHandler
{
    #region Config

    public float ShakeTime = 5;
    public float ShakeTimer;
    public bool IsActive = true;

    public Animator Animator
    {
        get
        {
            if (Animator_ == null)
            {
                Animator_ = GetComponentInChildren<Animator>();
            }

            return Animator_;
        }
        set { Animator_ = value; }
    }
    public Animator Animator_;

    public ChestData ChestData;

    private string AnswerColor;
    private FlowerInfo AnswerInfo;

    public Text ChestTimerLab;
    public Transform ChestTimerTransform;
    public float ChestRefreshTime = 600;
    public float ChestRefreshTimer;
    public bool IsAwardAvailable;

    public DateTime LastActivatedTime; //只有系统宝箱才用

    public bool Inited;
    public MeshFilter ChestMF;
    public MeshFilter ShadowMF;
    public MeshRenderer ChestMR;
    public MeshRenderer ParentMR;
    public MeshRenderer ShadowMR;
    private Mesh ShadowMesh
    {
        get
        {
            if (shadowMesh == null)
            {
                shadowMesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(ResourceLabel.FlowerShadow, Folder.Scene));
                shadowMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), shadowMesh.vertices.Length).ToList());
            }

            return shadowMesh;
        }
    }
    private Mesh shadowMesh;
    private Mesh SystemMesh
    {
        get
        {
            if (systemMesh == null)
            {
                systemMesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(ResourceLabel.SystemChest, Folder.Scene));
                systemMesh.SetUVs(1, Enumerable.Repeat(new Vector2(1,1), systemMesh.vertices.Length).ToList());
                systemTexture = ResourceManager.LoadSprite(ResourceLabel.SystemChest, Folder.Scene).texture;
            }

            return systemMesh;
        }
    }
    private Mesh systemMesh;
    private Mesh LuckyMesh
    {
        get
        {
            if (luckyMesh == null)
            {
                luckyMesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(ResourceLabel.DiamondChest, Folder.Scene));
                luckyMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), luckyMesh.vertices.Length).ToList());
                luckyTexture = ResourceManager.LoadSprite(ResourceLabel.DiamondChest, Folder.Scene).texture;
            }

            return luckyMesh;
        }
    }
    private Mesh luckyMesh;
    private Mesh NumberMesh
    {
        get
        {
            if (numberMesh == null)
            {
                //foreach (var uv in ManaReso.LoadSprite("数字宝箱", Folder.Scene).uv)
                //{
                //    Debug.LogWarning(uv);
                //}
                //Debug.Log(ManaReso.LoadSprite("数字宝箱", Folder.Scene).texture.name);
                numberMesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(ResourceLabel.NumberChest, Folder.Scene));
                numberMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), numberMesh.vertices.Length).ToList());
                numberTexture = ResourceManager.LoadSprite(ResourceLabel.NumberChest, Folder.Scene).texture;
            }

            return numberMesh;
        }
    }
    private Mesh numberMesh;
    private Mesh ColorMesh
    {
        get
        {
            if (colorMesh == null)
            {
                colorMesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(ResourceLabel.FlowerChest, Folder.Scene));
                colorMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), colorMesh.vertices.Length).ToList());
                colorTexture = ResourceManager.LoadSprite(ResourceLabel.FlowerChest, Folder.Scene).texture;
            }

            return colorMesh;
        }
    }
    private Mesh colorMesh;
    private Texture2D systemTexture;
    private Texture2D luckyTexture;
    private Texture2D numberTexture;
    private Texture2D colorTexture;

    public TweenGrayMesh TweenGrayMesh;
    public TweenRenderer TweenRenderer;
    public TweenScale TweenScale;

    public static InputField GuessInputField;

    public static PlazaRoomChest SelectedChest;
    public static PlazaRoomChest SystemChest;

    #endregion

    public void Update()
    {
        if (!IsActive)
        {
            if (ChestData.ChestType == ChestType.System && !IsAwardAvailable)
            {
                if (ChestRefreshTimer <= 0)
                {
                    SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.CheckDefaultChestStatus(ChestData.DatabaseRoomID);
                    IsAwardAvailable = true;
                }
                else
                {
                    ChestRefreshTimer -= UnityEngine.Time.deltaTime;
                    ChestTimerLab.text = ChestRefreshTimer.ToString("F0");
                }
            }
        }
        else
        {
            ShakeTimer += UnityEngine.Time.deltaTime;

            if (ShakeTimer >= ShakeTime)
            {
                ShakeTimer = 0;

                Animator.SetInteger("Count", 0);
            }
        }
    }


    public void GetAward(string inputValue)
    {
        if (ChestData.ChestType == ChestType.System || ChestData.ChestType == ChestType.Lucky)
        {
            GetAward();
        }
        else
        {
            Guess(inputValue);
        }
    }

    private void GetAward()
    {
        Deactive();
        TurnGray();

        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.GetChestAward(ChestData.ID);

        if (ChestData.ChestType != ChestType.System)
        {
            SetColliders(false);
        }
    }

    private void Guess(string inputValue)
    {
        if (string.IsNullOrEmpty(inputValue))
        {
            GuessFailed();
        }
        else
        {
            inputValue = inputValue.ToLower();
            inputValue = inputValue.Trim();

            if (ChestData.ChestType == ChestType.GuessColor)
            {
                if (inputValue == AnswerColor)
                {
                    GuessSucceed();
                }
                else
                {
                    GuessFailed();
                }
            }
            else
            {
                int digit = ChestData.Value % 10;
                int guessNumber = int.Parse(inputValue);
                if (guessNumber == digit)
                {
                    GuessSucceed();
                }
                else
                {
                    GuessFailed();
                }
            }
        }
    }

    private void GuessFailed()
    {
        ChestOperateData chestOperateData;
        ChestManager.OperateDataDictionary.TryGetValue(SelectedChest.ChestData.ID, out chestOperateData);
        int remainGuessAmt;
        if (chestOperateData == null)
        {
            chestOperateData = new ChestOperateData(false, SelectedChest.ChestData.ID, SelectedChest.ChestData.DatabaseRoomID);
            ChestManager.OperateDataDictionary.UniqueAdd(chestOperateData.ChestID, chestOperateData);
            remainGuessAmt = ChestManager.PlayerMaxGuessAmt - 1;
        }
        else if (chestOperateData.RemainGuessAmt == null)
        {
            remainGuessAmt = ChestManager.PlayerMaxGuessAmt - 1;
        }
        else
        {
            remainGuessAmt = (int) chestOperateData.RemainGuessAmt - 1;
        }
        ChestManager.OperateDataDictionary[SelectedChest.ChestData.ID].RemainGuessAmt = remainGuessAmt;

        string hint = Language.GetStr(LanguageLabel.UI__Y_GuessWrong);
        hint = hint.Replace(TransferLabel.Value, remainGuessAmt.ToString());
        Bubble.Show(null, hint);

        if (remainGuessAmt <= 0)
        {
            ChestManager.CloseCreateChestPanel();
            Deactive();
            TurnGray();
        }
    }

    private void GuessSucceed()
    {
        ResourceManager.Get<CanvasGroup>(CanvasLabel.Y_Chest).interactable = false;
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.GetChestAward(ChestData.ID);
    }


    public void RetriveChest()
    {
        if (ChestData.ChestType == ChestType.System)
        {
            ResourceManager.Save(ChestTimerTransform);    
        }

        TweenRenderer.StartBackward();
    }


    public void Init(ChestData chestData)
    {
        BaseInit(chestData);

        if (chestData.ChestType == ChestType.GuessColor)
        {
            AnswerInfo = GardenManager.GetFlowerInfoDict().Random();
            AnswerColor = Language.GetStr(LanguageLabel.CombineLanguageLabel(LanguageLabel.FlowerColor, AnswerInfo.FullID)).ToLower();
        }
    }

    public void SystemChestInit(ChestData chestData)
    {
        BaseInit(chestData);

        Deactive();
        TurnGray();

        ChestTimerTransform = ResourceManager.Get(ResourceLabel.ChestTimer, Folder.UI, false, ResourceManager.Get(CanvasLabel.W_HudParent), false, ObjType.ChestTimer);
        ChestTimerLab = ChestTimerTransform.GetComponentInChildren<Text>();
        HudTarget hudTarget = ChestTimerTransform.GetComponent<HudTarget>();
        if (hudTarget == null)
        {
            hudTarget = ChestTimerTransform.AddComponent<HudTarget>();
            ChestTimerTransform.CreateTweenCG(0, 1, 0.25f, false, true, Curve.EaseOutQuad);
            PlazaRoom.ControllDepthDictionary.Add(transform, new List<Transform> {ChestTimerTransform});
        }
        hudTarget.PosTra = transform.parent.FindChild(PlazaRoomChestLabel.Hud);
        ResetChestRefreshTimer();
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.CheckDefaultChestStatus(chestData.DatabaseRoomID);

        SystemChest = this;
    }

    private void BaseInit(ChestData chestData)
    {
        ChestData = chestData;

        if (GuessInputField == null)
        {
            GuessInputField = ResourceManager.Get<InputField>(CanvasLabel.Y_InputField);
        }

        if (!Inited)
        {
            Inited = true;

            ParentMR = transform.parent.GetComponent<MeshRenderer>();
            ChestMF = transform.GetComponent<MeshFilter>();
            ChestMR = transform.GetComponent<MeshRenderer>();
            ShadowMF = transform.parent.GetChild(1).GetComponent<MeshFilter>();
            ShadowMR = transform.parent.GetChild(1).GetComponent<MeshRenderer>();

            ShadowMF.mesh = ShadowMesh;

            TweenRenderer = new TweenRenderer(ParentMR, new Color(1, 1, 1, 0), Color.white, 0.25f, true, true, Curve.EaseOutQuad, false, true);
            TweenRenderer.OnBackwardFinish = () => { ResourceManager.Save(transform.parent.gameObject); };

            TweenScale = transform.CreateTweenScale(0, 0.8f, 0.25f, false, true, Curve.EaseOutQuad);
            TweenScale.StartForward();
        }
        else
        {
            TweenScale.InOrigin = true;
            TweenScale.StartForward();
        }

        SetColliders(true);

        ParentMR.sharedMaterial = PlayerManager.Player.Material;
        ChestMR.sharedMaterial = PlayerManager.Player.Material;
        ShadowMR.sharedMaterial = PlayerManager.Player.Material;

        GetMesh(chestData.ChestType);

        TweenGrayMesh = new TweenGrayMesh(ChestMF, 1, 0, 0.25f, true, true, Curve.EaseOutQuad);
        TweenGrayMesh.InDestination = true;
    }

    private void GetMesh(ChestType chestType)
    {
        if (chestType == ChestType.System)
        {
            if (ChestMF.mesh != SystemMesh)
            {
                ChestMF.mesh = SystemMesh;
                ChestMR.material.SetTexture("_MainTex", systemTexture);
            }
        }
        else if (chestType == ChestType.Lucky)
        {
            if (ChestMF.mesh != LuckyMesh)
            {
                ChestMF.mesh = LuckyMesh;
                ChestMR.material.SetTexture("_MainTex", luckyTexture);
            }
        }
        else if (chestType == ChestType.GuessColor)
        {
            if (ChestMF.mesh != ColorMesh)
            {
                ChestMF.mesh = ColorMesh;
                ChestMR.material.SetTexture("_MainTex", colorTexture);
            }
        }
        else if (chestType == ChestType.GuessNumber)
        {
            if (ChestMF.mesh != NumberMesh)
            {
                ChestMF.mesh = NumberMesh;
                ChestMR.material.SetTexture("_MainTex", numberTexture);
            }
        }
    }

    public void ResetChestRefreshTimer()
    {
        IsAwardAvailable = false;
        ChestTimerTransform.TweenForCG();
        ChestRefreshTimer = ChestRefreshTime;
    }


    public void Deactive()
    {
        IsActive = false;
    }

    public void Active()
    {
        IsActive = true;
    }

    public void SetColliders(bool enable)
    {
        foreach (var collider in GetComponentsInChildren<Collider>())
        {
            collider.enabled = enable;
        }
    }


    public void TurnGray()
    {
        TweenGrayMesh.StartBackward();
    }

    public void TurnNormalColor()
    {
        TweenGrayMesh.StartForward();
    }


    public void OnPointerClick(PointerEventData eventData)
    {
        SelectedChest = this;

        AudioManager.PlayClip(AudioLabel.ClickButton);

        if (ChestData.ChestType == ChestType.Lucky)
        {
            GetAward(null);
        }
        else if (ChestData.ChestType == ChestType.System)
        {
            if (IsActive)
            {
                GetAward(null);
            }
            else
            {
                Bubble.Show(null, Language.GetStr(LanguageLabel.UI__Y_Unactive));
            }
        }
        else
        {
            if (!IsActive)
            {
                Bubble.Show(null, Language.GetStr(LanguageLabel.UI__Y_OutOfChance));
                return;
            }

            ResourceManager.Get(CanvasLabel.Y_Chest).TweenForCG();
            ResourceManager.SetActive(CanvasLabel.Ya_GetAward, false);
            ResourceManager.SetActive(CanvasLabel.Y_Guess, true);
            ResourceManager.SetActive(CanvasLabel.Yb_CreateChest, false);

            if (ChestData.ChestType == ChestType.GuessColor)
            {
                ResourceManager.SetActive(CanvasLabel.Y_RewardLab, false);
                ResourceManager.SetActive(CanvasLabel.Y_RewardIcon, true);
                ResourceManager.Get<Image>(CanvasLabel.Y_RewardIcon).sprite = AnswerInfo.Icon;
                ResourceManager.Get<Image>(CanvasLabel.Y_RewardIcon).Resize(true, 0.3125f, 0.3125f);
                ResourceManager.Get<Image>(CanvasLabel.Y_RewardIcon).color = Color.white;
                LanguageManager.Add(ResourceManager.Get<Text>(CanvasLabel.Y_Tit), new MulLanStr(LanguageLabel.UI__Yb_GuessColor));
                LanguageManager.Add(ResourceManager.Get<Text>(CanvasLabel.Y_Desc), new MulLanStr(LanguageLabel.UI__Y_GuessColorDesc));

                GuessInputField.text = "";
                GuessInputField.characterLimit = 30;
            }
            else
            {
                ResourceManager.SetActive(CanvasLabel.Y_RewardLab, true);
                ResourceManager.SetActive(CanvasLabel.Y_RewardIcon, false);
                LanguageManager.Add(ResourceManager.Get<Text>(CanvasLabel.Y_Tit), new MulLanStr(LanguageLabel.UI__Yb_GuessNumber));
                LanguageManager.Add(ResourceManager.Get<Text>(CanvasLabel.Y_Desc), new MulLanStr(LanguageLabel.UI__Y_GuessNumberDesc));

                GuessInputField.text = "";
                GuessInputField.characterLimit = 1;
            }
        }
    }


    public void OnFinish()
    {
        Animator.SetInteger("Count", Animator.GetInteger("Count") + 1);
    }


    public void OnApplicationPause(bool pause)
    {
        if (!pause)
        {
            SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.CheckDefaultChestStatus(ChestData.DatabaseRoomID);
        }
    }
}