ZYZ/game-server/app/servers/battle/handler/normalBattleHandler.ts

import { Application, BackendSession } from 'pinus';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { getWarById, getGoodById } from '../../../util/gamedata';
import { CounterModel } from '../../../db/Counter';
import { HeroModel } from '../../../db/Hero';
import { EquipModel } from '../../../db/Equip';
import { genCode } from '../../../util/util';

export default function(app: Application) {
    return new NormalBattleHandler(app);
}

export class NormalBattleHandler {
    constructor(private app: Application) {
    }

    // 进入关卡前，记录信息，生成唯一标识
    async checkBattle(msg: {battleId: number, heroes: Array<any> }, session: BackendSession) {
        const { battleId, heroes } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let warInfo = getWarById(battleId);
        if(!warInfo) {
            return {
                code: 202,
                data: "缺少关卡信息"
            }
        }

        const battleCode = genCode(8);
        const BattleRecord = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: {
                roleId,
                roleName,
                battleId,
                status: 0,
                warName: warInfo.gk_name,
                warType: warInfo.war_type,
                record: { heroes }
            }
        }, true);

        let {status} = BattleRecord;

        return {
            code: 200,
            data: {
                battleId, battleCode, status
            }
        }
    }

    // 关卡结算，记录使用的武将，获得奖励
    async battleEnd(msg: {battleCode: string, battleId: number, isSuccess: boolean, heroes: Array<any>, }, session: BackendSession) {

        const { battleCode, battleId, isSuccess, heroes } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let warInfo = getWarById(battleId);

        const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
        if(!BattleRecord || BattleRecord.status != 0) {
            return {
                code: 202,
                data: '关卡状态错误'
            }
        }

        let flag = 1; // 对比hero信息
        let { record: { heroes: dbHeroes } } = BattleRecord;
        for(let hid of heroes) {
            if(dbHeroes.indexOf(hid) == -1) flag = 0;
        }
        if(!flag) {
            return {
                code: 202,
                data: '关卡信息不同'
            }
        }

        let params = {}, reward: Array<any>;
        if(isSuccess) { // 挑战胜利
            params = {
                $set: {
                    status: 1,
                    record: { heroes }
                }
            }
            reward = await this.handleReward(roleId, roleName, warInfo.reward);
        } else { // 挑战失败
            params = {
                $set: {
                    status: 2,
                    record: { heroes }
                }
            }
            reward = [];
        }

        const updateResult = await BattleRecordModel.updateBattleRecordByCode(battleCode, params, true);
        let { status } = updateResult;

        return {
            code: 200,
            data: {
                battleCode, battleId, status,
                goods: reward
            }
        }
    }

    private async handleReward(roleId: string, roleName: string, rewardStr:string) {
        let {weapons, armors, items, souls} = this.decodeReward(rewardStr);
        let addWeapons = await this.rewardWeapons(roleId, roleName, weapons);
        // 暂时只处理装备
        // let addArmors = await this.rewardArmors(roleId, roleName, armors);
        // let addItems = await this.rewardItems(roleId, roleName, items);
        // let addSouls = await this.rewardSouls(roleId, roleName, souls);

        let result = [].concat(addWeapons);
        return result;
    }

    private async rewardWeapons (roleId: string, roleName:string,  weapons: Array<{id:number,cnt:number, type: number}>) {

        let weaponsData = [];
        for (let weapon of weapons) {
            let cnt = weapon.cnt;
            let g = getGoodById(weapon.id);
            while (cnt > 0) {
                const seqId = await CounterModel.getNewCounter('eid');
                const equipInfo = {
                    roleId,
                    roleName,
                    eid: weapon.id,
                    eName: g.name,
                    seqId,
                    type: weapon.type,
                    lv: g.lv
                }
                const equip = await EquipModel.createEquip(equipInfo);
                cnt -= 1;
                weaponsData.push(equip);
            }
        }
        return weaponsData;
    }

    private decodeReward(rewardStr: string, multiple=1) {
        let weapons = [];
        let armors = [];
        let items = [];
        let souls = [];
        rewardStr.split('|').forEach((rStr) => {
            // r[0]: type, r[1]: id, r[2]: count
            let r = rStr.split('&');
            let type = parseInt(r[0] || '')||0;
            let id = parseInt(r[1] || '') || 0;
            let cnt = (parseInt(r[2] || '') || 0) * multiple;
            if (id !== 0 && cnt !== 0) {
                switch (r[0]) {
                case '0':
                    items.push({id, cnt, type});
                    break;
                case '1':
                    weapons.push({id, cnt, type});
                    break;
                case '2':
                    armors.push({id, cnt, type});
                    break;
                case '3':
                    souls.push({id, cnt, type});
                    break;
                default:
                    break;
                }
            }
        });
        return {weapons, armors, items, souls};
    }
}