207 lines
9.4 KiB
TypeScript
207 lines
9.4 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 } from '../pubUtils/data';
|
|
import { deepCopy, getRandomArr } from '../pubUtils/util';
|
|
import { getLvByScore } from './pvpService';
|
|
import { getMyRank, setRank, getRedis } from './redisService';
|
|
import { REDIS_KEY } from '../consts';
|
|
import { RankParam } from '../pubUtils/interface';
|
|
import { RoleModel } from '../db/Role';
|
|
import { MailModel, MailType } from '../db/Mail';
|
|
import { pinus } from 'pinus';
|
|
import { indexOf } from 'underscore';
|
|
import { PvpSeasonResultModel } from '../db/PvpSeasonResult'
|
|
const PER_SECOND = 1 * 1000;
|
|
const PER_DAY = 24 * 60 * 60;
|
|
const SETTLE_DIFF = 29 * 60;
|
|
const LIMIT_NUM = 1000;
|
|
var seasonJobId;
|
|
var warJobId;
|
|
var seasonEndTimeJobId;
|
|
export async function init() {
|
|
let seasonEndTime = 0;
|
|
let systemConfig = await SystemConfigModel.findSystemConfig();
|
|
if (!systemConfig) {
|
|
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()) {
|
|
await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
|
|
seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
|
|
systemConfig.seasonNum++;
|
|
await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum});
|
|
}
|
|
}
|
|
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
|
|
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
|
|
warJobId = scheduleJob("0 0 0 * * 3", resetPvpWarId);
|
|
}
|
|
|
|
export async function setPvpSeasonResult(obj:{ name:string, notSetNext?: boolean }) {
|
|
console.log('exce setPvpSeasonResult'+ obj?.name);
|
|
let { seasonNum, seasonEndTime } = await setNextPvpTime(obj?.notSetNext);
|
|
for (let page = 0; page < 3; page++) {
|
|
let pvpDefenses = await PvpDefenseModel.getPvpDef(500, page);
|
|
let addMails = new Array<MailType>();
|
|
let pushMessage = new Array<any>();
|
|
for (let pvpDefense of pvpDefenses) {
|
|
if (pvpDefense.seasonNum !== seasonNum) {
|
|
await setPvpDefResultOnTime(pvpDefense, seasonNum, seasonEndTime, addMails, pushMessage);
|
|
}
|
|
}
|
|
await MailModel.addMails(addMails);
|
|
for (let message of pushMessage) {
|
|
pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(message.sid, message.uid, message.route, message.data);
|
|
}
|
|
}
|
|
return { seasonNum, seasonEndTime };
|
|
}
|
|
|
|
export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number, addMails: Array<MailType>, pushMessage:Array<any>) {
|
|
let role = await RoleModel.findByRoleId(pvpDefense.roleId);
|
|
if (!role) {
|
|
return;
|
|
}
|
|
let { score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, seasonEndTime);
|
|
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime, seasonEndTime});
|
|
let { roleName, lv, vLv, headHid, sHid, title } = role;
|
|
let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
|
|
setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
|
|
//下发邮件
|
|
const doc = new MailModel();
|
|
const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: pvpDefense.seasonEndTime});
|
|
addMails.push(mail);
|
|
let key = 'login_roleId_' + pvpDefense.roleId;
|
|
let sid = await getRedis(key);
|
|
if (!!sid) {
|
|
pushMessage.push({route: 'onMailsAdd', data:[mail], uid: pvpDefense.roleId, sid});
|
|
}
|
|
return pvpDefense;
|
|
}
|
|
|
|
export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
|
|
let pvpRankRewards = getPvpRankRewards();
|
|
let pvpHeroRewards = getPvpHeroRewards();
|
|
let goods = [];
|
|
let rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId);// 排行榜排名
|
|
let oldPLv = getLvByScore(pvpDefense.heroScores);
|
|
let { challengeCnt, challengeRefTime } = pvpDefense;
|
|
let pvpRankReward = getScore(pvpRankRewards, rankLv);
|
|
let rankGoods = [];
|
|
if(pvpRankReward) {
|
|
goods = goods.concat(pvpRankReward.reward);
|
|
rankGoods = pvpRankReward.reward;
|
|
}
|
|
let heroGoods = [];
|
|
let score = 0;
|
|
for (let i = 0; i < pvpDefense.heroScores.length; i++) {
|
|
let heroScore = pvpDefense.heroScores[i];
|
|
let pvpHeroReward = getScore(pvpHeroRewards, heroScore.score);
|
|
if(pvpHeroReward) {
|
|
goods = goods.concat(pvpHeroReward.reward);
|
|
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: deepCopy(pvpDefense.heroScores),
|
|
seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: pvpDefense.seasonEndTime
|
|
}, heroGoods, rankGoods, show: true});
|
|
return { rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, seasonEndTime, goods};
|
|
}
|
|
|
|
export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
|
|
let role = await RoleModel.findByRoleId(pvpDefense.roleId);
|
|
if (!role) {
|
|
return;
|
|
}
|
|
let {score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, seasonEndTime);
|
|
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime, seasonEndTime});
|
|
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, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
|
|
//下发邮件
|
|
let sendTime = seasonEndTime - PVP.PVP_SEASON_DAYS * PER_DAY;
|
|
let mail = await MailModel.addMail({roleId, goods, sendName: '系统', mailId: 1, sendTime: sendTime});
|
|
let key = 'login_roleId_' + roleId;
|
|
let sid = await getRedis(key);
|
|
if (!!sid) {
|
|
pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(sid, pvpDefense.roleId, 'onMailsAdd', [mail]);
|
|
}
|
|
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 };
|
|
}
|
|
seasonEndTime = (PVP.PVP_SEASON_DAYS) * PER_DAY + seasonEndTime;
|
|
await SystemConfigModel.updateSeason(seasonEndTime);
|
|
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
|
|
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
|
|
return { seasonEndTime, seasonNum: seasonNum + 1 };
|
|
}
|
|
|
|
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});
|
|
}
|
|
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
|
|
console.log('settleTime = ' + settleTime)
|
|
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
|
|
return { seasonEndTime, seasonNum };
|
|
}
|