526 lines
22 KiB
TypeScript
526 lines
22 KiB
TypeScript
|
|
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 { RoleModel } from '../db/Role';
|
|
import { pinus } from 'pinus';
|
|
import { indexOf } from 'underscore';
|
|
import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
|
|
import { settleGuildWeekly } from './guildService';
|
|
import { sendMailByContent } from './mailService';
|
|
import { getGuildActivityByDic, sendEndMsgToAll, autoDeclare, sendGuildActivityStatus } from './guildActivityService';
|
|
import { sendUngotDividendJob, startGuildAuction, startWorldAuction, stopAuction } from './auctionService';
|
|
import { DicGuildActivity } from '../pubUtils/dictionary/DicGuildActivity';
|
|
import { dispatch } from '../pubUtils/dispatcher';
|
|
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';
|
|
import { reportOneOnline } from './authenticateService';
|
|
|
|
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 seasonMakeRewardTimJobId: Job;
|
|
var warJobId: Job;
|
|
var seasonRefreshTimeJobId: Job;
|
|
let guildWeeklyJobId: Job;
|
|
let guildActStartJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
|
|
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 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();//服务器重启，重置排行榜的信息
|
|
|
|
// 周功勋结算任务
|
|
guildWeeklyJobId = scheduleJob('settleGuildWeekly', '0 0 0 * * 1', settleGuildWeekly);
|
|
|
|
// 每5分钟汇报在线玩家在线情况
|
|
scheduleJob('reportOnline', '0 0/5 * * * *', reportOnlineSchedule);
|
|
|
|
// 军团活动排行榜
|
|
guildActivitySchedule();
|
|
|
|
// 拍卖行刷新：拍卖阶段刷新，分红发放
|
|
auctionSchedule();
|
|
|
|
// 每天5点推送刷新时间消息
|
|
// 顺便每天0点计算前一天活跃玩家中位数战力
|
|
scheduleJob('everyDayRefresh', `0 0 ${REFRESH_TIME} * * ?`, everydayRefresh);
|
|
|
|
// 跑马灯
|
|
await initMarquee();
|
|
|
|
// 维护信息
|
|
await initMaintenance();
|
|
}
|
|
|
|
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 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);
|
|
}
|
|
|
|
export async function reportOnlineSchedule() {
|
|
let allRoles = await getAllOnlineRoles();
|
|
console.log('reportOnlineSchedule all roles count: ', allRoles.length)
|
|
for (let { roleId, userCode, sid } of allRoles) {
|
|
let result = reportOneOnline(roleId, userCode, sid, false);
|
|
if (!result) continue;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 军团活动，每晚8点开启
|
|
*/
|
|
export async function guildActivitySchedule() {
|
|
/***********guildActivitySchedule***********/
|
|
if (guildActStartJobId) {
|
|
guildActStartJobId.cancel();
|
|
}
|
|
if (guildActSecondsJobId) {
|
|
guildActSecondsJobId.cancel();
|
|
guildActSecondsJobId = undefined;
|
|
}
|
|
if (guildActEndJobId) {
|
|
guildActEndJobId.cancel();
|
|
guildActEndJobId = undefined;
|
|
}
|
|
|
|
let dicGuildActivity = getTodayGuildActivity();
|
|
await delGuildActivityRank(dicGuildActivity.id);
|
|
|
|
console.log(dicGuildActivity)
|
|
|
|
guildActStartJobId = scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule);
|
|
}
|
|
|
|
// 军团晚间活动，每天8点开始
|
|
async function guildActivityStartSchedule() {
|
|
await guildActivityStart();
|
|
}
|
|
|
|
export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
|
|
console.log('*******开始军团晚间活动****')
|
|
if (!dicGuildActivity) dicGuildActivity = getTodayGuildActivity();
|
|
if (!dicGuildActivity) return;
|
|
|
|
console.log('********', dicGuildActivity.id, Date.now() + dicGuildActivity.duringTime * 1000)
|
|
let servers = await getAllServers(); // 玩家serverId列表
|
|
if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
|
|
guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', gateActivitySeconds);
|
|
// 结束时间
|
|
guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, gateActivityEnd);
|
|
} else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
|
|
guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', cityActivitySeconds);
|
|
// 结束时间
|
|
guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, cityActivityEnd);
|
|
} else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
|
|
|
|
// 开始活动
|
|
let guildServers = pinus.app.getServersByType('guild');
|
|
for (let serverId of servers) {
|
|
let sid = dispatch(serverId.toString(), guildServers, 'guild');
|
|
await pinus.app.rpc.guild.guildActivityRemote.raceActivityStart.toServer(sid.id, serverId);
|
|
}
|
|
|
|
guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/1 * * * * *', raceActivitySeconds);
|
|
// 结束时间
|
|
guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, raceActivityEnd);
|
|
}
|
|
|
|
for (let serverId of servers) {
|
|
await sendGuildActivityStatus(serverId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// 蛮夷入侵
|
|
// 结束军团活动
|
|
export async function gateActivityEnd() {
|
|
|
|
console.log('*****gateActivityEnd');
|
|
await sendEndMsgToAll();
|
|
await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
|
|
|
|
if (guildActSecondsJobId) {
|
|
guildActSecondsJobId.cancel();
|
|
guildActSecondsJobId = undefined;
|
|
}
|
|
if (guildActEndJobId) {
|
|
guildActEndJobId.cancel();
|
|
guildActEndJobId = undefined;
|
|
}
|
|
}
|
|
|
|
// 每10秒下发一次的任务
|
|
export async function gateActivitySeconds() {
|
|
console.log('*****gateActivitySeconds')
|
|
await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.broadcast(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
|
|
}
|
|
|
|
// 诸侯混战
|
|
// 结束军团活动
|
|
export async function cityActivityEnd() {
|
|
console.log('*****cityActivityEnd');
|
|
await sendEndMsgToAll();
|
|
await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
|
|
|
|
// 发完之后再做下周自动宣战
|
|
let serverlists = await getAllServers();
|
|
for (let serverId of serverlists) {
|
|
await autoDeclare(serverId);
|
|
}
|
|
if (guildActSecondsJobId) {
|
|
guildActSecondsJobId.cancel();
|
|
guildActSecondsJobId = undefined;
|
|
}
|
|
if (guildActEndJobId) {
|
|
guildActEndJobId.cancel();
|
|
guildActEndJobId = undefined;
|
|
}
|
|
}
|
|
|
|
// 每10秒下发一次的任务
|
|
export async function cityActivitySeconds() {
|
|
console.log('*****cityActivitySeconds')
|
|
await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.broadcast(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
|
|
}
|
|
|
|
// 粮草先行
|
|
// 结束军团活动
|
|
export async function raceActivityEnd() {
|
|
console.log('*****raceActivityEnd');
|
|
await sendEndMsgToAll();
|
|
await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
|
|
|
|
if (guildActSecondsJobId) {
|
|
guildActSecondsJobId.cancel();
|
|
guildActSecondsJobId = undefined;
|
|
}
|
|
if (guildActEndJobId) {
|
|
guildActEndJobId.cancel();
|
|
guildActEndJobId = undefined;
|
|
}
|
|
}
|
|
|
|
// 每10秒下发一次的任务
|
|
export async function raceActivitySeconds() {
|
|
console.log('*****raveActivitySeconds')
|
|
let servers = await getAllServers(); // 玩家serverId列表
|
|
let guildServers = pinus.app.getServersByType('guild');
|
|
for (let serverId of servers) {
|
|
let sid = dispatch(serverId.toString(), guildServers, 'guild');
|
|
await pinus.app.rpc.guild.guildActivityRemote.calWoodenHorseAndSend.toServer(sid.id, serverId);
|
|
}
|
|
}
|
|
|
|
let startGuildAuctionJobId: Job;
|
|
let startWorldAuctionJobId: Job;
|
|
let stopAuctionJobId: Job;
|
|
let sendUngotDividendJobId: Job;
|
|
|
|
export function auctionSchedule() {
|
|
clearAuctionSchedule();
|
|
let guildOpen = gameData.auctionTime.get(AUCTION_TIME.GUILD_OPEN);
|
|
let worldOpen = gameData.auctionTime.get(AUCTION_TIME.WORLD_OPEN);
|
|
let worldClose = gameData.auctionTime.get(AUCTION_TIME.WORLD_CLOSE);
|
|
|
|
console.log('***** auctionSchedule', guildOpen.hour, guildOpen.minute, guildOpen.seconds);
|
|
console.log('***** auctionSchedule', worldOpen.hour, worldOpen.minute, worldOpen.seconds);
|
|
console.log('***** auctionSchedule', worldClose.hour, worldClose.minute, worldClose.seconds);
|
|
startGuildAuctionJobId = scheduleJob('startGuildAuction', `${guildOpen.seconds} ${guildOpen.minute} ${guildOpen.hour} * * ?`, startGuildAuction);
|
|
startWorldAuctionJobId = scheduleJob('startWorldAuction', `${worldOpen.seconds} ${worldOpen.minute} ${worldOpen.hour} * * ?`, startWorldAuction);
|
|
stopAuctionJobId = scheduleJob('stopAuction', `${worldClose.seconds} ${worldClose.minute} ${worldClose.hour} * * ?`, stopAuction);
|
|
sendUngotDividendJobId = scheduleJob('sendUngotDividendJob', '0 0 5 00 * ?', sendUngotDividendJob);
|
|
|
|
}
|
|
|
|
function clearAuctionSchedule() {
|
|
if (startGuildAuctionJobId) {
|
|
startGuildAuctionJobId.cancel();
|
|
startGuildAuctionJobId = undefined;
|
|
}
|
|
if (startWorldAuctionJobId) {
|
|
startWorldAuctionJobId.cancel();
|
|
startWorldAuctionJobId = undefined;
|
|
}
|
|
if (stopAuctionJobId) {
|
|
stopAuctionJobId.cancel();
|
|
stopAuctionJobId = undefined;
|
|
}
|
|
if (sendUngotDividendJobId) {
|
|
sendUngotDividendJobId.cancel();
|
|
sendUngotDividendJobId = undefined;
|
|
}
|
|
} |