pvp: 更改pvpdefense结构

game-server/app/services/pvpService.ts

@@ -1,14 +1,14 @@
 
-import { PvpDefenseModel, Heroes, OppPlayers, PvpDefenseType, HeroScores, pvpUpdateInter } from '../db/PvpDefense';
+import { PvpDefenseModel, PvpDefenseType, pvpUpdateInter } from '../db/PvpDefense';
+import { Defense, Attack, LineupCe, OppPlayer, HeroScore, HeroReward, OppPlayerReturn } from '../domain/battleField/pvp';
 import { RoleType, CeAttrDataRole } from '../db/Role';
-import { PVP_HERO_POS, REDIS_KEY, PVP_CONST, COUNTER } from '../consts';
-import { setPvpDefResult } from '../services/timeTaskService';
+import { PVP_HERO_POS, REDIS_KEY, PVP_CONST, COUNTER, TASK_TYPE, MAIL_TYPE } from '../consts';
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
-import { getRandSingleIndex, genCode, shouldRefresh, getChineseName, makeRobotId, robotIdComBack } from '../pubUtils/util';
-import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface';
-import { gameData, getPLvByScore } from "../pubUtils/data";
+import { getRandSingleIndex, genCode, shouldRefresh, getChineseName, makeRobotId, robotIdComBack, getRandSingleEelm } from '../pubUtils/util';
+import { pvpEndParamInter, RewardInter } from '../pubUtils/interface';
+import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByRank } from "../pubUtils/data";
 import { PVP } from '../pubUtils/dicParam';
-import { PVPConfigModel } from '../db/SystemConfig'
+import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig'
 import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
 import { HeroesRecord } from '../db/PvpRecord';
 import { HeroModel, CeAttrData } from '../db/Hero';
@@ -20,50 +20,10 @@ import { pinus } from 'pinus';
 import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp';
 import { Rank } from './rankService';
 import { CounterModel } from '../db/Counter';
-
-export async function getPvpData() {
-
-}
-
-
-export async function initPvpInfo(role: RoleType) {
-    let heroes: Array<Heroes> = [];
-    //初始化最强5人阵容
-    let defCe = 0;
-    for (let i = PVP_HERO_POS.START; i <= PVP_HERO_POS.END; i++) {
-        let index = i - PVP_HERO_POS.START;
-        let item = role.topLineup[index];
-        if (item) defCe += item.ce;
-        heroes.push({
-            actorId: item?.hid || 0,
-            hero: item?.hero || null,
-            ce: item?.ce || 0,
-            dataId: i,
-            order: index + 1,
-        });
-    }
-    //初始化对手人阵容
-    let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 1);
-    let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
-    let challengeCnt = PVP.PVP_CHALLENGE_COUNTS;
-    let result = await PvpDefenseModel.createPvpDefenseAndPopulate({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe, seasonNum, challengeCnt });
-
-    //加入排行榜 
-    let r = new Rank(REDIS_KEY.PVP_RANK, {});
-    await r.setRankWithRoleInfo(REDIS_KEY.PVP_RANK, result.score, result.updatedAt.getTime(), role, false);
-
-    return result;
-}
-
-export async function checkPvp(role: RoleType) {
-    if (role.hasInit) {
-        let result = await PvpDefenseModel.findByRoleId(role.roleId, true);
-        if (!!result)
-            return result;
-        result = await initPvpInfo(role);
-        return result;
-    }
-}
+import { DicRankRewads } from '../pubUtils/dictionary/DicPvpRankReward';
+import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
+import { checkTask } from '../services/taskService';
+import { sendMailByContent } from './mailService';
 
 /**
  * 返回对手三人信息
@@ -71,9 +31,9 @@ export async function checkPvp(role: RoleType) {
  * @param oppPlayers pvpDefense表中的oppPlayers字段，需要populate过的
  * @param pLv 玩家本人的队伍等级
  */
-export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number) {
+export async function getEnemies(oppPlayers: OppPlayer[], winStreakNum: number) {
 
-    let result = new Array<oppPlayersInter>();
+    let result = new Array<OppPlayerReturn>();
     for (let oppPlayer of oppPlayers) {
         let dicOpponent = dicPvpOpponent.get(oppPlayer.pos);
         let oppDef = <PvpHistoryOppType>oppPlayer.oppDef; // select 'oppRoleId pos roleName head frame spine rankLv pLv defCe'
@@ -96,21 +56,18 @@ export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number)
  * @param score 我的军功
  * @param pLv 我的排名
  */
-export async function refreshEnemies(role: RoleType, score: number, pLv: number) {
-    let system = await PVPConfigModel.findCurPVPConfig();
-    let mapWarJson = gameData.warJson.get(system.warId);
-
+export async function refreshEnemies(role: RoleType, seasonNum: number, score: number, pLv: number) {
     let { roleId } = role;
-    let oppPlayers = new Array<OppPlayers>();
+    let oppPlayers: OppPlayer[] = [];
     let opp = dicPvpOpponent.values()
     for (let dicOpp of opp) {
         let flag = false; // 是否筛选成功
         if (score >= PVP_CONST.SCORE_LINE) { // 将这个放到const
-            flag = await matchPlayer(system.seasonNum, oppPlayers, mapWarJson, roleId, pLv, dicOpp); // 按照等级匹配对手
-            if (!flag) flag = await matchPlayerByRank(system.seasonNum, oppPlayers, mapWarJson, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
-            if (!flag) flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
+            flag = await matchPlayer(seasonNum, oppPlayers, roleId, pLv, dicOpp); // 按照等级匹配对手
+            if (!flag) flag = await matchPlayerByRank(seasonNum, oppPlayers, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
+            if (!flag) flag = await matchRobot(oppPlayers, role, pLv, dicOpp);
         } else {
-            flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
+            flag = await matchRobot(oppPlayers, role, pLv, dicOpp);
         }
         if (!flag) continue;
     }
@@ -118,7 +75,7 @@ export async function refreshEnemies(role: RoleType, score: number, pLv: number)
     return oppPlayers;
 }
 
-export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pos: number) {
+export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer[], roleId: string, pos: number) {
     // console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
     let r = new Rank(REDIS_KEY.PVP_RANK, {});
     let ridRanks = new Array<number>(); // 已经被使用了的排名
@@ -172,7 +129,7 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
 
     let pvpdefense = await PvpDefenseModel.findByRoleIdIncludeAll(oppRoleId);
     if (!pvpdefense || pvpdefense.seasonNum != seasonNum) return false;
-    let pvpHistoryOpp = await generPlayerOppHis(pvpdefense, mapWarJson, roleId, pos);
+    let pvpHistoryOpp = await generPlayerOppHis(pvpdefense, roleId, pos);
     if (!pvpHistoryOpp) return false;
 
     oppPlayers.push({
@@ -184,7 +141,7 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
     return true
 }
 
-async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pLv: number, dicOpp: DicPvpOpponent) {
+async function matchPlayer(seasonNum: number, oppPlayers: OppPlayer[], roleId: string, pLv: number, dicOpp: DicPvpOpponent) {
     // console.log('matchPlayer', JSON.stringify(oppPlayers))
 
     let { id: pos, minLv, maxLv } = dicOpp
@@ -203,7 +160,7 @@ async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJs
         index = getRandSingleIndex(range.length);
         result = range[index];
     }
-    let pvpHistoryOpp = await generPlayerOppHis(result, mapWarJson, roleId, pos);
+    let pvpHistoryOpp = await generPlayerOppHis(result, roleId, pos);
     if (!pvpHistoryOpp) return false;
     oppPlayers.push({
         roleId: pvpHistoryOpp.oppRoleId,
@@ -217,12 +174,13 @@ async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJs
 /**
  * @description 对手是玩家时，生成并返回pvpHistoryOpp
  * @param result 随机出的对手pvpDefense
- * @param mapWarJson 本周地图出兵表
  * @param roleId 自己的玩家id
  * @param pos 刷新这个对手的位置
  */
-async function generPlayerOppHis(pvpdefense: PvpDefenseType, mapWarJson: DicWarJson[], roleId: string, pos: number) {
-    let { heroScores, heroes: defenseHeroes } = pvpdefense;
+async function generPlayerOppHis(pvpdefense: PvpDefenseType, roleId: string, pos: number) {
+    let { heroScores, defense } = pvpdefense;
+    if(!defense) return false;
+    let { warId, heroes: defenseHeroes } = defense;
     let role = <RoleType>pvpdefense.role;
     let r = new Rank(REDIS_KEY.PVP_RANK, {});
     let rankLv = await r.getMyRank({ roleId: role.roleId });
@@ -233,6 +191,7 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, mapWarJson: DicWarJ
         let h = defenseHeroes.find(cur => cur.actorId == dbHero.hid); // 阵容里是否有这个武将
         let hs = heroScores.find(cur => cur.hid == dbHero.hid); // 这个武将是否有这个得分
         if (!!h) {
+            let mapWarJson = gameData.warJson.get(warId);
             let warJson = mapWarJson.find(cur => cur.dataId == h.dataId);
             if (warJson && warJson.relation == 2) {
                 let heroInfo = new PvpHeroInfo();
@@ -258,7 +217,7 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, mapWarJson: DicWarJ
     return pvpHistoryOpp;
 }
 
-async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], role: RoleType, pLv: number, dicOpp: DicPvpOpponent) {
+async function matchRobot(oppPlayers: OppPlayer[], role: RoleType, pLv: number, dicOpp: DicPvpOpponent) {
     // console.log('matchRobot', JSON.stringify(oppPlayers))
 
     let { lv: myLv, topLineupCe: myCe, roleId } = role;
@@ -271,23 +230,21 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
     if (!result) return false;
 
     let robotWarjson = gameData.warJson.get(result.war_id);
-    if (!robotWarjson) { /* TODO 判空处理 */ }
-    let heroes = new Array<PvpEnemies>();
+    if (!robotWarjson) return false
+    let heroes: PvpEnemies[] = [];
     let defCe = 0;
-    for (let warJson of mapWarJson) {
-        if (warJson.relation == 1) continue;
-        let h = robotWarjson.find(cur => cur.dataId == warJson.dataId);
-        if (h) {
-            let dicHero = gameData.hero.get(h.actorId);
-            if (!dicHero) continue;
-            let heroInfo = new PvpHeroInfo();
-            heroInfo.setRobotInfo(h, myLv, dicHero.initialStars, dicHero.quality);
-            let { attribute, ce } = getRobotAttribute(h.attribute, h.enemyCount, [], pLv, myCe, PVP_CONST.ENEMY_CE, ratio);
-            defCe += ce;
-            heroInfo.setAttribute(attribute);
-            let enemy = new PvpEnemies(warJson, heroInfo, 0, ce);
-            heroes.push(enemy);
-        }
+    for (let h of robotWarjson) {
+        if (h.relation == 1) continue;
+        let actorId = h.randomEnemy.length > 0? getRandSingleEelm(h.randomEnemy): 0;
+        let dicHero = gameData.hero.get(actorId);
+        if (!dicHero) continue;
+        let heroInfo = new PvpHeroInfo();
+        heroInfo.setRobotInfo(h, actorId, myLv, dicHero.initialStars, dicHero.quality);
+        let { attribute, ce } = getRobotAttribute(h.attribute, h.enemyCount, [], pLv, myCe, PVP_CONST.ENEMY_CE, ratio);
+        defCe += ce;
+        heroInfo.setAttribute(attribute);
+        let enemy = new PvpEnemies(h, heroInfo, 0, ce);
+        heroes.push(enemy);
     }
 
     let oppRoleId = generateRobotRoleId();
@@ -321,7 +278,7 @@ export function getPlusScore(win: number) {
     return result;
 }
 
-export function getLvByScore(heroScores: HeroScores[]) {
+export function getLvByScore(heroScores: HeroScore[]) {
     heroScores.sort((a, b) => b.score - a.score);
     let score = 0;
     for (let i = 0; i < 5; i++) {
@@ -331,71 +288,7 @@ export function getLvByScore(heroScores: HeroScores[]) {
     return getPLvByScore(score);
 }
 
-export async function defaultHeroes(role: RoleType, challengeCnt?: number, challengeRefTime?: number, isUpdate?: boolean) {
-    let pvpDefense = await PvpDefenseModel.findByRoleId(role.roleId);
-    if (!pvpDefense) return;
-    let { heroes, isDefaultHero } = pvpDefense;
-    if (!isUpdate && !isDefaultHero) {
-        return;
-    }
-    let orders = [1, 2, 3, 4, 5, 6];
-    role.topLineup.sort(function (a, b) {
-        return b.ce - a.ce;
-    });
-    heroes.sort(function (a, b) {
-        return b.ce - b.dataId - a.ce + a.dataId;
-    });
-    for (let hero of heroes) {
-        if (!!hero.order && !!hero.hero && findIndex(role.topLineup, { hid: hero.actorId }) != -1) {
-            let index = orders.indexOf(hero.order);
-            orders.splice(index, 1);
-        }
-    }
-    let defCe = 0;
-    let num = 0;
-    for (let i = 0; i < role.topLineup.length; i++) {
-        let item = role.topLineup[i];
-        let index = findIndex(heroes, { actorId: item.hid });
-        if (index == -1) {
-            for (let j = num; j < heroes.length; j++) {
-                let hero = heroes[j];
-                if (num >= 6) {
-                    break;
-                }
-                if (!!findWhere(role.topLineup, { hid: hero.actorId })) {
-                    continue;
-                }
-                if (!orders[0]) {
-                    break;
-                }
-                hero.actorId = item.hid;
-                hero.hero = item.hero;
-                hero.ce = item.ce;
-                hero.order = orders[0];
-                num = j;
-                orders.splice(0, 1);
-                break;
-            }
-        } else {
-            heroes[index].ce = item.ce;
-            heroes[index].hero = item.hero;
-            if (!heroes[index].order) {
-                heroes[index].order = orders[0];
-                orders.splice(0, 1);
-            }
-        }
-        defCe += item.ce;
-    }
-    if (!!challengeCnt && !!challengeRefTime) {
-        let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, challengeCnt, challengeRefTime, isDefaultHero: true });
-        return { resHeroes };
-    } else {
-        let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, isDefaultHero: true });
-        return { resHeroes };
-    }
-}
-
-export function refresh(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
+export function refChallengeCnt(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
     if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
         return { challengeCnt, challengeRefTime };
     }
@@ -422,89 +315,32 @@ export function comsumeChallengeCnt(challengeCnt: number, challengeRefTime: numb
         challengeRefTime = nowSeconds();
         return { challengeCnt, challengeRefTime };
     }
-    return refresh(challengeCnt, challengeRefTime, seasonEndTime);
+    return refChallengeCnt(challengeCnt, challengeRefTime, seasonEndTime);
 }
 
-export async function findPvpDefByRoleId(roleId: string) {
-    let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
-    let { warId, seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
-    if(!pvpDefense) return { pvpDefense, warId }
-    let oldSeasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
-    let { seasonEndTime: oldSeasonEndTime } = await PVPConfigModel.findPVPConfig(oldSeasonNum);
-    if (pvpDefense.seasonNum !== seasonNum && oldSeasonEndTime < nowSeconds()) {
-        let newPvpDefense = await setPvpDefResult(pvpDefense, seasonNum, oldSeasonEndTime);
-        return { pvpDefense: newPvpDefense, warId };
+export async function sendLastSeasonRewardIfNotSent(pvpDefense: PvpDefenseType) {
+    let pvpConfig = await PVPConfigModel.findCurPVPConfig(); // 当前的pvp赛季
+    if(pvpDefense.seasonNum != pvpConfig.seasonNum && pvpConfig.seasonEndTime < nowSeconds()) {
+        let oldPvpCongig = await PVPConfigModel.findPVPConfig(pvpDefense.seasonNum);
+        pvpDefense = await sendPVPRewardToUser(pvpDefense, pvpDefense.seasonNum, oldPvpCongig.seasonEndTime);
     }
-    let { challengeCnt, challengeRefTime } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
-    let { refOppCnt, refOppTime, shouldRefOpp } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime); // 刷新次数
-    if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt) {
-        await PvpDefenseModel.updateInfo(roleId, { challengeCnt, challengeRefTime, refOppCnt });
-        pvpDefense.challengeCnt = challengeCnt;
-        pvpDefense.challengeRefTime = challengeRefTime;
-        pvpDefense.refOppCnt = refOppCnt;
-        pvpDefense.refOppTime = refOppTime;
-    }
-    return { pvpDefense, warId, shouldRefOpp };
+    return pvpDefense;
 }
 
 // 获取刷新对手次数及消耗
-export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
+export function refreshRefOppCnt(refOppCnt: number, refDaily: Date) {
     let curTime = new Date();
-    let shouldRefOpp = shouldRefresh(refOppTime, curTime);
+    let shouldRefOpp = shouldRefresh(refDaily, curTime);
     if (shouldRefOpp) {
-        refOppCnt = 0; refOppTime = curTime;
+        refOppCnt = 0; refDaily = curTime;
     }
     return {
         shouldRefOpp,
-        refOppCnt, refOppTime,
+        refOppCnt, refDaily,
         consume: gameData.pvpRefreshConsume.get(refOppCnt + 1)
     }
 }
 
-/**
- * 获得玩家pvp信息，并检查是否在pvp赛季结算中结算过，未结算的进行结算
- * @param roleId 
- */
-export async function findPvpDefAllByRoleId(roleId: string) {
-    let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
-    let { warId, seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
-    if(!pvpDefense) return { pvpDefense, warId }
-    let oldSeasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
-    let { seasonEndTime: oldSeasonEndTime } = await PVPConfigModel.findPVPConfig(oldSeasonNum);
-
-    if (pvpDefense.seasonNum != seasonNum && oldSeasonEndTime < nowSeconds()) {//检查玩家是否在pvp赛季结算中结算过
-        let { score, pLv, winStreakNum, heroScores, challengeCnt, challengeRefTime } = await pinus.app.rpc.systimer.systimerRemote.setPvpDefResult.toServer('systimer-server-1', pvpDefense, seasonNum, oldSeasonEndTime);
-        pvpDefense.score = score;
-        pvpDefense.pLv = pLv;
-        pvpDefense.winStreakNum = winStreakNum;
-        pvpDefense.heroScores = heroScores;
-        pvpDefense.challengeCnt = challengeCnt;
-        pvpDefense.challengeRefTime = challengeRefTime;
-    }
-    pvpDefense.seasonNum = seasonNum;
-    let { challengeCnt, challengeRefTime } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
-    let { refOppCnt, refOppTime, shouldRefOpp } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime); // 刷新次数
-    if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt || shouldRefOpp) {
-        let update: pvpUpdateInter = {
-            challengeCnt, challengeRefTime, refOppCnt, refOppTime
-        };
-
-        if (shouldRefOpp) {
-            let role = <RoleType>pvpDefense.role;
-            let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv);
-            update.oppPlayers = oppPlayers;
-        }
-
-        let updateResult = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
-        pvpDefense.oppPlayers = updateResult.oppPlayers;
-        pvpDefense.challengeCnt = challengeCnt;
-        pvpDefense.challengeRefTime = challengeRefTime;
-        pvpDefense.refOppCnt = refOppCnt;
-        pvpDefense.refOppTime = refOppTime;
-    }
-
-    return { pvpDefense, warId, shouldRefOpp, seasonEndTime, oldSeasonEndTime };
-}
 
 /**
  * 根据比例计算机器人属性
@@ -561,7 +397,7 @@ export function getPlayerMainAttribute(heroAttrs: CeAttrData[], roleAttrs: CeAtt
 }
 
 // 获取我方战报记录
-export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: number, role: RoleType, isSuccess: boolean, pos: number, myHeroes: pvpEndParamInter[]) {
+export async function generMyRecInfo(heroScores: HeroScore[], winStreakNum: number, role: RoleType, isSuccess: boolean, pos: number, myHeroes: pvpEndParamInter[]) {
 
     let { roleId, roleName } = role;
 
@@ -618,7 +454,7 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
 }
 
 // 获取对手战报记录
-export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayers, oppHeroes: pvpEndParamInter[], myLv: number) {
+export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayer, oppHeroes: pvpEndParamInter[], myLv: number) {
     let oppHeroRecords = new Array<HeroesRecord>();
     let oppRole = <PvpHistoryOppType>curOpp.oppDef;
     if (!oppRole) { console.error('opp role not found') }
@@ -643,3 +479,102 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayers,
         score: 0
     }
 }
+
+/**
+ * pvp定时任务赛季结算
+ * @param obj 
+ */
+ export async function pvpSeasonEnd(pvpConfig: PVPConfigType) {
+    const pageNum = 500;
+    console.log('exce pvpSeasonEnd' + pvpConfig?.seasonNum);
+    let systemConfig = await PVPConfigModel.findCurPVPConfig();
+    let resultMaxRank = gameData.pvpRankMax.max;//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入pvp时结算
+    let maxPage = (resultMaxRank.min + 1000) / pageNum; //保底结算玩家数量
+    let lastPageNum = resultMaxRank.min % pageNum;
+    for (let page = 0; page < maxPage + 1; page++) {
+        let pvpDefenses = await PvpDefenseModel.getPvpDef(pageNum, page == maxPage ? lastPageNum : page);
+        for (let pvpDefense of pvpDefenses) {
+            if (pvpDefense.seasonNum !== systemConfig.seasonNum) {
+                await sendPVPRewardToUser(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime);
+            }
+        }
+    }
+    await PVPConfigModel.setReward(pvpConfig.seasonNum);
+}
+
+/**
+ * pvp定时任务结算获得添加邮件信息
+ * @param pvpDefense 
+ * @param seasonNum 
+ * @param oldSeasonEndTime 
+ */
+export async function sendPVPRewardToUser(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime: number, notPush?: boolean) {
+    //检查并返回排名结算以及武将功勋结算
+    let pvpSeasonResult = await savePvpSeasonResult(pvpDefense, seasonNum, seasonEndTime);
+    let { rankGoods, heroGoods, rankLv } = pvpSeasonResult;
+    //下发邮件
+    if (!!rankGoods.length) //排名奖励
+        await sendMailByContent(MAIL_TYPE.PVP_RANK_REWARD, pvpDefense.roleId, {
+            params: [JSON.stringify(seasonNum), (rankLv > 1000 ? '999+' : JSON.stringify(rankLv))],
+            goods: rankGoods, endTime: seasonEndTime, notPush
+        });
+    if (!!heroGoods.length) //武将功勋奖励
+        await sendMailByContent(MAIL_TYPE.PVP_RESULT, pvpDefense.roleId, {
+            params: [JSON.stringify(seasonNum)],
+            goods: heroGoods, endTime: seasonEndTime, notPush
+        });
+
+    pvpDefense = await PvpDefenseModel.resetScores(pvpDefense.roleId, seasonNum + 1, pvpSeasonResult.newScore, pvpSeasonResult.newHeroScores);
+    return pvpDefense;
+}
+
+/**
+ * 检查并返回排名结算以及武将功勋结算
+ * @param pvpDefense 
+ * @param seasonNum 
+ * @param oldSeasonEndTime 
+ * @param rankLv 
+ */
+export async function savePvpSeasonResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime: number, rankLv?: number) {
+    if (!rankLv) {
+        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        rankLv = await r.getMyRank({ roleId: pvpDefense.roleId });// 获得排行榜排名
+    }
+    let pvpRankReward: DicRankRewads = getPvpRankRewardsByRank(rankLv);
+    let rankGoods: RewardInter[] = [];
+    if (pvpRankReward) {
+        rankGoods = pvpRankReward.reward;//排名奖励
+    }
+    let heroGoods: HeroReward[]  = [];
+    let newHeroScores: HeroScore[] = [], newScore = 0;
+    for (let heroScore of pvpDefense.heroScores) {
+        let pvpHeroReward = getPvpHeroRewardsByScore(heroScore.score); //获得武将功勋奖励
+        if (pvpHeroReward) {
+            newHeroScores.push({...heroScore, score: pvpHeroReward.heroscore });
+            for(let { id, count } of pvpHeroReward.reward) {
+                heroGoods.push({
+                    hid: heroScore.hid, id, count
+                });
+            }
+        }
+        newScore += heroScore.score;
+    }
+
+    //pvp锁定的信息存入赛季结算表中
+    let pvpSeasonResult = await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, seasonNum, {
+        ...pvpDefense, rankLv, heroGoods, rankGoods, show: true, newScore, newHeroScores, seasonEndTime
+    });//结算修改玩家pvp信息
+
+    // 更新任务
+    await checkTask(pvpDefense.roleId, null, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores: pvpDefense.heroScores });
+    await checkTask(pvpDefense.roleId, null, TASK_TYPE.PVP_RANK, 1, false, { rankLv });
+    return pvpSeasonResult;
+}
+
+function getScore(arr, score) {
+    for (let item of arr) {
+        if ((item.max >= score || item.max == -1) && score >= item.min) {
+            return item;
+        }
+    }
+}