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

✨ feat(巅峰演武): 军功修改、匹配修改、新增挑战次数购买接口

Browse Source
This commit is contained in:
zhangxk
2023-10-12 21:20:26 +08:00
parent 778a31db7f
commit 00059fa2c2
9 changed files with 221 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,10 +3,10 @@ import { WAR_TYPE } from './../../../consts/constModules/battleConst';
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { findIndex } from 'underscore';
import { gameData, getPvpBoxBySeasonNumAndIndex } from '../../../pubUtils/data';
import { refreshEnemies, getEnemies, refChallengeCnt, generPVPOppRecInfo, generMyRecInfo, sendLastSeasonRewardIfNotSent, refreshRefOppCnt, generPvpLineupCe, calLineupScore, checkPvpSeasonIsStart, checkPvpSeasonIsSummit, getPvpSeasonStatus, checkPvpSeasonIsWaiting } from '../../../services/pvpService';
import { refreshEnemies, getEnemies, refChallengeCnt, generPVPOppRecInfo, generMyRecInfo, sendLastSeasonRewardIfNotSent, refreshRefOppCnt, generPvpLineupCe, calLineupScore, checkPvpSeasonIsStart, checkPvpSeasonIsSummit, getPvpSeasonStatus, checkPvpSeasonIsWaiting, refreshBuyChallengeCnt } from '../../../services/pvpService';
import { RoleModel, RoleType } from '../../../db/Role';
import { STATUS } from '../../../consts/statusCode';
import { resResult, genCode, checkRoleIsRobot, robotIdComBack } from '../../../pubUtils/util';
import { resResult, genCode, checkRoleIsRobot, robotIdComBack, parseGoodStr } from '../../../pubUtils/util';
import { PvpDefenseModel, pvpUpdateInter } from '../../../db/PvpDefense';
import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
import { Rank } from '../../../services/rankService';
@@ -17,7 +17,7 @@ import { PVP } from '../../../pubUtils/dicParam';
import { addItems, getGoldObject, handleCost, unlockFigure } from '../../../services/role/rewardService';
import { pick } from "underscore";
import { HeroModel } from '../../../db/Hero';
import PvpHistoryOpp, { PvpHistoryOppModel } from '../../../db/PvpHistoryOpp';
import PvpHistoryOpp, { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { PvpRecordModel, PvpRecordParam, PvpRecordType } from '../../../db/PvpRecord';
import { pvpEndParamInter } from '../../../pubUtils/interface';
@@ -77,6 +77,10 @@ export class PvpHandler {
update = { ...update, ...refOppObj }
}
if (refreshBuyChallengeCnt(pvpDefense.buyChallengeTime)) {
update = { ...update, buyChallengeCnt: 0, buyChallengeTime: Date.now() };
}
if(Object.keys(update).length > 0) {
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
}
@@ -695,6 +699,144 @@ export class PvpHandler {
});
}
async buyChallengeCnt(msg: { count: number }, session: BackendSession) {
let { count } = msg;
let roleId = session.get('roleId');
let sid: string = session.get('sid');
let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
let isRefreshBuyChallengeCnt = refreshBuyChallengeCnt(pvpDefense.buyChallengeTime);
if (isRefreshBuyChallengeCnt) pvpDefense.buyChallengeCnt = 0;
if (count + pvpDefense.buyChallengeCnt > PVP.PVP_CHALLENGE_COST_TIMES) {
return resResult(STATUS.PVP_CAN_NOT_BUY_CHALLENGE_CAT);
}
let cost = parseGoodStr(PVP.PVP_CHALLENGE_BUY_TIMES_COST);
for (let cur of cost) {
cur.count = cur.count * count;
}
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.PVP_BUY_CHALLENGE_CNT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 刷新次数
let refChallengeObj = await refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime, roleId, session.get('vipStartTime'));
let challengeCnt = refChallengeObj.challengeCnt + count;
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { challengeCnt, buyChallengeCnt: pvpDefense.buyChallengeCnt + count, buyChallengeTime: Date.now() });
if (!pvpDefense) return resResult(STATUS.PVP_BUY_CHALLENGE_FAIL)
return resResult(STATUS.SUCCESS, { challengeCnt: pvpDefense.challengeCnt, buyChallengeCnt: pvpDefense.buyChallengeCnt })
}
async sweep(msg: { warId: number, oppRoleId: string }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
const serverId = session.get('serverId');
const { warId, oppRoleId } = msg;
let warInfo = gameData.war.get(warId);
if (!warInfo) {
return resResult(STATUS.BATTLE_MISS_INFO);
}
const role = await RoleModel.findByRoleId(roleId, null, true);
if (!role || role.lv < 50) return resResult(STATUS.PVP_NOT_OPEN);
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
let { hisWinStreakNum = 0 } = pvpDefense;
// 检查挑战次数
let seasonNum: number = this.app.get('pvpSeasonNum');
let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
let { challengeCnt, challengeRefTime } = await refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime, roleId, session.get('vipStartTime'));
if (challengeCnt == 0) {
return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
}
let { attackCe } = PvpDataReturn.getAttackAndDefenseCe(pvpDefense);
let curOpp = pvpDefense.oppPlayers.find(cur => cur.roleId == oppRoleId);
if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
let oppDef = <PvpHistoryOppType>curOpp.oppDef;
// 战力检测
console.log('xxxxxxxxxxxxxxxxxxxxxxxxx attackCe',attackCe)
console.log('xxxxxxxxxxxxxxxxxxxxxxxxx oppDef',oppDef)
if (attackCe <= oppDef.defCe) return resResult(STATUS.PVP_SWEEP_NOT_CE);
// 对手记录更新
await PvpHistoryOppModel.setStatus(curOpp.oppDef.toString(), 1);
// 战斗记录
const battleCode = genCode(8) + '_sweep'; // 关卡唯一值
let heroes = pvpDefense.attack.heroes.map(cur => cur.actorId);
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId: warId,
status: 0,
warName: warInfo.gk_name,
warType: warInfo.warType,
record: { heroes, pos: curOpp.pos, oppRoleId, pvpSeasonNum: seasonNum }
}
}, true);
let update: pvpUpdateInter = {};
const myHeroes: pvpEndParamInter[] = heroes.map(hid => { return { hid, damage: 0, heal: 0, underDamage: 0 } })
const myRecInfo = await generMyRecInfo(pvpDefense, role, true, curOpp.pos, myHeroes);
let { attackInfo, showHeroScores, updateParam } = myRecInfo
update = { ...update, ...updateParam };
const oppHeroes: pvpEndParamInter[] = oppDef.heroes.map(cur => { return { hid: cur.actorId, damage: 0, heal: 0, underDamage: 0 } })
const defenseInfo = await generPVPOppRecInfo(true, curOpp, oppHeroes, serverId);
update = { ...update, oppBeforePlayers: pvpDefense.oppPlayers };
// 刷新对手
let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.score, pvpDefense.attack.pLv || 1);
update.oppPlayers = oppPlayers;
// 减少挑战次数
let refChallengeObj = await refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime, roleId, session.get('vipStartTime'));
refChallengeObj.challengeCnt--;
update = { ...update, ...refChallengeObj };
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
let result = new PvpDataReturn(); // 返回对象
result.setPvpDefense(pvpDefense);
// 加入排行榜
let groupId = await getPVPGroupIdOfServer(serverId);
let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum, groupId });
await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
if (defenseInfo && defenseInfo.score > 0) await r.setRankWithRoleInfo(defenseInfo.roleId, defenseInfo.score, pvpDefense.updatedAt.getTime(), null, true);
let myRank = await r.getMyRank({ roleId });
result.setMyRank(myRank);
let oppPlayersReturn = await getEnemies(r, pvpDefense.oppPlayers, pvpDefense.winStreakNum);
result.setOppPlayers(oppPlayersReturn);
await checkTaskInPvpEnd(serverId, roleId, sid, true, pvpDefense.heroScores, pvpDefense.seasonWinNum);
if (hisWinStreakNum < pvpDefense.hisWinStreakNum) {
await unlockFigure(sid, roleId, [{ type: FIGURE_UNLOCK_CONDITION.PVP_WIN_SERIES, paramWinStreakNum: pvpDefense.hisWinStreakNum }]);
}
return resResult(STATUS.SUCCESS, {
battleCode, isSuccess: true,
heroScores: showHeroScores,
createdAt: getSeconds(new Date()),
...pick(result, ['score', 'myRank', 'winStreakNum', 'attack', 'oppPlayers', 'challengeCnt', 'challengeRefTime', 'seasonWinNum'])
});
}
// debug接口

11
game-server/app/services/checkParam.ts
View File

@@ -769,6 +769,17 @@ export function checkRouteParam(route: string, msg: any) {
if (!checkNaturalNumbers(msg.id)) return false;
break;
}
case "battle.pvpHandler.buyChallengeCnt":
{
if (!checkNaturalNumbers(msg.count)) return false;
break;
}
case "battle.pvpHandler.sweep":
{
if (!checkNaturalNumbers(msg.warId)) return false;
if (!checkNaturalStrings(msg.oppRoleId)) return false;
break;
}
case "battle.ladderHandler.getOppLineup":
{
if (!checkNaturalStrings(msg.roleId)) return false;

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

@@ -2,14 +2,14 @@
import { PvpDefenseModel, PvpDefenseType, pvpUpdateInter } from '../db/PvpDefense';
import { Defense, Attack, LineupCe, OppPlayer, HeroScore, HeroReward, OppPlayerReturn, AttackHero, DefenseHero } from '../domain/battleField/pvp';
import { RoleType } from '../db/Role';
import { REDIS_KEY, TASK_TYPE, MAIL_TYPE, TA_EVENT, ITID, getHeadItid, getFrameItid, getSpineItid, PVP_SEASON_STATUS } from '../consts';
import { REDIS_KEY, TASK_TYPE, MAIL_TYPE, TA_EVENT, ITID, getHeadItid, getFrameItid, getSpineItid, PVP_SEASON_STATUS, SHOP_REFRESH_TYPE } from '../consts';
import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
import { getRandSingleIndex, genCode, shouldRefresh, getChineseName, makeRobotId, robotIdComBack, getRandSingleEelm } from '../pubUtils/util';
import { pvpEndParamInter, RewardInter } from '../pubUtils/interface';
import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByRank, getPvpDifficultByScore, getPlvAndScore, getPvpBoxsBySeasonNum, getPvpRankMaxRewardsBySeasonNum, randomGoodsByItid } from "../pubUtils/data";
import { EXTERIOR, PVP } from '../pubUtils/dicParam';
import { PVPConfigModel } from '../db/PvpConfig'
import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
import { nowSeconds, getTimeFun, getZeroPointD } from '../pubUtils/timeUtil';
import { HeroesRecord, PvpRecordPlayerInfo } from '../db/PvpRecord';
import { HeroModel, HeroType } from '../db/Hero';
import { AttributeCal } from '../domain/roleField/attribute';
@@ -539,36 +539,36 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayer,
}
let addSumScore = 0;
let pvpDefense = curOpp.isRobot? null: await PvpDefenseModel.findByRoleId(robotIdComBack(curOpp.roleId));
if(pvpDefense && !isSuccess) {
if(pvpDefense && pvpDefense.defense) {
let { attack, defense, heroScores, score, defenseScoreCnt, refDefenseScore } = pvpDefense;
if(shouldRefresh(refDefenseScore, new Date())) {
defenseScoreCnt = 0; refDefenseScore = new Date();
}
if(defenseScoreCnt < PVP.PVP_DEFENSE_SUCCESS_REWARD_MAX_CNT) {
for(let { actorId } of defense.heroes) {
let hs = heroScores.find(cur => cur.hid == actorId);
const dicOpp = gameData.pvpOpponent.get(curOpp.pos);
let addScore = PVP.PVP_DEFENSE_SUCCESS_REWARD - dicOpp.score;
if(hs) {
hs.score += addScore;
} else {
heroScores.push({ hid: actorId, score: addScore })
}
addSumScore += addScore;
}
// if(pvpDefense && !isSuccess) {
// if(pvpDefense && pvpDefense.defense) {
// let { attack, defense, heroScores, score, defenseScoreCnt, refDefenseScore } = pvpDefense;
// if(shouldRefresh(refDefenseScore, new Date())) {
// defenseScoreCnt = 0; refDefenseScore = new Date();
// }
// if(defenseScoreCnt < PVP.PVP_DEFENSE_SUCCESS_REWARD_MAX_CNT) {
// for(let { actorId } of defense.heroes) {
// let hs = heroScores.find(cur => cur.hid == actorId);
// const dicOpp = gameData.pvpOpponent.get(curOpp.pos);
// let addScore = PVP.PVP_DEFENSE_SUCCESS_REWARD - dicOpp.score;
// if(hs) {
// hs.score += addScore;
// } else {
// heroScores.push({ hid: actorId, score: addScore })
// }
// addSumScore += addScore;
// }
let newAttack = <Attack>calLineupScore(attack, heroScores);
let newDefense = <Defense>calLineupScore(defense, heroScores);
// let newAttack = <Attack>calLineupScore(attack, heroScores);
// let newDefense = <Defense>calLineupScore(defense, heroScores);
await PvpDefenseModel.updateInfo(pvpDefense.roleId, { attack: newAttack, defense: newDefense, heroScores, score: score + addSumScore, defenseScoreCnt: defenseScoreCnt + 1, refDefenseScore });
// await PvpDefenseModel.updateInfo(pvpDefense.roleId, { attack: newAttack, defense: newDefense, heroScores, score: score + addSumScore, defenseScoreCnt: defenseScoreCnt + 1, refDefenseScore });
} else {
await PvpDefenseModel.updateInfo(pvpDefense.roleId, { defenseScoreCnt: defenseScoreCnt + 1, refDefenseScore });
}
}
}
// } else {
// await PvpDefenseModel.updateInfo(pvpDefense.roleId, { defenseScoreCnt: defenseScoreCnt + 1, refDefenseScore });
// }
// }
// }
let defenseInfo = new PvpRecordPlayerInfo();
defenseInfo.setByHistoryOpp(oppRole, oppHeroRecords, !isSuccess, isSuccess ? 0 : addSumScore, pvpDefense?.serverId||serverId)
@@ -697,8 +697,8 @@ export async function savePvpSeasonResult(pvpDefense: PvpDefenseType, seasonNum:
}
newScore += pvpHeroReward.heroscore;
} else {
newHeroScores.push(heroScore);
newScore += heroScore.score;
newHeroScores.push({...heroScore, score:0});
// newScore += heroScore.score;
}
}
@@ -793,4 +793,12 @@ export function checkPvpSeasonIsSummit() {
export function checkPvpSeasonIsWaiting() {
let status = getPvpSeasonStatus();
return status == PVP_SEASON_STATUS.WAITING;
}
export function refreshBuyChallengeCnt(buyChallengeTime:number = 0){
let refTime = getZeroPointD(SHOP_REFRESH_TYPE.DAILY);
if(refTime.getTime() > buyChallengeTime){
return true
}
return false;
}