名将擂台：修复多处bug

game-server/app/servers/battle/handler/ladderHandler.ts

@@ -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 isRobot = targetRoleId.startsWith('robot');
-        let curOppPlayer = oppPlayers.find(cur => cur.roleId == targetRoleId);
-        let isRobot = curOppPlayer? curOppPlayer.isRobot: false;
         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);
+            let oppPlayers = await battleEndWhenChange(atkLadderMatch, true);
-            await battleEndWhenChange(defLadderMatch);
+            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) {

game-server/app/services/ladderService.ts

@@ -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);
+    let result = new LadderOppPlayerReturn(rank, !player || rank == 3001);
-    if(player) {
+    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);
+    if(needRefresh) {
-    await sendMessageToUserWithSuc(ladderMatch.roleId, PUSH_ROUTE.LADDER_RANK_UPDATE, {
+        let oppPlayers = await refreshLadderEnemies(ladderMatch);
-        oldRank: ladderMatch.oldRank,
+        await sendMessageToUserWithSuc(ladderMatch.roleId, PUSH_ROUTE.LADDER_RANK_UPDATE, {
-        newRank: ladderMatch.rank,
+            oldRank: ladderMatch.oldRank,
-        oppPlayers
+            newRank: ladderMatch.rank,
-    });
+            oppPlayers
-    return 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();
 }

game-server/app/services/sdk/ta.ts

@@ -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;

game-server/app/services/timeTaskService.ts

@@ -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 —————————————— //

shared/db/LadderMatch.ts

@@ -41,15 +41,10 @@ export default class LadderMatch extends BaseModel {
         return result;
     }
 
-    public static async checkByRank(rank: number) {
-        const result = await LadderMatchModel.exists({ rank });
-        return result;
-    }
-
     public static async findByRoleIdAndInclude(roleId: string) {
         const result: LadderMatchType = await LadderMatchModel.findOne({ roleId })
             .populate('role', 'roleId roleName head frame spine heads frames spines title lv updatedAt')
-            .populate('defense.heroes', 'hid skinId quality star colorStar lv')
+            .populate('defense.heroes.hero', 'hid skinId quality star colorStar lv')
             .lean();
         return result;
     }
@@ -71,7 +66,7 @@ export default class LadderMatch extends BaseModel {
     public static async updateByRoleIdAndInclude(roleId: string, params: LadderUpdateInter) {
         const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: params}, { new: true })
         .populate('role', 'roleId roleName head frame spine heads frames spines title lv updatedAt')
-        .populate('defense.heroes', 'hid skinId quality star colorStar lv')
+        .populate('defense.heroes.hero', 'hid skinId quality star colorStar lv')
         .lean();
         return defense;
     }
@@ -89,7 +84,15 @@ export default class LadderMatch extends BaseModel {
     }
 
     public static async lock(roleId: string, rank: number) {
-        const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId, rank, locked: 0 }, { $set: { locked: 1 }}, { new: true }).lean();
+        const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId, rank, locked: 0 }, { $set: { locked: 1 }}, { new: true })
+        .populate('role', 'roleId roleName head frame spine heads frames spines title lv updatedAt')
+        .populate('defense.heroes.hero', 'hid skinId quality star colorStar lv')
+        .lean();
+        return defense;
+    }
+
+    public static async unlock(roleId: string) {
+        const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { locked: 0 }}, { new: true }).lean();
         return defense;
     }
 
@@ -132,6 +135,10 @@ export default class LadderMatch extends BaseModel {
             { arrayFilters: [{"t.actorId": hid}] }).lean();
         return rec
     }
+
+    public static async clearLock() {
+        await LadderMatchModel.updateMany({ locked: 1 }, { $set: { locked: 0 } })
+    }
 }
 
 export const LadderMatchModel = getModelForClass(LadderMatch);

shared/db/LadderMatchRec.ts

@@ -4,6 +4,7 @@ import { LADDER_STATUS } from '../consts';
 import { LadderDefense, LadderOppPlayerInfo, LadderOppPlayerHeroInfo } from '../domain/battleField/ladder';
 import { genCode } from '../pubUtils/util';
 import { nowSeconds } from '../pubUtils/timeUtil';
+import { LADDER } from '../pubUtils/dicParam';
 
 @index({ battleCode: 1 })
 export default class LadderMatchRec extends BaseModel {
@@ -96,6 +97,20 @@ export default class LadderMatchRec extends BaseModel {
         }).select({ battleCode: 1, roleId1: 1, roleId2: 1,  _id: -1, endTime: 1, attackInfo: 1, defenseInfo: 1 }).limit(1000).lean();
         return recs;
     }
+
+    public static async checkByRank(roleId2: string) {
+        const result = await LadderMatchRecModel.exists({ roleId2, status: { $in: [LADDER_STATUS.BATTLE, LADDER_STATUS.CHECK] } });
+        return result;
+    }
+
+    public static async clearLock() {
+        await LadderMatchRecModel.updateMany({ 
+            $or: [
+                { status: LADDER_STATUS.CHECK, checkTime: { $lt: nowSeconds() - LADDER.LADDER_BATTLE_PREPARE_COUNTDOWN } },
+                { status: LADDER_STATUS.BATTLE, checkTime: { $lt: nowSeconds() - LADDER.LADDER_BATTLE_COUNTDOWN } }
+            ]
+         }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true } })
+    }
 }
 
 export const LadderMatchRecModel = getModelForClass(LadderMatchRec);

shared/domain/battleField/ladder.ts

@@ -234,6 +234,7 @@ export class LadderDataReturn {
     defense: LadderDefenseReturn = null;
     status: LADDER_STATUS = LADDER_STATUS.NO;
     time: number = 0;
+    battleCode: string = '';
     oppPlayers: LadderOppPlayerReturn[] = []
 
     setLadderData(ladderData: LadderMatchType, ladderRec?: LadderMatchRecType) {
@@ -246,6 +247,7 @@ export class LadderDataReturn {
             this.defense = new LadderDefenseReturn(ladderData.defense);
         }
         if(ladderRec) {
+            this.battleCode = ladderRec.battleCode;
             this.status = ladderRec.status;
             if(this.status == LADDER_STATUS.BATTLE) {
                 this.time = ladderRec.battleTime + LADDER.LADDER_BATTLE_COUNTDOWN;
@@ -336,7 +338,7 @@ export class LadderOppDetailHeroReturn {
     spine: string = '';                    // 动画
 
     constructor(warJson: DicWarJson, defensHero: LadderDefenseHero) {
-        this.dataId = warJson.actorId;
+        this.dataId = warJson.dataId;
         this.relation = warJson.relation;
         this.dirction = warJson.dirction;
         this.x = warJson.x;

shared/pubUtils/dicParam.ts

@@ -320,4 +320,6 @@ export const LADDER = {
   LADDER_CHALLENGE_BUY_TIMES_COST: '31002&20&20|31002&50&10|31002&100&10|31002&200&10', // 名将擂台每天购买挑战次数花费 物品id&数量&购买次数
   LADDER_ROBOT_NAME: '擂台守卫者', // 机器人默认名
   LADDER_INITIAL_CHALLENGE_TIMES: 5, // 战5次
+  LADDER_LINEUP_HEROS: 6, // 名将擂台最多上阵人数
+  LADDER_BGMAP_GKID: 60001, // 名将擂台防守阵容地图所用的关卡id
 };