pvp：巅峰之路修改

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

@@ -1,7 +1,7 @@
 
 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { uniq, findWhere, findIndex } from 'underscore';
-import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
+import { gameData, getPvpBoxBySeasonNumAndIndex } from '../../../pubUtils/data';
 import { refreshEnemies, getEnemies, getLvByScore, comsumeChallengeCnt, refChallengeCnt, generPVPOppRecInfo, generMyRecInfo, sendLastSeasonRewardIfNotSent, refreshRefOppCnt, generPvpLineupCe } from '../../../services/pvpService';
 import { RoleModel, RoleType } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
@@ -517,11 +517,13 @@ export class PvpHandler {
         let serverId = session.get('serverId');
         let roleName = session.get('roleName');
         
+        let seasonNum: number = this.app.get('pvpSeasonNum');
         let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
-        let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
+        let { seasonWinNum, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
-        let pvpBoxs = getPvpBoxs();
+        let dicPvpBox = getPvpBoxBySeasonNumAndIndex(seasonNum, id);
-        let pvpBox = findWhere(pvpBoxs, { id });
+        if(!dicPvpBox) return resResult(STATUS.DIC_DATA_NOT_FOUND);
-        if (hisScore < pvpBox.score) {
+
+        if (seasonWinNum < dicPvpBox.winTimes) {
             return resResult(STATUS.PVP_NOT_REACH_BOX_SCORE);
         }
         if (receivedBox.indexOf(id) != -1) {
@@ -530,7 +532,7 @@ export class PvpHandler {
         receivedBox.push(id);
         let { challengeCnt, challengeRefTime } = await refChallengeCnt(lastChallengeCnt, lastChallengeRefTime, seasonEndTime, roleId, session.get('vipStartTime'));
         await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
-        let result = await addItems(roleId, roleName, sid, pvpBox.reward, ITEM_CHANGE_REASON.PVP_BOX_REWARD);
+        let result = await addItems(roleId, roleName, sid, dicPvpBox.reward, ITEM_CHANGE_REASON.PVP_BOX_REWARD);
         // 任务
         await checkTask(serverId, roleId, sid, TASK_TYPE.PVP_RECEIVE_BOX);
         return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });

game-server/app/services/pvpService.ts

@@ -6,7 +6,7 @@ import { PVP_HERO_POS, REDIS_KEY, PVP_CONST, COUNTER, TASK_TYPE, MAIL_TYPE, TA_E
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
 import { getRandSingleIndex, genCode, shouldRefresh, getChineseName, makeRobotId, robotIdComBack, getRandSingleEelm } from '../pubUtils/util';
 import { pvpEndParamInter, RewardInter } from '../pubUtils/interface';
-import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByRank, getPvpDifficultByScore, getPlvAndScore } from "../pubUtils/data";
+import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByRank, getPvpDifficultByScore, getPlvAndScore, getPvpBoxsBySeasonNum } from "../pubUtils/data";
 import { PVP } from '../pubUtils/dicParam';
 import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig'
 import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
@@ -387,10 +387,11 @@ export function getRobotAttribute(hid: number, posRatio: number, score: number)
 
 // 获取我方战报记录
 export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType, isSuccess: boolean, pos: number, myHeroes: pvpEndParamInter[]) {
-    let { attack, defense, heroScores, winStreakNum, hisWinStreakNum = 0, score, hisScore } = pvpDefense;
+    let { attack, defense, heroScores, winStreakNum, hisWinStreakNum = 0, score, hisScore, seasonWinNum } = pvpDefense;
     let { roleId } = role;
     if (isSuccess) {
         winStreakNum ++;
+        seasonWinNum ++;
     } else {
         winStreakNum = 0;
     }
@@ -440,7 +441,7 @@ export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType,
     let newDefense = <Defense>calLineupScore(defense, heroScores);
 
     let updateParam = {
-        winStreakNum, hisWinStreakNum, attack: newAttack, defense: newDefense, heroScores, score: score + addSumScore, hisScore: hisScore > score + addSumScore? hisScore: score + addSumScore
+        winStreakNum, hisWinStreakNum, attack: newAttack, defense: newDefense, heroScores, score: score + addSumScore, hisScore: hisScore > score + addSumScore? hisScore: score + addSumScore, seasonWinNum
     }
 
     return { attackInfo, showHeroScores, updateParam }
@@ -542,25 +543,43 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayer,
 export async function sendPVPRewardToUser(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime: number) {
     //检查并返回排名结算以及武将功勋结算
     let pvpSeasonResult = await savePvpSeasonResult(pvpDefense, seasonNum, seasonEndTime);
-    let { rankGoods, heroGoods, rankLv } = pvpSeasonResult;
+    let { rankGoods, heroGoods, rankLv, seasonWinNum, receivedBox } = pvpSeasonResult;
     //下发邮件
-    if (!!rankGoods.length) //排名奖励
+    if (rankGoods.length > 0) //排名奖励
         await sendMailByContent(MAIL_TYPE.PVP_RANK_REWARD, pvpDefense.roleId, {
             params: [JSON.stringify(seasonNum), (rankLv > 1000 ? '999+' : JSON.stringify(rankLv))],
             goods: rankGoods
         });
-    if (!!heroGoods.length) //武将功勋奖励
+    if (heroGoods.length > 0) //武将功勋奖励
         await sendMailByContent(MAIL_TYPE.PVP_RESULT, pvpDefense.roleId, {
             params: [JSON.stringify(seasonNum)],
             goods: heroGoods
         });
 
+    if(receivedBox.length > 0) 
+        await sendUnreceivedPvpBox(pvpDefense.roleId, seasonNum, seasonWinNum, receivedBox);
+
     return {
         pvpSeasonResult,
         pvpDefense: await resetPvpScores(pvpDefense, seasonNum + 1, pvpSeasonResult)
     }
 }
 
+async function sendUnreceivedPvpBox(roleId: string, seasonNum: number, seasonWinNum: number, receivedBox: number[]) {
+    let rewards: RewardInter[] = [];
+    let pvpBoxes = getPvpBoxsBySeasonNum(seasonNum);
+    for(let { index, winTimes, reward } of pvpBoxes) {
+        if(seasonWinNum >= winTimes && receivedBox.indexOf(index) == -1) {
+            rewards.push(...reward);
+        }
+    }
+    if(rewards.length > 0) {
+        await sendMailByContent(MAIL_TYPE.PVP_BOX, roleId, {
+            goods: rewards
+        });
+    }
+}
+
 async function resetPvpScores(pvpDefense: PvpDefenseType, seasonNum: number, pvpSeasonResult: PvpSeasonResultType) {
     let { roleId, attack, defense } = pvpDefense;
     let { newHeroScores, newScore } = pvpSeasonResult;
@@ -571,7 +590,8 @@ async function resetPvpScores(pvpDefense: PvpDefenseType, seasonNum: number, pvp
 
     pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { 
         heroScores: newHeroScores, score: newScore, attack: newAttack, defense: newDefense,
-        seasonNum, challengeCnt: initCount, challengeRefTime: 0, winStreakNum: 0, isFirstEntry: true
+        seasonNum, challengeCnt: initCount, challengeRefTime: 0, winStreakNum: 0, isFirstEntry: true,
+        seasonWinNum: 0, receivedBox: []
     });
     return pvpDefense;
 }

shared/consts/constModules/mailConst.ts

@@ -53,6 +53,7 @@ export enum MAIL_TYPE {
     GUILD_DAILY_BOX = 24,  // 军团每日活跃宝箱补领
     GUILD_FUND_BOX = 25,   // 军团每日捐献宝箱补领
     GUILD_BOSS = 26, // 军团boss奖励
+    PVP_BOX = 27, // pvp巅峰之路宝箱
 };
 
 export const SEND_NAME = '系统';

shared/db/PvpDefense.ts

@@ -56,6 +56,8 @@ export default class PvpDefense extends BaseModel {
     receivedBox: Array<number>;
     @prop({ required: true, default: 0 })
     seasonNum: number;
+    @prop({ required: true, default: 0 })
+    seasonWinNum: number;          // 本赛季胜利次数
     @prop({ required: true, default: true })
     isFirstEntry: boolean;
 

shared/db/PvpSeasonResult.ts

@@ -38,6 +38,12 @@ export default class PvpSeasonResult extends BaseModel {
     @prop({ required: true, type: () => HeroScore, default:[] })
     newHeroScores: HeroScore[];
 
+    @prop({ required: true, type: Number, default: [] })
+    receivedBox: Array<number>;
+
+    @prop({ required: true, default: 0 })
+    seasonWinNum: number;          // 本赛季胜利次数
+
     public static async updatePvpSeasonResult(roleId: string, seasonNum: number, update: PvpSeasonResultUpdate , lean = true) {
         delete update._id;
         let result: PvpSeasonResultType = await PvpSeasonResultModel.findOneAndUpdate({roleId, seasonNum}, {$set: update}, {upsert: true, new: true}).lean(lean);

shared/domain/battleField/pvp.ts

@@ -240,6 +240,7 @@ export class PvpDataReturn {
     buyAttackCnt: number;
     challengeCnt: number;
     challengeRefTime: number;
+    seasonWinNum: number;
     receivedBox: number[] = [];
     hisScore: number = 0;
     heroScores: HeroScoreReturn[] = [];
@@ -249,6 +250,7 @@ export class PvpDataReturn {
     setPvpDefense(pvpDefense: PvpDefenseType) {
         this.score = pvpDefense.score;
         this.winStreakNum = pvpDefense.winStreakNum;
+        this.seasonWinNum = pvpDefense.seasonWinNum;
         this.receivedBox = pvpDefense.receivedBox;
         this.hisScore = pvpDefense.hisScore;
 

shared/pubUtils/data.ts

@@ -31,7 +31,7 @@ import { dicPvpTeamLevel, loadPvpTeamLevel } from './dictionary/DicPvpTeamLevel'
 import { dicPvpRefreshConsume, maxPvpRefreshCnt, loadPvpRefreshConsume } from './dictionary/DicPvpRefreshConsume';
 import { dicHeroRewads, loadPvpHeroReward } from './dictionary/DicPvpHeroReward';
 import { dicRankRewads, dicRankMax, loadPvpRankReward } from './dictionary/DicPvpRankReward';
-import { dicPvpBoxs, loadPvpBox } from './dictionary/DicPvpBox';
+import { DicPvpBox, dicPvpBoxesBySeasonNum, dicPvpBoxs, loadPvpBox } from './dictionary/DicPvpBox';
 import { dicGuildAuth, loadGuildAuth } from './dictionary/DicGuildAuth';
 import { dicCenterBase, dicEquipPriduceBase, dicBossBase, dicTrainBase, dicDonateBase, dicWishPoolBase, dicStoreBase, dicStructureConsume, dicBossBaseByBossLv, loadStructure } from "./dictionary/DicStructure";
 import { dicGuildActiveDayReward, loadGuildActiveDayReward } from './dictionary/DicGuildActiveDayReward';
@@ -157,6 +157,7 @@ export const gameData = {
     pvpHeroRewards: dicHeroRewads,
     pvpRankRewards: dicRankRewads,
     pvpBoxs: dicPvpBoxs,
+    pvpBoxesBySeasonNum: dicPvpBoxesBySeasonNum,
     pvpRankMax: dicRankMax,
     guildAuth: dicGuildAuth,
     centerBase: dicCenterBase,
@@ -468,8 +469,33 @@ export function getPvpRankRewardsByRank(rankLv: number) {
     return gameData.pvpRankMax.max;
 }
 
-export function getPvpBoxs() {
+function getPvpBoxKeysBySeasonNum(seasonNum: number) {
-    return gameData.pvpBoxs;
+    if(gameData.pvpBoxesBySeasonNum.has(seasonNum)) {
+        return gameData.pvpBoxesBySeasonNum.get(seasonNum);
+    } else {
+        let result = new Map<number, string>();
+        for(let [_seasonNum, key] of gameData.pvpBoxesBySeasonNum) {
+            result = key;
+            if(_seasonNum >= seasonNum) break;
+        }
+        return result
+    }
+}
+
+export function getPvpBoxBySeasonNumAndIndex(seasonNum: number, index: number) {
+    let indexToKey = getPvpBoxKeysBySeasonNum(seasonNum);
+    let key = indexToKey?.get(index);
+    return key? gameData.pvpBoxs.get(key): null;
+}
+
+export function getPvpBoxsBySeasonNum(seasonNum: number) {
+    let result: DicPvpBox[] = []
+    let indexToKey = getPvpBoxKeysBySeasonNum(seasonNum);
+    for(let [_, key] of indexToKey) {
+        let pvpBox = gameData.pvpBoxs.get(key);
+        if(pvpBox) result.push(pvpBox);
+    }
+    return result;
 }
 
 export function getResultMaxRank() {

shared/pubUtils/dictionary/DicPvpBox.ts

@@ -2,21 +2,29 @@ import { readFileAndParse, parseGoodStr } from '../util'
 import { FILENAME } from '../../consts'
 import { RewardInter } from '../interface';
 export interface DicPvpBox {
-
     readonly id: number;
-    readonly score: number;
+    readonly seasonNum: number;
+    readonly index: number;
+    readonly winTimes: number;
     readonly reward:  Array<RewardInter>;
 
 }
 
-export const dicPvpBoxs = new Array<DicPvpBox>();
+export const dicPvpBoxs = new Map<string, DicPvpBox>();
+export const dicPvpBoxesBySeasonNum = new Map<number, Map<number, string>>();
 export function loadPvpBox() {
-    dicPvpBoxs.splice(0, dicPvpBoxs.length);
+    dicPvpBoxs.clear();
+    dicPvpBoxesBySeasonNum.clear();
     let arr = readFileAndParse(FILENAME.DIC_PVP_BOX);
 
     arr.forEach(o => {
         o.reward = parseGoodStr(o.reward);
-        dicPvpBoxs.push(o);
+        let key = `${o.seasonNum}_${o.index}`;
+        dicPvpBoxs.set(key, o);
+        if(!dicPvpBoxesBySeasonNum.has(o.seasonNum)) {
+            dicPvpBoxesBySeasonNum.set(o.seasonNum, new Map());
+        }
+        dicPvpBoxesBySeasonNum.get(o.seasonNum).set(o.index, key);
     });
     arr = undefined;
 }

shared/resource/jsons/dic_email_content.json

@@ -187,5 +187,12 @@
         "sendName": "&",
         "content": "感谢您昨日为军团演武台所做的贡献，且有奖励尚未领取，现已发送至您的邮箱，请查收",
         "time": 720
+    },
+    {
+        "id": 27,
+        "title": "&",
+        "sendName": "&",
+        "content": "竞技新赛季开始啦，您在上赛季的巅峰之路中有奖励尚未领取，现已发送至您邮箱，请查收",
+        "time": 720
     }
 ]

shared/resource/jsons/dic_pvp_boxReward.json

@@ -1,52 +1,212 @@
 [
     {
         "id": 1,
-        "score": 500,
+        "seasonNum": 1,
+        "index": 1,
+        "winTimes": 2,
         "reward": "11014&10"
     },
     {
         "id": 2,
-        "score": 1000,
+        "seasonNum": 1,
+        "index": 2,
+        "winTimes": 4,
         "reward": "31001&200000"
     },
     {
         "id": 3,
-        "score": 1500,
+        "seasonNum": 1,
+        "index": 3,
+        "winTimes": 6,
         "reward": "17044&10"
     },
     {
         "id": 4,
-        "score": 2000,
+        "seasonNum": 1,
+        "index": 4,
+        "winTimes": 8,
         "reward": "31002&200"
     },
     {
         "id": 5,
-        "score": 2500,
+        "seasonNum": 1,
+        "index": 5,
+        "winTimes": 10,
         "reward": "60004&1"
     },
     {
         "id": 6,
-        "score": 3000,
+        "seasonNum": 1,
+        "index": 6,
+        "winTimes": 15,
         "reward": "22001&3"
     },
     {
         "id": 7,
-        "score": 3500,
+        "seasonNum": 1,
+        "index": 7,
+        "winTimes": 20,
         "reward": "11003&10"
     },
     {
         "id": 8,
-        "score": 4000,
+        "seasonNum": 1,
+        "index": 8,
+        "winTimes": 25,
         "reward": "17042&4"
     },
     {
         "id": 9,
-        "score": 4500,
+        "seasonNum": 1,
+        "index": 9,
+        "winTimes": 30,
         "reward": "17001&2"
     },
     {
         "id": 10,
-        "score": 5000,
+        "seasonNum": 1,
+        "index": 10,
+        "winTimes": 35,
+        "reward": "41202&1"
+    },
+    {
+        "id": 11,
+        "seasonNum": 2,
+        "index": 1,
+        "winTimes": 2,
+        "reward": "11014&10"
+    },
+    {
+        "id": 12,
+        "seasonNum": 2,
+        "index": 2,
+        "winTimes": 4,
+        "reward": "31001&200000"
+    },
+    {
+        "id": 13,
+        "seasonNum": 2,
+        "index": 3,
+        "winTimes": 6,
+        "reward": "17044&10"
+    },
+    {
+        "id": 14,
+        "seasonNum": 2,
+        "index": 4,
+        "winTimes": 8,
+        "reward": "31002&200"
+    },
+    {
+        "id": 15,
+        "seasonNum": 2,
+        "index": 5,
+        "winTimes": 10,
+        "reward": "60004&1"
+    },
+    {
+        "id": 16,
+        "seasonNum": 2,
+        "index": 6,
+        "winTimes": 15,
+        "reward": "22001&3"
+    },
+    {
+        "id": 17,
+        "seasonNum": 2,
+        "index": 7,
+        "winTimes": 20,
+        "reward": "11003&10"
+    },
+    {
+        "id": 18,
+        "seasonNum": 2,
+        "index": 8,
+        "winTimes": 25,
+        "reward": "17042&4"
+    },
+    {
+        "id": 19,
+        "seasonNum": 2,
+        "index": 9,
+        "winTimes": 30,
+        "reward": "17001&2"
+    },
+    {
+        "id": 20,
+        "seasonNum": 2,
+        "index": 10,
+        "winTimes": 35,
+        "reward": "41202&1"
+    },
+    {
+        "id": 21,
+        "seasonNum": 3,
+        "index": 1,
+        "winTimes": 2,
+        "reward": "11014&10"
+    },
+    {
+        "id": 22,
+        "seasonNum": 3,
+        "index": 2,
+        "winTimes": 4,
+        "reward": "31001&200000"
+    },
+    {
+        "id": 23,
+        "seasonNum": 3,
+        "index": 3,
+        "winTimes": 6,
+        "reward": "17044&10"
+    },
+    {
+        "id": 24,
+        "seasonNum": 3,
+        "index": 4,
+        "winTimes": 8,
+        "reward": "31002&200"
+    },
+    {
+        "id": 25,
+        "seasonNum": 3,
+        "index": 5,
+        "winTimes": 10,
+        "reward": "60004&1"
+    },
+    {
+        "id": 26,
+        "seasonNum": 3,
+        "index": 6,
+        "winTimes": 15,
+        "reward": "22001&3"
+    },
+    {
+        "id": 27,
+        "seasonNum": 3,
+        "index": 7,
+        "winTimes": 20,
+        "reward": "11003&10"
+    },
+    {
+        "id": 28,
+        "seasonNum": 3,
+        "index": 8,
+        "winTimes": 25,
+        "reward": "17042&4"
+    },
+    {
+        "id": 29,
+        "seasonNum": 3,
+        "index": 9,
+        "winTimes": 30,
+        "reward": "17001&2"
+    },
+    {
+        "id": 30,
+        "seasonNum": 3,
+        "index": 10,
+        "winTimes": 35,
         "reward": "41202&1"
     }
 ]