xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

名将擂台：刷新对手

Browse Source
This commit is contained in:
luying
2022-07-14 20:50:05 +08:00
parent 4ee1f25876
commit 7394f14e9d
17 changed files with 48281 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
game-server/app/services/ladderService.ts
View File

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

126
game-server/app/services/rankService.ts
View File

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

2
game-server/app/services/redisService.ts
View File

@@ -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) {

8
shared/consts/constModules/sysConst.ts
View File

@@ -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,
]
// 装备栏强化类型

18
shared/db/LadderMatch.ts
View File

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

42
shared/domain/battleField/ladder.ts
View File

@@ -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 {
@@ -180,4 +209,13 @@ export class LadderDataReturn {
this.oppPlayers = oppPlayers;
}
}
export class LadderOppPlayerInDB {
@prop({ required: true })
rank: number;
@prop({ required: true })
roleId: string;
@prop({ required: true })
isRobot: boolean;
}

1
shared/domain/rank.ts
View File

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

19
shared/pubUtils/data.ts
View File

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

59
shared/pubUtils/dictionary/DicLadderDifficultRatio.ts Normal file
View File

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

41
shared/pubUtils/dictionary/DicLadderMatch.ts Normal file
View File

@@ -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] }
}

27
shared/pubUtils/dictionary/DicLadderRankReward.ts Normal file
View File

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

2
shared/pubUtils/redis.ts
View File

@@ -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>;
// 移除有序集合中给定的排名区间的所有成员

112
shared/resource/jsons/dic_zyz_gk_ladder.json Normal file
View File

@@ -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"
}
]

112
shared/resource/jsons/dic_zyz_ladderMatch.json Normal file
View File

@@ -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
}
]

47602
shared/resource/jsons/dic_zyz_ladder_difficultRatio.json Normal file
View File

File diff suppressed because it is too large Load Diff

56
shared/resource/jsons/dic_zyz_ladder_rankReward.json Normal file
View File

@@ -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"
}
]

9
shared/resource/jsons/dic_zyz_rankingType.json
View File

@@ -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
}
]