名将擂台：刷新对手

2022-07-19 17:14:11 +08:00
parent 4ee1f25876
commit 7394f14e9d
17 changed files with 48281 additions and 72 deletions
@@ -1,10 +1,13 @@
+import { REDIS_KEY } from "../consts";
 import { LadderMatchModel, LadderMatchType } from "../db/LadderMatch";
 import { LadderMatchRecModel } from "../db/LadderMatchRec";
 import { RoleModel } from "../db/Role";
-import { LadderDataReturn } from "../domain/battleField/ladder";
-import { gameData } from "../pubUtils/data";
+import { LadderDataReturn, LadderOppPlayerInDB, LadderOppPlayerReturn } from "../domain/battleField/ladder";
+import { RoleRankInfo } from "../domain/rank";
+import { gameData, getDicLadderMatchByMyRank } from "../pubUtils/data";
 import { ItemInter } from "../pubUtils/interface";
-import { shouldRefresh } from "../pubUtils/util";
+import { getRandValueByMinMax, shouldRefresh } from "../pubUtils/util";
+import { Rank } from "./rankService";
 import { combineItems } from "./role/util";

 export function refreshLadderDaily(ladderData: LadderMatchType) {
@@ -59,8 +62,112 @@ export async function getLadderData(roleId: string, needOppPlayer: boolean) {
    result.setLadderData(ladderData, ladderRec);

    if(needOppPlayer) {
-        // let oppPlayersReturn = await getEnemies(ladderData.oppPlayers||[], ladderData.winStreakNum);
-        // result.setOppPlayers(oppPlayersReturn);
+        let oppPlayersReturn = await getLadderEnemies(ladderData);
+        result.setOppPlayers(oppPlayersReturn);
    }
    return result;
+}
+
+export async function getLadderEnemies(ladderData: LadderMatchType) {
+    let oppPlayers = ladderData.oppPlayers||[];
+    if(!oppPlayers || oppPlayers.length) {
+        return await getOppPlayerDetailByDb(ladderData.serverId, ladderData.oppPlayers);
+    } else {
+        return await refreshLadderEnemies(ladderData);
+    }
+}
+
+async function getOppPlayerDetailByDb(serverId: number, oppPlayers: LadderOppPlayerInDB[]) {
+    let oppPlayersReturn: LadderOppPlayerReturn[] = [];
+    for(let oppPlayer of oppPlayers) {
+        let player = await generateOppPlayer(serverId, oppPlayer.rank, oppPlayers);
+        oppPlayersReturn.push(player);
+    }
+    return oppPlayersReturn;
+}
+
+// 获取redis当中的玩家排名数据
+export async function getLadderMatchByRank(serverId: number, from: number, to: number) {
+    let r = new Rank(REDIS_KEY.LADDER, { serverId }, false, 3000);
+    let rawResults = await r.getRankByRangeRaw(from, to, false);
+    return rawResults.map(cur => ({ rank: cur.scores[0], roleId: cur.field }))
+}
+
+export async function refreshLadderEnemies(ladderData: LadderMatchType) {
+    let rankNumbers = randOppRankNumbers(ladderData.rank); // 随机出想要的排名
+
+    let min = rankNumbers[0], max = rankNumbers[rankNumbers.length - 1];
+    let ranks = await getLadderMatchByRank(ladderData.serverId, min, max);
+    
+    let oppPlayers: LadderOppPlayerReturn[] = [], oppPlayersSave: LadderOppPlayerInDB[] = [];
+    for(let rank of rankNumbers) {
+        let player = await generateOppPlayer(ladderData.serverId, rank, ranks);
+        oppPlayersSave.push({ rank, roleId: player.roleId, isRobot: player.isRobot });
+        oppPlayers.push(player);
+    }
+    await LadderMatchModel.updateByRoleId(ladderData.roleId, { 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 r = new Rank(REDIS_KEY.LADDER, { serverId }, false);
+        let param = <RoleRankInfo>await r.getParam(player.rank, player.roleId, [player.rank]);
+        result.setByRedis(param, 0);
+    } else {
+        let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
+        result.setByRobot(dicLadderDifficultRatio);
+    }
+    return result;
+}
+
+function randOppRankNumbers(myRank: number) {
+    let dicLadderMatch = getDicLadderMatchByMyRank(myRank);
+    if(!dicLadderMatch) return new Array(5).fill(3001);
+
+    let beforeRanks = randomRank(true, myRank, dicLadderMatch.rangeBeforeMax, dicLadderMatch.rangeBeforeNum, dicLadderMatch.gap.min, dicLadderMatch.gap.max);
+    let afterRanks = randomRank(false, myRank, dicLadderMatch.rangeAfterMax, dicLadderMatch.rangeAfterNum, dicLadderMatch.gap.min, dicLadderMatch.gap.max);
+
+    let topTen = getNumberArr(1, 10);
+    let ranks = [...topTen, ...beforeRanks, ...afterRanks];
+    return uniqueArr(ranks.sort((a, b) => a - b));
+}
+
+function uniqueArr<T>(arr: T[]) {
+    return arr.filter( (item, index, arr) => {
+        //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
+        return arr.indexOf(item) === index;
+    });
+}
+
+function getNumberArr(from: number, to: number) {
+    let arr: number[] = [];
+    for(let i = from; i <= to; i++) arr.push(i);
+    return arr;
+}
+
+function randomRank(isBefore: boolean, myRank: number, range: number, num: number, gapMin: number, gapMax: number) {
+    let ratio = isBefore? -1: 1;
+    let arr: number[] = [], result = myRank;
+    while(arr.length < num) {
+        let minMax = [ result + ratio * gapMin, result + ratio * gapMax ].sort((a, b) => a - b);
+        let num = getRandValueByMinMax(minMax[0], minMax[1], 0);
+        if(isOver(isBefore, myRank, range, num)) break;
+        result = num;
+        arr.push(result);
+    }
+    return arr;
+}
+
+// 超出匹配范围
+function isOver(isBefore: boolean, myRank: number, range: number, result: number) {
+    if(isBefore) {
+        console.log('before', myRank - range < result)
+        return result < myRank - range;
+    } else {
+        console.log('after', myRank + range > result)
+        return result > myRank + range;
+    }
 }