226 lines
11 KiB
TypeScript
226 lines
11 KiB
TypeScript
|
|
import { scheduleJob, Job } from 'node-schedule';
|
|
import { SystemConfigModel } from '../db/SystemConfig';
|
|
import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
|
|
import { PVP } from '../pubUtils/dicParam';
|
|
import { nowSeconds, getTodayZeroPoint } from '../pubUtils/timeUtil';
|
|
import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank } from '../pubUtils/data';
|
|
import { deepCopy, getRandomArr, resResult } from '../pubUtils/util';
|
|
import { getLvByScore } from './pvpService';
|
|
import { getMyRank, setRank, resetPvpRanks } from './redisService';
|
|
import { MAIL_TYPE, REDIS_KEY } from '../consts';
|
|
import { RankParam } from '../domain/rank';
|
|
import { RoleModel } from '../db/Role';
|
|
import { MailModel, MailType } from '../db/Mail';
|
|
import { pinus } from 'pinus';
|
|
import { indexOf } from 'underscore';
|
|
import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
|
|
import { settleGuildWeekly } from './guildService';
|
|
import { STATUS } from '../consts/statusCode';
|
|
import { getMailContent, sendMail } from './mailService';
|
|
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;
|
|
var warJobId;
|
|
var seasonEndTimeJobId;
|
|
let guildWeeklyJobId
|
|
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];//TODO随机地图
|
|
seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
|
|
systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
|
|
} else {
|
|
seasonEndTime = systemConfig.seasonEndTime;
|
|
if (systemConfig.seasonEndTime - SETTLE_DIFF <= nowSeconds()) {
|
|
seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
|
|
console.log('update season seasonNum = '+ systemConfig.seasonNum);
|
|
systemConfig.seasonNum++;
|
|
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(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
|
|
|
|
seasonEndTimeJobId = scheduleJob((seasonEndTime - PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
|
|
warJobId = scheduleJob("0 0 0 * * 3", resetPvpWarId);
|
|
console.log('execute season resetPvpRanks');
|
|
await resetPvpRanks();
|
|
|
|
// 周功勋结算任务
|
|
guildWeeklyJobId = scheduleJob('0 0 0 * * 1', settleGuildWeekly, { name: 'settleGuildWeekly' });
|
|
|
|
}
|
|
|
|
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);
|
|
let resultMaxRank = getResultMaxRank();
|
|
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 addMails = new Array<MailType>();
|
|
let pushMessage = new Array<any>();
|
|
for (let pvpDefense of pvpDefenses) {
|
|
if (pvpDefense.seasonNum !== seasonNum) {
|
|
await setPvpDefResultOnTime(pvpDefense, seasonNum, oldSeasonEndTime, addMails, pushMessage);
|
|
}
|
|
}
|
|
await MailModel.addMails(addMails);
|
|
if (obj?.notPush) {
|
|
continue;
|
|
}
|
|
for (let message of pushMessage) {
|
|
pinus.app.channelService.pushMessageByUids('onMailsAdd', resResult(STATUS.SUCCESS, { mails: message.data }), [{uid: message.uid, sid: message.sid}]);
|
|
}
|
|
}
|
|
return { seasonNum, seasonEndTime, oldSeasonEndTime};
|
|
}
|
|
|
|
export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, addMails: Array<MailType>, pushMessage:Array<any>) {
|
|
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 getMailContent(pvpDefense.roleId, MAIL_TYPE.PVP_RANK_REWARD, [JSON.stringify(seasonNum), JSON.stringify(rankLv)], rankGoods, addMails, pushMessage, oldSeasonEndTime);
|
|
if (!!heroGoods.length)
|
|
await getMailContent(pvpDefense.roleId, MAIL_TYPE.PVP_RESULT, [JSON.stringify(seasonNum)], heroGoods, addMails, pushMessage, oldSeasonEndTime);
|
|
return pvpDefense;
|
|
}
|
|
|
|
export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime:number, rankLv?:number) {
|
|
let pvpRankRewards = getPvpRankRewards();
|
|
let pvpHeroRewards = getPvpHeroRewards();
|
|
if (!rankLv) {
|
|
rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId);// 排行榜排名
|
|
}
|
|
let oldPLv = getLvByScore(pvpDefense.heroScores);
|
|
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);
|
|
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 });
|
|
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};
|
|
}
|
|
|
|
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 { roleName, lv, vLv, headHid, sHid, title , roleId } = role;
|
|
let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
|
|
setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
|
|
//下发邮件
|
|
if (!!rankGoods.length)
|
|
await sendMail(MAIL_TYPE.PVP_RANK_REWARD, roleId, '系统', [JSON.stringify(seasonNum), JSON.stringify(pLv)], rankGoods, oldSeasonEndTime);
|
|
if (!!heroGoods.length)
|
|
await sendMail(MAIL_TYPE.PVP_RESULT, roleId, '系统', [JSON.stringify(seasonNum)], heroGoods, oldSeasonEndTime);
|
|
return pvpDefense;
|
|
}
|
|
|
|
export async function resetPvpWarId() {
|
|
console.log('resetPvpWarId');
|
|
let systemConfig = await SystemConfigModel.findSystemConfig();
|
|
let warIds = deepCopy(getPvpGkWarIds());
|
|
let index = indexOf(warIds, systemConfig.warId);
|
|
if (index != -1) {
|
|
warIds.splice(index, 1);
|
|
}
|
|
let res = getRandomArr(warIds, 1);
|
|
let warId = res[0];//TODO随机地图
|
|
return await SystemConfigModel.updateSystemConfig({ warId });
|
|
}
|
|
|
|
async function setNextPvpTime(notSetNext: boolean) {
|
|
let { seasonEndTime, seasonNum } = await SystemConfigModel.findSystemConfig();
|
|
if (!!notSetNext) {
|
|
return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
|
|
}
|
|
let oldSeasonEndTime = seasonEndTime;
|
|
seasonEndTime = (PVP.PVP_SEASON_DAYS + 1) * PER_DAY + getTodayZeroPoint();
|
|
await SystemConfigModel.updateSeason(seasonEndTime, oldSeasonEndTime);
|
|
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
|
|
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
|
|
seasonEndTimeJobId = scheduleJob((seasonEndTime - PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
|
|
return { seasonEndTime, seasonNum: seasonNum + 1, oldSeasonEndTime };
|
|
}
|
|
|
|
function getScore(arr, score) {
|
|
for (let item of arr) {
|
|
if ((item.max >= score||item.max == -1) && score >= item.min) {
|
|
return item;
|
|
}
|
|
}
|
|
}
|
|
|
|
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];//TODO随机地图
|
|
seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
|
|
systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
|
|
} else {
|
|
seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
|
|
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(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
|
|
return { seasonEndTime, seasonNum };
|
|
} |