card_svr/src/utils/game.util.ts

import {Card} from "../rooms/schema/Card";

import arrUtil from "./array.util";
import {Player} from "../rooms/schema/Player";
import {BaseConst} from "../constants/BaseConst";
import {SystemCardCfg} from "../cfg/parsers/SystemCardCfg";
import {EffectCardCfg} from "../cfg/parsers/EffectCardCfg";
import {error} from "../common/Debug";

let gameUtil = {
    /**
     * 游戏开始时, 初始化卡组
     */
    initCardQue() {
        let cards: Array<Card> = [];
        let numCfgMap: Map<number, SystemCardCfg> = global.$cfg.get(BaseConst.SYSTEMCARD);
        let effCfgMap: Map<number, EffectCardCfg> = global.$cfg.get(BaseConst.EFFECTCARD);

        let countMap: Map<number, number> = new Map();
        let localId = 1;
        for (let [id, cfg] of numCfgMap) {
            for (let i = 0; i < cfg.count; i++) {
                if (cfg.type_id == 1) {
                    let effid = this.getRandomEffect(cfg.weightArr, effCfgMap, countMap);
                    let card = new Card(localId ++, cfg.point, cfg.type_id, effid);
                    cards.push(card);
                } else {
                    let card = new Card(localId ++, cfg.point, cfg.type_id, 0);
                    cards.push(card);
                }

            }
        }

        arrUtil.randomSort(cards);
        return cards;
    },
    /**
     * 根据配表中的权重, 获取一个效果卡的id
     * @param weightArr 配表中的权重列表
     * @param effCfgMap 配表中的所有效果卡的配置
     * @param countMap  当前已生成的效果卡数量
     */
    getRandomEffect(weightArr: number[][], effCfgMap: Map<number, EffectCardCfg>, countMap: Map<number, number>) {
        let total = 0;
        let tmpArr:number[][] = [];
        for (let data of weightArr) {
            total += data[1];
            tmpArr.push([data[0], total]);
        }
        let num = Math.random() * total;
        let effid;
        for (let data of tmpArr) {
            if (data[1] >= num ) {
                let count = countMap.has(data[0]) ? countMap.get(data[0]) : 0;
                if (count < effCfgMap.get(data[0]).count) {
                    effid = effCfgMap.get(data[0]).id;
                    countMap.set(effid, count + 1);
                    break;
                }
            }
        }
        if (!effid) {
            for (let [id, count] of countMap) {
                if (count < effCfgMap.get(id).count) {
                    effid = id;
                    countMap.set(effid, count + 1);
                    break
                }
            }
        }
        if (!effid) {
            error('生成卡组时, 无法匹配效果卡, 请确认效果卡的最大数量是否等于点数卡总数')
        }
        return effid;
    },
    /**
     * 检查目标数组中的卡id是否在存在
     * @param cardMap
     * @param cardIds
     */
    checkCardsExists(cardMap: Map<string, Card>, cardIds: Array<string>) {
        let result = true;
        for (let id of cardIds) {
            if (!cardMap.has(id + '')) {
                result = false;
                break;
            }
        }
        return result;
    },
    /**
     * 抽卡
     * @param cardArr
     * @param player
     * @param count
     * @param fromplayer
     */
    drawCard(cardArr: Card[], player: Player, count: number, fromplayer?: Player): Card[] {
        let cards: Card[] = [];
        for (let i = 0; i < count; i++) {
            cards.push(cardArr.pop());
        }
        //TODO:
        this.addCardToPlayer(player, cards);
        return cards;
    },
    /**
     * 随机移除n张手牌
     * @param player
     * @param count
     */
    removeCard(player: Player, count: number): Card[] {
      let cards = [];
      let cardArr: Card[] = [...player.cards.values()];
      cards = arrUtil.randomGet(cardArr, count);
      for (let card of cards) {
          player.cards.delete(card.id + '');
          player.cardSet.delete(card.id + '');
      }
      return cards;
    },
    /**
     * 往玩家的卡组里添加卡
     * @param player
     * @param cards
     */
    addCardToPlayer(player: Player, cards: Card[]) {
        for (let card of cards) {
            player.cards.set(card.id + '', card);
            player.cardSet.add(card.id + '');
        }
        player.countTotal += cards.length;
    },
    /**
     * 更换相同数量的卡
     * @param cardArr
     * @param player
     * @param targetCards
     */
    changeCard(cardArr: Card[], player: Player, targetCards: Card[]): Card[] {
        let cards: Card[] = [];
        for (let card of targetCards) {
            player.cards.delete(card.id + '');
            player.cardSet.delete(card.id + '');
        }
        arrUtil.randomInsert(cardArr, targetCards);
        let count = targetCards.length;
        for (let i = 0; i < count; i++) {
            let card = cardArr.pop();
            cards.push(card);
            player.cards.set(card.id + '', card);
            player.cardSet.add(card.id + '');
        }
        return cards;
    },
    /**
     * 检查出牌是否符合规则
     * @param cardsLst
     */
    checkDiscard(cardsLst: Card[]) {
        if (cardsLst.length == 0 || cardsLst.length == 2) {
            return false
        } else if (cardsLst.length == 1) {
            return true;
        }
        let numSet: number[] = [];
        cardsLst.forEach(function (value) {
            if (value.number < 11) {
                numSet.push(value.number);
            }
        });
        if (numSet.length === 1) {
            return true;
        }
        if (numSet.length < 3) {
            return false;
        }
        numSet.sort((a, b) => {
            return a - b;
        });
        let preNum;
        let sequence = true; //是否是顺序
        let same = true; //是否是相同
        for (let num of numSet) {
            if (preNum) {
                if (num !== (preNum + 1) && sequence) {
                    sequence = false;
                }
                if (num !== preNum && same) {
                    same = false;
                }
                if (!sequence && !same) {
                    return false;
                }
            }
            preNum = num;
        }

        return true;
    },
    /**
     * 结算时计算总的ap
     * @param player
     */
    calcTotalAp(player: Player) {
        let result = 0;
        for (let [pid, pet] of player.pets) {
            result += pet.ap;
        }
        return result;
    }

}
export default gameUtil;