名将擂台：获取对手

game-server/app/services/ladderService.ts

@@ -1,12 +1,14 @@
-import { REDIS_KEY } from "../consts";
-import { LadderMatchModel, LadderMatchType } from "../db/LadderMatch";
+import { LADDER_OPP_STATUS, LADDER_STATUS, PUSH_ROUTE, REDIS_KEY } from "../consts";
+import { HeroType } from "../db/Hero";
+import { LadderMatchModel, LadderMatchType, LadderUpdateInter } from "../db/LadderMatch";
 import { LadderMatchRecModel } from "../db/LadderMatchRec";
-import { RoleModel } from "../db/Role";
-import { LadderDataReturn, LadderOppPlayerInDB, LadderOppPlayerReturn } from "../domain/battleField/ladder";
+import { RoleModel, RoleType } from "../db/Role";
+import { LadderDataReturn, LadderDefense, LadderOppPlayerHeroInfo, LadderOppPlayerInDB, LadderOppPlayerInfo, LadderOppPlayerReturn } from "../domain/battleField/ladder";
 import { RoleRankInfo } from "../domain/rank";
 import { gameData, getDicLadderMatchByMyRank } from "../pubUtils/data";
 import { ItemInter } from "../pubUtils/interface";
 import { getRandValueByMinMax, shouldRefresh } from "../pubUtils/util";
+import { sendMessageToUserWithSuc } from "./pushService";
 import { Rank } from "./rankService";
 import { combineItems } from "./role/util";
 
@@ -93,7 +95,7 @@ export async function getLadderMatchByRank(serverId: number, from: number, to: n
     return rawResults.map(cur => ({ rank: cur.scores[0], roleId: cur.field }))
 }
 
-export async function refreshLadderEnemies(ladderData: LadderMatchType) {
+export async function refreshLadderEnemies(ladderData: LadderMatchType, update: LadderUpdateInter = {}) {
     let rankNumbers = randOppRankNumbers(ladderData.rank); // 随机出想要的排名
 
     let min = rankNumbers[0], max = rankNumbers[rankNumbers.length - 1];
@@ -105,7 +107,7 @@ export async function refreshLadderEnemies(ladderData: LadderMatchType) {
         oppPlayersSave.push({ rank, roleId: player.roleId, isRobot: player.isRobot });
         oppPlayers.push(player);
     }
-    await LadderMatchModel.updateByRoleId(ladderData.roleId, { oppPlayers: oppPlayersSave });
+    await LadderMatchModel.updateByRoleId(ladderData.roleId, { ...update, oppPlayers: oppPlayersSave });
     return oppPlayers
 }
 
@@ -170,4 +172,94 @@ function isOver(isBefore: boolean, myRank: number, range: number, result: number
         console.log('after', myRank + range > result)
         return result > myRank + range;
     }
-}
+}
+
+export function checkRank(myRank: number, targetRank: number) {
+    let dicLadderMatch = getDicLadderMatchByMyRank(myRank);
+    if(!dicLadderMatch && myRank != 0 && targetRank != 3001) return false;
+    if(myRank < targetRank) { // 向后打
+        if(myRank + dicLadderMatch.rangeAfterMax < targetRank) return false;
+    } else { // 向前打
+        if(myRank - dicLadderMatch.rangeBeforeMax > targetRank) return false;
+    }
+    return true;
+}
+
+export async function getLadderOppStatus(ladderData: LadderMatchType, targetRoleId: string, myRank: number, rank: number) {
+    if(ladderData.rank != myRank) return { status: LADDER_OPP_STATUS.MY_RANK_CHANGE };
+    let { oppPlayers } = ladderData;
+    let curOppPlayer = oppPlayers.find(cur => cur.roleId == targetRoleId);
+    if(!curOppPlayer|| curOppPlayer.rank != rank) return { status: LADDER_OPP_STATUS.OPP_RANK_CHANGE };
+
+    if(curOppPlayer.isRobot) {
+        let hisLadderData = await LadderMatchModel.checkByRank(rank);
+        if(hisLadderData) return { status: LADDER_OPP_STATUS.OPP_RANK_CHANGE };
+
+        return { status: LADDER_OPP_STATUS.BATTLE, isRobot: true };
+    } else {
+        let hisLadderData = await LadderMatchModel.lock(targetRoleId, rank);
+        if(!hisLadderData) return { status: LADDER_OPP_STATUS.OPP_IS_LOCKED };
+
+        return { status: LADDER_OPP_STATUS.BATTLE, isRobot: false, hisLadderData };
+    }
+}
+
+/**
+ * 
+ * @param isRobot 是否是机器
+ * @param isDefense 是攻还是守方
+ * @param rank 排名
+ * @param ladderData 需要populate过的ladderMatch表
+ * @returns 
+ */
+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 heroes: LadderOppPlayerHeroInfo[] = [];
+        for(let json of dicWarJson) {
+            if(json.relation == 2) {
+                let hero = new LadderOppPlayerHeroInfo();
+                hero.setByWarJson(json);
+                heroes.push(hero);
+            }
+        }
+        let info = new LadderOppPlayerInfo();
+        info.initByRobot(dicLadderDifficultRatio, heroes, isDefense);
+        return info;
+    } else {
+        let defCe = calculateDefCeByDefense(ladderData.defense);
+        let role = <RoleType>ladderData.role;
+        let heroes: LadderOppPlayerHeroInfo[] = [];
+        if(isDefense) { // 防守方可以将武将也存入，攻方要等出战
+            let defenseHeroes = ladderData.defense?.heroes||[];
+            for(let defenseHero of defenseHeroes) {
+                let hero = new LadderOppPlayerHeroInfo();
+                hero.setByDefenseHero(<HeroType>defenseHero.hero);
+                heroes.push(hero);
+            }
+        }
+        let info = new LadderOppPlayerInfo();
+        info.initByPlayer(rank, role, heroes, defCe, isDefense);
+        return info;
+    }
+} 
+
+function calculateDefCeByDefense(defense: LadderDefense) {
+    if(!defense) return 0;
+    let ce = 0;
+    for(let hero of defense.heroes) {
+        ce += hero.ce;
+    }
+    return ce;
+}
+
+export async function ladderTimeout(battleCode: string, status: LADDER_STATUS) {
+    let rec = await LadderMatchRecModel.timeout(battleCode);
+    if(status == LADDER_STATUS.CHECK) {
+        await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_CHECK_STOP, { battleCode });
+    } else if (status == LADDER_STATUS.BATTLE) {
+        await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_BATTLE_STOP, { battleCode });
+    }
+}