名将擂台：刷新对手

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 { LadderDataReturn, LadderOppPlayerInDB, LadderOppPlayerReturn } from "../domain/battleField/ladder";
-import { gameData } from "../pubUtils/data";
+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);
+        let oppPlayersReturn = await getLadderEnemies(ladderData);
-        // result.setOppPlayers(oppPlayersReturn);
+        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') {
+    // 获取区间里的排行榜，格式 {rank, field, score}[]
-
+    public async getRankByRangeRaw(from: number | string = '+inf', to: number | string = '-inf', isReverse = true) {
-        let ranks = new Array<RoleRankInfo | GuildRankInfo>();
+        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;
-
+            ranks.push({ rank: Math.floor(ii / 2) + 1, field: rankFromDb[ii], scores: this.decodeScore(rankFromDb[ii + 1]) });
-            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);
             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;
-
+            let param = await this.getParam(Math.floor(ii / 2) + 1, rankFromDb[ii], this.decodeScore(rankFromDb[ii + 1]));
-            const field = rankFromDb[ii];
+            if(param) ranks.push(param);
-            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);
             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) {

shared/consts/constModules/sysConst.ts

@@ -244,6 +244,7 @@ export enum REDIS_KEY {
     SURVEY_CHANNEL = 'survey',  // 文件频道
     USER_CHANNEL = 'userChannel', // 玩家登录频道
     USER_CODE = 'userCode',  // 玩家userCode对应roleId
+    LADDER = 'ladder',       // 名将擂台
 }
 
 // 各排行榜对应hash的key
@@ -536,6 +537,10 @@ export const FILENAME = {
     DIC_TOWER_PVP_SUB_ATTR: 'dic_tower_pvp_subattr',
     DIC_SYSTEM_OPEN_TIME: 'dic_zyz_systemOpenTime',
     DIC_MAIN_WAR_REWARD: 'dic_zyz_mainCity_reward',
+    DIC_LADDER_DIFFICULTRATIO: 'dic_zyz_ladder_difficultRatio',
+    DIC_LADDER_RANKREWARD: 'dic_zyz_ladder_rankReward',
+    DIC_GK_LADDER: 'dic_zyz_gk_ladder',
+    DIC_LADDER_MATCH: 'dic_zyz_ladderMatch',
 }
 
 export const WAR_RELATE_TABLES = [
@@ -556,7 +561,8 @@ export const WAR_RELATE_TABLES = [
     FILENAME.DIC_GK_NEWHERO,
     FILENAME.DIC_GK_PROBATION,
     FILENAME.DIC_GK_ARMY_TRAIN,
-    FILENAME.DIC_GK_ARMY_BOSS
+    FILENAME.DIC_GK_ARMY_BOSS,
+    FILENAME.DIC_GK_LADDER,
 ]
 
 // 装备栏强化类型

shared/db/LadderMatch.ts

@@ -1,6 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
-import { LadderDefense, } from '../domain/battleField/ladder';
+import { LadderDefense, LadderOppPlayerInDB } from '../domain/battleField/ladder';
 import Role from './Role';
 
 @index({ roleId: 1 })
@@ -19,6 +19,9 @@ export default class LadderMatch extends BaseModel {
     @prop({ required: true, default: null, _id: false })
     defense: LadderDefense;
 
+    @prop({ required: true, type: LadderOppPlayerInDB, default: [], _id: false })
+    oppPlayers: LadderOppPlayerInDB[];
+
     @prop({ required: true, default: () => { return new Date() } })
     refDaily: Date;                  // 每日刷新，控制refOppCnt和setAttackCnt
     @prop({ required: true, default: 0 })
@@ -46,6 +49,19 @@ export default class LadderMatch extends BaseModel {
         const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: params}, { new: true }).lean();
         return defense;
     }
+
+    public static async findAll(serverId: number) {
+        let result: LadderMatchType[] = [], latestTime = new Date();
+        while(latestTime) {
+            let ladderMatch = await LadderMatchModel.find({ serverId, rank: { $gt: 0 }, createdAt: { $lt: latestTime } })
+                .sort({ createdAt: -1 })
+                .populate('role', 'roleId roleName head frame spine heads frames spines title lv updatedAt')
+                .limit(1000);
+            result.push(...ladderMatch);
+            latestTime = ladderMatch[ladderMatch.length - 1]?.createdAt;
+        }
+        return result
+    }
 }
 
 export const LadderMatchModel = getModelForClass(LadderMatch);

shared/domain/battleField/ladder.ts

@@ -4,7 +4,9 @@ import Hero from '../../db/Hero';
 import { LadderMatchType } from "../../db/LadderMatch";
 import { LadderMatchRecType } from "../../db/LadderMatchRec";
 import { RoleType } from "../../db/Role";
-import { EXTERIOR } from "../../pubUtils/dicParam";
+import { EXTERIOR, LADDER } from "../../pubUtils/dicParam";
+import { DicLadderDifficultRatio } from "../../pubUtils/dictionary/DicLadderDifficultRatio";
+import { RoleRankInfo } from "../rank";
 
 // ladderMatch表
 export class LadderDefenseHero {
@@ -134,7 +136,7 @@ export class LadderDefenseReturn {
 }
 
 export class LadderOppPlayerReturn {
-    rank: number;           // 对手拍名
+    rank: number;           // 对手排名
     roleId: string;        // 对手玩家id            
     roleName: string;      // 对手玩家名            
     head: number;          // 头像            
@@ -144,6 +146,33 @@ export class LadderOppPlayerReturn {
     title: number;          // 对手爵位
     defCe: number;         // 对手防守阵容战力
     isRobot: boolean;      // 是否是机器人  
+
+    constructor(rank: number, isRobot: boolean) {
+        this.rank = rank;
+        this.isRobot = isRobot;
+    }
+
+    setByRedis(param: RoleRankInfo, defCe: number) {
+        this.roleId = param.roleId;
+        this.roleName = param.roleName;
+        this.head = param.head;
+        this.frame = param.frame;
+        this.spine = param.spine;
+        this.lv = param.lv;
+        this.title = param.title;
+        this.defCe = defCe;
+    }
+
+    setByRobot(ladderDifficultRatio: DicLadderDifficultRatio) {
+        this.roleId = `robot${this.rank}`;
+        this.roleName = LADDER.LADDER_ROBOT_NAME;
+        this.frame = EXTERIOR.EXTERIOR_FACECASE;
+        this.head = ladderDifficultRatio.head;
+        this.spine = ladderDifficultRatio.spine;
+        this.lv = ladderDifficultRatio.level;
+        this.title = 1;
+        this.defCe = ladderDifficultRatio.ce;
+    }
 }
 
 export class LadderDataReturn {
@@ -181,3 +210,12 @@ export class LadderDataReturn {
     }
 
 }
+
+export class LadderOppPlayerInDB {
+    @prop({ required: true })
+    rank: number;
+    @prop({ required: true })
+    roleId: string;
+    @prop({ required: true })
+    isRobot: boolean;
+}

shared/domain/rank.ts

@@ -306,6 +306,7 @@ export class KeyName {
             case REDIS_KEY.GATE_ACTIVITY:
             case REDIS_KEY.RACE_ACTIVITY:
             case REDIS_KEY.TOWER_RANK:
+            case REDIS_KEY.LADDER:
                 return `${this.key}:${this.serverId}`;
             case REDIS_KEY.HERO_RANK:
                 return `${this.key}:${this.serverId}:${this.hid}`;

shared/pubUtils/data.ts

@@ -107,6 +107,9 @@ import { dicTowerPvpSubAttr, loadTowerPvpSubAttr } from './dictionary/DicTowerPv
 import { dicSystemOpenTime, loadSystemOpenTime } from "./dictionary/DicSystemOpenTime";
 import { dicRandomEffectPoolPlan, loadRandomEffectPoolPlan } from './dictionary/DicRandomEffectPoolPlan';
 import { dicMainWarRewardByChapter, loadMainWarReward } from './dictionary/DicMainWarReward';
+import { dicLadderMatch, loadLadderMatch } from "./dictionary/DicLadderMatch";
+import { dicLadderDifficultRatio, loadLadderDifficultRatio } from "./dictionary/DicLadderDifficultRatio";
+import { dicLadderRankReward, loadLadderRankReward } from "./dictionary/DicLadderRankReward";
 
 export const gameData = {
     daily: dicDaily,
@@ -270,6 +273,9 @@ export const gameData = {
     sysOpenTime: dicSystemOpenTime,
     randomEffectPoolPlan: dicRandomEffectPoolPlan,
     ladderConsume: new Array<{id: number, count: number, times: number}>(),
+    ladderMatch: dicLadderMatch,
+    ladderDifficultRatio: dicLadderDifficultRatio,
+    ladderRankReward: dicLadderRankReward
 };
 
 // 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -981,6 +987,16 @@ export function decodeLadderBuyCost() {
     }
 }
 
+export function getDicLadderMatchByMyRank(myRank: number) {
+    for(let dic of gameData.ladderMatch) {
+        let { rankMin, rankMax } = dic;
+        if(rankMin < myRank && (rankMax >= myRank || rankMax == -1) ) {
+            return dic;
+        }
+    }
+    return null
+}
+
 // 初始加载
 function initDatas() {
     parseDicParam();
@@ -1154,6 +1170,9 @@ function loadDatas() {
     loadSystemOpenTime();
     loadRandomEffectPoolPlan();
     loadMainWarReward();
+    loadLadderMatch();
+    loadLadderDifficultRatio();
+    loadLadderRankReward();
 }
 
 // 重载dicParam

shared/pubUtils/dictionary/DicLadderDifficultRatio.ts

@@ -0,0 +1,59 @@
+// 邮件内容
+import {decodeArrayListStr, parseGoodStr, readFileAndParse} from '../util'
+import { FILENAME } from '../../consts'
+import { RewardInter } from '../interface';
+
+export interface DicLadderDifficultRatio {
+    // id
+    readonly id: number;
+    // 排名
+    readonly rank: number;
+    // 强度倍率
+    readonly value: number;
+    // 次级属性
+    readonly secondAttrLevel: number;
+    // 等级
+    readonly level: number;
+    // 关卡id
+    readonly gkId: number;
+    // 头像
+    readonly head: number;
+    // 形象
+    readonly spine: number;
+    // 胜利奖励
+    readonly randomWinReward: { id: number, count: number, weight: number }[];
+    // 失败奖励
+    readonly randomFailReward: { id: number, count: number, weight: number }[];
+    // 突破奖励
+    readonly onceReward: RewardInter[];
+    // 战力
+    readonly ce: number;
+}
+
+export const dicLadderDifficultRatio = new Map<number, DicLadderDifficultRatio>();
+export function loadLadderDifficultRatio() {
+    dicLadderDifficultRatio.clear();
+    
+    let arr = readFileAndParse(FILENAME.DIC_LADDER_DIFFICULTRATIO);
+    arr.forEach(o => {
+        o.gkId = parseInt(o.gkId);
+        o.randomWinReward = parseRewardWithWeight(o.randomWinReward);
+        o.randomFailReward = parseRewardWithWeight(o.randomFailReward);
+        o.onceReward = parseGoodStr(o.onceReward)
+        dicLadderDifficultRatio.set(o.id, o);
+    });
+    arr = undefined;
+}
+
+function parseRewardWithWeight(str: string) {
+    let result = new Array<{ id: number, count: number, weight: number }>();
+    if (!str) return result;
+    let decodeArr = decodeArrayListStr(str);
+    for (let [id, count, weight] of decodeArr) {
+        if (isNaN(parseInt(id)) || isNaN(parseInt(count)) || isNaN(parseInt(weight))) {
+            throw new Error('data table format wrong');
+        }
+        result.push({ id: parseInt(id), count: parseInt(count), weight: parseInt(weight) });
+    }
+    return result
+}

shared/pubUtils/dictionary/DicLadderMatch.ts

@@ -0,0 +1,41 @@
+// 名将擂台匹配范围
+import { parseNumberList, readFileAndParse} from '../util'
+import { FILENAME } from '../../consts'
+
+export interface DicLadderMatch {
+    // id
+    readonly id: number;
+    // 最低排名
+    readonly rankMin: number;
+    // 最高排名
+    readonly rankMax: number;
+    // 玩家随机范围往前数最多多少人
+    readonly rangeBeforeMax: number;
+    // 玩家随机范围往后数最多多少人
+    readonly rangeAfterMax: number;
+    // 玩家随机范围往前随多少人
+    readonly rangeBeforeNum: number;
+    // 玩家随机范围往后随多少人
+    readonly rangeAfterNum: number;
+    // 玩家随机间隔
+    readonly gap: { min: number, max: number };
+    // 是否可以挑战前十
+    readonly topChallenge: number;
+}
+
+export const dicLadderMatch: DicLadderMatch[] = [];
+export function loadLadderMatch() {
+    dicLadderMatch.splice(0, dicLadderMatch.length);
+    
+    let arr = readFileAndParse(FILENAME.DIC_LADDER_MATCH);
+    arr.forEach(o => {
+        o.gap = parseGap(o.interval);
+        dicLadderMatch.push(o);
+    });
+    arr = undefined;
+}
+
+function parseGap(str: string) {
+    let arr = parseNumberList(str);
+    return { min: arr[0], max: arr[1] }
+}

shared/pubUtils/dictionary/DicLadderRankReward.ts

@@ -0,0 +1,27 @@
+// 名将擂台每天22点排名奖励
+import {parseGoodStr, readFileAndParse} from '../util'
+import { FILENAME } from '../../consts'
+import { RewardInter } from '../interface';
+
+export interface DicLadderRankReward {
+    // id
+    readonly id: number;
+    // 最低排名
+    readonly rankMin: number;
+    // 最高排名
+    readonly rankMax: number;
+    // 突破奖励
+    readonly reward: RewardInter[];
+}
+
+export const dicLadderRankReward: DicLadderRankReward[] = [];
+export function loadLadderRankReward() {
+    dicLadderRankReward.splice(0, dicLadderRankReward.length);
+    
+    let arr = readFileAndParse(FILENAME.DIC_LADDER_DIFFICULTRATIO);
+    arr.forEach(o => {
+        o.reward = parseGoodStr(o.reward)
+        dicLadderRankReward.push(o);
+    });
+    arr = undefined;
+}

shared/pubUtils/redis.ts

@@ -48,6 +48,8 @@ declare module 'redis' {
         zaddAsync(key: string, score: number, member: string): Promise<number>;
         // 返回有序集中指定分数区间内的成员，分数从高到低排序
         zrevrangebyscoreAsync(key: string, max: (string|number), min: (string|number), withscores?: string, limit?:string, offset?: number, count?:number): Promise<string[]>;
+        // 返回有序集中指定分数区间内的成员，分数从高到低排序
+        zrangebyscoreAsync(key: string, max: (string|number), min: (string|number), withscores?: string, limit?:string, offset?: number, count?:number): Promise<string[]>;
         // 获取有序集合的成员数
         zcardAsync(key: string): Promise<number>;
         // 移除有序集合中给定的排名区间的所有成员

shared/resource/jsons/dic_zyz_gk_ladder.json

@@ -0,0 +1,112 @@
+[
+    {
+        "war_id": 4601,
+        "dispatchJsonId": 4601,
+        "bg_img": 9965,
+        "mapid": 9965,
+        "script_id": 0,
+        "warType": 21,
+        "gk_name": "天梯模板1",
+        "lvLimted": 1,
+        "turnLimted": 10,
+        "forcedCharactor": "&",
+        "fobiddenCharactor": "&",
+        "heroInUI": "1&307",
+        "victoryInfoInUI": "消灭所有敌军\n10回合内造成伤害更高",
+        "loseInfoInUI": "我方全部阵亡 \n10回合内造成伤害不敌敌军",
+        "starInfoInUI": "无",
+        "cost": 0,
+        "recommendedPower": 0,
+        "previousGk": 0,
+        "needPrepare": 1,
+        "HeroNum": "6&6"
+    },
+    {
+        "war_id": 4602,
+        "dispatchJsonId": 4602,
+        "bg_img": 9965,
+        "mapid": 9965,
+        "script_id": 0,
+        "warType": 21,
+        "gk_name": "天梯模板2",
+        "lvLimted": 1,
+        "turnLimted": 10,
+        "forcedCharactor": "&",
+        "fobiddenCharactor": "&",
+        "heroInUI": "1&307",
+        "victoryInfoInUI": "消灭所有敌军\n10回合内造成伤害更高",
+        "loseInfoInUI": "我方全部阵亡 \n10回合内造成伤害不敌敌军",
+        "starInfoInUI": "无",
+        "cost": 0,
+        "recommendedPower": 0,
+        "previousGk": 0,
+        "needPrepare": 1,
+        "HeroNum": "6&6"
+    },
+    {
+        "war_id": 4603,
+        "dispatchJsonId": 4603,
+        "bg_img": 9965,
+        "mapid": 9965,
+        "script_id": 0,
+        "warType": 21,
+        "gk_name": "天梯模板3",
+        "lvLimted": 1,
+        "turnLimted": 10,
+        "forcedCharactor": "&",
+        "fobiddenCharactor": "&",
+        "heroInUI": "1&307",
+        "victoryInfoInUI": "消灭所有敌军\n10回合内造成伤害更高",
+        "loseInfoInUI": "我方全部阵亡 \n10回合内造成伤害不敌敌军",
+        "starInfoInUI": "无",
+        "cost": 0,
+        "recommendedPower": 0,
+        "previousGk": 0,
+        "needPrepare": 1,
+        "HeroNum": "6&6"
+    },
+    {
+        "war_id": 4604,
+        "dispatchJsonId": 4604,
+        "bg_img": 9965,
+        "mapid": 9965,
+        "script_id": 0,
+        "warType": 21,
+        "gk_name": "天梯模板4",
+        "lvLimted": 1,
+        "turnLimted": 10,
+        "forcedCharactor": "&",
+        "fobiddenCharactor": "&",
+        "heroInUI": "1&307",
+        "victoryInfoInUI": "消灭所有敌军\n10回合内造成伤害更高",
+        "loseInfoInUI": "我方全部阵亡 \n10回合内造成伤害不敌敌军",
+        "starInfoInUI": "无",
+        "cost": 0,
+        "recommendedPower": 0,
+        "previousGk": 0,
+        "needPrepare": 1,
+        "HeroNum": "6&6"
+    },
+    {
+        "war_id": 4605,
+        "dispatchJsonId": 4605,
+        "bg_img": 9965,
+        "mapid": 9965,
+        "script_id": 0,
+        "warType": 21,
+        "gk_name": "天梯模板5",
+        "lvLimted": 1,
+        "turnLimted": 10,
+        "forcedCharactor": "&",
+        "fobiddenCharactor": "&",
+        "heroInUI": "1&307",
+        "victoryInfoInUI": "消灭所有敌军\n10回合内造成伤害更高",
+        "loseInfoInUI": "我方全部阵亡 \n10回合内造成伤害不敌敌军",
+        "starInfoInUI": "无",
+        "cost": 0,
+        "recommendedPower": 0,
+        "previousGk": 0,
+        "needPrepare": 1,
+        "HeroNum": "6&6"
+    }
+]

shared/resource/jsons/dic_zyz_ladderMatch.json

@@ -0,0 +1,112 @@
+[
+    {
+        "id": 1,
+        "rankMin": 0,
+        "rankMax": 1,
+        "rangeBeforeMax": 0,
+        "rangeAfterMax": 0,
+        "rangeBeforeNum": 0,
+        "rangeAfterNum": 0,
+        "interval": "0&0",
+        "topChallenge": 1
+    },
+    {
+        "id": 2,
+        "rankMin": 1,
+        "rankMax": 10,
+        "rangeBeforeMax": 0,
+        "rangeAfterMax": 0,
+        "rangeBeforeNum": 0,
+        "rangeAfterNum": 1,
+        "interval": "0&0",
+        "topChallenge": 1
+    },
+    {
+        "id": 3,
+        "rankMin": 10,
+        "rankMax": 20,
+        "rangeBeforeMax": 5,
+        "rangeAfterMax": 1,
+        "rangeBeforeNum": 3,
+        "rangeAfterNum": 1,
+        "interval": "0&5",
+        "topChallenge": 1
+    },
+    {
+        "id": 4,
+        "rankMin": 20,
+        "rankMax": 50,
+        "rangeBeforeMax": 10,
+        "rangeAfterMax": 1,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "0&5",
+        "topChallenge": 0
+    },
+    {
+        "id": 5,
+        "rankMin": 50,
+        "rankMax": 100,
+        "rangeBeforeMax": 30,
+        "rangeAfterMax": 5,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "3&6",
+        "topChallenge": 0
+    },
+    {
+        "id": 6,
+        "rankMin": 100,
+        "rankMax": 200,
+        "rangeBeforeMax": 50,
+        "rangeAfterMax": 10,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "5&10",
+        "topChallenge": 0
+    },
+    {
+        "id": 7,
+        "rankMin": 200,
+        "rankMax": 500,
+        "rangeBeforeMax": 100,
+        "rangeAfterMax": 50,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "10&20",
+        "topChallenge": 0
+    },
+    {
+        "id": 8,
+        "rankMin": 500,
+        "rankMax": 1000,
+        "rangeBeforeMax": 200,
+        "rangeAfterMax": 100,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "20&40",
+        "topChallenge": 0
+    },
+    {
+        "id": 9,
+        "rankMin": 1000,
+        "rankMax": 2000,
+        "rangeBeforeMax": 300,
+        "rangeAfterMax": 100,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "30&60",
+        "topChallenge": 0
+    },
+    {
+        "id": 10,
+        "rankMin": 2000,
+        "rankMax": -1,
+        "rangeBeforeMax": 500,
+        "rangeAfterMax": 100,
+        "rangeBeforeNum": 5,
+        "rangeAfterNum": 1,
+        "interval": "50&100",
+        "topChallenge": 0
+    }
+]

shared/resource/jsons/dic_zyz_ladder_rankReward.json

@@ -0,0 +1,56 @@
+[
+    {
+        "id": 1,
+        "rankMin": 0,
+        "rankMax": 1,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 2,
+        "rankMin": 1,
+        "rankMax": 10,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 3,
+        "rankMin": 10,
+        "rankMax": 50,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 4,
+        "rankMin": 50,
+        "rankMax": 100,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 5,
+        "rankMin": 100,
+        "rankMax": 200,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 6,
+        "rankMin": 200,
+        "rankMax": 500,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 7,
+        "rankMin": 500,
+        "rankMax": 1000,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 8,
+        "rankMin": 1000,
+        "rankMax": 2000,
+        "reward": "31002&1000"
+    },
+    {
+        "id": 9,
+        "rankMin": 2000,
+        "rankMax": -1,
+        "reward": "31002&1000"
+    }
+]

shared/resource/jsons/dic_zyz_rankingType.json

@@ -43,7 +43,7 @@
     },
     {
         "id": 7,
-        "name": "主线推进 ",
+        "name": "主线推进",
         "group": 2,
         "groupName": "玩法",
         "general": 0
@@ -61,5 +61,12 @@
         "group": 2,
         "groupName": "玩法",
         "general": 0
+    },
+    {
+        "id": 10,
+        "name": "名将擂台",
+        "group": 2,
+        "groupName": "玩法",
+        "general": 0
     }
 ]