xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pvp：重写pvp定时器任务逻辑

Browse Source
This commit is contained in:
qiaoxin
2021-07-20 19:07:48 +08:00
parent 05ffcdee7d
commit 1779f0ae33
8 changed files with 405 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-server/app/servers/battle/handler/pvpHandler.ts
+17 -10
View File
@@ -1,3 +1,4 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus'; import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { uniq, findWhere, findIndex } from 'underscore'; import { uniq, findWhere, findIndex } from 'underscore';
import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data'; import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
@@ -5,11 +6,10 @@ import { refreshEnemies, getEnemies, getLvByScore, defaultHeroes, comsumeChallen
import { RoleModel, RoleType } from '../../../db/Role'; import { RoleModel, RoleType } from '../../../db/Role';
import { STATUS } from '../../../consts/statusCode'; import { STATUS } from '../../../consts/statusCode';
import { resResult, genCode } from '../../../pubUtils/util'; import { resResult, genCode } from '../../../pubUtils/util';
import { PvpDefenseModel, OppPlayers } from '../../../db/PvpDefense'; import { PvpDefenseModel, OppPlayers } from '../../../db/PvpDefense';
import { pvpEndParamInter } from '../../../pubUtils/interface'; import { pvpEndParamInter } from '../../../pubUtils/interface';
import { PlayerDetail, PlayerDetailHero } from '../../../domain/battleField/guild'; 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 { PVP } from '../../../pubUtils/dicParam';
import { addItems } from '../../../services/rewardService'; import { addItems } from '../../../services/rewardService';
import { HeroModel } from '../../../db/Hero'; import { HeroModel } from '../../../db/Hero';
@@ -18,10 +18,10 @@ import { BattleRecordModel } from '../../../db/BattleRecord';
import { PvpRecordModel } from '../../../db/PvpRecord'; import { PvpRecordModel } from '../../../db/PvpRecord';
import { handleCost } from '../../../services/rewardService'; import { handleCost } from '../../../services/rewardService';
import { nowSeconds, getSeconds } from '../../../pubUtils/timeUtil'; 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 { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp'; import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
import { SystemConfigModel } from '../../../db/SystemConfig'; import { PVPConfigModel } from '../../../db/SystemConfig';
import { Rank } from '../../../services/rankService'; import { Rank } from '../../../services/rankService';
import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService'; import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
@@ -75,8 +75,9 @@ export class PvpHandler {
} }
async debugPvpSeasonReset(msg: {}, session: BackendSession) { async debugPvpSeasonReset(msg: {}, session: BackendSession) {
let { seasonNum, seasonEndTime } = await setPvpSeasonResult({ name: 'exce setPvpSeasonResult debug' }); await pvpSeasonEnd({ name: 'exce setPvpSeasonResult debug' });
return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime }) let systemConfig = await createNextPvpSeason();
return resResult(STATUS.SUCCESS, { seasonNum: systemConfig.seasonNum, seasonEndTime: systemConfig.seasonEndTime })
} }
async debugPvpWarReset(msg: {}, session: BackendSession) { async debugPvpWarReset(msg: {}, session: BackendSession) {
@@ -100,6 +101,7 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime }); return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
} }
//1获取主界面
async getData(msg: {}, session: BackendSession) { async getData(msg: {}, session: BackendSession) {
let roleId = session.get('roleId'); let roleId = session.get('roleId');
let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId); let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
@@ -200,7 +202,7 @@ export class PvpHandler {
const pvpDefense = await PvpDefenseModel.findByRoleId(roleId); const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN); 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); let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
if (challengeCnt == 0) { if (challengeCnt == 0) {
return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH); return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
@@ -286,7 +288,7 @@ export class PvpHandler {
await BattleRecordModel.updateBattleRecordByCode(battleCode, { await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess ? 1 : 2 } $set: { status: isSuccess ? 1 : 2 }
}, true); }, true);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig(); let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
// 减少挑战次数 // 减少挑战次数
let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime); 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) { async saveDefense(msg: { heroes: Array<{ actorId: number, dataId: number, order: number }>, isDefaultHero: boolean }, session: BackendSession) {
let { heroes, isDefaultHero } = msg; let { heroes, isDefaultHero } = msg;
let roleId = session.get('roleId'); let roleId = session.get('roleId');
@@ -330,7 +333,7 @@ export class PvpHandler {
heroes = uniq(heroes, function (item) { heroes = uniq(heroes, function (item) {
return item.order; 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 { heroes: defHeros, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
let defCe = 0; let defCe = 0;
let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime); let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
@@ -404,6 +407,7 @@ export class PvpHandler {
} }
//8. 排行榜
async getRank(msg: {}, session: BackendSession) { async getRank(msg: {}, session: BackendSession) {
let roleId = session.get('roleId'); let roleId = session.get('roleId');
@@ -420,6 +424,7 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { ranks, myRank }); return resResult(STATUS.SUCCESS, { ranks, myRank });
} }
//2.5. 获取对手详细信息（排行榜，战报，阵容查看）
async getPlayerDetail(msg: { roleId: string }, session: BackendSession) { async getPlayerDetail(msg: { roleId: string }, session: BackendSession) {
let roleId = session.get('roleId'); let roleId = session.get('roleId');
@@ -470,13 +475,14 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, result); return resResult(STATUS.SUCCESS, result);
} }
//7. 领取巅峰之路奖励
async receiveBox(msg: { id: number }, session: BackendSession) { async receiveBox(msg: { id: number }, session: BackendSession) {
let { id } = msg; let { id } = msg;
let roleId = session.get('roleId'); let roleId = session.get('roleId');
let sid: string = session.get('sid'); let sid: string = session.get('sid');
let roleName = session.get('roleName'); let roleName = session.get('roleName');
const funcs: number[] = session.get('funcs'); 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 { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let pvpBoxs = getPvpBoxs(); let pvpBoxs = getPvpBoxs();
let pvpBox = findWhere(pvpBoxs, { id }); let pvpBox = findWhere(pvpBoxs, { id });
@@ -495,6 +501,7 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime }); return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });
} }
//9. 战报
async getRec(msg: {}, session: BackendSession) { async getRec(msg: {}, session: BackendSession) {
let roleId = session.get('roleId'); let roleId = session.get('roleId');
let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId); let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId);
game-server/app/services/guildService.ts
+11 -9
View File
@@ -1,11 +1,11 @@
import { gameData, getGuildActiveWeekReward, getGuildActiveByIdAndType, getGoodById } from "../pubUtils/data"; import { gameData, getGuildActiveWeekReward, getGuildActiveByIdAndType, getGoodById } from "../pubUtils/data";
import { GuildModel, GuildType } from "../db/Guild"; import { GuildModel, GuildType } from "../db/Guild";
import { resResult, shouldRefresh } from "../pubUtils/util"; 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 { RoleModel, RoleType } from "../db/Role";
import { UserGuildModel, UserGuildType } from "../db/UserGuild"; import { UserGuildModel, UserGuildType } from "../db/UserGuild";
import { UserGuildApplyModel } from "../db/UserGuildApply"; import { UserGuildApplyModel } from "../db/UserGuildApply";
import { SystemConfigModel } from "../db/SystemConfig"; import { PVPConfigModel } from "../db/SystemConfig";
import { nowSeconds } from "../pubUtils/timeUtil"; import { nowSeconds } from "../pubUtils/timeUtil";
import { pinus, BackendSession, FrontendOrBackendSession } from "pinus"; import { pinus, BackendSession, FrontendOrBackendSession } from "pinus";
import { ARMY } from "../pubUtils/dicParam"; import { ARMY } from "../pubUtils/dicParam";
@@ -17,6 +17,7 @@ import { DATA_NAME } from '../consts/dataName';
import { addRoleToGuildChannel } from "./chatService"; import { addRoleToGuildChannel } from "./chatService";
import { Rank } from "./rankService"; import { Rank } from "./rankService";
import { checkActivityTask, checkTask } from "./taskService"; 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) { export async function getMyGuildInfo(roleId: string, sid: string, userGuild: UserGuildType, guild: GuildType, serverId: number, session: FrontendOrBackendSession) {
@@ -24,10 +25,10 @@ export async function getMyGuildInfo(roleId: string, sid: string, userGuild: Use
let leaderIsOnline = await isRoleOnline(leader.roleId); let leaderIsOnline = await isRoleOnline(leader.roleId);
// 打开公会页面，加入channel // 打开公会页面，加入channel
if(userGuild.guildCode) { if (userGuild.guildCode) {
addRoleToGuildChannel(roleId, sid, guild.code); addRoleToGuildChannel(roleId, sid, guild.code);
session.set('guildCode', 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; 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 } };
} }
/** /**
@@ -304,7 +305,8 @@ export async function settleGuildWeekly() {
res.releaseCallback();//解锁 res.releaseCallback();//解锁
} }
await initSingleRank(REDIS_KEY.GUILD_ACTIVE_RANK); 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结束 —————'); console.log('————— settleGuildWeekly结束 —————');
} }
@@ -314,10 +316,10 @@ export async function getWishPool(userGuild: UserGuildType) {
let userGuilds = await UserGuildModel.getWishPoolGoods(code, ' wishDntCnt wishGoods roleId'); let userGuilds = await UserGuildModel.getWishPoolGoods(code, ' wishDntCnt wishGoods roleId');
let list = []; let list = [];
userGuilds.map(({ wishGoods, roleId })=>{ userGuilds.map(({ wishGoods, roleId }) => {
wishGoods.map(({ type, goodId, count, receiveCnt, drawCnt, id })=>{ wishGoods.map(({ type, goodId, count, receiveCnt, drawCnt, id }) => {
list.push({ type, goodId, count, receiveCnt, drawCnt, id, roleId }) list.push({ type, goodId, count, receiveCnt, drawCnt, id, roleId })
}); });
}); });
return { list, wishDntCnt:wishDntCnt||0, wishGoods }; return { list, wishDntCnt: wishDntCnt || 0, wishGoods };
} }
game-server/app/services/pvpService.ts
+105 -98
View File
@@ -1,14 +1,14 @@
import { PvpDefenseModel, Heroes, OppPlayers, PvpDefenseType, HeroScores, pvpUpdateInter } from '../db/PvpDefense'; import { PvpDefenseModel, Heroes, OppPlayers, PvpDefenseType, HeroScores, pvpUpdateInter } from '../db/PvpDefense';
import { RoleType } from '../db/Role'; 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 { setPvpDefResult } from '../services/timeTaskService';
import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent"; import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
import { getRandSingleIndex, genCode, shouldRefresh, getChineseName } from '../pubUtils/util'; import { getRandSingleIndex, genCode, shouldRefresh, getChineseName } from '../pubUtils/util';
import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface'; import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface';
import { gameData, getPLvByScore } from "../pubUtils/data"; import { gameData, getPLvByScore } from "../pubUtils/data";
import { PVP } from '../pubUtils/dicParam'; import { PVP } from '../pubUtils/dicParam';
import { SystemConfigModel } from '../db/SystemConfig' import { PVPConfigModel } from '../db/SystemConfig'
import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil'; import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
import { HeroesRecord } from '../db/PvpRecord'; import { HeroesRecord } from '../db/PvpRecord';
import { HeroModel } from '../db/Hero'; import { HeroModel } from '../db/Hero';
@@ -19,6 +19,7 @@ import { findWhere, findIndex } from 'underscore';
import { pinus } from 'pinus'; import { pinus } from 'pinus';
import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp'; import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp';
import { Rank } from './rankService'; import { Rank } from './rankService';
import { CounterModel } from '../db/Counter';
export async function getPvpData() { 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++) { for (let i = PVP_HERO_POS.START; i <= PVP_HERO_POS.END; i++) {
let index = i - PVP_HERO_POS.START; let index = i - PVP_HERO_POS.START;
let item = role.topLineup[index]; let item = role.topLineup[index];
if(item) defCe += item.ce; if (item) defCe += item.ce;
heroes.push({ heroes.push({
actorId: item?.hid||0, actorId: item?.hid || 0,
hero: item?.hero||null, hero: item?.hero || null,
ce: item?.ce||0, ce: item?.ce || 0,
dataId: i, dataId: i,
order: index + 1, order: index + 1,
}); });
} }
//初始化对手人阵容 //初始化对手人阵容
let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 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 challengeCnt = PVP.PVP_CHALLENGE_COUNTS;
let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe, seasonNum, challengeCnt }); 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) { export async function checkPvp(role: RoleType) {
if(role.hasInit) { if (role.hasInit) {
let result = await PvpDefenseModel.findByRoleId(role.roleId, true); let result = await PvpDefenseModel.findByRoleId(role.roleId, true);
if (!!result) if (!!result)
return result; return result;
@@ -73,10 +74,10 @@ export async function checkPvp(role: RoleType) {
export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number) { export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number) {
let result = new Array<oppPlayersInter>(); let result = new Array<oppPlayersInter>();
for(let oppPlayer of oppPlayers) { for (let oppPlayer of oppPlayers) {
let dicOpponent = dicPvpOpponent.get(oppPlayer.pos); let dicOpponent = dicPvpOpponent.get(oppPlayer.pos);
let oppDef = <PvpHistoryOppType>oppPlayer.oppDef; // select 'oppRoleId pos roleName head frame spine rankLv pLv defCe' 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({ result.push({
...oppDef, ...oppDef,
roleId: oppDef.oppRoleId, roleId: oppDef.oppRoleId,
@@ -96,22 +97,22 @@ export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number)
* @param pLv 我的排名 * @param pLv 我的排名
*/ */
export async function refreshEnemies(role: RoleType, score: number, pLv: number) { 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 mapWarJson = gameData.warJson.get(system.warId);
let { roleId } = role; let { roleId } = role;
let oppPlayers = new Array<OppPlayers>(); let oppPlayers = new Array<OppPlayers>();
let opp = dicPvpOpponent.values() let opp = dicPvpOpponent.values()
for(let dicOpp of opp) { for (let dicOpp of opp) {
let flag = false; // 是否筛选成功 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); // 按照等级匹配对手 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 matchPlayerByRank(system.seasonNum, oppPlayers, mapWarJson, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
if(!flag) flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp); if (!flag) flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
} else { } else {
flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp); flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
} }
if(!flag) continue; if (!flag) continue;
} }
return oppPlayers; return oppPlayers;
@@ -121,58 +122,58 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
// console.log('matchPlayerByRank', JSON.stringify(oppPlayers)) // console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
let r = new Rank(REDIS_KEY.PVP_RANK, {}); let r = new Rank(REDIS_KEY.PVP_RANK, {});
let ridRanks = new Array<number>(); // 已经被使用了的排名 let ridRanks = new Array<number>(); // 已经被使用了的排名
for(let { roleId: curRoleId } of oppPlayers) { for (let { roleId: curRoleId } of oppPlayers) {
let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId)}); let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId) });
ridRanks.push(rankLv); ridRanks.push(rankLv);
} }
let myRank = await r.getMyRank({roleId}); let myRank = await r.getMyRank({ roleId });
ridRanks.push(myRank); ridRanks.push(myRank);
let oppRoleId = ''; let oppRoleId = '';
let oppRank = 0; let oppRank = 0;
if(myRank == 0) { if (myRank == 0) {
return false return false
} else if(myRank == 1) { // 第一名 } else if (myRank == 1) { // 第一名
if(pos == 1) { if (pos == 1) {
oppRank = 2; oppRank = 2;
while(ridRanks.includes(oppRank)) { while (ridRanks.includes(oppRank)) {
oppRank --; oppRank--;
} }
} else if(pos == 2) { } else if (pos == 2) {
oppRank = 3; oppRank = 3;
while(ridRanks.includes(oppRank)) { while (ridRanks.includes(oppRank)) {
oppRank --; oppRank--;
} }
} else { } else {
oppRank = 4; oppRank = 4;
while(ridRanks.includes(oppRank)) { while (ridRanks.includes(oppRank)) {
oppRank ++; oppRank++;
} }
} }
} else if(myRank == 0){ } else if (myRank == 0) {
return false return false
} else { } else {
if(pos == 1 || pos == 2) { // 刷新我前一名 if (pos == 1 || pos == 2) { // 刷新我前一名
oppRank = myRank - 1; oppRank = myRank - 1;
while(ridRanks.includes(oppRank)) { while (ridRanks.includes(oppRank)) {
oppRank --; oppRank--;
} }
} else { // 刷新我后一名 } else { // 刷新我后一名
oppRank = myRank + 1; oppRank = myRank + 1;
while(ridRanks.includes(oppRank)) { while (ridRanks.includes(oppRank)) {
oppRank ++; oppRank++;
} }
} }
} }
let result = await r.getUserByRank(oppRank); let result = await r.getUserByRank(oppRank);
if(result.length <= 0) return false; if (result.length <= 0) return false;
oppRoleId = result[0]; oppRoleId = result[0];
let pvpdefense = await PvpDefenseModel.findByRoleIdIncludeAll(oppRoleId); 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); let pvpHistoryOpp = await generPlayerOppHis(pvpdefense, mapWarJson, roleId, pos);
if(!pvpHistoryOpp) return false; if (!pvpHistoryOpp) return false;
oppPlayers.push({ oppPlayers.push({
roleId: pvpHistoryOpp.oppRoleId, roleId: pvpHistoryOpp.oppRoleId,
@@ -183,7 +184,7 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
return true 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)) // console.log('matchPlayer', JSON.stringify(oppPlayers))
let { id: pos, minLv, maxLv } = dicOpp let { id: pos, minLv, maxLv } = dicOpp
@@ -191,19 +192,19 @@ async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJs
range = range.filter(cur => { range = range.filter(cur => {
return oppPlayers.findIndex(ccur => ccur.roleId == makeRobotId(cur.roleId)) == -1; 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 index = getRandSingleIndex(range.length);
let result = range[index]; // 本次匹配结果 pvpdefense let result = range[index]; // 本次匹配结果 pvpdefense
if(!result) return false; if (!result) return false;
if(result.roleId == roleId) { if (result.roleId == roleId) {
range.splice(index, 1); range.splice(index, 1);
if(range.length <= 0) return false; if (range.length <= 0) return false;
index = getRandSingleIndex(range.length); index = getRandSingleIndex(range.length);
result = range[index]; result = range[index];
} }
let pvpHistoryOpp = await generPlayerOppHis(result, mapWarJson, roleId, pos); let pvpHistoryOpp = await generPlayerOppHis(result, mapWarJson, roleId, pos);
if(!pvpHistoryOpp) return false; if (!pvpHistoryOpp) return false;
oppPlayers.push({ oppPlayers.push({
roleId: pvpHistoryOpp.oppRoleId, roleId: pvpHistoryOpp.oppRoleId,
oppDef: pvpHistoryOpp._id, oppDef: pvpHistoryOpp._id,
@@ -225,25 +226,25 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, mapWarJson: DicWarJ
let role = <RoleType>pvpdefense.role; let role = <RoleType>pvpdefense.role;
let r = new Rank(REDIS_KEY.PVP_RANK, {}); let r = new Rank(REDIS_KEY.PVP_RANK, {});
let rankLv = await r.getMyRank({ roleId: role.roleId }); 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 heroes = new Array<PvpEnemies>();
let otherHeroes = new Array<PvpOtherHeroes>(); // 阵容外的所有武将信息 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 h = defenseHeroes.find(cur => cur.actorId == dbHero.hid); // 阵容里是否有这个武将
let hs = heroScores.find(cur => cur.hid == dbHero.hid); // 这个武将是否有这个得分 let hs = heroScores.find(cur => cur.hid == dbHero.hid); // 这个武将是否有这个得分
if(!!h) { if (!!h) {
let warJson = mapWarJson.find(cur => cur.dataId == h.dataId); let warJson = mapWarJson.find(cur => cur.dataId == h.dataId);
if(warJson && warJson.relation == 2) { if (warJson && warJson.relation == 2) {
let heroInfo = new PvpHeroInfo(); let heroInfo = new PvpHeroInfo();
heroInfo.setHeroInfo(dbHero); heroInfo.setHeroInfo(dbHero);
heroInfo.setOutIndex(h.order); heroInfo.setOutIndex(h.order);
let attribute = getPlayerAttribute(dbHero.attr, role.attr); let attribute = getPlayerAttribute(dbHero.attr, role.attr);
heroInfo.setAttribute(attribute); 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); heroes.push(enemy);
} }
} else { } else {
let heroInfo = new PvpOtherHeroes(hs?hs.score: 0); let heroInfo = new PvpOtherHeroes(hs ? hs.score : 0);
heroInfo.setHeroInfo(dbHero); heroInfo.setHeroInfo(dbHero);
otherHeroes.push(heroInfo); otherHeroes.push(heroInfo);
} }
@@ -263,22 +264,22 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
let { lv: myLv, topLineupCe: myCe, roleId } = role; let { lv: myLv, topLineupCe: myCe, roleId } = role;
let { id: pos, minLv, maxLv, ratio } = dicOpp; let { id: pos, minLv, maxLv, ratio } = dicOpp;
let range = gameData.pvpWar; let range = gameData.pvpWar;
if(range.length <= 0) return false; if (range.length <= 0) return false;
let index = getRandSingleIndex(range.length); let index = getRandSingleIndex(range.length);
let result = range[index]; let result = range[index];
if(!result) return false; if (!result) return false;
let robotWarjson = gameData.warJson.get(result.war_id); let robotWarjson = gameData.warJson.get(result.war_id);
if(!robotWarjson) { /* TODO 判空处理 */ } if (!robotWarjson) { /* TODO 判空处理 */ }
let heroes = new Array<PvpEnemies>(); let heroes = new Array<PvpEnemies>();
let defCe = 0; let defCe = 0;
for(let warJson of mapWarJson) { for (let warJson of mapWarJson) {
if(warJson.relation == 1) continue; if (warJson.relation == 1) continue;
let h = robotWarjson.find(cur => cur.dataId == warJson.dataId); let h = robotWarjson.find(cur => cur.dataId == warJson.dataId);
if(h) { if (h) {
let dicHero = gameData.hero.get(h.actorId); let dicHero = gameData.hero.get(h.actorId);
if(!dicHero) continue; if (!dicHero) continue;
let heroInfo = new PvpHeroInfo(); let heroInfo = new PvpHeroInfo();
heroInfo.setRobotInfo(h, myLv, dicHero.initialStars, dicHero.quality); heroInfo.setRobotInfo(h, myLv, dicHero.initialStars, dicHero.quality);
let attribute = getRobotAttribute(h.attribute, myCe, PVP_CONST.ENEMY_CE, ratio); 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 oppRoleId = generateRobotRoleId();
let roleName = getChineseName(); let roleName = getChineseName();
let hisPLv = Math.floor(pLv + (minLv + maxLv)/2); let hisPLv = Math.floor(pLv + (minLv + maxLv) / 2);
if(hisPLv < 1) hisPLv = 1 if (hisPLv < 1) hisPLv = 1
let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({ let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0 roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0
@@ -330,53 +331,53 @@ export function robotIdComBack(robotRoleId: string) {
// 根据连胜次数，获得加成的积分 // 根据连胜次数，获得加成的积分
export function getPlusScore(win: number) { export function getPlusScore(win: number) {
let result = win - 1; let result = win - 1;
if(result < 0) result = 0; if (result < 0) result = 0;
if(result > PVP.PVP_WINREWARD_UPLIMIT) result = PVP.PVP_WINREWARD_UPLIMIT; if (result > PVP.PVP_WINREWARD_UPLIMIT) result = PVP.PVP_WINREWARD_UPLIMIT;
return result; return result;
} }
export function getLvByScore(heroScores: HeroScores[]) { export function getLvByScore(heroScores: HeroScores[]) {
heroScores.sort((a, b) => b.score - a.score); heroScores.sort((a, b) => b.score - a.score);
let score = 0; let score = 0;
for(let i = 0; i < 5; i++) { for (let i = 0; i < 5; i++) {
if(!heroScores[i]) break; if (!heroScores[i]) break;
score += heroScores[i].score; score += heroScores[i].score;
} }
return getPLvByScore(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); let pvpDefense = await PvpDefenseModel.findByRoleId(role.roleId);
if(!pvpDefense) return; if (!pvpDefense) return;
let { heroes, isDefaultHero } = pvpDefense; let { heroes, isDefaultHero } = pvpDefense;
if (!isUpdate && !isDefaultHero) { if (!isUpdate && !isDefaultHero) {
return; return;
} }
let orders = [1, 2, 3, 4, 5, 6]; 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; return b.ce - a.ce;
}); });
heroes.sort(function(a, b) { heroes.sort(function (a, b) {
return b.ce - b.dataId - a.ce + a.dataId; return b.ce - b.dataId - a.ce + a.dataId;
}); });
for (let hero of heroes) { 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); let index = orders.indexOf(hero.order);
orders.splice(index, 1); orders.splice(index, 1);
} }
} }
let defCe = 0; let defCe = 0;
let num = 0; let num = 0;
for (let i = 0; i < role.topLineup.length; i++) { for (let i = 0; i < role.topLineup.length; i++) {
let item = role.topLineup[i]; let item = role.topLineup[i];
let index = findIndex(heroes, {actorId: item.hid}); let index = findIndex(heroes, { actorId: item.hid });
if (index == -1) { if (index == -1) {
for (let j = num; j < heroes.length; j++) { for (let j = num; j < heroes.length; j++) {
let hero = heroes[j]; let hero = heroes[j];
if (num >= 6) { if (num >= 6) {
break; break;
} }
if (!!findWhere(role.topLineup, {hid: hero.actorId})) { if (!!findWhere(role.topLineup, { hid: hero.actorId })) {
continue; continue;
} }
if (!orders[0]) { if (!orders[0]) {
@@ -401,68 +402,70 @@ export async function defaultHeroes ( role:RoleType, challengeCnt?:number, chall
defCe += item.ce; defCe += item.ce;
} }
if (!!challengeCnt && !!challengeRefTime) { if (!!challengeCnt && !!challengeRefTime) {
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes, challengeCnt, challengeRefTime, isDefaultHero:true}); let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, challengeCnt, challengeRefTime, isDefaultHero: true });
return { resHeroes}; return { resHeroes };
} else { } else {
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes, isDefaultHero:true}); let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, isDefaultHero: true });
return { resHeroes}; return { resHeroes };
} }
} }
export function refresh(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) { export function refresh(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) { if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
return {challengeCnt, challengeRefTime}; return { challengeCnt, challengeRefTime };
} }
let period = PVP.PVP_CHALLENGE_NORMALTIMES * 60; let period = PVP.PVP_CHALLENGE_NORMALTIMES * 60;
if (getTimeFun(seasonEndTime).checkDay()) { if (getTimeFun(seasonEndTime).checkDay()) {
period = PVP.PVP_CHALLENGE_FINALTIMES * 60; period = PVP.PVP_CHALLENGE_FINALTIMES * 60;
} }
let time = nowSeconds(); let time = nowSeconds();
let num = Math.floor(( time - challengeRefTime)/period); let num = Math.floor((time - challengeRefTime) / period);
if (num > 0) { if (num > 0) {
challengeCnt += num; challengeCnt += num;
challengeRefTime = challengeRefTime + period * num; challengeRefTime = challengeRefTime + period * num;
} }
challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS?PVP.PVP_CHALLENGE_COUNTS:challengeCnt; challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS ? PVP.PVP_CHALLENGE_COUNTS : challengeCnt;
return {challengeCnt, challengeRefTime}; return { challengeCnt, challengeRefTime };
} }
export function comsumeChallengeCnt( challengeCnt: number, challengeRefTime: number, seasonEndTime:number ) { export function comsumeChallengeCnt(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
challengeCnt--; challengeCnt--;
if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) { if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
return {challengeCnt, challengeRefTime}; return { challengeCnt, challengeRefTime };
} }
if (challengeCnt == PVP.PVP_CHALLENGE_COUNTS - 1) { if (challengeCnt == PVP.PVP_CHALLENGE_COUNTS - 1) {
challengeRefTime = nowSeconds(); challengeRefTime = nowSeconds();
return {challengeCnt, challengeRefTime}; return { challengeCnt, challengeRefTime };
} }
return refresh(challengeCnt, challengeRefTime, seasonEndTime); return refresh(challengeCnt, challengeRefTime, seasonEndTime);
} }
export async function findPvpDefByRoleId(roleId: string) { export async function findPvpDefByRoleId(roleId: string) {
let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId); 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()) { if (pvpDefense.seasonNum !== seasonNum && oldSeasonEndTime < nowSeconds()) {
let newPvpDefense = await setPvpDefResult(pvpDefense, seasonNum, oldSeasonEndTime); let newPvpDefense = await setPvpDefResult(pvpDefense, seasonNum, oldSeasonEndTime);
return {pvpDefense: newPvpDefense, warId}; return { pvpDefense: newPvpDefense, warId };
} }
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); // 刷新次数 let { refOppCnt, refOppTime, shouldRefOpp } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime); // 刷新次数
if (challengeCnt != pvpDefense.challengeCnt ||refOppCnt != pvpDefense.refOppCnt) { if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt) {
await PvpDefenseModel.updateInfo( roleId, { challengeCnt, challengeRefTime, refOppCnt}); await PvpDefenseModel.updateInfo(roleId, { challengeCnt, challengeRefTime, refOppCnt });
pvpDefense.challengeCnt = challengeCnt; pvpDefense.challengeCnt = challengeCnt;
pvpDefense.challengeRefTime = challengeRefTime; pvpDefense.challengeRefTime = challengeRefTime;
pvpDefense.refOppCnt = refOppCnt; pvpDefense.refOppCnt = refOppCnt;
pvpDefense.refOppTime = refOppTime; pvpDefense.refOppTime = refOppTime;
} }
return {pvpDefense, warId, shouldRefOpp}; return { pvpDefense, warId, shouldRefOpp };
} }
// 获取刷新对手次数及消耗 // 获取刷新对手次数及消耗
export function getRefOppCnt(refOppCnt: number, refOppTime: Date) { export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
let curTime = new Date(); let curTime = new Date();
let shouldRefOpp = shouldRefresh(refOppTime, curTime); let shouldRefOpp = shouldRefresh(refOppTime, curTime);
if(shouldRefOpp) { if (shouldRefOpp) {
refOppCnt = 0; refOppTime = curTime; refOppCnt = 0; refOppTime = curTime;
} }
return { return {
@@ -471,13 +474,17 @@ export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
consume: gameData.pvpRefreshConsume.get(refOppCnt + 1) consume: gameData.pvpRefreshConsume.get(refOppCnt + 1)
} }
} }
/** /**
* 获得玩家pvp信息，并检查是否在pvp赛季结算中结算过，未结算的进行结算 * 获得玩家pvp信息，并检查是否在pvp赛季结算中结算过，未结算的进行结算
* @param roleId * @param roleId
*/ */
export async function findPvpDefAllByRoleId(roleId: string) { export async function findPvpDefAllByRoleId(roleId: string) {
let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId); 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赛季结算中结算过 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); let { score, pLv, winStreakNum, heroScores, challengeCnt, challengeRefTime } = await pinus.app.rpc.systimer.systimerRemote.setPvpDefResult.toServer('systimer-server-1', pvpDefense, seasonNum, oldSeasonEndTime);
pvpDefense.score = score; pvpDefense.score = score;
@@ -488,20 +495,20 @@ export async function findPvpDefAllByRoleId(roleId: string) {
pvpDefense.challengeRefTime = challengeRefTime; pvpDefense.challengeRefTime = challengeRefTime;
} }
pvpDefense.seasonNum = seasonNum; 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); // 刷新次数 let { refOppCnt, refOppTime, shouldRefOpp } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime); // 刷新次数
if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt || shouldRefOpp) { if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt || shouldRefOpp) {
let update: pvpUpdateInter = { let update: pvpUpdateInter = {
challengeCnt, challengeRefTime, refOppCnt, refOppTime challengeCnt, challengeRefTime, refOppCnt, refOppTime
}; };
if(shouldRefOpp) { if (shouldRefOpp) {
let role = <RoleType>pvpDefense.role; let role = <RoleType>pvpDefense.role;
let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv); let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv);
update.oppPlayers = oppPlayers; update.oppPlayers = oppPlayers;
} }
let updateResult = await PvpDefenseModel.updateInfoAndInclude( roleId, update); let updateResult = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
pvpDefense.oppPlayers = updateResult.oppPlayers; pvpDefense.oppPlayers = updateResult.oppPlayers;
pvpDefense.challengeCnt = challengeCnt; pvpDefense.challengeCnt = challengeCnt;
pvpDefense.challengeRefTime = challengeRefTime; pvpDefense.challengeRefTime = challengeRefTime;
@@ -509,7 +516,7 @@ export async function findPvpDefAllByRoleId(roleId: string) {
pvpDefense.refOppTime = refOppTime; 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 enemyCe 出兵表对手战力
* @param ratio 系数 * @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(); let newAttribute = new Attribute();
newAttribute.setByWarJson(attribute, Math.sqrt(ce / enemyCe * ratio)); newAttribute.setByWarJson(attribute, Math.sqrt(ce / enemyCe * ratio));
@@ -584,7 +591,7 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
}); });
} else { } else {
showHeroScores.push({ 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'); 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) { export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayers, oppHeroes: pvpEndParamInter[], myLv: number) {
let oppHeroRecords = new Array<HeroesRecord>(); let oppHeroRecords = new Array<HeroesRecord>();
let oppRole = <PvpHistoryOppType>curOpp.oppDef; 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) { for (let { hid, damage, heal, underDamage } of oppHeroes) {
let historyHero = oppRole.heroes.find(cur => cur.actorId == hid); let historyHero = oppRole.heroes.find(cur => cur.actorId == hid);
if(historyHero) { if (historyHero) {
let hs = new HeroesRecord(historyHero, damage, heal, underDamage); let hs = new HeroesRecord(historyHero, damage, heal, underDamage);
oppHeroRecords.push(hs); oppHeroRecords.push(hs);
} }
game-server/app/services/rankService.ts
+65 -65
View File
@@ -4,7 +4,7 @@ import { redisClient, setUserInfo } from "./redisService";
import { RoleType, RoleModel } from "../db/Role"; import { RoleType, RoleModel } from "../db/Role";
import { GuildType, GuildModel } from "../db/Guild"; import { GuildType, GuildModel } from "../db/Guild";
import { HeroModel, HeroType, HeroUpdate } from "../db/Hero"; import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
import { SystemConfigModel } from "../db/SystemConfig"; import { PVPConfigModel } from "../db/SystemConfig";
import { PvpDefenseModel } from "../db/PvpDefense"; import { PvpDefenseModel } from "../db/PvpDefense";
import { gameData } from "../pubUtils/data"; import { gameData } from "../pubUtils/data";
import { nowSeconds } from "../pubUtils/timeUtil"; import { nowSeconds } from "../pubUtils/timeUtil";
@@ -238,9 +238,9 @@ export class Rank {
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true); role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
} }
let { dungeonWarId, dungeonHeroes } = role; let { dungeonWarId, dungeonHeroes } = role;
if(dungeonWarId > 0) { if (dungeonWarId > 0) {
let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId); 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 heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
let arr = new Array<LineupParam>(); let arr = new Array<LineupParam>();
for (let seqId of lineup) { for (let seqId of lineup) {
@@ -259,7 +259,7 @@ export class Rank {
let { showLineup, topLineup = [] } = role; let { showLineup, topLineup = [] } = role;
let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP); let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
let arr = new Array<LineupParam>(); 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) { for (let hid of showLineup) {
let curHero = heroes.find(cur => cur.hid == hid); let curHero = heroes.find(cur => cur.hid == hid);
if (curHero) { if (curHero) {
@@ -292,7 +292,7 @@ export class Rank {
*/ */
public async setRank(myId: myIdInter, score: number, timestamp: number, isInc = false) { public async setRank(myId: myIdInter, score: number, timestamp: number, isInc = false) {
let oldTop = await this.getRankByRank(0, 0); 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; let newScore = score;
if (this.isUnion) { if (this.isUnion) {
@@ -383,7 +383,7 @@ export class Rank {
} }
for (let extraKey of this.extraKeys) { 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); return await this.generFields(param);
@@ -408,7 +408,7 @@ export class Rank {
} }
for (let extraKey of this.extraKeys) { 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); return await this.generFields(param);
@@ -420,7 +420,7 @@ export class Rank {
let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId); let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
if (!hasCurUser) { if (!hasCurUser) {
if(!role) { if (!role) {
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true); role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
} }
param = new RoleRankInfo(role, true); param = new RoleRankInfo(role, true);
@@ -473,13 +473,13 @@ export class Rank {
let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId)); let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
if (!hasCurUser) { if (!hasCurUser) {
if(!hero) { if (!hero) {
hero = await HeroModel.findByHidAndRole(myId.hid, myId.roleId, HERO_SELECT.RANK_LINEUP); hero = await HeroModel.findByHidAndRole(myId.hid, myId.roleId, HERO_SELECT.RANK_LINEUP);
} }
let arr = new Array<LineupParam>(); let arr = new Array<LineupParam>();
let lineParam = new LineupParam(hero); let lineParam = new LineupParam(hero);
arr.push(lineParam); arr.push(lineParam);
if(this.key == REDIS_KEY.HERO_RANK) { if (this.key == REDIS_KEY.HERO_RANK) {
param.setSingleHero(arr); param.setSingleHero(arr);
} else { } else {
param.setTopLine(arr); param.setTopLine(arr);
@@ -487,7 +487,7 @@ export class Rank {
} else { } else {
const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId)); const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
const infoObj = JSON.parse(info); const infoObj = JSON.parse(info);
if(this.key == REDIS_KEY.HERO_RANK) { if (this.key == REDIS_KEY.HERO_RANK) {
param.setSingleHero(infoObj); param.setSingleHero(infoObj);
} else { } else {
param.setTopLine(infoObj); param.setTopLine(infoObj);
@@ -503,7 +503,7 @@ export class Rank {
} }
let { dungeonWarId, dungeonHeroes } = role; let { dungeonWarId, dungeonHeroes } = role;
let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId); 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 heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.RANK_LINEUP);
let arr = new Array<LineupParam>(); let arr = new Array<LineupParam>();
for (let seqId of lineup) { for (let seqId of lineup) {
@@ -531,7 +531,7 @@ export class Rank {
let { showLineup, topLineup = [] } = role; let { showLineup, topLineup = [] } = role;
let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL); let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
let arr = new Array<LineupParam>(); 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) { for (let hid of showLineup) {
let curHero = heroes.find(cur => cur.hid == hid); let curHero = heroes.find(cur => cur.hid == hid);
if (curHero) { if (curHero) {
@@ -579,7 +579,7 @@ export class Rank {
let num = 0; let num = 0;
for (let ii = 0; ii < rankFromDb.length; ii += 2) { for (let ii = 0; ii < rankFromDb.length; ii += 2) {
if(num >= this.limit) break; if (num >= this.limit) break;
const field = rankFromDb[ii]; const field = rankFromDb[ii];
let myId = this.decodeFields(this.key, field); let myId = this.decodeFields(this.key, field);
@@ -589,7 +589,7 @@ export class Rank {
let param: RoleRankInfo | GuildRankInfo; let param: RoleRankInfo | GuildRankInfo;
if (this.infoKey == REDIS_KEY.USER_INFO) { 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; continue;
} }
param = new RoleRankInfo(userInfo, false); param = new RoleRankInfo(userInfo, false);
@@ -603,7 +603,7 @@ export class Rank {
await this.setExInfoToParam(extraKey, param, myId, {}); await this.setExInfoToParam(extraKey, param, myId, {});
} }
ranks.push(param); ranks.push(param);
num ++; num++;
} }
return ranks return ranks
} }
@@ -620,7 +620,7 @@ export class Rank {
let num = 0; let num = 0;
for (let ii = 0; ii < rankFromDb.length; ii += 2) { for (let ii = 0; ii < rankFromDb.length; ii += 2) {
if(num >= this.limit) break; if (num >= this.limit) break;
const field = rankFromDb[ii]; const field = rankFromDb[ii];
let myId = this.decodeFields(this.key, field); let myId = this.decodeFields(this.key, field);
@@ -630,7 +630,7 @@ export class Rank {
let param: RoleRankInfo | GuildRankInfo; let param: RoleRankInfo | GuildRankInfo;
if (this.infoKey == REDIS_KEY.USER_INFO) { 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; continue;
} }
param = new RoleRankInfo(userInfo, false); param = new RoleRankInfo(userInfo, false);
@@ -644,7 +644,7 @@ export class Rank {
await this.setExInfoToParam(extraKey, param, myId, {}); await this.setExInfoToParam(extraKey, param, myId, {});
} }
ranks.push(param); ranks.push(param);
num ++; num++;
} }
return ranks return ranks
} }
@@ -658,7 +658,7 @@ export class Rank {
} }
// console.log('**getMyRank',key, this.composeFields(this.key, myId), this.key, myId) // console.log('**getMyRank',key, this.composeFields(this.key, myId), this.key, myId)
let myRank = await redisClient().zrevrankAsync(key, this.composeFields(this.key, myId)); let myRank = await redisClient().zrevrankAsync(key, this.composeFields(this.key, myId));
if(!myRank && myRank != 0) { if (!myRank && myRank != 0) {
return 0; return 0;
} else { } else {
return myRank + 1; return myRank + 1;
@@ -726,36 +726,36 @@ export class Rank {
private handleTimestamp(timestamp: number = 0) { private handleTimestamp(timestamp: number = 0) {
let l = timestamp.toString().length; let l = timestamp.toString().length;
if(l > this.timelen) { if (l > this.timelen) {
timestamp = Math.floor(timestamp / Math.pow(10, l - this.timelen)); timestamp = Math.floor(timestamp / Math.pow(10, l - this.timelen));
} }
return timestamp return timestamp
} }
private async checkMyRankAndPush(myId: myIdInter, oldScore: number, newScore: number) { private async checkMyRankAndPush(myId: myIdInter, oldScore: number, newScore: number) {
if(this.isInit) return; if (this.isInit) return;
let myRank = await this.getMyRank(myId); let myRank = await this.getMyRank(myId);
if(myRank == 1 && newScore > oldScore) { if (myRank == 1 && newScore > oldScore) {
let serverId = this.keyName.serverId; let serverId = this.keyName.serverId;
let sid = await getWorldChannelSid(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); let redisKey = RANK_TYPE_TO_KEY.get(id);
if(redisKey == this.key) { if (redisKey == this.key) {
if(general == 1) { if (general == 1) {
let r = new Rank(redisKey, { serverId }, false, 1); let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange(); let ranks = <RoleRankInfo[]>await r.getRankByRange();
if(ranks.length > 0) { if (ranks.length > 0) {
let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false)); let param = new GeneralRankParamRole(id, ranks[0] || new RoleRankInfo({}, false));
pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general}); pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, { ...param, general });
} }
} else if (general = 2) { } else if (general = 2) {
let r = new Rank(redisKey, { serverId }, false, 1); let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange(); let ranks = <RoleRankInfo[]>await r.getRankByRange();
let hero: HeroUpdate; let hero: HeroUpdate;
if(ranks.length > 0) { if (ranks.length > 0) {
hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins'); hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins');
let param = new GeneralRankParamBattle(id, ranks[0]||new RoleRankInfo({}, false), hero); let param = new GeneralRankParamBattle(id, ranks[0] || new RoleRankInfo({}, false), hero);
pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general}); pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, { ...param, general });
} }
} }
@@ -772,23 +772,23 @@ export class Rank {
* @param type 排行榜类型 * @param type 排行榜类型
* @param serverId 分服 * @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 serverId = args.serverId;
let ranks = await RoleModel.getRank('tower', serverId, ROLE_SELECT.RANK); let ranks = await RoleModel.getRank('tower', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
// console.log(roleId); // 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) { } else if (type == REDIS_KEY.GUILD_ACTIVE_RANK) {
let serverId = args.serverId; let serverId = args.serverId;
let ranks = await GuildModel.getRank(type, serverId); let ranks = await GuildModel.getRank(type, serverId);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let guild of ranks) { for (let guild of ranks) {
await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild); await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
} }
} else if (type == REDIS_KEY.GUILD_LV_RANK) { } 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 ranks = await GuildModel.getRank(type, serverId);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let guild of ranks) { for (let guild of ranks) {
await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild); await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild);
} }
} else if ( type == REDIS_KEY.PVP_RANK) { } else if (type == REDIS_KEY.PVP_RANK) {
let { seasonNum } = await SystemConfigModel.findSystemConfig(); let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
console.log('execute season resetPvpRanks seasonNum = ' + seasonNum); console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中 let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
let r = new Rank(type, {}); let r = new Rank(type, {});
r.setIsInit(true); 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; let role = <RoleType>_role;
if (!role) { if (!role) {
continue; 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 ranks = await RoleModel.getRank('topLineup', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
// console.log(roleId); // console.log(roleId);
await r.setRankWithRoleInfo(role.roleId, role.topLineupCe, role.updatedAt.getTime(), role); 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 ranks = await HeroModel.getAllRank(serverId, HERO_SELECT.RANK_LINEUP);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); 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); await r.setRankWithHeroInfo(hero.roleId, hero.hid, hero.ce, hero.updatedAt.getTime(), hero);
} }
} else if (type == REDIS_KEY.HERO_NUM_RANK) { } 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 ranks = await RoleModel.getRank('heroNum', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role ); await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role);
} }
} else if (type == REDIS_KEY.USER_LV) { } else if (type == REDIS_KEY.USER_LV) {
let serverId = args.serverId; let serverId = args.serverId;
let ranks = await RoleModel.getRank('lv', serverId, ROLE_SELECT.RANK); let ranks = await RoleModel.getRank('lv', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.lv, role.updatedAt.getTime(), role); await r.setRankWithRoleInfo(role.roleId, role.lv, role.updatedAt.getTime(), role);
} }
} else if (type == REDIS_KEY.SUM_CE_RANK) { } 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 ranks = await RoleModel.getRank('ce', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.ce, role.updatedAt.getTime(), role); await r.setRankWithRoleInfo(role.roleId, role.ce, role.updatedAt.getTime(), role);
} }
} else if (type == REDIS_KEY.DUNGEON_RANK) { } 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 ranks = await RoleModel.getRank('dungeon', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.dungeonWarId, role.dungeonUpdatedAt, role); await r.setRankWithRoleInfo(role.roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
} }
} else if (type == REDIS_KEY.MAIN_RANK) { } 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 ranks = await RoleModel.getRank('main', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.mainWarId, role.mainUpdatedAt, role); await r.setRankWithRoleInfo(role.roleId, role.mainWarId, role.mainUpdatedAt, role);
} }
} else if (type == REDIS_KEY.MAIN_ELITE_RANK) { } 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 ranks = await RoleModel.getRank('mainElite', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId }); let r = new Rank(type, { serverId });
r.setIsInit(true); r.setIsInit(true);
for(let role of ranks) { for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role); await r.setRankWithRoleInfo(role.roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
} }
} else if (type == REDIS_KEY.HERO_RANK) { } else if (type == REDIS_KEY.HERO_RANK) {
let serverId = args.serverId; 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 ranks = await HeroModel.getRank(hid, serverId, HERO_SELECT.RANK_LINEUP);
let r = new Rank(type, { serverId, hid }); let r = new Rank(type, { serverId, hid });
r.setIsInit(true); 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); 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 role 玩家数据
* @param serverId 所在服务器 * @param serverId 所在服务器
*/ */
export async function getGeneralRank(role: RoleType&{rankReceived: number[]}, serverId: number) { export async function getGeneralRank(role: RoleType & { rankReceived: number[] }, serverId: number) {
let { rankReceived = []} = role; let { rankReceived = [] } = role;
let res = { let res = {
role: new Array<GeneralRankParamRole>(), role: new Array<GeneralRankParamRole>(),
battle: new Array<GeneralRankParamBattle>() 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); let redisKey = RANK_TYPE_TO_KEY.get(id);
if(redisKey) { if (redisKey) {
let received = rankReceived.filter(rewardId => { let received = rankReceived.filter(rewardId => {
let dic = gameData.generalRankReward.get(rewardId); let dic = gameData.generalRankReward.get(rewardId);
return dic && dic.rankId == id; return dic && dic.rankId == id;
}); });
if(general == 1) { if (general == 1) {
let r = new Rank(redisKey, { serverId }, false, 1); let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange(); let ranks = <RoleRankInfo[]>await r.getRankByRange();
if(ranks.length > 0) { if (ranks.length > 0) {
let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false), received); let param = new GeneralRankParamRole(id, ranks[0] || new RoleRankInfo({}, false), received);
res.role.push(param); res.role.push(param);
} }
} else if (general = 2) { } else if (general = 2) {
let r = new Rank(redisKey, { serverId }, false, 1); let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange(); let ranks = <RoleRankInfo[]>await r.getRankByRange();
let hero: HeroUpdate; let hero: HeroUpdate;
if(ranks.length > 0) { if (ranks.length > 0) {
hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins'); 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); res.battle.push(param);
} }
} }
game-server/app/services/timeTaskService.ts
+171 -133
View File
@@ -1,14 +1,14 @@
import { scheduleJob, Job, scheduledJobs } from 'node-schedule'; import { scheduleJob, Job, scheduledJobs } from 'node-schedule';
import { SystemConfigModel } from '../db/SystemConfig'; import { PVPConfigModel } from '../db/SystemConfig';
import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense'; import PvpDefenseType, { PvpDefenseModel } from '../db/PvpDefense';
import { PVP } from '../pubUtils/dicParam'; import { PVP } from '../pubUtils/dicParam';
import { nowSeconds, getAge, getTimeFun } from '../pubUtils/timeUtil'; import { nowSeconds, getAge, getTimeFun } from '../pubUtils/timeUtil';
import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity } from '../pubUtils/data'; import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity } from '../pubUtils/data';
import { deepCopy, resResult, getRandSingleEelm } from '../pubUtils/util'; import { deepCopy, resResult, getRandSingleEelm } from '../pubUtils/util';
import { getLvByScore } from './pvpService'; import { getLvByScore } from './pvpService';
import { getAllOnlineRoles, getAllServers, initSingleRank, delGuildActivityRank } from './redisService'; 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 { RoleModel } from '../db/Role';
import { MailModel, MailType } from '../db/Mail'; import { MailModel, MailType } from '../db/Mail';
import { pinus } from 'pinus'; import { pinus } from 'pinus';
@@ -28,44 +28,41 @@ import { Rank } from './rankService';
import { checkTask } from './taskService'; import { checkTask } from './taskService';
import { everydayRefresh } from './connectorService'; import { everydayRefresh } from './connectorService';
import { initMarquee, initMaintenance } from './gmService'; import { initMarquee, initMaintenance } from './gmService';
import moment = require('moment');
import { CounterModel } from '../db/Counter';
const PER_SECOND = 1 * 1000; const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60; const PER_DAY = 24 * 60 * 60;
const SETTLE_DIFF = 29 * 60; const SETTLE_DIFF = 29 * 60;
const pageNum = 500; const pageNum = 500;
const PER_MINUTE = 1 * 60; const PER_MINUTE = 1 * 60;
var seasonJobId: Job; var seasonMakeRewardTimJobId: Job;
var warJobId: Job; var warJobId: Job;
var seasonEndTimeJobId: Job; var seasonRefreshTimeJobId: Job;
let guildWeeklyJobId: Job; let guildWeeklyJobId: Job;
let guildActSecondsJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除 let guildActSecondsJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let guildActEndJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除 let guildActEndJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let pvpMakeRewardInterval = null;
let pvpRefreshInterval = null;
/** /**
* 服务器启动即开启定时任务，结算时常是23-24点，实际结算的时间点是23：31分钟 * 服务器启动即开启定时任务，结算时常是23-24点，实际结算的时间点是23：31分钟
*/ */
export async function init() { export async function init() {
let seasonEndTime = 0; let systemConfig = await PVPConfigModel.findCurPVPConfig();
let systemConfig = await SystemConfigModel.findSystemConfig();//系统全局参数表
if (!systemConfig) { let seasonEndTime = systemConfig ? systemConfig.seasonEndTime : <number>getTimeFun(moment(SERVER_OPEN_TIME).startOf('d').add(-1, 'minute').toDate()).getAfterDay(PVP.PVP_SEASON_DAYS);
console.log('create season seasonNum = '+ systemConfig?.seasonNum); if (nowSeconds() > seasonEndTime) {//停服太长，数据配置问题导致数据太老，需要刷新赛季数据
let warIds = getPvpGkWarIds(); while (nowSeconds() > seasonEndTime) {
let warId = warIds[0]; seasonEndTime = <number>getTimeFun(seasonEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
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; if (!systemConfig || seasonEndTime != systemConfig.seasonEndTime) {
seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);//设置实际赛季结算时间 systemConfig = await createNewPvpSeasonData(seasonEndTime)
}
await resetPVPTimer(seasonEndTime);
seasonEndTimeJobId = scheduleJob('resetRank', seasonEndTime * PER_SECOND, resetPvpRanks);//由于24之后，才展示结算之后的信息，为保排行榜信息一致性，设置实际重置排行榜的时间为12点
warJobId = scheduleJob("0 0 0 * * 1", resetPvpWarId);//每周1零点重置地图 warJobId = scheduleJob("0 0 0 * * 1", resetPvpWarId);//每周1零点重置地图
await resetPvpRanks();//服务器重启，重置排行榜的信息 await resetPvpRanks();//服务器重启，重置排行榜的信息
@@ -92,29 +89,76 @@ export async function init() {
await initMaintenance(); await initMaintenance();
} }
function setPvpSeasonSchdule() { async function resetPVPTimer(seasonEndTime: number) {
setPvpSeasonResult(); 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定时任务赛季结算 * pvp定时任务赛季结算
* @param obj * @param obj
*/ */
export async function setPvpSeasonResult(obj?:{ name:string, notSetNext?: boolean, notPush?: boolean }) { export async function pvpSeasonEnd(obj?: { name: string, notSetNext?: boolean, notPush?: boolean }) {
console.log('exce setPvpSeasonResult'+ obj?.name); console.log('exce pvpSeasonEnd' + obj?.name);
let { seasonNum, seasonEndTime, oldSeasonEndTime } = await setNextPvpTime(obj?.notSetNext);//设置下个结算任务 let systemConfig = await PVPConfigModel.findCurPVPConfig();
let resultMaxRank = getResultMaxRank();//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入pvp时结算 let resultMaxRank = getResultMaxRank();//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入pvp时结算
let maxPage = (resultMaxRank.min + 1000) / pageNum; //保底结算玩家数量 let maxPage = (resultMaxRank.min + 1000) / pageNum; //保底结算玩家数量
let lastPageNum = resultMaxRank.min % pageNum; let lastPageNum = resultMaxRank.min % pageNum;
for (let page = 0; page < maxPage + 1; page++) { 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) { for (let pvpDefense of pvpDefenses) {
if (pvpDefense.seasonNum !== seasonNum) { if (pvpDefense.seasonNum !== systemConfig.seasonNum) {
await setPvpDefResultOnTime(pvpDefense, seasonNum, oldSeasonEndTime, obj?.notPush); await setPvpDefResultOnTime(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime, obj?.notPush);
} }
} }
} }
return { seasonNum, seasonEndTime, oldSeasonEndTime};
} }
/** /**
* pvp定时任务结算获得添加邮件信息 * 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) { 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); 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) //排名奖励 if (!!rankGoods.length) //排名奖励
await sendMailByContent(MAIL_TYPE.PVP_RANK_REWARD, pvpDefense.roleId, { 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 goods: rankGoods, endTime: oldSeasonEndTime, notPush
}); });
if (!!heroGoods.length) //武将功勋奖励 if (!!heroGoods.length) //武将功勋奖励
@@ -146,7 +190,7 @@ export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNu
* @param oldSeasonEndTime * @param oldSeasonEndTime
* @param rankLv * @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 pvpRankRewards = getPvpRankRewards();
let pvpHeroRewards = getPvpHeroRewards(); let pvpHeroRewards = getPvpHeroRewards();
if (!rankLv) { if (!rankLv) {
@@ -162,7 +206,7 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
pvpRankReward = getResultMaxRank();//最大排名等级挡位信息 pvpRankReward = getResultMaxRank();//最大排名等级挡位信息
} }
let rankGoods = []; let rankGoods = [];
if(pvpRankReward) { if (pvpRankReward) {
rankGoods = pvpRankReward.reward;//排名奖励 rankGoods = pvpRankReward.reward;//排名奖励
} }
let heroGoods = []; let heroGoods = [];
@@ -186,15 +230,19 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
let pLv = getLvByScore(pvpDefense.heroScores); let pLv = getLvByScore(pvpDefense.heroScores);
//pvp锁定的信息存入赛季结算表中 //pvp锁定的信息存入赛季结算表中
await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, { await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, {
oldSeasonData:{refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores, oldSeasonData: {
refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores,
seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime 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_HERO_SCORE, 0, false, { heroScores: pvpDefense.heroScores });
await checkTask(pvpDefense.roleId, null, null, TASK_TYPE.PVP_RANK, 1, false, { rankLv }); 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 {
return {id, count}; rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, oldSeasonEndTime, heroGoods: heroGoods.map(({ id, count }) => {
}), rankGoods}; return { id, count };
}), rankGoods
};
} }
/** /**
* 个人pvp结算，结算中未结算的，都按照最大排名挡位结算 * 个人pvp结算，结算中未结算的，都按照最大排名挡位结算
@@ -202,15 +250,15 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
* @param seasonNum * @param seasonNum
* @param oldSeasonEndTime * @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); let role = await RoleModel.findByRoleId(pvpDefense.roleId);
if (!role) { if (!role) {
return; return;
} }
let resultMaxRank = getResultMaxRank(); let resultMaxRank = getResultMaxRank();
let rankLv = resultMaxRank.min; //最大排名挡位结算 let rankLv = resultMaxRank.min; //最大排名挡位结算
let {score, pLv, heroScores, challengeCnt, challengeRefTime, rankGoods, heroGoods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv); 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}); pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, { score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime });
let { roleId } = role; let { roleId } = role;
let r = new Rank(REDIS_KEY.PVP_RANK, {}); let r = new Rank(REDIS_KEY.PVP_RANK, {});
r.setRankWithRoleInfo(pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role, true); r.setRankWithRoleInfo(pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role, true);
@@ -221,41 +269,45 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
await sendMailByContent(MAIL_TYPE.PVP_RESULT, roleId, { params: [JSON.stringify(seasonNum)], goods: heroGoods, endTime: oldSeasonEndTime }); await sendMailByContent(MAIL_TYPE.PVP_RESULT, roleId, { params: [JSON.stringify(seasonNum)], goods: heroGoods, endTime: oldSeasonEndTime });
return pvpDefense; return pvpDefense;
} }
/** /**
* 每周重置地图 * 新pvp赛季数据
*/ */
export async function resetPvpWarId() { export async function createNewPvpSeasonData(seasonEndTime: number) {
// console.log('resetPvpWarId'); console.log('createNewPvpSeasonData');
let systemConfig = await SystemConfigModel.findSystemConfig(); 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 warIds: number[] = deepCopy(getPvpGkWarIds());
let index = indexOf(warIds, systemConfig.warId); let index = indexOf(warIds, oldWarId);
if (index != -1) { if (index != -1) {
warIds.splice(index, 1); warIds.splice(index, 1);
} }
let warId = getRandSingleEelm(warIds); let warId = getRandSingleEelm(warIds);
return await SystemConfigModel.updateSystemConfig({ warId }); console.log('getPvpWarId', oldWarId, warId);
return warId;
} }
/** /**
* 重置下个定时结算 * 每周重置地图
* @param notSetNext
*/ */
async function setNextPvpTime(notSetNext: boolean) { export async function resetPvpWarId() {
let { seasonEndTime, seasonNum } = await SystemConfigModel.findSystemConfig(); let systemConfig = await PVPConfigModel.findCurPVPConfig();
if (!!notSetNext) { let warId = getPvpWarId(systemConfig.warId)
return { seasonEndTime, seasonNum , oldSeasonEndTime: 0}; return await PVPConfigModel.updatePVPConfig(systemConfig.seasonNum, { warId });
}
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 };
} }
function getScore(arr, score) { function getScore(arr, score) {
for (let item of arr) { 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; return item;
} }
} }
@@ -265,67 +317,51 @@ function getScore(arr, score) {
* @param hour * @param hour
*/ */
export async function resetPvpSeasonTime(hour: number) { export async function resetPvpSeasonTime(hour: number) {
if (!!seasonJobId) { let systemConfig = await PVPConfigModel.findCurPVPConfig();
seasonJobId.cancel();
} let seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
let seasonEndTime = 0; systemConfig = await createNewPvpSeasonData(seasonEndTime);
let seasonNum = 1; await resetPVPTimer(seasonEndTime);
if (!!seasonEndTimeJobId) { await resetPvpRanks();
seasonEndTimeJobId.cancel(); console.log('settleTime = ' + systemConfig.seasonNum)
}
let systemConfig = await SystemConfigModel.findSystemConfig(); return { seasonEndTime, seasonNum: systemConfig.seasonNum };
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 };
} }
async function resetPvpRanks() { export async function resetPvpRanks() {
await initSingleRank(REDIS_KEY.PVP_RANK); await initSingleRank(REDIS_KEY.PVP_RANK);
} }
export async function reportOnlineSchedule() { export async function reportOnlineSchedule() {
let allRoles = await getAllOnlineRoles(); let allRoles = await getAllOnlineRoles();
console.log('reportOnlineSchedule all roles count: ', allRoles.length) 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); 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) { export async function reportOneOnline(roleId: string, userCode: string, sid: string, pkgName: string) {
let result = await reportOnline(userCode, pkgName); // 连接sdk 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); 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 { reportTime = new Date(), lastLoginTime = new Date(), guestTime, isGuest, hasAuthenticated, birthday } = user;
let age = getAge(birthday); let age = getAge(birthday);
let isAdult = age >= ADULT_AGE; let isAdult = age >= ADULT_AGE;
if(isGuest || !hasAuthenticated) { if (isGuest || !hasAuthenticated) {
let lastTime = lastLoginTime > reportTime? lastLoginTime.getTime(): reportTime.getTime(); let lastTime = lastLoginTime > reportTime ? lastLoginTime.getTime() : reportTime.getTime();
let guestTimeInc = Math.floor((Date.now() - lastTime)/1000); let guestTimeInc = Math.floor((Date.now() - lastTime) / 1000);
user = await UserModel.updatePlayTime(userCode, guestTimeInc, result.total); // 记录时间 user = await UserModel.updatePlayTime(userCode, guestTimeInc, result.total); // 记录时间
guestTime = user.guestTime; guestTime = user.guestTime;
if ( guestTime > GUEST_MAX_TIME ) { if (guestTime > GUEST_MAX_TIME) {
pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, { pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, {
isGuest, isGuest,
guestTime, // 游客已体验时间 guestTime, // 游客已体验时间
@@ -333,10 +369,10 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
isAdult, // 是否已成年 isAdult, // 是否已成年
todayPlayTime: result.total, // 今天已游戏时长 todayPlayTime: result.total, // 今天已游戏时长
type: ADDICTION_PREVENTION_CODE.GUEST, type: ADDICTION_PREVENTION_CODE.GUEST,
} ), [{uid: roleId, sid: sid}]); }), [{ uid: roleId, sid: sid }]);
} }
} else { } 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); // 记录时间 user = await UserModel.updatePlayTime(userCode, 0, result.total, result.code); // 记录时间
pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, { pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, {
@@ -346,7 +382,7 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
isAdult, // 是否已成年 isAdult, // 是否已成年
todayPlayTime: result.total, // 今天已游戏时长 todayPlayTime: result.total, // 今天已游戏时长
type: result.code type: result.code
} ), [{uid: roleId, sid: sid}]); }), [{ uid: roleId, sid: sid }]);
} }
} }
} }
@@ -363,26 +399,26 @@ async function guildActivitySchedule() {
scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule); scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule);
let statusResult = getGuildActivityByDic(dicGuildActivity); 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 (!guildActSecondsJobId) {
if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) { if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/10 * * * * *`, gateActivitySeconds); 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); 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); guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/1 * * * * *`, raceActivitySeconds);
} }
} }
if(!guildActEndJobId) { if (!guildActEndJobId) {
if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) { if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, gateActivityEnd); 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); 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); guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, raceActivityEnd);
} }
} }
@@ -396,15 +432,15 @@ async function guildActivityStartSchedule() {
export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) { export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
console.log('*******开始军团晚间活动****') console.log('*******开始军团晚间活动****')
if(!dicGuildActivity) dicGuildActivity = getTodayGuildActivity(); if (!dicGuildActivity) dicGuildActivity = getTodayGuildActivity();
if(!dicGuildActivity) return; if (!dicGuildActivity) return;
if(guildActSecondsJobId||guildActEndJobId) { if (guildActSecondsJobId || guildActEndJobId) {
return false return false
} }
let servers = await getAllServers(); // 玩家serverId列表 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); guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', gateActivitySeconds);
// 结束时间 // 结束时间
guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, gateActivityEnd); 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'); let guildServers = pinus.app.getServersByType('guild');
for(let serverId of servers) { for (let serverId of servers) {
let sid = dispatch(serverId.toString(), guildServers); let sid = dispatch(serverId.toString(), guildServers);
await pinus.app.rpc.guild.guildActivityRemote.raceActivityStart.toServer(sid.id, serverId); 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); guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, raceActivityEnd);
} }
for(let serverId of servers) { for (let serverId of servers) {
await sendGuildActivityStatus(serverId); await sendGuildActivityStatus(serverId);
} }
return true; return true;
@@ -439,15 +475,15 @@ export async function gateActivityEnd() {
console.log('*****gateActivityEnd'); console.log('*****gateActivityEnd');
await sendEndMsgToAll(); await sendEndMsgToAll();
let servers = pinus.app.getServersByType('guild'); 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); await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
} }
if(guildActSecondsJobId) { if (guildActSecondsJobId) {
guildActSecondsJobId.cancel(); guildActSecondsJobId.cancel();
guildActSecondsJobId = undefined; guildActSecondsJobId = undefined;
} }
if(guildActEndJobId) { if (guildActEndJobId) {
guildActEndJobId.cancel(); guildActEndJobId.cancel();
guildActEndJobId = undefined; guildActEndJobId = undefined;
} }
@@ -457,7 +493,7 @@ export async function gateActivityEnd() {
export async function gateActivitySeconds() { export async function gateActivitySeconds() {
console.log('*****gateActivitySeconds') console.log('*****gateActivitySeconds')
let servers = pinus.app.getServersByType('guild'); 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); 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'); console.log('*****cityActivityEnd');
await sendEndMsgToAll(); await sendEndMsgToAll();
let servers = pinus.app.getServersByType('guild'); 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); await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
} }
// 发完之后再做下周自动宣战 // 发完之后再做下周自动宣战
let serverlists = await getAllServers(); let serverlists = await getAllServers();
for(let serverId of serverlists) { for (let serverId of serverlists) {
await autoDeclare(serverId); await autoDeclare(serverId);
} }
if(guildActSecondsJobId) { if (guildActSecondsJobId) {
guildActSecondsJobId.cancel(); guildActSecondsJobId.cancel();
guildActSecondsJobId = undefined; guildActSecondsJobId = undefined;
} }
if(guildActEndJobId) { if (guildActEndJobId) {
guildActEndJobId.cancel(); guildActEndJobId.cancel();
guildActEndJobId = undefined; guildActEndJobId = undefined;
} }
@@ -491,7 +527,7 @@ export async function cityActivityEnd() {
export async function cityActivitySeconds() { export async function cityActivitySeconds() {
console.log('*****cityActivitySeconds') console.log('*****cityActivitySeconds')
let servers = pinus.app.getServersByType('guild'); 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); 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'); console.log('*****raceActivityEnd');
await sendEndMsgToAll(); await sendEndMsgToAll();
let servers = pinus.app.getServersByType('guild'); 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); await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
} }
if(guildActSecondsJobId) { if (guildActSecondsJobId) {
guildActSecondsJobId.cancel(); guildActSecondsJobId.cancel();
guildActSecondsJobId = undefined; guildActSecondsJobId = undefined;
} }
if(guildActEndJobId) { if (guildActEndJobId) {
guildActEndJobId.cancel(); guildActEndJobId.cancel();
guildActEndJobId = undefined; guildActEndJobId = undefined;
} }
@@ -521,7 +559,7 @@ export async function raceActivitySeconds() {
console.log('*****raveActivitySeconds') console.log('*****raveActivitySeconds')
let servers = await getAllServers(); // 玩家serverId列表 let servers = await getAllServers(); // 玩家serverId列表
let guildServers = pinus.app.getServersByType('guild'); let guildServers = pinus.app.getServersByType('guild');
for(let serverId of servers) { for (let serverId of servers) {
let sid = dispatch(serverId.toString(), guildServers); let sid = dispatch(serverId.toString(), guildServers);
await pinus.app.rpc.guild.guildActivityRemote.calWoodenHorseAndSend.toServer(sid.id, serverId); await pinus.app.rpc.guild.guildActivityRemote.calWoodenHorseAndSend.toServer(sid.id, serverId);
} }
game-server/test/chat.test.ts
-1
View File
@@ -291,7 +291,6 @@ describe('聊天测试', function () {
setTimeout(() => { setTimeout(() => {
if (i === HERO_GROW_MAX.STAR && j > 0) { if (i === HERO_GROW_MAX.STAR && j > 0) {
} else { } else {
console.log('dddddddddddd', i, j);
pinusClient.request('role.heroHandler.starUp', { hid: XIAHOUQINGYI_HID, star: i, starStage: j }, (starUpRes) => { pinusClient.request('role.heroHandler.starUp', { hid: XIAHOUQINGYI_HID, star: i, starStage: j }, (starUpRes) => {
if (starUpRes.code === STATUS.ROLE_STAR_REACH_MAX.code) { if (starUpRes.code === STATUS.ROLE_STAR_REACH_MAX.code) {
pinusClient.request('role.heroHandler.qualityUp', { hid: XIAHOUQINGYI_HID, quality: 2 }, (qualityUpRes) => { pinusClient.request('role.heroHandler.qualityUp', { hid: XIAHOUQINGYI_HID, quality: 2 }, (qualityUpRes) => {
shared/consts/constModules/sysConst.ts
+1
View File
@@ -44,6 +44,7 @@ export const COUNTER = {
ACTIVITY_GROUP_TYPE: { name: 'actgrptype', def: 1 }, ACTIVITY_GROUP_TYPE: { name: 'actgrptype', def: 1 },
NOTICE: { name: 'notice', def: 1 }, NOTICE: { name: 'notice', def: 1 },
GIFT_CODE: { name: 'giftCode', 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]; export const DEFAULT_HEROES = [19, 53, 46, 40, 22, 56, 32, 28, 18];
shared/db/SystemConfig.ts
+15 -14
View File
@@ -1,9 +1,11 @@
import BaseModel from './BaseModel'; import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose'; import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { COUNTER } from '../consts';
@index({ id: 1 }) @index({ id: 1 })
export default class SystemConfig extends BaseModel { export default class PVPConfig extends BaseModel {
@prop({ required: true, default: 1}) @prop({ required: true, default: 1 })
id: number; id: number;
@prop({ required: true }) @prop({ required: true })
warId: number; // 地图 warId: number; // 地图
@@ -11,34 +13,33 @@ export default class SystemConfig extends BaseModel {
seasonNum: number; // 赛季 seasonNum: number; // 赛季
@prop({ required: true }) @prop({ required: true })
seasonEndTime: number; //赛季结束的时间 seasonEndTime: number; //赛季结束的时间
@prop({ required: true , default: 0 })
oldSeasonEndTime: number; //上赛季结束的时间
@prop({ required: false }) @prop({ required: false })
settleGuildWeeklyTime: number; settleGuildWeeklyTime: number;
public static async findSystemConfig(lean = true) { public static async findCurPVPConfig() {
const result: SystemConfigType = await SystemConfigModel.findOne({}).lean(lean); let seasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
const result: PVPConfigType = await PVPConfigModel.findOne({ seasonNum }).lean(true);
return result; return result;
} }
public static async createSystemConfig(seasonEndTime: number, warId: number, lean = true) { public static async findPVPConfig(seasonNum: number) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, { seasonEndTime, warId, seasonNum: 1 }, { upsert: true, new: true }).lean(lean); const result: PVPConfigType = await PVPConfigModel.findOne({ seasonNum }).lean(true);
return result; return result;
} }
public static async updateSystemConfig(update: { seasonEndTime?: number, warId?: number, seasonNum?:number , oldSeasonEndTime?: number, settleGuildWeeklyTime?: number}, lean = true) { public static async createPVPConfig(seasonNum: number, seasonEndTime: number, warId: number) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, update, { upsert: true, new: true }).lean(lean); const result: PVPConfigType = await PVPConfigModel.findOneAndUpdate({ seasonNum }, { warId, seasonEndTime }, { upsert: true, new: true }).lean(true);
return result; return result;
} }
public static async updateSeason( seasonEndTime: number, oldSeasonEndTime: number, lean = true) { public static async updatePVPConfig(seasonNum: number, update: { warId?: number, settleGuildWeeklyTime?: number }) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, { seasonEndTime, $inc: { seasonNum: 1 }, oldSeasonEndTime }, { upsert: true, new: true }).lean(lean); const result: PVPConfigType = await PVPConfigModel.findOneAndUpdate({ seasonNum }, update, { new: true }).lean(true);
return result; 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; id: number;
}; };