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

名将擂台：修复多处bug

Browse Source
This commit is contained in:
luying
2022-07-19 09:58:31 +08:00
parent d72f6ef080
commit 05d8449ca3
10 changed files with 10325 additions and 6837 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
game-server/app/servers/battle/handler/ladderHandler.ts
View File

@@ -1,18 +1,17 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { pick } from 'underscore';
import { isArray, pick } from 'underscore';
import { gameData } from '../../../pubUtils/data';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { LadderMatchModel, LadderUpdateInter } from '../../../db/LadderMatch';
import { battleEndWhenChange, checkRank, generateInitRecInfo, getBuyCntCost, getLadderData, getLadderOppDetailData, getLadderOppStatus, ladderBattleEndReward, refreshLadderDaily, refreshLadderEnemies, sendLadderDailyReward } from '../../../services/ladderService';
import { battleEndWhenChange, checkRank, generateInitRecInfo, generateOppPlayers, getBuyCntCost, getLadderData, getLadderEnemies, getLadderOppDetailData, getLadderOppStatus, getNumberArr, ladderBattleEndReward, refreshLadderDaily, refreshLadderEnemies, sendLadderDailyReward, uniqueArr } from '../../../services/ladderService';
import { LadderDataReturn, LadderDefense, LadderDefenseHero, LadderOppDetailReturn, LadderOppLineupReturn, LadderOppPlayerHeroInfo, LadderOppPlayerReturn } from '../../../domain/battleField/ladder';
import { LadderMatchRecModel } from '../../../db/LadderMatchRec';
import { HeroModel } from '../../../db/Hero';
import { LADDER } from '../../../pubUtils/dicParam';
import { handleCost } from '../../../services/role/rewardService';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS, REDIS_KEY } from '../../../consts';
import { getHeroesAttributes } from '../../../services/playerCeService';
import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
import { ServerlistModel } from '../../../db/Serverlist';
import { saveLadderDefCeByData } from '../../../services/redisService';
@@ -39,20 +38,19 @@ export class LadderHandler {
// 2. 获取对手阵容信息
async getOppLineup(msg: { roleId: string, rank: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleId: string = session.get('roleId');
let { roleId: targetRoleId, rank } = msg;
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let { oppPlayers = [] } = ladderData;
let curOppPlayer = oppPlayers.find(cur => cur.roleId == targetRoleId);
let isRobot = curOppPlayer? curOppPlayer.isRobot: false;
let isRobot = targetRoleId.startsWith('robot');
let result = new LadderOppLineupReturn();
result.setMyRank(ladderData.rank);
if(isRobot) {
let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
let dicWarJson = gameData.warJson.get(dicLadderDifficultRatio.gkId);
let dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
result.setRobot(dicLadderDifficultRatio, dicWarJson);
} else {
let hisLadderData = await LadderMatchModel.findByRoleIdAndInclude(targetRoleId);
@@ -71,8 +69,10 @@ export class LadderHandler {
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
if(!checkRank(myRank, rank)) return resResult(STATUS.LADDER_RANK_ERROR);
let { status, isRobot, hisLadderData } = await getLadderOppStatus(ladderData, targetRoleId, myRank, rank);
if(status != LADDER_OPP_STATUS.BATTLE) {
await LadderMatchModel.unlock(targetRoleId);
let oppPlayers = await refreshLadderEnemies(ladderData);
return resResult(STATUS.SUCCESS, {
status, oppPlayers
@@ -87,6 +87,7 @@ export class LadderHandler {
}
if(refOppObj.challengeCnt + 1 > LADDER.LADDER_CHALLENGE_FREE_TIMES + refOppObj.buyCnt) {
await LadderMatchModel.unlock(targetRoleId);
return resResult(STATUS.LADDER_CHALLENGE_CNT_MAX);
}
update.challengeCnt = refOppObj.challengeCnt + 1;
@@ -196,8 +197,8 @@ export class LadderHandler {
let { isChange, atkLadderMatch, defLadderMatch } = await LadderMatchModel.changeRank(isSuccess, rec.attackInfo, rec.defenseInfo);
if(isChange) {
let oppPlayers = await battleEndWhenChange(atkLadderMatch);
await battleEndWhenChange(defLadderMatch);
let oppPlayers = await battleEndWhenChange(atkLadderMatch, true);
await battleEndWhenChange(defLadderMatch, true);
result.setOppPlayers(oppPlayers);
rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess, atkLadderMatch.rank, defLadderMatch? defLadderMatch.rank: rec.attackInfo.oldRank);
if(atkLadderMatch.rank == 1) {
@@ -205,6 +206,8 @@ export class LadderHandler {
}
} else {
rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess);
let oppPlayers = await getLadderEnemies(atkLadderMatch);
result.setOppPlayers(oppPlayers);
}
await BattleRecordModel.updateBattleRecordByCode(battleCode, { $set: { status: isSuccess? 1: 2 } });
@@ -362,6 +365,43 @@ export class LadderHandler {
return resResult(STATUS.SUCCESS);
}
async setMyRank(msg: { magicWord: string, rank: number }, session: BackendSession) {
const { magicWord, rank } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
ladderData = await LadderMatchModel.updateByRoleId(roleId, { rank, historyRank: ladderData.historyRank < rank? ladderData.historyRank: rank });
await battleEndWhenChange(ladderData, false);
await LadderMatchModel.updateByRoleId(roleId, { refDaily: new Date(Date.now() - 86400000) });
return resResult(STATUS.SUCCESS);
}
async setMyOpp(msg: { magicWord: string, oppRanks: number[] }, session: BackendSession) {
const { magicWord, oppRanks } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.WRONG_PARMS);
}
if(!isArray(oppRanks) || oppRanks.length <= 0) return resResult(STATUS.WRONG_PARMS);
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let topTen = getNumberArr(1, 10);
let ranks = [...topTen, ...oppRanks];
let newRanks = uniqueArr(ranks.sort((a, b) => a - b));
await generateOppPlayers(newRanks, serverId, roleId);
return resResult(STATUS.SUCCESS);
}
async sendDailyReward(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {

53
game-server/app/services/ladderService.ts
View File

@@ -103,24 +103,27 @@ export async function getLadderMatchByRank(serverId: number, max: number|'+inf',
export async function refreshLadderEnemies(ladderData: LadderMatchType, update: LadderUpdateInter = {}) {
let rankNumbers = randOppRankNumbers(ladderData.rank); // 随机出想要的排名
return await generateOppPlayers(rankNumbers, ladderData.serverId, ladderData.roleId, update);
}
export async function generateOppPlayers(rankNumbers: number[], serverId: number, roleId: string, update: LadderUpdateInter = {}) {
let min = rankNumbers[0], max = rankNumbers[rankNumbers.length - 1];
let ranks = await getLadderMatchByRank(ladderData.serverId, max, min);
let ranks = await getLadderMatchByRank(serverId, max, min);
let oppPlayers: LadderOppPlayerReturn[] = [], oppPlayersSave: LadderOppPlayerInDB[] = [];
for(let rank of rankNumbers) {
let player = await generateOppPlayer(ladderData.serverId, rank, ranks);
let player = await generateOppPlayer(serverId, rank, ranks);
oppPlayersSave.push({ rank, roleId: player.roleId, isRobot: player.isRobot });
oppPlayers.push(player);
}
await LadderMatchModel.updateByRoleId(ladderData.roleId, { ...update, oppPlayers: oppPlayersSave });
await LadderMatchModel.updateByRoleId(roleId, { ...update, oppPlayers: oppPlayersSave });
return oppPlayers
}
async function generateOppPlayer(serverId: number, rank: number, oppPlayers: { rank: number, roleId: string, isRobot?: boolean }[]) {
let player = oppPlayers.find(cur => cur.rank == rank && !cur.isRobot);
let result = new LadderOppPlayerReturn(rank, !player);
if(player) {
let result = new LadderOppPlayerReturn(rank, !player || rank == 3001);
if(player && rank != 3001) {
let r = new Rank(REDIS_KEY.LADDER, { serverId }, false);
let param = <RoleRankInfo>await r.getParam(player.rank, player.roleId, [player.rank]);
let defCe = await getLadderDefCe(player.roleId);
@@ -144,14 +147,14 @@ function randOppRankNumbers(myRank: number) {
return uniqueArr(ranks.sort((a, b) => a - b));
}
function uniqueArr<T>(arr: T[]) {
export function uniqueArr<T>(arr: T[]) {
return arr.filter( (item, index, arr) => {
//当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
return arr.indexOf(item) === index;
});
}
function getNumberArr(from: number, to: number) {
export function getNumberArr(from: number, to: number) {
let arr: number[] = [];
for(let i = from; i <= to; i++) arr.push(i);
return arr;
@@ -187,6 +190,7 @@ export function checkRank(myRank: number, targetRank: number) {
if(myRank == 0 && targetRank == 3001) return true;
return false
}
if(myRank == targetRank) return false;
if(myRank < targetRank) { // 向后打
if(myRank + dicLadderMatch.rangeAfterMax < targetRank) return false;
} else { // 向前打
@@ -208,7 +212,7 @@ export async function getLadderOppStatus(ladderData: LadderMatchType, targetRole
if(curOppPlayer.isRobot) {
if(rank <= 3000) {
let hisLadderData = await LadderMatchModel.checkByRank(rank);
let hisLadderData = await LadderMatchRecModel.checkByRank(`robot${rank}`);
if(hisLadderData) return { status: LADDER_OPP_STATUS.OPP_RANK_CHANGE };
}
@@ -232,7 +236,8 @@ export async function getLadderOppStatus(ladderData: LadderMatchType, targetRole
export function generateInitRecInfo(isRobot: boolean, isDefense: boolean, rank: number, ladderData: LadderMatchType) {
if(isRobot) {
let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
let dicWarJson = gameData.warJson.get(dicLadderDifficultRatio.gkId)||[];
let dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId)||[];
let heroes: LadderOppPlayerHeroInfo[] = [];
for(let json of dicWarJson) {
@@ -274,6 +279,8 @@ function calculateDefCeByDefense(defense: LadderDefense) {
export async function ladderTimeout(battleCode: string, status: LADDER_STATUS) {
let rec = await LadderMatchRecModel.timeout(battleCode);
console.log('##### rec.defenseInfo', rec.defenseInfo, rec.defenseInfo.isRobot, rec.defenseInfo.roleId)
if(rec.defenseInfo && !rec.defenseInfo.isRobot) await LadderMatchModel.unlock(rec.defenseInfo.roleId);
if(status == LADDER_STATUS.CHECK) {
await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_CHECK_STOP, { battleCode });
} else if (status == LADDER_STATUS.BATTLE) {
@@ -287,7 +294,7 @@ export async function ladderTimeout(battleCode: string, status: LADDER_STATUS) {
* @param isAtk
* @returns
*/
export async function battleEndWhenChange(ladderMatch: LadderMatchType) {
export async function battleEndWhenChange(ladderMatch: LadderMatchType, needRefresh: boolean) {
if(!ladderMatch) return;
// 更新redis
@@ -298,13 +305,17 @@ export async function battleEndWhenChange(ladderMatch: LadderMatchType) {
}
// 刷新对手
let oppPlayers = await refreshLadderEnemies(ladderMatch);
await sendMessageToUserWithSuc(ladderMatch.roleId, PUSH_ROUTE.LADDER_RANK_UPDATE, {
oldRank: ladderMatch.oldRank,
newRank: ladderMatch.rank,
oppPlayers
});
return oppPlayers
if(needRefresh) {
let oppPlayers = await refreshLadderEnemies(ladderMatch);
await sendMessageToUserWithSuc(ladderMatch.roleId, PUSH_ROUTE.LADDER_RANK_UPDATE, {
oldRank: ladderMatch.oldRank,
newRank: ladderMatch.rank,
oppPlayers
});
return oppPlayers
} else {
return []
}
}
export async function ladderBattleEndReward(roleId: string, roleName: string, sid: string, rank: number, isSuccess: boolean, historyRank: number, num: number) {
@@ -358,7 +369,8 @@ export async function getLadderOppDetailData(rec: LadderMatchRecType) {
result.setByRobot(dicLadderDifficultRatio);
} else {
let hisLadderData = await LadderMatchModel.findByRoleIdAndInclude(rec.roleId2);
let dicWarJson = gameData.warJson.get(dicLadderDifficultRatio.gkId)
let dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
result.setByPlayer(hisLadderData, dicWarJson);
let attrByHid = await getHeroesAttributes(rec.roleId2);
for(let [hid, attribute] of attrByHid) {
@@ -366,4 +378,9 @@ export async function getLadderOppDetailData(rec: LadderMatchRecType) {
}
}
return result;
}
export async function clearLadderLock() {
await LadderMatchModel.clearLock();
await LadderMatchRecModel.clearLock();
}

3
game-server/app/services/sdk/ta.ts
View File

@@ -7,6 +7,9 @@ const KEY_NAME_MATCH_REGEX = /^[a-zA-Z#][a-zA-Z0-9_]+$/;
let util: any = {};
util.version = '1.2.2';
util.log = function(message: string) {
console.log(message);
}
util.each = function (obj, iterator, context) {
if (obj === null) {
return;

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

@@ -40,6 +40,7 @@ import { checkPopUpConditionWhenGuildActivityEnd } from './activity/popUpShopSer
import { pushRefreshTime } from './connectorService';
import { sendUnReceivedActivityDailyCoin } from './activity/dailyCoinService';
import { ladderTimeout, sendLadderDailyReward } from './ladderService';
import { clearLadderLock } from './ladderService';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
@@ -761,5 +762,6 @@ async function ladderDailyReward() {
await sendLadderDailyReward(serverId);
}
});
await clearLadderLock();
}
// —————————————— 名将擂台 end —————————————— //