461 lines
22 KiB
TypeScript
461 lines
22 KiB
TypeScript
// 征战中原相关
|
|
|
|
import moment = require("moment");
|
|
import { GVG_PERIOD, GVG_RETURN_ITEM_TYPE, REDIS_KEY, VESTIGE_OPP_STATUS, VESTIGE_STATUS } from "../../consts";
|
|
import { ArtifactModel } from "../../db/Artifact";
|
|
import { GVGConfigModel } from "../../db/GVGConfig";
|
|
import { GVGLeagueModel, GVGLeagueType } from "../../db/GVGLeague";
|
|
import { GVGUserDataModel } from "../../db/GVGUserData";
|
|
import { GVGVestigeModel } from "../../db/GVGVestige";
|
|
import { GVGVestigeLeagueRankModel, GVGVestigeLeagueRankType } from "../../db/GVGVestigeLeagueRank";
|
|
import { GVGVestigeLockModel } from "../../db/GVGVestigeLock";
|
|
import { GVGVestigeRankModel, GVGVestigeRankType, GVGVestigeRankUpdate } from "../../db/GVGVestigeRank";
|
|
import { GVGVestigeRecType } from "../../db/GVGVestigeRec";
|
|
import { GVGVestigeSumRankModel, GVGVestigeSumRankType } from "../../db/GVGVestigeSumRank";
|
|
import { HeroModel, HeroType } from "../../db/Hero";
|
|
import { RoleModel } from "../../db/Role";
|
|
import { OppDetailData, OppPlayerHeroInfo, OppPlayerInfo } from "../../domain/gvgField/gvgDb";
|
|
import { GVGVestigeOppPlayer } from "../../domain/gvgField/returnData";
|
|
import { KeyNameParam, LeagueRankInfo, myIdInter, RoleRankInfo } from "../../domain/rank";
|
|
import { gameData, getGVGVestigeLeagueRank, getGVGVestigePlayerRank, getGVGVestigeRange } from "../../pubUtils/data";
|
|
import { GVG } from "../../pubUtils/dicParam";
|
|
import { RewardInter } from "../../pubUtils/interface";
|
|
import { getTimeFun, nowSeconds } from "../../pubUtils/timeUtil";
|
|
import { getRandEelm } from "../../pubUtils/util";
|
|
import { getNumberArr, uniqueArr } from "../ladderService";
|
|
import { getHeroesAttributes } from "../playerCeService";
|
|
import { Rank } from "../rankService";
|
|
import { findKeys, getAllServerName, redisClient } from "../redisService";
|
|
import { isDevelopEnv } from "../utilService";
|
|
import { combinePushItem } from "./gvgItemService";
|
|
import { addVestigeLeagueRankRec, addVestigeRankMessage } from "./gvgRecService";
|
|
import { getGroupIdOfServer, getGroupKey, getGVGServerType, getPeriodByTime } from "./gvgService";
|
|
|
|
let gvgFightTime = undefined;
|
|
|
|
// ！！注意，这个函数会改动内存，线上不应该使用
|
|
export function setPeriodTime(startFightTime: number, endFightTime: number) {
|
|
gvgFightTime = { startFightTime, endFightTime }
|
|
}
|
|
|
|
export function resetPeriodTime() {
|
|
gvgFightTime = undefined;
|
|
}
|
|
|
|
// 备战期的遗迹和激战期的开始结束战斗时间
|
|
export function getFightTimeByPeriod(period: GVG_PERIOD, time?: number) {
|
|
let dicPeriod = gameData.gvgPeriod.get(period);
|
|
if(!dicPeriod) return { startFightTime: 0, endFightTime: 0 };
|
|
|
|
if(isDevelopEnv() && gvgFightTime) {
|
|
return gvgFightTime;
|
|
}
|
|
|
|
return {
|
|
startFightTime: <number>getTimeFun(time).getTimeWithHour(dicPeriod.startHour, dicPeriod.startMinute, dicPeriod.startSecond),
|
|
endFightTime: <number>getTimeFun(time).getTimeWithHour(dicPeriod.endHour, dicPeriod.endMinute, dicPeriod.endSecond),
|
|
}
|
|
}
|
|
|
|
export function checkFightTime() {
|
|
let { startFightTime, endFightTime } = getFightTimeByPeriod(GVG_PERIOD.PREPARE);
|
|
let now = nowSeconds();
|
|
return startFightTime <= now && endFightTime >= now;
|
|
}
|
|
|
|
// 征战中原每天随机的遗迹点
|
|
export async function getVestiges(serverId: number) {
|
|
let groupKey = await getGroupKey(serverId);
|
|
let serverType = await getGVGServerType(serverId);
|
|
let vestige = await GVGVestigeModel.getVestige(groupKey);
|
|
if(!vestige) {
|
|
let dicGVGVestige = gameData.gvgVestigeByServerType.get(serverType)||[];
|
|
let cnt = gameData.gvgVestigeCntByServerType.get(serverType)||0;
|
|
let randResult = getRandEelm(dicGVGVestige, cnt);
|
|
vestige = await GVGVestigeModel.initTodayVestige(groupKey, randResult);
|
|
}
|
|
return vestige.vestiges||[];
|
|
}
|
|
|
|
export async function getMyVestiges(serverId: number, roleId: string) {
|
|
let vestiges = await getVestiges(serverId);
|
|
let myRanks = await GVGVestigeRankModel.findAllByRole(roleId);
|
|
let result: { vestigeId: number, position: string, myRank: number }[] = [];
|
|
for(let vestige of vestiges) {
|
|
let myRank = myRanks.find(cur => cur.vestigeId == vestige.vestigeId);
|
|
result.push({ ...vestige, myRank: myRank?.rank||0 });
|
|
}
|
|
return result;
|
|
}
|
|
|
|
export async function checkVestige(serverId: number, vestigeId: number) {
|
|
let vestiges = await getVestiges(serverId);
|
|
return !!vestiges.find(cur => cur.vestigeId == vestigeId);
|
|
}
|
|
|
|
// 根据自己排名随机出对手排名
|
|
export function refreshVestigeOppRanks(rank: number) {
|
|
let dicRange = getGVGVestigeRange(rank);
|
|
if(!dicRange) return [];
|
|
|
|
let { rangeBeforeFrom, rangeBeforeTo, rangeBeforeNum, rangeAfterFrom, rangeAfterTo, rangeAfterNum } = dicRange;
|
|
let beforeRanks = randomRank(rangeBeforeFrom == -1? rank: rangeBeforeFrom, rangeBeforeTo == -1? rank: rangeBeforeTo, rangeBeforeNum);
|
|
let afterRanks = randomRank(rangeAfterFrom == -1? rank: rangeAfterFrom, rangeAfterTo == -1? rank: rangeAfterTo, rangeAfterNum);
|
|
|
|
let topRanks = getNumberArr(dicRange.topChallengeFrom, dicRange.topChallengeTo);
|
|
let ranks = [...topRanks, ...beforeRanks, ...afterRanks];
|
|
return uniqueArr(ranks.sort((a, b) => a - b));
|
|
}
|
|
|
|
function randomRank(min: number, max: number, len: number) {
|
|
if(min == max || len == 0) return [];
|
|
let arr = getNumberArr(min + 1, max);
|
|
return getRandEelm(arr, len);
|
|
}
|
|
|
|
// 根据ranks获取oppPlayer显示数据
|
|
export async function getOppPlayerByRanks(serverId: number, groupKey: string, vestigeId: number, ranks: number[]) {
|
|
let serverNames = await getAllServerName();
|
|
let opps = await GVGVestigeRankModel.findByRanks(groupKey, vestigeId, ranks);
|
|
let roleIds = opps.map(cur => cur.roleId);
|
|
let roles = await RoleModel.findByRoleIds(roleIds, 'roleId roleName head frame spine heads frames spines title lv guildName serverId updatedAt')
|
|
let dicRankMap = gameData.gvgVestige.get(vestigeId);
|
|
if(!dicRankMap) return [];
|
|
let result: GVGVestigeOppPlayer[] = [];
|
|
for(let rank of ranks) {
|
|
let obj = new GVGVestigeOppPlayer(rank);
|
|
let opp = opps.find(cur => cur.rank == rank);
|
|
let dicCurRank = dicRankMap.get(rank);
|
|
if(opp) {
|
|
let role = roles.find(cur => cur.roleId == opp.roleId);
|
|
if(!role) continue;
|
|
let lineupce = opp.lineup.reduce((pre, cur) => pre + cur.ce, 0);
|
|
const { leagueCode, name } = opp;
|
|
obj.setByRole(role, serverNames, lineupce, dicCurRank?.score||0, leagueCode, name);
|
|
} else {
|
|
obj.setByDic(dicCurRank, serverNames[serverId]);
|
|
}
|
|
result.push(obj);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// 获取其他遗迹里使用过的武将
|
|
export async function getVestigeUsedHeroes(roleId: string, curVestigeId: number) {
|
|
let myDatas = await GVGVestigeRankModel.findAllByRole(roleId);
|
|
let result: number[] = [];
|
|
for(let { vestigeId, lineup = [] } of myDatas) {
|
|
if(vestigeId == curVestigeId) continue;
|
|
result.push(...lineup.map(cur => cur.actorId));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// 是否在其他遗迹中使用过这个武将
|
|
export async function checkHeroIsUsedInOtherVestige(roleId: string, curVestigeId: number, heroes: { actorId: number }[]) {
|
|
let usedHeroes = await getVestigeUsedHeroes(roleId, curVestigeId);
|
|
for(let { actorId } of heroes) {
|
|
if(usedHeroes.indexOf(actorId) != -1) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// 检查我的排名是否可以挑战对方的排名
|
|
export function checkVestigeRank(myRank: number, targetRank: number) {
|
|
let dicRange = getGVGVestigeRange(myRank);
|
|
if(!dicRange) return false;
|
|
if(myRank == targetRank || targetRank == 0) return false;
|
|
|
|
// 是否可以挑战最前的几个排名
|
|
if(dicRange.topChallengeFrom <= targetRank && dicRange.topChallengeTo >= targetRank) return true;
|
|
if(dicRange.rangeBeforeTo == -1) {
|
|
if(dicRange.rangeBeforeFrom < targetRank && myRank > targetRank) return true;
|
|
} else {
|
|
if(dicRange.rangeBeforeFrom < targetRank && dicRange.rangeBeforeTo >= targetRank) return true;
|
|
}
|
|
if(dicRange.rangeAfterTo == -1) {
|
|
if(dicRange.rangeAfterFrom < targetRank && myRank > targetRank) return true;
|
|
} else {
|
|
if(dicRange.rangeAfterFrom < targetRank && dicRange.rangeAfterTo >= targetRank) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
export function isRobot(roleId: string) {
|
|
if(!roleId) roleId = '';
|
|
return roleId.startsWith('robot');
|
|
}
|
|
|
|
export async function checkVestigeOppStatus(configId: number, groupKey: string, vestigeId: number, roleId: string, myRank: number, targetRoleId: string, rank: number) {
|
|
|
|
let myData = await getMyVestigeRank(configId, groupKey, vestigeId, roleId);
|
|
if(!myData || myData.rank != myRank) return VESTIGE_OPP_STATUS.MY_RANK_CHANGE;
|
|
|
|
if(isRobot(targetRoleId)) {
|
|
let targetData = await GVGVestigeRankModel.findByRank(configId, groupKey, vestigeId, rank);
|
|
if(targetData) return VESTIGE_OPP_STATUS.OPP_RANK_CHANGE;
|
|
} else {
|
|
let targetData = await GVGVestigeRankModel.findByRole(vestigeId, targetRoleId);
|
|
if(targetData?.rank != rank) return VESTIGE_OPP_STATUS.OPP_RANK_CHANGE;
|
|
}
|
|
let lockResult = await GVGVestigeLockModel.chooseOppLock(groupKey, vestigeId, rank, configId, roleId, targetRoleId);
|
|
if(!lockResult) return VESTIGE_OPP_STATUS.OPP_IS_LOCKED;
|
|
|
|
return VESTIGE_OPP_STATUS.BATTLE;
|
|
}
|
|
|
|
// 生成防守数据
|
|
export async function generateDefenseInfo(roleId: string, vestigeId: number, rank: number) {
|
|
if(isRobot(roleId)) {
|
|
let dicRank = gameData.gvgVestige.get(vestigeId)?.get(rank); // 调用之前已经验证过了
|
|
let dicWar = gameData.war.get(dicRank?.warId);
|
|
let dicWarJson = gameData.warJson.get(dicWar?.dispatchJsonId);
|
|
if(!dicWarJson) return new OppPlayerInfo();
|
|
|
|
let heroes: OppPlayerHeroInfo[] = [];
|
|
for(let json of dicWarJson) {
|
|
if(json.relation == 2) {
|
|
let hero = new OppPlayerHeroInfo();
|
|
hero.setByWarJson(json);
|
|
heroes.push(hero);
|
|
}
|
|
}
|
|
let info = new OppPlayerInfo();
|
|
info.initByRobot(dicRank, heroes, true);
|
|
return info;
|
|
} else {
|
|
let playerVestigeData = await GVGVestigeRankModel.findByRole(vestigeId, roleId);
|
|
if(!playerVestigeData) return null;
|
|
let lineup = playerVestigeData.lineup||[];
|
|
let hids = lineup.map(cur => cur.actorId);
|
|
let role = await RoleModel.findByRoleId(playerVestigeData.roleId, 'roleId roleName heads head frames frame spines spine title lv');
|
|
let heroes = await HeroModel.findByHidRange(hids, playerVestigeData.roleId, 'hid skinId lv star colorStar quality ce');
|
|
let league = await GVGLeagueModel.findByCode(playerVestigeData.leagueCode);
|
|
|
|
let info = new OppPlayerInfo();
|
|
info.initByPlayer(playerVestigeData.rank, role, league, true);
|
|
info.setPlayerHeroes(heroes, lineup);
|
|
return info;
|
|
}
|
|
}
|
|
|
|
export async function generateAttackInfo(roleId: string, league: GVGLeagueType, rank: number) {
|
|
let role = await RoleModel.findByRoleId(roleId, 'roleId roleName heads head frames frame spines spine title lv');
|
|
let info = new OppPlayerInfo();
|
|
info.initByPlayer(rank, role, league, false);
|
|
return info;
|
|
}
|
|
|
|
export async function generateAttackHeroInfo(lineup: { actorId: number, dataId: number, order: number }[], dbHeroes: HeroType[]) {
|
|
let info = new OppPlayerInfo();
|
|
info.setPlayerHeroes(dbHeroes, lineup);
|
|
return info;
|
|
}
|
|
|
|
export async function getOppDetailData(rec: GVGVestigeRecType) {
|
|
let isRobot = rec.defenseInfo.isRobot;
|
|
let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rec.defenseInfo.oldRank);
|
|
let result = new OppDetailData(rec, getVestigeRecStatus(rec));
|
|
if(!isRobot) {
|
|
const dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
|
|
const dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
|
|
const defenseInfo = rec.defenseInfo.heroes||[];
|
|
const hids = defenseInfo.map(cur => cur.hid);
|
|
const heroes = await HeroModel.findByHidRange(hids, rec.defenseRoleId, 'hid lv quality star colorStar skins ce skinId');
|
|
const artifactSeids = heroes.map(hero => hero.artifact);
|
|
const artifacts = await ArtifactModel.findbySeqIds(rec.defenseRoleId, artifactSeids);
|
|
result.setByPlayer(dicWarJson, defenseInfo, heroes, artifacts);
|
|
let attrByHid = await getHeroesAttributes(rec.defenseRoleId);
|
|
for(let [hid, attribute] of attrByHid) {
|
|
result.setAttribute(hid, attribute.getAttributesToString());
|
|
}
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
// 根据记录里的时间判断当前状态
|
|
export function getVestigeRecStatus(rec: GVGVestigeRecType) {
|
|
let { checkTime = 0, battleTime = 0, endTime = 0, cancel } = rec;
|
|
if(cancel) return { status: VESTIGE_STATUS.COMPLETE, time: Math.floor(endTime/1000) };
|
|
if(endTime > 0 && endTime <= Date.now()) return { status: VESTIGE_STATUS.COMPLETE, time: Math.floor(endTime/1000) };
|
|
if(battleTime > 0 && battleTime <= Date.now() && battleTime + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN * 1000 > Date.now()) return { status: VESTIGE_STATUS.BATTLE, time: Math.floor(battleTime/1000) + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN };
|
|
if(checkTime > 0 && checkTime <= Date.now() && checkTime + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN * 1000 > Date.now()) return { status: VESTIGE_STATUS.CHECK, time: Math.floor(checkTime/1000) + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN };
|
|
// 超时的
|
|
if(battleTime > 0 && endTime == 0 && battleTime + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN * 1000 <= Date.now()) return { status: VESTIGE_STATUS.COMPLETE, time: Math.floor(battleTime/1000) + GVG.GVG_VESTIGE_BATTLE_COUNTDOWN };
|
|
if(checkTime > 0 && battleTime == 0 && checkTime + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN * 1000 <= Date.now()) return { status: VESTIGE_STATUS.COMPLETE, time: Math.floor(checkTime/1000) + GVG.GVG_VESTIGE_PREPARE_COUNTDOWN };
|
|
return { status: VESTIGE_STATUS.NO, time: 0 };
|
|
}
|
|
|
|
// 将开始战斗时候的阵容存到防守阵容
|
|
export async function updateMyVestigeRank(isChange: boolean, atkData: GVGVestigeRankType, defData: GVGVestigeRankType, historyRank: number, rec: GVGVestigeRecType) {
|
|
let update: GVGVestigeRankUpdate = {}, needUpdate = false;
|
|
if(isChange) {
|
|
if(atkData && !atkData.hasDefense) { // 只有第一次挑战且自己没有主动保存过阵容的时候才会这么保存
|
|
let heroes = rec.attackInfo.heroes||[];
|
|
let lineup = heroes.map(hero => ({ actorId: hero.hid, dataId: hero.dataId, order: hero.order, ce: hero.ce }));
|
|
update.lineup = lineup;
|
|
update.hasDefense = true;
|
|
needUpdate = true;
|
|
}
|
|
if(atkData && (historyRank == 0 || atkData.rank < historyRank)) { // 更新历史最高排名
|
|
update.historyRank = atkData.rank;
|
|
needUpdate = true;
|
|
}
|
|
if(atkData) { // 排名变化时刷新对手
|
|
let oppRanks = refreshVestigeOppRanks(atkData.rank);
|
|
update.oppRanks = oppRanks;
|
|
needUpdate = true;
|
|
}
|
|
}
|
|
if(needUpdate) {
|
|
atkData = await GVGVestigeRankModel.updateByRoleId(atkData.vestigeId, atkData.roleId, update);
|
|
}
|
|
if(isChange && defData) {
|
|
let oppRanks = refreshVestigeOppRanks(defData.rank);
|
|
defData = await GVGVestigeRankModel.updateByRoleId(defData.vestigeId, defData.roleId, { oppRanks });
|
|
}
|
|
return atkData
|
|
}
|
|
|
|
export function calBreakGoods(vestige: number, historyRank: number, rank: number) {
|
|
let dicRankMap = gameData.gvgVestige.get(vestige);
|
|
if(!dicRankMap) return { rewards: [], leagueRewards: [] };
|
|
let rewards: RewardInter[] = [], leagueRewards: RewardInter[] = [];
|
|
for(let i = historyRank + 1; i <= rank; i++) {
|
|
let dicRank = dicRankMap.get(i);
|
|
if(!dicRank) continue;
|
|
combinePushItem(rewards, dicRank.onceReward);
|
|
combinePushItem(leagueRewards, dicRank.onceLeagueReward);
|
|
}
|
|
return { rewards, leagueRewards }
|
|
}
|
|
|
|
// 玩家当天的驻扎记录，没有的话就创建一个
|
|
export async function getMyVestigeRank(configId: number, groupKey: string, vestigeId: number, roleId: string, myLeague?: GVGLeagueType) {
|
|
|
|
let myVestigeRank = await GVGVestigeRankModel.findByRole(vestigeId, roleId); // 我在这个遗迹的排名
|
|
if(!myVestigeRank) {
|
|
let role = await RoleModel.findByRoleId(roleId, 'roleId guildCode');
|
|
let oppRanks = refreshVestigeOppRanks(-1);
|
|
if(!myLeague) {
|
|
myLeague = await GVGLeagueModel.findLeagueByGuild(role.guildCode);
|
|
if(!myLeague) return null
|
|
}
|
|
const { leagueCode, name } = myLeague;
|
|
myVestigeRank = await GVGVestigeRankModel.initRank(configId, vestigeId, groupKey, role, leagueCode, name, oppRanks );
|
|
}
|
|
return myVestigeRank;
|
|
}
|
|
|
|
// 保存排行榜
|
|
export async function saveScoreToRank(rec: GVGVestigeRecType) {
|
|
await savePlayerRank(rec.configId, rec.groupKey, rec.vestigeId, rec.attackInfo);
|
|
await savePlayerRank(rec.configId, rec.groupKey, rec.vestigeId, rec.defenseInfo);
|
|
}
|
|
|
|
export function getDayKeyInfo() {
|
|
return moment().format('YYMMDD');
|
|
}
|
|
|
|
export async function savePlayerRank(configId: number, groupKey: string, vestigeId: number, playerInfo: Partial<OppPlayerInfo>) {
|
|
if(playerInfo.isRobot) return
|
|
let dicRankMap = gameData.gvgVestige.get(vestigeId);
|
|
let newRank = dicRankMap?.get(playerInfo.newRank)?.score||0;
|
|
let oldRank = dicRankMap?.get(playerInfo.oldRank)?.score||0;
|
|
|
|
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
|
|
let myScore = await GVGVestigeSumRankModel.incScore(playerInfo.roleId, playerInfo.leagueCode, configId, groupKey, newRank - oldRank);
|
|
let r1 = new Rank(REDIS_KEY.GVG_VESTIGE_MEMBER_ALL, { groupKey, day: getDayKeyInfo() });
|
|
await r1.setExpire(nextWeek);
|
|
await r1.setRankWithRoleInfo(playerInfo.roleId, myScore.score, myScore.updatedAt.getTime());
|
|
let leagueScore = await GVGVestigeLeagueRankModel.incScore(configId, playerInfo.leagueCode, groupKey, newRank - oldRank);
|
|
let r2 = new Rank(REDIS_KEY.GVG_VESTIGE_LEAGUE, { groupKey, day: getDayKeyInfo() });
|
|
await r2.setExpire(nextWeek);
|
|
await r2.setRankWithLeagueInfo(playerInfo.leagueCode, leagueScore.score, leagueScore.updatedAt.getTime());
|
|
}
|
|
|
|
export async function getVestigeRank(redisKey: REDIS_KEY, isSimple: boolean, keyParam: KeyNameParam, myId: myIdInter, serverNames?: any) {
|
|
let r = new Rank(redisKey, keyParam);
|
|
r.setGenerFieldsFun((obj => {
|
|
if(redisKey == REDIS_KEY.GVG_VESTIGE_MEMBER_ALL && obj instanceof RoleRankInfo) {
|
|
if(isSimple) {
|
|
return { rank: obj.rank, name: obj.roleName, serverName: serverNames[obj.serverId], score: obj.num }
|
|
} else {
|
|
return { ...obj, serverName: serverNames[obj.serverId], score: obj.num }
|
|
}
|
|
}
|
|
if(redisKey == REDIS_KEY.GVG_VESTIGE_LEAGUE && obj instanceof LeagueRankInfo) {
|
|
if(isSimple) {
|
|
return { rank: obj.rank, name: obj.name, score: obj.num }
|
|
} else {
|
|
return { ...obj, score: obj.num, leader: {...obj.leader, serverName: serverNames[obj.leader.serverId]}};
|
|
}
|
|
}
|
|
return obj
|
|
}));
|
|
|
|
let { ranks, myRank } = await r.getRankListWithMyRank(myId);
|
|
if (!myRank) {
|
|
if(redisKey == REDIS_KEY.GVG_VESTIGE_MEMBER_ALL) {
|
|
myRank = await r.generMyRankWithRole(myId.roleId, 0, 0);
|
|
} else if (redisKey == REDIS_KEY.GVG_VESTIGE_LEAGUE) {
|
|
myRank = await r.generMyRankWithLeague(myId.leagueCode, 0, 0);
|
|
}
|
|
}
|
|
return { ranks, myRank }
|
|
}
|
|
|
|
// systimer 服
|
|
export async function saveVestigeRankSchedule() {
|
|
let config = await GVGConfigModel.findConfig();
|
|
let period = getPeriodByTime(config.teamTime, config.prepareTime, config.battleTime, config.scheduleTime);
|
|
if(period != GVG_PERIOD.PREPARE) return;
|
|
let day = getDayKeyInfo();
|
|
let keys = await findKeys(`${REDIS_KEY.GVG_VESTIGE_LEAGUE}:${day}:`);
|
|
for(let key of keys) {
|
|
let [,, groupKey] = key.split(':');
|
|
let r = new Rank(REDIS_KEY.GVG_VESTIGE_LEAGUE, { groupKey, day});
|
|
let ranks = await r.getRankByRangeRaw();
|
|
await GVGVestigeLeagueRankModel.saveRank(groupKey, ranks);
|
|
await addVestigeLeagueRankRec(config.configId, groupKey, ranks);
|
|
await addVestigeRankMessage(ranks);
|
|
}
|
|
|
|
let memberKeys = await findKeys(`${REDIS_KEY.GVG_VESTIGE_MEMBER_ALL}:${day}:`);
|
|
for(let key of memberKeys) {
|
|
let [,, groupKey] = key.split(':');
|
|
let r = new Rank(REDIS_KEY.GVG_VESTIGE_MEMBER_ALL, { groupKey, day});
|
|
let ranks = await r.getRankByRangeRaw();
|
|
await GVGVestigeSumRankModel.saveRank(groupKey, ranks);
|
|
}
|
|
let playerSumRanks = await GVGVestigeSumRankModel.findAllScores();
|
|
await GVGUserDataModel.addVestigeScores(config.configId, playerSumRanks);
|
|
}
|
|
|
|
export function calVestigeLeagueBoxRewards(canReceiveRanks: GVGVestigeLeagueRankType[], canReceivePlayerRanks: GVGVestigeSumRankType[]) {
|
|
let rewards: RewardInter[] = [], leagueReward: RewardInter[] = [];
|
|
for(let { rank } of canReceiveRanks) {
|
|
let dicRank = getGVGVestigeLeagueRank(rank);
|
|
if(!dicRank) { console.error('dic_zyz_GVGVestigeLeagueRank error'); continue; }
|
|
// console.log('###### league', rank, dicRank)
|
|
combinePushItem(rewards, dicRank.rankReward);
|
|
combinePushItem(leagueReward, dicRank.rankLeagueReward);
|
|
}
|
|
for(let { rank } of canReceivePlayerRanks) {
|
|
let dicRank = getGVGVestigePlayerRank(rank);
|
|
if(!dicRank) { console.error('dic_zyz_GVGVestigPlayerRank error'); continue; }
|
|
// console.log('###### player', rank, dicRank)
|
|
combinePushItem(rewards, dicRank.rankPlayerReward);
|
|
combinePushItem(leagueReward, dicRank.rankPlayerLeagueReward);
|
|
}
|
|
let boxPreview: { id: number, count: number, itemType: number }[] = [];
|
|
for(let { id, count } of rewards) boxPreview.push({ id, count, itemType: GVG_RETURN_ITEM_TYPE.NORMAL_ITEM });
|
|
for(let { id, count } of leagueReward) boxPreview.push({ id, count, itemType: GVG_RETURN_ITEM_TYPE.GVG_ITEM });
|
|
return {
|
|
leagueReward, rewards, boxPreview, canReceiveBox: canReceiveRanks.length > 0 || canReceivePlayerRanks.length > 0
|
|
}
|
|
} |