FarplaneSpire/Assets/Scripts/Battle/BattleField.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using FSEvent;
using FSRole;
using FSCard;
using FSAssist;

// 战场相关
namespace FSBattle {
    // 战场回合状态
    public enum BattleFieldRound {
        BATTLE_FIELD_READY_GAME         = 0X0010001,     // 游戏准备
        BATTLE_FIELD_DRAW_CARDS         = 0X0010002,     // 抽牌
        BATTLE_FIELD_ENEMY_DEAL         = 0X0010003,     // 敌方出牌
        BATTLE_FIELD_PLAYER_DEAL        = 0X0010004,     // 我方出牌
        BATTLE_FIELD_COMPAIRE_CARDS     = 0X0010005,     // 比牌
        BATTLE_FIELD_MAKE_UP_CARDS      = 0X0010006,     // 补牌
        BATTLE_FIELD_PLAYER_PLAY_A_HAND = 0X0010007,     // 玩家出牌
        BATTLE_FIELD_ENEMY_ACTION       = 0X0010008,     // 敌人行动
        BATTLE_FIELD_ROUND_END          = 0X0010009,     // 回合结束
    }

    // 战场组件
    public class BattleField : MonoBehaviour {
        // 记录战场状态
        private BattleFieldRound round = BattleFieldRound.BATTLE_FIELD_READY_GAME;
        public Transform cachePlace;
        
        // Use this for initialization
        void Start() {
            InitEvent();

            Invoke("BattleStart", 1.0f);
        }

        // Update is called once per frame
        void Update() {
            
        }

        private void OnDestroy() {
            RemoveEvent();
        }

        /*
         * 注册事件
        */
        private void InitEvent() {
            EventListener.Instance.RegisterEvent(EventEnum.EVENT_ENTER_COMPAIRE_CARD_ROUND, EnterCompaireRound);
            EventListener.Instance.RegisterEvent(EventEnum.EVENT_ENTER_ENEMY_DEAL_ROUND, EnterEnemyDealRound);
            EventListener.Instance.RegisterEvent(EventEnum.EVENT_ENTER_PLAYER_DEAL_ROUND, EnterPlayerDealRound);
            EventListener.Instance.RegisterEvent(EventEnum.EVENT_ENTER_PLAY_A_HAND_ROUND, EnterPlayAHandRound);
            EventListener.Instance.RegisterEvent(EventEnum.EVENT_ERASE_CARD, EraseCard);
        }

        /*
         * 移除事件
        */
        private void RemoveEvent() {
            EventListener.Instance.RemoveEvent(EventEnum.EVENT_ENTER_COMPAIRE_CARD_ROUND);
            EventListener.Instance.RemoveEvent(EventEnum.EVENT_ENEMY_DEAL_CARD);
            EventListener.Instance.RemoveEvent(EventEnum.EVENT_ENTER_PLAYER_DEAL_ROUND);
            EventListener.Instance.RemoveEvent(EventEnum.EVENT_ENTER_PLAY_A_HAND_ROUND);
            EventListener.Instance.RemoveEvent(EventEnum.EVENT_ERASE_CARD);
        }

        /*
         * 战场开始
        */
        private void BattleStart() {
            ReadyHandle();
        }

        /*
         * 进入下一个回合
        */
        public void NextRound() {
            // 回合循环转化
            switch (round) {
                case BattleFieldRound.BATTLE_FIELD_READY_GAME:
                    round = BattleFieldRound.BATTLE_FIELD_DRAW_CARDS;
                    // 推送玩家抽牌和敌人抽牌事件
                    EventListener.Instance.PostEvent(EventEnum.EVENT_PLAYER_SHUFFLING_CARD);
                    // 为了需要再添加敌人抽牌的事件
                    print("抽牌");

                    // 同时更新行动回合
                    foreach(Transform roleTrs in BattleFieldManager.Instance.ArmyArray) {
                        Role role = roleTrs.GetComponent<Role>();
                        role.CurrentAttr.Mp = role.OriginAttr.Mp;

                        Dictionary<string, object> info = new Dictionary<string, object>();
                        info.Add("role", role);
                        EventListener.Instance.PostEvent(EventEnum.EVENT_UPDATE_PLAYER_ENGINE, info);
                    }

                    foreach(Transform roleTrs in BattleFieldManager.Instance.EnemyArray) {
                        Role role = roleTrs.GetComponent<Role>();
                        role.CurrentAttr.Mp = role.OriginAttr.Mp;
                    }

                    break;

                case BattleFieldRound.BATTLE_FIELD_DRAW_CARDS:
                    round = BattleFieldRound.BATTLE_FIELD_ENEMY_DEAL;
                    // 等未来敌人管理类添加后再处理，当前过2秒后进入下一回合
                    EventListener.Instance.PostEvent(EventEnum.EVENT_ENEMY_DEAL_CARD);
                    print("敌人出牌完毕");
                    break;

                case BattleFieldRound.BATTLE_FIELD_ENEMY_DEAL:
                    round = BattleFieldRound.BATTLE_FIELD_PLAYER_DEAL;
                    // 将按钮字体改为我方结束出牌
                    print("我方出牌，直到按下回合结束按钮 ... ");
                    break;

                case BattleFieldRound.BATTLE_FIELD_PLAYER_DEAL:
                    round = BattleFieldRound.BATTLE_FIELD_COMPAIRE_CARDS;
                    print("开始比牌 ... ");
                    // 比牌
                    CompaireCards();
                    // 接下来点击结束回合按钮后进入下一回合
                    //// 未来在此实现比牌功能，当前过2秒后进入下一回合
                    //Invoke("NextRound", 2.0f);
                    break;

                case BattleFieldRound.BATTLE_FIELD_COMPAIRE_CARDS:
                    round = BattleFieldRound.BATTLE_FIELD_READY_GAME;
                    // 清理比较牌
                    EventListener.Instance.PostEvent(EventEnum.EVENT_CLEAR_COMPAIRE_CARDS);
                    // 运行Buff
                    ExecuteRoleBuff();
                    // 回合重新回到开始回合，过2秒后进入下一回合
                    Invoke("NextRound", 2.0f);
                    print("准备好了 ... ");
                    break;

                case BattleFieldRound.BATTLE_FIELD_MAKE_UP_CARDS:
                    break;
            }
        }

        /*
         * 准备游戏回合的事件处理 
        */
        private void ReadyHandle() {
            // 通过消息中心，发布带参数的消息
            Dictionary<string, object> info = new Dictionary<string, object>();
            info.Add("remind", "准备中 ... ");

            EventListener.Instance.PostEvent(EventEnum.EVENT_UPDATE_ROUND_TEXT, info);

            // 过1秒后进入下一回合
            Invoke("NextRound", 1.0f);
        }

        /*
         * 抽牌结束，进入敌人行动回合
        */
        private void EnterEnemyDealRound() {
            // 保证当前处于抽牌阶段
            if (round == BattleFieldRound.BATTLE_FIELD_DRAW_CARDS) {
                NextRound();
            }
        }

        /*
         * 敌人出牌结束，进入玩家出牌阶段
        */
        private void EnterPlayerDealRound() {
            // 保证当前处于敌人出牌阶段
            if (round == BattleFieldRound.BATTLE_FIELD_ENEMY_DEAL) {
                NextRound();
            }
        }

        /*
         * 进入比牌回合
        */
        private void EnterCompaireRound() {
            // 首先得保证上一个回合是我方出牌回合
            if (round == BattleFieldRound.BATTLE_FIELD_PLAYER_DEAL) {
                // 通知清理牌桌
                EventListener.Instance.PostEvent(EventEnum.EVENT_CLEAR_HAND_CARDS);
                NextRound();
            } else if (round == BattleFieldRound.BATTLE_FIELD_COMPAIRE_CARDS) {
                // 如果是比牌回合，则暂无处理，直接进入下一回合
                NextRound();
            }
        }

        /*
         * 回合轮回，重新开始
        */
        private void EnterPlayAHandRound() {
            // 首先需要保证上一个回合是结束回合
            if (round == BattleFieldRound.BATTLE_FIELD_ROUND_END) {
                NextRound();
            }
        }

        /*
         * 执行角色BUFF操作
        */
        private void ExecuteRoleBuff() {
            // 遍历数组来启动Buff
            foreach (Transform trs in BattleFieldManager.Instance.RoleArray) {
                Role role = trs.GetComponent<Role>();
                role.BuffExecute();
            }
        }

        /*
         * 比牌
        */
        private void CompaireCards() {
            // 新建一个
            ArrayList executeArray = new ArrayList();
            // 循环遍历两个数组
            int index = 0;
            // 暂定动画为缩小，缩小的尺寸
            Vector3 scaleSize = new Vector3(AssistConfig.CardScale, AssistConfig.CardScale, AssistConfig.CardScale);

            while (true) {
                // 首先判断两个数组是否到最大位置
                if (index < BattleFieldManager.Instance.CpArray.Count) {
                    Dictionary<string, Transform> info = (Dictionary<string, Transform>)BattleFieldManager.Instance.CpArray[index];
                    // 获取两张卡片
                    // 再比较两张卡片是否存在，有一方不存在则另一方加入比较数组中
                    if (info.ContainsKey(AssistConfig.Army) && !info.ContainsKey(AssistConfig.Enemy)) {
                        Transform armyTrs = info[AssistConfig.Army];
                        Card armyCard = armyTrs.GetComponent<Card>();
                        armyCard.SetFront(true);
                        executeArray.Add(armyTrs);
                    } else if (!info.ContainsKey(AssistConfig.Army) && info.ContainsKey(AssistConfig.Enemy)) {
                        Transform enemyTrs = info[AssistConfig.Enemy];
                        Card enemyCard = enemyTrs.GetComponent<Card>();
                        enemyCard.SetFront(true);
                        executeArray.Add(enemyCard);
                    } else {
                        Transform armyTrs = info[AssistConfig.Army];
                        Transform enemyTrs = info[AssistConfig.Enemy];
                        // 获取两张牌
                        Card armyCard = armyTrs.GetComponent<Card>();
                        Card enemyCard = enemyTrs.GetComponent<Card>();

                        // 翻牌
                        armyCard.SetFront(true);
                        enemyCard.SetFront(true);

                        // 获取韧性
                        int armyTen = armyCard.Source.CompairePassBuff(armyCard.Tenacity);
                        int enemyTen = enemyCard.Source.CompairePassBuff(enemyCard.Tenacity);

                        print("我方韧性 : " + armyTen + ", 敌方韧性 : " + enemyTen);

                        // 比较韧性
                        // 首先比较两张牌类型一样的情况
                        if (armyCard.Type == enemyCard.Type) {
                            if (armyCard.Type == CardType.CARD_TYPE_ATTACK) {
                                // 当都是攻击类型的时候
                                // 根据韧性来进行比较
                                if (armyTen > enemyTen) {
                                    executeArray.Add(armyCard);
                                    enemyTrs.localScale = scaleSize;
                                } else if (armyTen < enemyTen) {
                                    executeArray.Add(enemyCard);
                                    armyTrs.localScale = scaleSize;
                                } else {
                                    // 当相等的时候，都不处理
                                    armyTrs.localScale = scaleSize;
                                    enemyTrs.localScale = scaleSize;
                                }
                            } else if (armyCard.Type == CardType.CARD_TYPE_DEFANCE) {
                                // 当都是防御类型的时候
                                if (armyTen > enemyTen) {
                                    executeArray.Add(armyCard);
                                    enemyTrs.localScale = scaleSize;
                                } else if (armyTen < enemyTen) {
                                    executeArray.Add(enemyCard);
                                    armyTrs.localScale = scaleSize;
                                } else {
                                    // 当相等的时候，都加入处理
                                    executeArray.Add(armyCard);
                                    executeArray.Add(enemyCard);
                                }
                            } else {
                                // 特殊牌全部加入处理
                                executeArray.Add(armyCard);
                                executeArray.Add(enemyCard);
                            }
                        } else {
                            // 当韧性不相等的时候，高的生效
                                if (armyTen > enemyTen) {
                                    executeArray.Add(armyCard);
                                    enemyTrs.localScale = scaleSize;
                                } else {
                                    executeArray.Add(enemyCard);
                                    armyTrs.localScale = scaleSize;
                                }
                        }
                    }
                } else {
                    break;
                }

                index++;
            }
           
            print("最终执行的卡片有 .. " + executeArray.Count + " 张");
            foreach(Card card in executeArray) {
                // 执行卡片
                card.OnExecute();
            }
        }

        /*
         * 选择一张牌，从其父节点移除，放在缓存区中
        */
        private void EraseCard(Dictionary<string, object> info) {
            Transform cardTrs = (Transform)info["card"];
            cardTrs.SetParent(cachePlace);
            cardTrs.localScale = Vector3.zero;
        }

        ///*
        // * 给本类使用的移除方法，需要传入对应的角色
        //*/
        //private void EraseCPCard(Transform cardTrs, int index) {
        //    cardTrs.SetParent(cachePlace);
        //    cardTrs.localScale = Vector3.zero;
        //    // 判断角色，同时从对应的比较数组中移除，添加到弃牌堆
        //    if (index == 0) {
        //        // 首先保证在数组中
        //        if (BattleFieldManager.Instance.ArmyCpArray.Contains(cardTrs)) {
        //            BattleFieldManager.Instance.ArmyThrowPool.Add(cardTrs);
        //            BattleFieldManager.Instance.ArmyCpArray.Remove(cardTrs);
        //            // 同时通知更新牌堆数据
        //            Dictionary<string, object> info = new Dictionary<string, object>();
        //            info.Add("index", 1);
        //            info.Add("num", BattleFieldManager.Instance.ArmyThrowPool.Count);

        //            EventListener.Instance.PostEvent(EventEnum.EVENT_UPDATE_TABLE_INFO, info);
        //        }
        //    } else if (index == 1) {
        //        // 首先保证在数组中
        //        if (BattleFieldManager.Instance.EnemyCpArray.Contains(cardTrs)) {
        //            BattleFieldManager.Instance.EnemyThrowPool.Add(cardTrs);
        //            BattleFieldManager.Instance.EnemyCpArray.Remove(cardTrs);
        //        }
        //    }
        //}
    }
}