719 lines
29 KiB
TypeScript
719 lines
29 KiB
TypeScript
import { KeyName, KeyNameParam, RankParam, GuildRankParam, RoleRankInfo, GuildRankInfo, GuildLeader, LineupParam, myIdInter } from "../domain/rank";
|
|
import { REDIS_RANK_TO_INFO, ROLE_SELECT, GUILD_SELECT, REDIS_KEY, REDIS_RANK_TO_EXTRA, HERO_SELECT, COMPOSE_FIELD_TYPE, KEY_TO_COMPOSE_FIELD, RANK_TYPE } from "../consts";
|
|
import { redisClient, setUserInfo } from "./redisService";
|
|
import { RoleType, RoleModel } from "../db/Role";
|
|
import { GuildType, GuildModel } from "../db/Guild";
|
|
import { HeroModel, HeroType } from "../db/Hero";
|
|
import { SystemConfigModel } from "../db/SystemConfig";
|
|
import { PvpDefenseModel } from "../db/PvpDefense";
|
|
import { gameData } from "../pubUtils/data";
|
|
|
|
|
|
/**
|
|
* @description 排行榜相关操作
|
|
* @export
|
|
* @class Rank
|
|
*/
|
|
export class Rank {
|
|
key: string; // 排行榜原始key
|
|
keyName: KeyName; // 拼接之后的key
|
|
infoKey: string; // 玩家数据key
|
|
extraKeys: string[];
|
|
isUnion: boolean; // 是否使用多个zset联合计算
|
|
limit: number = 200; // 排行榜长度
|
|
timelen: number = 10; // 给时间位留的长度
|
|
unionRankLife: number = 10;
|
|
|
|
constructor(key: string, keyParam: KeyNameParam, isUnion = false, limit = 200) {
|
|
this.key = key;
|
|
this.keyName = new KeyName(key, keyParam);
|
|
this.infoKey = REDIS_RANK_TO_INFO.get(key);
|
|
this.extraKeys = REDIS_RANK_TO_EXTRA.get(key) || [];
|
|
this.isUnion = isUnion;
|
|
switch (key) {
|
|
case REDIS_KEY.TOP_LINEUP_RANK:
|
|
case REDIS_KEY.TOP_HERO_RANK:
|
|
case REDIS_KEY.SUM_CE_RANK:
|
|
case REDIS_KEY.HERO_RANK:
|
|
this.timelen = 0; break;
|
|
case REDIS_KEY.RACE_ACTIVITY:
|
|
this.timelen = 6; break;
|
|
default:
|
|
this.timelen = 10; break;
|
|
}
|
|
|
|
this.limit = limit;
|
|
}
|
|
|
|
private async generFields(obj: GuildRankInfo | RoleRankInfo) {
|
|
return obj;
|
|
}
|
|
|
|
public setGenerFieldsFun(cb: (obj: GuildRankInfo | RoleRankInfo) => any) {
|
|
this.generFields = cb;
|
|
}
|
|
|
|
// 合成的排行榜的生命时长 单位s
|
|
public setUnionRankLife(unionRankLife: number) {
|
|
this.unionRankLife = unionRankLife;
|
|
}
|
|
|
|
public async existsRank() {
|
|
const result = await redisClient().existsAsync(this.keyName.getName());
|
|
return result;
|
|
}
|
|
|
|
public async setRankWithRoleInfo(roleId: string, score: number, timestamp: number, role?: RoleType, isInc = true) {
|
|
// 如果没有信息，更新玩家信息
|
|
for (let infoKey of [this.infoKey, ...this.extraKeys]) {
|
|
const hasCurUser = await redisClient().hexistsAsync(infoKey, roleId);
|
|
if (!hasCurUser) {
|
|
await this.generParamAndSet(infoKey, { roleId }, { role });
|
|
}
|
|
}
|
|
let newScore = await this.setRank({ roleId }, score, timestamp, isInc);
|
|
|
|
return newScore;
|
|
}
|
|
|
|
public async setRankWithGuildInfo(guildCode: string, score: number, timestamp: number, guild?: GuildType, isInc = true) {
|
|
for (let infoKey of [this.infoKey, ...this.extraKeys]) {
|
|
const hasCurUser = await redisClient().hexistsAsync(infoKey, guildCode);
|
|
if (!hasCurUser) {
|
|
await this.generParamAndSet(infoKey, { guildCode }, { guild });
|
|
}
|
|
}
|
|
let newScore = await this.setRank({ guildCode }, score, timestamp, isInc);
|
|
|
|
return newScore;
|
|
}
|
|
|
|
public async setRankWithHeroInfo(roleId: string, hid: number, score: number, timestamp: number, hero?: HeroType, isInc = true) {
|
|
// 如果没有信息，更新玩家信息
|
|
for (let infoKey of [this.infoKey, ...this.extraKeys]) {
|
|
await this.generParamAndSet(infoKey, { roleId, hid }, { hero });
|
|
}
|
|
let newScore = await this.setRank({ roleId, hid }, score, timestamp, isInc);
|
|
|
|
return newScore;
|
|
}
|
|
|
|
private composeFields(key: string, param: myIdInter) {
|
|
let type = KEY_TO_COMPOSE_FIELD.get(key);
|
|
|
|
if (type == COMPOSE_FIELD_TYPE.ROLE) {
|
|
return param.roleId;
|
|
} else if (type == COMPOSE_FIELD_TYPE.GUILD) {
|
|
return param.guildCode;
|
|
} else if (type == COMPOSE_FIELD_TYPE.ROLE_HERO) {
|
|
return `${param.roleId}:${param.hid}`;
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
private decodeFields(key: string, field: string) {
|
|
let type = KEY_TO_COMPOSE_FIELD.get(key);
|
|
|
|
let arr = field.split(':');
|
|
if (type == COMPOSE_FIELD_TYPE.ROLE) {
|
|
return { roleId: arr[0] };
|
|
} else if (type == COMPOSE_FIELD_TYPE.GUILD) {
|
|
return { guildCode: arr[0] };
|
|
} else if (type == COMPOSE_FIELD_TYPE.ROLE_HERO) {
|
|
return { roleId: arr[0], hid: parseInt(arr[1]) };
|
|
} else {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// 保存info相关数据
|
|
public async generParamAndSet(infoKey: string, fields: myIdInter, db: { role?: RoleType, guild?: GuildType, hero?: HeroType }) {
|
|
let { roleId, guildCode, hid } = fields;
|
|
let { role, guild, hero } = db;
|
|
|
|
if (infoKey == REDIS_KEY.USER_INFO) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
let param = new RankParam(role, true);
|
|
await this.setUserInfo(infoKey, { roleId }, param);
|
|
} else if (infoKey == REDIS_KEY.GUILD_INFO) {
|
|
if (!guild) {
|
|
guild = await GuildModel.findByCode(guildCode, this.keyName.serverId, GUILD_SELECT.RANK)
|
|
}
|
|
let param = new GuildRankParam(guild);
|
|
await this.setUserInfo(infoKey, { guildCode }, param);
|
|
} else if (infoKey == REDIS_KEY.TOP_LINEUP_INFO) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
let { topLineup = [] } = role;
|
|
let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
|
|
let arr = new Array<LineupParam>();
|
|
for (let { hid } of topLineup) {
|
|
let curHero = heroes.find(cur => cur.hid == hid);
|
|
if (curHero) {
|
|
let param = new LineupParam(curHero);
|
|
arr.push(param);
|
|
}
|
|
}
|
|
await this.setUserInfo(infoKey, { roleId }, arr);
|
|
} else if (infoKey == REDIS_KEY.HERO_INFO) {
|
|
if (!hero) {
|
|
hero = await HeroModel.findByHidAndRole(hid, roleId, HERO_SELECT.RANK_LINEUP, true);
|
|
}
|
|
let arr = new Array<LineupParam>();
|
|
if (hero) {
|
|
let param = new LineupParam(hero);
|
|
arr.push(param);
|
|
await this.setUserInfo(infoKey, { roleId, hid }, arr);
|
|
}
|
|
} else if (infoKey == REDIS_KEY.DUNGEON_LINEUP) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
let { dungeonWarId, dungeonHeroes } = role;
|
|
if(dungeonWarId > 0) {
|
|
let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId);
|
|
let lineup = cur?cur.heroes: [];
|
|
let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
|
|
let arr = new Array<LineupParam>();
|
|
for (let seqId of lineup) {
|
|
let curHero = heroes.find(cur => cur.seqId == seqId);
|
|
if (curHero) {
|
|
let param = new LineupParam(curHero);
|
|
arr.push(param);
|
|
}
|
|
}
|
|
await this.setUserInfo(infoKey, { roleId }, arr);
|
|
}
|
|
} else if (infoKey == REDIS_KEY.SHOW_LINEUP) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
let { showLineup, topLineup = [] } = role;
|
|
let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
|
|
let arr = new Array<LineupParam>();
|
|
if(!showLineup) showLineup = topLineup.map(cur => cur.hid);
|
|
for (let hid of showLineup) {
|
|
let curHero = heroes.find(cur => cur.hid == hid);
|
|
if (curHero) {
|
|
let param = new LineupParam(curHero);
|
|
arr.push(param);
|
|
}
|
|
}
|
|
await this.setUserInfo(infoKey, { roleId }, arr);
|
|
}
|
|
}
|
|
|
|
private async setUserInfo(infoKey: string, myId: myIdInter, param: RankParam | GuildRankParam | LineupParam[]) {
|
|
let field = this.composeFields(infoKey, myId);
|
|
let value = JSON.stringify(param);
|
|
return await redisClient().hsetAsync(infoKey, field, value);
|
|
}
|
|
|
|
public async setRank(myId: myIdInter, score: number, timestamp: number, isInc = false) {
|
|
|
|
// 更新分数
|
|
let newScore = score;
|
|
if (this.isUnion) {
|
|
newScore = await this.updateRankScoreAtom(myId, score, timestamp, isInc);
|
|
} else {
|
|
newScore = await this.updateRankScoreEncode(myId, score, timestamp, isInc)
|
|
}
|
|
return newScore;
|
|
}
|
|
|
|
/**
|
|
* @description 使用将score和time合成一个字段更新分数
|
|
* @param myId
|
|
* @param score
|
|
* @param timestamp
|
|
*/
|
|
private async updateRankScoreEncode(myId: myIdInter, score: number = 0, timestamp: number = 0, isInc = false) {
|
|
let newScore = score;
|
|
let key = this.keyName.getName();
|
|
if (isInc) {
|
|
let oldScore = await this.getMyScore(myId);
|
|
newScore = oldScore + score;
|
|
}
|
|
|
|
let scoreStr = this.encodeScore(newScore, timestamp);
|
|
await redisClient().zaddAsync(key, scoreStr, this.composeFields(this.key, myId));
|
|
return score
|
|
}
|
|
|
|
/**
|
|
* @description 使用分两个zset更新redis中某field的值
|
|
* @param myId
|
|
* @param score
|
|
* @param timestamp
|
|
* @param isInc
|
|
* @class Rank
|
|
*/
|
|
private async updateRankScoreAtom(myId: myIdInter, score: number = 0, timestamp: number = 0, isInc = false) {
|
|
let key = this.keyName.getName();
|
|
let timeKey = this.keyName.getTimeName();
|
|
|
|
let pow = Math.pow(10, this.timelen + 1);
|
|
let newScore = 0;
|
|
// 分数zset
|
|
if (isInc) {
|
|
newScore = await redisClient().zincrbyAsync(key, score, this.composeFields(this.key, myId));
|
|
} else {
|
|
newScore = await redisClient().zaddAsync(key, score, this.composeFields(this.key, myId));
|
|
}
|
|
// 时间zset
|
|
await redisClient().zaddAsync(timeKey, pow - 1 - this.handleTimestamp(timestamp), this.composeFields(this.key, myId));
|
|
|
|
return parseInt(newScore.toString());
|
|
}
|
|
|
|
|
|
/**
|
|
* @description 设置到期时间
|
|
* @param time 到期时间，10位时间戳
|
|
* @class Rank
|
|
*/
|
|
public async setExpire(time: number) {
|
|
let key = this.keyName.getName();
|
|
let timeKey = this.keyName.getTimeName();
|
|
|
|
await redisClient().expireatAsync(key, time);
|
|
await redisClient().expireatAsync(timeKey, time);
|
|
}
|
|
|
|
public async generMyRankWithRole(roleId: string, score: number = 0, time: number = 0, role?: RoleType) {
|
|
// 如果没有信息，更新玩家信息
|
|
let param: RoleRankInfo;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
|
|
if (!hasCurUser) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
param = new RoleRankInfo(role, true);
|
|
param.setInfo(0, { roleId }, score, time);
|
|
} else {
|
|
const info = await redisClient().hgetAsync(this.infoKey, roleId);
|
|
const userInfo = JSON.parse(info);
|
|
|
|
param = new RoleRankInfo(userInfo, false);
|
|
param.setInfo(0, { roleId }, score, time);
|
|
}
|
|
|
|
for (let extraKey of this.extraKeys) {
|
|
await this.setExInfoToParam(extraKey, param, { roleId }, {role});
|
|
}
|
|
|
|
return await this.generFields(param);
|
|
}
|
|
|
|
public async generMyRankWithGuild(guildCode: string, score: number, time: number, guild?: GuildType) {
|
|
// 如果没有信息，更新玩家信息
|
|
let param: GuildRankInfo;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(this.infoKey, guildCode);
|
|
if (!hasCurUser) {
|
|
if (!guild) {
|
|
guild = await GuildModel.findByCode(guildCode, this.keyName.serverId, GUILD_SELECT.RANK);
|
|
}
|
|
param = new GuildRankInfo(guild);
|
|
param.setInfo(0, { guildCode }, score, time);
|
|
} else {
|
|
const info = await redisClient().hgetAsync(this.infoKey, guildCode);
|
|
const guildInfo = JSON.parse(info);
|
|
param = new GuildRankInfo(guildInfo);
|
|
param.setInfo(0, { guildCode }, score, time);
|
|
}
|
|
|
|
for (let extraKey of this.extraKeys) {
|
|
await this.setExInfoToParam(extraKey, param, { guildCode }, { guild } );
|
|
}
|
|
|
|
return await this.generFields(param);
|
|
}
|
|
|
|
public async generMyRankWithHero(roleId: string, hid: number, score: number, time: number, hero?: HeroType, role?: RoleType) {
|
|
// 如果没有信息，更新玩家信息
|
|
let param: RoleRankInfo;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
|
|
if (!hasCurUser) {
|
|
if(!role) {
|
|
role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
param = new RoleRankInfo(role, true);
|
|
param.setInfo(0, { roleId, hid }, score, time);
|
|
} else {
|
|
const info = await redisClient().hgetAsync(this.infoKey, roleId);
|
|
const userInfo = JSON.parse(info);
|
|
|
|
param = new RoleRankInfo(userInfo, false);
|
|
param.setInfo(0, { roleId, hid }, score, time);
|
|
}
|
|
|
|
for (let extraKey of this.extraKeys) {
|
|
await this.setExInfoToParam(extraKey, param, { roleId, hid }, { hero, role });
|
|
}
|
|
|
|
return await this.generFields(param);
|
|
}
|
|
|
|
private async setExInfoToParam(extraKey: string, param: RoleRankInfo | GuildRankInfo, myId: myIdInter, db: { role?: RoleType, guild?: GuildType, hero?: HeroType }) {
|
|
let { role, guild, hero } = db;
|
|
|
|
if (extraKey == REDIS_KEY.TOP_LINEUP_INFO) {
|
|
param = <RoleRankInfo>param;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
|
|
if (!hasCurUser) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(myId.roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
|
|
let { topLineup } = role;
|
|
let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
|
|
let arr = new Array<LineupParam>();
|
|
for (let { hid } of topLineup) {
|
|
let curHero = heroes.find(cur => cur.hid == hid);
|
|
if (curHero) {
|
|
let param = new LineupParam(curHero);
|
|
arr.push(param);
|
|
}
|
|
}
|
|
param.setTopLine(arr);
|
|
} else {
|
|
const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
|
|
const infoObj = JSON.parse(info);
|
|
param.setTopLine(infoObj);
|
|
}
|
|
} else if (extraKey == REDIS_KEY.HERO_INFO) {
|
|
param = <RoleRankInfo>param;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
|
|
if (!hasCurUser) {
|
|
if(!hero) {
|
|
hero = await HeroModel.findByHidAndRole(myId.hid, myId.roleId, HERO_SELECT.RANK_LINEUP);
|
|
}
|
|
let arr = new Array<LineupParam>();
|
|
let lineParam = new LineupParam(hero);
|
|
arr.push(lineParam);
|
|
if(this.key == REDIS_KEY.HERO_RANK) {
|
|
param.setSingleHero(arr);
|
|
} else {
|
|
param.setTopLine(arr);
|
|
}
|
|
} else {
|
|
const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
|
|
const infoObj = JSON.parse(info);
|
|
if(this.key == REDIS_KEY.HERO_RANK) {
|
|
param.setSingleHero(infoObj);
|
|
} else {
|
|
param.setTopLine(infoObj);
|
|
}
|
|
}
|
|
} else if (extraKey == REDIS_KEY.DUNGEON_LINEUP) {
|
|
param = <RoleRankInfo>param;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
|
|
if (!hasCurUser) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(myId.roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
let { dungeonWarId, dungeonHeroes } = role;
|
|
let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId);
|
|
let lineup = cur?cur.heroes: [];
|
|
let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.RANK_LINEUP);
|
|
let arr = new Array<LineupParam>();
|
|
for (let seqId of lineup) {
|
|
let curHero = heroes.find(cur => cur.seqId == seqId);
|
|
if (curHero) {
|
|
let param = new LineupParam(curHero);
|
|
arr.push(param);
|
|
}
|
|
}
|
|
param.setTopLine(arr);
|
|
} else {
|
|
const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
|
|
const infoObj = JSON.parse(info);
|
|
param.setTopLine(infoObj);
|
|
}
|
|
} else if (extraKey == REDIS_KEY.SHOW_LINEUP) {
|
|
param = <RoleRankInfo>param;
|
|
|
|
let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
|
|
if (!hasCurUser) {
|
|
if (!role) {
|
|
role = await RoleModel.findByRoleId(myId.roleId, ROLE_SELECT.RANK, true);
|
|
}
|
|
|
|
let { showLineup, topLineup = [] } = role;
|
|
let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
|
|
let arr = new Array<LineupParam>();
|
|
if(!showLineup) showLineup = topLineup.map(cur => cur.hid);
|
|
for (let hid of showLineup) {
|
|
let curHero = heroes.find(cur => cur.hid == hid);
|
|
if (curHero) {
|
|
let param = new LineupParam(curHero);
|
|
arr.push(param);
|
|
}
|
|
}
|
|
param.setTopLine(arr);
|
|
} else {
|
|
const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
|
|
const infoObj = JSON.parse(info);
|
|
param.setTopLine(infoObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
public async getRankListWithMyRank(myId: myIdInter) {
|
|
let ranks = await this.getRankByRange();
|
|
let newRanks = [], newMyRank: RoleRankInfo | GuildRankInfo;
|
|
let myRank = ranks.find(cur => {
|
|
return cur.isMyInfo(myId);
|
|
});
|
|
if (this.generFields) {
|
|
for (let rank of ranks) {
|
|
let n = await this.generFields(rank);
|
|
newRanks.push(n);
|
|
}
|
|
if (myRank) {
|
|
newMyRank = await this.generFields(myRank);
|
|
}
|
|
}
|
|
|
|
return { myRank: newMyRank, ranks: newRanks }
|
|
}
|
|
|
|
public async getRankByRange(from: number | string = '+inf', to: number | string = '-inf') {
|
|
|
|
let ranks = new Array<RoleRankInfo | GuildRankInfo>();
|
|
let key = this.keyName.getName();
|
|
if (this.isUnion) {
|
|
key = await this.generateUnionRank();
|
|
}
|
|
|
|
const rankFromDb = await redisClient().zrevrangebyscoreAsync(key, from, to, "WITHSCORES", "LIMIT", 0, this.limit);
|
|
|
|
for (let ii = 0; ii < rankFromDb.length; ii += 2) {
|
|
const field = rankFromDb[ii];
|
|
let myId = this.decodeFields(this.key, field);
|
|
const { score, time } = 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) {
|
|
param = new RoleRankInfo(userInfo, false);
|
|
param.setInfo(Math.floor(ii / 2) + 1, myId, score, time);
|
|
} else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
|
|
param = new GuildRankInfo(userInfo);
|
|
param.setInfo(Math.floor(ii / 2) + 1, myId, score, time);
|
|
}
|
|
|
|
for (let extraKey of this.extraKeys) {
|
|
await this.setExInfoToParam(extraKey, param, myId, {});
|
|
}
|
|
ranks.push(param);
|
|
}
|
|
return ranks
|
|
}
|
|
|
|
|
|
// 获取我的排名
|
|
public async getMyRank(myId: myIdInter) {
|
|
let key = this.keyName.getName();
|
|
if (this.isUnion) {
|
|
key = await this.generateUnionRank();
|
|
}
|
|
console.log('**getMyRank',key, this.composeFields(this.key, myId), this.key, myId)
|
|
let myRank = await redisClient().zrevrankAsync(key, this.composeFields(this.key, myId));
|
|
if(!myRank && myRank != 0) {
|
|
return 0;
|
|
} else {
|
|
return myRank + 1;
|
|
}
|
|
}
|
|
|
|
// 获取排名第几名的信息
|
|
public async getUserByRank(rank: number) {
|
|
let key = this.keyName.getName();
|
|
let myRank = await redisClient().zrevrangeAsync(key, rank - 1, rank - 1);
|
|
return myRank;
|
|
}
|
|
|
|
|
|
// 获取排名第几名的信息
|
|
public async getMyScore(myId: myIdInter) {
|
|
let key = this.keyName.getName();
|
|
let score = await redisClient().zscoreAsync(key, this.composeFields(this.key, myId));
|
|
if (!score) score = 0;
|
|
if (!this.isUnion) {
|
|
let result = this.decodeScore(score.toString());
|
|
score = result.score;
|
|
}
|
|
return parseInt(score.toString());
|
|
}
|
|
|
|
// 从排行榜中移除
|
|
public async removeFromRank(myId: myIdInter) {
|
|
let key = this.keyName.getName();
|
|
await redisClient().zremAsync(key, this.composeFields(this.key, myId));
|
|
|
|
return true;
|
|
}
|
|
|
|
private async generateUnionRank() {
|
|
let unionKey = this.keyName.getUnionName(); // 联合的key
|
|
let existsKey = await redisClient().existsAsync(unionKey);
|
|
if (!existsKey) {
|
|
let originKey = this.keyName.getName();
|
|
let timeKey = this.keyName.getTimeName();
|
|
|
|
let pow = Math.pow(10, this.timelen + 1);
|
|
await redisClient().zunionstoreAsync(unionKey, 2, originKey, timeKey, 'WEIGHTS', pow, 1);
|
|
await redisClient().expireAsync(unionKey, this.unionRankLife); // 10秒更新一次
|
|
}
|
|
return unionKey;
|
|
}
|
|
|
|
// 有序排行综合时间和得分排序
|
|
private encodeScore(score: number, timestamp: number) {
|
|
let timelen = this.timelen;
|
|
let pow = Math.pow(10, timelen + 1);
|
|
return score * pow + pow - 1 - this.handleTimestamp(timestamp)
|
|
}
|
|
|
|
private decodeScore(num: string) {
|
|
let timelen = this.timelen;
|
|
let pow = Math.pow(10, timelen + 1);
|
|
let _num = parseInt(num);
|
|
return {
|
|
time: pow - _num % pow,
|
|
score: Math.floor(_num / pow)
|
|
};
|
|
}
|
|
|
|
private handleTimestamp(timestamp: number = 0) {
|
|
let l = timestamp.toString().length;
|
|
if(l > this.timelen) {
|
|
timestamp = Math.floor(timestamp / Math.pow(10, l - this.timelen));
|
|
}
|
|
return timestamp
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* 从数据库内获取排行榜存入redis
|
|
* @param type 排行榜类型
|
|
* @param serverId 分服
|
|
*/
|
|
export async function setRankRedisFromDb(type: string, args?: {serverId?: number}) {
|
|
|
|
if(type == REDIS_KEY.TOWER_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('tower', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
// console.log(roleId);
|
|
await r.setRankWithRoleInfo(role.roleId, role.towerLv, role.towerUpTime?role.towerUpTime.getTime():0, role);
|
|
}
|
|
} else if (type == REDIS_KEY.GUILD_ACTIVE_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await GuildModel.getRank(type, serverId);
|
|
let r = new Rank(type, { serverId });
|
|
for(let guild of ranks) {
|
|
await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
|
|
}
|
|
} else if (type == REDIS_KEY.GUILD_LV_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await GuildModel.getRank(type, serverId);
|
|
let r = new Rank(type, { serverId });
|
|
for(let guild of ranks) {
|
|
await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild);
|
|
}
|
|
} else if ( type == REDIS_KEY.PVP_RANK) {
|
|
let { seasonNum } = await SystemConfigModel.findSystemConfig();
|
|
console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
|
|
let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
|
|
let r = new Rank(type, {});
|
|
for(let {roleId, role: _role, score, updatedAt } of ranks) {
|
|
let role = <RoleType>_role;
|
|
if (!role) {
|
|
continue;
|
|
}
|
|
await r.setRankWithRoleInfo(roleId, score, updatedAt.getTime(), role);
|
|
}
|
|
} else if (type == REDIS_KEY.TOP_LINEUP_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('topLineup', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
// console.log(roleId);
|
|
await r.setRankWithRoleInfo(role.roleId, role.topLineupCe, role.updatedAt.getTime(), role);
|
|
}
|
|
} else if (type == REDIS_KEY.TOP_HERO_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await HeroModel.getAllRank(serverId, HERO_SELECT.RANK_LINEUP);
|
|
let r = new Rank(type, { serverId });
|
|
for(let hero of ranks) {
|
|
await r.setRankWithHeroInfo(hero.roleId, hero.hid, hero.ce, hero.updatedAt.getTime(), hero);
|
|
}
|
|
} else if (type == REDIS_KEY.HERO_NUM_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('heroNum', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role );
|
|
}
|
|
} else if (type == REDIS_KEY.USER_LV) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('lv', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
await r.setRankWithRoleInfo(role.roleId, role.lv, role.updatedAt.getTime(), role);
|
|
}
|
|
} else if (type == REDIS_KEY.SUM_CE_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('ce', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
await r.setRankWithRoleInfo(role.roleId, role.ce, role.updatedAt.getTime(), role);
|
|
}
|
|
} else if (type == REDIS_KEY.DUNGEON_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('dungeon', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
await r.setRankWithRoleInfo(role.roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
|
|
}
|
|
} else if (type == REDIS_KEY.MAIN_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('main', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
await r.setRankWithRoleInfo(role.roleId, role.mainWarId, role.mainUpdatedAt, role);
|
|
}
|
|
} else if (type == REDIS_KEY.MAIN_ELITE_RANK) {
|
|
let serverId = args.serverId;
|
|
let ranks = await RoleModel.getRank('mainElite', serverId, ROLE_SELECT.RANK);
|
|
let r = new Rank(type, { serverId });
|
|
for(let role of ranks) {
|
|
await r.setRankWithRoleInfo(role.roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
|
|
}
|
|
} else if (type == REDIS_KEY.HERO_RANK) {
|
|
let serverId = args.serverId;
|
|
|
|
for(let hid of gameData.dicMyHeroes) {
|
|
let ranks = await HeroModel.getRank(hid, serverId, HERO_SELECT.RANK_LINEUP);
|
|
let r = new Rank(type, { serverId, hid });
|
|
for(let hero of ranks) {
|
|
await r.setRankWithHeroInfo(hero.roleId, hid, hero.ce, hero.updatedAt.getTime(), hero);
|
|
}
|
|
}
|
|
}
|
|
} |