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

获得战报，刷新，领取

Browse Source
This commit is contained in:
mamengke01
2021-01-08 16:16:51 +08:00
parent 099026869a
commit 12f308f0f5
14 changed files with 243 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
game-server/app/servers/battle/filter/checkEventFilter.ts
View File

@@ -1,5 +1,5 @@
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback} from "pinus";
import {checkEvent} from '../../../services/eventSercive';
import {checkEvent, getCurrentTime} from '../../../services/eventSercive';
module.exports = function(app: Application) {
return new Filter(app);
@@ -10,11 +10,12 @@ var Filter = function(this: any, app: Application) {
};
Filter.prototype.before = function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
next(null);
};
Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
getCurrentTime(session);
return checkEvent(session).then(()=>{
next(err);
}).catch(e => {

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

@@ -1,7 +1,7 @@
import {Application, BackendSession} from 'pinus';
const _ = require('underscore');
import { gameData } from '../../../pubUtils/data';
import { checkPvp, initPvpInfo, refreshEnemies, getEnemies, getPlusScore, getLvByScore, defaultHeroes, checkRoleIsRobot} from '../../../services/pvpService';
import { gameData, getPvpBoxs } from '../../../pubUtils/data';
import { checkPvp, initPvpInfo, refreshEnemies, getEnemies, getPlusScore, getLvByScore, defaultHeroes, comsumeChallengeCnt, refresh, findPvpDefByRoleId, checkRoleIsRobot } from '../../../services/pvpService';
import { RoleModel, RoleType } from '../../../db/Role';
import { STATUS } from '../../../consts/statusCode';
import { resResult, reduceCe, genCode } from '../../../pubUtils/util';
@@ -11,6 +11,7 @@ import { PvpDefenseModel, PvpDefenseType, OppPlayers } from '../../../db/PvpDefe
import { oppHeroesDefenseInter, pvpEndParamInter, RankParam, PlayerDetail, PlayerDetailHero } from '../../../pubUtils/interface';
import { PVP_HERO_POS, REDIS_KEY } from '../../../consts';
import { addItems } from '../../../services/rewardService';
import { HeroType, HeroModel } from '../../../db/Hero';
import { CeAttrNumber } from '../../../db/generalField';
import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
@@ -31,10 +32,10 @@ export class PvpHandler {
let roleId = session.get('roleId');
let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let oppPlayers = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
let {warId, seasonNum, seasonEndTime} = await SystemConfigModel.findSystemConfig();
let {heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry} = pvpDefense;
let { warId, seasonNum, seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry } = pvpDefense;
if (pvpDefense.seasonNum !== seasonNum) {
let { score, pLv, winStreakNum, heroScores, refOppCnt, challengeCnt, challengeRefTime } = await setPvpDefResult(pvpDefense, seasonNum);
let { score, pLv, winStreakNum, heroScores, refOppCnt, challengeCnt, challengeRefTime } = await setPvpDefResult(pvpDefense, seasonNum, seasonEndTime);
}
if (isFirstEntry) {
await PvpDefenseModel.updateInfo(roleId, {isFirstEntry:false});
@@ -143,10 +144,14 @@ export class PvpHandler {
let checkHeroes = await checkBattleHeroesByHid(roleId, heroes);
if(!checkHeroes) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
// TODO 检查挑战次数
const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
// 检查挑战次数
let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, pvpDefense.seasonEndTime);
if (challengeCnt == 0) {
return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
}
let { oppPlayers } = pvpDefense;
let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId);
if(!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
@@ -190,7 +195,7 @@ export class PvpHandler {
if(!flag) return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
// 更新军功
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
let {pvpDefense, warId} = await findPvpDefByRoleId(roleId);
if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
let { oppPlayers, winStreakNum, heroScores, score } = pvpDefense;
let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
@@ -274,20 +279,29 @@ export class PvpHandler {
$set: { status: isSuccess?1:2 }
}, true);
// TODO 增加挑战次数
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers: newOppPlayers, heroScores, score, pLv, winStreakNum });
// 增加挑战次数
let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, pvpDefense.seasonEndTime);
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers: newOppPlayers, heroScores, score, pLv, winStreakNum, challengeCnt, challengeRefTime });
let result = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
// 加入排行榜
let params = new RankParam(roleName, role.lv, role.vLv, role.headHid, role.sHid, role.title);
await setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
let myRank = await getMyRank(REDIS_KEY.PVP_RANK, 0, roleId);
return resResult(STATUS.SUCCESS, {
battleCode, isSuccess,
score, pLv, myRank,
heroScores: showHeroScores,
oppPlayers: result
oppPlayers: result,
seasonNum: pvpDefense.seasonNum,
seasonEndTime: pvpDefense.seasonEndTime,
refOppCnt: pvpDefense.refOppCnt,
challengeCnt: pvpDefense.challengeCnt,
challengeRefTime: pvpDefense.challengeRefTime,
hisScore: pvpDefense.hisScore,
winStreakNum: pvpDefense.winStreakNum,
warId
});
}
@@ -300,12 +314,14 @@ export class PvpHandler {
heroes = _.uniq(heroes, function(item) {
return item.order;
});
let { heroes: defHeros } = await PvpDefenseModel.findByRoleId(roleId);
let { heroes: defHeros, seasonEndTime, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
let defCe = 0;
let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
if (!!isDefaultHero) {
let role = await RoleModel.findByRoleId(roleId);
let { resHeroes } = await defaultHeroes(role);
return resResult(STATUS.SUCCESS, { data: { heroes: resHeroes } });
return resResult(STATUS.SUCCESS, { heroes: resHeroes, challengeCnt, challengeRefTime} );
} else {
for (let dataId = PVP_HERO_POS.START; dataId <= PVP_HERO_POS.END; dataId++) {
let index = _.findIndex(heroes, {dataId});
@@ -332,8 +348,8 @@ export class PvpHandler {
defHeros[defIndex].hero = hero._id;
defCe += hero.ce;
}
let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, {defCe, heroes: defHeros});
return resResult(STATUS.SUCCESS, { data: { heroes: resHeroes } });
let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, {defCe, heroes: defHeros, challengeCnt, challengeRefTime });
return resResult(STATUS.SUCCESS, { heroes: resHeroes, challengeCnt, challengeRefTime });
}
}
@@ -419,4 +435,35 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, result);
}
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');
let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime, seasonEndTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let pvpBoxs = getPvpBoxs();
let pvpBox = _.findWhere(pvpBoxs, {id})
if (hisScore < pvpBox.score) {
return resResult(STATUS.PVP_NOT_REACH_BOX_SCORE);
}
if (_.indexOf(receivedBox, id) != -1 ) {
return resResult(STATUS.PVP_BOX_IS_GOT);
}
receivedBox.push(id);
let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
await PvpDefenseModel.updateInfo(roleId, {receivedBox, challengeCnt, challengeRefTime});
let result = await addItems(roleId, roleName, sid, pvpBox.reward );
return resResult(STATUS.SUCCESS,{goods: result, receivedBox, challengeCnt, challengeRefTime});
}
async getRec(msg: {}, session: BackendSession ) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId);
return resResult(STATUS.SUCCESS, {list: pvpRecords});
}
}

4
game-server/app/servers/connector/handler/entryHandler.ts
View File

@@ -11,7 +11,7 @@ import { FUNC_OPT_TYPE } from '../../../consts';
import { getAp } from '../../../services/actionPointService';
import { ItemModel } from '../../../db/Item';
import { chackFunOpenWhenLogin } from '../../../services/funcSwitchService';
import { eventOnPlayerLvUp } from '../../../services/playerEventService';
import { loginRefresh } from '../../../services/playerEventService';
export default function (app: Application) {
return new EntryHandler(app);
}
@@ -77,6 +77,7 @@ export class EntryHandler {
let heros = await HeroModel.findByRole(role.roleId);
let equips = await EquipModel.findbyRole(role.roleId);
let items = await ItemModel.findbyRole(role.roleId);
await loginRefresh(role.roleId);
await chackFunOpenWhenLogin(role, session.get('funcs'));
role['heros'] = heros.map(cur => returnHeroCeRatio(cur));
@@ -86,7 +87,6 @@ export class EntryHandler {
role['apJson'] = apJson;
role['ce'] = reduceCe(role.ce);
role['topFiveCe'] = reduceCe(role.topFiveCe);
return resResult(STATUS.SUCCESS, { role });
}

7
game-server/app/services/eventSercive.ts
View File

@@ -407,3 +407,10 @@ export function checkQuiz(id: number, answer: number) {
answerNo: result?result.correct: 0
}
}
export function getCurrentTime(session: FrontendOrBackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let uids = [{uid: roleId, sid}];
pinus.app.get('channelService').pushMessageByUids('onPushCurrentTime', resResult(STATUS.SUCCESS, {time: Date.now()}), uids);
}

6
game-server/app/services/playerEventService.ts
View File

@@ -2,7 +2,7 @@
* 体力系统
*/
import { fromCallback } from 'bluebird';
import { checkPvp } from '../services/pvpService'
import { checkPvp, findPvpDefByRoleId } from '../services/pvpService'
import { getFuncsSwitch } from '../pubUtils/data';
import { FUNCS_ID, FUNC_OPT_TYPE } from '../consts/constModules/sysConst';
import { RoleModel } from '../db/Role'
@@ -24,3 +24,7 @@ export async function eventOnPlayerLvUp(roleId: string, lv: number, addFuncs: Ar
}
}
}
export async function loginRefresh(roleId: string) {
await findPvpDefByRoleId(roleId);
}

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

@@ -4,7 +4,7 @@
import { PvpDefenseModel, Heroes, OppPlayers, Robot, PvpDefenseType, HeroScores } from '../db/PvpDefense';
import { RoleType } from '../db/Role';
import { PVP_HERO_POS, ROBOT_NAME, REDIS_KEY } from '../consts';
import { setPvpDefResult } from '../services/timeTaskService';
import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
import { getRandomIndexByLen, genCode, getRandomByLen } from '../pubUtils/util';
import { oppPlayersInter, RankParam } from '../pubUtils/interface';
@@ -12,6 +12,7 @@ import { gameData, getPLvByScore } from "../pubUtils/data";
import { PVP } from '../pubUtils/dicParam';
import { SystemConfigModel } from '../db/SystemConfig'
import { setRank, getMyRank } from './redisService';
import { nowSeconds, checkTodayTime } from '../pubUtils/timeUtil';
const _ = require('underscore');
@@ -31,9 +32,9 @@ export async function initPvpInfo(role: RoleType) {
}
//初始化对手人阵容
let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 1);
let {warId, seasonNum } = await SystemConfigModel.findSystemConfig();
let {warId, seasonNum, seasonEndTime} = 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, warId, challengeCnt });
let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id, heroes, oppPlayers, defCe: role.topFiveCe, seasonNum, seasonEndTime, challengeCnt });
//加入排行榜
let { roleId, roleName, lv, vLv, headHid, sHid, title } = role;
@@ -185,7 +186,7 @@ export function getLvByScore(heroScores: HeroScores[]) {
return getPLvByScore(score);
}
export async function defaultHeroes ( role:RoleType) {
export async function defaultHeroes ( role:RoleType, challengeCnt?:number, challengeRefTime?:number,) {
let { heroes } = await PvpDefenseModel.findByRoleId(role.roleId);
heroes.sort(function(a, b) {
return a.ce + a.dataId - b.ce + b.dataId;
@@ -214,6 +215,55 @@ export async function defaultHeroes ( role:RoleType) {
}
defCe += item.ce;
}
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes});
return { resHeroes};
}
if (!!challengeCnt && !!challengeRefTime) {
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes, challengeCnt, challengeRefTime});
return { resHeroes};
} else {
let { heroes: resHeroes} = await PvpDefenseModel.updateInfo(role.roleId, {defCe, heroes});
return { resHeroes};
}
}
export function refresh(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
return {challengeCnt, challengeRefTime};
}
let period = PVP.PVP_CHALLENGE_NORMALTIMES;
if (checkTodayTime(seasonEndTime)) {
period = PVP.PVP_CHALLENGE_FINALTIMES;
}
let time = nowSeconds();
let num = Math.floor(( time - challengeRefTime)/period);
if (num > 0) {
challengeCnt += num;
challengeRefTime = challengeRefTime + period * num;
}
return {challengeCnt, challengeRefTime};
}
export function comsumeChallengeCnt( challengeCnt: number, challengeRefTime: number, seasonEndTime:number ) {
challengeCnt--;
if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
return {challengeCnt, challengeRefTime};
}
if (challengeCnt == PVP.PVP_CHALLENGE_COUNTS - 1) {
challengeRefTime = nowSeconds();
return {challengeCnt, challengeRefTime};
}
return refresh(challengeCnt, challengeRefTime, seasonEndTime);
}
export async function findPvpDefByRoleId(roleId: string) {
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
let {warId, seasonNum, seasonEndTime} = await SystemConfigModel.findSystemConfig();
if (pvpDefense.seasonNum !== seasonNum) {
let newPvpDefense = await setPvpDefResult(pvpDefense, seasonNum, seasonEndTime);
return {pvpDefense: newPvpDefense, warId};
} else {
let {challengeCnt, challengeRefTime} = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, pvpDefense.seasonEndTime)
if (challengeCnt != pvpDefense.challengeCnt) {
pvpDefense = await PvpDefenseModel.updateInfo( roleId, { challengeCnt, challengeRefTime});
}
return {pvpDefense, warId};
}
}

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

@@ -38,14 +38,16 @@ export async function init() {
export async function setPvpSeasonResult(obj:{ name:string }) {
console.log('exce setPvpSeasonResult'+ obj.name);
let { seasonNum } = await setNextPvpTime();
let { seasonNum, seasonEndTime } = await setNextPvpTime();
let pvpDefenses = await PvpDefenseModel.getPvpDef(LIMIT_NUM);
for (let pvpDefense of pvpDefenses) {
await setPvpDefResult(pvpDefense, seasonNum);
if (pvpDefense.seasonNum !== seasonNum) {
await setPvpDefResult(pvpDefense, seasonNum, seasonEndTime);
}
}
}
export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number) {
export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number) {
let pvpRankRewards = getPvpRankRewards();
let pvpHeroRewards = getPvpHeroRewards();
let goods = [];
@@ -61,7 +63,7 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
score += heroScore.score;
}
let pLv = getPLvByScore(score);
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score:score, pLv, heroScores: pvpDefense.heroScores, winStreakNum:0, seasonNum, refOppCnt:0, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0});
pvpDefense = await PvpDefenseModel.updateInfo(pvpDefense.roleId, {score:score, pLv, heroScores: pvpDefense.heroScores, winStreakNum:0, seasonNum, refOppCnt:0, challengeCnt:PVP.PVP_CHALLENGE_COUNTS, challengeRefTime:0, seasonEndTime});
//TODO 下发邮件
return pvpDefense;
}

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

@@ -296,6 +296,7 @@ export const FILENAME = {
DIC_PVP_REFRESHCONSUME: 'dic_pvp_refreshConsume',
DIC_PVP_HERO_REWARD: 'dic_pvp_heroAccountReward',
DIC_PVP_RANK_REWARD: 'dic_pvp_rankReward',
DIC_PVP_BOX: 'dic_pvp_boxReward',
}
export const WAR_RELATE_TABLES = [

4
shared/consts/statusCode.ts
View File

@@ -182,6 +182,10 @@ export const STATUS = {
ROLE_SCHOOL_POSITION_LOCKED: {code: 30604, simStr: '该位置未解锁'},
ROLE_SCHOOL_POSITION_UNLOCK_NOT_NEED: {code: 30605, simStr: '该位置已解锁'},
ROLE_SCROLL_REACH_MAX: {code: 30606, simStr: '已经升到可以升的最高等级'},
// pvp 30800-30899
PVP_NOT_REACH_BOX_SCORE: {code: 30800, simStr: '未达到宝箱领取军功'},
PVP_BOX_IS_GOT: {code: 30801, simStr: '宝箱已经领取'},
PVP_CHALLENGE_TIMES_NOT_ENOUGH: {code: 30802, simStr: '挑战次数不足'},
// 社交相关状态 40000 - 49999
// 运营模块相关状态 50000 - 59999

6
shared/db/PvpDefense.ts
View File

@@ -19,6 +19,8 @@ interface pvpUpdateInter {
challengeCnt?:number;
challengeRefTime?:number;
isFirstEntry?:boolean;
receivedBox?: Array<number>;
seasonEndTime?:number;
}
export class Heroes {
@@ -138,6 +140,8 @@ 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) {
@@ -150,7 +154,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, warId: 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, seasonEndTime: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);

107
shared/db/PvpRecord.ts
View File

@@ -3,70 +3,75 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
export class HeroesRecord {
@prop({ required: true, default: 0 })
hid: number; // 武将id
@prop({ required: true, default: 0 })
quality: number; // 品质
@prop({ required: true, default: 0 })
star: number; // 星级
@prop({ required: true, default: 0 })
colorStar: number; // 觉醒
@prop({ required: true, default: 0 })
lv: number; // 等级
@prop({ required: true, default: 0 })
damage: number; // 伤害
@prop({ required: true, default: 0 })
heal: number; // 治疗
@prop({ required: true, default: 0 })
underDamage: number; // 承伤
@prop({ required: true, default: 0 })
hid: number; // 武将id
@prop({ required: true, default: 0 })
quality: number; // 品质
@prop({ required: true, default: 0 })
star: number; // 星级
@prop({ required: true, default: 0 })
colorStar: number; // 觉醒
@prop({ required: true, default: 0 })
lv: number; // 等级
@prop({ required: true, default: 0 })
damage: number; // 伤害
@prop({ required: true, default: 0 })
heal: number; // 治疗
@prop({ required: true, default: 0 })
underDamage: number; // 承伤
}
export class PlayerInfo {
@prop({ required: true })
roleId: string; // 角色 id
@prop({ required: true })
roleName: string; // 角色 名
@prop({ required: true, default: 0 })
lv: number; // 等级
@prop({ required: true, default: 0 })
sHid: number; // 形象
@prop({ required: true, default: 0 })
headHid: number; // 头像
@prop({ required: true, default: 0 })
title: number; // 爵位
@prop({ required: true, default: 0 })
ce: number; // 最高五人战力
@prop({ required: true, default: false })
isSuccess: boolean; // 是否胜利
@prop({ required: true, default: 0 })
score: number; // 获得的总积分
@prop({ required: true, type: HeroesRecord, default: [], _id: false })
heroes: HeroesRecord[]; // 获得的总积分
@prop({ required: true })
roleId: string; // 角色 id
@prop({ required: true })
roleName: string; // 角色 名
@prop({ required: true, default: 0 })
lv: number; // 等级
@prop({ required: true, default: 0 })
sHid: number; // 形象
@prop({ required: true, default: 0 })
headHid: number; // 头像
@prop({ required: true, default: 0 })
title: number; // 爵位
@prop({ required: true, default: 0 })
ce: number; // 最高五人战力
@prop({ required: true, default: false })
isSuccess: boolean; // 是否胜利
@prop({ required: true, default: 0 })
score: number; // 获得的总积分
@prop({ required: true, type: HeroesRecord, default: [], _id: false })
heroes: HeroesRecord[]; // 获得的总积分
}
@index({ roleId1: 1, updatedAt: -1 })
@index({ roleId2: 1, updatedAt: -1 })
export default class PvpRecord extends BaseModel {
@prop({ required: true })
roleId1: string; // 角色 id
@prop({ required: true })
roleId2: string; // 角色 id
@prop({ required: true })
roleId1: string; // 角色 id
@prop({ required: true })
roleId2: string; // 角色 id
@prop({ required: true, default: 0 })
warId: number; // 这一关使用的地图
@prop({ required: true, type: PlayerInfo, default: {}, _id: false })
attackInfo: PlayerInfo; // 攻方信息
@prop({ required: true, type: PlayerInfo, default: {}, _id: false })
defenseInfo: PlayerInfo; // 守方信息
@prop({ required: true, default: 0 })
warId: number; // 这一关使用的地图
@prop({ required: true, type: PlayerInfo, default: {}, _id: false })
attackInfo: PlayerInfo; // 攻方信息
@prop({ required: true, type: PlayerInfo, default: {}, _id: false })
defenseInfo: PlayerInfo; // 守方信息
public static async createRec(param: { roleId1: string, roleId2: string, warId: number, attackInfo: PlayerInfo, defenseInfo: PlayerInfo}, lean = true) {
const result = await PvpRecordModel.findOneAndUpdate({}, param, { new: true, upsert: true }).lean();
return result;
}
public static async createRec(param: { roleId1: string, roleId2: string, warId: number, attackInfo: PlayerInfo, defenseInfo: PlayerInfo }, lean = true) {
const result = await PvpRecordModel.findOneAndUpdate({}, param, { new: true, upsert: true }).lean();
return result;
}
public static async getRecByRoleId( roleId: string, lean = true) {
const result: PvpRecord[] = await PvpRecordModel.find({ $or:[{roleId1: roleId}, {roleId2: roleId}] }).lean(lean);
return result;
}
}
export const PvpRecordModel = getModelForClass(PvpRecord);
export interface PvpRecordType extends Pick<DocumentType<PvpRecord>, keyof PvpRecord>{};
export interface PvpRecordType extends Pick<DocumentType<PvpRecord>, keyof PvpRecord> { };

6
shared/pubUtils/data.ts
View File

@@ -42,6 +42,7 @@ import { dicPvpRefreshConsume } from './dictionary/DicPvpRefreshConsume';
import { dicGkPvp, dicGkPvps } from './dictionary/DicGkPvp';
import { dicHeroRewads } from './dictionary/DicPvpHeroReward';
import { dicRankRewads } from './dictionary/DicPvpRankReward';
import { dicPvpBoxs } from './dictionary/DicPvpBox';
export const gameData = {
blurprtCompose: dicBlueprtCompose,
blueprtPossibility: dicBlueprtPossibility,
@@ -98,6 +99,7 @@ export const gameData = {
pvpGks: dicGkPvps,
pvpHeroRewards: dicHeroRewads,
pvpRankRewards: dicRankRewads,
pvpBoxs: dicPvpBoxs,
};
// 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -290,4 +292,8 @@ export function getPvpHeroRewards() {
export function getPvpRankRewards() {
return gameData.pvpRankRewards;
}
export function getPvpBoxs() {
return gameData.pvpBoxs;
}

20
shared/pubUtils/dictionary/DicPvpBox.ts Normal file
View File

@@ -0,0 +1,20 @@
import { readJsonFile, parseGoodStr } from '../util'
import { FILENAME } from '../../consts'
import { RewardInter } from '../interface';
export interface DicPvpBox {
readonly id: number;
readonly score: number;
readonly reward: Array<RewardInter>;
}
const str = readJsonFile(FILENAME.DIC_PVP_BOX);
let arr = JSON.parse(str);
export const dicPvpBoxs = new Array<DicPvpBox>();
arr.forEach(o => {
o.reward = parseGoodStr(o.reward);
dicPvpBoxs.push(o);
});

9
shared/pubUtils/timeUtil.ts
View File

@@ -1,5 +1,7 @@
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
export function nowSeconds() {
return Math.floor(Date.now() / PER_SECOND );
}
@@ -11,4 +13,11 @@ export function getTodayZeroPoint() {
date.setSeconds(0);
var time = Math.floor(date.getTime() / PER_SECOND);
return time;
}
export function checkTodayTime(seasonEndTime: number) {
if (seasonEndTime - nowSeconds() <= PER_DAY) {
return true;
}
return false;
}