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

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

Browse Source
This commit is contained in:
qiaoxin
2021-07-20 19:07:48 +08:00
parent 05ffcdee7d
commit 1779f0ae33
8 changed files with 405 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-server/app/services/pvpService.ts
+113 -106
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);
}