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

27
game-server/app/servers/battle/handler/pvpHandler.ts
View File

@@ -1,3 +1,4 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { uniq, findWhere, findIndex } from 'underscore';
import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
@@ -5,11 +6,10 @@ import { refreshEnemies, getEnemies, getLvByScore, defaultHeroes, comsumeChallen
import { RoleModel, RoleType } from '../../../db/Role';
import { STATUS } from '../../../consts/statusCode';
import { resResult, genCode } from '../../../pubUtils/util';
import { PvpDefenseModel, OppPlayers } from '../../../db/PvpDefense';
import { pvpEndParamInter } from '../../../pubUtils/interface';
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 { addItems } from '../../../services/rewardService';
import { HeroModel } from '../../../db/Hero';
@@ -18,10 +18,10 @@ import { BattleRecordModel } from '../../../db/BattleRecord';
import { PvpRecordModel } from '../../../db/PvpRecord';
import { handleCost } from '../../../services/rewardService';
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 { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
import { SystemConfigModel } from '../../../db/SystemConfig';
import { PVPConfigModel } from '../../../db/SystemConfig';
import { Rank } from '../../../services/rankService';
import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
@@ -75,8 +75,9 @@ export class PvpHandler {
}
async debugPvpSeasonReset(msg: {}, session: BackendSession) {
let { seasonNum, seasonEndTime } = await setPvpSeasonResult({ name: 'exce setPvpSeasonResult debug' });
return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime })
await pvpSeasonEnd({ name: 'exce setPvpSeasonResult debug' });
let systemConfig = await createNextPvpSeason();
return resResult(STATUS.SUCCESS, { seasonNum: systemConfig.seasonNum, seasonEndTime: systemConfig.seasonEndTime })
}
async debugPvpWarReset(msg: {}, session: BackendSession) {
@@ -100,6 +101,7 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
}
//1获取主界面
async getData(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
@@ -200,7 +202,7 @@ export class PvpHandler {
const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
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);
if (challengeCnt == 0) {
return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
@@ -286,7 +288,7 @@ export class PvpHandler {
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess ? 1 : 2 }
}, true);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
// 减少挑战次数
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) {
let { heroes, isDefaultHero } = msg;
let roleId = session.get('roleId');
@@ -330,7 +333,7 @@ export class PvpHandler {
heroes = uniq(heroes, function (item) {
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 defCe = 0;
let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
@@ -404,6 +407,7 @@ export class PvpHandler {
}
//8. 排行榜
async getRank(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
@@ -420,6 +424,7 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { ranks, myRank });
}
//2.5. 获取对手详细信息（排行榜，战报，阵容查看）
async getPlayerDetail(msg: { roleId: string }, session: BackendSession) {
let roleId = session.get('roleId');
@@ -470,13 +475,14 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, result);
}
//7. 领取巅峰之路奖励
async receiveBox(msg: { id: number }, session: BackendSession) {
let { id } = msg;
let roleId = session.get('roleId');
let sid: string = session.get('sid');
let roleName = session.get('roleName');
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 pvpBoxs = getPvpBoxs();
let pvpBox = findWhere(pvpBoxs, { id });
@@ -495,6 +501,7 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });
}
//9. 战报
async getRec(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId);

24
game-server/app/services/guildService.ts
View File

@@ -1,11 +1,11 @@
import { gameData, getGuildActiveWeekReward, getGuildActiveByIdAndType, getGoodById } from "../pubUtils/data";
import { GuildModel, GuildType } from "../db/Guild";
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 { UserGuildModel, UserGuildType } from "../db/UserGuild";
import { UserGuildApplyModel } from "../db/UserGuildApply";
import { SystemConfigModel } from "../db/SystemConfig";
import { PVPConfigModel } from "../db/SystemConfig";
import { nowSeconds } from "../pubUtils/timeUtil";
import { pinus, BackendSession, FrontendOrBackendSession } from "pinus";
import { ARMY } from "../pubUtils/dicParam";
@@ -17,17 +17,18 @@ import { DATA_NAME } from '../consts/dataName';
import { addRoleToGuildChannel } from "./chatService";
import { Rank } from "./rankService";
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) {
let leader = <RoleType>guild.leader;
let leaderIsOnline = await isRoleOnline(leader.roleId);
// 打开公会页面，加入channel
if(userGuild.guildCode) {
if (userGuild.guildCode) {
addRoleToGuildChannel(roleId, sid, 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;
// 返回
return { hasGuild: true, guildMemberMax, ...guild, leader: { ...leader, isOnline: leaderIsOnline }, rank, myInfo: {...userGuild }};
return { hasGuild: true, guildMemberMax, ...guild, leader: { ...leader, isOnline: leaderIsOnline }, rank, myInfo: { ...userGuild } };
}
/**
@@ -225,7 +226,7 @@ export async function getUserGuildWithRefActive(roleId: string, select?: string,
return;
for (let i = 0; i < drawCnt; i++) {
let donateName = donateNames[donateNames.length - i - 1];
await sendMailByContent(MAIL_TYPE.WISH_POOL_REWARD, roleId, {
await sendMailByContent(MAIL_TYPE.WISH_POOL_REWARD, roleId, {
params: [donateName, goodInfo.name],
goods: [{ id: goodId, count: drawCnt }],
notPush
@@ -304,7 +305,8 @@ export async function settleGuildWeekly() {
res.releaseCallback();//解锁
}
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结束 —————');
}
@@ -314,10 +316,10 @@ export async function getWishPool(userGuild: UserGuildType) {
let userGuilds = await UserGuildModel.getWishPoolGoods(code, ' wishDntCnt wishGoods roleId');
let list = [];
userGuilds.map(({ wishGoods, roleId })=>{
wishGoods.map(({ type, goodId, count, receiveCnt, drawCnt, id })=>{
userGuilds.map(({ wishGoods, roleId }) => {
wishGoods.map(({ type, goodId, count, receiveCnt, drawCnt, id }) => {
list.push({ type, goodId, count, receiveCnt, drawCnt, id, roleId })
});
});
return { list, wishDntCnt:wishDntCnt||0, wishGoods };
return { list, wishDntCnt: wishDntCnt || 0, wishGoods };
}

219
game-server/app/services/pvpService.ts
View File

@@ -1,14 +1,14 @@
import { PvpDefenseModel, Heroes, OppPlayers, PvpDefenseType, HeroScores, pvpUpdateInter } from '../db/PvpDefense';
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 { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
import { getRandSingleIndex, genCode, shouldRefresh, getChineseName } from '../pubUtils/util';
import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface';
import { gameData, getPLvByScore } from "../pubUtils/data";
import { PVP } from '../pubUtils/dicParam';
import { SystemConfigModel } from '../db/SystemConfig'
import { PVPConfigModel } from '../db/SystemConfig'
import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
import { HeroesRecord } from '../db/PvpRecord';
import { HeroModel } from '../db/Hero';
@@ -19,9 +19,10 @@ import { findWhere, findIndex } from 'underscore';
import { pinus } from 'pinus';
import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp';
import { Rank } from './rankService';
import { CounterModel } from '../db/Counter';
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++) {
let index = i - PVP_HERO_POS.START;
let item = role.topLineup[index];
if(item) defCe += item.ce;
if (item) defCe += item.ce;
heroes.push({
actorId: item?.hid||0,
hero: item?.hero||null,
ce: item?.ce||0,
actorId: item?.hid || 0,
hero: item?.hero || null,
ce: item?.ce || 0,
dataId: i,
order: index + 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 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) {
if(role.hasInit) {
if (role.hasInit) {
let result = await PvpDefenseModel.findByRoleId(role.roleId, true);
if (!!result)
return result;
@@ -73,10 +74,10 @@ export async function checkPvp(role: RoleType) {
export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number) {
let result = new Array<oppPlayersInter>();
for(let oppPlayer of oppPlayers) {
for (let oppPlayer of oppPlayers) {
let dicOpponent = dicPvpOpponent.get(oppPlayer.pos);
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({
...oppDef,
roleId: oppDef.oppRoleId,
@@ -96,24 +97,24 @@ export async function getEnemies(oppPlayers: OppPlayers[], winStreakNum: number)
* @param pLv 我的排名
*/
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 { roleId } = role;
let oppPlayers = new Array<OppPlayers>();
let opp = dicPvpOpponent.values()
for(let dicOpp of opp) {
for (let dicOpp of opp) {
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); // 按照等级匹配对手
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 matchPlayerByRank(system.seasonNum, oppPlayers, mapWarJson, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
if (!flag) flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
} else {
flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
}
if(!flag) continue;
if (!flag) continue;
}
return oppPlayers;
}
@@ -121,58 +122,58 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
// console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
let r = new Rank(REDIS_KEY.PVP_RANK, {});
let ridRanks = new Array<number>(); // 已经被使用了的排名
for(let { roleId: curRoleId } of oppPlayers) {
let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId)});
for (let { roleId: curRoleId } of oppPlayers) {
let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId) });
ridRanks.push(rankLv);
}
let myRank = await r.getMyRank({roleId});
let myRank = await r.getMyRank({ roleId });
ridRanks.push(myRank);
let oppRoleId = '';
let oppRank = 0;
if(myRank == 0) {
if (myRank == 0) {
return false
} else if(myRank == 1) { // 第一名
if(pos == 1) {
} else if (myRank == 1) { // 第一名
if (pos == 1) {
oppRank = 2;
while(ridRanks.includes(oppRank)) {
oppRank --;
while (ridRanks.includes(oppRank)) {
oppRank--;
}
} else if(pos == 2) {
} else if (pos == 2) {
oppRank = 3;
while(ridRanks.includes(oppRank)) {
oppRank --;
while (ridRanks.includes(oppRank)) {
oppRank--;
}
} else {
oppRank = 4;
while(ridRanks.includes(oppRank)) {
oppRank ++;
while (ridRanks.includes(oppRank)) {
oppRank++;
}
}
} else if(myRank == 0){
} else if (myRank == 0) {
return false
} else {
if(pos == 1 || pos == 2) { // 刷新我前一名
if (pos == 1 || pos == 2) { // 刷新我前一名
oppRank = myRank - 1;
while(ridRanks.includes(oppRank)) {
oppRank --;
while (ridRanks.includes(oppRank)) {
oppRank--;
}
} else { // 刷新我后一名
oppRank = myRank + 1;
while(ridRanks.includes(oppRank)) {
oppRank ++;
while (ridRanks.includes(oppRank)) {
oppRank++;
}
}
}
let result = await r.getUserByRank(oppRank);
if(result.length <= 0) return false;
if (result.length <= 0) return false;
oppRoleId = result[0];
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);
if(!pvpHistoryOpp) return false;
if (!pvpHistoryOpp) return false;
oppPlayers.push({
roleId: pvpHistoryOpp.oppRoleId,
@@ -183,7 +184,7 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
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))
let { id: pos, minLv, maxLv } = dicOpp
@@ -191,19 +192,19 @@ async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJs
range = range.filter(cur => {
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 result = range[index]; // 本次匹配结果 pvpdefense
if(!result) return false;
if(result.roleId == roleId) {
if (!result) return false;
if (result.roleId == roleId) {
range.splice(index, 1);
if(range.length <= 0) return false;
if (range.length <= 0) return false;
index = getRandSingleIndex(range.length);
result = range[index];
}
let pvpHistoryOpp = await generPlayerOppHis(result, mapWarJson, roleId, pos);
if(!pvpHistoryOpp) return false;
if (!pvpHistoryOpp) return false;
oppPlayers.push({
roleId: pvpHistoryOpp.oppRoleId,
oppDef: pvpHistoryOpp._id,
@@ -225,25 +226,25 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, mapWarJson: DicWarJ
let role = <RoleType>pvpdefense.role;
let r = new Rank(REDIS_KEY.PVP_RANK, {});
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 otherHeroes = new Array<PvpOtherHeroes>(); // 阵容外的所有武将信息
for(let dbHero of dbHeroes) {
for (let dbHero of dbHeroes) {
let h = defenseHeroes.find(cur => cur.actorId == dbHero.hid); // 阵容里是否有这个武将
let hs = heroScores.find(cur => cur.hid == dbHero.hid); // 这个武将是否有这个得分
if(!!h) {
if (!!h) {
let warJson = mapWarJson.find(cur => cur.dataId == h.dataId);
if(warJson && warJson.relation == 2) {
if (warJson && warJson.relation == 2) {
let heroInfo = new PvpHeroInfo();
heroInfo.setHeroInfo(dbHero);
heroInfo.setOutIndex(h.order);
let attribute = getPlayerAttribute(dbHero.attr, role.attr);
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);
}
} else {
let heroInfo = new PvpOtherHeroes(hs?hs.score: 0);
} else {
let heroInfo = new PvpOtherHeroes(hs ? hs.score : 0);
heroInfo.setHeroInfo(dbHero);
otherHeroes.push(heroInfo);
}
@@ -263,22 +264,22 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
let { lv: myLv, topLineupCe: myCe, roleId } = role;
let { id: pos, minLv, maxLv, ratio } = dicOpp;
let range = gameData.pvpWar;
if(range.length <= 0) return false;
if (range.length <= 0) return false;
let index = getRandSingleIndex(range.length);
let result = range[index];
if(!result) return false;
if (!result) return false;
let robotWarjson = gameData.warJson.get(result.war_id);
if(!robotWarjson) { /* TODO 判空处理 */ }
if (!robotWarjson) { /* TODO 判空处理 */ }
let heroes = new Array<PvpEnemies>();
let defCe = 0;
for(let warJson of mapWarJson) {
if(warJson.relation == 1) continue;
for (let warJson of mapWarJson) {
if (warJson.relation == 1) continue;
let h = robotWarjson.find(cur => cur.dataId == warJson.dataId);
if(h) {
if (h) {
let dicHero = gameData.hero.get(h.actorId);
if(!dicHero) continue;
if (!dicHero) continue;
let heroInfo = new PvpHeroInfo();
heroInfo.setRobotInfo(h, myLv, dicHero.initialStars, dicHero.quality);
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 roleName = getChineseName();
let hisPLv = Math.floor(pLv + (minLv + maxLv)/2);
if(hisPLv < 1) hisPLv = 1
let hisPLv = Math.floor(pLv + (minLv + maxLv) / 2);
if (hisPLv < 1) hisPLv = 1
let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0
@@ -330,55 +331,55 @@ export function robotIdComBack(robotRoleId: string) {
// 根据连胜次数，获得加成的积分
export function getPlusScore(win: number) {
let result = win - 1;
if(result < 0) result = 0;
if(result > PVP.PVP_WINREWARD_UPLIMIT) result = PVP.PVP_WINREWARD_UPLIMIT;
if (result < 0) result = 0;
if (result > PVP.PVP_WINREWARD_UPLIMIT) result = PVP.PVP_WINREWARD_UPLIMIT;
return result;
}
export function getLvByScore(heroScores: HeroScores[]) {
heroScores.sort((a, b) => b.score - a.score);
let score = 0;
for(let i = 0; i < 5; i++) {
if(!heroScores[i]) break;
for (let i = 0; i < 5; i++) {
if (!heroScores[i]) break;
score += heroScores[i].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);
if(!pvpDefense) return;
if (!pvpDefense) return;
let { heroes, isDefaultHero } = pvpDefense;
if (!isUpdate && !isDefaultHero) {
return;
}
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;
});
heroes.sort(function(a, b) {
heroes.sort(function (a, b) {
return b.ce - b.dataId - a.ce + a.dataId;
});
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);
orders.splice(index, 1);
}
}
let defCe = 0;
let num = 0;
let num = 0;
for (let i = 0; i < role.topLineup.length; i++) {
let item = role.topLineup[i];
let index = findIndex(heroes, {actorId: item.hid});
let index = findIndex(heroes, { actorId: item.hid });
if (index == -1) {
for (let j = num; j < heroes.length; j++) {
let hero = heroes[j];
if (num >= 6) {
break;
}
if (!!findWhere(role.topLineup, {hid: hero.actorId})) {
if (!!findWhere(role.topLineup, { hid: hero.actorId })) {
continue;
}
}
if (!orders[0]) {
break;
}
@@ -401,68 +402,70 @@ export async function defaultHeroes ( role:RoleType, challengeCnt?:number, chall
defCe += item.ce;
}
if (!!challengeCnt && !!challengeRefTime) {
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes, challengeCnt, challengeRefTime, isDefaultHero:true});
return { resHeroes};
let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, challengeCnt, challengeRefTime, isDefaultHero: true });
return { resHeroes };
} else {
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes, isDefaultHero:true});
return { resHeroes};
let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(role.roleId, { defCe, heroes, isDefaultHero: true });
return { resHeroes };
}
}
export function refresh(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
return {challengeCnt, challengeRefTime};
return { challengeCnt, challengeRefTime };
}
let period = PVP.PVP_CHALLENGE_NORMALTIMES * 60;
if (getTimeFun(seasonEndTime).checkDay()) {
period = PVP.PVP_CHALLENGE_FINALTIMES * 60;
}
let time = nowSeconds();
let num = Math.floor(( time - challengeRefTime)/period);
let num = Math.floor((time - challengeRefTime) / period);
if (num > 0) {
challengeCnt += num;
challengeRefTime = challengeRefTime + period * num;
}
challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS?PVP.PVP_CHALLENGE_COUNTS:challengeCnt;
return {challengeCnt, challengeRefTime};
}
challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS ? PVP.PVP_CHALLENGE_COUNTS : challengeCnt;
return { challengeCnt, challengeRefTime };
}
export function comsumeChallengeCnt( challengeCnt: number, challengeRefTime: number, seasonEndTime:number ) {
export function comsumeChallengeCnt(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
challengeCnt--;
if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
return {challengeCnt, challengeRefTime};
return { challengeCnt, challengeRefTime };
}
if (challengeCnt == PVP.PVP_CHALLENGE_COUNTS - 1) {
challengeRefTime = nowSeconds();
return {challengeCnt, challengeRefTime};
return { challengeCnt, challengeRefTime };
}
return refresh(challengeCnt, challengeRefTime, seasonEndTime);
}
export async function findPvpDefByRoleId(roleId: string) {
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()) {
let newPvpDefense = await setPvpDefResult(pvpDefense, seasonNum, oldSeasonEndTime);
return {pvpDefense: newPvpDefense, warId};
}
let {challengeCnt, challengeRefTime} = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
return { pvpDefense: newPvpDefense, warId };
}
let { challengeCnt, challengeRefTime } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
let { refOppCnt, refOppTime, shouldRefOpp } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime); // 刷新次数
if (challengeCnt != pvpDefense.challengeCnt ||refOppCnt != pvpDefense.refOppCnt) {
await PvpDefenseModel.updateInfo( roleId, { challengeCnt, challengeRefTime, refOppCnt});
if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt) {
await PvpDefenseModel.updateInfo(roleId, { challengeCnt, challengeRefTime, refOppCnt });
pvpDefense.challengeCnt = challengeCnt;
pvpDefense.challengeRefTime = challengeRefTime;
pvpDefense.refOppCnt = refOppCnt;
pvpDefense.refOppTime = refOppTime;
}
return {pvpDefense, warId, shouldRefOpp};
return { pvpDefense, warId, shouldRefOpp };
}
// 获取刷新对手次数及消耗
export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
let curTime = new Date();
let shouldRefOpp = shouldRefresh(refOppTime, curTime);
if(shouldRefOpp) {
if (shouldRefOpp) {
refOppCnt = 0; refOppTime = curTime;
}
return {
@@ -471,13 +474,17 @@ export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
consume: gameData.pvpRefreshConsume.get(refOppCnt + 1)
}
}
/**
* 获得玩家pvp信息，并检查是否在pvp赛季结算中结算过，未结算的进行结算
* @param roleId
*/
export async function findPvpDefAllByRoleId(roleId: string) {
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赛季结算中结算过
let { score, pLv, winStreakNum, heroScores, challengeCnt, challengeRefTime } = await pinus.app.rpc.systimer.systimerRemote.setPvpDefResult.toServer('systimer-server-1', pvpDefense, seasonNum, oldSeasonEndTime);
pvpDefense.score = score;
@@ -486,22 +493,22 @@ export async function findPvpDefAllByRoleId(roleId: string) {
pvpDefense.heroScores = heroScores;
pvpDefense.challengeCnt = challengeCnt;
pvpDefense.challengeRefTime = challengeRefTime;
}
}
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); // 刷新次数
if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt || shouldRefOpp) {
let update: pvpUpdateInter = {
challengeCnt, challengeRefTime, refOppCnt, refOppTime
};
if(shouldRefOpp) {
if (shouldRefOpp) {
let role = <RoleType>pvpDefense.role;
let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv);
update.oppPlayers = oppPlayers;
}
let updateResult = await PvpDefenseModel.updateInfoAndInclude( roleId, update);
let updateResult = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
pvpDefense.oppPlayers = updateResult.oppPlayers;
pvpDefense.challengeCnt = challengeCnt;
pvpDefense.challengeRefTime = challengeRefTime;
@@ -509,7 +516,7 @@ export async function findPvpDefAllByRoleId(roleId: string) {
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 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();
newAttribute.setByWarJson(attribute, Math.sqrt(ce / enemyCe * ratio));
@@ -584,7 +591,7 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
});
} else {
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');
@@ -616,10 +623,10 @@ export async function generMyRecInfo(heroScores: HeroScores[], winStreakNum: num
export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayers, oppHeroes: pvpEndParamInter[], myLv: number) {
let oppHeroRecords = new Array<HeroesRecord>();
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) {
let historyHero = oppRole.heroes.find(cur => cur.actorId == hid);
if(historyHero) {
if (historyHero) {
let hs = new HeroesRecord(historyHero, damage, heal, underDamage);
oppHeroRecords.push(hs);
}

132
game-server/app/services/rankService.ts
View File

@@ -4,7 +4,7 @@ import { redisClient, setUserInfo } from "./redisService";
import { RoleType, RoleModel } from "../db/Role";
import { GuildType, GuildModel } from "../db/Guild";
import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
import { SystemConfigModel } from "../db/SystemConfig";
import { PVPConfigModel } from "../db/SystemConfig";
import { PvpDefenseModel } from "../db/PvpDefense";
import { gameData } from "../pubUtils/data";
import { nowSeconds } from "../pubUtils/timeUtil";
@@ -42,7 +42,7 @@ export class Rank {
this.timelen = 0; break;
case REDIS_KEY.RACE_ACTIVITY:
this.timelen = 6; break;
default:
default:
this.timelen = 10; break;
}
@@ -238,9 +238,9 @@ export class Rank {
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
}
let { dungeonWarId, dungeonHeroes } = role;
if(dungeonWarId > 0) {
if (dungeonWarId > 0) {
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 arr = new Array<LineupParam>();
for (let seqId of lineup) {
@@ -259,7 +259,7 @@ export class Rank {
let { showLineup, topLineup = [] } = role;
let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
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) {
let curHero = heroes.find(cur => cur.hid == hid);
if (curHero) {
@@ -292,7 +292,7 @@ export class Rank {
*/
public async setRank(myId: myIdInter, score: number, timestamp: number, isInc = false) {
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;
if (this.isUnion) {
@@ -383,7 +383,7 @@ export class Rank {
}
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);
@@ -408,7 +408,7 @@ export class Rank {
}
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);
@@ -420,7 +420,7 @@ export class Rank {
let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
if (!hasCurUser) {
if(!role) {
if (!role) {
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
}
param = new RoleRankInfo(role, true);
@@ -473,13 +473,13 @@ export class Rank {
let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
if (!hasCurUser) {
if(!hero) {
if (!hero) {
hero = await HeroModel.findByHidAndRole(myId.hid, myId.roleId, HERO_SELECT.RANK_LINEUP);
}
let arr = new Array<LineupParam>();
let lineParam = new LineupParam(hero);
arr.push(lineParam);
if(this.key == REDIS_KEY.HERO_RANK) {
if (this.key == REDIS_KEY.HERO_RANK) {
param.setSingleHero(arr);
} else {
param.setTopLine(arr);
@@ -487,7 +487,7 @@ export class Rank {
} else {
const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
const infoObj = JSON.parse(info);
if(this.key == REDIS_KEY.HERO_RANK) {
if (this.key == REDIS_KEY.HERO_RANK) {
param.setSingleHero(infoObj);
} else {
param.setTopLine(infoObj);
@@ -503,7 +503,7 @@ export class Rank {
}
let { dungeonWarId, dungeonHeroes } = role;
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 arr = new Array<LineupParam>();
for (let seqId of lineup) {
@@ -531,7 +531,7 @@ export class Rank {
let { showLineup, topLineup = [] } = role;
let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
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) {
let curHero = heroes.find(cur => cur.hid == hid);
if (curHero) {
@@ -579,7 +579,7 @@ export class Rank {
let num = 0;
for (let ii = 0; ii < rankFromDb.length; ii += 2) {
if(num >= this.limit) break;
if (num >= this.limit) break;
const field = rankFromDb[ii];
let myId = this.decodeFields(this.key, field);
@@ -589,7 +589,7 @@ export class Rank {
let param: RoleRankInfo | GuildRankInfo;
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;
}
param = new RoleRankInfo(userInfo, false);
@@ -603,7 +603,7 @@ export class Rank {
await this.setExInfoToParam(extraKey, param, myId, {});
}
ranks.push(param);
num ++;
num++;
}
return ranks
}
@@ -620,7 +620,7 @@ export class Rank {
let num = 0;
for (let ii = 0; ii < rankFromDb.length; ii += 2) {
if(num >= this.limit) break;
if (num >= this.limit) break;
const field = rankFromDb[ii];
let myId = this.decodeFields(this.key, field);
@@ -630,7 +630,7 @@ export class Rank {
let param: RoleRankInfo | GuildRankInfo;
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;
}
param = new RoleRankInfo(userInfo, false);
@@ -644,7 +644,7 @@ export class Rank {
await this.setExInfoToParam(extraKey, param, myId, {});
}
ranks.push(param);
num ++;
num++;
}
return ranks
}
@@ -658,7 +658,7 @@ export class Rank {
}
// console.log('**getMyRank',key, this.composeFields(this.key, myId), this.key, myId)
let myRank = await redisClient().zrevrankAsync(key, this.composeFields(this.key, myId));
if(!myRank && myRank != 0) {
if (!myRank && myRank != 0) {
return 0;
} else {
return myRank + 1;
@@ -726,36 +726,36 @@ export class Rank {
private handleTimestamp(timestamp: number = 0) {
let l = timestamp.toString().length;
if(l > this.timelen) {
if (l > this.timelen) {
timestamp = Math.floor(timestamp / Math.pow(10, l - this.timelen));
}
return timestamp
}
private async checkMyRankAndPush(myId: myIdInter, oldScore: number, newScore: number) {
if(this.isInit) return;
if (this.isInit) return;
let myRank = await this.getMyRank(myId);
if(myRank == 1 && newScore > oldScore) {
if (myRank == 1 && newScore > oldScore) {
let serverId = this.keyName.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);
if(redisKey == this.key) {
if(general == 1) {
if (redisKey == this.key) {
if (general == 1) {
let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange();
if(ranks.length > 0) {
let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false));
pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general});
let ranks = <RoleRankInfo[]>await r.getRankByRange();
if (ranks.length > 0) {
let param = new GeneralRankParamRole(id, ranks[0] || new RoleRankInfo({}, false));
pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, { ...param, general });
}
} else if (general = 2) {
let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange();
let ranks = <RoleRankInfo[]>await r.getRankByRange();
let hero: HeroUpdate;
if(ranks.length > 0) {
if (ranks.length > 0) {
hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins');
let param = new GeneralRankParamBattle(id, ranks[0]||new RoleRankInfo({}, false), hero);
pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general});
let param = new GeneralRankParamBattle(id, ranks[0] || new RoleRankInfo({}, false), hero);
pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, { ...param, general });
}
}
@@ -772,23 +772,23 @@ export class Rank {
* @param type 排行榜类型
* @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 ranks = await RoleModel.getRank('tower', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
// 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) {
let serverId = args.serverId;
let ranks = await GuildModel.getRank(type, serverId);
let r = new Rank(type, { serverId });
r.setIsInit(true);
for(let guild of ranks) {
for (let guild of ranks) {
await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
}
} 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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let guild of ranks) {
for (let guild of ranks) {
await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild);
}
} else if ( type == REDIS_KEY.PVP_RANK) {
let { seasonNum } = await SystemConfigModel.findSystemConfig();
} else if (type == REDIS_KEY.PVP_RANK) {
let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
let r = new Rank(type, {});
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;
if (!role) {
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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
// console.log(roleId);
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 r = new Rank(type, { serverId });
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);
}
} 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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role );
for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role);
}
} else if (type == REDIS_KEY.USER_LV) {
let serverId = args.serverId;
let ranks = await RoleModel.getRank('lv', serverId, ROLE_SELECT.RANK);
let r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.lv, role.updatedAt.getTime(), role);
}
} 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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.ce, role.updatedAt.getTime(), role);
}
} 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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
}
} 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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.mainWarId, role.mainUpdatedAt, role);
}
} 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 r = new Rank(type, { serverId });
r.setIsInit(true);
for(let role of ranks) {
for (let role of ranks) {
await r.setRankWithRoleInfo(role.roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
}
} else if (type == REDIS_KEY.HERO_RANK) {
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 r = new Rank(type, { serverId, hid });
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);
}
}
@@ -896,35 +896,35 @@ export async function setRankRedisFromDb(type: string, args?: {serverId?: number
* @param role 玩家数据
* @param serverId 所在服务器
*/
export async function getGeneralRank(role: RoleType&{rankReceived: number[]}, serverId: number) {
let { rankReceived = []} = role;
export async function getGeneralRank(role: RoleType & { rankReceived: number[] }, serverId: number) {
let { rankReceived = [] } = role;
let res = {
role: new Array<GeneralRankParamRole>(),
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);
if(redisKey) {
if (redisKey) {
let received = rankReceived.filter(rewardId => {
let dic = gameData.generalRankReward.get(rewardId);
return dic && dic.rankId == id;
});
if(general == 1) {
if (general == 1) {
let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange();
if(ranks.length > 0) {
let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false), received);
let ranks = <RoleRankInfo[]>await r.getRankByRange();
if (ranks.length > 0) {
let param = new GeneralRankParamRole(id, ranks[0] || new RoleRankInfo({}, false), received);
res.role.push(param);
}
} else if (general = 2) {
let r = new Rank(redisKey, { serverId }, false, 1);
let ranks = <RoleRankInfo[]> await r.getRankByRange();
let ranks = <RoleRankInfo[]>await r.getRankByRange();
let hero: HeroUpdate;
if(ranks.length > 0) {
if (ranks.length > 0) {
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);
}
}

320
game-server/app/services/timeTaskService.ts
View File

@@ -1,14 +1,14 @@
import { scheduleJob, Job, scheduledJobs } from 'node-schedule';
import { SystemConfigModel } from '../db/SystemConfig';
import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
import { scheduleJob, Job, scheduledJobs } from 'node-schedule';
import { PVPConfigModel } from '../db/SystemConfig';
import PvpDefenseType, { PvpDefenseModel } from '../db/PvpDefense';
import { PVP } from '../pubUtils/dicParam';
import { nowSeconds, getAge, getTimeFun } from '../pubUtils/timeUtil';
import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity } from '../pubUtils/data';
import { deepCopy, resResult, getRandSingleEelm } from '../pubUtils/util';
import { getLvByScore } from './pvpService';
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 { MailModel, MailType } from '../db/Mail';
import { pinus } from 'pinus';
@@ -28,44 +28,41 @@ import { Rank } from './rankService';
import { checkTask } from './taskService';
import { everydayRefresh } from './connectorService';
import { initMarquee, initMaintenance } from './gmService';
import moment = require('moment');
import { CounterModel } from '../db/Counter';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
const SETTLE_DIFF = 29 * 60;
const pageNum = 500;
const PER_MINUTE = 1 * 60;
var seasonJobId: Job;
var seasonMakeRewardTimJobId: Job;
var warJobId: Job;
var seasonEndTimeJobId: Job;
var seasonRefreshTimeJobId: Job;
let guildWeeklyJobId: Job;
let guildActSecondsJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let guildActEndJobId: Job; // 军团活动开启后每10(or 1)秒循环的定时任务，到结束活动清除
let pvpMakeRewardInterval = null;
let pvpRefreshInterval = null;
/**
* 服务器启动即开启定时任务，结算时常是23-24点，实际结算的时间点是23：31分钟
*/
export async function init() {
let seasonEndTime = 0;
let systemConfig = await SystemConfigModel.findSystemConfig();//系统全局参数表
if (!systemConfig) {
console.log('create season seasonNum = '+ systemConfig?.seasonNum);
let warIds = getPvpGkWarIds();
let warId = warIds[0];
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;
seasonJobId = scheduleJob('setPvpSeasonResult', settleTime, setPvpSeasonSchdule);//设置实际赛季结算时间
let systemConfig = await PVPConfigModel.findCurPVPConfig();
let seasonEndTime = systemConfig ? systemConfig.seasonEndTime : <number>getTimeFun(moment(SERVER_OPEN_TIME).startOf('d').add(-1, 'minute').toDate()).getAfterDay(PVP.PVP_SEASON_DAYS);
if (nowSeconds() > seasonEndTime) {//停服太长，数据配置问题导致数据太老，需要刷新赛季数据
while (nowSeconds() > seasonEndTime) {
seasonEndTime = <number>getTimeFun(seasonEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
}
}
if (!systemConfig || seasonEndTime != systemConfig.seasonEndTime) {
systemConfig = await createNewPvpSeasonData(seasonEndTime)
}
await resetPVPTimer(seasonEndTime);
seasonEndTimeJobId = scheduleJob('resetRank', seasonEndTime * PER_SECOND, resetPvpRanks);//由于24之后，才展示结算之后的信息，为保排行榜信息一致性，设置实际重置排行榜的时间为12点
warJobId = scheduleJob("0 0 0 * * 1", resetPvpWarId);//每周1零点重置地图
await resetPvpRanks();//服务器重启，重置排行榜的信息
@@ -92,29 +89,76 @@ export async function init() {
await initMaintenance();
}
function setPvpSeasonSchdule() {
setPvpSeasonResult();
async function resetPVPTimer(seasonEndTime: number) {
if (!!seasonMakeRewardTimJobId) {
seasonMakeRewardTimJobId.cancel();
clearInterval(pvpMakeRewardInterval);
}
if (!!seasonRefreshTimeJobId) {
seasonRefreshTimeJobId.cancel();
clearInterval(pvpRefreshInterval);
}
if (seasonEndTime - SETTLE_DIFF - nowSeconds() < 0) {//23：30-24：00之间,已经过了结算时间，还未开启新赛季
console.log('立刻结算奖励:', nowSeconds());
await pvpSeasonEnd();
//定时结算奖励
seasonMakeRewardTimJobId = scheduleJob('seasonMakeRewardTimJobId', (seasonEndTime - SETTLE_DIFF - nowSeconds()) * PER_SECOND + PVP.PVP_SEASON_DAYS * PER_DAY * PER_SECOND, pvpMakeRewardTimer);//
} else {
//定时结算奖励
seasonMakeRewardTimJobId = scheduleJob('seasonMakeRewardTimJobId', (seasonEndTime - SETTLE_DIFF - nowSeconds()) * PER_SECOND, pvpMakeRewardTimer);//
};
//定时开启新赛季
seasonRefreshTimeJobId = scheduleJob('seasonRefreshTimeJobId', (seasonEndTime - nowSeconds()) * PER_SECOND, pvpRefreshTimer);//
}
//pvp结算奖励定时器
async function pvpMakeRewardTimer() {
pvpMakeRewardInterval = setInterval(async () => {
console.log('定时结算奖励:', nowSeconds());
await pvpSeasonEnd()
}, PVP.PVP_SEASON_DAYS * PER_DAY * PER_SECOND)
}
//pvp刷新开始新赛季定时器
async function pvpRefreshTimer() {
pvpRefreshInterval = setInterval(async () => {
console.log('定时开启新赛季:', nowSeconds());
await createNextPvpSeason();
}, PVP.PVP_SEASON_DAYS * PER_DAY * PER_SECOND)
}
//创建下个新赛季
export async function createNextPvpSeason() {
let systemConfig = await PVPConfigModel.findCurPVPConfig();
let seasonEndTime = systemConfig ? systemConfig.seasonEndTime : <number>getTimeFun(moment(SERVER_OPEN_TIME).startOf('d').add(-1, 'minute').toDate()).getAfterDay(PVP.PVP_SEASON_DAYS);
if (nowSeconds() > seasonEndTime) {//停服太长，数据配置问题导致数据太老，需要刷新赛季数据
while (nowSeconds() > seasonEndTime) {
seasonEndTime = <number>getTimeFun(seasonEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
}
}
systemConfig = await createNewPvpSeasonData(seasonEndTime)
await resetPvpRanks()
return systemConfig;
}
/**
* pvp定时任务赛季结算
* @param obj
*/
export async function setPvpSeasonResult(obj?:{ name:string, notSetNext?: boolean, notPush?: boolean }) {
console.log('exce setPvpSeasonResult'+ obj?.name);
let { seasonNum, seasonEndTime, oldSeasonEndTime } = await setNextPvpTime(obj?.notSetNext);//设置下个结算任务
export async function pvpSeasonEnd(obj?: { name: string, notSetNext?: boolean, notPush?: boolean }) {
console.log('exce pvpSeasonEnd' + obj?.name);
let systemConfig = await PVPConfigModel.findCurPVPConfig();
let resultMaxRank = getResultMaxRank();//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入pvp时结算
let maxPage = (resultMaxRank.min + 1000) / pageNum; //保底结算玩家数量
let lastPageNum = resultMaxRank.min % pageNum;
for (let page = 0; page < maxPage + 1; page++) {
let pvpDefenses = await PvpDefenseModel.getPvpDef(pageNum, page == maxPage?lastPageNum:page);
let pvpDefenses = await PvpDefenseModel.getPvpDef(pageNum, page == maxPage ? lastPageNum : page);
for (let pvpDefense of pvpDefenses) {
if (pvpDefense.seasonNum !== seasonNum) {
await setPvpDefResultOnTime(pvpDefense, seasonNum, oldSeasonEndTime, obj?.notPush);
if (pvpDefense.seasonNum !== systemConfig.seasonNum) {
await setPvpDefResultOnTime(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime, obj?.notPush);
}
}
}
return { seasonNum, seasonEndTime, oldSeasonEndTime};
}
/**
* 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) {
//检查并返回排名结算以及武将功勋结算
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) //排名奖励
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
});
if (!!heroGoods.length) //武将功勋奖励
@@ -146,7 +190,7 @@ export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNu
* @param oldSeasonEndTime
* @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 pvpHeroRewards = getPvpHeroRewards();
if (!rankLv) {
@@ -162,7 +206,7 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
pvpRankReward = getResultMaxRank();//最大排名等级挡位信息
}
let rankGoods = [];
if(pvpRankReward) {
if (pvpRankReward) {
rankGoods = pvpRankReward.reward;//排名奖励
}
let heroGoods = [];
@@ -181,20 +225,24 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
});
}
}
score += heroScore.score;
score += heroScore.score;
}
let pLv = getLvByScore(pvpDefense.heroScores);
//pvp锁定的信息存入赛季结算表中
await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, {
oldSeasonData:{refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores,
await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, {
oldSeasonData: {
refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: oldHeroScores,
seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime
}, heroGoods, rankGoods, show: true });//结算修改玩家pvp信息
}, 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_RANK, 1, false, { rankLv });
return { rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, oldSeasonEndTime, heroGoods:heroGoods.map(({id, count})=>{
return {id, count};
}), rankGoods};
return {
rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, oldSeasonEndTime, heroGoods: heroGoods.map(({ id, count }) => {
return { id, count };
}), rankGoods
};
}
/**
* 个人pvp结算，结算中未结算的，都按照最大排名挡位结算
@@ -202,60 +250,64 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
* @param seasonNum
* @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);
if (!role) {
return;
}
let resultMaxRank = getResultMaxRank();
let rankLv = resultMaxRank.min; //最大排名挡位结算
let {score, pLv, heroScores, challengeCnt, challengeRefTime, rankGoods, heroGoods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv);
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
let { score, pLv, heroScores, challengeCnt, challengeRefTime, rankGoods, heroGoods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv);
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(pvpDefense.roleId, { score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime });
let { roleId } = role;
let r = new Rank(REDIS_KEY.PVP_RANK, {});
r.setRankWithRoleInfo(pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role, true);
//下发邮件
if (!!rankGoods.length)
if (!!rankGoods.length)
await sendMailByContent(MAIL_TYPE.PVP_RANK_REWARD, roleId, { params: [JSON.stringify(seasonNum), '999+'], goods: rankGoods, endTime: oldSeasonEndTime });
if (!!heroGoods.length)
if (!!heroGoods.length)
await sendMailByContent(MAIL_TYPE.PVP_RESULT, roleId, { params: [JSON.stringify(seasonNum)], goods: heroGoods, endTime: oldSeasonEndTime });
return pvpDefense;
}
/**
* 每周重置地图
* 新pvp赛季数据
*/
export async function resetPvpWarId() {
// console.log('resetPvpWarId');
let systemConfig = await SystemConfigModel.findSystemConfig();
export async function createNewPvpSeasonData(seasonEndTime: number) {
console.log('createNewPvpSeasonData');
let seasonNum = await CounterModel.getNewCounter(COUNTER.PVP_SEASON_NUM);
// let seasonEndTime: number = <number>getTimeFun(oldEndTime).getAfterDay(PVP.PVP_SEASON_DAYS);
let warId = getPvpWarId(-1);
let systemConfig = await PVPConfigModel.createPVPConfig(seasonNum, seasonEndTime, warId);
return systemConfig;
}
/**
* 随机地图Id
*/
function getPvpWarId(oldWarId: number): number {
let warIds: number[] = deepCopy(getPvpGkWarIds());
let index = indexOf(warIds, systemConfig.warId);
let index = indexOf(warIds, oldWarId);
if (index != -1) {
warIds.splice(index, 1);
}
let warId = getRandSingleEelm(warIds);
return await SystemConfigModel.updateSystemConfig({ warId });
console.log('getPvpWarId', oldWarId, warId);
return warId;
}
/**
* 重置下个定时结算
* @param notSetNext
* 每周重置地图
*/
async function setNextPvpTime(notSetNext: boolean) {
let { seasonEndTime, seasonNum } = await SystemConfigModel.findSystemConfig();
if (!!notSetNext) {
return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
}
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 };
export async function resetPvpWarId() {
let systemConfig = await PVPConfigModel.findCurPVPConfig();
let warId = getPvpWarId(systemConfig.warId)
return await PVPConfigModel.updatePVPConfig(systemConfig.seasonNum, { warId });
}
function getScore(arr, score) {
for (let item of arr) {
if ((item.max >= score||item.max == -1) && score >= item.min) {
if ((item.max >= score || item.max == -1) && score >= item.min) {
return item;
}
}
@@ -265,67 +317,51 @@ function getScore(arr, score) {
* @param hour
*/
export async function resetPvpSeasonTime(hour: number) {
if (!!seasonJobId) {
seasonJobId.cancel();
}
let seasonEndTime = 0;
let seasonNum = 1;
if (!!seasonEndTimeJobId) {
seasonEndTimeJobId.cancel();
}
let systemConfig = await SystemConfigModel.findSystemConfig();
if (!systemConfig) {
let warIds = getPvpGkWarIds();
let warId = warIds[0];
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 };
let systemConfig = await PVPConfigModel.findCurPVPConfig();
let seasonEndTime = <number>getTimeFun().getTimeWithHour(REFRESH_TIME - hour);
systemConfig = await createNewPvpSeasonData(seasonEndTime);
await resetPVPTimer(seasonEndTime);
await resetPvpRanks();
console.log('settleTime = ' + systemConfig.seasonNum)
return { seasonEndTime, seasonNum: systemConfig.seasonNum };
}
async function resetPvpRanks() {
export async function resetPvpRanks() {
await initSingleRank(REDIS_KEY.PVP_RANK);
}
export async function reportOnlineSchedule() {
let allRoles = await getAllOnlineRoles();
console.log('reportOnlineSchedule all roles count: ', allRoles.length)
for(let { roleId, userCode, sid, pkgName } of allRoles) {
for (let { roleId, userCode, sid, pkgName } of allRoles) {
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) {
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);
if(!user) return false;
if (!user) return false;
let { reportTime = new Date(), lastLoginTime = new Date(), guestTime, isGuest, hasAuthenticated, birthday } = user;
let age = getAge(birthday);
let isAdult = age >= ADULT_AGE;
if(isGuest || !hasAuthenticated) {
let lastTime = lastLoginTime > reportTime? lastLoginTime.getTime(): reportTime.getTime();
let guestTimeInc = Math.floor((Date.now() - lastTime)/1000);
if (isGuest || !hasAuthenticated) {
let lastTime = lastLoginTime > reportTime ? lastLoginTime.getTime() : reportTime.getTime();
let guestTimeInc = Math.floor((Date.now() - lastTime) / 1000);
user = await UserModel.updatePlayTime(userCode, guestTimeInc, result.total); // 记录时间
guestTime = user.guestTime;
if ( guestTime > GUEST_MAX_TIME ) {
if (guestTime > GUEST_MAX_TIME) {
pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, {
isGuest,
guestTime, // 游客已体验时间
@@ -333,10 +369,10 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
isAdult, // 是否已成年
todayPlayTime: result.total, // 今天已游戏时长
type: ADDICTION_PREVENTION_CODE.GUEST,
} ), [{uid: roleId, sid: sid}]);
}), [{ uid: roleId, sid: sid }]);
}
} 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); // 记录时间
pinus.app.channelService.pushMessageByUids('onPlayTime', resResult(STATUS.SUCCESS, {
@@ -346,7 +382,7 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
isAdult, // 是否已成年
todayPlayTime: result.total, // 今天已游戏时长
type: result.code
} ), [{uid: roleId, sid: sid}]);
}), [{ uid: roleId, sid: sid }]);
}
}
}
@@ -357,32 +393,32 @@ export async function reportOneOnline(roleId: string, userCode: string, sid: str
async function guildActivitySchedule() {
/***********guildActivitySchedule***********/
let dicGuildActivity = getTodayGuildActivity();
let dicGuildActivity = getTodayGuildActivity();
await delGuildActivityRank(dicGuildActivity.id);
scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule);
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(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
if (!guildActSecondsJobId) {
if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
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);
} else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
} else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/1 * * * * *`, raceActivitySeconds);
}
}
if(!guildActEndJobId) {
if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
if (!guildActEndJobId) {
if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
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);
} else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
} else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, raceActivityEnd);
}
}
@@ -396,15 +432,15 @@ async function guildActivityStartSchedule() {
export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
console.log('*******开始军团晚间活动****')
if(!dicGuildActivity) dicGuildActivity = getTodayGuildActivity();
if(!dicGuildActivity) return;
if (!dicGuildActivity) dicGuildActivity = getTodayGuildActivity();
if (!dicGuildActivity) return;
if(guildActSecondsJobId||guildActEndJobId) {
if (guildActSecondsJobId || guildActEndJobId) {
return false
}
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);
// 结束时间
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');
for(let serverId of servers) {
for (let serverId of servers) {
let sid = dispatch(serverId.toString(), guildServers);
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);
}
for(let serverId of servers) {
for (let serverId of servers) {
await sendGuildActivityStatus(serverId);
}
return true;
@@ -439,15 +475,15 @@ export async function gateActivityEnd() {
console.log('*****gateActivityEnd');
await sendEndMsgToAll();
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);
}
if(guildActSecondsJobId) {
if (guildActSecondsJobId) {
guildActSecondsJobId.cancel();
guildActSecondsJobId = undefined;
}
if(guildActEndJobId) {
if (guildActEndJobId) {
guildActEndJobId.cancel();
guildActEndJobId = undefined;
}
@@ -457,7 +493,7 @@ export async function gateActivityEnd() {
export async function gateActivitySeconds() {
console.log('*****gateActivitySeconds')
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);
}
}
@@ -468,20 +504,20 @@ export async function cityActivityEnd() {
console.log('*****cityActivityEnd');
await sendEndMsgToAll();
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);
}
// 发完之后再做下周自动宣战
let serverlists = await getAllServers();
for(let serverId of serverlists) {
for (let serverId of serverlists) {
await autoDeclare(serverId);
}
if(guildActSecondsJobId) {
if (guildActSecondsJobId) {
guildActSecondsJobId.cancel();
guildActSecondsJobId = undefined;
}
if(guildActEndJobId) {
if (guildActEndJobId) {
guildActEndJobId.cancel();
guildActEndJobId = undefined;
}
@@ -491,7 +527,7 @@ export async function cityActivityEnd() {
export async function cityActivitySeconds() {
console.log('*****cityActivitySeconds')
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);
}
}
@@ -502,15 +538,17 @@ export async function raceActivityEnd() {
console.log('*****raceActivityEnd');
await sendEndMsgToAll();
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);
}
if(guildActSecondsJobId) {
if (guildActSecondsJobId) {
guildActSecondsJobId.cancel();
guildActSecondsJobId = undefined;
}
if(guildActEndJobId) {
if (guildActEndJobId) {
guildActEndJobId.cancel();
guildActEndJobId = undefined;
}
@@ -521,7 +559,7 @@ export async function raceActivitySeconds() {
console.log('*****raveActivitySeconds')
let servers = await getAllServers(); // 玩家serverId列表
let guildServers = pinus.app.getServersByType('guild');
for(let serverId of servers) {
for (let serverId of servers) {
let sid = dispatch(serverId.toString(), guildServers);
await pinus.app.rpc.guild.guildActivityRemote.calWoodenHorseAndSend.toServer(sid.id, serverId);
}

1
game-server/test/chat.test.ts
View File

@@ -291,7 +291,6 @@ describe('聊天测试', function () {
setTimeout(() => {
if (i === HERO_GROW_MAX.STAR && j > 0) {
} else {
console.log('dddddddddddd', i, j);
pinusClient.request('role.heroHandler.starUp', { hid: XIAHOUQINGYI_HID, star: i, starStage: j }, (starUpRes) => {
if (starUpRes.code === STATUS.ROLE_STAR_REACH_MAX.code) {
pinusClient.request('role.heroHandler.qualityUp', { hid: XIAHOUQINGYI_HID, quality: 2 }, (qualityUpRes) => {

1
shared/consts/constModules/sysConst.ts
View File

@@ -44,6 +44,7 @@ export const COUNTER = {
ACTIVITY_GROUP_TYPE: { name: 'actgrptype', def: 1 },
NOTICE: { name: 'notice', 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];

31
shared/db/SystemConfig.ts
View File

@@ -1,44 +1,45 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { COUNTER } from '../consts';
@index({ id: 1 })
export default class SystemConfig extends BaseModel {
@prop({ required: true, default: 1})
id: number;
export default class PVPConfig extends BaseModel {
@prop({ required: true, default: 1 })
id: number;
@prop({ required: true })
warId: number; // 地图
@prop({ required: true, default: 1 })
seasonNum: number; // 赛季
@prop({ required: true })
seasonEndTime: number; //赛季结束的时间
@prop({ required: true , default: 0 })
oldSeasonEndTime: number; //上赛季结束的时间
@prop({ required: false })
settleGuildWeeklyTime: number;
public static async findSystemConfig(lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOne({}).lean(lean);
public static async findCurPVPConfig() {
let seasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
const result: PVPConfigType = await PVPConfigModel.findOne({ seasonNum }).lean(true);
return result;
}
public static async createSystemConfig(seasonEndTime: number, warId: number, lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, { seasonEndTime, warId, seasonNum: 1 }, { upsert: true, new: true }).lean(lean);
public static async findPVPConfig(seasonNum: number) {
const result: PVPConfigType = await PVPConfigModel.findOne({ seasonNum }).lean(true);
return result;
}
public static async updateSystemConfig(update: { seasonEndTime?: number, warId?: number, seasonNum?:number , oldSeasonEndTime?: number, settleGuildWeeklyTime?: number}, lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, update, { upsert: true, new: true }).lean(lean);
public static async createPVPConfig(seasonNum: number, seasonEndTime: number, warId: number) {
const result: PVPConfigType = await PVPConfigModel.findOneAndUpdate({ seasonNum }, { warId, seasonEndTime }, { upsert: true, new: true }).lean(true);
return result;
}
public static async updateSeason( seasonEndTime: number, oldSeasonEndTime: number, lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({}, { seasonEndTime, $inc: { seasonNum: 1 }, oldSeasonEndTime }, { upsert: true, new: true }).lean(lean);
public static async updatePVPConfig(seasonNum: number, update: { warId?: number, settleGuildWeeklyTime?: number }) {
const result: PVPConfigType = await PVPConfigModel.findOneAndUpdate({ seasonNum }, update, { new: true }).lean(true);
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;
};