pvp：重写pvp定时器任务逻辑

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

@@ -1,3 +1,4 @@
+
 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { uniq, findWhere, findIndex } from 'underscore';
 import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
@@ -5,11 +6,10 @@ import { refreshEnemies, getEnemies, getLvByScore, defaultHeroes, comsumeChallen
 import { RoleModel, RoleType } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult, genCode } from '../../../pubUtils/util';
-
 import { PvpDefenseModel, OppPlayers } 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 } from '../../../consts';
+import { PVP_HERO_POS, PVP_HERO_ORDER, REDIS_KEY, LINEUP_NUM, TASK_TYPE, COUNTER } from '../../../consts';
 import { PVP } from '../../../pubUtils/dicParam';
 import { addItems } from '../../../services/rewardService';
 import { HeroModel } from '../../../db/Hero';
@@ -18,10 +18,10 @@ import { BattleRecordModel } from '../../../db/BattleRecord';
 import { PvpRecordModel } from '../../../db/PvpRecord';
 import { handleCost } from '../../../services/rewardService';
 import { nowSeconds, getSeconds } from '../../../pubUtils/timeUtil';
-import { setPvpSeasonResult, resetPvpWarId, resetPvpSeasonTime } from '../../../services/timeTaskService';
+import { pvpSeasonEnd, resetPvpWarId, createNextPvpSeason } from '../../../services/timeTaskService';
 import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
 import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
-import { SystemConfigModel } from '../../../db/SystemConfig';
+import { PVPConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
 import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
 
@@ -75,8 +75,9 @@ export class PvpHandler {
     }
 
     async debugPvpSeasonReset(msg: {}, session: BackendSession) {
-        let { seasonNum, seasonEndTime } = await setPvpSeasonResult({ name: 'exce setPvpSeasonResult debug' });
+        await pvpSeasonEnd({ name: 'exce setPvpSeasonResult debug' });
-        return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime })
+        let systemConfig = await createNextPvpSeason();
+        return resResult(STATUS.SUCCESS, { seasonNum: systemConfig.seasonNum, seasonEndTime: systemConfig.seasonEndTime })
     }
 
     async debugPvpWarReset(msg: {}, session: BackendSession) {
@@ -100,6 +101,7 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
     }
 
+    //1获取主界面
     async getData(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
@@ -200,7 +202,7 @@ export class PvpHandler {
         const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
         if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 检查挑战次数
-        let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
+        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
         let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         if (challengeCnt == 0) {
             return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
@@ -286,7 +288,7 @@ export class PvpHandler {
         await BattleRecordModel.updateBattleRecordByCode(battleCode, {
             $set: { status: isSuccess ? 1 : 2 }
         }, true);
-        let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
+        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
 
         // 减少挑战次数
         let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
@@ -321,6 +323,7 @@ export class PvpHandler {
         });
     }
 
+    //3. 保存防守阵容
     async saveDefense(msg: { heroes: Array<{ actorId: number, dataId: number, order: number }>, isDefaultHero: boolean }, session: BackendSession) {
         let { heroes, isDefaultHero } = msg;
         let roleId = session.get('roleId');
@@ -330,7 +333,7 @@ export class PvpHandler {
         heroes = uniq(heroes, function (item) {
             return item.order;
         });
-        let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
+        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);
@@ -404,6 +407,7 @@ export class PvpHandler {
 
     }
 
+    //8. 排行榜
     async getRank(msg: {}, session: BackendSession) {
 
         let roleId = session.get('roleId');
@@ -420,6 +424,7 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { ranks, myRank });
     }
 
+    //2.5. 获取对手详细信息（排行榜，战报，阵容查看）
     async getPlayerDetail(msg: { roleId: string }, session: BackendSession) {
 
         let roleId = session.get('roleId');
@@ -470,13 +475,14 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, result);
     }
 
+    //7. 领取巅峰之路奖励
     async receiveBox(msg: { id: number }, session: BackendSession) {
         let { id } = msg;
         let roleId = session.get('roleId');
         let sid: string = session.get('sid');
         let roleName = session.get('roleName');
         const funcs: number[] = session.get('funcs');
-        let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
+        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
         let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
         let pvpBoxs = getPvpBoxs();
         let pvpBox = findWhere(pvpBoxs, { id });
@@ -495,6 +501,7 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });
     }
 
+    //9. 战报
     async getRec(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId);

game-server/app/services/guildService.ts

@@ -1,11 +1,11 @@
 import { gameData, getGuildActiveWeekReward, getGuildActiveByIdAndType, getGoodById } from "../pubUtils/data";
 import { GuildModel, GuildType } from "../db/Guild";
 import { resResult, shouldRefresh } from "../pubUtils/util";
-import { STATUS, MAIL_TYPE, GUILD_AUTH, GUILD_JOB, REDIS_KEY, CHAT_SERVER, TASK_TYPE } from "../consts";
+import { STATUS, MAIL_TYPE, GUILD_AUTH, GUILD_JOB, REDIS_KEY, CHAT_SERVER, TASK_TYPE, COUNTER } from "../consts";
 import { RoleModel, RoleType } from "../db/Role";
 import { UserGuildModel, UserGuildType } from "../db/UserGuild";
 import { UserGuildApplyModel } from "../db/UserGuildApply";
-import { SystemConfigModel } from "../db/SystemConfig";
+import { PVPConfigModel } from "../db/SystemConfig";
 import { nowSeconds } from "../pubUtils/timeUtil";
 import { pinus, BackendSession, FrontendOrBackendSession } from "pinus";
 import { ARMY } from "../pubUtils/dicParam";
@@ -17,6 +17,7 @@ import { DATA_NAME } from '../consts/dataName';
 import { addRoleToGuildChannel } from "./chatService";
 import { Rank } from "./rankService";
 import { checkActivityTask, checkTask } from "./taskService";
+import { CounterModel } from "../db/Counter";
 
 export async function getMyGuildInfo(roleId: string, sid: string, userGuild: UserGuildType, guild: GuildType, serverId: number, session: FrontendOrBackendSession) {
 
@@ -304,7 +305,8 @@ export async function settleGuildWeekly() {
         res.releaseCallback();//解锁
     }
     await initSingleRank(REDIS_KEY.GUILD_ACTIVE_RANK);
-    await SystemConfigModel.updateSystemConfig({ settleGuildWeeklyTime: nowSeconds() }); // 记录一下
+    let curSeasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
+    await PVPConfigModel.updatePVPConfig(curSeasonNum, { settleGuildWeeklyTime: nowSeconds() }); // 记录一下,不知道原作者有什么用处...
     console.log('————— settleGuildWeekly结束 —————');
 }
 

game-server/app/services/pvpService.ts

@@ -1,14 +1,14 @@
 
 import { PvpDefenseModel, Heroes, OppPlayers, PvpDefenseType, HeroScores, pvpUpdateInter } from '../db/PvpDefense';
 import { RoleType } from '../db/Role';
-import { PVP_HERO_POS, REDIS_KEY, PVP_CONST } from '../consts';
+import { PVP_HERO_POS, REDIS_KEY, PVP_CONST, COUNTER } from '../consts';
 import { setPvpDefResult } from '../services/timeTaskService';
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
 import { getRandSingleIndex, genCode, shouldRefresh, getChineseName } from '../pubUtils/util';
 import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface';
 import { gameData, getPLvByScore } from "../pubUtils/data";
 import { PVP } from '../pubUtils/dicParam';
-import { SystemConfigModel } from '../db/SystemConfig'
+import { PVPConfigModel } from '../db/SystemConfig'
 import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
 import { HeroesRecord } from '../db/PvpRecord';
 import { HeroModel } from '../db/Hero';
@@ -19,6 +19,7 @@ import { findWhere, findIndex } from 'underscore';
 import { pinus } from 'pinus';
 import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp';
 import { Rank } from './rankService';
+import { CounterModel } from '../db/Counter';
 
 export async function getPvpData() {
 
@@ -43,7 +44,7 @@ export async function initPvpInfo(role: RoleType) {
     }
     //初始化对手人阵容
     let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 1);
-    let {seasonNum} = await SystemConfigModel.findSystemConfig();
+    let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
     let challengeCnt = PVP.PVP_CHALLENGE_COUNTS;
     let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe, seasonNum, challengeCnt });
 
@@ -96,7 +97,7 @@ export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number)
  * @param pLv 我的排名
  */
 export async function refreshEnemies(role: RoleType, score: number, pLv: number) {
-    let system = await SystemConfigModel.findSystemConfig();
+    let system = await PVPConfigModel.findCurPVPConfig();
     let mapWarJson = gameData.warJson.get(system.warId);
 
     let { roleId } = role;
@@ -441,7 +442,9 @@ export function comsumeChallengeCnt( challengeCnt: number, challengeRefTime: num
 
 export async function findPvpDefByRoleId(roleId: string) {
     let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
-    let {warId, seasonNum, seasonEndTime, oldSeasonEndTime} = await SystemConfigModel.findSystemConfig();
+    let { warId, seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+    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 };
@@ -471,13 +474,17 @@ export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
         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, oldSeasonEndTime } = await SystemConfigModel.findSystemConfig();
+    let { warId, seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+    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;

game-server/app/services/rankService.ts

@@ -4,7 +4,7 @@ import { redisClient, setUserInfo } from "./redisService";
 import { RoleType, RoleModel } from "../db/Role";
 import { GuildType, GuildModel } from "../db/Guild";
 import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
-import { SystemConfigModel } from "../db/SystemConfig";
+import { PVPConfigModel } from "../db/SystemConfig";
 import { PvpDefenseModel } from "../db/PvpDefense";
 import { gameData } from "../pubUtils/data";
 import { nowSeconds } from "../pubUtils/timeUtil";
@@ -800,7 +800,7 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
             await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild);
         }
     } else if (type == REDIS_KEY.PVP_RANK) {
-        let { seasonNum } = await SystemConfigModel.findSystemConfig();
+        let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
         console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
         let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
         let r = new Rank(type, {});

game-server/app/services/timeTaskService.ts

@@ -1,6 +1,6 @@
 
 import { scheduleJob, Job, scheduledJobs } from 'node-schedule';
-import { SystemConfigModel } from '../db/SystemConfig';
+import { PVPConfigModel } from '../db/SystemConfig';
 import PvpDefenseType, { PvpDefenseModel } from '../db/PvpDefense';
 import { PVP } from '../pubUtils/dicParam';
 import { nowSeconds, getAge, getTimeFun } from '../pubUtils/timeUtil';
@@ -8,7 +8,7 @@ import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank,
 import { deepCopy, resResult, getRandSingleEelm } from '../pubUtils/util';
 import { getLvByScore } from './pvpService';
 import { getAllOnlineRoles, getAllServers, initSingleRank, delGuildActivityRank } from './redisService';
-import { MAIL_TYPE, REDIS_KEY, ADULT_AGE, GUEST_MAX_TIME, ADDICTION_PREVENTION_CODE, GUILD_ACTIVITY_STATUS, GUILD_ACTIVITY_TYPE, TASK_TYPE, TIME_OUTPUT_TYPE, REFRESH_TIME, SEND_NAME } from '../consts';
+import { MAIL_TYPE, REDIS_KEY, ADULT_AGE, GUEST_MAX_TIME, ADDICTION_PREVENTION_CODE, GUILD_ACTIVITY_STATUS, GUILD_ACTIVITY_TYPE, TASK_TYPE, TIME_OUTPUT_TYPE, REFRESH_TIME, SEND_NAME, SERVER_OPEN_TIME, COUNTER } from '../consts';
 import { RoleModel } from '../db/Role';
 import { MailModel, MailType } from '../db/Mail';
 import { pinus } from 'pinus';
@@ -28,44 +28,41 @@ import { Rank } from './rankService';
 import { checkTask } from './taskService';
 import { everydayRefresh } from './connectorService';
 import { initMarquee, initMaintenance } from './gmService';
+import moment = require('moment');
+import { CounterModel } from '../db/Counter';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
 const SETTLE_DIFF = 29 * 60;
 const pageNum = 500;
 const PER_MINUTE = 1 * 60;
-var seasonJobId: Job;
+var seasonMakeRewardTimJobId: Job;
 var warJobId: Job;
-var seasonEndTimeJobId: Job;
+var seasonRefreshTimeJobId: Job;
 let guildWeeklyJobId: Job;
 let guildActSecondsJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
 let guildActEndJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
+let pvpMakeRewardInterval = null;
+let pvpRefreshInterval = null;
+
 /**
  * 服务器启动即开启定时任务，结算时常是23-24点，实际结算的时间点是23：31分钟
  */
 export async function init() {
-    let seasonEndTime = 0;
+    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-    let systemConfig = await SystemConfigModel.findSystemConfig();//系统全局参数表
+
-    if (!systemConfig) {
+    let seasonEndTime = systemConfig ? systemConfig.seasonEndTime : <number>getTimeFun(moment(SERVER_OPEN_TIME).startOf('d').add(-1, 'minute').toDate()).getAfterDay(PVP.PVP_SEASON_DAYS);
-        console.log('create season seasonNum = '+ systemConfig?.seasonNum);
+    if (nowSeconds() > seasonEndTime) {//停服太长，数据配置问题导致数据太老，需要刷新赛季数据
-        let warIds = getPvpGkWarIds();
+        while (nowSeconds() > seasonEndTime) {
-        let warId = warIds[0];
+            seasonEndTime = <number>getTimeFun(seasonEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
-        seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS);
+        }
-        systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
+    }
-    } else {
+    if (!systemConfig || seasonEndTime != systemConfig.seasonEndTime) {
-        seasonEndTime = systemConfig.seasonEndTime;
+        systemConfig = await createNewPvpSeasonData(seasonEndTime)
-        if (systemConfig.seasonEndTime - SETTLE_DIFF <= nowSeconds()) {//服务器启动时，检查当前时间是否大于实际结算的时间，若大于则重新开启定时任务，若小于则按照结束时间开启定时任务
+    }
-            seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS);
+
-            console.log('update season seasonNum = '+ systemConfig.seasonNum);
+    await resetPVPTimer(seasonEndTime);
-            systemConfig.seasonNum++;//赛季值增加1
-            await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum, oldSeasonEndTime: systemConfig.seasonEndTime});
-            await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true, notPush: true });
-        } 
-    }
-    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
-    seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);//设置实际赛季结算时间
 
-    seasonEndTimeJobId = scheduleJob('resetRank', seasonEndTime * PER_SECOND, resetPvpRanks);//由于24之后，才展示结算之后的信息，为保排行榜信息一致性，设置实际重置排行榜的时间为12点
     warJobId = scheduleJob("0 0 0 * * 1", resetPvpWarId);//每周1零点重置地图
     await resetPvpRanks();//服务器重启，重置排行榜的信息
 
@@ -92,29 +89,76 @@ export async function init() {
     await initMaintenance();
 }
 
-function setPvpSeasonSchdule() {
+async function resetPVPTimer(seasonEndTime: number) {
-    setPvpSeasonResult();
+    if (!!seasonMakeRewardTimJobId) {
+        seasonMakeRewardTimJobId.cancel();
+        clearInterval(pvpMakeRewardInterval);
+    }
+    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);//
+}
+
+//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 setPvpSeasonResult(obj?:{ name:string, notSetNext?: boolean, notPush?: boolean }) {
+export async function pvpSeasonEnd(obj?: { name: string, notSetNext?: boolean, notPush?: boolean }) {
-    console.log('exce setPvpSeasonResult'+ obj?.name);
+    console.log('exce pvpSeasonEnd' + obj?.name);
-    let { seasonNum, seasonEndTime, oldSeasonEndTime } = await setNextPvpTime(obj?.notSetNext);//设置下个结算任务
+    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 !== seasonNum) {
+            if (pvpDefense.seasonNum !== systemConfig.seasonNum) {
-                await setPvpDefResultOnTime(pvpDefense, seasonNum, oldSeasonEndTime, obj?.notPush);
+                await setPvpDefResultOnTime(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime, obj?.notPush);
             }
         }
     }
-    return { seasonNum, seasonEndTime, oldSeasonEndTime};
 }
 /**
  * pvp定时任务结算获得添加邮件信息
@@ -186,15 +230,19 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
     let pLv = getLvByScore(pvpDefense.heroScores);
     //pvp锁定的信息存入赛季结算表中
     await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, {
-        oldSeasonData:{refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores, 
+        oldSeasonData: {
+            refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores,
             seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime
-        }, heroGoods, rankGoods, show: true });//结算修改玩家pvp信息
+        }, heroGoods, rankGoods, show: true
+    });//结算修改玩家pvp信息
     // 更新任务
     await checkTask(pvpDefense.roleId, null, null, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores: pvpDefense.heroScores });
     await checkTask(pvpDefense.roleId, null, 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 {
+        rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, oldSeasonEndTime, heroGoods: heroGoods.map(({ id, count }) => {
             return { id, count };
-    }), rankGoods};
+        }), rankGoods
+    };
 }
 /**
  * 个人pvp结算，结算中未结算的，都按照最大排名挡位结算
@@ -221,36 +269,40 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
         await sendMailByContent(MAIL_TYPE.PVP_RESULT, roleId, { params: [JSON.stringify(seasonNum)], goods: heroGoods, endTime: oldSeasonEndTime });
     return pvpDefense;
 }
+
 /**
- * 每周重置地图
+ * 新pvp赛季数据
  */
-export async function resetPvpWarId() {
+export async function createNewPvpSeasonData(seasonEndTime: number) {
-    // console.log('resetPvpWarId');
+    console.log('createNewPvpSeasonData');
-    let systemConfig = await SystemConfigModel.findSystemConfig();
+    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, systemConfig.warId);
+    let index = indexOf(warIds, oldWarId);
     if (index != -1) {
         warIds.splice(index, 1);
     }
     let warId = getRandSingleEelm(warIds);
-    return await SystemConfigModel.updateSystemConfig({ warId });
+    console.log('getPvpWarId', oldWarId, warId);
+    return warId;
 }
+
 /**
- * 重置下个定时结算
+ * 每周重置地图
- * @param notSetNext 
  */
-async function setNextPvpTime(notSetNext: boolean) {
+export async function resetPvpWarId() {
-    let { seasonEndTime, seasonNum } = await SystemConfigModel.findSystemConfig();
+    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-    if (!!notSetNext) {
+    let warId = getPvpWarId(systemConfig.warId)
-        return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
+    return await PVPConfigModel.updatePVPConfig(systemConfig.seasonNum, { warId });
-    }
-    let oldSeasonEndTime = seasonEndTime;
-    seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS + 1);
-    await SystemConfigModel.updateSeason(seasonEndTime, oldSeasonEndTime);
-    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
-    seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);
-    seasonEndTimeJobId = scheduleJob('resetRank', seasonEndTime* PER_SECOND, resetPvpRanks);
-    return { seasonEndTime, seasonNum: seasonNum + 1, oldSeasonEndTime };
 }
 
 function getScore(arr, score) {
@@ -265,35 +317,19 @@ function getScore(arr, score) {
  * @param hour 
  */
 export async function resetPvpSeasonTime(hour: number) {
-    if (!!seasonJobId) {
+    let systemConfig = await PVPConfigModel.findCurPVPConfig();
-        seasonJobId.cancel();
+
-    }
+    let seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
-    let seasonEndTime = 0;
+    systemConfig = await createNewPvpSeasonData(seasonEndTime);
-    let seasonNum = 1;
+    await resetPVPTimer(seasonEndTime);
-    if (!!seasonEndTimeJobId) {
-        seasonEndTimeJobId.cancel();
-    }
-    let systemConfig = await SystemConfigModel.findSystemConfig();
-    if (!systemConfig) {
-        let warIds = getPvpGkWarIds();
-        let warId = warIds[0];
-        seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
-        systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
-    } else {
-        seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
-        seasonNum = systemConfig.seasonNum + 1;
-        await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum, oldSeasonEndTime: 0});
-        await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
     await resetPvpRanks();
-    }
+    console.log('settleTime = ' + systemConfig.seasonNum)
-    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
+
-    console.log('settleTime = ' + settleTime)
+    return { seasonEndTime, seasonNum: systemConfig.seasonNum };
-    seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);
-    return { seasonEndTime, seasonNum };
 }
 
 
-async function resetPvpRanks() {
+export async function resetPvpRanks() {
     await initSingleRank(REDIS_KEY.PVP_RANK);
 }
 
@@ -511,6 +547,8 @@ export async function raceActivityEnd() {
         guildActSecondsJobId = undefined;
     }
     if (guildActEndJobId) {
+
+
         guildActEndJobId.cancel();
         guildActEndJobId = undefined;
     }

game-server/test/chat.test.ts

@@ -291,7 +291,6 @@ describe('聊天测试', function () {
             setTimeout(() => {
               if (i === HERO_GROW_MAX.STAR && j > 0) {
               } else {
-                console.log('dddddddddddd', i, j);
                 pinusClient.request('role.heroHandler.starUp', { hid: XIAHOUQINGYI_HID, star: i, starStage: j }, (starUpRes) => {
                   if (starUpRes.code === STATUS.ROLE_STAR_REACH_MAX.code) {
                     pinusClient.request('role.heroHandler.qualityUp', { hid: XIAHOUQINGYI_HID, quality: 2 }, (qualityUpRes) => {

shared/consts/constModules/sysConst.ts

@@ -44,6 +44,7 @@ export const COUNTER = {
     ACTIVITY_GROUP_TYPE: { name: 'actgrptype', def: 1 },
     NOTICE: { name: 'notice', def: 1 },
     GIFT_CODE: { name: 'giftCode', def: 1 },
+    PVP_SEASON_NUM: { name: 'pvpSeason', def: 1 },
 };
 
 export const DEFAULT_HEROES = [19, 53, 46, 40, 22, 56, 32, 28, 18];

shared/db/SystemConfig.ts

@@ -1,8 +1,10 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+import { CounterModel } from './Counter';
+import { COUNTER } from '../consts';
 
 @index({ id: 1 })
-export default class SystemConfig extends BaseModel {
+export default class PVPConfig extends BaseModel {
     @prop({ required: true, default: 1 })
     id: number;
     @prop({ required: true })
@@ -11,34 +13,33 @@ export default class SystemConfig extends BaseModel {
     seasonNum: number;              // 赛季
     @prop({ required: true })
     seasonEndTime: number;         //赛季结束的时间
-    @prop({ required: true , default: 0 })
-    oldSeasonEndTime: number;         //上赛季结束的时间
     @prop({ required: false })
     settleGuildWeeklyTime: number;
 
-    public static async findSystemConfig(lean = true) {
+    public static async findCurPVPConfig() {
-        const result: SystemConfigType = await SystemConfigModel.findOne({}).lean(lean);
+        let seasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
+        const result: PVPConfigType = await PVPConfigModel.findOne({ seasonNum }).lean(true);
         return result;
     }
 
-    public static async createSystemConfig(seasonEndTime: number, warId: number, lean = true) {
+    public static async findPVPConfig(seasonNum: number) {
-        const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, { seasonEndTime, warId, seasonNum: 1 }, { upsert: true, new: true }).lean(lean);
+        const result: PVPConfigType = await PVPConfigModel.findOne({ seasonNum }).lean(true);
         return result;
     }
 
-    public static async updateSystemConfig(update: { seasonEndTime?: number, warId?: number, seasonNum?:number , oldSeasonEndTime?: number, settleGuildWeeklyTime?: number}, lean = true) {
+    public static async createPVPConfig(seasonNum: number, seasonEndTime: number, warId: number) {
-        const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, update, { upsert: true, new: true }).lean(lean);
+        const result: PVPConfigType = await PVPConfigModel.findOneAndUpdate({ seasonNum }, { warId, seasonEndTime }, { upsert: true, new: true }).lean(true);
         return result;
     }
 
-    public static async updateSeason( seasonEndTime: number, oldSeasonEndTime: number, lean = true) {
+    public static async updatePVPConfig(seasonNum: number, update: { warId?: number, settleGuildWeeklyTime?: number }) {
-        const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({},  { seasonEndTime, $inc: { seasonNum: 1 }, oldSeasonEndTime }, { upsert: true, new: true }).lean(lean);
+        const result: PVPConfigType = await PVPConfigModel.findOneAndUpdate({ seasonNum }, update, { new: true }).lean(true);
         return result;
     }
 }
 
-export const SystemConfigModel = getModelForClass(SystemConfig);
+export const PVPConfigModel = getModelForClass(PVPConfig);
 
-export interface SystemConfigType extends Pick<DocumentType<SystemConfig>, keyof SystemConfig> { 
+export interface PVPConfigType extends Pick<DocumentType<PVPConfig>, keyof PVPConfig> {
     id: number;
 };