ET/Unity/Assets/Scripts/Codes/HotfixView/Client/Demo/UI/UIStartFightRoom/UIStartFightRoomComponentSystem.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.Experimental.GlobalIllumination;
using UnityEngine.PlayerLoop;
using UnityEngine.UI;

namespace ET.Client
{
    #region 定时器 刷新
    [Invoke(TimerInvokeType.fightTimeShow)]
    public class UIStartFightRoomComponentChecker : ATimer<UIStartFightRoomComponent>
    {
        protected override void Run(UIStartFightRoomComponent self)
        {
            try
            {
                self.Check();
            }
            catch (Exception e)
            {
                Log.Error($"idle check error: {self.Id}\n{e}");
            }
        }
    }

    [Invoke(TimerInvokeType.startFightTimeCount)]
    public class UIStartFightTimeCountChecker : ATimer<UIStartFightRoomComponent>
    {
        protected override void Run(UIStartFightRoomComponent self)
        {
            try
            {
                self.UpdateTimeCount();
            }
            catch (Exception e)
            {
                Log.Error($"idle check error: {self.Id}\n{e}");
            }
        }
    }
    #endregion

    [FriendOf(typeof(UIStartFightRoomComponent))]
	public static class UIStartFightRoomComponentSystem
    {
        public static void Check(this UIStartFightRoomComponent self)
        {
            self.timeTxt.text = string.Format("{0}:{1}", DateTime.Now.Hour, DateTime.Now.Minute);

        }

        public static void UpdateTimeCount(this UIStartFightRoomComponent self)
        {
            if (self.startTimeCount > 0)
            {
                self.timeCountTxt.text = self.startTimeCount.ToString();
            }
            else
            {
                if (self.startTimer > 0)
                    TimerComponent.Instance?.Remove(ref self.startTimer);
                self.timeCountTxt.text = "";
            }
            self.startTimeCount = self.startTimeCount - 1;
        }

        [ObjectSystem]
		public class UIStartFightRoomComponentAwakeSystem : AwakeSystem<UIStartFightRoomComponent>
		{
			protected override void Awake(UIStartFightRoomComponent self, params object[] param)
			{
                ReferenceCollector rc = self.GetParent<UI>().GameObject.GetComponent<ReferenceCollector>();
                //头像部分
                self.houseIdTxt = rc.Get<GameObject>("houseIdTxt");
                self.gameNumTxt = rc.Get<GameObject>("gameNumTxt");
                self.curResidueTxt = rc.Get<GameObject>("curResidueTxt");

                //右上系统信息部分
                self.wifiImage = rc.Get<GameObject>("wifiImage");
                self.powerImage = rc.Get<GameObject>("powerImage");
                var timeTxt = rc.Get<GameObject>("timeTxt");
                self.timeTxt = timeTxt.GetComponent<UnityEngine.UI.Text>();
                self.menuBtn = rc.Get<GameObject>("menuBtn");
                self.menuBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnMenuBtn(); });
                self.faceBtn = rc.Get<GameObject>("faceBtn");
                self.faceBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnFaceBtn(); });
                self.videoBtn = rc.Get<GameObject>("videoBtn");
                self.videoBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnVideoBtn(); });

                //菜单
                self.menuPanel = rc.Get<GameObject>("menuPanel");
                self.menuPanel.SetActive(false);
                self.maskBtn = rc.Get<GameObject>("maskBtn");
                self.maskBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnMenuPanelClose(); });
                self.menuBackBtn = rc.Get<GameObject>("menuBackBtn");
                self.menuBackBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnMenuPanelBack(); });
                self.menuQuitBtn = rc.Get<GameObject>("menuQuitBtn");
                self.menuQuitBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnMenuPanelQuit(); });
                self.menuSettingBtn = rc.Get<GameObject>("menuSettingBtn");
                self.menuSettingBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnMenuPanelSetting(); });

                //表情面板
                self.facePanel = rc.Get<GameObject>("facePanel");
                self.facePanel.SetActive(false);
                self.fastToggleBtn = rc.Get<GameObject>("fastToggleBtn");
                self.fastToggleBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnFaceFastToggleBtn(0); });
                self.faceToggleBtn = rc.Get<GameObject>("faceToggleBtn");
                self.faceToggleBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnFaceFastToggleBtn(1); });
                self.faceAndVideoObj = rc.Get<GameObject>("faceAndVideoObj");
                self.faceAndVideoObj.SetActive(false);
                self.facePanelCloseBtn = rc.Get<GameObject>("facePanelCloseBtn");
                self.facePanelCloseBtn.GetComponent<Button>().onClick.AddListener(() => { self.facePanel.SetActive(false); });

                //表情列表以及快捷语列表
                self.listFastGridBg = rc.Get<GameObject>("listFastGridBg");
                self.listFastGridBg.SetActive(false);
                self.listFastContent = rc.Get<GameObject>("listFastContent");
                self.gridFastItem = rc.Get<GameObject>("gridFastItem");
                self.listFaceGridBg = rc.Get<GameObject>("listFaceGridBg");
                self.listFaceGridBg.SetActive(false);
                self.listFaceContent = rc.Get<GameObject>("listFaceContent");
                self.gridFaceItem = rc.Get<GameObject>("gridFaceItem");

                self.shakeDiceImage1 = rc.Get<GameObject>("shakeDiceImage1");
                self.shakeDiceImage2 = rc.Get<GameObject>("shakeDiceImage2");
                self.shakeDiceImage3 = rc.Get<GameObject>("shakeDiceImage3");
                self.shakeDiceImage4 = rc.Get<GameObject>("shakeDiceImage4");
                self.timeCountTxt = rc.Get<GameObject>("timeCountTxt").GetComponent<UnityEngine.UI.Text>();

              

                //玩
                self.readyBtn = rc.Get<GameObject>("readyBtn");
                self.readyBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnReadyAndInviteBtn(0); });
                self.inviteBtn = rc.Get<GameObject>("inviteBtn");
                self.inviteBtn.GetComponent<Button>().onClick.AddListener(() => { self.OnReadyAndInviteBtn(1); });

                self.fightCardItem = rc.Get<GameObject>("fightCardItem");
                self.fightCardItem.SetActive(false);
                GameUtil.Instance.SetCardCloneItem(self.fightCardItem,0);
                self.fightCardItem1 = rc.Get<GameObject>("fightCardItem1");
                self.fightCardItem1.SetActive(false);
                GameUtil.Instance.SetCardCloneItem(self.fightCardItem1, 1);
                for (int i = 1;i <= 4;i++)
                {
                    UIStartFightRoomPlayerCom uIStartFightRoomPlayerCom = new UIStartFightRoomPlayerCom();
                    var playerObj = rc.Get<GameObject>("player" + i);
                    var playerIconObj = rc.Get<GameObject>("playerIcon" + i);
                    var readyImage = rc.Get<GameObject>("readyImage" + i);
                    var playName = rc.Get<GameObject>("playName" + i).GetComponent<Text>();
                    var playerIconImage = playerIconObj.GetComponent<UnityEngine.UI.Image>();
                    uIStartFightRoomPlayerCom.playerObj = playerObj;
                    uIStartFightRoomPlayerCom.readyImage = readyImage;
                    uIStartFightRoomPlayerCom.playerIcon = playerIconImage;
                    uIStartFightRoomPlayerCom.playName = playName;

                    var fightCardContentNode = rc.Get<GameObject>("fightCardContent" + i);
                    uIStartFightRoomPlayerCom.fightCardNode = fightCardContentNode;

                    var disCardContentNode = rc.Get<GameObject>("disCardContent" + i);
                    uIStartFightRoomPlayerCom.disCardsNode = disCardContentNode;

                    var haveBeenOutContentNode = rc.Get<GameObject>("haveBeenOutContent" + i);
                    uIStartFightRoomPlayerCom.haveBeenOutContentNode = haveBeenOutContentNode;

                    self.uIStartFightRoomPlayerComs.Add(uIStartFightRoomPlayerCom);
                    playerObj.SetActive(false);

                    var playChatObj = rc.Get<GameObject>("playChatObj" + i);
                    self.playChatObjList.Add(playChatObj);
                }

                //操作
                self.operatorObj = rc.Get<GameObject>("operatorObj");
                self.operatorObj.SetActive(false);
                for (int i = 1;i <= 5;i++)
                {
                    int operatorIndex = 1;
                    var operatorObjBtn = rc.Get<GameObject>("operatorBtn" + i);
                    var btn = operatorObjBtn.GetComponent<Button>();
                    operatorIndex = i;
                    btn.onClick.AddListener(()=>
                    {
                        self.OnOperatorBtn(operatorIndex);
                    });
                    self.operatorObj_btn.Add(operatorObjBtn);
                }
                self.Init();
            }
        }

        private static async void Init(this UIStartFightRoomComponent self)
        {
            self.RepeatedTimer = TimerComponent.Instance.NewRepeatedTimer(ConstValue.fightTimeRefreshTime / 2 + 100, TimerInvokeType.fightTimeShow, self);
            var startFightRoomInfo = self.ClientScene().GetComponent<StartFightRoomComponment>().GetStartFightRoomInfo();
            CommonBridge.Instance.dispathPush += DispathPush;
            self.readyBtn.SetActive(true);
            self.inviteBtn.SetActive(true);
            self.houseIdTxt.GetComponent<Text>().text = startFightRoomInfo.roomInfo.RoomId.ToString();
            self.gameNumTxt.GetComponent<Text>().text = startFightRoomInfo.roomInfo.OwnerId.ToString();
            self.curResidueTxt.GetComponent<Text>().text = "0";
            await SoundManager.Instance.PlaySound("common_playing", true);
        }

        private static async void DispathPush(Scene scene, object type)
        {
            var ui = scene.GetComponent<UIComponent>().Get(UIType.UIStartFightRoom);
            var startFightRoomInfo = scene.GetComponent<StartFightRoomComponment>().GetStartFightRoomInfo();
            switch (type)
            {
                case EventType.JoinRoomPush:
                    {
                        var startFightRoomComponentUI = ui.GetComponent<UIStartFightRoomComponent>();
                        //处理其他玩家信息
                        for (int i = 1; i < startFightRoomComponentUI.uIStartFightRoomPlayerComs.Count; i++)
                        {
                            startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].playerObj.SetActive(false);
                        }
                        if (startFightRoomInfo.roomInfo.OtherInfo != null && startFightRoomInfo.roomInfo.OtherInfo.Count > 0)
                        {
                            for (int i = 0; i < startFightRoomInfo.roomInfo.OtherInfo.Count; i++)
                            {
                                var otherPlayInfo = startFightRoomInfo.roomInfo.OtherInfo[i];
                                if (i >= startFightRoomComponentUI.uIStartFightRoomPlayerComs.Count - 1)
                                {
                                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i + 1].playerObj.SetActive(false);
                                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i + 1].playName.text = "";
                                }
                                else
                                {
                                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i + 1].playerObj.SetActive(true);
                                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i + 1].readyImage.SetActive(false);
                                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i + 1].playName.text = startFightRoomInfo.roomInfo.OtherInfo[i].name;
                                }
                            }
                        }
                        RefreshOrientation(startFightRoomInfo.roomInfo.OpPos, startFightRoomComponentUI);
                        break;
                    }
                case EventType.ReadyPush:
                    {
                        var startFightRoomComponent = ui.GetComponent<UIStartFightRoomComponent>();
                        //先处理自己的信息
                        if (startFightRoomInfo.roomInfo.MyInfo != null)
                        {
                            startFightRoomComponent.readyBtn.SetActive(startFightRoomInfo.roomInfo.MyInfo.state == 0);
                            startFightRoomComponent.inviteBtn.SetActive(startFightRoomInfo.roomInfo.MyInfo.state == 0);
                            startFightRoomComponent.uIStartFightRoomPlayerComs[0].playerObj.SetActive(true);
                            startFightRoomComponent.faceAndVideoObj.SetActive(true);
                            startFightRoomComponent.uIStartFightRoomPlayerComs[0].readyImage.SetActive(startFightRoomInfo.roomInfo.MyInfo.state == 1);
                        }
                        //处理其他玩家信息
                        for (int i = 1;i < startFightRoomComponent.uIStartFightRoomPlayerComs.Count;i++)
                        {
                            startFightRoomComponent.uIStartFightRoomPlayerComs[i].playerObj.SetActive(false);
                        }
                        if (startFightRoomInfo.roomInfo.OtherInfo != null && startFightRoomInfo.roomInfo.OtherInfo.Count > 0)
                        {
                            for (int i = 0; i < startFightRoomInfo.roomInfo.OtherInfo.Count; i++)
                            {
                                var otherPlayInfo = startFightRoomInfo.roomInfo.OtherInfo[i];
                                if (i >= startFightRoomComponent.uIStartFightRoomPlayerComs.Count - 1)
                                {
                                    startFightRoomComponent.uIStartFightRoomPlayerComs[i + 1].playerObj.SetActive(false);
                                }
                                else
                                {
                                    startFightRoomComponent.uIStartFightRoomPlayerComs[i + 1].playerObj.SetActive(true);
                                    startFightRoomComponent.uIStartFightRoomPlayerComs[i + 1].readyImage.SetActive(otherPlayInfo.state == 1);
                                }
                            }
                        }
                        break;
                    }
                case EventType.ReadyStartPush:
                    {
                        //开始 倒计时
                        Log.Error("@@@@@  倒计时： " + startFightRoomInfo.readyStartTimeCount);
                        var startFightRoomComponentUI = ui.GetComponent<UIStartFightRoomComponent>();
                        startFightRoomComponentUI.startTimeCount = startFightRoomInfo.readyStartTimeCount;
                        startFightRoomComponentUI.startTimer = TimerComponent.Instance.NewRepeatedTimer(ConstValue.fightTimeRefreshTime / 2 + 100, TimerInvokeType.startFightTimeCount, startFightRoomComponentUI);
                        break;
                    }
                case EventType.GameStartPush:
                case EventType.GameDrawCardPush:
                case EventType.GameOperationPush:
                case EventType.KickPush:
                    {
                        //正式开始 发牌
                        var startFightRoomComponentUI = ui.GetComponent<UIStartFightRoomComponent>();
                        var myCardInfo = startFightRoomInfo.roomInfo.MyInfo;
                        var roleInfo = scene.GetComponent<RoleInfoComponment>().GetRoleInfo();
                        if (myCardInfo != null && myCardInfo.cardInfo != null && myCardInfo.cardInfo.Acts.Count > 0 && roleInfo.roleId == myCardInfo.id)
                        {
                            //处理操作按钮
                            for (int i = 0; i < startFightRoomComponentUI.operatorObj_btn.Count; i++)
                            {
                                startFightRoomComponentUI.operatorObj_btn[i].SetActive(false);
                            }
                            for (int i = 0; i < myCardInfo.cardInfo.Acts.Count; i++)
                            {
                                if (myCardInfo.cardInfo.Acts[i] == 1)
                                {
                                    if (!startFightRoomComponentUI.operatorObj.activeInHierarchy)
                                    {
                                        startFightRoomComponentUI.operatorObj.SetActive(true);
                                    }
                                    startFightRoomComponentUI.operatorObj_btn[i].SetActive(true);
                                }
                            }
                        }
                        RefreshPlayCardList(scene, startFightRoomInfo, startFightRoomComponentUI);
                        break;
                    }
                case EventType.GameDisCardPush:
                    {
                        //其他玩家出推送，处理自己的操作
                        var startFightRoomComponentUI = ui.GetComponent<UIStartFightRoomComponent>();
                        var roomInfo = startFightRoomInfo.roomInfo;
                        var myCardInfo = roomInfo.MyInfo;
                        var roleInfo = scene.GetComponent<RoleInfoComponment>().GetRoleInfo();
                        if (myCardInfo != null && myCardInfo.cardInfo != null && myCardInfo.cardInfo.Acts.Count > 0 && roleInfo.roleId == myCardInfo.id)
                        {
                            //处理操作按钮
                            for (int i = 0;i < startFightRoomComponentUI.operatorObj_btn.Count;i++)
                            {
                                startFightRoomComponentUI.operatorObj_btn[i].SetActive(false);
                            }
                            for (int i = 0; i < myCardInfo.cardInfo.Acts.Count; i++)
                            {
                                if (myCardInfo.cardInfo.Acts[i] == 1)
                                {
                                    if (!startFightRoomComponentUI.operatorObj.activeInHierarchy)
                                    {
                                        startFightRoomComponentUI.operatorObj.SetActive(true);
                                    }
                                    startFightRoomComponentUI.operatorObj_btn[i].SetActive(true);
                                }
                            }
                            //重置所有牌的状态
                            var parentNode = startFightRoomComponentUI.uIStartFightRoomPlayerComs[0].fightCardNode;
                            for (int i = 0;i < parentNode.transform.childCount;i++)
                            {
                                StartFightCardItem startFightCardItem = parentNode.transform.GetChild(i).gameObject.GetComponent<StartFightCardItem>();
                                startFightCardItem.GetDown();
                            }
                            GameObjectPool.Instance.ClearRealySelCardList();

                            //抬起
                            if (myCardInfo.cardInfo != null && myCardInfo.cardInfo.ActInfo != null && myCardInfo.cardInfo.ActInfo.Count > 0 && roleInfo.roleId == myCardInfo.id)
                            {
                                for (int i = 0; i < myCardInfo.cardInfo.ActInfo.Count; i++)
                                {
                                    //根据服务器信息 弹起响应的牌
                                    DisCardPushWithOperator(parentNode.transform, myCardInfo.cardInfo.ActInfo[i]);
                                }
                            }
                            
                            //记录当前出的牌
                            GameUtil.Instance.curCardVal = startFightRoomInfo.roomInfo.CurDisCard;
                            Log.Error("当前出的牌: " + GameUtil.Instance.curCardVal);
                        }

                        if (startFightRoomInfo.roomInfo.Time > 0)
                        {
                            startFightRoomComponentUI.startTimeCount = startFightRoomInfo.roomInfo.Time;
                            startFightRoomComponentUI.startTimer = TimerComponent.Instance.NewRepeatedTimer(ConstValue.fightTimeRefreshTime / 2 + 100, TimerInvokeType.startFightTimeCount, startFightRoomComponentUI);
                        }
                        else
                        {
                            Log.Error("清空回合倒计时");
                            if (startFightRoomComponentUI.startTimer > 0)
                            {
                                startFightRoomComponentUI.timeCountTxt.text = "";
                                TimerComponent.Instance?.Remove(ref startFightRoomComponentUI.startTimer);
                            }
                        }
                        break;
                    }
                case EventType.HGHHSettlementPush:
                    {
                         Log.Error("@#@#@@@@@  " + startFightRoomInfo.settlementInfo.CurRound);
                        await UIHelper.Create(scene, UIType.UISettle, UILayer.Mid);
                        break;
                    }
            }
        }

        #region 右上系统部分
        public static void OnMenuBtn(this UIStartFightRoomComponent self)
        {
            self.menuPanel.SetActive(!self.menuPanel.activeInHierarchy);
        }

        public static async void OnFaceBtn(this UIStartFightRoomComponent self)
        {
            await SoundManager.Instance.PlaySound("clickbtnsound");
            self.facePanel.SetActive(true);
            self.LoadChatData(0);
        }

        public static void OnVideoBtn(this UIStartFightRoomComponent self)
        {

        }
        #endregion

        #region 菜单
        public static void OnMenuPanelClose(this UIStartFightRoomComponent self)
        {
            self.menuPanel.SetActive(false);
        }

        public static async void OnMenuPanelBack(this UIStartFightRoomComponent self)
        {
            Action<object> myAction = (param) =>
            {
                int result = (int)param;
                if (result == 1)
                {
                    self.ReturnMainUI().Coroutine();
                }
            };
            Dictionary<string,object> dic = new Dictionary<string, object>()
            {
                { "callback",myAction},
                { "title","提示"},
                { "content","返回大厅，你的房间仍会保留。"},
                { "yesTxt","确定"},
                { "cancelTxt","取消"},
            };
            await SoundManager.Instance.PlaySound("clickbtnsound");
            await UIHelper.Create(self.ClientScene(), UIType.UIAlert, UILayer.High, dic);
        }

        public static void OnMenuPanelQuit(this UIStartFightRoomComponent self)
        {

        }

        public static void OnMenuPanelSetting(this UIStartFightRoomComponent self)
        {

        }
        #endregion

        #region 表情
        public static async void OnFaceFastToggleBtn(this UIStartFightRoomComponent self,int index)
        {
            await SoundManager.Instance.PlaySound("clickbtnsound");
            self.LoadChatData(index);
        }

        static async void LoadChatData(this UIStartFightRoomComponent self, int index)
        {
            self.listFaceGridBg.SetActive(false);
            self.listFastGridBg.SetActive(false);
            string[] abName = new string[] { "com_bg1", "com_bg2" };
            await ResourcesComponentHelper.Instance.LoadSprite(self.ClientScene(), "commonatlas");
            Sprite sprite = ResourcesComponentHelper.Instance.GetSprite("commonatlas", abName[0]);
            Sprite sprite1 = ResourcesComponentHelper.Instance.GetSprite("commonatlas", abName[1]);
            self.fastToggleBtn.GetComponent<UnityEngine.UI.Image>().sprite = index == 0 ? sprite: sprite1;
            self.faceToggleBtn.GetComponent<UnityEngine.UI.Image>().sprite = index == 1 ? sprite : sprite1;
            self.CleanChatItem(index);
            if (index == 0)
            {
                self.listFastGridBg.SetActive(true);
                var startFightRoomInfo = self.ClientScene().GetComponent<StartFightRoomComponment>().GetStartFightRoomInfo();
                int sexType = startFightRoomInfo.roomInfo.MyInfo.sex;
                var fightConfig = FightChatConfigCategory.Instance.GetAll();
                var achievedDic = fightConfig.Where(kvp => kvp.Value.Type == sexType);
                foreach (var item in achievedDic)
                {
                    if (GameObjectPool.Instance.chatFastItemPools.Count > 0)
                    {
                        GameObject uiFastItem = GameObjectPool.Instance.chatFastItemPools[0];
                        GameObjectPool.Instance.chatFastItemPools.RemoveAt(0);
                        uiFastItem.SetActive(true);
                        uiFastItem.transform.SetParent(self.listFastContent.transform, false);
                        var txt = uiFastItem.GetComponentInChildren<UnityEngine.UI.Text>();
                        txt.text = item.Value.Desc;
                        var btn = txt.gameObject.GetComponent<Button>();
                        btn.onClick.RemoveAllListeners();
                        btn.onClick.AddListener(async () =>
                        {
                            Log.Error("btn click1:  " + item.Value.Desc + "  vedio:  " + item.Value.VedioPath);
                            await SoundManager.Instance.PlaySound(item.Value.VedioPath);
                            self.facePanel.SetActive(false);
                            self.playChatObjList[0].SetActive(true);
                            var playChatTxt = self.playChatObjList[0].GetComponentInChildren<UnityEngine.UI.Text>();
                            playChatTxt.text = item.Value.Desc;
                            await TimerComponent.Instance.WaitAsync(3000);
                            self.playChatObjList[0].SetActive(false);
                        });
                    }
                    else
                    {
                        var uiFastItem = GameUtil.Instance.InitializeObj(self.gridFastItem);
                        uiFastItem.gameObject.SetActive(true);
                        uiFastItem.transform.SetParent(self.listFastContent.transform, false);
                        var txt = uiFastItem.GetComponentInChildren<UnityEngine.UI.Text>();
                        txt.text = item.Value.Desc;
                        var btn = txt.gameObject.GetComponent<Button>();
                        btn.onClick.RemoveAllListeners();
                        btn.onClick.AddListener(async () =>
                        {
                            Log.Error("btn click1:  " + item.Value.Desc + "  vedio:  " + item.Value.VedioPath);
                            await SoundManager.Instance.PlaySound(item.Value.VedioPath);
                            self.facePanel.SetActive(false);
                            self.playChatObjList[0].SetActive(true);
                            var playChatTxt = self.playChatObjList[0].GetComponentInChildren<UnityEngine.UI.Text>();
                            playChatTxt.text = item.Value.Desc;
                            await TimerComponent.Instance.WaitAsync(3000);
                            self.playChatObjList[0].SetActive(false);
                        });
                    }
                }
            }
            else
            { 
            
            }
        }

        static void CleanChatItem(this UIStartFightRoomComponent self,int index)
        {
            Transform node = null;
            List<GameObject> list = null;
            if (index == 0)
            {
                node = self.listFastContent.transform;
                list = GameObjectPool.Instance.chatFastItemPools;
            }
            else
            {
                node = self.listFaceContent.transform;
                list = GameObjectPool.Instance.chatFaceItemPools;
            }
            for (int i = 0; i < node.childCount; i++)
            {
                var child = node.GetChild(i);
                list.Add(child.gameObject);
                child.gameObject.SetActive(false);
            }
        }
        #endregion

        #region 邀请以及准备
        public static void OnReadyAndInviteBtn(this UIStartFightRoomComponent self, int index)
        {
            if (index == 0)
            {
                self.ReadyRes().Coroutine();
            }
            else
            {
                //邀请
            }
        }
        #endregion

        public static void SetBattery()
        {
            //var level = SystemInfo.batteryLevel == -1 ? 1 : SystemInfo.batteryLevel;
            //batteryLevelImg.fillAmount = level;
            //batteryTxt.text = (level * 100).ToString() + "%";
            //var isCharging = SystemInfo.batteryStatus == BatteryStatus.Charging;
            //charging.gameObject.SetActive(isCharging);
        }

        static async ETTask ReturnMainUI(this UIStartFightRoomComponent self)
        {
            var scene = self.ClientScene();
            await UIHelper.Remove(scene, UIType.UIStartFightRoom);
            var startFightRoomInfo = scene.GetComponent<StartFightRoomComponment>().GetStartFightRoomInfo();
            Dictionary<string, object> dic = new Dictionary<string, object>()
            {
                { "result",1},
                { "roomId",startFightRoomInfo.roomInfo.RoomId.ToString()}
            };
            await UIHelper.Create(scene, UIType.UIMain, UILayer.Hidden, dic);
        }

        static async ETTask ReadyRes(this UIStartFightRoomComponent self)
        {
            //try
            {
                var scene = self.ClientScene();
                var session = scene.GetComponent<SessionComponent>().Session;
                if (session != null)
                {
                    G2C_HGHHReady g2Ready = (G2C_HGHHReady)await session.Call(
                        new C2G_HGHHReady() { });
                    if (g2Ready.Error != ErrorCode.ERR_Success)
                    {
                        Log.Error($"g2Ready错误...errCode={g2Ready.Error}" + "    mess:  " + g2Ready.Message);
                        return;
                    }
                }
            }
            //catch (Exception e)
            //{
            //    Log.Error($"准备出错...{e.Message}");
            //}
        }

        public static async void OnCloseAsync(this UIStartFightRoomComponent self)
        {
            await UIHelper.Remove(self.ClientScene(),UIType.UIStartFightRoom);
        }

        //操作请求
        public static async void OnOperatorBtn(this UIStartFightRoomComponent self, int operatorIndex)
        {
            var startFightRoomInfo = GameUtil.Instance.GetSceneComponent().GetComponent<StartFightRoomComponment>().GetStartFightRoomInfo();
            int sexType = startFightRoomInfo.roomInfo.MyInfo.sex;
            switch (operatorIndex)
            {
                //1-5 吃碰杠胡过
                case 1:
                    {
                        //吃
                        //var list = GameObjectPool.Instance.GetRealySelCardList();
                        //if (list == null || list.Count <= 0 || list.Count > 3)
                        //{
                        //    await CommonUtil.Instance.OpenCommonServerMsgPanel("出牌不符合条件，请重新调整   " + string.Join(", ", list));
                        //    return;
                        //}
                        //var isSequence = GameUtil.Instance.CheckIsSequence(list);
                        //if (!isSequence)
                        //{
                        //    await CommonUtil.Instance.OpenCommonServerMsgPanel("出牌不符合条件，请重新调整   " + string.Join(", ", list));
                        //    return;
                        //}
                        int cardVal = GameUtil.Instance.curRequestCardVal;
                        Log.Error("当前吃牌请求发送的值：  " + cardVal);
                        Dictionary<string, object> dic = new Dictionary<string, object>()
                        {
                            { "OpType",operatorIndex},
                            { "Card",cardVal}
                        };
                        await RequestServerUtil.Instance.OpenRequestServer(HGHHMessage.C2G_HGHHOperation, dic,async (messageObj, errorCode) =>
                        {
                            if (errorCode != ErrorCode.ERR_Success)
                            {
                                await CommonUtil.Instance.OpenCommonServerMsgPanel($"操作失败，errCode={errorCode},operatorType={operatorIndex}");
                                return;
                            }
                            string soundStrType = sexType == 0 ? GameSetting.Instance.disCardBoySoundName : GameSetting.Instance.disCardGirlSoundName;
                            await SoundManager.Instance.PlaySound(string.Concat(soundStrType, "chi"));
                            self.operatorObj.SetActive(false);
                        });
                        break;
                    }
                case 2:
                case 3:
                case 5:
                    {
                        var cardType = 0;
                        if (operatorIndex == 2)
                        {
                            var list = GameObjectPool.Instance.GetRealySelCardList();
                            cardType = list[0];
                        }
                        
                        //peng 杠 guo
                        Dictionary<string, object> dic = new Dictionary<string, object>()
                        {
                            { "OpType",operatorIndex},
                            { "Card",cardType}
                        };
                        await RequestServerUtil.Instance.OpenRequestServer(HGHHMessage.C2G_HGHHOperation, dic, async (messageObj, errorCode) =>
                        {
                            if (errorCode != ErrorCode.ERR_Success)
                            {
                                await CommonUtil.Instance.OpenCommonServerMsgPanel($"操作失败，errCode={errorCode},operatorType={operatorIndex}");
                                return;
                            }
                            self.operatorObj.SetActive(false);
                            if (operatorIndex == 2 || operatorIndex == 3)
                            {
                                string soundStrType = sexType == 0 ? GameSetting.Instance.disCardBoySoundName : GameSetting.Instance.disCardGirlSoundName;
                                string destSoundStr = operatorIndex == 2? "peng": "hu";
                                await SoundManager.Instance.PlaySound(string.Concat(soundStrType, destSoundStr));
                            }
                        });
                        break;
                    }
                case 4:
                    {
                        //胡
                        int cardVal = GameUtil.Instance.curRequestCardVal;
                        Log.Error("当前杠牌请求发送的值：  " + cardVal);
                        Dictionary<string, object> dic = new Dictionary<string, object>()
                        {
                            { "OpType",operatorIndex},
                            { "Card",cardVal}
                        };
                        await RequestServerUtil.Instance.OpenRequestServer(HGHHMessage.C2G_HGHHOperation, dic, async (messageObj, errorCode) =>
                        {
                            if (errorCode != ErrorCode.ERR_Success)
                            {
                                await CommonUtil.Instance.OpenCommonServerMsgPanel($"操作失败，errCode={errorCode},operatorType={operatorIndex}");
                                return;
                            }
                            self.operatorObj.SetActive(false);
                            string soundStrType = sexType == 0 ? GameSetting.Instance.disCardBoySoundName : GameSetting.Instance.disCardGirlSoundName;
                            await SoundManager.Instance.PlaySound(string.Concat(soundStrType, "gang"));
                        });
                        break;
                    }
            }
        }

        public static async void RefreshPlayCardList(Scene scene,StartFightRoomInfo startFightRoomInfo, UIStartFightRoomComponent startFightRoomComponentUI)
        {
            var allPos = GetPosList(startFightRoomInfo.roomInfo.MyInfo.pos);
            List<PlayerInfo> allPlayerInfo = new List<PlayerInfo>();
            allPlayerInfo.Add(startFightRoomInfo.roomInfo.MyInfo);
            allPlayerInfo.AddRange(startFightRoomInfo.roomInfo.OtherInfo);
            var roleInfo = scene.GetComponent<RoleInfoComponment>().GetRoleInfo();
            for (int i = 0; i < allPos.Count; i++)
            {
                var playInfo = GetOtherPlayInfoByPos(allPlayerInfo, allPos[i]);
                if (playInfo == null)
                {
                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].playerObj.SetActive(false);
                }
                else
                {
                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].playerObj.SetActive(true);
                    startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].readyImage.SetActive(false);
                    //身上的牌列表
                    var fightCardParentNode = startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].fightCardNode;
                    //已出过牌的列表
                    var disCardParentNode = startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].disCardsNode;
                    //操作过的 如 吃 碰 杠 列表
                    var haveBeenOutContentNode = startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].haveBeenOutContentNode;

                    //playInfo.cardInfo.RemainCards
                    if (roleInfo.roleId == playInfo.id)
                    {
                        playInfo.cardInfo.RemainCards.Sort();
                        Log.Error("@@@@@@###  RemainCards:   " + string.Join(",", playInfo.cardInfo.RemainCards) + "    Count:  " + playInfo.cardInfo.RemainCards.Count);
                    }
                    int type = i;
                    if (i == 0 || i == 2)
                    {
                        type = 0;
                    }
                    CleanCardItemList(fightCardParentNode.transform, 0);
                    for (int p = 0; p < playInfo.cardInfo.RemainCardsNum; p++)
                    {
                        //if (GameObjectPool.Instance.fightCardItemPools.Count > 0 && GameObjectPool.Instance.fightCardItemPools.ContainsKey(type) && GameObjectPool.Instance.fightCardItemPools[type].Count > 0)
                        //{
                        //    GameObject uifightItem = GameObjectPool.Instance.fightCardItemPools[type][0];
                        //    GameObjectPool.Instance.fightCardItemPools[type].RemoveAt(0);
                        //    uifightItem.gameObject.SetActive(true);
                        //    uifightItem.transform.SetParent(fightCardParentNode.transform, false);

                        //    if (roleInfo.roleId == playInfo.id)
                        //    {
                        //        var value = playInfo.cardInfo.RemainCards[p];
                        //        StartFightCardItem startFightCardItem = uifightItem.GetComponent<StartFightCardItem>();
                        //        if (startFightCardItem == null)
                        //            startFightCardItem = uifightItem.AddComponent<StartFightCardItem>();

                        //        startFightCardItem.Init(uifightItem.GetComponentInChildren<UnityEngine.UI.Image>(), value, (val) =>
                        //        {
                        //            if (playInfo.pos != startFightRoomInfo.roomInfo.OpPos || playInfo.id != startFightRoomInfo.roomInfo.OpId)
                        //            {
                        //                Log.Error($"@@@ 不是自己回合  state: {playInfo.state}  ===>opPos:  {startFightRoomInfo.roomInfo.OpPos}  ===> ID：{playInfo.id}  ===>  opId:  {startFightRoomInfo.roomInfo.OpId}");
                        //                return;
                        //            }
                        //            DisCardRequest(val, startFightRoomComponentUI).Coroutine();
                        //        });
                        //    }
                        //    else
                        //    {
                        //        string spiring = "";
                        //        switch (i)
                        //        {
                        //            case 1:
                        //                {
                        //                    //右
                        //                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByRight, "0");
                        //                    break;
                        //                }
                        //            case 2:
                        //                {
                        //                    //shang
                        //                    spiring = string.Concat(GameSetting.Instance.selfPlayCardCenterSpiteName, "0");
                        //                    break;
                        //                }
                        //            case 3:
                        //                {
                        //                    //zuo
                        //                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByLeft, "0");
                        //                    break;
                        //                }
                        //        }
                        //        var sprite = await GameObjectPool.Instance.AcquireSprite(spiring);
                        //        UnityEngine.UI.Image icon = uifightItem.GetComponentInChildren<UnityEngine.UI.Image>();
                        //        icon.sprite = sprite;
                        //        var btn = icon.gameObject.GetComponent<Button>();
                        //        btn.onClick.RemoveAllListeners();
                        //        //btn.onClick.AddListener(() =>
                        //        //{
                        //        //    Log.Error("card Click...");
                        //        //});
                        //    }
                        //}
                        //else
                        {
                            if (roleInfo.roleId == playInfo.id)
                            {
                                var uifightItem = GameUtil.Instance.InitializeObj(GameUtil.Instance.GetCardCloneItem(0));
                                uifightItem.SetActive(true);
                                uifightItem.transform.SetParent(fightCardParentNode.transform, false);
                                var value = playInfo.cardInfo.RemainCards[p];
                                StartFightCardItem startFightCardItem = uifightItem.GetComponent<StartFightCardItem>();
                                if (startFightCardItem == null)
                                    startFightCardItem = uifightItem.AddComponent<StartFightCardItem>();

                                startFightCardItem.Init(uifightItem.GetComponentInChildren<UnityEngine.UI.Image>(), value, (val) =>
                                {
                                    if (playInfo.pos != startFightRoomInfo.roomInfo.OpPos || playInfo.id != startFightRoomInfo.roomInfo.OpId)
                                    {
                                        Log.Error($"@@@ 不是自己回合  state: {playInfo.state}  ===>opPos:  {startFightRoomInfo.roomInfo.OpPos}  ===> ID：{playInfo.id}  ===>  opId:  {startFightRoomInfo.roomInfo.OpId}");
                                        return;
                                    }
                                    DisCardRequest(val, startFightRoomComponentUI).Coroutine();
                                });
                            }
                            else
                            {
                                string spiring = "";
                                Vector2 sizeDelta = Vector2.zero;
                                switch (i)
                                {
                                    case 1:
                                        {
                                            //右
                                            spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByRight, "0");
                                            sizeDelta = GameUtil.Instance.otherHandCardSize;
                                            break;
                                        }
                                    case 2:
                                        {
                                            //shang
                                            spiring = string.Concat(GameSetting.Instance.selfPlayCardCenterSpiteName, "0");
                                            sizeDelta = new Vector2(GameUtil.Instance.otherHandCardSize.y, GameUtil.Instance.otherHandCardSize.x);
                                            break;
                                        }
                                    case 3:
                                        {
                                            //zuo
                                            spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByLeft, "0");
                                            sizeDelta = GameUtil.Instance.otherHandCardSize;
                                            break;
                                        }
                                }
                                var uifightItem = GameUtil.Instance.InitializeObj(GameUtil.Instance.GetCardCloneItem(1));
                                uifightItem.SetActive(true);
                                uifightItem.transform.SetParent(fightCardParentNode.transform, false);
                                var sprite = await GameObjectPool.Instance.AcquireSprite(spiring);
                                UnityEngine.UI.Image icon = uifightItem.GetComponentInChildren<UnityEngine.UI.Image>();
                                icon.sprite = sprite;
                                var btn = icon.gameObject.GetComponent<Button>();
                                btn.onClick.RemoveAllListeners();
                                icon.gameObject.GetComponent<RectTransform>().sizeDelta = sizeDelta;
                            }
                        }
                        startFightRoomComponentUI.uIStartFightRoomPlayerComs[i].playName.text = playInfo.name;
                    }
                    //已经出过的牌列表
                    type = i;
                    if (i == 0 || i == 2)
                    {
                        type = 0;
                    }
                    CleanCardItemList(disCardParentNode.transform, 1);
                    if (playInfo.cardInfo.DisCards != null && playInfo.cardInfo.DisCards.Count > 0)
                    {
                        disCardParentNode.transform.parent.gameObject.SetActive(true);
                        disCardParentNode.SetActive(true);
                        Log.Error("@@@@@@###  disCarsd:   " + string.Join(",",playInfo.cardInfo.DisCards));
                        for (int l = 0; l < playInfo.cardInfo.DisCards.Count; l++)
                        {
                            int value = playInfo.cardInfo.DisCards[l];
                            //if (GameObjectPool.Instance.disCardItemPools.Count > 0 && GameObjectPool.Instance.disCardItemPools.ContainsKey(type) && GameObjectPool.Instance.disCardItemPools[type].Count > 0)
                            //{
                            //    GameObject uiDisItem = GameObjectPool.Instance.disCardItemPools[type][0];
                            //    GameObjectPool.Instance.disCardItemPools[type].RemoveAt(0);
                            //    uiDisItem.gameObject.SetActive(true);
                            //    uiDisItem.transform.SetParent(disCardParentNode.transform, false);
                            //    string spiring = "";
                            //    Vector2 sizeDelta = Vector2.zero;
                            //    if (roleInfo.roleId == playInfo.id)
                            //    {
                            //        spiring = string.Concat(GameSetting.Instance.selfPlayCardShowSpiteName, value);
                            //        sizeDelta = GameUtil.Instance.myShowCard;
                            //    }
                            //    else
                            //    {
                            //        switch (i)
                            //        {
                            //            case 1:
                            //                {
                            //                    //右
                            //                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByRight, value);
                            //                    break;
                            //                }
                            //            case 2:
                            //                {
                            //                    //shang
                            //                    spiring = string.Concat(GameSetting.Instance.selfPlayCardCenterSpiteName, value);
                            //                    break;
                            //                }
                            //            case 3:
                            //                {
                            //                    //zuo
                            //                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByLeft, value);
                            //                    sizeDelta = GameUtil.Instance.otherLeftCardSize;
                            //                    break;
                            //                }
                            //        }
                            //    }
                                
                            //    var sprite = await GameObjectPool.Instance.AcquireSprite(spiring);
                            //    UnityEngine.UI.Image icon = uiDisItem.GetComponentInChildren<UnityEngine.UI.Image>();
                            //    icon.sprite = sprite;
                            //    icon.gameObject.GetComponent<RectTransform>().sizeDelta = sizeDelta;
                            //}
                            //else
                            {
                                string spiring = "";
                                Vector2 sizeDelta = Vector2.zero;
                                if (roleInfo.roleId == playInfo.id)
                                {
                                    spiring = string.Concat(GameSetting.Instance.selfPlayCardShowSpiteName, value);
                                    sizeDelta = GameUtil.Instance.myShowCard;
                                }
                                else
                                {
                                    switch (i)
                                    {
                                        case 1:
                                            {
                                                //右
                                                spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByRight, value);
                                                sizeDelta = GameUtil.Instance.otherLeftCardSize;
                                                break;
                                            }
                                        case 2:
                                            {
                                                //shang
                                                spiring = string.Concat(GameSetting.Instance.selfPlayCardCenterSpiteName, value);
                                                sizeDelta = new Vector2(GameUtil.Instance.otherLeftCardSize.y, GameUtil.Instance.otherLeftCardSize.x);
                                                break;
                                            }
                                        case 3:
                                            {
                                                //zuo
                                                spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByLeft, value);
                                                sizeDelta = GameUtil.Instance.otherLeftCardSize;
                                                break;
                                            }
                                    }
                                }
                                var uiDisItem = GameUtil.Instance.InitializeObj(GameUtil.Instance.GetCardCloneItem(roleInfo.roleId == playInfo.id?0:1));
                                uiDisItem.SetActive(true);
                                uiDisItem.transform.SetParent(disCardParentNode.transform, false);
                                var sprite = await GameObjectPool.Instance.AcquireSprite(spiring);
                                UnityEngine.UI.Image icon = uiDisItem.GetComponentInChildren<UnityEngine.UI.Image>();
                                icon.sprite = sprite;
                                icon.gameObject.GetComponent<RectTransform>().sizeDelta = sizeDelta;
                            }
                        }
                    }

                    //已经操作过 如 碰 吃刚列表
                    type = i;
                    if (i == 0 || i == 2)
                    {
                        type = 0;
                    }
                    CleanCardItemList(haveBeenOutContentNode.transform,2);
                    if (playInfo.cardInfo.UsedInfo != null && playInfo.cardInfo.UsedInfo.Count > 0)
                    {
                        haveBeenOutContentNode.transform.parent.gameObject.SetActive(true);
                        haveBeenOutContentNode.SetActive(true);
                        var len = playInfo.cardInfo.UsedInfo.Count;
                        for (int l = 0;l < playInfo.cardInfo.UsedInfo.Count;l++)
                        {
                            //这里只存一张 根据类型 自己去补
                            ActInfo actInfo = playInfo.cardInfo.UsedInfo[l];
                            List<int> havCardVals = null;
                            ActInfoType actInfoType = (ActInfoType)actInfo.Type;
                            switch (actInfoType)
                            {
                                case ActInfoType.LightPole:
                                case ActInfoType.BackPole:
                                case ActInfoType.DarkPole:
                                    {
                                        havCardVals = new List<int>() { actInfo.Card, actInfo.Card, actInfo.Card, actInfo.Card};
                                        break;
                                    }
                                case ActInfoType.Peng:
                                    {
                                        havCardVals = new List<int>() { actInfo.Card, actInfo.Card, actInfo.Card};
                                        break;
                                    }
                                case ActInfoType.Chi:
                                    {
                                        havCardVals = new List<int>() { actInfo.Card, actInfo.Card + 1, actInfo.Card + 2};
                                        break;
                                    }
                            }
                            for (int k = 0;k < havCardVals.Count;k++)
                            {
                                Log.Error("##@###@@@@@");
                                //if (GameObjectPool.Instance.havCardItemPools.Count > 0 && GameObjectPool.Instance.havCardItemPools.ContainsKey(type) && GameObjectPool.Instance.havCardItemPools[type].Count > 0)
                                //{
                                //    GameObject uiHavItem = GameObjectPool.Instance.havCardItemPools[type][0];
                                //    GameObjectPool.Instance.havCardItemPools[type].RemoveAt(0);
                                //    uiHavItem.gameObject.SetActive(true);
                                //    uiHavItem.transform.SetParent(haveBeenOutContentNode.transform, false);
                                //    string spiring = "";
                                //    if (roleInfo.roleId == playInfo.id)
                                //    {
                                //        spiring = string.Concat(GameSetting.Instance.selfPlayCardShowSpiteName, havCardVals[k]);
                                //    }
                                //    else
                                //    {
                                //        switch (i)
                                //        {
                                //            case 1:
                                //                {
                                //                    //右
                                //                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByRight, havCardVals[k]);
                                //                    break;
                                //                }
                                //            case 2:
                                //                {
                                //                    //shang
                                //                    spiring = string.Concat(GameSetting.Instance.selfPlayCardCenterSpiteName, havCardVals[k]);
                                //                    break;
                                //                }
                                //            case 3:
                                //                {
                                //                    //zuo
                                //                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByLeft, havCardVals[k]);
                                //                    break;
                                //                }
                                //        }
                                //    }

                                //    var sprite = await GameObjectPool.Instance.AcquireSprite(spiring);
                                //    UnityEngine.UI.Image icon = uiHavItem.GetComponentInChildren<UnityEngine.UI.Image>();
                                //    if(icon != null)
                                //        icon.sprite = sprite;
                                //}
                                //else
                                {
                                    string spiring = "";
                                    Vector2 sizeDelta = Vector2.zero;
                                    if (roleInfo.roleId == playInfo.id)
                                    {
                                        spiring = string.Concat(GameSetting.Instance.selfPlayCardShowSpiteName, havCardVals[k]);
                                        sizeDelta = GameUtil.Instance.myShowCard;
                                    }
                                    else
                                    {
                                        switch (i)
                                        {
                                            case 1:
                                                {
                                                    //右
                                                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByRight, havCardVals[k]);
                                                    sizeDelta = GameUtil.Instance.otherLeftCardSize;
                                                    break;
                                                }
                                            case 2:
                                                {
                                                    //shang
                                                    spiring = string.Concat(GameSetting.Instance.selfPlayCardCenterSpiteName, havCardVals[k]);
                                                    sizeDelta = new Vector2(GameUtil.Instance.otherLeftCardSize.y, GameUtil.Instance.otherLeftCardSize.x);
                                                    break;
                                                }
                                            case 3:
                                                {
                                                    //zuo
                                                    spiring = string.Concat(GameSetting.Instance.otherPlayCardSpiteNameByLeft, havCardVals[k]);
                                                    sizeDelta = GameUtil.Instance.otherLeftCardSize;
                                                    break;
                                                }
                                        }
                                    }
                                    var uiHavItem = GameUtil.Instance.InitializeObj(GameUtil.Instance.GetCardCloneItem(roleInfo.roleId == playInfo.id ? 0 : 1));
                                    uiHavItem.SetActive(true);
                                    uiHavItem.transform.SetParent(haveBeenOutContentNode.transform, false);
                                    var sprite = await GameObjectPool.Instance.AcquireSprite(spiring);
                                    UnityEngine.UI.Image icon = uiHavItem.GetComponentInChildren<UnityEngine.UI.Image>();
                                    icon.sprite = sprite;
                                    icon.gameObject.GetComponent<RectTransform>().sizeDelta = sizeDelta;
                                }
                            }
                        }
                    }
                }
            }
            //处理每个回合倒计时
            Log.Error("当前自己回合");
            startFightRoomComponentUI.startTimeCount = startFightRoomInfo.roomInfo.Time;
            if (startFightRoomComponentUI.startTimer > 0)
            {
                startFightRoomComponentUI.timeCountTxt.text = "";
                TimerComponent.Instance?.Remove(ref startFightRoomComponentUI.startTimer);
            }
            startFightRoomComponentUI.startTimer = TimerComponent.Instance.NewRepeatedTimer(ConstValue.fightTimeRefreshTime / 2 + 100, TimerInvokeType.startFightTimeCount, startFightRoomComponentUI);
            //处理当前操作玩家的状态显示
            //RefreshCenterOperationState(startFightRoomInfo.roomInfo.OpPos, startFightRoomComponentUI);
        }

        //刷新中间表示当前操作玩家
        public static async void RefreshCenterOperationState(int OpPos, UIStartFightRoomComponent uIStartFightRoomComponent)
        {
            //await ResourcesComponentHelper.Instance.LoadSprite(GameUtil.Instance.GetSceneComponent(), "fightatlas");
            //string abName = string.Concat("TimePoint",OpPos);
            //Sprite sprite = ResourcesComponentHelper.Instance.GetSprite("fightatlas", abName);
            //uIStartFightRoomComponent.shakeDiceImage.sprite = sprite;
        }

        public static void RefreshOrientation(int opPos,UIStartFightRoomComponent uIStartFightRoomComponent)
        {
            uIStartFightRoomComponent.shakeDiceImage1.SetActive(false);
            uIStartFightRoomComponent.shakeDiceImage2.SetActive(false);
            uIStartFightRoomComponent.shakeDiceImage3.SetActive(false);
            uIStartFightRoomComponent.shakeDiceImage4.SetActive(false);
            switch (opPos)
            {
                case 0:
                    uIStartFightRoomComponent.shakeDiceImage1.SetActive(true);
                    break;
                case 1:
                    uIStartFightRoomComponent.shakeDiceImage2.SetActive(true);
                    break;
                case 2:
                    uIStartFightRoomComponent.shakeDiceImage3.SetActive(true);
                    break;
                case 3:
                    uIStartFightRoomComponent.shakeDiceImage4.SetActive(true);
                    break;
            }
            
        }

        public static void RestartPlayGame(this UIStartFightRoomComponent self)
        {
            Log.Error("@@@  清理 ");
            //清理相关桌面数据
            //身上的牌列表
            for (int i = 0; i < 4; i++)
            {
                var fightCardParentNode = self.uIStartFightRoomPlayerComs[i].fightCardNode;
                //已出过牌的列表
                var disCardParentNode = self.uIStartFightRoomPlayerComs[i].disCardsNode;
                //操作过的 如 吃 碰 杠 列表
                var haveBeenOutContentNode = self.uIStartFightRoomPlayerComs[i].haveBeenOutContentNode;
                CleanCardItemList(fightCardParentNode.transform,0);
                CleanCardItemList(disCardParentNode.transform, 1);
                CleanCardItemList(haveBeenOutContentNode.transform, 2);
            }
            
            self.Init();
        }

        #region 请求相关
        //操作，chi p hu
        public static async ETTask OperationCardRequest(int operationType,int firstCard)
        {
            try
            {
                var scene = GameUtil.Instance.GetSceneComponent();
                var session = scene.GetComponent<SessionComponent>().Session;
                if (session != null)
                {
                    G2C_HGHHOperation g2Operation = (G2C_HGHHOperation)await session.Call(
                        new C2G_HGHHOperation() { OpType = operationType , Card = firstCard });
                    if (g2Operation.Error != ErrorCode.ERR_Success)
                    {
                        Log.Error($"操作 {operationType} 出错...errCode={g2Operation.Error}");
                        return;
                    }
                    //之后走推送
                }
            }
            catch (Exception e)
            {
                Log.Error($"操作 {operationType} 出错...{e.Message}");
            }
        }

        //出
        public static async ETTask DisCardRequest(int disCard, UIStartFightRoomComponent startFightRoomComponentUI)
        {
            try
            {
                var scene = GameUtil.Instance.GetSceneComponent();
                var session = scene.GetComponent<SessionComponent>().Session;
                if (session != null)
                {
                    G2C_HGHHDisCard g2DisCard = (G2C_HGHHDisCard)await session.Call(
                        new C2G_HGHHDisCard() { Card = disCard });
                    if (g2DisCard.Error != ErrorCode.ERR_Success)
                    {
                        await CommonUtil.Instance.OpenCommonServerMsgPanel($"出牌{disCard} 出错...errCode={g2DisCard.Error}");
                        return;
                    }
                    var startFightRoomInfo = GameUtil.Instance.GetSceneComponent().GetComponent<StartFightRoomComponment>().GetStartFightRoomInfo();
                    int sexType = startFightRoomInfo.roomInfo.MyInfo.sex;
                    string soundStrType = sexType == 0 ? GameSetting.Instance.disCardBoySoundName : GameSetting.Instance.disCardGirlSoundName;
                    await SoundManager.Instance.PlaySound(string.Concat(soundStrType, disCard));
                    //出牌之后 暂停回合倒计时
                    if (startFightRoomComponentUI.startTimer > 0)
                    {
                        startFightRoomComponentUI.timeCountTxt.text = "";
                        TimerComponent.Instance?.Remove(ref startFightRoomComponentUI.startTimer);
                    }
                    //startFightRoomComponentUI.shakeDiceImage.sprite = null;
                    //之后走推送
                }
            }
            catch (Exception e)
            {
                Log.Error($"操作 {disCard} 出错...{e.Message}");
            }
        }
        #endregion

        //type 上下0 右1 左2
        public static void CleanCardItemList(Transform node,int index)
        {
            //Dictionary<int, List<GameObject>> tempList = null;
            //switch (index)
            //{
            //    case 0:
            //        {
            //            tempList = GameObjectPool.Instance.fightCardItemPools;
            //            break;
            //        }
            //    case 1:
            //        {
            //            tempList = GameObjectPool.Instance.disCardItemPools;
            //            break;
            //        }
            //    case 2:
            //        {
            //            tempList = GameObjectPool.Instance.havCardItemPools;
            //            break;
            //        }
            //}
            for (int i = 0;i < node.childCount;i++)
            { 
                var child = node.GetChild(i);
                StartFightCardItem startFightCardItem = child.gameObject.GetComponent<StartFightCardItem>();
                if(startFightCardItem != null)
                    startFightCardItem.GetDown();
                child.gameObject.SetActive(false);
            }
        }

        public static void DisCardPushWithOperator(Transform node, ActInfo actInfo)
        {
            Log.Error("@@@当前牌: " + actInfo.Card);
            ActInfoType actInfoType = (ActInfoType)actInfo.Type;
            switch (actInfoType)
            { 
                case ActInfoType.LightPole:
                case ActInfoType.BackPole:
                case ActInfoType.DarkPole:
                    {
                        var cardVal = actInfo.Card;
                        int loopIndex = 1;
                        for (int i = 0; i < node.childCount; i++)
                        {
                            if (loopIndex >= 3)
                            {
                                break;
                            }
                            var child = node.GetChild(i);
                            StartFightCardItem startFightCardItem = child.gameObject.GetComponent<StartFightCardItem>();
                            if (startFightCardItem.val == cardVal)
                            {
                                startFightCardItem.StandUp();
                                loopIndex++;
                            }
                        }
                        break;
                    }
                case ActInfoType.Peng:
                    {
                        var cardVal = actInfo.Card;
                        int loopIndex = 0;
                        for (int i = 0; i < node.childCount; i++)
                        {
                            if (loopIndex >= 2)
                            {
                                break;
                            }
                            var child = node.GetChild(i);
                            StartFightCardItem startFightCardItem = child.gameObject.GetComponent<StartFightCardItem>();
                            if (startFightCardItem.val == cardVal)
                            {
                                startFightCardItem.StandUp();
                                loopIndex++;
                            }
                        }
                        break;
                    }
                case ActInfoType.Chi:
                    {
                        var cardVal = actInfo.Card;
                        bool IsExist(List<int> cardVals,int cardVal,out int outCardVal)
                        {
                            outCardVal = 0;
                            for (int i = 0;i < cardVals.Count;i++)
                            {
                                if (cardVals[i] == cardVal)
                                {
                                    outCardVal = cardVal;
                                    return true;
                                }
                            }
                            return false;
                        }
                        List<int> cardVals = new List<int>() { cardVal, cardVal + 1, cardVal + 2};
                        List<int> tempCards = new List<int>();
                        //发1
                        //出2  1233
                        for (int i = 0; i < node.childCount; i++)
                        {
                            var child = node.GetChild(i);
                            StartFightCardItem startFightCardItem = child.gameObject.GetComponent<StartFightCardItem>();
                            int outCardVal = 0;
                            if (IsExist(cardVals, startFightCardItem.val,out outCardVal))
                            {
                                Log.Error("#####  startFightCardItem.val:  " + startFightCardItem.val + "  outCardVal:  " + outCardVal);
                                if (outCardVal == GameUtil.Instance.curCardVal || tempCards.Contains(startFightCardItem.val))
                                {
                                    continue;
                                }
                                startFightCardItem.StandUp();
                                tempCards.Add(startFightCardItem.val);
                            }
                        }
                        GameUtil.Instance.curRequestCardVal = cardVal;
                        break;
                    }
            }
        }

        public static PlayerInfo GetOtherPlayInfoByPos(List<PlayerInfo> allPlayerInfos,int pos)
        {
            for (int i = 0;i < allPlayerInfos.Count;i++)
            {
                if (allPlayerInfos[i].pos == pos)
                { 
                    return allPlayerInfos[i];
                }
            }
            return null;
        }

        //根据自己位置 确定其他座位
        public static List<int> GetPosList(int myPos)
        {
            List<int> list = null;
            switch (myPos)
            { 
                case 0:
                    {
                        list = new List<int>() { 0,1,2,3};
                        break ;
                    }
                case 1:
                    {
                        list = new List<int>() { 1,2,3,0};
                        break;
                    }
                case 2:
                    {
                        list = new List<int>() { 2,3,0,1};
                        break;
                    }
                case 3:
                    {
                        list = new List<int>() { 3,0,1,2};
                        break;
                    }
            }
            return list;
        }

        public static void SortList(List<int> list)
        {
            list.Sort();

        }

        [ObjectSystem]
        public class UIStartFightRoomComponentDestroySystem : DestroySystem<UIStartFightRoomComponent>
        {
            protected override void Destroy(UIStartFightRoomComponent self)
            {
                TimerComponent.Instance?.Remove(ref self.RepeatedTimer);
                CommonBridge.Instance.Clear();
            }
        }
    }
}