FarplaneSpire/Assets/Scripts/Battle/BattleField.cs

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

// 战场相关
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 GameObject cardPrefab;
        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() {
            // 给卡池添加牌
            int[] armyPool = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
            int[] enemyPool = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };

            foreach (int index in armyPool) {
                GameObject cardObj = Instantiate(cardPrefab, cachePlace);
                // 挂载卡片组件
                CardManager.Instance.LoadCard(cardObj, index.ToString());
                // 添加进卡池中
                BattleFieldManager.Instance.ArmyTakePool.Add(cardObj.transform);
            }

            Dictionary<string, object> info = new Dictionary<string, object>();
            info.Add("index", 0);
            info.Add("num", armyPool.Length);

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

            info["index"] = 1;
            info["num"] = 0;

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

            foreach (int index in enemyPool) {
                GameObject cardObj = Instantiate(cardPrefab, cachePlace);
                // 挂载卡片组件
                CardManager.Instance.LoadCard(cardObj, index.ToString());
                // 添加进卡池中
                BattleFieldManager.Instance.EnemyTakePool.Add(cardObj.transform);
            }

            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("抽牌");
                    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();
            }
        }

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

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

        /*
         * 比牌
        */
        private void CompaireCards() {
            // 新建一个
            ArrayList executeArray = new ArrayList();
            // 循环遍历两个数组
            int index = 0;

            while (true) {
                // 首先判断两个数组是否到最大位置
                if (index < BattleFieldManager.Instance.ArmyCpArray.Count && index < BattleFieldManager.Instance.EnemyCpArray.Count) {
                    // 获取两张卡片
                    Card armyCard = ((Transform)BattleFieldManager.Instance.ArmyCpArray[index]).GetComponent<Card>();
                    Card enemyCard = ((Transform)BattleFieldManager.Instance.EnemyCpArray[index]).GetComponent<Card>();

                    // 比较韧性
                    if (armyCard.Tenacity > enemyCard.Tenacity) {
                        executeArray.Add(armyCard);
                    } else if (armyCard.Tenacity < enemyCard.Tenacity) {
                        executeArray.Add(enemyCard);
                    } else {

                    }
                } else if (index < BattleFieldManager.Instance.ArmyCpArray.Count && index >= BattleFieldManager.Instance.EnemyCpArray.Count) {
                    // 此种是我方比较卡片比较多的情况，将剩下的牌都放入比较数组中
                    for (; index < BattleFieldManager.Instance.ArmyCpArray.Count; index++) {
                        executeArray.Add(BattleFieldManager.Instance.ArmyCpArray[index]);
                    }

                    break;
                } else if (index >= BattleFieldManager.Instance.ArmyCpArray.Count && index < BattleFieldManager.Instance.EnemyCpArray.Count) {
                    // 此种是地方比较卡片比较多的情况，将剩下的牌都放入比较数组中
                    for (; index < BattleFieldManager.Instance.EnemyCpArray.Count; index++) {
                        executeArray.Add(BattleFieldManager.Instance.EnemyCpArray[index]);
                    }

                    break;
                } else {
                    break;
                }

                index++;
            }

            print("最终执行的卡片有 .. " + executeArray.Count + " 张");
        }

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