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

/**
 * 战场奖励发放 对象
 * 支持战场相关的奖励格式，目前包括fixedReward, randomReward, conditionReward
 */

import { BattleDropModel } from '../db/BattleDrop';
import { getRandEelmWithWeight, getRandSingleEelm, getReasonByWarType } from '../pubUtils/util';
import { BATTLE_REWARD_TYPE, BLUEPRT_CONST } from '../consts';
import { addItems } from './role/rewardService';
import { RoleModel } from '../db/Role';
import { gameData } from '../pubUtils/data';
import { DicWar } from '../pubUtils/dictionary/DicWar';
import { RewardInter } from '../pubUtils/interface';
import { getZeroPointD } from '../pubUtils/timeUtil';
import { combineItems } from './role/util';

export class WarReward {
    private roleId: string;
    private roleName: string;
    private sid: string;
    private battleId: number;
    private condition: Map<number, boolean>;
    private warInfo: DicWar;
    private isSuccess: boolean;
    private rewards: Array<{type?: number, id: number, count: number, times?: number}> = [];
    private fixReward: Array<{id: number, count: number}> = [];
    private conditionReward: Array<{id: number, count: number, condition: number}> = [];
    private randomReward: Array<{id: number, count: number, frequency: number}> = [];
    private ladderReward: Array<{id: number, count: number, weight: number, isSuccess: boolean}> = [];
    private costAp: number;

    constructor(roleId: string, roleName: string, sid: string, battleId: number, isSuccess: boolean) {
        this.roleId = roleId;
        this.roleName = roleName;
        this.sid = sid;
        if(battleId) {
            this.battleId = battleId;
            this.warInfo = gameData.war.get(battleId);
            let { fixReward, conditionReward, randomReward } = this.warInfo;
            this.setFixReward(fixReward);
            this.setConditionReward(conditionReward);
            this.setRandomReward(randomReward);
        }
        this.condition = new Map();

        this.isSuccess = isSuccess;
        this.costAp = this.warInfo.cost;
    }

    public setCondition(id: number, isOk: boolean) {
        this.condition.set(id, isOk);
    }

    public setFixReward(reward: RewardInter[]) {
        for(let r of reward) {
            // console.log('#####setFixReward', JSON.stringify(r));
            this.fixReward.push(r);
        }
    }

    public resetFixReward(reward: RewardInter[]) {
        this.fixReward = reward;
    }

    public setConditionReward(reward: {id: number, count: number, condition: number}[]) {
        for(let r of reward) {
            this.conditionReward.push(r);
        }
    }

    public setRandomReward(reward: {id: number, count: number, frequency: number}[]) {
        for(let r of reward) {
            this.randomReward.push(r);
        }
    }

    public setLadderReward(reward: {id: number, count: number, weight: number}[], isSuccess: boolean) {
        for(let r of reward) {
            this.ladderReward.push({...r, isSuccess});
        }
    }

    private handleFixReward(num: number) {
        if(!this.fixReward) return
        for(let i = 0; i < num; i++) {
            for(let obj of this.fixReward) {
                // console.log('##### handleFixReward', JSON.stringify(obj));
                this.rewards.push({type: BATTLE_REWARD_TYPE.FIX_REWARD, times: i +1, ...obj, count: obj.count });
            }
        }
    }
    private handleConditionReward(num: number) {
        if(!this.conditionReward) return
        for(let i = 0; i < num; i++) {
            for(let obj of this.conditionReward) {
                if(this.condition.get(obj.condition)) {
                    this.rewards.push({type: BATTLE_REWARD_TYPE.CONDITION_REWARD, times: i +1, ...obj, count: obj.count});
                }
            }
        }
    }

    private async handleRandomReward(num: number) {
        if(!this.randomReward) return
        for(let obj of this.randomReward) {
            let { id, frequency } = obj;
            let dropHistory = await BattleDropModel.findByGid(this.roleId, this.battleId, id);
            let { getNum = 0, allNum = 0, getSum = 0, allSum = 0 } = dropHistory;
            for(let i = 0; i < num; i ++) {
                let flag = false; // 是否可以获得
                if(allNum >= frequency) {
                    allNum = 0; getNum = 0;
                }
                allNum++; allSum++;
                if(getNum == 0) {
                    let r = Math.random();
                    if(r <= 1/frequency*allNum || (allNum >= frequency) ) {
                        flag = true; // 独立概率随机
                    }
                }
                if(flag) {
                    getNum ++; getSum++;
                    this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, times: i +1, ...obj});
                }
            }
            await BattleDropModel.updateByGid(this.roleId, this.battleId, id, {
                getNum, allNum, getSum, allSum
            });
        }
    }

    private async handleLadderReward(num: number, isSuccess: boolean) {
        if(!this.ladderReward) return;
        for(let i = 0; i < num; i++) {
            let arr = this.ladderReward.filter(cur => cur.isSuccess == isSuccess);
            let { dic: reward } = getRandEelmWithWeight(arr);
            if(reward) {
                this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, times: i +1, id: reward.id, count: reward.count });
            }
        }
    }

    public async saveReward(num: number, combine: boolean = false) {
        this.rewards = new Array();
        // let warType = this.warInfo.warType;
        
        if(this.isSuccess) { // 成功了才给固定奖励
            // console.log(this.fixReward)
            if(this.fixReward) this.handleFixReward(num);
            if(this.conditionReward) this.handleConditionReward(num);
            if(this.randomReward) await this.handleRandomReward(num);

            // if(this.costAp > 0) await this.handlerBlueprtReward(num);
        }
        if(this.ladderReward) this.handleLadderReward(num, this.isSuccess);

        let rewards = this.rewards;
        if(combine) {
            rewards = combineItems(rewards);
        }
        console.log('##### saveReward', JSON.stringify(rewards))
        await addItems(this.roleId, this.roleName, this.sid, rewards, getReasonByWarType(this.warInfo.warType));
        return rewards;
    }
}