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

pvp赛季结算界面

Browse Source
This commit is contained in:
mamengke01
2021-01-15 16:06:52 +08:00
parent 2e501014b0
commit 3d9a5e7592
8 changed files with 119 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -21,6 +21,7 @@ import { nowSeconds } from '../../../pubUtils/timeUtil';
import { setPvpSeasonResult, resetPvpWarId, resetPvpSeasonTime } from '../../../services/timeTaskService';
import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
import { SystemConfigModel } from '../../../db/SystemConfig';
export default function(app: Application) {
return new PvpHandler(app);
@@ -92,9 +93,9 @@ export class PvpHandler {
async getData (msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let { pvpDefense, warId } = await findPvpDefAllByRoleId(roleId);
let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
let oppPlayers = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
let { isDefaultHero, heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, seasonNum, seasonEndTime } = pvpDefense;
let { isDefaultHero, heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, seasonNum } = pvpDefense;
if (isFirstEntry) {
await PvpDefenseModel.updateInfo(roleId, {isFirstEntry:false});
}
@@ -103,12 +104,12 @@ export class PvpHandler {
if (!!pvpSeasonResult) {
var { oldSeasonData, show, heroGoods, rankGoods} = pvpSeasonResult;
if ( oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息
// seasonEndTime = oldSeasonData.seasonEndTime;
// heroScores = oldSeasonData.heroScores;
// score = oldSeasonData.score;
// refOppCnt = oldSeasonData.refOppCnt;
// challengeCnt = oldSeasonData.challengeCnt;
// challengeRefTime = oldSeasonData.challengeRefTime;
seasonEndTime = oldSeasonData.seasonEndTime;
heroScores = oldSeasonData.heroScores;
score = oldSeasonData.score;
refOppCnt = oldSeasonData.refOppCnt;
challengeCnt = oldSeasonData.challengeCnt;
challengeRefTime = oldSeasonData.challengeRefTime;
} else if(show) {
await PvpSeasonResultModel.updatePvpSeasonResult(roleId, {show: false});
flag = true;
@@ -187,7 +188,8 @@ export class PvpHandler {
const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
// 检查挑战次数
let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, pvpDefense.seasonEndTime);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
if (challengeCnt == 0) {
return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
}
@@ -266,9 +268,10 @@ export class PvpHandler {
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess?1:2 }
}, true);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
// 减少挑战次数
let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, pvpDefense.seasonEndTime);
let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
if ( hisScore < score) {
hisScore = score;
}
@@ -305,7 +308,8 @@ export class PvpHandler {
heroes = uniq(heroes, function(item) {
return item.order;
});
let { heroes: defHeros, seasonEndTime, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { heroes: defHeros, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
let defCe = 0;
let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
@@ -419,7 +423,8 @@ export class PvpHandler {
let roleId = session.get('roleId');
let sid: string = session.get('sid');
let roleName = session.get('roleName');
let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime, seasonEndTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let pvpBoxs = getPvpBoxs();
let pvpBox = findWhere(pvpBoxs, {id});
if (hisScore < pvpBox.score) {

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

@@ -35,9 +35,9 @@ export async function initPvpInfo(role: RoleType) {
}
//初始化对手人阵容
let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 1);
let {seasonNum, seasonEndTime} = await SystemConfigModel.findSystemConfig();
let {seasonNum} = await SystemConfigModel.findSystemConfig();
let challengeCnt = PVP.PVP_CHALLENGE_COUNTS;
let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe: role.topFiveCe, seasonNum, seasonEndTime, challengeCnt });
let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe: role.topFiveCe, seasonNum, challengeCnt });
//加入排行榜
let { roleId, roleName, lv, vLv, headHid, sHid, title } = role;
@@ -404,12 +404,12 @@ export function comsumeChallengeCnt( challengeCnt: number, challengeRefTime: num
export async function findPvpDefByRoleId(roleId: string) {
let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let {warId, seasonNum, seasonEndTime} = await SystemConfigModel.findSystemConfig();
if (pvpDefense.seasonNum !== seasonNum) {
let newPvpDefense = await setPvpDefResult(pvpDefense, seasonNum, seasonEndTime);
let {warId, seasonNum, seasonEndTime, oldSeasonEndTime} = await SystemConfigModel.findSystemConfig();
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, pvpDefense.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) {
await PvpDefenseModel.updateInfo( roleId, { challengeCnt, challengeRefTime, refOppCnt});
@@ -437,9 +437,9 @@ export function getRefOppCnt(refOppCnt: number, refOppTime: Date) {
export async function findPvpDefAllByRoleId(roleId: string) {
let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let { warId, seasonNum, seasonEndTime } = await SystemConfigModel.findSystemConfig();
if (pvpDefense.seasonNum != seasonNum) {
let { score, pLv, winStreakNum, heroScores, challengeCnt, challengeRefTime } = await pinus.app.rpc.systimer.systimerRemote.setPvpDefResult.toServer('systimer-server-1', pvpDefense, seasonNum, seasonEndTime);
let { warId, seasonNum, seasonEndTime, oldSeasonEndTime } = await SystemConfigModel.findSystemConfig();
if (pvpDefense.seasonNum != seasonNum && oldSeasonEndTime < nowSeconds()) {
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.pLv = pLv;
pvpDefense.winStreakNum = winStreakNum;
@@ -448,8 +448,7 @@ export async function findPvpDefAllByRoleId(roleId: string) {
pvpDefense.challengeRefTime = challengeRefTime;
}
pvpDefense.seasonNum = seasonNum;
pvpDefense.seasonEndTime = seasonEndTime;
let {challengeCnt, challengeRefTime} = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, pvpDefense.seasonEndTime);
let {challengeCnt, challengeRefTime} = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonNum);
let { refOppCnt, refOppTime, shouldRefOpp } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime); // 刷新次数
if (challengeCnt != pvpDefense.challengeCnt || refOppCnt != pvpDefense.refOppCnt || shouldRefOpp) {
let update: pvpUpdateInter = {
@@ -470,7 +469,7 @@ export async function findPvpDefAllByRoleId(roleId: string) {
pvpDefense.refOppTime = refOppTime;
}
return {pvpDefense, warId, shouldRefOpp};
return {pvpDefense, warId, shouldRefOpp, seasonEndTime, oldSeasonEndTime};
}
/**

40
game-server/app/services/redisService.ts
View File

@@ -6,8 +6,9 @@ import { GameModel } from "../db/Game";
import { promisifyAll } from 'bluebird';
import { pinus } from 'pinus';
import { PvpDefenseModel } from '../db/PvpDefense';
import { SystemConfigModel } from '../db/SystemConfig';
import { RankParam } from '../pubUtils/interface';
import { accessSync } from 'fs';
/**
* 在服务重新启动时，将信息存入redis
*/
@@ -36,21 +37,6 @@ export async function initRank(serverId: number) {
let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
await redisUserInfoAdd(roleId, rankPram);
}
let pvpRank = await PvpDefenseModel.getRank();
for(let {roleId, role: _role, score, updatedAt } of pvpRank) {
let role = <RoleType>_role;
if (!role) {
continue;
}
let { roleName, headHid, sHid, title, lv, vLv } = role;
await client.zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
const hasCurUser = await client.hexistsAsync(REDIS_KEY.USER_INFO, roleId);
if(!hasCurUser) {
let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
await redisUserInfoAdd(roleId, rankPram);
}
}
}
// 排行榜是否存在
@@ -242,4 +228,26 @@ export async function delRedis(key: string) {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.delAsync(key);
}
export async function resetPvpRanks() {
const client: Redis.RedisClient = pinus.app.get('redis');
await client.delAsync(REDIS_KEY.PVP_RANK);
let { seasonNum } = await SystemConfigModel.findSystemConfig();
let pvpRank = await PvpDefenseModel.getRank(seasonNum);
for(let {roleId, role: _role, score, updatedAt } of pvpRank) {
let role = <RoleType>_role;
if (!role) {
continue;
}
let { roleName, headHid, sHid, title, lv, vLv } = role;
await client.zaddAsync(getKeyName(REDIS_KEY.PVP_RANK), encodeScoreWithTime(score, updatedAt?updatedAt.getTime():0), roleId);
const hasCurUser = await client.hexistsAsync(REDIS_KEY.USER_INFO, roleId);
if(!hasCurUser) {
let rankPram = new RankParam(roleName, lv, vLv, headHid, sHid, title);
await redisUserInfoAdd(roleId, rankPram);
}
}
}
/**************** 寻宝相关 end */

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

@@ -4,21 +4,23 @@ import { SystemConfigModel } from '../db/SystemConfig';
import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
import { PVP } from '../pubUtils/dicParam';
import { nowSeconds, getTodayZeroPoint } from '../pubUtils/timeUtil';
import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards } from '../pubUtils/data';
import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank } from '../pubUtils/data';
import { deepCopy, getRandomArr } from '../pubUtils/util';
import { getLvByScore } from './pvpService';
import { getMyRank, setRank, getRedis } from './redisService';
import { getMyRank, setRank, getRedis, resetPvpRanks } from './redisService';
import { REDIS_KEY } from '../consts';
import { RankParam } from '../pubUtils/interface';
import { RoleModel } from '../db/Role';
import { MailModel, MailType } from '../db/Mail';
import { pinus } from 'pinus';
import { indexOf } from 'underscore';
import { PvpSeasonResultModel } from '../db/PvpSeasonResult'
import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
const SETTLE_DIFF = 29 * 60;
const LIMIT_NUM = 1000;
const pageNum = 500;
const PER_MINUTE = 1 * 1000;
var seasonJobId;
var warJobId;
var seasonEndTimeJobId;
@@ -33,27 +35,32 @@ export async function init() {
} else {
seasonEndTime = systemConfig.seasonEndTime;
if (systemConfig.seasonEndTime - SETTLE_DIFF <= nowSeconds()) {
await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
systemConfig.seasonNum++;
await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum});
await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: systemConfig.seasonNum, oldSeasonEndTime: systemConfig.seasonEndTime});
await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
}
}
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
seasonEndTimeJobId = scheduleJob((seasonEndTime - PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
warJobId = scheduleJob("0 0 0 * * 3", resetPvpWarId);
await resetPvpRanks();
}
export async function setPvpSeasonResult(obj:{ name:string, notSetNext?: boolean }) {
console.log('exce setPvpSeasonResult'+ obj?.name);
let { seasonNum, seasonEndTime } = await setNextPvpTime(obj?.notSetNext);
for (let page = 0; page < 3; page++) {
let pvpDefenses = await PvpDefenseModel.getPvpDef(500, page);
let { seasonNum, seasonEndTime, oldSeasonEndTime } = await setNextPvpTime(obj?.notSetNext);
let resultMaxRank = getResultMaxRank();
let maxPage = (resultMaxRank.min + 1000) / pageNum;
let lastPageNum = resultMaxRank.min % pageNum;
for (let page = 0; page < maxPage + 1; page++) {
let pvpDefenses = await PvpDefenseModel.getPvpDef(pageNum, page == maxPage?lastPageNum:page);
let addMails = new Array<MailType>();
let pushMessage = new Array<any>();
for (let pvpDefense of pvpDefenses) {
if (pvpDefense.seasonNum !== seasonNum) {
await setPvpDefResultOnTime(pvpDefense, seasonNum, seasonEndTime, addMails, pushMessage);
await setPvpDefResultOnTime(pvpDefense, seasonNum, oldSeasonEndTime, addMails, pushMessage);
}
}
await MailModel.addMails(addMails);
@@ -61,22 +68,17 @@ export async function setPvpSeasonResult(obj:{ name:string, notSetNext?: boolean
pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(message.sid, message.uid, message.route, message.data);
}
}
return { seasonNum, seasonEndTime };
return { seasonNum, seasonEndTime, oldSeasonEndTime};
}
export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number, addMails: Array<MailType>, pushMessage:Array<any>) {
let role = await RoleModel.findByRoleId(pvpDefense.roleId);
if (!role) {
return;
}
let { score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, seasonEndTime);
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime, seasonEndTime});
let { roleName, lv, vLv, headHid, sHid, title } = role;
let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime: number, addMails: Array<MailType>, pushMessage:Array<any>) {
let { score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime);
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
//下发邮件
const doc = new MailModel();
const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: pvpDefense.seasonEndTime});
const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: oldSeasonEndTime});
addMails.push(mail);
let key = 'login_roleId_' + pvpDefense.roleId;
let sid = await getRedis(key);
@@ -86,14 +88,21 @@ export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNu
return pvpDefense;
}
export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime:number, rankLv?:number) {
let pvpRankRewards = getPvpRankRewards();
let pvpHeroRewards = getPvpHeroRewards();
let goods = [];
let rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId);// 排行榜排名
if (!rankLv) {
rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId);// 排行榜排名
}
let oldPLv = getLvByScore(pvpDefense.heroScores);
let { challengeCnt, challengeRefTime } = pvpDefense;
let pvpRankReward = getScore(pvpRankRewards, rankLv);
let pvpRankReward;
if (!!rankLv) {
pvpRankReward = getScore(pvpRankRewards, rankLv);
} else {
pvpRankReward = getResultMaxRank();
}
let rankGoods = [];
if(pvpRankReward) {
goods = goods.concat(pvpRankReward.reward);
@@ -120,24 +129,25 @@ export async function checkResult(pvpDefense: PvpDefenseType, seasonNum: number,
let pLv = getLvByScore(pvpDefense.heroScores);
await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, {
oldSeasonData:{refOppCnt: pvpDefense.refOppCnt, rankLv, score: pvpDefense.score, pLv: oldPLv, heroScores: deepCopy(pvpDefense.heroScores),
seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: pvpDefense.seasonEndTime
seasonNum: pvpDefense.seasonNum, challengeCnt, challengeRefTime, seasonEndTime: oldSeasonEndTime
}, heroGoods, rankGoods, show: true});
return { rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, seasonEndTime, goods};
return { rankLv, score, pLv, heroScores: pvpDefense.heroScores, seasonNum, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, oldSeasonEndTime, goods};
}
export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, oldSeasonEndTime:number) {
let role = await RoleModel.findByRoleId(pvpDefense.roleId);
if (!role) {
return;
}
let {score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, seasonEndTime);
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime, seasonEndTime});
let resultMaxRank = getResultMaxRank();
let rankLv = resultMaxRank.min;
let {score, pLv, heroScores, challengeCnt, challengeRefTime, goods } = await checkResult(pvpDefense, seasonNum, oldSeasonEndTime, rankLv);
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score, pLv, heroScores, seasonNum, challengeCnt, challengeRefTime});
let { roleName, lv, vLv, headHid, sHid, title , roleId } = role;
let params = new RankParam(roleName, lv, vLv, headHid, sHid, title);
setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
//下发邮件
let sendTime = seasonEndTime - PVP.PVP_SEASON_DAYS * PER_DAY;
let mail = await MailModel.addMail({roleId, goods, sendName: '系统', mailId: 1, sendTime: sendTime});
let mail = await MailModel.addMail({roleId, goods, sendName: '系统', mailId: 1, sendTime: oldSeasonEndTime});
let key = 'login_roleId_' + roleId;
let sid = await getRedis(key);
if (!!sid) {
@@ -162,13 +172,15 @@ export async function resetPvpWarId() {
async function setNextPvpTime(notSetNext: boolean) {
let {seasonEndTime, seasonNum} = await SystemConfigModel.findSystemConfig();
if (!!notSetNext) {
return { seasonEndTime, seasonNum };
return { seasonEndTime, seasonNum , oldSeasonEndTime: 0};
}
let oldSeasonEndTime = seasonEndTime;
seasonEndTime = (PVP.PVP_SEASON_DAYS) * PER_DAY + seasonEndTime;
await SystemConfigModel.updateSeason(seasonEndTime);
await SystemConfigModel.updateSeason(seasonEndTime, oldSeasonEndTime);
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
return { seasonEndTime, seasonNum: seasonNum + 1 };
seasonEndTimeJobId = scheduleJob((seasonEndTime - PER_MINUTE)* PER_SECOND, resetPvpRanks, { name: 'resetRank' });
return { seasonEndTime, seasonNum: seasonNum + 1, oldSeasonEndTime };
}
function getScore(arr, score) {
@@ -197,10 +209,11 @@ export async function resetPvpSeasonTime(hour: number) {
} else {
seasonEndTime = hour * 60 * 60 + getTodayZeroPoint();
seasonNum = systemConfig.seasonNum + 1;
await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum});
await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum, oldSeasonEndTime: 0});
await setPvpSeasonResult({name: 'simpleJobExample' + systemConfig.seasonNum, notSetNext: true });
}
let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
console.log('settleTime = ' + settleTime)
seasonJobId = scheduleJob(settleTime, setPvpSeasonResult, { name: 'setPvpSeasonResult' });
return { seasonEndTime, seasonNum };
}
}

9
shared/db/PvpDefense.ts
View File

@@ -22,7 +22,6 @@ export interface pvpUpdateInter {
challengeRefTime?:number;
isFirstEntry?:boolean;
receivedBox?: Array<number>;
seasonEndTime?:number;
isDefaultHero?:boolean;
}
@@ -143,8 +142,6 @@ export default class PvpDefense extends BaseModel {
receivedBox: Array<number>;
@prop({ required: true, default: 0 })
seasonNum: number;
@prop({ required: true, default: 0 })
seasonEndTime: number;
@prop({ required: true, default: true })
isFirstEntry: boolean;
public static async findByRoleId(roleId: string, lean = true) {
@@ -160,7 +157,7 @@ export default class PvpDefense extends BaseModel {
return result;
}
public static async createPvpDefense(params: { roleId: string, roleName: string, role: string, heroes: Array<Heroes>, oppPlayers: Array<OppPlayers>, defCe: number, seasonNum: number, seasonEndTime:number, challengeCnt: number }, lean = true) {
public static async createPvpDefense(params: { roleId: string, roleName: string, role: string, heroes: Array<Heroes>, oppPlayers: Array<OppPlayers>, defCe: number, seasonNum: number,challengeCnt: number }, lean = true) {
const doc = new PvpDefenseModel();
const update = Object.assign(doc.toJSON(), params);
const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: params.roleId }, update, { upsert: true, new: true }).lean(lean);
@@ -230,9 +227,9 @@ export default class PvpDefense extends BaseModel {
return result;
}
public static async getRank(page = 1, limit = 1000, lean = true) {
public static async getRank(seasonNum: number, page = 1, limit = 1000, lean = true) {
let sortBy = { score: -1, updatedAt: 1 };
const ranks: PvpDefenseType[] = await PvpDefenseModel.find().select('roleId role score updatedAt')
const ranks: PvpDefenseType[] = await PvpDefenseModel.find({seasonNum}).select('roleId role score updatedAt')
.populate('role', 'roleId roleName headHid sHid title lv vLv')
.sort(sortBy).limit(limit).skip((page - 1) * limit).lean(lean);
return ranks;

8
shared/db/SystemConfig.ts
View File

@@ -11,6 +11,8 @@ export default class SystemConfig extends BaseModel {
seasonNum: number; // 赛季
@prop({ required: true })
seasonEndTime: number; //赛季结束的时间
@prop({ required: true , default: 0 })
oldSeasonEndTime: number; //上赛季结束的时间
public static async findSystemConfig(lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOne({ id: 1 }).lean(lean);
return result;
@@ -21,13 +23,13 @@ export default class SystemConfig extends BaseModel {
return result;
}
public static async updateSystemConfig(update: { seasonEndTime?: number, warId?: number, seasonNum?:number }, lean = true) {
public static async updateSystemConfig(update: { seasonEndTime?: number, warId?: number, seasonNum?:number , oldSeasonEndTime?: number}, lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({ id: 1}, update, { upsert: true, new: true }).lean(lean);
return result;
}
public static async updateSeason( seasonEndTime: number, lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({ id: 1}, { seasonEndTime, $inc: { seasonNum: 1 } }, { upsert: true, new: true }).lean(lean);
public static async updateSeason( seasonEndTime: number, oldSeasonEndTime: number, lean = true) {
const result: SystemConfigType = await SystemConfigModel.findOneAndUpdate({ id: 1}, { seasonEndTime, $inc: { seasonNum: 1 }, oldSeasonEndTime }, { upsert: true, new: true }).lean(lean);
return result;
}
}

7
shared/pubUtils/data.ts
View File

@@ -41,7 +41,7 @@ import { dicPvpTeamLevel } from './dictionary/DicPvpTeamLevel';
import { dicPvpRefreshConsume, maxPvpRefreshCnt } from './dictionary/DicPvpRefreshConsume';
import { dicGkPvp, dicGkPvps } from './dictionary/DicGkPvp';
import { dicHeroRewads } from './dictionary/DicPvpHeroReward';
import { dicRankRewads } from './dictionary/DicPvpRankReward';
import { dicRankRewads, dicRankMax } from './dictionary/DicPvpRankReward';
import { dicPvpBoxs } from './dictionary/DicPvpBox';
export const gameData = {
blurprtCompose: dicBlueprtCompose,
@@ -101,6 +101,7 @@ export const gameData = {
pvpHeroRewards: dicHeroRewads,
pvpRankRewards: dicRankRewads,
pvpBoxs: dicPvpBoxs,
pvpRankMax: dicRankMax,
};
// 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -297,4 +298,8 @@ export function getPvpRankRewards() {
export function getPvpBoxs() {
return gameData.pvpBoxs;
}
export function getResultMaxRank() {
return gameData.pvpRankMax;
}

4
shared/pubUtils/dictionary/DicPvpRankReward.ts
View File

@@ -14,7 +14,11 @@ const str = readJsonFile(FILENAME.DIC_PVP_RANK_REWARD);
let arr = JSON.parse(str);
export const dicRankRewads = new Array<DicRankRewads>();
export var dicRankMax: DicRankRewads;
arr.forEach(o => {
o.reward = parseGoodStr(o.reward);
if (!dicRankMax||o.min > dicRankMax.min) {
dicRankMax = o;
}
dicRankRewads.push(o);
});