diff --git a/game-server/app/servers/battle/handler/pvpHandler.ts b/game-server/app/servers/battle/handler/pvpHandler.ts
index 0fc470d36..eaef9a79b 100644
--- a/game-server/app/servers/battle/handler/pvpHandler.ts
+++ b/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' });
-        return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime })
+        await pvpSeasonEnd({ name: 'exce setPvpSeasonResult debug' });
+        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);
diff --git a/game-server/app/services/guildService.ts b/game-server/app/services/guildService.ts
index d4b17c2a0..205c16df9 100644
--- a/game-server/app/services/guildService.ts
+++ b/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,17 +17,18 @@ 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) {
-    
+
     let leader = <RoleType>guild.leader;
     let leaderIsOnline = await isRoleOnline(leader.roleId);
 
     // 打开公会页面，加入channel
-    if(userGuild.guildCode) {
+    if (userGuild.guildCode) {
         addRoleToGuildChannel(roleId, sid, guild.code);
         session.set('guildCode', guild.code);
-        session.push('guildCode', () => {});
+        session.push('guildCode', () => { });
     }
 
     // 获取排行榜
@@ -39,7 +40,7 @@ export async function getMyGuildInfo(roleId: string, sid: string, userGuild: Use
     let guildMemberMax = dicGuild && memberCnt >= dicGuild.peopleNum;
 
     // 返回
-    return { hasGuild: true, guildMemberMax, ...guild, leader: { ...leader, isOnline: leaderIsOnline }, rank, myInfo: {...userGuild }};
+    return { hasGuild: true, guildMemberMax, ...guild, leader: { ...leader, isOnline: leaderIsOnline }, rank, myInfo: { ...userGuild } };
 }
 
 /**
@@ -225,7 +226,7 @@ export async function getUserGuildWithRefActive(roleId: string, select?: string,
                 return;
             for (let i = 0; i < drawCnt; i++) {
                 let donateName = donateNames[donateNames.length - i - 1];
-                await sendMailByContent(MAIL_TYPE.WISH_POOL_REWARD, roleId, { 
+                await sendMailByContent(MAIL_TYPE.WISH_POOL_REWARD, roleId, {
                     params: [donateName, goodInfo.name],
                     goods: [{ id: goodId, count: drawCnt }],
                     notPush
@@ -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结束 —————');
 }
 
@@ -314,10 +316,10 @@ export async function getWishPool(userGuild: UserGuildType) {
 
     let userGuilds = await UserGuildModel.getWishPoolGoods(code, ' wishDntCnt wishGoods roleId');
     let list = [];
-    userGuilds.map(({ wishGoods, roleId })=>{
-        wishGoods.map(({ type, goodId, count, receiveCnt, drawCnt, id })=>{
+    userGuilds.map(({ wishGoods, roleId }) => {
+        wishGoods.map(({ type, goodId, count, receiveCnt, drawCnt, id }) => {
             list.push({ type, goodId, count, receiveCnt, drawCnt, id, roleId })
         });
     });
-    return { list, wishDntCnt:wishDntCnt||0, wishGoods };
+    return { list, wishDntCnt: wishDntCnt || 0, wishGoods };
 }
diff --git a/game-server/app/services/pvpService.ts b/game-server/app/services/pvpService.ts
index 80d13d4b1..1ec3d5912 100644
--- a/game-server/app/services/pvpService.ts
+++ b/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,9 +19,10 @@ 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() {
-    
+
 }
 
 
@@ -32,18 +33,18 @@ export async function initPvpInfo(role: RoleType) {
     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;
+        if (item) defCe += item.ce;
         heroes.push({
-            actorId: item?.hid||0,
-            hero: item?.hero||null,
-            ce: item?.ce||0,
+            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 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 });
 
@@ -55,7 +56,7 @@ export async function initPvpInfo(role: RoleType) {
 }
 
 export async function checkPvp(role: RoleType) {
-    if(role.hasInit) {
+    if (role.hasInit) {
         let result = await PvpDefenseModel.findByRoleId(role.roleId, true);
         if (!!result)
             return result;
@@ -73,10 +74,10 @@ export async function checkPvp(role: RoleType) {
 export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number) {
 
     let result = new Array<oppPlayersInter>();
-    for(let oppPlayer of oppPlayers) {
+    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'
-        if(oppDef) delete oppDef.heroes;
+        if (oppDef) delete oppDef.heroes;
         result.push({
             ...oppDef,
             roleId: oppDef.oppRoleId,
@@ -96,24 +97,24 @@ 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;
     let oppPlayers = new Array<OppPlayers>();
     let opp = dicPvpOpponent.values()
-    for(let dicOpp of opp) {
+    for (let dicOpp of opp) {
         let flag = false; // 是否筛选成功
-        if(score >= PVP_CONST.SCORE_LINE) { // 将这个放到const
+        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);
+            if (!flag) flag = await matchPlayerByRank(system.seasonNum, oppPlayers, mapWarJson, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
+            if (!flag) flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
         } else {
             flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
         }
-        if(!flag) continue;
+        if (!flag) continue;
     }
-    
+
     return oppPlayers;
 }
 
@@ -121,58 +122,58 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
     // console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
     let r = new Rank(REDIS_KEY.PVP_RANK, {});
     let ridRanks = new Array<number>(); // 已经被使用了的排名
-    for(let { roleId: curRoleId } of oppPlayers) {
-        let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId)});
+    for (let { roleId: curRoleId } of oppPlayers) {
+        let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId) });
         ridRanks.push(rankLv);
     }
 
-    let myRank = await r.getMyRank({roleId});
+    let myRank = await r.getMyRank({ roleId });
     ridRanks.push(myRank);
 
     let oppRoleId = '';
     let oppRank = 0;
-    if(myRank == 0) {
+    if (myRank == 0) {
         return false
-    } else if(myRank == 1) { // 第一名
-        if(pos == 1) {
+    } else if (myRank == 1) { // 第一名
+        if (pos == 1) {
             oppRank = 2;
-            while(ridRanks.includes(oppRank)) {
-                oppRank --;
+            while (ridRanks.includes(oppRank)) {
+                oppRank--;
             }
-        } else if(pos == 2) {
+        } else if (pos == 2) {
             oppRank = 3;
-            while(ridRanks.includes(oppRank)) {
-                oppRank --;
+            while (ridRanks.includes(oppRank)) {
+                oppRank--;
             }
         } else {
             oppRank = 4;
-            while(ridRanks.includes(oppRank)) {
-                oppRank ++;
+            while (ridRanks.includes(oppRank)) {
+                oppRank++;
             }
         }
-    } else if(myRank == 0){
+    } else if (myRank == 0) {
         return false
     } else {
-        if(pos == 1 || pos == 2) { // 刷新我前一名
+        if (pos == 1 || pos == 2) { // 刷新我前一名
             oppRank = myRank - 1;
-            while(ridRanks.includes(oppRank)) {
-                oppRank --;
+            while (ridRanks.includes(oppRank)) {
+                oppRank--;
             }
         } else { // 刷新我后一名
             oppRank = myRank + 1;
-            while(ridRanks.includes(oppRank)) {
-                oppRank ++;
+            while (ridRanks.includes(oppRank)) {
+                oppRank++;
             }
         }
     }
     let result = await r.getUserByRank(oppRank);
-    if(result.length <= 0) return false;
+    if (result.length <= 0) return false;
     oppRoleId = result[0];
 
     let pvpdefense = await PvpDefenseModel.findByRoleIdIncludeAll(oppRoleId);
-    if(!pvpdefense || pvpdefense.seasonNum != seasonNum) return false;
+    if (!pvpdefense || pvpdefense.seasonNum != seasonNum) return false;
     let pvpHistoryOpp = await generPlayerOppHis(pvpdefense, mapWarJson, roleId, pos);
-    if(!pvpHistoryOpp) return false;
+    if (!pvpHistoryOpp) return false;
 
     oppPlayers.push({
         roleId: pvpHistoryOpp.oppRoleId,
@@ -183,7 +184,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: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pLv: number, dicOpp: DicPvpOpponent) {
     // console.log('matchPlayer', JSON.stringify(oppPlayers))
 
     let { id: pos, minLv, maxLv } = dicOpp
@@ -191,19 +192,19 @@ async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJs
     range = range.filter(cur => {
         return oppPlayers.findIndex(ccur => ccur.roleId == makeRobotId(cur.roleId)) == -1;
     });
-    if(range.length <= 0) return false;
+    if (range.length <= 0) return false;
 
     let index = getRandSingleIndex(range.length);
     let result = range[index]; // 本次匹配结果 pvpdefense
-    if(!result) return false;
-    if(result.roleId == roleId) {
+    if (!result) return false;
+    if (result.roleId == roleId) {
         range.splice(index, 1);
-        if(range.length <= 0) return false;
+        if (range.length <= 0) return false;
         index = getRandSingleIndex(range.length);
         result = range[index];
     }
     let pvpHistoryOpp = await generPlayerOppHis(result, mapWarJson, roleId, pos);
-    if(!pvpHistoryOpp) return false;
+    if (!pvpHistoryOpp) return false;
     oppPlayers.push({
         roleId: pvpHistoryOpp.oppRoleId,
         oppDef: pvpHistoryOpp._id,
@@ -225,25 +226,25 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, mapWarJson: DicWarJ
     let role = <RoleType>pvpdefense.role;
     let r = new Rank(REDIS_KEY.PVP_RANK, {});
     let rankLv = await r.getMyRank({ roleId: role.roleId });
-    let dbHeroes = await HeroModel.findByRole(role.roleId, [{field: 'ce', sortBy: -1}]);
+    let dbHeroes = await HeroModel.findByRole(role.roleId, [{ field: 'ce', sortBy: -1 }]);
     let heroes = new Array<PvpEnemies>();
     let otherHeroes = new Array<PvpOtherHeroes>(); // 阵容外的所有武将信息
-    for(let dbHero of dbHeroes) {
+    for (let dbHero of dbHeroes) {
         let h = defenseHeroes.find(cur => cur.actorId == dbHero.hid); // 阵容里是否有这个武将
         let hs = heroScores.find(cur => cur.hid == dbHero.hid); // 这个武将是否有这个得分
-        if(!!h) { 
+        if (!!h) {
             let warJson = mapWarJson.find(cur => cur.dataId == h.dataId);
-            if(warJson && warJson.relation == 2) {
+            if (warJson && warJson.relation == 2) {
                 let heroInfo = new PvpHeroInfo();
                 heroInfo.setHeroInfo(dbHero);
                 heroInfo.setOutIndex(h.order);
                 let attribute = getPlayerAttribute(dbHero.attr, role.attr);
                 heroInfo.setAttribute(attribute);
-                let enemy = new PvpEnemies(warJson, heroInfo, hs?hs.score: 0, attribute.ce);
+                let enemy = new PvpEnemies(warJson, heroInfo, hs ? hs.score : 0, attribute.ce);
                 heroes.push(enemy);
             }
-        } else { 
-            let heroInfo = new PvpOtherHeroes(hs?hs.score: 0);
+        } else {
+            let heroInfo = new PvpOtherHeroes(hs ? hs.score : 0);
             heroInfo.setHeroInfo(dbHero);
             otherHeroes.push(heroInfo);
         }
@@ -263,22 +264,22 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
     let { lv: myLv, topLineupCe: myCe, roleId } = role;
     let { id: pos, minLv, maxLv, ratio } = dicOpp;
     let range = gameData.pvpWar;
-    if(range.length <= 0) return false;
+    if (range.length <= 0) return false;
 
     let index = getRandSingleIndex(range.length);
     let result = range[index];
-    if(!result) return false;
+    if (!result) return false;
 
     let robotWarjson = gameData.warJson.get(result.war_id);
-    if(!robotWarjson) { /* TODO 判空处理 */ }
+    if (!robotWarjson) { /* TODO 判空处理 */ }
     let heroes = new Array<PvpEnemies>();
     let defCe = 0;
-    for(let warJson of mapWarJson) {
-        if(warJson.relation == 1) continue;
+    for (let warJson of mapWarJson) {
+        if (warJson.relation == 1) continue;
         let h = robotWarjson.find(cur => cur.dataId == warJson.dataId);
-        if(h) {
+        if (h) {
             let dicHero = gameData.hero.get(h.actorId);
-            if(!dicHero) continue;
+            if (!dicHero) continue;
             let heroInfo = new PvpHeroInfo();
             heroInfo.setRobotInfo(h, myLv, dicHero.initialStars, dicHero.quality);
             let attribute = getRobotAttribute(h.attribute, myCe, PVP_CONST.ENEMY_CE, ratio);
@@ -291,8 +292,8 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
 
     let oppRoleId = generateRobotRoleId();
     let roleName = getChineseName();
-    let hisPLv = Math.floor(pLv + (minLv + maxLv)/2);
-    if(hisPLv < 1) hisPLv = 1
+    let hisPLv = Math.floor(pLv + (minLv + maxLv) / 2);
+    if (hisPLv < 1) hisPLv = 1
 
     let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
         roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0
@@ -330,55 +331,55 @@ export function robotIdComBack(robotRoleId: string) {
 // 根据连胜次数，获得加成的积分
 export function getPlusScore(win: number) {
     let result = win - 1;
-    if(result < 0) result = 0;
-    if(result > PVP.PVP_WINREWARD_UPLIMIT) result = PVP.PVP_WINREWARD_UPLIMIT;
+    if (result < 0) result = 0;
+    if (result > PVP.PVP_WINREWARD_UPLIMIT) result = PVP.PVP_WINREWARD_UPLIMIT;
     return result;
 }
 
 export function getLvByScore(heroScores: HeroScores[]) {
     heroScores.sort((a, b) => b.score - a.score);
     let score = 0;
-    for(let i = 0; i < 5; i++) {
-        if(!heroScores[i]) break;
+    for (let i = 0; i < 5; i++) {
+        if (!heroScores[i]) break;
         score += heroScores[i].score;
     }
     return getPLvByScore(score);
 }
 
-export async function defaultHeroes ( role:RoleType, challengeCnt?:number, challengeRefTime?:number, isUpdate?: boolean) {
+export async function defaultHeroes(role: RoleType, challengeCnt?: number, challengeRefTime?: number, isUpdate?: boolean) {
     let pvpDefense = await PvpDefenseModel.findByRoleId(role.roleId);
-    if(!pvpDefense) return;
+    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) {
+    role.topLineup.sort(function (a, b) {
         return b.ce - a.ce;
     });
-    heroes.sort(function(a, b) {
+    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) {
+        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;
+    let num = 0;
     for (let i = 0; i < role.topLineup.length; i++) {
         let item = role.topLineup[i];
-        let index = findIndex(heroes, {actorId: item.hid});
+        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})) {
+                if (!!findWhere(role.topLineup, { hid: hero.actorId })) {
                     continue;
-                } 
+                }
                 if (!orders[0]) {
                     break;
                 }
@@ -401,68 +402,70 @@ export async function defaultHeroes ( role:RoleType, challengeCnt?:number, chall
         defCe += item.ce;
     }
     if (!!challengeCnt && !!challengeRefTime) {
-        let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes, challengeCnt, challengeRefTime, isDefaultHero:true});
-        return { resHeroes};
+        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};
+        let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, isDefaultHero: true });
+        return { resHeroes };
     }
 }
 
 export function refresh(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
     if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
-        return {challengeCnt, challengeRefTime};
+        return { challengeCnt, challengeRefTime };
     }
     let period = PVP.PVP_CHALLENGE_NORMALTIMES * 60;
     if (getTimeFun(seasonEndTime).checkDay()) {
         period = PVP.PVP_CHALLENGE_FINALTIMES * 60;
     }
     let time = nowSeconds();
-    let num = Math.floor(( time - challengeRefTime)/period);
+    let num = Math.floor((time - challengeRefTime) / period);
     if (num > 0) {
         challengeCnt += num;
         challengeRefTime = challengeRefTime + period * num;
-    } 
-    challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS?PVP.PVP_CHALLENGE_COUNTS:challengeCnt;
-    return {challengeCnt, challengeRefTime};
+    }
+    challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS ? PVP.PVP_CHALLENGE_COUNTS : challengeCnt;
+    return { challengeCnt, challengeRefTime };
 }
 
-export function comsumeChallengeCnt( challengeCnt: number, challengeRefTime: number, seasonEndTime:number ) {
+export function comsumeChallengeCnt(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
     challengeCnt--;
     if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
-        return {challengeCnt, challengeRefTime};
+        return { challengeCnt, challengeRefTime };
     }
     if (challengeCnt == PVP.PVP_CHALLENGE_COUNTS - 1) {
         challengeRefTime = nowSeconds();
-        return {challengeCnt, challengeRefTime};
+        return { challengeCnt, challengeRefTime };
     }
     return refresh(challengeCnt, challengeRefTime, seasonEndTime);
 }
 
 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};
-    } 
-    let {challengeCnt, challengeRefTime} = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        return { pvpDefense: newPvpDefense, warId };
+    }
+    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});
+    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, warId, shouldRefOpp };
 }
 
 // 获取刷新对手次数及消耗
 export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
     let curTime = new Date();
     let shouldRefOpp = shouldRefresh(refOppTime, curTime);
-    if(shouldRefOpp) {
+    if (shouldRefOpp) {
         refOppCnt = 0; refOppTime = curTime;
     }
     return {
@@ -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;
@@ -486,22 +493,22 @@ export async function findPvpDefAllByRoleId(roleId: string) {
         pvpDefense.heroScores = heroScores;
         pvpDefense.challengeCnt = challengeCnt;
         pvpDefense.challengeRefTime = challengeRefTime;
-    } 
+    }
     pvpDefense.seasonNum = seasonNum;
-    let {challengeCnt, challengeRefTime} = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, 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 || shouldRefOpp) {
         let update: pvpUpdateInter = {
             challengeCnt, challengeRefTime, refOppCnt, refOppTime
         };
-        
-        if(shouldRefOpp) {
+
+        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);
+        let updateResult = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
         pvpDefense.oppPlayers = updateResult.oppPlayers;
         pvpDefense.challengeCnt = challengeCnt;
         pvpDefense.challengeRefTime = challengeRefTime;
@@ -509,7 +516,7 @@ export async function findPvpDefAllByRoleId(roleId: string) {
         pvpDefense.refOppTime = refOppTime;
     }
 
-    return {pvpDefense, warId, shouldRefOpp, seasonEndTime, oldSeasonEndTime};
+    return { pvpDefense, warId, shouldRefOpp, seasonEndTime, oldSeasonEndTime };
 }
 
 /**
@@ -519,7 +526,7 @@ export async function findPvpDefAllByRoleId(roleId: string) {
  * @param enemyCe 出兵表对手战力
  * @param ratio 系数
  */
-export function getRobotAttribute(attribute: {id: number, val: number}[], ce: number, enemyCe: number, ratio: number) {
+export function getRobotAttribute(attribute: { id: number, val: number }[], ce: number, enemyCe: number, ratio: number) {
 
     let newAttribute = new Attribute();
     newAttribute.setByWarJson(attribute, Math.sqrt(ce / enemyCe * ratio));
@@ -584,7 +591,7 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
             });
         } else {
             showHeroScores.push({
-                hid, addScore: 0, plusScore: 0, score: curHeroScore?curHeroScore.score: 0
+                hid, addScore: 0, plusScore: 0, score: curHeroScore ? curHeroScore.score : 0
             });
         }
         const myHero = await HeroModel.findByHidAndRole(hid, roleId, 'quality star colorStar lv');
@@ -616,10 +623,10 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
 export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayers, oppHeroes: pvpEndParamInter[], myLv: number) {
     let oppHeroRecords = new Array<HeroesRecord>();
     let oppRole = <PvpHistoryOppType>curOpp.oppDef;
-    if(!oppRole) { console.error('opp role not found') }
+    if (!oppRole) { console.error('opp role not found') }
     for (let { hid, damage, heal, underDamage } of oppHeroes) {
         let historyHero = oppRole.heroes.find(cur => cur.actorId == hid);
-        if(historyHero) {
+        if (historyHero) {
             let hs = new HeroesRecord(historyHero, damage, heal, underDamage);
             oppHeroRecords.push(hs);
         }
diff --git a/game-server/app/services/rankService.ts b/game-server/app/services/rankService.ts
index 11dda783d..c083965ae 100644
--- a/game-server/app/services/rankService.ts
+++ b/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";
@@ -42,7 +42,7 @@ export class Rank {
                 this.timelen = 0; break;
             case REDIS_KEY.RACE_ACTIVITY:
                 this.timelen = 6; break;
-            default: 
+            default:
                 this.timelen = 10; break;
         }
 
@@ -238,9 +238,9 @@ export class Rank {
                 role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
             }
             let { dungeonWarId, dungeonHeroes } = role;
-            if(dungeonWarId > 0) {
+            if (dungeonWarId > 0) {
                 let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId);
-                let lineup = cur?cur.heroes: [];
+                let lineup = cur ? cur.heroes : [];
                 let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
                 let arr = new Array<LineupParam>();
                 for (let seqId of lineup) {
@@ -259,7 +259,7 @@ export class Rank {
             let { showLineup, topLineup = [] } = role;
             let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
             let arr = new Array<LineupParam>();
-            if(!showLineup) showLineup = topLineup.map(cur => cur.hid);
+            if (!showLineup) showLineup = topLineup.map(cur => cur.hid);
             for (let hid of showLineup) {
                 let curHero = heroes.find(cur => cur.hid == hid);
                 if (curHero) {
@@ -292,7 +292,7 @@ export class Rank {
      */
     public async setRank(myId: myIdInter, score: number, timestamp: number, isInc = false) {
         let oldTop = await this.getRankByRank(0, 0);
-        let oldScore = oldTop.length > 0? oldTop[0].num: 0;
+        let oldScore = oldTop.length > 0 ? oldTop[0].num : 0;
         // 更新分数
         let newScore = score;
         if (this.isUnion) {
@@ -383,7 +383,7 @@ export class Rank {
         }
 
         for (let extraKey of this.extraKeys) {
-            await this.setExInfoToParam(extraKey, param, { roleId }, {role});
+            await this.setExInfoToParam(extraKey, param, { roleId }, { role });
         }
 
         return await this.generFields(param);
@@ -408,7 +408,7 @@ export class Rank {
         }
 
         for (let extraKey of this.extraKeys) {
-            await this.setExInfoToParam(extraKey, param, { guildCode }, { guild } );
+            await this.setExInfoToParam(extraKey, param, { guildCode }, { guild });
         }
 
         return await this.generFields(param);
@@ -420,7 +420,7 @@ export class Rank {
 
         let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
         if (!hasCurUser) {
-            if(!role) {
+            if (!role) {
                 role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
             }
             param = new RoleRankInfo(role, true);
@@ -473,13 +473,13 @@ export class Rank {
 
             let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
             if (!hasCurUser) {
-                if(!hero) {
+                if (!hero) {
                     hero = await HeroModel.findByHidAndRole(myId.hid, myId.roleId, HERO_SELECT.RANK_LINEUP);
                 }
                 let arr = new Array<LineupParam>();
                 let lineParam = new LineupParam(hero);
                 arr.push(lineParam);
-                if(this.key == REDIS_KEY.HERO_RANK) {
+                if (this.key == REDIS_KEY.HERO_RANK) {
                     param.setSingleHero(arr);
                 } else {
                     param.setTopLine(arr);
@@ -487,7 +487,7 @@ export class Rank {
             } else {
                 const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
                 const infoObj = JSON.parse(info);
-                if(this.key == REDIS_KEY.HERO_RANK) {
+                if (this.key == REDIS_KEY.HERO_RANK) {
                     param.setSingleHero(infoObj);
                 } else {
                     param.setTopLine(infoObj);
@@ -503,7 +503,7 @@ export class Rank {
                 }
                 let { dungeonWarId, dungeonHeroes } = role;
                 let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId);
-                let lineup = cur?cur.heroes: [];
+                let lineup = cur ? cur.heroes : [];
                 let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.RANK_LINEUP);
                 let arr = new Array<LineupParam>();
                 for (let seqId of lineup) {
@@ -531,7 +531,7 @@ export class Rank {
                 let { showLineup, topLineup = [] } = role;
                 let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
                 let arr = new Array<LineupParam>();
-                if(!showLineup) showLineup = topLineup.map(cur => cur.hid);
+                if (!showLineup) showLineup = topLineup.map(cur => cur.hid);
                 for (let hid of showLineup) {
                     let curHero = heroes.find(cur => cur.hid == hid);
                     if (curHero) {
@@ -579,7 +579,7 @@ export class Rank {
 
         let num = 0;
         for (let ii = 0; ii < rankFromDb.length; ii += 2) {
-            if(num >= this.limit) break;
+            if (num >= this.limit) break;
 
             const field = rankFromDb[ii];
             let myId = this.decodeFields(this.key, field);
@@ -589,7 +589,7 @@ export class Rank {
 
             let param: RoleRankInfo | GuildRankInfo;
             if (this.infoKey == REDIS_KEY.USER_INFO) {
-                if(nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
+                if (nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
                     continue;
                 }
                 param = new RoleRankInfo(userInfo, false);
@@ -603,7 +603,7 @@ export class Rank {
                 await this.setExInfoToParam(extraKey, param, myId, {});
             }
             ranks.push(param);
-            num ++;
+            num++;
         }
         return ranks
     }
@@ -620,7 +620,7 @@ export class Rank {
 
         let num = 0;
         for (let ii = 0; ii < rankFromDb.length; ii += 2) {
-            if(num >= this.limit) break;
+            if (num >= this.limit) break;
 
             const field = rankFromDb[ii];
             let myId = this.decodeFields(this.key, field);
@@ -630,7 +630,7 @@ export class Rank {
 
             let param: RoleRankInfo | GuildRankInfo;
             if (this.infoKey == REDIS_KEY.USER_INFO) {
-                if(nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
+                if (nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
                     continue;
                 }
                 param = new RoleRankInfo(userInfo, false);
@@ -644,7 +644,7 @@ export class Rank {
                 await this.setExInfoToParam(extraKey, param, myId, {});
             }
             ranks.push(param);
-            num ++;
+            num++;
         }
         return ranks
     }
@@ -658,7 +658,7 @@ export class Rank {
         }
         // console.log('**getMyRank',key, this.composeFields(this.key, myId), this.key, myId)
         let myRank = await redisClient().zrevrankAsync(key, this.composeFields(this.key, myId));
-        if(!myRank && myRank != 0) {
+        if (!myRank && myRank != 0) {
             return 0;
         } else {
             return myRank + 1;
@@ -726,36 +726,36 @@ export class Rank {
 
     private handleTimestamp(timestamp: number = 0) {
         let l = timestamp.toString().length;
-        if(l > this.timelen) {
+        if (l > this.timelen) {
             timestamp = Math.floor(timestamp / Math.pow(10, l - this.timelen));
         }
         return timestamp
     }
 
     private async checkMyRankAndPush(myId: myIdInter, oldScore: number, newScore: number) {
-        if(this.isInit) return;
+        if (this.isInit) return;
         let myRank = await this.getMyRank(myId);
-        if(myRank == 1 && newScore > oldScore) {
+        if (myRank == 1 && newScore > oldScore) {
             let serverId = this.keyName.serverId;
             let sid = await getWorldChannelSid(serverId);
-            for(let { id, general } of gameData.rank) {
+            for (let { id, general } of gameData.rank) {
                 let redisKey = RANK_TYPE_TO_KEY.get(id);
-                if(redisKey == this.key) {
-                    if(general == 1) {
+                if (redisKey == this.key) {
+                    if (general == 1) {
                         let r = new Rank(redisKey, { serverId }, false, 1);
-                        let ranks = <RoleRankInfo[]> await r.getRankByRange();
-                        if(ranks.length > 0) {
-                            let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false));
-                            pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general});
+                        let ranks = <RoleRankInfo[]>await r.getRankByRange();
+                        if (ranks.length > 0) {
+                            let param = new GeneralRankParamRole(id, ranks[0] || new RoleRankInfo({}, false));
+                            pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, { ...param, general });
                         }
                     } else if (general = 2) {
                         let r = new Rank(redisKey, { serverId }, false, 1);
-                        let ranks = <RoleRankInfo[]> await r.getRankByRange();
+                        let ranks = <RoleRankInfo[]>await r.getRankByRange();
                         let hero: HeroUpdate;
-                        if(ranks.length > 0) {
+                        if (ranks.length > 0) {
                             hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins');
-                            let param = new GeneralRankParamBattle(id, ranks[0]||new RoleRankInfo({}, false), hero);
-                            pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general});
+                            let param = new GeneralRankParamBattle(id, ranks[0] || new RoleRankInfo({}, false), hero);
+                            pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, { ...param, general });
                         }
                     }
 
@@ -772,23 +772,23 @@ export class Rank {
  * @param type 排行榜类型
  * @param serverId 分服
  */
-export async function setRankRedisFromDb(type: string, args?: {serverId?: number}) {
+export async function setRankRedisFromDb(type: string, args?: { serverId?: number }) {
 
-    if(type == REDIS_KEY.TOWER_RANK) {
+    if (type == REDIS_KEY.TOWER_RANK) {
         let serverId = args.serverId;
         let ranks = await RoleModel.getRank('tower', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             // console.log(roleId);
-            await r.setRankWithRoleInfo(role.roleId, role.towerLv, role.towerUpTime?role.towerUpTime.getTime():0, role);
+            await r.setRankWithRoleInfo(role.roleId, role.towerLv, role.towerUpTime ? role.towerUpTime.getTime() : 0, role);
         }
     } else if (type == REDIS_KEY.GUILD_ACTIVE_RANK) {
         let serverId = args.serverId;
         let ranks = await GuildModel.getRank(type, serverId);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let guild of ranks) {
+        for (let guild of ranks) {
             await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
         }
     } else if (type == REDIS_KEY.GUILD_LV_RANK) {
@@ -796,16 +796,16 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await GuildModel.getRank(type, serverId);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let guild of ranks) {
+        for (let guild of ranks) {
             await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild);
         }
-    } else if ( type == REDIS_KEY.PVP_RANK) {
-        let { seasonNum } = await SystemConfigModel.findSystemConfig();
+    } else if (type == REDIS_KEY.PVP_RANK) {
+        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, {});
         r.setIsInit(true);
-        for(let {roleId, role: _role, score, updatedAt } of ranks) {
+        for (let { roleId, role: _role, score, updatedAt } of ranks) {
             let role = <RoleType>_role;
             if (!role) {
                 continue;
@@ -817,7 +817,7 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await RoleModel.getRank('topLineup', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             // console.log(roleId);
             await r.setRankWithRoleInfo(role.roleId, role.topLineupCe, role.updatedAt.getTime(), role);
         }
@@ -826,7 +826,7 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await HeroModel.getAllRank(serverId, HERO_SELECT.RANK_LINEUP);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let hero of ranks) {
+        for (let hero of ranks) {
             await r.setRankWithHeroInfo(hero.roleId, hero.hid, hero.ce, hero.updatedAt.getTime(), hero);
         }
     } else if (type == REDIS_KEY.HERO_NUM_RANK) {
@@ -834,15 +834,15 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await RoleModel.getRank('heroNum', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
-            await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role );
+        for (let role of ranks) {
+            await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role);
         }
     } else if (type == REDIS_KEY.USER_LV) {
         let serverId = args.serverId;
         let ranks = await RoleModel.getRank('lv', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             await r.setRankWithRoleInfo(role.roleId, role.lv, role.updatedAt.getTime(), role);
         }
     } else if (type == REDIS_KEY.SUM_CE_RANK) {
@@ -850,7 +850,7 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await RoleModel.getRank('ce', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             await r.setRankWithRoleInfo(role.roleId, role.ce, role.updatedAt.getTime(), role);
         }
     } else if (type == REDIS_KEY.DUNGEON_RANK) {
@@ -858,7 +858,7 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await RoleModel.getRank('dungeon', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             await r.setRankWithRoleInfo(role.roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
         }
     } else if (type == REDIS_KEY.MAIN_RANK) {
@@ -866,7 +866,7 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await RoleModel.getRank('main', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             await r.setRankWithRoleInfo(role.roleId, role.mainWarId, role.mainUpdatedAt, role);
         }
     } else if (type == REDIS_KEY.MAIN_ELITE_RANK) {
@@ -874,17 +874,17 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
         let ranks = await RoleModel.getRank('mainElite', serverId, ROLE_SELECT.RANK);
         let r = new Rank(type, { serverId });
         r.setIsInit(true);
-        for(let role of ranks) {
+        for (let role of ranks) {
             await r.setRankWithRoleInfo(role.roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
         }
     } else if (type == REDIS_KEY.HERO_RANK) {
         let serverId = args.serverId;
 
-        for(let hid of gameData.dicMyHeroes) {
+        for (let hid of gameData.dicMyHeroes) {
             let ranks = await HeroModel.getRank(hid, serverId, HERO_SELECT.RANK_LINEUP);
             let r = new Rank(type, { serverId, hid });
             r.setIsInit(true);
-            for(let hero of ranks) {
+            for (let hero of ranks) {
                 await r.setRankWithHeroInfo(hero.roleId, hid, hero.ce, hero.updatedAt.getTime(), hero);
             }
         }
@@ -896,35 +896,35 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
  * @param role 玩家数据
  * @param serverId 所在服务器
  */
-export async function getGeneralRank(role: RoleType&{rankReceived: number[]}, serverId: number) {
-    let { rankReceived = []} = role;
+export async function getGeneralRank(role: RoleType & { rankReceived: number[] }, serverId: number) {
+    let { rankReceived = [] } = role;
 
     let res = {
         role: new Array<GeneralRankParamRole>(),
         battle: new Array<GeneralRankParamBattle>()
     };
 
-    for(let { id, general } of gameData.rank) {
+    for (let { id, general } of gameData.rank) {
         let redisKey = RANK_TYPE_TO_KEY.get(id);
-        if(redisKey) {
+        if (redisKey) {
             let received = rankReceived.filter(rewardId => {
                 let dic = gameData.generalRankReward.get(rewardId);
                 return dic && dic.rankId == id;
             });
-            if(general == 1) {
+            if (general == 1) {
                 let r = new Rank(redisKey, { serverId }, false, 1);
-                let ranks = <RoleRankInfo[]> await r.getRankByRange();
-                if(ranks.length > 0) {
-                    let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false), received);
+                let ranks = <RoleRankInfo[]>await r.getRankByRange();
+                if (ranks.length > 0) {
+                    let param = new GeneralRankParamRole(id, ranks[0] || new RoleRankInfo({}, false), received);
                     res.role.push(param);
                 }
             } else if (general = 2) {
                 let r = new Rank(redisKey, { serverId }, false, 1);
-                let ranks = <RoleRankInfo[]> await r.getRankByRange();
+                let ranks = <RoleRankInfo[]>await r.getRankByRange();
                 let hero: HeroUpdate;
-                if(ranks.length > 0) {
+                if (ranks.length > 0) {
                     hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins');
-                    let param = new GeneralRankParamBattle(id, ranks[0]||new RoleRankInfo({}, false), hero, received);
+                    let param = new GeneralRankParamBattle(id, ranks[0] || new RoleRankInfo({}, false), hero, received);
                     res.battle.push(param);
                 }
             }
diff --git a/game-server/app/services/timeTaskService.ts b/game-server/app/services/timeTaskService.ts
index ac6a474bc..b6f0306f2 100644
--- a/game-server/app/services/timeTaskService.ts
+++ b/game-server/app/services/timeTaskService.ts
@@ -1,14 +1,14 @@
 
-import { scheduleJob, Job, scheduledJobs  } from 'node-schedule';
-import { SystemConfigModel } from '../db/SystemConfig';
-import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
+import { scheduleJob, Job, scheduledJobs } from 'node-schedule';
+import { PVPConfigModel } from '../db/SystemConfig';
+import PvpDefenseType, { PvpDefenseModel } from '../db/PvpDefense';
 import { PVP } from '../pubUtils/dicParam';
 import { nowSeconds, getAge, getTimeFun } from '../pubUtils/timeUtil';
 import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity } from '../pubUtils/data';
 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 SystemConfigModel.findSystemConfig();//系统全局参数表
-    if (!systemConfig) {
-        console.log('create season seasonNum = '+ systemConfig?.seasonNum);
-        let warIds = getPvpGkWarIds();
-        let warId = warIds[0];
-        seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS);
-        systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
-    } else {
-        seasonEndTime = systemConfig.seasonEndTime;
-        if (systemConfig.seasonEndTime - SETTLE_DIFF <= nowSeconds()) {//服务器启动时，检查当前时间是否大于实际结算的时间，若大于则重新开启定时任务，若小于则按照结束时间开启定时任务
-            seasonEndTime = <number>getTimeFun().getAfterDay(PVP.PVP_SEASON_DAYS);
-            console.log('update season seasonNum = '+ systemConfig.seasonNum);
-            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);//设置实际赛季结算时间
+    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);
 
-    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() {
-    setPvpSeasonResult();
+async function resetPVPTimer(seasonEndTime: number) {
+    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 }) {
-    console.log('exce setPvpSeasonResult'+ obj?.name);
-    let { seasonNum, seasonEndTime, oldSeasonEndTime } = await setNextPvpTime(obj?.notSetNext);//设置下个结算任务
+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);
+        let pvpDefenses = await PvpDefenseModel.getPvpDef(pageNum, page == maxPage ? lastPageNum : page);
         for (let pvpDefense of pvpDefenses) {
-            if (pvpDefense.seasonNum !== seasonNum) {
-                await setPvpDefResultOnTime(pvpDefense, seasonNum, oldSeasonEndTime, obj?.notPush);
+            if (pvpDefense.seasonNum !== systemConfig.seasonNum) {
+                await setPvpDefResultOnTime(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime, obj?.notPush);
             }
         }
     }
-    return { seasonNum, seasonEndTime, oldSeasonEndTime};
 }
 /**
  * pvp定时任务结算获得添加邮件信息
@@ -125,11 +169,11 @@ export async function setPvpSeasonResult(obj?:{ name:string, notSetNext?: boolea
 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});
+    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))],
+            params: [JSON.stringify(seasonNum), (rankLv > 1000 ? '999+' : JSON.stringify(rankLv))],
             goods: rankGoods, endTime: oldSeasonEndTime, notPush
         });
     if (!!heroGoods.length) //武将功勋奖励
@@ -146,7 +190,7 @@ export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNu
  * @param oldSeasonEndTime 
  * @param rankLv 
  */
-export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime:number, rankLv?:number) {
+export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, rankLv?: number) {
     let pvpRankRewards = getPvpRankRewards();
     let pvpHeroRewards = getPvpHeroRewards();
     if (!rankLv) {
@@ -162,7 +206,7 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
         pvpRankReward = getResultMaxRank();//最大排名等级挡位信息
     }
     let rankGoods = [];
-    if(pvpRankReward) {
+    if (pvpRankReward) {
         rankGoods = pvpRankReward.reward;//排名奖励
     }
     let heroGoods = [];
@@ -181,20 +225,24 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
                 });
             }
         }
-        score += heroScore.score; 
+        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, 
+    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信息
+        }, 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 {id, count};
-    }), rankGoods};
+    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结算，结算中未结算的，都按照最大排名挡位结算
@@ -202,60 +250,64 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
  * @param seasonNum 
  * @param oldSeasonEndTime 
  */
-export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime:number) {
+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 { 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) 
+    if (!!rankGoods.length)
         await sendMailByContent(MAIL_TYPE.PVP_RANK_REWARD, roleId, { params: [JSON.stringify(seasonNum), '999+'], goods: rankGoods, endTime: oldSeasonEndTime });
-    if (!!heroGoods.length) 
+    if (!!heroGoods.length)
         await sendMailByContent(MAIL_TYPE.PVP_RESULT, roleId, { params: [JSON.stringify(seasonNum)], goods: heroGoods, endTime: oldSeasonEndTime });
     return pvpDefense;
 }
+
 /**
- * 每周重置地图
+ * 新pvp赛季数据
  */
-export async function resetPvpWarId() {
-    // console.log('resetPvpWarId');
-    let systemConfig = await SystemConfigModel.findSystemConfig();
+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, 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) {
-    let { seasonEndTime, seasonNum } = await SystemConfigModel.findSystemConfig();
-    if (!!notSetNext) {
-        return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
-    }
-    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 };
+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) {
+        if ((item.max >= score || item.max == -1) && score >= item.min) {
             return item;
         }
     }
@@ -265,67 +317,51 @@ function getScore(arr, score) {
  * @param hour 
  */
 export async function resetPvpSeasonTime(hour: number) {
-    if (!!seasonJobId) {
-        seasonJobId.cancel();
-    }
-    let seasonEndTime = 0;
-    let seasonNum = 1;
-    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();
-    }
-    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
-    console.log('settleTime = ' + settleTime)
-    seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);
-    return { seasonEndTime, seasonNum };
+    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 };
 }
 
 
-async function resetPvpRanks() {
+export async function resetPvpRanks() {
     await initSingleRank(REDIS_KEY.PVP_RANK);
 }
 
 export async function reportOnlineSchedule() {
     let allRoles = await getAllOnlineRoles();
     console.log('reportOnlineSchedule all roles count: ', allRoles.length)
-    for(let { roleId, userCode, sid, pkgName } of allRoles) {
+    for (let { roleId, userCode, sid, pkgName } of allRoles) {
         let result = reportOneOnline(roleId, userCode, sid, pkgName);
-        if(!result) continue;
+        if (!result) continue;
     }
 }
 
 export async function reportOneOnline(roleId: string, userCode: string, sid: string, pkgName: string) {
 
     let result = await reportOnline(userCode, pkgName); // 连接sdk
-    if(!result || result.code == -1) return false;
+    if (!result || result.code == -1) return false;
 
     let user = await UserModel.findUserByUserCode(userCode);
-    if(!user) return false;
+    if (!user) return false;
     let { reportTime = new Date(), lastLoginTime = new Date(), guestTime, isGuest, hasAuthenticated, birthday } = user;
-    
+
     let age = getAge(birthday);
     let isAdult = age >= ADULT_AGE;
 
-    if(isGuest || !hasAuthenticated) {
-        let lastTime = lastLoginTime > reportTime? lastLoginTime.getTime(): reportTime.getTime();
-        let guestTimeInc = Math.floor((Date.now() - lastTime)/1000);
+    if (isGuest || !hasAuthenticated) {
+        let lastTime = lastLoginTime > reportTime ? lastLoginTime.getTime() : reportTime.getTime();
+        let guestTimeInc = Math.floor((Date.now() - lastTime) / 1000);
         user = await UserModel.updatePlayTime(userCode, guestTimeInc, result.total); // 记录时间
 
         guestTime = user.guestTime;
 
-        if ( guestTime > GUEST_MAX_TIME ) {
+        if (guestTime > GUEST_MAX_TIME) {
             pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, {
                 isGuest,
                 guestTime,                   // 游客已体验时间
@@ -333,10 +369,10 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
                 isAdult,                                // 是否已成年
                 todayPlayTime: result.total,            // 今天已游戏时长
                 type: ADDICTION_PREVENTION_CODE.GUEST,
-            }  ), [{uid: roleId, sid: sid}]);
+            }), [{ uid: roleId, sid: sid }]);
         }
     } else {
-        if(result.code != ADDICTION_PREVENTION_CODE.SUCCESS && result.age != -1) { // 未成年人防沉迷
+        if (result.code != ADDICTION_PREVENTION_CODE.SUCCESS && result.age != -1) { // 未成年人防沉迷
             user = await UserModel.updatePlayTime(userCode, 0, result.total, result.code); // 记录时间
 
             pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, {
@@ -346,7 +382,7 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
                 isAdult,                                // 是否已成年
                 todayPlayTime: result.total,            // 今天已游戏时长
                 type: result.code
-            }  ), [{uid: roleId, sid: sid}]);
+            }), [{ uid: roleId, sid: sid }]);
         }
     }
 }
@@ -357,32 +393,32 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
 async function guildActivitySchedule() {
     /***********guildActivitySchedule***********/
 
-    let dicGuildActivity = getTodayGuildActivity(); 
+    let dicGuildActivity = getTodayGuildActivity();
     await delGuildActivityRank(dicGuildActivity.id);
 
     scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule);
 
     let statusResult = getGuildActivityByDic(dicGuildActivity);
-    if(!statusResult) return;
+    if (!statusResult) return;
 
-    if(statusResult.status == GUILD_ACTIVITY_STATUS.START) {
+    if (statusResult.status == GUILD_ACTIVITY_STATUS.START) {
         // 断掉活动续期
-        if(!guildActSecondsJobId) {
-            if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
+        if (!guildActSecondsJobId) {
+            if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
                 guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/10 * * * * *`, gateActivitySeconds);
-            } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
+            } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
                 guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/10 * * * * *`, cityActivitySeconds);
-            } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+            } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
                 guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/1 * * * * *`, raceActivitySeconds);
             }
         }
 
-        if(!guildActEndJobId) {
-            if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
+        if (!guildActEndJobId) {
+            if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
                 guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, gateActivityEnd);
-            } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
+            } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
                 guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, cityActivityEnd);
-            } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+            } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
                 guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, raceActivityEnd);
             }
         }
@@ -396,15 +432,15 @@ async function guildActivityStartSchedule() {
 
 export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
     console.log('*******开始军团晚间活动****')
-    if(!dicGuildActivity) dicGuildActivity = getTodayGuildActivity();
-    if(!dicGuildActivity) return;
+    if (!dicGuildActivity) dicGuildActivity = getTodayGuildActivity();
+    if (!dicGuildActivity) return;
 
-    if(guildActSecondsJobId||guildActEndJobId) {
+    if (guildActSecondsJobId || guildActEndJobId) {
         return false
     }
 
     let servers = await getAllServers(); // 玩家serverId列表
-    if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
+    if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
         guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', gateActivitySeconds);
         // 结束时间
         guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, gateActivityEnd);
@@ -416,7 +452,7 @@ export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
 
         // 开始活动
         let guildServers = pinus.app.getServersByType('guild');
-        for(let serverId of servers) {
+        for (let serverId of servers) {
             let sid = dispatch(serverId.toString(), guildServers);
             await pinus.app.rpc.guild.guildActivityRemote.raceActivityStart.toServer(sid.id, serverId);
         }
@@ -426,7 +462,7 @@ export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
         guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, raceActivityEnd);
     }
 
-    for(let serverId of servers) {
+    for (let serverId of servers) {
         await sendGuildActivityStatus(serverId);
     }
     return true;
@@ -439,15 +475,15 @@ export async function gateActivityEnd() {
     console.log('*****gateActivityEnd');
     await sendEndMsgToAll();
     let servers = pinus.app.getServersByType('guild');
-    for(let { id } of servers) {
+    for (let { id } of servers) {
         await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
     }
 
-    if(guildActSecondsJobId) {
+    if (guildActSecondsJobId) {
         guildActSecondsJobId.cancel();
         guildActSecondsJobId = undefined;
     }
-    if(guildActEndJobId) {
+    if (guildActEndJobId) {
         guildActEndJobId.cancel();
         guildActEndJobId = undefined;
     }
@@ -457,7 +493,7 @@ export async function gateActivityEnd() {
 export async function gateActivitySeconds() {
     console.log('*****gateActivitySeconds')
     let servers = pinus.app.getServersByType('guild');
-    for(let { id } of servers) {
+    for (let { id } of servers) {
         await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.toServer(id, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
     }
 }
@@ -468,20 +504,20 @@ export async function cityActivityEnd() {
     console.log('*****cityActivityEnd');
     await sendEndMsgToAll();
     let servers = pinus.app.getServersByType('guild');
-    for(let { id } of servers) {
+    for (let { id } of servers) {
         await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
     }
 
     // 发完之后再做下周自动宣战
     let serverlists = await getAllServers();
-    for(let serverId of serverlists) {
+    for (let serverId of serverlists) {
         await autoDeclare(serverId);
     }
-    if(guildActSecondsJobId) {
+    if (guildActSecondsJobId) {
         guildActSecondsJobId.cancel();
         guildActSecondsJobId = undefined;
     }
-    if(guildActEndJobId) {
+    if (guildActEndJobId) {
         guildActEndJobId.cancel();
         guildActEndJobId = undefined;
     }
@@ -491,7 +527,7 @@ export async function cityActivityEnd() {
 export async function cityActivitySeconds() {
     console.log('*****cityActivitySeconds')
     let servers = pinus.app.getServersByType('guild');
-    for(let { id } of servers) {
+    for (let { id } of servers) {
         await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.toServer(id, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
     }
 }
@@ -502,15 +538,17 @@ export async function raceActivityEnd() {
     console.log('*****raceActivityEnd');
     await sendEndMsgToAll();
     let servers = pinus.app.getServersByType('guild');
-    for(let { id } of servers) {
+    for (let { id } of servers) {
         await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
     }
 
-    if(guildActSecondsJobId) {
+    if (guildActSecondsJobId) {
         guildActSecondsJobId.cancel();
         guildActSecondsJobId = undefined;
     }
-    if(guildActEndJobId) {
+    if (guildActEndJobId) {
+
+
         guildActEndJobId.cancel();
         guildActEndJobId = undefined;
     }
@@ -521,7 +559,7 @@ export async function raceActivitySeconds() {
     console.log('*****raveActivitySeconds')
     let servers = await getAllServers(); // 玩家serverId列表
     let guildServers = pinus.app.getServersByType('guild');
-    for(let serverId of servers) {
+    for (let serverId of servers) {
         let sid = dispatch(serverId.toString(), guildServers);
         await pinus.app.rpc.guild.guildActivityRemote.calWoodenHorseAndSend.toServer(sid.id, serverId);
     }
diff --git a/game-server/test/chat.test.ts b/game-server/test/chat.test.ts
index c3ba0c54e..d0a0e65cc 100644
--- a/game-server/test/chat.test.ts
+++ b/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) => {
diff --git a/shared/consts/constModules/sysConst.ts b/shared/consts/constModules/sysConst.ts
index e873f62be..51cec20df 100644
--- a/shared/consts/constModules/sysConst.ts
+++ b/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];
diff --git a/shared/db/SystemConfig.ts b/shared/db/SystemConfig.ts
index b07f57122..0bf3359ca 100644
--- a/shared/db/SystemConfig.ts
+++ b/shared/db/SystemConfig.ts
@@ -1,44 +1,45 @@
 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 {
-    @prop({ required: true, default: 1})
-    id: number;	
+export default class PVPConfig extends BaseModel {
+    @prop({ required: true, default: 1 })
+    id: number;
     @prop({ required: true })
     warId: number;					// 地图
     @prop({ required: true, default: 1 })
     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) {
-        const result: SystemConfigType = await SystemConfigModel.findOne({}).lean(lean);
+    public static async findCurPVPConfig() {
+        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) {
-        const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, { seasonEndTime, warId, seasonNum: 1 }, { upsert: true, new: true }).lean(lean);
+    public static async findPVPConfig(seasonNum: number) {
+        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) {
-        const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, update, { upsert: true, new: true }).lean(lean);
+    public static async createPVPConfig(seasonNum: number, seasonEndTime: number, warId: number) {
+        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) {
-        const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({},  { seasonEndTime, $inc: { seasonNum: 1 }, oldSeasonEndTime }, { upsert: true, new: true }).lean(lean);
+    public static async updatePVPConfig(seasonNum: number, update: { warId?: number, settleGuildWeeklyTime?: number }) {
+        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;
 };
\ No newline at end of file