using DragonBones;

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

using System;
using System.Xml;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using Animation = DragonBones.Animation;
using Slot = DragonBones.Slot;
using Random = UnityEngine.Random;
using Transform = UnityEngine.Transform;

public class PlayerLabel
{
    public static string MessageBox = "MessageBox";
    public static string NickName = "NickName";
    public static string Pivot = "Pivot";
    public static string Shadow = "Shadow";
    public static string ExpressionMeshFilter = "ExpressionMeshFilter";
    public static string ShadowParent = "ShadowParent";
    public static string Player = "Player";
    public static string RightPos = "RightPos";
    public static string LeftPos = "LeftPos";
    public static string EnterGameTra = "EnterGameTra";
}

public enum BodyPart
{
    Leg = 0,
    LeftHand = 1,
    RightHand = 2,
	LeftLongSleeve = 3,
    LeftShortSleeve = 4,
    RightLongSleeve = 5,
    RightShortSleeve = 6,
    Neck = 7,
    Eye = 8,
    Top = 9,
    Shoe = 10,
    Head = 11,
    Wing = 12,
    Dress = 13,
    Mouse = 14,
    Headwear = 15,
}

public class ExchangeInfo
{
    public float ExchangeRate;
    public double Value;
    public Current Current;

    public static void GetExchangeValue(ExchangeInfo info, StaticsManager.ConsumeModule consumeModule)
    {
        if (info.Current == Current.Coin)
        {
            Manager.AddCoin(info.Value, StaticsManager.ItemID.获得金币, consumeModule);
        }
        else if (info.Current == Current.Diamond)
        {
            Manager.AddDiamond(info.Value, StaticsManager.ItemID.获得钻石, consumeModule);
        }
    }

    public static ExchangeInfo GetExchangeInfo(Current current, double amt, float rate)
    {
        ExchangeInfo info = new ExchangeInfo();
        info.ExchangeRate = rate;
        info.Value = amt * rate;
        info.Current = current;
        return info;
    }
}

public class CloseItemLabel
{
    public static string Icon1 = "Icon1";
    public static string Icon2 = "Icon2";
    public static string Icon3 = "Icon3";
    public static string CloseItem = "CloseItem";
    public static string BuyBtn = "BuyBtn";
    public static string BuyBtnLab = "BuyBtnLab";
}

public class CloseItem
{
    public enum CloseType
    {
        Top,
        Hair,
        Wing,
        Dress,
        Decarator,
        Shoe,
    }

    #region Config

    public string Name
    {
        get { return Language.GetStr(LanguageLabel.CombineLanguageLabel(LanguageLabel.DressRoom, FullID)); }
    }

    public static string IDPrefix = "Armature";

    public string FullID
    {
        get { return IDPrefix + ID; }
    }
    public int ID;

    public int Index;
    public int BuyLevel;
    public int PixelSize;
    public bool IsBought;
    public string ArmatureName;

    public string[] ExtraArmatureNames;
    public BodyPart[] ExtraBodyParts;

    public float SpriteAlpha;
    public float IconOffset;
    public TextPlus BuyBtnLab;
    public Sprite[] Sprites;
    public Image Icon1;
    public Image Icon2;
    public Image Icon3;
    public Button BuyBtn;
    public Button DressBtn;
    public Vector2 IconOffset1;
    public Vector2 IconOffset2;
    public BodyPart BodyPart;
    public Transform Transform;
    public CloseType Type;
    public bool Unavailable; //True-不显示

    public double BuyCost;
    public double BuyAdvanceCost;
    public Current BuyCurrent;
    public Current BuyAdvanceCurrent;

    public Dictionary<string, Transform> ChildDic = new Dictionary<string, Transform>();

    #endregion

    public CloseItem(XmlAttributeCollection attribute)
    {
        Unavailable = Auxiliary.StringToBool(attribute[19].Value, false);

        ID = Auxiliary.StringToInt(attribute[0].Value, -1);
        BodyPart = BodyPartParse(attribute[4].Value);
        ArmatureName = attribute[16].Value;

        PlayerManager.CloseIDDictionary.Add(ArmatureName, ID);
        PlayerManager.CloseItemDictionary.Add(ID, this);

        if (Unavailable)
        {
            return;
        }

        Type = TypeParse(attribute[2].Value);
        Index = Auxiliary.StringToInt(attribute[3].Value, -1);
        BuyLevel = Auxiliary.StringToInt(attribute[5].Value, 0);
        BuyCurrent = Auxiliary.CurrentParse(attribute[6].Value);
        BuyCost = Auxiliary.StringToDouble(attribute[7].Value, 0);
        BuyAdvanceCurrent = Auxiliary.CurrentParse(attribute[8].Value);
        BuyAdvanceCost = Auxiliary.StringToDouble(attribute[9].Value, 0);
        PixelSize = Auxiliary.StringToInt(attribute[10].Value, 100);
        IconOffset = Auxiliary.StringToFloat(attribute[11].Value, 0);
        IconOffset1 = Auxiliary.StringToVector(',', attribute[12].Value, new Vector3());
        IconOffset2 = Auxiliary.StringToVector(',', attribute[13].Value, new Vector3());
        Sprites = SpriteParse(attribute[14].Value);
        SpriteAlpha = Auxiliary.StringToFloat(attribute[15].Value, 1);
        ExtraBodyParts = BodyPartParses(attribute[17].Value);
        ExtraArmatureNames = Auxiliary.StringToStrings(',', attribute[18].Value, new List<string>()).ToArray();

        CreateItem();
    }

    protected void CreateItem()
    {
        Transform = ResourceManager.Get(ResourceLabel.CloseItem, Folder.UI, false, ResourceManager.Get(CanvasLabel.Canvas), false);

        if (Type == CloseType.Top)
        {
            Transform.SetParent(ResourceManager.Get(CanvasLabel.Pb_TopGrid));
        }
        else if (Type == CloseType.Hair)
        {
            Transform.SetParent(ResourceManager.Get(CanvasLabel.Pa_HairGrid));
        }
        else if (Type == CloseType.Dress)
        {
            Transform.SetParent(ResourceManager.Get(CanvasLabel.Pc_DressGrid));
        }
        else if (Type == CloseType.Wing)
        {
            Transform.SetParent(ResourceManager.Get(CanvasLabel.Pe_WingGrid));
        }
        else if (Type == CloseType.Decarator)
        {
            Transform.SetParent(ResourceManager.Get(CanvasLabel.Pd_DecaratorGrid));
        }
        else if (Type == CloseType.Shoe)
        {
            Transform.SetParent(ResourceManager.Get(CanvasLabel.Pf_ShoeGrid));
        }
        else
        {
            throw new Exception();
        }

        Transform.SetSiblingIndex(Index);


        Auxiliary.CompileDic(Transform, ChildDic);

        Icon1 = ChildDic[CloseItemLabel.Icon1].GetComponent<Image>();
        Icon2 = ChildDic[CloseItemLabel.Icon2].GetComponent<Image>();
        Icon3 = ChildDic[CloseItemLabel.Icon3].GetComponent<Image>();
        DressBtn = ChildDic[CloseItemLabel.CloseItem].GetComponent<Button>();
        BuyBtn = ChildDic[CloseItemLabel.BuyBtn].GetComponent<Button>();
        BuyBtnLab = ChildDic[CloseItemLabel.BuyBtnLab].GetComponent<TextPlus>();

        SetupStandardItem(Icon1, Icon2, Icon3, BuyBtn, BuyBtnLab);
        //BuyBtnLab.GetComponent<TextPlus>().SetY = true;

        //float newSize = PixelSize / Sprites[0].rect.width;

        //SetupUI(newSize, new Vector2(), Icon1, Icon2, Icon3);

        //if (BuyCurrent != Current.Free)
        //{
        //    BuyBtnLab.text = Auxiliary.ImageParse(BuyCurrent) + Auxiliary.ShrinkNumberStr(BuyCost);
        //}

        //if (BuyLevel > Manager.GardenLevel)
        //{
        //    BuyBtn.interactable = false;
        //    BuyBtn.image.material = Lib.GrayMat;
        //}

        BuyBtn.onClick.AddListener
        (
            () =>
            {
                AudioManager.PlayClip(AudioLabel.ClickButton);

                OpenBuyPanel(null, NavigateToChargeFromDressroom);
                //ResourceManager.Get(CanvasLabel.Pa_Info).TweenForCG();

                //float newSize = PixelSize / Sprites[0].rect.width;
                //SetupUI(newSize, new Vector2(0, 22), ResourceManager.Get<Image>(CanvasLabel.Pa_Icon1), ResourceManager.Get<Image>(CanvasLabel.Pa_Icon3), ResourceManager.Get<Image>(CanvasLabel.Pa_Icon2));

                //ResourceManager.SetText(CanvasLabel.Pa_Lab, Name);
                //ResourceManager.SetText(CanvasLabel.Pa_BtnLab, Language.GetStr(LanguageLabel.UI__Pa_BtnLab) + Auxiliary.ImageParse(BuyCurrent) + BuyCost);

                //ResourceManager.SetButtonEvent
                //(
                //    CanvasLabel.Pa_Btn,
                //    () => OnBuy
                //);
            }
        );

        DressBtn.onClick.AddListener
        (
            () =>
            {
                AudioManager.PlayClip(AudioLabel.ClickButton);

                if (BuyLevel > Manager.GardenLevel)
                {
                    Bubble.Show(null, Language.GetStr(LanguageLabel.UI__P_Unlock));
                    return;
                }

               ChangeDress(PlayerManager.Player);
            }
        );
    }

    protected Sprite[] SpriteParse(string str)
    {
        string[] spriteNames = str.Split(',');

        Sprite[] sprites = new Sprite[spriteNames.Length];

        for (int i = 0; i < spriteNames.Length; i++)
        {
            if (!PlayerManager.CloseSpriteDictionary.ContainsKey(spriteNames[i]))
            {
                Debug.Log(spriteNames[i]);
            }

            sprites[i] = PlayerManager.CloseSpriteDictionary[spriteNames[i]];
        }

        return sprites;
    }

    protected BodyPart BodyPartParse(string str)
    {
        int type = Auxiliary.StringToInt(str, -1);

        if (type == 1)
        {
            return BodyPart.Head;
        }
        else if (type == 2)
        {
            return BodyPart.Dress;
        }
        else if (type == 3)
        {
            return BodyPart.Shoe;
        }
        else if (type == 4)
        {
            return BodyPart.Headwear;
        }
        else if (type == 5)
        {
            return BodyPart.Top;
        }
        else if (type == 6)
        {
            return BodyPart.Wing;
        }
        else if (type == 7)
        {
            return BodyPart.LeftLongSleeve;
        }
        else if (type == 8)
        {
            return BodyPart.RightLongSleeve;
        }
        else if (type == 9)
        {
            return BodyPart.LeftShortSleeve;
        }
        else if (type == 10)
        {
            return BodyPart.RightShortSleeve;
        }
        else if (type == 11)
        {
            return BodyPart.Eye;
        }
        else if (type == 12)
        {
            return BodyPart.Mouse;
        }
        else
        {
            throw new Exception();
        }
    }

    protected BodyPart[] BodyPartParses(string str)
    {
        List<string> typeIDs = Auxiliary.StringToStrings(',', str, new List<string>());

        BodyPart[] bodyParts = new BodyPart[typeIDs.Count];

        for (int i = 0; i < typeIDs.Count; i++)
        {
            bodyParts[i] = BodyPartParse(typeIDs[i]);
        }

        return bodyParts;
    }

    protected CloseType TypeParse(string str)
    {
        int type = Auxiliary.StringToInt(str, -1);

        if (type == 1)
        {
            return CloseType.Hair; 
        }
        else if (type == 2)
        {
            return CloseType.Top;
        }
        else if (type == 3)
        {
            return CloseType.Dress;
        }
        else if (type == 4)
        {
            return CloseType.Decarator;
        }
        else if (type == 5)
        {
            return CloseType.Wing;
        }
        else if (type == 6)
        {
            return CloseType.Shoe;
        }
        else
        {
            throw new Exception();
        }
    }


    public void SetupUI(float newSize, Vector2 offset, Image icon1, Image icon2, Image icon3)
    {
        icon1.SetActive(false);
        icon3.SetActive(false);

        icon2.SetActive(true);
        icon2.sprite = Sprites[0];
        icon2.Resize(true, new Vector2(newSize, newSize));

        icon2.SetAlpha(SpriteAlpha);
        icon2.transform.localPosition = offset + new Vector2(0, IconOffset);

        if (Sprites.Length >= 2)
        {
            icon1.SetActive(true);

            icon1.sprite = Sprites[1];
            icon1.Resize(true, new Vector2(newSize, newSize));

            icon1.SetAlpha(SpriteAlpha);
            icon1.transform.localPosition = IconOffset1 * newSize + offset + new Vector2(0, IconOffset);
        }

        if (Sprites.Length >= 3)
        {
            icon3.SetActive(true);

            icon3.sprite = Sprites[2];
            icon3.Resize(true, new Vector2(newSize, newSize));

            icon3.SetAlpha(SpriteAlpha);
            icon3.transform.localPosition = IconOffset2 * newSize + offset + new Vector2(0, IconOffset);
        }
    }

    public void SetupStandardItem(Image icon1, Image icon2, Image icon3, Button buyButton, TextPlus buyButtonText)
    {
        buyButtonText.GetComponent<TextPlus>().SetY = true;
        float newSize = PixelSize / Sprites[0].rect.width;
        SetupUI(newSize, new Vector2(), icon1, icon2, icon3);
        if (BuyCurrent != Current.Free)
        {
            buyButtonText.text = Auxiliary.ImageParse(BuyCurrent) + Auxiliary.ShrinkNumberStr(BuyCost);
            buyButton.interactable = true;
        }
        if (BuyLevel > Manager.GardenLevel)
        {
            buyButton.interactable = false;
            buyButton.image.material = Lib.GrayMat;
        }
    }

    public void OpenBuyPanel(Action buySucceedCallback, Action navigateAction)
    {
        ResourceManager.Get(CanvasLabel.Pa_Info).TweenForCG();

        float newSize = PixelSize / Sprites[0].rect.width;
        SetupUI(newSize, new Vector2(0, 22), ResourceManager.Get<Image>(CanvasLabel.Pa_Icon1), ResourceManager.Get<Image>(CanvasLabel.Pa_Icon3), ResourceManager.Get<Image>(CanvasLabel.Pa_Icon2));

        ResourceManager.SetText(CanvasLabel.Pa_Lab, Name);
        ResourceManager.SetText(CanvasLabel.Pa_BtnLab, Language.GetStr(LanguageLabel.UI__Pa_BtnLab) + Auxiliary.ImageParse(BuyCurrent) + BuyCost);

        ResourceManager.SetButtonEvent
        (
            CanvasLabel.Pa_Btn,
            () => OnBuy(buySucceedCallback, navigateAction)
        );
    }


    public void Unlock()
    {
        if (Unavailable)
        {
            return;
        }

        IsBought = true;

        BuyBtn.interactable = false;
        BuyBtn.image.material = Lib.GrayMat;

        BuyBtnLab.text = Language.GetStr(LanguageLabel.UI__P_BtnLab2);

        Manager.CloseAmt++;
    }

    public void OnBuy(Action buySucceedCallback, Action navigateAction)
    {
        bool navigate = navigateAction != null;
        Manager.Pay
        (
            "",
            BuyCost,
            BuyCurrent,
            () =>
            {
                OnBuySucceed();

                ResourceManager.Get(CanvasLabel.Pa_Info).TweenBacCG();

                ChangeDress(PlayerManager.Player);
                SaveDressData();

                buySucceedCallback.SafeInvoke();
            },
            StaticsManager.ItemID.解锁服装,
            StaticsManager.ConsumeModule.Shop,
            navigate,
            false,
            () =>
            {
                PlayerManager.Player.ResetDressDatas();
                navigateAction.SafeInvoke();
            }
        );
    }

    public void OnBuySucceed()
    {
        Unlock();
        AudioManager.PlayClip(AudioLabel.GetCurrent);
        PlayerManager.BoughtCloseIDs.UniqueAdd(ID);
        HttpManager.UploadConfig();
    }

    public void NavigateToChargeFromDressroom()
    {
        TweenRoot tweenRoot = ResourceManager.Get(CanvasLabel.Pa_Info).TweenBacCG();

        tweenRoot.AddEventOnetime
        (
            EventType.BackwardFinish,
            () =>
            {
                PlayerManager.Player.LeaveDressroom();
            }
        );

        ResourceManager.Get(CanvasLabel.B_SignIn0).GetTweenCG().AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                ResourceManager.Get(CanvasLabel.F_Manage0).TweenForVec();
            }
        );
    }

    public void ChangeDress(Player player, bool resetDepth = true)
    {
        player.ChangeClose(BodyPart, ArmatureName, resetDepth);

        if (Unavailable)
        {
            return;
        }

        if (ExtraBodyParts.Length > 0)
        {
            player.ChangeClose(BodyPart.LeftLongSleeve, "Empty", resetDepth);
            player.ChangeClose(BodyPart.LeftShortSleeve, "Empty", resetDepth);
            player.ChangeClose(BodyPart.RightLongSleeve, "Empty", resetDepth);
            player.ChangeClose(BodyPart.RightShortSleeve, "Empty", resetDepth);
        }

        for (int i = 0; i < ExtraArmatureNames.Length; i++)
        {
            player.ChangeClose(ExtraBodyParts[i], ExtraArmatureNames[i], resetDepth);
        }
    }

    public void SaveDressData() //仅在购买完成时调用
    {
        SaveDressData(BodyPart);
        if (BodyPart == BodyPart.Top)
        {
            PlayerManager.DressDatas[8] = "Empty";
            PlayerManager.DressDatas[9] = "Empty";
            PlayerManager.DressDatas[10] = "Empty";
            PlayerManager.DressDatas[11] = "Empty";

            foreach (var bodyPart in ExtraBodyParts)
            {
                SaveDressData(bodyPart);
            }
        }
    }

    public void SaveDressData(BodyPart bodyPart) //仅在购买完成时调用
    {
        if (bodyPart == BodyPart.LeftLongSleeve)
        {
            PlayerManager.DressDatas[8] = PlayerManager.Player.LeftLongSleeve;
        }
        else if (bodyPart == BodyPart.LeftShortSleeve)
        {
            PlayerManager.DressDatas[9] = PlayerManager.Player.LeftShortSleeve;
        }
        else if (bodyPart == BodyPart.RightLongSleeve)
        {
            PlayerManager.DressDatas[10] = PlayerManager.Player.RightLongSleeve;
        }
        else if (bodyPart == BodyPart.RightShortSleeve)
        {
            PlayerManager.DressDatas[11] = PlayerManager.Player.RightShortSleeve;
        }
        else if (bodyPart == BodyPart.Top)
        {
            PlayerManager.DressDatas[4] = PlayerManager.Player.Top;
        }
        else if (bodyPart == BodyPart.Shoe)
        {
            PlayerManager.DressDatas[2] = PlayerManager.Player.Shoe;
        }
        else if (bodyPart == BodyPart.Head)
        {
            PlayerManager.DressDatas[0] = PlayerManager.Player.Head;
        }
        else if (bodyPart == BodyPart.Wing)
        {
            PlayerManager.DressDatas[7] = PlayerManager.Player.Wing;
        }
        else if (bodyPart == BodyPart.Dress)
        {
            PlayerManager.DressDatas[1] = PlayerManager.Player.Dress;
        }
        else if (bodyPart == BodyPart.Headwear)
        {
            PlayerManager.DressDatas[3] = PlayerManager.Player.HeadWear;
        }
        else
        {
            throw new Exception();
        }
    }

    public void OnLevelChange()
    {
        if (Unavailable)
        {
            return;
        }

        if (IsBought)
        {
            return;
        }

        if (BuyLevel < Manager.GardenLevel)
        {
            BuyBtn.interactable = true;
            BuyBtn.image.material = null;
        }
    }


    public ExchangeInfo GetExchangeValue(float rate, StaticsManager.ConsumeModule consumeModule)
    {
        ExchangeInfo info = ExchangeInfo.GetExchangeInfo(BuyCurrent, BuyCost, rate);
        ExchangeInfo.GetExchangeValue(info, consumeModule);
        return info;
    }


    public static List<KV<Current, KV<int, double>>> GetTotalBuyCost(bool excludeBought, List<int> closeIDs)
    {
        int coinAmount = 0;
        int diamondAmount = 0;
        double totalCoin = 0;
        double totalDiamond = 0;
        foreach (var closeID in closeIDs)
        {
            if (PlayerManager.CloseItemDictionary[closeID].Sprites == null) continue;
            if (PlayerManager.CloseItemDictionary[closeID].ArmatureName == "Empty") continue;
            CloseItem closeItem = PlayerManager.CloseItemDictionary[closeID];
            if (closeItem.IsBought && excludeBought) continue;
            if (closeItem.BuyCurrent == Current.Coin)
            {
                totalCoin += closeItem.BuyCost;
                coinAmount++;
            }
            if (closeItem.BuyCurrent == Current.Diamond)
            {
                totalDiamond += closeItem.BuyCost;
                diamondAmount++;
            }
        }
        List<KV<Current, KV<int, double>>> results = new List<KV<Current, KV<int, double>>>();
        results.Add(new KV<Current, KV<int, double>>(Current.Coin, new KV<int, double>(coinAmount, totalCoin)));
        results.Add(new KV<Current, KV<int, double>>(Current.Diamond, new KV<int, double>(diamondAmount, totalDiamond)));
        return results;
    }
}

public enum PlayerDirection
{
    Left = 0,
    Right = 1,
}

public class Player : Regist , IPointerClickHandler
{
    #region Config

    public static string IdleAnimationName = "newAnimation";
    public static string JumpAnimationName = "newAnimation1";
    public static string WalkAnimationName = "newAnimation2";
    public static string RunAnimationName = "newAnimation3";

    public static bool InDressRoom;
    public static float InDressRoomJumpFrequency;

    public float JumpTime;
    public float JumpTimer;

    public PlayerDirection PlayerDirection
    {
        get { return playerDirection; }
        set
        {
            playerDirection = value;

            Flip(playerDirection);
        }
    }
    public PlayerDirection playerDirection = PlayerDirection.Left;

    public bool IsDisplayInUGUI;
    public float UGUIScale;

    public bool PlayAnimFlag1;
    public bool PlayAnimFlag2;
    public string CurrentAnimationName;

    public MeshFilter ExpressionMeshFilter;

    public Dictionary<string, Transform> ChildDic = new Dictionary<string, Transform>();

    private string ExpressionName;
    private Coroutine ResetExpressionCoroutine;

    public static Dictionary<string, Vector3> LeftExpressionPositionDictionary = new Dictionary<string, Vector3>
    {
        {"郁闷", new Vector3(0, -0.22f, -0.00001f)},
        {"汗颜", new Vector3(0.35f, 0.91f, -0.00001f)},
        {"惊讶", new Vector3(0.09f, -0.07f, -0.00001f)},
        {"开心", new Vector3(0.1f, -0.22f, -0.00001f)},
        {"哭", new Vector3(0.07f, -0.64f, -0.00001f)},
        {"期待", new Vector3(0.04f, -0.20f, -0.00001f)},
        {"色咪咪", new Vector3(0.03f, -0.09f, -0.00001f)},
        {"委屈", new Vector3(0f, -0.27f, -0.00001f)},
    };

    public static Dictionary<string, Vector3> RightExpressionPositionDictionary = new Dictionary<string, Vector3>
    {
        {"郁闷", new Vector3(0, -0.22f, -0.00001f)},
        {"汗颜", new Vector3(-0.22f, 0.91f, -0.00001f)},
        {"惊讶", new Vector3(-0.09f, -0.07f, -0.00001f)},
        {"开心", new Vector3(-0.1f, -0.22f, -0.00001f)},
        {"哭", new Vector3(-0.07f, -0.64f, -0.00001f)},
        {"期待", new Vector3(-0.04f, -0.20f, -0.00001f)},
        {"色咪咪", new Vector3(-0.03f, -0.09f, -0.00001f)},
        {"委屈", new Vector3(0f, -0.27f, -0.00001f)},
    };

    #region 换装

    public Transform Shadow;

    private Transform Pivot
    {
        get
        {
            if (pivot == null)
            {
                pivot = UAC.transform.FindChild(PlayerLabel.Pivot);
            }

            return pivot;
        }
    }
    private Transform pivot;

    public string Eye;
    public string Top;
    public string Shoe;
    public string Head;
    public string Wing;
    public string Dress;
    public string Mouse;
    public string HeadWear;
    public string LeftLongSleeve;
    public string LeftShortSleeve;
    public string RightLongSleeve;
    public string RightShortSleeve;
    private string TempClose;

	public DragonBones.Slot NeckSlot;
	public DragonBones.Slot LeftHandSlot;
	public DragonBones.Slot RightHandSlot;
	public DragonBones.Slot LeftLegSlot;
	public DragonBones.Slot RightLegSlot;
	public DragonBones.Slot LeftShortSleeveSlot;
	public DragonBones.Slot RightShortSleeveSlot;

	public DragonBones.Slot EyeSlot;
	public DragonBones.Slot TopSlot;
	public DragonBones.Slot HeadSlot;
	public DragonBones.Slot DressSlot;
	public DragonBones.Slot WingSlot;
	public DragonBones.Slot MouseSlot;
	public DragonBones.Slot LeftShoeSlot;
	public DragonBones.Slot RightShoeSlot;
	public DragonBones.Slot HeadWearSlot;

    public UnityArmatureComponent UAC;
    //public UnityArmatureComponent LeftShortSleeveUAC;
    //public UnityArmatureComponent RightShortSleeveUAC;
    public UnityArmatureComponent LeftLongSleeveUAC;
    public UnityArmatureComponent RightLongSleeveUAC;

    #endregion

    #endregion

    public override bool InitAtOnce()
    {
        if (base.InitAtOnce())
        {
            return true;
        }

        enabled = true;

        Auxiliary.CompileDic(transform, ChildDic);

        Vector3 bigShadowScale = new Vector3(1.820952f, 2.418199f, 1.820952f);
        Vector3 smallShadowScale = new Vector3(1.081191f, 1.435807f, 1.081191f);

        Shadow = ChildDic[PlayerLabel.Shadow];
        Shadow.CreateStreamScale
        (
            new List<float>() {0, 0, 0},
            new List<float>() {0.33f, 0.33f, 0.33f, 0.33f},
            new List<VecPair>() {new VecPair(bigShadowScale, smallShadowScale), new VecPair(smallShadowScale, bigShadowScale), new VecPair(bigShadowScale, smallShadowScale), new VecPair(smallShadowScale, bigShadowScale)},
            true,
            true,
            Curve.EaseOutQuad
        );
        MeshFilter meshFilter = Shadow.GetComponent<MeshFilter>();
        meshFilter.mesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(ResourceLabel.FlowerShadow, Folder.Scene));
        meshFilter.mesh.SetUVs(1, Enumerable.Repeat(new Vector2(0, 1), meshFilter.mesh.vertices.Length).ToList());
        Shadow.GetComponent<MeshRenderer>().sharedMaterial = UnityFactory.Materials[0];

        ExpressionMeshFilter = ChildDic[PlayerLabel.ExpressionMeshFilter].GetComponent<MeshFilter>();
        ExpressionMeshFilter.GetComponent<MeshRenderer>().sharedMaterial = UnityFactory.Materials[0];

        return false;
    }


    public void Update()
    {
        if (InDressRoom)
        {
            JumpTimer += Time.deltaTime;

            if (JumpTimer > JumpTime)
            {
                if (!PlayAnimFlag1 && !PlayAnimFlag2)
                {
                    PlayAnim(JumpAnimationName);
                }

                PlayAnimFlag2 = true;
            }

            if (JumpTimer > InDressRoomJumpFrequency)
            {
                PlayAnimFlag2 = false;

                JumpTime = Mathf.Lerp(0, InDressRoomJumpFrequency, Random.Range(0f, 1f));
                JumpTimer = 0;
            }
        }

        //if (GardenSmartFoxManager.GardenSmartFox.PlazaRoomManager.InPlazaRoom)
        //{
        //    MoveThread();
        //}
    }


    public void OnAnimStart(string str, EventObject eventObject)
    {
        if (eventObject.animationState.name == JumpAnimationName)
        {
            Shadow.StreamReForScale();

            PlayAnimFlag1 = true;

            TempClose = Eye;

            ChangeClose(BodyPart.Eye, "眼睛表情1");
        }
        else if (eventObject.animationState.name == IdleAnimationName)
        {
            PlayAnimFlag1 = false;

            if (TempClose != null)
            {
                ChangeClose(BodyPart.Eye, TempClose);
            }
        }
    }

    public void PlayAnim(string animName)
    {
        if (PlayAnimFlag1)
        {
            return;
        }

        if (UAC.anim.lastAnimationName == animName)
        {
            return;
        }

        if (SFSManager.GardenSmartFox.PlazaRoomController.JoinedPlazaRoom)
        {
            CurrentAnimationName = animName;
        }

        UAC.anim.FadeIn(animName, GetFadeInTime(UAC.anim.lastAnimationName, animName));
    }

    public float GetFadeInTime(string lastAnimation, string targetAnimation)
    {
        if (lastAnimation == JumpAnimationName && targetAnimation == IdleAnimationName)
            return -1f;
        else
            return 0.1f;

        //throw new Exception();
    }


    public void SetAllCollider(bool enable)
    {
        BoxCollider2D[] colliders = GetComponentsInChildren<BoxCollider2D>();

        for (int i = 0; i < colliders.Length; i++)
        {
            colliders[i].enabled = enable;
        }
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        AudioManager.PlayClip(AudioLabel.GetCurrent);

        PlayAnim(JumpAnimationName);
    }


    public void ResetExpression()
    {
        ExpressionMeshFilter.SetActive(false);
        EyeSlot.UnityTransform.GetChild(0).SetActive(true);
        MouseSlot.UnityTransform.GetChild(0).SetActive(true);
    }

    public void ChangeExpression(string expressionName, float duration)
    {
        ExpressionName = expressionName;

        ExpressionMeshFilter.sharedMesh = SpriteUtility.CreateMesh(ResourceManager.LoadSprite(expressionName, Folder.Scene));
        ExpressionMeshFilter.mesh.SetUVs(1, Enumerable.Repeat(new Vector2(0, 1), ExpressionMeshFilter.mesh.vertices.Length).ToList());
        ExpressionMeshFilter.transform.parent = EyeSlot.UnityTransform;

        ExpressionMeshFilter.SetActive(true);
        EyeSlot.UnityTransform.GetChild(0).SetActive(false);
        MouseSlot.UnityTransform.GetChild(0).SetActive(false);

        FlipExpression(expressionName, PlayerDirection);

        if (ResetExpressionCoroutine != null)
            Auxiliary.Instance.StopCoroutine(ResetExpressionCoroutine);

        ResetExpressionCoroutine = Auxiliary.Instance.DelayCall
        (
            () =>
            {
                ResetExpression();
            },
            duration
        );
    }


    public void Flip(PlayerDirection direction)
    {
        FlipExpression(ExpressionName, direction);
        if (direction == PlayerDirection.Left)
        {
            UAC.armature.flipX = false;

            playerDirection = PlayerDirection.Left;
        }
        else if (direction == PlayerDirection.Right)
        {
            UAC.armature.flipX = true;

            playerDirection = PlayerDirection.Right;
        }
        else
        {
            throw new Exception();
        }

        DelayCall.Call(1, () => Shadow.SetX(Pivot.position.x));
    }

    public void FlipExpression(string expressionName, PlayerDirection direction)
    {
        if (string.IsNullOrEmpty(ExpressionName))
        {
            return;
        }

        if (direction == PlayerDirection.Left)
        {
            ExpressionMeshFilter.transform.eulerAngles = new Vector3();
            ExpressionMeshFilter.transform.localPosition = LeftExpressionPositionDictionary[ExpressionName];
        }
        else if (direction == PlayerDirection.Right)
        {
            UAC.armature.flipX = true;

            ExpressionMeshFilter.transform.eulerAngles = new Vector3(0, 180, 0);
            ExpressionMeshFilter.transform.localPosition = RightExpressionPositionDictionary[ExpressionName];

            playerDirection = PlayerDirection.Right;
        }
        else
        {
            throw new Exception();
        }
    }


    public void SaveDressDatas(bool showNavigate)
    {
        AudioManager.PlayClip(AudioLabel.ClickButton);

        List<CloseItem> closeUnitList = new List<CloseItem>();

        closeUnitList.Add(PlayerManager.CloseItemDictionary[PlayerManager.CloseIDDictionary[Head]]);
        closeUnitList.Add(PlayerManager.CloseItemDictionary[PlayerManager.CloseIDDictionary[Dress]]);
        closeUnitList.Add(PlayerManager.CloseItemDictionary[PlayerManager.CloseIDDictionary[Shoe]]);
        closeUnitList.Add(PlayerManager.CloseItemDictionary[PlayerManager.CloseIDDictionary[HeadWear]]);
        closeUnitList.Add(PlayerManager.CloseItemDictionary[PlayerManager.CloseIDDictionary[Top]]);

        if (Wing != "Empty")
        {
            closeUnitList.Add(PlayerManager.CloseItemDictionary[PlayerManager.CloseIDDictionary[Wing]]);
        }

        for (int i = 0; i < closeUnitList.Count; i++)
        {
            if (!closeUnitList[i].IsBought)
            {
                if (showNavigate)
                {
                    BuyDressNavigate(closeUnitList);
                }

                return;
            }
        }

        PlayerManager.DressDatas[0] = Head;
        PlayerManager.DressDatas[1] = Dress;
        PlayerManager.DressDatas[2] = Shoe;
        PlayerManager.DressDatas[3] = HeadWear;
        PlayerManager.DressDatas[4] = Top;
        PlayerManager.DressDatas[7] = Wing;
        PlayerManager.DressDatas[8] = LeftLongSleeve;
        PlayerManager.DressDatas[9] = LeftShortSleeve;
        PlayerManager.DressDatas[10] = RightLongSleeve;
        PlayerManager.DressDatas[11] = RightShortSleeve;
        Toast.Show(1.5f, Language.GetStr(LanguageLabel.UI__P_SaveSucceed));
    }

    public void ResetDressDatas()
    {
        AudioManager.PlayClip(AudioLabel.ClickButton);

        List<string> dressData = new List<string>(PlayerManager.DressDatas);

        dressData[5] = Eye;

        PlayerManager.BuildPlayer(dressData);
    }

    public List<int> GetCurrentChangableDressIDs()
    {
        List<int> ids = new List<int>();
        ids.Add(PlayerManager.CloseIDDictionary[Head]);
        ids.Add(PlayerManager.CloseIDDictionary[Dress]);
        ids.Add(PlayerManager.CloseIDDictionary[Shoe]);
        ids.Add(PlayerManager.CloseIDDictionary[HeadWear]);
        ids.Add(PlayerManager.CloseIDDictionary[Top]);
        ids.Add(PlayerManager.CloseIDDictionary[Wing]);
        ids.Add(PlayAnimFlag1 ? PlayerManager.CloseIDDictionary[TempClose] : PlayerManager.CloseIDDictionary[Eye]);
        ids.Add(PlayerManager.CloseIDDictionary[Mouse]);
        ids.Add(PlayerManager.CloseIDDictionary[Wing]);
        return ids;
    }

    public static List<string> DressIDToDressName(List<int> ids)
    {
        List<string> names = new List<string>();
        foreach (var id in ids)
        {
            names.Add(PlayerManager.CloseItemDictionary[id].ArmatureName);
        }
        return names;
    }

    public List<string> GetCurrentDressNames()
    {
        List<string> names = new List<string>();
        return names;
    }

    public List<string> GetCurrentChangableDressNames()
    {
        List<string> names = new List<string>();
        names.Add(Head);
        names.Add(Dress);
        names.Add(Shoe);
        names.Add(HeadWear);
        names.Add(Top);
        names.Add(Wing);
        if (PlayAnimFlag1) names.Add(TempClose);
        else names.Add(Eye);
        names.Add(Mouse);
        names.Add(Wing);
        return names;
    }

    public void BuyDressNavigate(List<CloseItem> closeUnitList)
    {
        for (int i = 0; i < closeUnitList.Count; i++)
        {
            if (closeUnitList[i].IsBought)
            {
                closeUnitList.RemoveAt(i--);
            }
            else
            {
                closeUnitList[i].BuyBtn.onClick.Invoke();

                closeUnitList.RemoveAt(i--);

                ResourceManager.Get(CanvasLabel.Pa_Info).GetTweenCG().AddEventOnetime
                    (
                        EventType.BackwardFinish,
                        () =>
                        {
                            if (closeUnitList.Count == 0)
                            {
                                SaveDressDatas(false);
                            }
                            else
                            {
                                BuyDressNavigate(closeUnitList);
                            }
                        }
                    );

                return;
            }
        }
    }

    public void LeaveDressroom()
    {
        bool allSave = true;
        bool allBought = true;

        List<string> currentDerssData = new List<string>() { Head, Dress, Shoe, HeadWear, Top, Wing };

        for (int i = 0; i < currentDerssData.Count; i++)
        {
            if (!PlayerManager.CloseIDDictionary.ContainsKey(currentDerssData[i]))
            {
                continue;
            }

            int id = PlayerManager.CloseIDDictionary[currentDerssData[i]];

            allBought = allBought && PlayerManager.CloseItemDictionary[id].IsBought;
            //Debug.Log(ManaPlayer.CloseUnitDic[id].Name + "    " + ManaPlayer.CloseUnitDic[id].Bought);
            allSave = allSave && currentDerssData[i] == PlayerManager.DressDatas[i];
        }

        if (allBought)
        {
            if (allSave)
            {
                ExitDressRoom();
            }
            else
            {
                ResetDressDatas();
                ExitDressRoom();
            }
        }
        else
        {
            Bubble.Show
            (
                null, Language.GetStr(LanguageLabel.UI__P_Return), null, null,
                () =>
                {
                    ResetDressDatas();
                    ResourceManager.Get(CanvasLabel.K_Bubble).GetTweenGra().AddEventOnetime(EventType.BackwardFinish, () => { ExitDressRoom(); });
                }
            );
        }
    }

    public void ExitDressRoom()
    {
        Manager.SceneSwitchFlag = false;

        TweenRoot tweenRoot = ResourceManager.Get(CanvasLabel.I_BlackMask).TweenBacCG();

        tweenRoot.AddEventOnetime
            (
                EventType.BackwardFinish,
                () =>
                {
                    transform.SetParent(ResourceManager.Get(GardenLabel.GardenPivot));

                    transform.position = ResourceManager.Get(GardenLabel.GardenPlayerPos).position;
                    transform.localScale = ResourceManager.Get(GardenLabel.GardenPlayerPos).lossyScale;

                    ResourceManager.Get(ResourceLabel.Garden).TweenForSr();
                    ResourceManager.Get(DressroomLabel.DressRoom).TweenBacSr();

                    ResourceManager.Get(CanvasLabel.C_Main).TweenForCG();
                    ResourceManager.Get(CanvasLabel.P_DressRoom).TweenBacCG();
                }
            );


        tweenRoot = ResourceManager.Get(CanvasLabel.P_DressRoom).GetTweenCG();

        tweenRoot.AddEventOnetime
            (
                EventType.BackwardFinish,
                () =>
                {
                    SetAllCollider(true);

                    InDressRoom = false;

                    JumpTimer = 0;

                    PlayAnim(IdleAnimationName);

                    DeactiveShadow();

                    ResourceManager.Get(CanvasLabel.B_SignIn0).TweenForCG();
                    ResourceManager.Get(CanvasLabel.I_BlackMask).TweenForCG();
                }
            );
    }

    public void EnterDressRoom()
    {
        if (Manager.SceneSwitchFlag)
        {
            return;
        }

        ResourceManager.Get(CanvasLabel.B_SignIn0).TweenBacCG();

        InDressRoom = true;

        JumpTime = Mathf.Lerp(0, 10, Random.Range(0.5f, 1f));

        Manager.SceneSwitchFlag = true;


        ResourceManager.Get(CanvasLabel.C_Main).TweenBacCG();


        SetAllCollider(false);

        TweenRoot tweenRoot = ResourceManager.Get(CanvasLabel.I_BlackMask).TweenBacCG();

        tweenRoot.AddEventOnetime
            (
                EventType.BackwardFinish,
                () =>
                {
                    GardenManager.RetrieveAllElf();
                    IAPManager.RetrieveADChest();

                    ActiveShadow();

                    transform.SetParent(ResourceManager.Get(DressroomLabel.DressRoom));

                    transform.position = ResourceManager.Get(DressroomLabel.DressRoomPos).position;
                    transform.localScale = ResourceManager.Get(DressroomLabel.DressRoomPos).lossyScale;

                    ResourceManager.Get(ResourceLabel.Garden).TweenBacSr();
                    ResourceManager.Get(DressroomLabel.DressRoom).TweenForSr();

                    ResourceManager.Get(CanvasLabel.P_DressRoom).TweenForCG();
                }
            );


        tweenRoot = ResourceManager.Get(CanvasLabel.P_DressRoom).GetTweenCG();

        tweenRoot.AddEventOnetime
            (
                EventType.ForwardFinish,
                () =>
                {
                    ResourceManager.Get(CanvasLabel.I_BlackMask).TweenForCG();
                }
            );
    }


    public void ActiveShadow()
    {
        ChildDic[PlayerLabel.ShadowParent].SetActive(true);
        ChildDic[PlayerLabel.ShadowParent].SetLZ(3);
    }

    public void DeactiveShadow()
    {
        Shadow.GetStreamScale().Pause();
        Shadow.GetStreamScale().InOrigin = true;
        ChildDic[PlayerLabel.ShadowParent].SetActive(false);
    }


    public void DisplayInUI(float scale)
    {
        UGUIScale = scale;
        scale *= ResourceManager.Get<Canvas>(CanvasLabel.Canvas).scaleFactor;
        MeshFilter[] meshFilters = UAC.GetComponentsInChildren<MeshFilter>(true);
        MeshRenderer[] meshRenderers = UAC.GetComponentsInChildren<MeshRenderer>(true);
        for (int i = 0; i < meshRenderers.Length; i++)
        {
            MeshFilter meshFilter = meshFilters[i];
            MeshRenderer meshRenderer = meshRenderers[i];
            UnityUGUIDisplay unityUGUIDisplay = meshRenderer.GetComponent<UnityUGUIDisplay>();
            if (unityUGUIDisplay == null) unityUGUIDisplay = meshRenderer.AddComponent<UnityUGUIDisplay>();
            unityUGUIDisplay.Enable(meshFilter, meshRenderer);
            unityUGUIDisplay.raycastTarget = false;
            meshRenderer.enabled = false;
            UAC.transform.localScale = new Vector3(scale, scale, 1);
            SetAllCollider(false);
            DeactiveShadow();
        }
        IsDisplayInUGUI = true;
        ResetDepth();
    }

    public void DisplayInScene()
    {
        MeshRenderer[] meshRenderers = UAC.GetComponentsInChildren<MeshRenderer>(true);
        foreach (var meshRenderer in meshRenderers)
        {
            UnityUGUIDisplay unityUGUIDisplay = meshRenderer.GetComponent<UnityUGUIDisplay>();
            if (unityUGUIDisplay == null) continue;
            unityUGUIDisplay.Disable();
            meshRenderer.enabled = true;
            UAC.transform.localScale = Vector3.one;
            SetAllCollider(true);
            ActiveShadow();
        }
        IsDisplayInUGUI = false;
        ResetDepth();
    }

    #region 换装

    public void CorrectPivot()
    {
        List<Transform> children = new List<Transform>();

        while (transform.childCount > 0)
        {
            children.Add(transform.GetChild(0));

            children.Back(0).parent = null;
        }

        Vector3 offset = Pivot.position - transform.position;
        children[0].position += offset;
        children[1].position += offset;
        transform.position += offset;

        foreach (var collider in GetComponents<BoxCollider2D>())
        {
            collider.offset -= new Vector2(offset.x, offset.y);
        }

        for (int i = 0; i < children.Count; i++)
        {
            children[i].parent = transform;
        }
    }

    public UnityArmatureComponent Build()
    {
        if (!PlayerManager.Inited)
        {
            UnityFactory.factory.LoadDragonBonesData(ResourceManager.Load<TextAsset>(ResourceLabel.StandSke, Folder.Config));

            UnityFactory.factory.LoadTextureAtlasData(ResourceManager.Load<TextAsset>(ResourceLabel.StandTex, Folder.Config), ResourceLabel.StandTexture);

            PlayerManager.Inited = true;
        }

        UAC = UnityFactory.factory.BuildArmatureComponent("Armature");
        
        UAC.transform.parent = transform;
        UAC.transform.localScale = new Vector3(1, 1, 1);
        UAC.transform.localPosition = new Vector3();

        UAC.anim.Play(IdleAnimationName);

        UAC.AddEventListener(EventObject.START, OnAnimStart);

        Eye = "眼睛1";
        Top = "上衣1";
        Shoe = "鞋子1";
        Head = "脑壳1";
        Wing = "Empty";
        Dress = "裙子1";
        Mouse = "嘴巴1";
        HeadWear = "头饰品1";

        NeckSlot = UAC.armature.GetSlot("脖子");
        LeftHandSlot = UAC.armature.GetSlot("左手");
        RightHandSlot = UAC.armature.GetSlot("右手");
        LeftLegSlot = UAC.armature.GetSlot("左腿");
        RightLegSlot = UAC.armature.GetSlot("右腿");

        LeftLongSleeveUAC = UAC.transform.FindChild("长袖9左 (长袖9左)").GetComponent<UnityArmatureComponent>();
        RightLongSleeveUAC = UAC.transform.FindChild("长袖9右 (长袖9右)").GetComponent<UnityArmatureComponent>();

		LeftShortSleeveSlot = UAC.armature.GetSlot("上衣1袖子左");
		RightShortSleeveSlot = UAC.armature.GetSlot("上衣1袖子右");

        EyeSlot = UAC.armature.GetSlot("眼睛");
        TopSlot = UAC.armature.GetSlot("上衣");
        HeadSlot = UAC.armature.GetSlot("脑壳");
        WingSlot = UAC.armature.GetSlot("翅膀");
        DressSlot = UAC.armature.GetSlot("裙子");
        MouseSlot = UAC.armature.GetSlot("嘴巴");
        LeftShoeSlot = UAC.armature.GetSlot("鞋子左");
        RightShoeSlot = UAC.armature.GetSlot("鞋子右");
        HeadWearSlot = UAC.armature.GetSlot("头饰品");

        ChangeClose(BodyPart.Eye, "眼睛1", false);
        ChangeClose(BodyPart.Top, "上衣1", false);
        ChangeClose(BodyPart.Shoe, "鞋子1", false);
        ChangeClose(BodyPart.Head, "脑壳1", false);
        ChangeClose(BodyPart.Dress, "裙子1", false);
        ChangeClose(BodyPart.Mouse, "嘴巴1", false);
        ChangeClose(BodyPart.Headwear, "头饰品1", false);

        ChangeClose(BodyPart.LeftLongSleeve, "Empty", false);
        ChangeClose(BodyPart.RightLongSleeve, "Empty", false);
        ChangeClose(BodyPart.LeftShortSleeve, "短袖2左", false);
        ChangeClose(BodyPart.RightShortSleeve, "短袖2右", false);

        CorrectPivot();

        return UAC;
    }

    public UnityArmatureComponent BuildPink()
    {
        Build();

        ChangeClose(BodyPart.Eye, "眼睛3", false);
        ChangeClose(BodyPart.Top, "上衣3", false);
        ChangeClose(BodyPart.Shoe, "鞋子3", false);
        ChangeClose(BodyPart.Head, "脑壳3", false);
        ChangeClose(BodyPart.Wing, "Empty", false);
        ChangeClose(BodyPart.Dress, "裙子3", false);
        ChangeClose(BodyPart.Mouse, "嘴巴3", false);
        ChangeClose(BodyPart.Headwear, "头饰品3", false);

        ResetDepth();

        return UAC;
    }

    public UnityArmatureComponent BuildBlond()
    {
        Build();

        ChangeClose(BodyPart.Wing, "Empty", false);

        ResetDepth();

        return UAC;
    }

    public UnityArmatureComponent BuildBrown()
    {
        Build();

        ChangeClose(BodyPart.Eye, "眼睛2", false);
        ChangeClose(BodyPart.Top, "上衣2", false);
        ChangeClose(BodyPart.Shoe, "鞋子2", false);
        ChangeClose(BodyPart.Head, "脑壳2", false);
        ChangeClose(BodyPart.Wing, "Empty", false);
        ChangeClose(BodyPart.Dress, "裙子2", false);
        ChangeClose(BodyPart.Mouse, "嘴巴2", false);
        ChangeClose(BodyPart.Headwear, "头饰品2", false);

        ResetDepth();

        return UAC;
    }


    public void ResetDepth()
    {
        if (IsDisplayInUGUI)
        {
            SetSlotAsFirstChild(TopSlot);
            SetSlotAsFirstChild(DressSlot);
            SetSlotAsFirstChild(LeftShortSleeveSlot);
            SetSlotAsFirstChild(RightShortSleeveSlot);
            LeftLongSleeveUAC.transform.SetAsFirstSibling();
            RightLongSleeveUAC.transform.SetAsFirstSibling();
            SetSlotAsFirstChild(EyeSlot);
            SetSlotAsFirstChild(MouseSlot);
            SetSlotAsFirstChild(LeftShoeSlot);
            SetSlotAsFirstChild(RightShoeSlot);
            SetSlotAsFirstChild(HeadWearSlot);
            SetSlotAsFirstChild(LeftHandSlot);
            SetSlotAsFirstChild(RightHandSlot);
            SetSlotAsFirstChild(HeadSlot);
            SetSlotAsFirstChild(LeftLegSlot);
            SetSlotAsFirstChild(RightLegSlot);
            SetSlotAsFirstChild(NeckSlot);
            SetSlotAsFirstChild(WingSlot);
        }
        else
        {
            UAC.transform.SetLZ(2.5f);

            SetSlotLocalZ(WingSlot, 0.00003f);
            SetSlotLocalZ(EyeSlot, -0.00001f);
            SetSlotLocalZ(TopSlot, -0.00003f);
            SetSlotLocalZ(MouseSlot, -0.00001f);
            SetSlotLocalZ(HeadWearSlot, -0.00001f);
            SetSlotLocalZ(LeftShoeSlot, -0.00001f);
            SetSlotLocalZ(RightShoeSlot, -0.00001f);
            SetSlotLocalZ(LeftLegSlot, 0);
            SetSlotLocalZ(RightLegSlot, 0);
            SetSlotLocalZ(NeckSlot, 0.00001f);
            SetSlotLocalZ(LeftHandSlot, -0.00001f);
            SetSlotLocalZ(RightHandSlot, -0.00001f);
            SetSlotLocalZ(LeftShortSleeveSlot, -0.000015f);
            SetSlotLocalZ(RightShortSleeveSlot, -0.000015f);

            SetSlotLocalZ(HeadSlot, 0);
            if (HeadSlot.UnityTransform != null && HeadSlot.UnityTransform.childCount > 1)
            {
                HeadSlot.UnityTransform.GetChild(0).SetLZ(0.00002f);
                HeadSlot.UnityTransform.GetChild(1).SetLZ(0f);
            }

            SetSlotLocalZ(DressSlot, -0.00002f);
            if (DressSlot.UnityTransform != null && DressSlot.UnityTransform.childCount > 1)
            {
                DressSlot.UnityTransform.GetChild(0).SetLZ(0.00002f);
                DressSlot.UnityTransform.GetChild(1).SetLZ(0f);
            }

            LeftLongSleeveUAC.transform.SetLZ(-0.000015f);
            RightLongSleeveUAC.transform.SetLZ(-0.000015f);

            //UAC.transform.SetLZ(2.5f);

            //WingSlot.UnityTransform.SetLZ(0);
            //EyeSlot.UnityTransform.SetLZ(0);
            //TopSlot.UnityTransform.SetLZ(0);
            //MouseSlot.UnityTransform.SetLZ(0);
            //HeadWearSlot.UnityTransform.SetLZ(0);
            //LeftShoeSlot.UnityTransform.SetLZ(0);
            //RightShoeSlot.UnityTransform.SetLZ(0);
            //LeftLegSlot.UnityTransform.SetLZ(0);
            //RightLegSlot.UnityTransform.SetLZ(0);
            //NeckSlot.UnityTransform.SetLZ(0);
            //LeftHandSlot.UnityTransform.SetLZ(0);
            //RightHandSlot.UnityTransform.SetLZ(0);
            //LeftShortSleeveSlot.UnityTransform.SetLZ(0);
            //RightShortSleeveSlot.UnityTransform.SetLZ(0);

            //WingSlot.SetLZ(0.00003f);
            //EyeSlot.SetLZ(-0.00001f);
            //TopSlot.SetLZ(-0.00003f);
            //MouseSlot.SetLZ(-0.00001f);
            //HeadWearSlot.SetLZ(-0.00001f);

            //HeadSlot.UnityTransform.SetLZ(0);
            //if (HeadSlot.UnityTransform.childCount > 1)
            //{
            //    HeadSlot.UnityTransform.GetChild(0).SetLZ(0.00002f);
            //    HeadSlot.UnityTransform.GetChild(1).SetLZ(0f);
            //}

            //DressSlot.UnityTransform.SetLZ(-0.00002f);

            //if (DressSlot.UnityTransform.childCount > 1)
            //{
            //    DressSlot.UnityTransform.GetChild(0).SetLZ(0.00002f);
            //    DressSlot.UnityTransform.GetChild(1).SetLZ(0f);
            //}

            //LeftShoeSlot.SetLZ(-0.00001f);
            //RightShoeSlot.SetLZ(-0.00001f);

            //LeftLegSlot.SetLZ(0);
            //RightLegSlot.SetLZ(0);
            //NeckSlot.SetLZ(0.00001f);
            //LeftHandSlot.SetLZ(-0.00001f);
            //RightHandSlot.SetLZ(-0.00001f);

            //LeftShortSleeveSlot.SetLZ(-0.000015f);
            //RightShortSleeveSlot.SetLZ(-0.000015f);

            //LeftLongSleeveUAC.transform.SetLZ(-0.000015f);
            //RightLongSleeveUAC.transform.SetLZ(-0.000015f);
        }
    }

    private void SetSlotLocalZ(DragonBones.Slot slot, float z)
    {
        if (slot.UnityTransform == null)
        {
            UAC.transform.FindChild(slot.name).SetLZ(z);
        }
        else
        {
            slot.UnityTransform.SetLZ(z);
        }
    }

    private void SetSlotAsFirstChild(DragonBones.Slot slot)
    {
        if (slot.UnityTransform == null)
        {
            UAC.transform.FindChild(slot.name).SetAsFirstSibling();
        }
        else
        {
            slot.UnityTransform.SetAsFirstSibling();
        }
    }

    public void ChangeClose(BodyPart bodyPart, string armatureName, bool setDepth = true)
    {
//		Debug.Log (bodyPart + " " + armatureName);
        List<DragonBones.Slot> slotList = new List<DragonBones.Slot>();

        if (bodyPart == BodyPart.Eye)
        {
            Eye = armatureName;

            slotList.Add(EyeSlot);
        }
        else if (bodyPart == BodyPart.Top)
        {
            Top = armatureName;

            slotList.Add(TopSlot);
        }
        else if (bodyPart == BodyPart.Shoe)
        {
            Shoe = armatureName;

            slotList.Add(LeftShoeSlot);
            slotList.Add(RightShoeSlot);
        }
        else if (bodyPart == BodyPart.Head)
        {
            Head = armatureName;

            slotList.Add(HeadSlot);
        }
        else if (bodyPart == BodyPart.Wing)
        {
            if (Wing == armatureName)
            {
                return;
            }
            else
            {
                Wing = armatureName;

                slotList.Add(WingSlot);
            }
        }
        else if (bodyPart == BodyPart.Dress)
        {
            Dress = armatureName;

            slotList.Add(DressSlot);
        }
        else if (bodyPart == BodyPart.Mouse)
        {
            Mouse = armatureName;
            
            slotList.Add(MouseSlot);
        }
        else if (bodyPart == BodyPart.Headwear)
        {
            HeadWear = armatureName;

            slotList.Add(HeadWearSlot);
        }
        else if (bodyPart == BodyPart.Leg)
        {
            slotList.Add(LeftLegSlot);
            slotList.Add(RightLegSlot);
        }
        else if (bodyPart == BodyPart.LeftHand)
        {
            slotList.Add(LeftHandSlot);
        }
        else if (bodyPart == BodyPart.RightHand)
        {
            slotList.Add(RightHandSlot);
        }
        else if (bodyPart == BodyPart.Neck)
        {
            slotList.Add(NeckSlot);
        }
		else if (bodyPart == BodyPart.LeftLongSleeve)
		{
            LeftLongSleeve = armatureName;

            ChangeClose(LeftLongSleeveUAC, armatureName);

            return;
        }
		else if (bodyPart == BodyPart.LeftShortSleeve)
		{
			LeftShortSleeve = armatureName;
		
			slotList.Add(LeftShortSleeveSlot);
		}
		else if (bodyPart == BodyPart.RightLongSleeve)
		{
		    RightLongSleeve = armatureName;

			ChangeClose(RightLongSleeveUAC, armatureName);

            return;
        }
		else if (bodyPart == BodyPart.RightShortSleeve)
		{
			RightShortSleeve = armatureName;

			slotList.Add(RightShortSleeveSlot);
		}
        else
        {
            throw new Exception();
        }

        ChangeClose(slotList, armatureName, setDepth);


        if (bodyPart == BodyPart.Wing)
        {
            TweenRoot tweenRoot = transform.FindChild("Armature/" + Wing).GetChild(0).CreateTweenScale(new Vector3(1, 1, 1), new Vector3(0.6f, 1, 1), 0.75f, true, true, Curve.Linear);

            tweenRoot.PingPong = true;

            tweenRoot.StartForward();
        }
    }

    public void ChangeClose(List<DragonBones.Slot> slotList, string armatureName, bool setDepth = true)
    {
        for (int i = 0; i < slotList.Count; i++)
        {
            slotList[i].childArmature = UnityFactory.factory.BuildArmature(armatureName, null, null, null, true);
            slotList[i].UnityTransform = slotList[i].childArmature.UnityTransform.parent;
        }

        if (setDepth)
        {
            DelayCall.Call
            (
                1,
                () =>
                {
                    ResetDepth();
                    if (IsDisplayInUGUI) DisplayInUI(UGUIScale);
                }
            );
        }
    }

    public void ChangeClose(UnityArmatureComponent uac, string armatureName, bool setDepth = true)
    {
        if (armatureName == "Empty")
        {
            uac.SetActive(false);
        }
        else
        {
            uac.SetActive(true);
        }

        if (setDepth)
        {
            DelayCall.Call
            (
                1,
                () =>
                {
                    ResetDepth();
                    if (IsDisplayInUGUI) DisplayInUI(UGUIScale);
                }
            );
        }
    }

    #endregion
}