ZYZ/game-server/app/services/battleService.ts

import { HangUpRecordModel } from './../db/HangUpRecord';
import { ChannelService } from 'pinus';
import { HANG_UP_CONSTS } from './../consts/consts';
import { BattleRecordModel } from './../db/BattleRecord';
import { TowerRecordModel } from './../db/TowerRecord';
import { RoleModel } from './../db/Role';
import { getTowerDataByLv } from "../util/gamedata"
import { decodeArrayStr, shouldRefresh } from '../util/util';
import { handleFixedReward } from './rewardService';

export async function checkTowerWar(roleId: string, battleId: number, heroes: Array<number>) {
    const battleIdStr = `${battleId}`;
    let { towerLv } = await RoleModel.findByRoleId(roleId);
    const towerInfo = getTowerDataByLv(towerLv);
    if (!towerInfo) {
        console.error(`天梯层数异常，lv ${towerLv} by ${roleId}`);
        return { status: -1, msg: '天梯层数异常' };
    }
    const warIds = decodeArrayStr(towerInfo.warIds) || [];
    if (warIds.indexOf(battleIdStr) === -1) {
        return { status: -1, msg: '战斗 Id 异常' };
    }

    let { heroes: recHeroes = [], warStatus = [] } = await TowerRecordModel.getRecordByLv(roleId, towerLv);
    for (let hid of heroes) {
        if (recHeroes.indexOf(hid) !== -1) {
            return { status: -1, msg: '使用了重复的武将' };
        }
    }
    const curWarStatus = warStatus.find(elem => elem.warId == battleId);
    if (curWarStatus.status) {
        return {status: -1, msg: '天梯关卡不能重复挑战'};
    }

    return { status: 0, data: {
        heroes: recHeroes, warStatus: curWarStatus
    }};
}

export async function towerBattleEnd(channelService: ChannelService, sid: string, roleId: string, battleCode: string, battleId: number, succeed: boolean, heroes: Array<number>) {
    if (succeed) {
        let battleRec = await BattleRecordModel.getBattleRecordByCode(battleCode);
        if (battleRec.battleId != battleId) {
            return { status: -1, msg: '战斗数据错误' };
        }
        let { towerLv, roleName } = await RoleModel.findByRoleId(roleId);
        let { warStatus, heroes: recHeroes } = await TowerRecordModel.getRecordByLv(roleId, towerLv);
        for (let hid of heroes) {
            if (recHeroes.indexOf(hid) !== -1) {
                return { status: -1, msg: '使用了重复的武将' };
            }
        }

        let inc = 1;
        warStatus.forEach(st => {
            if (st.warId !== battleId && st.status === false) {
                inc = 0;
            }
        })
        let newRec = await TowerRecordModel.updateRecord(roleId, towerLv, battleCode, battleId, heroes, inc);
        let bonusReward = null;
        let towerReward = null;
        if (inc === 1) {
            await RoleModel.towerLvUp(roleId);
            const nextTowerInfo = getTowerDataByLv(towerLv + 1);
            if (nextTowerInfo) {
                const { warIds } = nextTowerInfo;
                const sts = decodeArrayStr(warIds).map(id => {
                    return {warId: parseInt(id), status: false};
                });
                await TowerRecordModel.createRecord({roleId, lv: towerLv + 1, warStatus: sts});
            }
            const { bonus, fixReward } = getTowerDataByLv(towerLv);
            if (bonus) {
                bonusReward = await handleFixedReward(roleId, roleName, bonus, 1);
            }
            if (fixReward) {
                towerReward = await handleFixedReward(roleId, roleName, fixReward, 1);
            }
            if (towerLv + 1 >= HANG_UP_CONSTS.ENABLE_LV) {
                await startHangUp(roleId, roleName);
                channelService.pushMessageByUids('hangUpEnable', {code: 200, data: {enable: true}}, [{uid: roleId, sid}]);
            }
        }
        return {
            status: 0,
            data: {
                newRec,
                bonusReward, towerReward,
                towerStatus: !!inc
            }
        };
    }
}

async function startHangUp(roleId: string, roleName: string) {
    await HangUpRecordModel.initRecord(roleId, roleName);
}

export async function calcuHangUpReward(roleId: string, speedUp = false, speedUpCnt = 1, curTime = new Date()) {
    let { towerLv, hangUpSpdUpCnt, lastSpdUpTime } = await RoleModel.findByRoleId(roleId);
    let { startLv, startTime} = await HangUpRecordModel.getCurRec(roleId);
    let towerInfo = getTowerDataByLv(towerLv - 1); // towerLv 是当前层，奖励计算按照已经通过的层，即上一层
    let multi = 1;
    if (speedUp) {
        if (hangUpSpdUpCnt >= speedUpCnt || shouldRefresh(lastSpdUpTime, new Date, HANG_UP_CONSTS.REFRESH_TIME, 1)) {
            multi = speedUpCnt;
        } else {
            multi = 0;
        }
    } else {
        let deltaTime = curTime.getTime() - startTime.getTime();
        if (deltaTime > HANG_UP_CONSTS.MAX_TIME) deltaTime = HANG_UP_CONSTS.MAX_TIME;
        multi = Math.floor(deltaTime / HANG_UP_CONSTS.UNIT_TIME);
    }
    return {
        endLv: towerLv - 1,
        endTime: new Date(startTime.getTime() + multi * HANG_UP_CONSTS.UNIT_TIME),
        timeReward: towerInfo.timeReward,
        multi
    };
}