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

import { Application, BackendSession, pinus } from 'pinus';
import { resResult, genCode, getRandomByLen } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { BossInstanceModel } from '../../../db/BossInstance';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { nowSeconds, getTodayZeroPoint } from '../../../pubUtils/timeUtil';
import { getBossInstanceInfo, bossResult, checkMemberExists, pushBossHpMessage, getBossInstanceWhenEnd, addBossInstance } from '../../../services/guildBossService';
import { findWhere, random } from 'underscore'
import { GUILD_DATA_NAME, GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
import { UserGuildModel } from '../../../db/UserGuild';
import { GUILD_OPERATE } from '../../../consts';
import { checkAuth } from '../../../services/guildService';
import { GuildModel } from '../../../db/Guild';
import { getBossByLv } from '../../../pubUtils/data';
import { lockData } from '../../../services/redLockService';
export default function (app: Application) {
    return new GuildHandler(app);
}

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

    // 获得boss关卡
    async getBossInstance(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        let bossInstance = await BossInstanceModel.findBossInstance(code);
        if (!bossInstance) {
            return resResult(STATUS.SUCCESS, {status: 1});//1：等待团长开启，2：今日已开启，且boss通关，3：开启中
        }
        let result = await getBossInstanceInfo(bossInstance, roleId);

        return resResult(STATUS.SUCCESS, result);
    }
    
    //开启演武场
    async openBossInstance(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        const checkMyResult = await checkAuth(GUILD_OPERATE.OPEN_BOSS, roleId, null, userGuild);
        if(!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
        let res:any = await lockData(serverId, GUILD_DATA_NAME.BOSS_SCRIPT, code);//加锁
        if (!!res.err) 
            return resResult(STATUS.REDLOCK_ERR); 
        let bossInstance = await BossInstanceModel.findBossInstance(code);
        if (!!bossInstance && ( bossInstance.bossHp > 0 || bossInstance.startTime >= getTodayZeroPoint() )) {
            return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
        }
        const guild = await GuildModel.findByCode(code, serverId, 'lv structure');
        if(!guild) {
            return resResult(STATUS.GUILD_NOT_FOUND);
        }
        const { structure } = guild;
        const curStructure = structure.find(cur => cur.id == GUILD_STRUCTURE.BOSS);
        if(!curStructure) {
            return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
        }
        let bossBase = getBossByLv(curStructure.lv);
        let {bossHp, warId } = getRandomByLen(bossBase.wars);
        let resGuild = await GuildModel.costFund(code, bossBase.consume)
        if (!resGuild) 
            return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
        await BossInstanceModel.openBossInstance(code, bossHp, warId);
        let result = {warId, ranks: [], myRank: {}, bossHp, type: 3, isBattled: false};
        return resResult(STATUS.SUCCESS, result);
    }

    async battleBoss(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        let bossInstance = await BossInstanceModel.findBossInstance(code);
        if (!bossInstance) 
            return resResult(STATUS.GUILD_SCRIPT_NOT_OPENED);
        if (bossInstance.bossHp <= 0) 
            return resResult(STATUS.GUILD_SCRIPT_IS_COMPLETE);
        let myRank = findWhere(bossInstance.ranks, {roleId});
        if (!!myRank && myRank.time > getTodayZeroPoint()) 
            return resResult(STATUS.GUILD_SCRIPT_IS_BATTLED);
        let { warId, ranks } = bossInstance;
        const battleCode = genCode(8); // 关卡唯一值
        //TODO查看地图字典
        let warInfo;
        await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: {
                roleId, roleName, battleId: warId,
                status: 0,
                // warName: warInfo.gk_name,
                // warType: warInfo.warType,
                record: { heroes:[],recordNum: bossInstance.num, bossHp: bossInstance.bossHp},
            }
        }, true);
        const serverId = session.get('serverId');
        await addBossInstance(code, serverId, roleId);
        if (!findWhere(ranks, {roleId})) {
            await BossInstanceModel.pushRanks(code, {roleId, score: 0, time: nowSeconds()});
        } else {
            await BossInstanceModel.updateRank(code, roleId);
        }
        return resResult(STATUS.SUCCESS, { battleCode });
    }

    async action (msg: { damage: number, battleCode: string }, session: BackendSession ) {
        const { battleCode, damage } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        let flag = await checkMemberExists(code, serverId, roleId, battleCode);
        if (!flag) {
            return resResult(STATUS.REDLOCK_ERR); 
        }
        //记录伤害
        let bossInstance = await BossInstanceModel.updateBossHp(code, damage, roleId);
        if (!bossInstance) {//进入结算
            let flag = await bossResult(code, serverId, GUILD_DATA_NAME.BOSS_SCRIPT, roleId, damage);
            if (!flag) {
                return resResult(STATUS.WRONG_PARMS);
            }
            return resResult(STATUS.SUCCESS, { bossHp: 0 });
        } else {
            pushBossHpMessage(code, serverId, bossInstance.bossHp);
            return resResult(STATUS.SUCCESS, { bossHp: bossInstance.bossHp });
        }
    }

    async battleBossEnd(msg: { battleCode: string }, session: BackendSession) {
        const { battleCode } = msg;
        const roleId = session.get('roleId');
        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS); 
        const { guildCode: code } = userGuild;
        const battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
        if (!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId) {
            return resResult(STATUS.WRONG_PARMS);
        } 
        await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: { status: 1 }//战斗结束统一设置成1
        }, true);
        let bossInstance = await BossInstanceModel.findBossInstance(code);
        let result = await getBossInstanceWhenEnd(bossInstance, roleId, battleRecord.record.recordNum);

        return resResult(STATUS.SUCCESS, result);
    }

    
}