pvp: 更改pvpdefense结构

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

@@ -2,11 +2,11 @@
 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { uniq, findWhere, findIndex } from 'underscore';
 import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
-import { refreshEnemies, getEnemies, getLvByScore, defaultHeroes, comsumeChallengeCnt, refresh, findPvpDefByRoleId, getRefOppCnt, findPvpDefAllByRoleId, generPVPOppRecInfo, generMyRecInfo, initPvpInfo } from '../../../services/pvpService';
+import { refreshEnemies, getEnemies, getLvByScore, comsumeChallengeCnt, refChallengeCnt, generPVPOppRecInfo, generMyRecInfo, sendLastSeasonRewardIfNotSent, refreshRefOppCnt } from '../../../services/pvpService';
 import { RoleModel, RoleType } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult, genCode, checkRoleIsRobot, robotIdComBack } from '../../../pubUtils/util';
-import { PvpDefenseModel, OppPlayers } from '../../../db/PvpDefense';
+import { PvpDefenseModel, pvpUpdateInter } from '../../../db/PvpDefense';
 import { pvpEndParamInter } from '../../../pubUtils/interface';
 import { PlayerDetail, PlayerDetailHero } from '../../../domain/battleField/guild';
 import { PVP_HERO_POS, PVP_HERO_ORDER, REDIS_KEY, LINEUP_NUM, TASK_TYPE, COUNTER } from '../../../consts';
@@ -18,12 +18,12 @@ import { BattleRecordModel } from '../../../db/BattleRecord';
 import { PvpRecordModel } from '../../../db/PvpRecord';
 import { handleCost } from '../../../services/rewardService';
 import { nowSeconds, getSeconds } from '../../../pubUtils/timeUtil';
-import { pvpSeasonEnd, resetPvpWarId, createNextPvpSeason } from '../../../services/timeTaskService';
 import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
 import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
 import { PVPConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
 import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
+import { PvpDataReturn } from '../../../domain/battleField/pvp';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -37,48 +37,62 @@ export class PvpHandler {
     //1获取主界面
     async getData(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
-        let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
+ 
+        let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
         if(!pvpDefense) {
             let role = await RoleModel.findByRoleId(roleId);
-            pvpDefense = await initPvpInfo(role);
+            pvpDefense = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id });
         }
-        let oppPlayers = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
-        let { isDefaultHero, heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, seasonNum } = pvpDefense;
-        if (isFirstEntry) {
-            await PvpDefenseModel.updateInfo(roleId, { isFirstEntry: false });
+        pvpDefense = await sendLastSeasonRewardIfNotSent(pvpDefense);
+        let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+
+        
+        let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        let refOppObj = refreshRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refDaily);
+
+        let update: pvpUpdateInter = { ...refChallengeObj, ...refOppObj};
+        
+        let result = new PvpDataReturn(pvpDefense); // 返回对象
+        
+        if(refOppObj.shouldRefOpp) {
+            let role = <RoleType>pvpDefense.role;
+            let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.pLv);
+            update.oppPlayers = oppPlayers;
+            let oppPlayersReturn = await getEnemies(oppPlayers||[], pvpDefense.winStreakNum);
+            result.setOppPlayers(oppPlayersReturn);
+        } else {
+            let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers||[], pvpDefense.winStreakNum);
+            result.setOppPlayers(oppPlayersReturn);
         }
-        let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId);
-        let flag = false;
-        if (!!pvpSeasonResult) {
-            var { oldSeasonData, show, heroGoods, rankGoods } = pvpSeasonResult;
-            if (oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
-                seasonEndTime = oldSeasonData.seasonEndTime;
-                heroScores = oldSeasonData.heroScores;
-                score = oldSeasonData.score;
-                refOppCnt = oldSeasonData.refOppCnt;
-                challengeCnt = oldSeasonData.challengeCnt;
-                challengeRefTime = oldSeasonData.challengeRefTime;
-            } else if (show) {//是否需要弹出结算奖励界面
-                await PvpSeasonResultModel.updatePvpSeasonResult(roleId, { show: false });
-                flag = true;
-            }
+
+        let { score, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry } = pvpDefense;
+        if (pvpDefense.isFirstEntry) {
+            update.isFirstEntry = false;
+        }
+        let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId, pvpDefense.seasonNum);
+
+        result.setPvpConfig(seasonNum, seasonEndTime);
+        
+        if (!!pvpSeasonResult && !!pvpSeasonResult.show) {
+            result.setPvpSeasonResult(pvpSeasonResult);
+            await PvpSeasonResultModel.updatePvpSeasonResult(roleId, pvpSeasonResult.seasonNum, { show: false });
         }
 
         let r = new Rank(REDIS_KEY.PVP_RANK, {});
         let myRank = await r.getMyRank({ roleId });//去redis中获取排名
+        result.setMyRank(myRank);
 
-        let data: any = {
-            warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
-                let { actorId, dataId, order } = cur;
-                return { actorId, dataId, order }
-            }), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero
-        }
-        if (flag) {//弹出结赛季结算奖励
-            data.resultRecord = { oldSeasonData, heroGoods, rankGoods }
-        }
-        return resResult(STATUS.SUCCESS, data);
+        // let data: any = {
+        //     warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
+        //         let { actorId, dataId, order } = cur;
+        //         return { actorId, dataId, order }
+        //     }), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero
+        // }
+
+        return resResult(STATUS.SUCCESS, result);
     }
 
+    /*
     // 刷新对手
     async refreshOppPlayer(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
@@ -140,7 +154,7 @@ export class PvpHandler {
         if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 检查挑战次数
         let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
-        let { challengeCnt, challengeRefTime } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        let { challengeCnt, challengeRefTime } = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         if (challengeCnt == 0) {
             return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
         }
@@ -273,7 +287,7 @@ export class PvpHandler {
         let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
         let { heroes: defHeros, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
         let defCe = 0;
-        let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
+        let { challengeCnt, challengeRefTime } = refChallengeCnt(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
 
         if (!!isDefaultHero) {
             let { topLineup } = await RoleModel.findByRoleId(roleId);
@@ -430,7 +444,7 @@ export class PvpHandler {
             return resResult(STATUS.PVP_BOX_IS_GOT);
         }
         receivedBox.push(id);
-        let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
+        let { challengeCnt, challengeRefTime } = refChallengeCnt(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
         await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
         let result = await addItems(roleId, roleName, sid, pvpBox.reward);
         // 任务
@@ -514,4 +528,6 @@ export class PvpHandler {
         let { challengeRefTime } = await PvpDefenseModel.updateInfoAndInclude(roleId, { challengeCnt, challengeRefTime: nowSeconds(), refOppCnt: 0 });
         return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
     }
+
+    */
 }

game-server/app/servers/systimer/remote/systimerRemote.ts

@@ -1,5 +1,5 @@
 import { Application, ChannelService } from 'pinus';
-import { resetPvpSeasonTime, setPvpDefResult, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule } from '../../../services/timeTaskService';
+import { resetPvpSeasonTime, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule } from '../../../services/timeTaskService';
 import PvpDefenseType from '../../../db/PvpDefense';
 import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
 import { reloadResources } from '../../../pubUtils/data';
@@ -23,10 +23,6 @@ export class SystimerRemote {
         return await resetPvpSeasonTime(day);
     }
 
-    public async setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
-        return await setPvpDefResult(pvpDefense, seasonNum, seasonEndTime);
-    }
-
     public async guildActivityStart(dicGuildActivity: DicGuildActivity) {
         return await guildActivityStart(dicGuildActivity);
     }

game-server/app/services/connectorService.ts

@@ -35,7 +35,6 @@ import { setMedianCe, getAllGuildActivityStatus } from './guildActivityService';
 import { getAllOnlineRoles } from './redisService';
 import Item from '../db/Item';
 import { PvpDefenseModel } from '../db/PvpDefense';
-import { findPvpDefAllByRoleId } from './pvpService';
 import { getDonation } from './donateService';
 
 export async function pushData(role: RoleType, session: FrontendOrBackendSession, pushType: 'entry' | 'refresh' = 'entry') {
@@ -189,10 +188,10 @@ async function getTowerEntryData(role: RoleType) {
 async function getPvpEntryData(roleId: string) {
     let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
     if (pvpDefense) {
-        let { pvpDefense, } = await findPvpDefAllByRoleId(roleId);
-        let { challengeCnt, receivedBox, score, hisScore } = pvpDefense;
+        // let { pvpDefense, } = await findPvpDefAllByRoleId(roleId);
+        // let { challengeCnt, receivedBox, score, hisScore } = pvpDefense;
 
-        return { challengeCnt, score, hisScore, receivedBox }
+        // return { challengeCnt, score, hisScore, receivedBox }
     } else {
         return null
     }

game-server/app/services/expeditionService.ts

@@ -1,17 +1,14 @@
 
 import { ExpeditionPointModel } from '../db/ExpeditionPoint';
-import Role, { RoleModel, RoleType } from '../db/Role';
-import { PvpDefenseModel } from '../db/PvpDefense';
-
+import Role, { CeAttrDataRole, RoleModel } from '../db/Role';
 import { shouldRefresh, calculateSumCE, getRandSingleEelm } from '../pubUtils/util';
-import { LINEUP_NUM, EXPEDITION_WAR_RECORD_STATUS, ABI_TYPE } from '../consts';
+import { LINEUP_NUM, EXPEDITION_WAR_RECORD_STATUS } from '../consts';
 import { ExpeditionWarRecordModel } from '../db/ExpeditionWarRecord';
-import { HeroType } from '../db/Hero';
+import { CeAttrData, HeroType } from '../db/Hero';
 import { gameData } from '../pubUtils/data';
-import { getPlayerAttribute, getRobotAttribute } from './pvpService';
 import { getTimeFunD } from '../pubUtils/timeUtil';
 import { ExpeditionRecordModel } from '../db/ExpeditionRecord';
-import { Attribute } from '../domain/roleField/attribute';
+import { Attribute, AttributeCal } from '../domain/roleField/attribute';
 import * as dicParam from '../pubUtils/dicParam';
 
 /**
@@ -80,7 +77,7 @@ export async function findOrCreateEnemies(roleId: string, myCe: number, expediti
             };
 
             // 获取系数和步长
-            let {scale, range, lv} = await getCEScaleAndRange(roleId, curDicExpedition);
+            let { scale, range, lv } = await getCEScaleAndRange(roleId, curDicExpedition);
             // 优先匹配其他玩家
             let flag = await matchPlayers(roleId, scale, range, myCe, curDicExpedition.json, enemyObj);
             // 当数量不够时使用机器人匹配
@@ -133,30 +130,30 @@ export async function matchPlayers(roleId: string, scale: number, range: number,
     let min = myCe * scale * (1 - range/100);
     let max = myCe * scale * (1 + range/100);
 
-    let resultRange = await PvpDefenseModel.findByScale(roleId, min, max);
+    let resultRange = await RoleModel.findByCeScale(min, max);
+    resultRange = resultRange.filter(cur => cur.roleId != roleId);
     if(resultRange.length > 0) {
         let index = Math.floor(Math.random() * resultRange.length);
-        let result = resultRange[index];
-        let {roleId, heroes, defCe } = result;
-        let role = <RoleType>result.role;
+        let role = resultRange[index];
+        let {roleId, topLineup, topLineupCe } = role;
         let { attr: roleAttrs } = role;
 
         enemyObj.enemyFrom = 1;
         enemyObj.enemyId = roleId;
-        enemyObj.ce = defCe;
+        enemyObj.ce = topLineupCe;
         
         let heroIndex = 0;
         for(let json of dicWarJson) {
             if(json.relation == 2) {
-                let hero = heroes[heroIndex];
+                let hero = topLineup[heroIndex];
                 if(hero) {
                     let h = <HeroType>hero.hero;
                     if(h) {
                         let { star, lv, attr: heroAttrs, ce } = h;
-                        let dicHero = gameData.hero.get(hero.actorId);
+                        let dicHero = gameData.hero.get(hero.hid);
                         let { attribute } = getPlayerAttribute(lv, heroAttrs, roleAttrs);
                         let heroInfo = { 
-                            actorId: hero.actorId,
+                            actorId: hero.hid,
                             skinId: h.skinId,
                             actorName: dicHero.name, 
                             skill:0, 
@@ -269,4 +266,46 @@ export async function getResetRemainCnt(curTime: Date, roleId: string, role?: Ro
         resetCnt: maxCnt - expeditionResetCnt,
         needRefresh
     };
+}
+
+/**
+ * 根据比例计算机器人属性
+ * @param attribute 出兵表中的属性字段
+ * @param ce 我的战力
+ * @param enemyCe 出兵表对手战力
+ * @param ratio 系数
+ */
+ export function getRobotAttribute(mainAttrs: { id: number, val: number }[], enemyCount: number, subAttrs: {id: number, val: number}[], lv: number, ce: number, enemyCe: number, ratio: number) {
+
+    let newAttribute = new AttributeCal();
+    newAttribute.setLv(lv);
+    newAttribute.setByWarJson(subAttrs); // 次级属性
+    let subAttrCe = newAttribute.calSubAttrCeAndReduce() * enemyCount;
+    if(ce * ratio > subAttrCe) {
+        let mainAttrCe = ce * ratio - subAttrCe;
+        newAttribute.setByWarJson(mainAttrs, mainAttrCe / enemyCe);
+        let attrArr = newAttribute.getReduceAttributesToString();
+        let newCe = newAttribute.calCelAndReduce();
+        return { attribute: attrArr, ce: newCe };
+    } else {
+        newAttribute = new AttributeCal();
+        newAttribute.setByWarJson(mainAttrs, ce * ratio / enemyCe);
+        let attrArr = newAttribute.getReduceAttributesToString();
+        let newCe = newAttribute.calCelAndReduce();
+        return { attribute: attrArr, ce: newCe };
+    }
+}
+
+/**
+ * @description 根据玩家数据获取到他的属性
+ * @param ceAttr hero表的ceAttr
+ * @param globalCeAttr role表中的globalCeAttr
+ */
+export function getPlayerAttribute(lv: number, heroAttrs: CeAttrData[] = [], roleAttrs: CeAttrDataRole[] = []) {
+    let newAttribute = new AttributeCal();
+    newAttribute.setLv(lv);
+    newAttribute.setByDbData(roleAttrs, heroAttrs);
+    let attribute = newAttribute.getReduceAttributesToString();
+    let ce = newAttribute.calCelAndReduce();
+    return { attribute, ce };
 }

game-server/app/services/guildService.ts

@@ -316,7 +316,6 @@ export async function settleGuildWeekly() {
     await initSingleRank(REDIS_KEY.GUILD_ACTIVE_RANK);
     await initSingleRank(REDIS_KEY.GUILD_LV_RANK);
     let curSeasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
-    await PVPConfigModel.updatePVPConfig(curSeasonNum, { settleGuildWeeklyTime: nowSeconds() }); // 记录一下,不知道原作者有什么用处...
     console.log('————— settleGuildWeekly结束 —————');
 }
 

game-server/app/services/playerCeService.ts

@@ -8,7 +8,6 @@ import { STATUS } from '../consts/statusCode';
 import { resResult, reduceCe } from '../pubUtils/util';
 import { calPlayerCeAndSave as pubCalPlayerCeAndSave,  reCalAllHeroCe } from '../pubUtils/playerCe';
 import { HeroType, HeroUpdate } from '../db/Hero';
-import { defaultHeroes } from './pvpService'; 
 
 import { RoleUpdate, RoleType } from '../db/Role';
 import { Rank } from './rankService';
@@ -39,7 +38,6 @@ export async function pushCalPlayerCe(roleId: string, sid: string, calResult: ca
     //下发战力
     let uids = [{ uid: roleId, sid }];
     pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: reduceCe(role.ce) , heros: pushHeros, topLineupCe:  reduceCe(topLineupCe) }), uids);
-    defaultHeroes(role);
     if(guild) {
         await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]);
     }

game-server/app/services/playerEventService.ts

@@ -1,5 +1,4 @@
 
-import { findPvpDefByRoleId } from '../services/pvpService' 
 import { getFuncsSwitch, gameData } from '../pubUtils/data';
 import { FUNCS_ID, FUNC_OPT_TYPE } from '../consts/constModules/sysConst';
 import { RoleModel } from '../db/Role';
@@ -22,8 +21,4 @@ export async function eventOnPlayerLvUp(roleId: string, lv: number, addFuncs: Ar
         }
     }
 
-}
-
-export async function loginRefresh(roleId: string) {
-    await findPvpDefByRoleId(roleId);
 }

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;
+        }
+    }
+}

game-server/app/services/redisService.ts

@@ -34,6 +34,10 @@ export async function initAllRank() {
     await delKeys(REDIS_KEY.MAIN_ELITE_RANK);
     await delKeys(REDIS_KEY.HERO_RANK);
     await delKeys(REDIS_KEY.SHOW_LINEUP);
+    await delKeys(REDIS_KEY.PVP_RANK);
+
+    await setRankRedisFromDb(REDIS_KEY.PVP_RANK, {});
+
     for(let {id} of serverList) {
         await initRank(id);
     }

game-server/app/services/timeTaskService.ts

@@ -1,14 +1,11 @@
 
 import { scheduleJob, Job, } from 'node-schedule';
-import { PVPConfigModel } from '../db/SystemConfig';
-import PvpDefenseType, { PvpDefenseModel } from '../db/PvpDefense';
-import { PVP, SERVER_DEBUG_MODE } from '../pubUtils/dicParam';
-import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
-import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity, gameData } from '../pubUtils/data';
-import { deepCopy, getRandSingleEelm } from '../pubUtils/util';
-import { getLvByScore } from './pvpService';
-import { getAllOnlineRoles, getAllServers, initSingleRank, delGuildActivityRank } from './redisService';
-import { MAIL_TYPE, REDIS_KEY, GUILD_ACTIVITY_STATUS, GUILD_ACTIVITY_TYPE, TASK_TYPE, TIME_OUTPUT_TYPE, REFRESH_TIME, SEND_NAME, SERVER_OPEN_TIME, COUNTER, AUCTION_TIME } from '../consts';
+import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig';
+import { nowSeconds, getTimeFun, getZeroPoint } from '../pubUtils/timeUtil';
+import { getTodayGuildActivity, gameData } from '../pubUtils/data';
+import { pvpSeasonEnd } from './pvpService';
+import { getAllOnlineRoles, getAllServers, delGuildActivityRank } from './redisService';
+import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, SEND_NAME, SERVER_OPEN_TIME, COUNTER, AUCTION_TIME } from '../consts';
 import { RoleModel } from '../db/Role';
 import { pinus } from 'pinus';
 import { indexOf } from 'underscore';
@@ -29,8 +26,7 @@ import { reportOneOnline } from './authenticateService';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
-const SETTLE_DIFF = 29 * 60;
-const pageNum = 500;
+const SETTLE_DIFF_SECONDS = 29 * 60;
 const PER_MINUTE = 1 * 60;
 var seasonMakeRewardTimJobId: Job;
 var warJobId: Job;
@@ -46,22 +42,9 @@ let pvpRefreshInterval = null;
  * 服务器启动即开启定时任务，结算时常是23-24点，实际结算的时间点是23：31分钟
  */
 export async function init() {
-    let systemConfig = await PVPConfigModel.findCurPVPConfig();
 
-    let seasonEndTime = systemConfig ? systemConfig.seasonEndTime : <number>getTimeFun(moment(SERVER_OPEN_TIME).startOf('d').add(-1, 'minute').toDate()).getAfterDay(PVP.PVP_SEASON_DAYS);
-    if (nowSeconds() > seasonEndTime) {//停服太长，数据配置问题导致数据太老，需要刷新赛季数据
-        while (nowSeconds() > seasonEndTime) {
-            seasonEndTime = <number>getTimeFun(seasonEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
-        }
-    }
-    if (!systemConfig || seasonEndTime != systemConfig.seasonEndTime) {
-        systemConfig = await createNewPvpSeasonData(seasonEndTime)
-    }
-
-    await resetPVPTimer(seasonEndTime);
-
-    warJobId = scheduleJob("0 0 0 * * 1", resetPvpWarId);//每周1零点重置地图
-    await resetPvpRanks();//服务器重启，重置排行榜的信息
+    // pvp赛季
+    await setPvpSeason();
 
     // 周功勋结算任务
     guildWeeklyJobId = scheduleJob('settleGuildWeekly', '0 0 0 * * 1', settleGuildWeekly);
@@ -86,248 +69,67 @@ export async function init() {
     await initMaintenance();
 }
 
-async function resetPVPTimer(seasonEndTime: number) {
+function getSeasonContinueDay(seasonNum: number) {
+    const pvpSeasonDuring = [{seasonNum: 1, day: 7},{seasonNum: 2, day: 15},{seasonNum: 3, day: 30},];
+
+    let maxDay = 0;
+    for(let {seasonNum: dicSeasonNum, day } of pvpSeasonDuring) {
+        if(seasonNum == dicSeasonNum) return day;
+        if(maxDay < day) maxDay = day;
+    }
+    return maxDay;
+}
+
+async function setPvpSeason() {
+    let pvpConfig = await PVPConfigModel.findCurPVPConfig();
+    if(!pvpConfig || pvpConfig.seasonEndTime <= nowSeconds() ) {
+        if(!pvpConfig.hasSettleReward) {
+            await pvpSeasonEnd(pvpConfig);
+        }
+
+        let lastSeasonNum = pvpConfig? pvpConfig.seasonNum: 0;
+        let lastSeasonEndTime = pvpConfig? pvpConfig.seasonEndTime: 0;
+
+        let newSeasonStartTime = lastSeasonEndTime;
+        let during = getSeasonContinueDay(lastSeasonNum + 1) * PER_DAY;
+        let rewardTime = SETTLE_DIFF_SECONDS;
+        if(nowSeconds() - lastSeasonEndTime > during) {
+            newSeasonStartTime = getZeroPoint();
+        }
+        pvpConfig = await PVPConfigModel.createPVPConfig(lastSeasonNum + 1, newSeasonStartTime, newSeasonStartTime + during - rewardTime, newSeasonStartTime + during - PER_MINUTE);
+    }
+    await setPvpSeasonMakeRewardJob(pvpConfig);
+    await setNextSeasonJob(pvpConfig);
+}
+
+async function setPvpSeasonMakeRewardJob(pvpConfig: PVPConfigType) {
     if (!!seasonMakeRewardTimJobId) {
         seasonMakeRewardTimJobId.cancel();
-        clearInterval(pvpMakeRewardInterval);
     }
+    if(pvpConfig.seasonRewardTime < nowSeconds() && !pvpConfig.hasSettleReward) { // 未发奖励
+        await pvpSeasonEnd(pvpConfig);
+    } else {
+        seasonMakeRewardTimJobId = scheduleJob('seasonMakeRewardTimJobId', pvpConfig.seasonRewardTime, async () => {
+            await pvpSeasonEnd(pvpConfig);
+        });
+    }
+}
+
+async function setNextSeasonJob(pvpConfig: PVPConfigType) {
     if (!!seasonRefreshTimeJobId) {
         seasonRefreshTimeJobId.cancel();
-        clearInterval(pvpRefreshInterval);
     }
-    if (seasonEndTime - SETTLE_DIFF - nowSeconds() < 0) {//23：30-24：00之间,已经过了结算时间，还未开启新赛季
-        console.log('立刻结算奖励:', nowSeconds());
-        await pvpSeasonEnd();
-        //定时结算奖励
-        seasonMakeRewardTimJobId = scheduleJob('seasonMakeRewardTimJobId', (seasonEndTime - SETTLE_DIFF - nowSeconds()) * PER_SECOND + PVP.PVP_SEASON_DAYS * PER_DAY * PER_SECOND, pvpMakeRewardTimer);//
-    } else {
-        //定时结算奖励
-        seasonMakeRewardTimJobId = scheduleJob('seasonMakeRewardTimJobId', (seasonEndTime - SETTLE_DIFF - nowSeconds()) * PER_SECOND, pvpMakeRewardTimer);//
-    };
-    //定时开启新赛季
-    seasonRefreshTimeJobId = scheduleJob('seasonRefreshTimeJobId', (seasonEndTime - nowSeconds()) * PER_SECOND, pvpRefreshTimer);//
+    //定时开启新赛季，比seasonEndTime多定一分钟，保证定时器时间没错
+    seasonRefreshTimeJobId = scheduleJob('seasonRefreshTimeJobId', pvpConfig.seasonEndTime + PER_MINUTE, setPvpSeason);
 }
 
-//pvp结算奖励定时器
-async function pvpMakeRewardTimer() {
-    pvpMakeRewardInterval = setInterval(async () => {
-        console.log('定时结算奖励:', nowSeconds());
-        await pvpSeasonEnd()
-    }, PVP.PVP_SEASON_DAYS * PER_DAY * PER_SECOND)
-}
-
-//pvp刷新开始新赛季定时器
-async function pvpRefreshTimer() {
-    pvpRefreshInterval = setInterval(async () => {
-        console.log('定时开启新赛季:', nowSeconds());
-        await createNextPvpSeason();
-    }, PVP.PVP_SEASON_DAYS * PER_DAY * PER_SECOND)
-}
-
-//创建下个新赛季
-export async function createNextPvpSeason() {
-    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-    let seasonEndTime = systemConfig ? systemConfig.seasonEndTime : <number>getTimeFun(moment(SERVER_OPEN_TIME).startOf('d').add(-1, 'minute').toDate()).getAfterDay(PVP.PVP_SEASON_DAYS);
-    if (nowSeconds() > seasonEndTime) {//停服太长，数据配置问题导致数据太老，需要刷新赛季数据
-        while (nowSeconds() > seasonEndTime) {
-            seasonEndTime = <number>getTimeFun(seasonEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
-        }
-    }
-    systemConfig = await createNewPvpSeasonData(seasonEndTime)
-    await resetPvpRanks()
-    return systemConfig;
-}
-
-/**
- * pvp定时任务赛季结算
- * @param obj 
- */
-export async function pvpSeasonEnd(obj?: { name: string, notSetNext?: boolean, notPush?: boolean }) {
-    console.log('exce pvpSeasonEnd' + obj?.name);
-    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-    let resultMaxRank = getResultMaxRank();//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入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 setPvpDefResultOnTime(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime, obj?.notPush);
-            }
-        }
-    }
-}
-/**
- * pvp定时任务结算获得添加邮件信息
- * @param pvpDefense 
- * @param seasonNum 
- * @param oldSeasonEndTime 
- */
-export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, notPush?: boolean) {
-    //检查并返回排名结算以及武将功勋结算
-    let { score, pLv, heroScores, challengeCnt, challengeRefTime, rankGoods, heroGoods, rankLv } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime);
-    pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, { score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime });
-    //下发邮件
-    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: oldSeasonEndTime, notPush
-        });
-    if (!!heroGoods.length) //武将功勋奖励
-        await sendMailByContent(MAIL_TYPE.PVP_RESULT, pvpDefense.roleId, {
-            params: [JSON.stringify(seasonNum)],
-            goods: heroGoods, endTime: oldSeasonEndTime, notPush
-        });
-    return pvpDefense;
-}
-/**
- * 检查并返回排名结算以及武将功勋结算
- * @param pvpDefense 
- * @param seasonNum 
- * @param oldSeasonEndTime 
- * @param rankLv 
- */
-export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, rankLv?: number) {
-    let pvpRankRewards = getPvpRankRewards();
-    let pvpHeroRewards = getPvpHeroRewards();
-    if (!rankLv) {
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
-        rankLv = await r.getMyRank({ roleId: pvpDefense.roleId });// 获得排行榜排名
-    }
-    let oldPLv = getLvByScore(pvpDefense.heroScores);//结算前玩家的pvp等级
-    let { challengeCnt, challengeRefTime } = pvpDefense;
-    let pvpRankReward;
-    if (!!rankLv) {
-        pvpRankReward = getScore(pvpRankRewards, rankLv);//获得排名挡位信息
-    } else {
-        pvpRankReward = getResultMaxRank();//最大排名等级挡位信息
-    }
-    let rankGoods = [];
-    if (pvpRankReward) {
-        rankGoods = pvpRankReward.reward;//排名奖励
-    }
-    let heroGoods = [];
-    let score = 0;
-    let oldHeroScores = deepCopy(pvpDefense.heroScores)
-    for (let i = 0; i < pvpDefense.heroScores.length; i++) {
-        let heroScore = pvpDefense.heroScores[i];
-        let pvpHeroReward = getScore(pvpHeroRewards, heroScore.score);//获得武将功勋奖励
-        if (pvpHeroReward) {
-            heroScore.score = pvpHeroReward.heroscore;
-            if (!!pvpHeroReward.reward[0]) {
-                heroGoods.push({
-                    hid: heroScore.hid,
-                    id: pvpHeroReward.reward[0].id,
-                    count: pvpHeroReward.reward[0].count,
-                });
-            }
-        }
-        score += heroScore.score;
-    }
-    let pLv = getLvByScore(pvpDefense.heroScores);
-    //pvp锁定的信息存入赛季结算表中
-    await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, {
-        oldSeasonData: {
-            refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores,
-            seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime
-        }, heroGoods, rankGoods, show: true
-    });//结算修改玩家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 {
-        rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, oldSeasonEndTime, heroGoods: heroGoods.map(({ id, count }) => {
-            return { id, count };
-        }), rankGoods
-    };
-}
-/**
- * 个人pvp结算，结算中未结算的，都按照最大排名挡位结算
- * @param pvpDefense 
- * @param seasonNum 
- * @param oldSeasonEndTime 
- */
-export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number) {
-    let role = await RoleModel.findByRoleId(pvpDefense.roleId);
-    if (!role) {
-        return;
-    }
-    let resultMaxRank = getResultMaxRank();
-    let rankLv = resultMaxRank.min;   //最大排名挡位结算
-    let { score, pLv, heroScores, challengeCnt, challengeRefTime, rankGoods, heroGoods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv);
-    pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, { score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime });
-    let { roleId } = role;
-    let r = new Rank(REDIS_KEY.PVP_RANK, {});
-    r.setRankWithRoleInfo(pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role, true);
-    //下发邮件
-    if (!!rankGoods.length)
-        await sendMailByContent(MAIL_TYPE.PVP_RANK_REWARD, roleId, { params: [JSON.stringify(seasonNum), '999+'], goods: rankGoods, endTime: oldSeasonEndTime });
-    if (!!heroGoods.length)
-        await sendMailByContent(MAIL_TYPE.PVP_RESULT, roleId, { params: [JSON.stringify(seasonNum)], goods: heroGoods, endTime: oldSeasonEndTime });
-    return pvpDefense;
-}
-
-/**
- * 新pvp赛季数据
- */
-export async function createNewPvpSeasonData(seasonEndTime: number) {
-    console.log('createNewPvpSeasonData');
-    let seasonNum = await CounterModel.getNewCounter(COUNTER.PVP_SEASON_NUM);
-    // let seasonEndTime: number = <number>getTimeFun(oldEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
-    let warId = getPvpWarId(-1);
-    let systemConfig = await PVPConfigModel.createPVPConfig(seasonNum, seasonEndTime, warId);
-    return systemConfig;
-}
-
-/**
- * 随机地图Id
- */
-function getPvpWarId(oldWarId: number): number {
-    let warIds: number[] = deepCopy(getPvpGkWarIds());
-    let index = indexOf(warIds, oldWarId);
-    if (index != -1) {
-        warIds.splice(index, 1);
-    }
-    let warId = getRandSingleEelm(warIds);
-    console.log('getPvpWarId', oldWarId, warId);
-    return warId;
-}
-
-/**
- * 每周重置地图
- */
-export async function resetPvpWarId() {
-    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-    let warId = getPvpWarId(systemConfig.warId)
-    return await PVPConfigModel.updatePVPConfig(systemConfig.seasonNum, { warId });
-}
-
-function getScore(arr, score) {
-    for (let item of arr) {
-        if ((item.max >= score || item.max == -1) && score >= item.min) {
-            return item;
-        }
-    }
-}
 /**
  * debug接口
  * @param hour 
  */
 export async function resetPvpSeasonTime(hour: number) {
-    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-
-    let seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
-    systemConfig = await createNewPvpSeasonData(seasonEndTime);
-    await resetPVPTimer(seasonEndTime);
-    await resetPvpRanks();
-    console.log('settleTime = ' + systemConfig.seasonNum)
-
-    return { seasonEndTime, seasonNum: systemConfig.seasonNum };
-}
-
-
-export async function resetPvpRanks() {
-    await initSingleRank(REDIS_KEY.PVP_RANK);
+    await PVPConfigModel.setCurPvpConfig({ seasonEndTime: getZeroPoint() });
+    return await setPvpSeason();
 }
 
 export async function reportOnlineSchedule() {