名将擂台：刷新对手

game-server/app/services/ladderService.ts

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

game-server/app/services/rankService.ts

@@ -14,6 +14,7 @@ import { RANK_FIRST_REWARD_STATUS } from '../consts';
 import { CounterModel } from "../db/Counter";
 import { ActivityTimeLimitRankModel } from "../db/ActivityTimeLimitRank";
 import { sendMessageToServerWithSuc } from "./pushService";
+import { LadderMatchModel } from "../db/LadderMatch";
 
 
 /**
@@ -49,6 +50,11 @@ export class Rank {
 
     private setValueConfig(key: REDIS_KEY) {
         switch (key) {
+            case REDIS_KEY.LADDER:
+                this.valueConfig = [
+                    new ValueConfig(true, 'rank', 0, false, false)
+                ]; 
+                break;
             case REDIS_KEY.TOP_LINEUP_RANK:
             case REDIS_KEY.TOP_HERO_RANK:
             case REDIS_KEY.SUM_CE_RANK:
@@ -700,53 +706,67 @@ export class Rank {
         return ranks
     }
 
-    public async getRankByRange(from: number | string = '+inf', to: number | string = '-inf') {
-
-        let ranks = new Array<RoleRankInfo | GuildRankInfo>();
+    // 获取区间里的排行榜，格式 {rank, field, score}[]
+    public async getRankByRangeRaw(from: number | string = '+inf', to: number | string = '-inf', isReverse = true) {
+        let ranks: { rank: number, field: string, scores: number[] }[] = [];
         let key = this.keyName.getName();
         if (this.isUnion) {
             key = await this.generateUnionRank();
         }
 
-        const rankFromDb = await redisClient().zrevrangebyscoreAsync(key, from, to, "WITHSCORES");
+        const rankFromDb = isReverse? 
+            (await redisClient().zrevrangebyscoreAsync(key, from, to, "WITHSCORES")):
+            (await redisClient().zrangebyscoreAsync(key, from, to, "WITHSCORES"));
 
         let num = 0;
         for (let ii = 0; ii < rankFromDb.length; ii += 2) {
             if (num >= this.limit) break;
-
-            const field = rankFromDb[ii];
-            let myId = this.decodeFields(this.key, field);
-            const scores = this.decodeScore(rankFromDb[ii + 1]);
-
-            const info = await redisClient().hgetAsync(this.infoKey, this.composeFields(this.infoKey, myId));
-            const userInfo = JSON.parse(info);
-
-            let param: RoleRankInfo | GuildRankInfo;
-            if (this.infoKey == REDIS_KEY.USER_INFO) {
-                if (nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
-                    continue;
-                }
-                param = new RoleRankInfo(userInfo);
-                param.setInfo(Math.floor(ii / 2) + 1, myId, scores[0], scores[1]);
-            } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
-                if(this.key == REDIS_KEY.GUILD_LV_RANK|| this.key == REDIS_KEY.RACE_ACTIVITY) {
-                    param = new GuildRankInfo(userInfo);
-                    param.setInfo2(Math.floor(ii / 2) + 1, myId, scores[0], scores[1], scores[2]);
-                } else {
-                    param = new GuildRankInfo(userInfo);
-                    param.setInfo(Math.floor(ii / 2) + 1, myId, scores[0], scores[1]);
-                }
-            }
-
-            for (let extraKey of this.extraKeys) {
-                await this.setExInfoToParam(extraKey, param, myId, {});
-            }
-            ranks.push(param);
+            ranks.push({ rank: Math.floor(ii / 2) + 1, field: rankFromDb[ii], scores: this.decodeScore(rankFromDb[ii + 1]) });
             num++;
         }
         return ranks
     }
 
+    public async getRankByRange(from: number | string = '+inf', to: number | string = '-inf', isReverse = true) {
+        let raws = await this.getRankByRangeRaw(from, to, isReverse);
+
+        let ranks = new Array<RoleRankInfo | GuildRankInfo>();
+        for (let { rank, field, scores } of raws) {
+            let param = await this.getParam(rank, field, scores);
+            if(param) ranks.push(param);
+        }
+        return ranks
+    }
+
+    public async getParam(rank: number, field: string, scores: number[]) {
+        let myId = this.decodeFields(this.key, field);
+
+        const info = await redisClient().hgetAsync(this.infoKey, this.composeFields(this.infoKey, myId));
+        const userInfo = JSON.parse(info);
+
+        let param: RoleRankInfo | GuildRankInfo;
+        if (this.infoKey == REDIS_KEY.USER_INFO) {
+            if (nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
+                return null;
+            }
+            param = new RoleRankInfo(userInfo);
+            param.setInfo(rank, myId, scores[0], scores[1]);
+        } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
+            if(this.key == REDIS_KEY.GUILD_LV_RANK|| this.key == REDIS_KEY.RACE_ACTIVITY) {
+                param = new GuildRankInfo(userInfo);
+                param.setInfo2(rank, myId, scores[0], scores[1], scores[2]);
+            } else {
+                param = new GuildRankInfo(userInfo);
+                param.setInfo(rank, myId, scores[0], scores[1]);
+            }
+        }
+
+        for (let extraKey of this.extraKeys) {
+            await this.setExInfoToParam(extraKey, param, myId, {});
+        }
+        return param
+    }
+
     public async getRankByRank(start: number, end: number) {
 
         let ranks = new Array<RoleRankInfo | GuildRankInfo>();
@@ -762,35 +782,8 @@ export class Rank {
         let num = 0;
         for (let ii = 0; ii < rankFromDb.length; ii += 2) {
             if (num >= this.limit) break;
-
-            const field = rankFromDb[ii];
-            let myId = this.decodeFields(this.key, field);
-            const scores = this.decodeScore(rankFromDb[ii + 1]);
-            const info = await redisClient().hgetAsync(this.infoKey, this.composeFields(this.infoKey, myId));
-            if(!info) continue;
-            const userInfo = JSON.parse(info);
-
-            let param: RoleRankInfo | GuildRankInfo;
-            if (this.infoKey == REDIS_KEY.USER_INFO) {
-                if (nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
-                    continue;
-                }
-                param = new RoleRankInfo(userInfo);
-                param.setInfo(Math.floor(ii / 2) + 1, myId, scores[0], scores[1]);
-            } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
-                if(this.key == REDIS_KEY.GUILD_LV_RANK) {
-                    param = new GuildRankInfo(userInfo);
-                    param.setInfo2(Math.floor(ii / 2) + 1, myId, scores[0], scores[1], scores[2]);
-                } else {
-                    param = new GuildRankInfo(userInfo);
-                    param.setInfo(Math.floor(ii / 2) + 1, myId, scores[0], scores[1]);
-                }
-            }
-
-            for (let extraKey of this.extraKeys) {
-                await this.setExInfoToParam(extraKey, param, myId, {});
-            }
-            ranks.push(param);
+            let param = await this.getParam(Math.floor(ii / 2) + 1, rankFromDb[ii], this.decodeScore(rankFromDb[ii + 1]));
+            if(param) ranks.push(param);
             num++;
         }
         return ranks
@@ -1109,6 +1102,15 @@ export async function setRankRedisFromDb(type: string, args?: { serverId?: numbe
                 await r.setRankWithHeroInfo(hero.roleId, hid, hero.ce, hero.updatedAt.getTime(), hero);
             }
         }
+    } else if (type == REDIS_KEY.LADDER) {
+        let serverId = args.serverId;
+        let ranks = await LadderMatchModel.findAll(serverId);
+        let r = new Rank(type, { serverId });
+        r.setIsInit(true);
+        for (let rank of ranks) {
+            let role = <RoleType>rank.role;
+            await r.setRankWithRoleInfo(rank.roleId, rank.rank, 0, role);
+        }
     }
 }
 

game-server/app/services/redisService.ts

@@ -44,6 +44,7 @@ export async function initAllRank() {
     // await delKeys(REDIS_KEY.PVP_RANK);
     await delKeys(REDIS_KEY.GUILD_FUND);
     await delKeys(REDIS_KEY.SUM_CE_SNAPSHOT);
+    await delKeys(REDIS_KEY.LADDER);
 
     await setRankRedisFromDb(REDIS_KEY.PVP_RANK, {});
 
@@ -72,6 +73,7 @@ export async function initRank(serverId: number) {
     await setRankRedisFromDb(REDIS_KEY.MAIN_RANK, { serverId });
     await setRankRedisFromDb(REDIS_KEY.MAIN_ELITE_RANK, { serverId });
     await setRankRedisFromDb(REDIS_KEY.HERO_RANK, { serverId });
+    await setRankRedisFromDb(REDIS_KEY.LADDER, { serverId });
 }
 
 export async function initActivitiesRank(serverId: number) {