pvp: 更改pvpdefense结构

game-server/app/services/timeTaskService.ts

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