名将擂台：奖励及扫荡

game-server/app/servers/battle/handler/ladderHandler.ts

@@ -5,7 +5,7 @@ import { gameData } from '../../../pubUtils/data';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { LadderMatchModel, LadderUpdateInter } from '../../../db/LadderMatch';
-import { battleEndWhenChange, checkRank, generateInitRecInfo, getBuyCntCost, getLadderData, getLadderOppStatus, refreshLadderDaily, refreshLadderEnemies } from '../../../services/ladderService';
+import { battleEndWhenChange, checkRank, generateInitRecInfo, getBuyCntCost, getLadderData, getLadderOppStatus, ladderBattleEndReward, refreshLadderDaily, refreshLadderEnemies } from '../../../services/ladderService';
 import { LadderDataReturn, LadderDefense, LadderDefenseHero, LadderOppDetailReturn, LadderOppLineupReturn, LadderOppPlayerHeroInfo, LadderOppPlayerReturn } from '../../../domain/battleField/ladder';
 import { LadderMatchRecModel } from '../../../db/LadderMatchRec';
 import { HeroModel } from '../../../db/Hero';
@@ -15,6 +15,7 @@ import { ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS, REDIS_KEY } from
 import { getHeroesAttributes } from '../../../services/playerCeService';
 import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
 import { Rank } from '../../../services/rankService';
+import { WarReward } from '../../../services/warRewardService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -176,12 +177,14 @@ export class LadderHandler {
     // 7. 挑战结算
     async battleEnd(msg: { battleCode: string, isSuccess: boolean }, session: BackendSession) {
         let roleId = session.get('roleId');
-        let serverId = session.get('serverId');
+        let roleName = session.get('roleName');
+        let sid = session.get('sid');
         let { battleCode, isSuccess } = msg;
 
         let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
         if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
         if(rec.status != LADDER_STATUS.BATTLE) return resResult(STATUS.LADDER_REC_STATUS_ERR);
+        let rank = rec.defenseInfo.oldRank;
 
         let ladderData = await LadderMatchModel.findByRoleId(roleId);
         if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
@@ -202,24 +205,48 @@ export class LadderHandler {
             rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess);
         }
 
-        ladderData = await LadderMatchModel.updateByRoleId(roleId, { historyRank: atkLadderMatch.rank < ladderData.historyRank? atkLadderMatch.rank: ladderData.historyRank, locked: 0 });
+        let isBreak = ladderData.historyRank > atkLadderMatch.rank;
+        ladderData = await LadderMatchModel.updateByRoleId(roleId, { historyRank: isBreak? atkLadderMatch.rank: ladderData.historyRank, locked: 0 });
 
         result.setLadderData(ladderData, rec);
         // 获取奖励
+        let { battleGoods, breakGoods } = await ladderBattleEndReward(roleId, roleName, sid, rank, isSuccess, isBreak, 1);
 
-        return resResult(STATUS.SUCCESS, result)
+        return resResult(STATUS.SUCCESS, {...pick(result, ['rank', 'historyRank', 'challengeCnt','status', 'time', 'oppPlayers']), battleGoods, breakGoods});
     }
 
     // 8. 战5次（扫荡）
     async battleSweep(msg: { roleId: string, rank: number, count: number }, session: BackendSession) {
         let roleId = session.get('roleId');
+        let roleName = session.get('roleName');
+        let sid = session.get('sid');
         let { roleId: targetRoleId, rank, count } = msg;
 
-        // 检查是否可以扫荡对手
+        let ladderData = await LadderMatchModel.findByRoleId(roleId);
-        // 扣挑战次数
+        if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
-        // 获取奖励
 
-        return resResult(STATUS.SUCCESS)
+        if(ladderData.rank >= rank) return resResult(STATUS.LADDER_RANK_ERR);
+
+        // 刷新次数
+        let refOppObj = refreshLadderDaily(ladderData);
+        let update: LadderUpdateInter = {};
+        if(refOppObj.shouldRefOpp) {
+            update = { ...refOppObj };
+        }
+
+        if(refOppObj.challengeCnt + count > LADDER.LADDER_CHALLENGE_FREE_TIMES + refOppObj.buyCnt) {
+            return resResult(STATUS.LADDER_CHALLENGE_CNT_MAX);
+        }
+        update.challengeCnt = refOppObj.challengeCnt + count;
+        ladderData = await LadderMatchModel.updateByRoleIdAndInclude(roleId, update);
+
+        // 获取奖励
+        let { battleGoods } = await ladderBattleEndReward(roleId, roleName, sid, rank, true, false, count);
+
+        return resResult(STATUS.SUCCESS, {
+            challengeCnt: ladderData.challengeCnt,
+            battleGoods
+        });
     }
 
     // 9. 设置防守阵容

game-server/app/services/ladderService.ts

@@ -1,4 +1,4 @@
-import { LADDER_OPP_STATUS, LADDER_STATUS, PUSH_ROUTE, REDIS_KEY } from "../consts";
+import { ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS, PUSH_ROUTE, REDIS_KEY } from "../consts";
 import { HeroType } from "../db/Hero";
 import { LadderMatchModel, LadderMatchType, LadderUpdateInter } from "../db/LadderMatch";
 import { LadderMatchRecModel } from "../db/LadderMatchRec";
@@ -10,7 +10,9 @@ import { ItemInter } from "../pubUtils/interface";
 import { getRandValueByMinMax, shouldRefresh } from "../pubUtils/util";
 import { sendMessageToUserWithSuc } from "./pushService";
 import { Rank } from "./rankService";
+import { addItems } from "./role/rewardService";
 import { combineItems } from "./role/util";
+import { WarReward } from "./warRewardService";
 
 export function refreshLadderDaily(ladderData: LadderMatchType) {
 
@@ -272,7 +274,6 @@ export async function battleEndWhenChange(ladderMatch: LadderMatchType) {
 
     // 更新redis
     let r = new Rank(REDIS_KEY.LADDER, { serverId: ladderMatch.serverId });
-    console.log('##### ladderMatch.roleId', ladderMatch.roleId)
     r.setRankWithRoleInfo(ladderMatch.roleId, ladderMatch.rank, 0);
 
     // 刷新对手
@@ -283,4 +284,15 @@ export async function battleEndWhenChange(ladderMatch: LadderMatchType) {
         oppPlayers
     });
     return oppPlayers
+}
+
+export async function ladderBattleEndReward(roleId: string, roleName: string, sid: string, rank: number, isSuccess: boolean, isBreak: boolean, num: number) {
+    let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
+    if(!dicLadderDifficultRatio) return null;
+    let warReward = new WarReward(roleId, roleName, sid, dicLadderDifficultRatio.gkId, isSuccess);
+    warReward.setLadderReward(dicLadderDifficultRatio.randomFailReward, true);
+    warReward.setLadderReward(dicLadderDifficultRatio.randomWinReward, false);
+    let battleGoods = await warReward.saveReward(num);
+    let breakGoods = isBreak? await addItems(roleId, roleName, sid, dicLadderDifficultRatio?.onceReward||[], ITEM_CHANGE_REASON.LADDER_BATTLE_REWARD): [];
+    return { battleGoods, breakGoods };
 }

game-server/app/services/warRewardService.ts

@@ -22,24 +22,26 @@ export class WarReward {
     private condition: Map<number, boolean>;
     private warInfo: DicWar;
     private isSuccess: boolean;
-    private rewards: Array<{type?: number, id: number, count: number, times?: number}>;
+    private rewards: Array<{type?: number, id: number, count: number, times?: number}> = [];
-    private fixReward: Array<{id: number, count: number}>;
+    private fixReward: Array<{id: number, count: number}> = [];
-    private conditionReward: Array<{id: number, count: number, condition: number}>;
+    private conditionReward: Array<{id: number, count: number, condition: number}> = [];
-    private randomReward: Array<{id: number, count: number, frequency: 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;
-        this.battleId = battleId;
+        if(battleId) {
+            this.battleId = battleId;
+            this.warInfo = gameData.war.get(battleId);
+            let { fixReward, conditionReward, randomReward } = this.warInfo;
+            this.fixReward = fixReward;
+            this.conditionReward = conditionReward;
+            this.randomReward = randomReward;
+        }
         this.condition = new Map();
-        this.warInfo = gameData.war.get(battleId);
-
-        let { fixReward, conditionReward, randomReward } = this.warInfo;
-        this.fixReward = fixReward;
-        this.conditionReward = conditionReward;
-        this.randomReward = randomReward;
 
         this.isSuccess = isSuccess;
         this.costAp = this.warInfo.cost;
@@ -71,16 +73,24 @@ export class WarReward {
         }
     }
 
-    private handleFixReward(num: number, fixReward: RewardInter[]) {
+    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 fixReward) {
+            for(let obj of this.fixReward) {
                 this.rewards.push({type: BATTLE_REWARD_TYPE.FIX_REWARD, times: i +1, ...obj, count: obj.count });
             }
         }
     }
-    private handleConditionReward(num: number, conditionReward: {id: number, count: number, condition: number}[]) {
+    private handleConditionReward(num: number) {
+        if(!this.conditionReward) return
         for(let i = 0; i < num; i++) {
-            for(let obj of conditionReward) {
+            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});
                 }
@@ -88,9 +98,9 @@ export class WarReward {
         }
     }
 
-    private async handleRandomReward(num: number, randomReward: {id: number, count: number, frequency: number}[]) {
+    private async handleRandomReward(num: number) {
-
+        if(!this.randomReward) return
-        for(let obj of randomReward) {
+        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;
@@ -117,18 +127,30 @@ export class WarReward {
         }
     }
 
+    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, this.fixReward);
+            if(this.fixReward) this.handleFixReward(num);
-            if(this.conditionReward) this.handleConditionReward(num, this.conditionReward);
+            if(this.conditionReward) this.handleConditionReward(num);
-            if(this.randomReward) await this.handleRandomReward(num, this.randomReward);
+            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) {

shared/consts/constModules/battleConst.ts

@@ -32,6 +32,7 @@ export const WAR_TYPE = {
   ACT_NEW_HERO_GK: 18, // 新将演绎活动
   TRY: 19,           // 试用关卡
   BOSS: 20,          // 演武台
+  LADDER: 21,        // 名将擂台
 };
 
 // 藏宝图掉落参数

shared/consts/constModules/sysConst.ts

@@ -1020,6 +1020,7 @@ export enum ITEM_CHANGE_REASON {
     ACT_DAILY_COIN_RECEIVE_BOX = 149,        // 招财进宝领取宝箱 
     USE_VOUCHER = 150,                       // 使用代金券
     LADDER_BUY_CNT = 151,                    // 名将擂台购买次数
+    LADDER_BATTLE_REWARD = 152,              // 名将擂台关卡奖励
 }
 
 export enum TA_EVENT {

shared/consts/statusCode.ts

@@ -267,6 +267,7 @@ export const STATUS = {
     LADDER_REC_STATUS_IS_COMPLETE: { code: 21205, simStr: '该战斗已结束' },
     LADDER_CHALLENGE_CNT_MAX: { code: 21206, simStr: '挑战次数已达上限' },
     LADDER_REC_STATUS_ERR: { code: 21207, simStr: '战斗状态错误' },
+    LADDER_RANK_ERR: { code: 21208, simStr: '不可连战比排名自己高的玩家' },
 
     // 通用 30000 - 30099
     DIC_DATA_NOT_FOUND: { code: 30000, simStr: '数据表未找到' },

shared/pubUtils/util.ts

@@ -681,6 +681,8 @@ export function getReasonByWarType(warType: number) {
             return ITEM_CHANGE_REASON.TRY_BATTLE_END;
         case WAR_TYPE.BOSS:
             return ITEM_CHANGE_REASON.BOSS_BATTLE_END;
+        case WAR_TYPE.LADDER:
+            return ITEM_CHANGE_REASON.LADDER_BATTLE_REWARD;
         default: 
             return ITEM_CHANGE_REASON.NORMAL_BATTLE_END;
     }