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 PlazaRoomChest : MonoBehaviour, IPointerClickHandler
{
    #region Config

    public float Time = 5;
    public float Timer;
    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 bool Initialized;
    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(ManaReso.LoadSprite("花影子", 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(ManaReso.LoadSprite("系统宝箱", Folder.Scene));
                systemMesh.SetUVs(1, Enumerable.Repeat(new Vector2(1,1), systemMesh.vertices.Length).ToList());
            }

            return systemMesh;
        }
    }
    private Mesh systemMesh;
    private Mesh LuckyMesh
    {
        get
        {
            if (luckyMesh == null)
            {
                luckyMesh = SpriteUtility.CreateMesh(ManaReso.LoadSprite("钻石宝箱", Folder.Scene));
                luckyMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), luckyMesh.vertices.Length).ToList());
            }

            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(ManaReso.LoadSprite("数字宝箱", Folder.Scene));
                numberMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), numberMesh.vertices.Length).ToList());
            }

            return numberMesh;
        }
    }
    private Mesh numberMesh;
    private Mesh ColorMesh
    {
        get
        {
            if (colorMesh == null)
            {
                colorMesh = SpriteUtility.CreateMesh(ManaReso.LoadSprite("花朵宝箱", Folder.Scene));
                colorMesh.SetUVs(1, Enumerable.Repeat(new Vector2(0,1), colorMesh.vertices.Length).ToList());
            }

            return colorMesh;
        }
    }
    private Mesh colorMesh;

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

    public static InputField InputField;
    public static PlazaRoomChest CurrentChest;
    public static PlazaRoomChest SystemChest;

    #endregion

    public void Update()
    {
        if (!IsActive)
        {
            return;
        }

        Timer += UnityEngine.Time.deltaTime;

        if (Timer >= Time)
        {
            Timer = 0;

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


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

    private void Take()
    {
        Deactive();
        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;
        ChestMge.OperateDataDictionary.TryGetValue(CurrentChest.ChestData.ID, out chestOperateData);
        int remainGuessAmt;
        if (chestOperateData == null)
        {
            remainGuessAmt = ChestMge.PlayerMaxGuessAmt - 1;
        }
        else
        {
            remainGuessAmt = (int) chestOperateData.GuessedAmt - 1;
            chestOperateData.GuessedAmt -= 1;
        }

        if (remainGuessAmt <= 0)
        {
            Bubble.Show(null, Language.GetStr("UI", "Y_GuessWrong"));
            Deactive();
            TurnGray();
        }
        else
        {
            Bubble.Show(null, Language.GetStr("UI", "Y_GuessWrong"));
        }
    }

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


    public void RetriveChest()
    {
        TweenRenderer.StartBackward();
    }

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

        if (chestData.ChestType == ChestType.GuessColor)
        {
            AnswerInfo = ManaGarden.FlowerInfoDic.Random();
            AnswerColor = Language.GetStr("FlowerColor", AnswerInfo.ID).ToLower();
        }
    }

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

        Deactive();
        TurnGray();

        SystemChest = this;
    }

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

        if (InputField == null)
        {
            InputField = ManaReso.Get<InputField>("Y_InputField");
        }

        if (!Initialized)
        {
            Initialized = 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 = () => { ManaReso.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 = UnityFactory.Materials[0];
        ChestMR.sharedMaterial = UnityFactory.Materials[0];
        ShadowMR.sharedMaterial = UnityFactory.Materials[0];

        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;
        }
        else if (chestType == ChestType.Lucky)
        {
            if (ChestMF.mesh != LuckyMesh)
                ChestMF.mesh = LuckyMesh;
        }
        else if (chestType == ChestType.GuessColor)
        {
            if (ChestMF.mesh != ColorMesh)
                ChestMF.mesh = ColorMesh;
        }
        else if (chestType == ChestType.GuessNumber)
        {
            if (ChestMF.mesh != NumberMesh)
                ChestMF.mesh = NumberMesh;
        }
    }


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

    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)
    {
        CurrentChest = this;

        ManaAudio.PlayClip(Clip.BtnClip);

        if (ChestData.ChestType == ChestType.Lucky)
        {
            GetAward(null);
        }
        else if (ChestData.ChestType == ChestType.System)
        {
            if (IsActive)
            {
                GetAward(null);
            }
            else
            {
                Bubble.Show(null, Language.GetStr("UI", "Y_Unactive"));
            }
        }
        else
        {
            ManaReso.Get("Y_Chest").TweenForCG();
            ManaReso.SetActive("Ya_GetAward", false);
            ManaReso.SetActive("Y_Guess", true);
            ManaReso.SetActive("Yb_CreateChest", false);

            if (ChestData.ChestType == ChestType.GuessColor)
            {
                ManaReso.SetActive("Y_RewardLab", false);
                ManaReso.SetActive("Y_RewardIcon", true);
                ManaReso.Get<Image>("Y_RewardIcon").sprite = AnswerInfo.Icon;
                ManaReso.Get<Image>("Y_RewardIcon").Resize(true, 0.3125f, 0.3125f);
                ManaReso.Get<Image>("Y_RewardIcon").color = Color.white;
                ManaLan.Add(ManaReso.Get<Text>("Y_Tit"), new LanStr("UI", "Yb_GuessColor"));
                ManaLan.Add(ManaReso.Get<Text>("Y_Desc"), new LanStr("UI", "Y_GuessColorDesc"));

                InputField.text = "";
                InputField.characterLimit = 30;
            }
            else
            {
                ManaReso.SetActive("Y_RewardLab", true);
                ManaReso.SetActive("Y_RewardIcon", false);
                ManaLan.Add(ManaReso.Get<Text>("Y_Tit"), new LanStr("UI", "Yb_GuessNumber"));
                ManaLan.Add(ManaReso.Get<Text>("Y_Desc"), new LanStr("UI", "Y_GuessNumberDesc"));

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