pvp：修复赛季初始排行

game-server/app.ts

@@ -122,8 +122,9 @@ app.configure(ALL_ENVS, 'guild', function () {
 })
 
 app.configure(ALL_ENVS, 'systimer', function () {
-    app.afterStart(() => {
+    app.afterStart(async () => {
-        timeTaskService.init();
+        await redisService.initAllRank();
+        await timeTaskService.init();
     });
 });
 
@@ -219,7 +220,6 @@ if (app.isMaster()) {
     app.event.on('start_all', (servers) => {
         // 全部服务器启动完毕后初始化 redis 数据
         redisService.readDataBase();
-        redisService.initAllRank();
         redisService.clearComBtlQueue();
         redisService.clearChannelServers();
         updateTeamStatus(COM_TEAM_STATUS.DEFAULT, COM_TEAM_STATUS.LOOSE);

game-server/app/servers/battle/handler/pvpHandler.ts

@@ -471,7 +471,8 @@ export class PvpHandler {
                 newHero.setIsDefense(false);
                 heroes.push(newHero);
             }
-            result = new PlayerDetail({ ...pvpHistoryOpp, roleId: pvpHistoryOpp.oppRoleId, heroes, rank: pvpHistoryOpp.rankLv });
+            result = new PlayerDetail(pvpHistoryOpp.oppRoleId, heroes, pvpHistoryOpp.rankLv);
+            result.setRobot(pvpHistoryOpp);
         } else { // 查询对方pvpDefense
             let pvpDefense = await PvpDefenseModel.findByRoleId(oppoRoleId);
             let dbHeroes = await HeroModel.findByRole(oppoRoleId);
@@ -489,7 +490,9 @@ export class PvpHandler {
             let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
             let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
 
-            result = new PlayerDetail({ ...role, ...pvpDefense, heroes, rank });
+            result = new PlayerDetail(oppoRoleId, heroes, rank);
+            result.setPlayer(role);
+            result.setPvpDefense(pvpDefense);
         }
 
         return resResult(STATUS.SUCCESS, result);

game-server/app/servers/role/handler/friendHandler.ts

@@ -686,7 +686,9 @@ export class FriendHandler {
         let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
 
-        result = new PlayerDetail({ ...role, defCe: topLineupCe, heroes });
+        result = new PlayerDetail(oppoRoleId, heroes, rank);
+        result.setPlayer(role);
+        result.setCe(topLineupCe);
         result.setWarStar(role.warStar, rank, towerLv - 1);
 
         return resResult(STATUS.SUCCESS, result);

game-server/app/services/guildActivityService.ts

@@ -453,7 +453,7 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
                 await GuildActivityCityModel.guard(serverId, cityId, "", ""); // 无人能占领
             }
         }
-        let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, guildRank);
+        let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, guildRank, cityId);
         let members = obj.getMembersOfGuild(guildCode);
 
         let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, {

game-server/app/services/pvpService.ts

@@ -457,6 +457,7 @@ export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType,
 }
 
 function calLineupScore(lineup: Attack|Defense, heroScores: HeroScore[]) {
+    if(!lineup) return lineup;
     let score = 0;
     for(let { actorId } of lineup.heroes) {
         let hs = heroScores.find(cur => cur.hid == actorId);
@@ -517,9 +518,9 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayer,
  export async function pvpSeasonEnd(pvpConfig: PVPConfigType) {
     console.log('exce pvpSeasonEnd' + pvpConfig.seasonNum);
     let resultMaxRank = gameData.pvpRankMax.max;//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入pvp时结算
-    let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum: pvpConfig.seasonNum });
+    let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum: pvpConfig.seasonNum }, false, resultMaxRank.min - 1);
-    let allRank = <RoleRankInfo[]>(await r.getRankByRank(0, resultMaxRank.min - 2));
+    let allRank = <RoleRankInfo[]>(await r.getRankByRange());
-    console.log('******** resultMaxRank', resultMaxRank.max)
+    console.log('******** allRank', 0, resultMaxRank.min - 2, allRank)
     for(let { rank, roleId } of allRank) {
         console.log('******** pvpSeasonEnd: ', rank, roleId);
         let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);

game-server/app/services/rankService.ts

@@ -1,6 +1,6 @@
 import { KeyName, KeyNameParam, RankParam, GuildRankParam, RoleRankInfo, GuildLeader, LineupParam, myIdInter, GeneralRankParam, ValueConfig, GuildRankInfo } 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_TO_KEY } from "../consts";
+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_TO_KEY, COUNTER } from "../consts";
-import { redisClient, setUserInfo } from "./redisService";
+import { redisClient, delKeys } from "./redisService";
 import { RoleType, RoleModel } from "../db/Role";
 import { GuildType, GuildModel } from "../db/Guild";
 import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
@@ -13,6 +13,7 @@ import { pinus } from "pinus";
 import { RankFirstModel, RankFirstType, RankFirstUpdateParam } from "../db/RankFirst";
 import { getRandSingleEelm } from "../pubUtils/util";
 import { RANK_FIRST_REWARD_STATUS } from '../consts';
+import { CounterModel } from "../db/Counter";
 
 
 /**
@@ -709,6 +710,8 @@ export class Rank {
 
         const rankFromDb = await redisClient().zrevrangeAsync(key, start, end, "WITHSCORES");
 
+        console.log(key, start, end, rankFromDb)
+
         let num = 0;
         for (let ii = 0; ii < rankFromDb.length; ii += 2) {
             if (num >= this.limit) break;
@@ -930,9 +933,12 @@ export async function setRankRedisFromDb(type: string, args?: { serverId?: numbe
             await r.setRankWithGuildInfoArrParam(guild.code, [guild.lv, guild.activeWeekly, guild.activeUpdateTime], guild);
         }
     } else if (type == REDIS_KEY.PVP_RANK) {
-        let seasonNum: number = pinus.app.get('pvpSeasonNum');
+        let seasonNum = await CounterModel.getCounter(COUNTER.PVP_SEASON_NUM);
         if(seasonNum > 0) {
+            let keyName = new KeyName(type, { seasonNum })
+            await delKeys(keyName.getName());
             let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
+
             let r = new Rank(type, { seasonNum });
             r.setIsInit(true);
             for (let { roleId, role: _role, score, updatedAt } of ranks) {

game-server/app/services/redisService.ts

@@ -13,13 +13,13 @@ import moment = require('moment');
  * 在服务重新启动时，将信息存入redis
  */
 export async function initAllRank() {
+    console.log('******* initAllRank ******')
     const serverList = await ServerlistModel.getAllServerList();
     await delKeys(REDIS_KEY.ONLINE_USERS);
     await delKeys(REDIS_KEY.USER_INFO);
     await delKeys(REDIS_KEY.GUILD_INFO);
     await delKeys(REDIS_KEY.TOP_LINEUP_INFO);
     await delKeys(REDIS_KEY.HERO_INFO);
-    await delKeys(REDIS_KEY.PVP_RANK);
     await delKeys(REDIS_KEY.TOWER_RANK);
     await delKeys(REDIS_KEY.GUILD_LV_RANK);
     await delKeys(REDIS_KEY.GUILD_ACTIVE_RANK);
@@ -34,7 +34,7 @@ export async function initAllRank() {
     await delKeys(REDIS_KEY.MAIN_ELITE_RANK);
     await delKeys(REDIS_KEY.HERO_RANK);
     await delKeys(REDIS_KEY.SHOW_LINEUP);
-    await delKeys(REDIS_KEY.PVP_RANK);
+    // await delKeys(REDIS_KEY.PVP_RANK);
 
     await setRankRedisFromDb(REDIS_KEY.PVP_RANK, {});
 
@@ -99,7 +99,7 @@ export async function delGuildActivityRank(aid: number) {
     }
 }
 
-async function delKeys(key: string) {
+export async function delKeys(key: string) {
     let keys = await redisClient().keysAsync(`${key}*`);
     for(let key of keys) {
         await redisClient().delAsync(key);

game-server/app/services/timeTaskService.ts

@@ -45,6 +45,8 @@ let pvpRefreshInterval = null;
  */
 export async function init() {
 
+    console.log('******* init systimer *******')
+
     // pvp赛季
     await setPvpSeason();
 

shared/db/PvpDefense.ts

@@ -142,8 +142,8 @@ export default class PvpDefense extends BaseModel {
 
     public static async getRank(seasonNum: number, page = 1, limit = 1000) {
         let sortBy = { score: -1, updatedAt: 1 };
-        const ranks: PvpDefenseType[] = await PvpDefenseModel.find({seasonNum}).select('roleId role score updatedAt')
+        const ranks: PvpDefenseType[] = await PvpDefenseModel.find({seasonNum, score: { $gt: 0 }}).select('roleId role score updatedAt')
-        .populate('role', 'roleId roleName head frame spine heads frames spines title lv vLv')
+        .populate('role', 'roleId roleName head frame spine heads frames spines title lv vLv updatedAt')
         .sort(sortBy).limit(limit).skip((page - 1) * limit).lean({ getters: true, virtuals: true });
         return ranks;
     }

shared/domain/battleField/guild.ts

@@ -6,6 +6,7 @@ import { gameData } from "../../pubUtils/data";
 import { EXTERIOR } from "../../pubUtils/dicParam";
 import { HeroType } from "../../db/Hero";
 import { PvpDefenseType } from "../../db/PvpDefense";
+import { PvpHistoryOppType } from "../../db/PvpHistoryOpp";
 
 export class PlayerDetailHero {
     actorId: number;
@@ -99,19 +100,48 @@ export class PlayerDetail {
     
     battle?: PlayerDetailBattle = new PlayerDetailBattle([], 0, 0);
 
-    constructor(detail: PlayerDetail) {
+    constructor(roleId: string, heroes: PlayerDetailHero[], rank: number) {
-        if(detail.roleId) this.roleId = detail.roleId;
+        this.roleId = roleId;
-        if(detail.roleName) this.roleName = detail.roleName;
+        this.heroes = heroes;
-        if(detail.lv) this.lv = detail.lv;
+        this.rank = rank;
-        if(detail.title) this.title = detail.title;
+    }
-        if(detail.head) this.head = detail.head;
+
-        if(detail.frame) this.frame = detail.frame;
+    setRobot(pvpHistoryOpp: PvpHistoryOppType) {
-        if(detail.spine) this.spine = detail.spine;
+        if(pvpHistoryOpp.roleName) this.roleName = pvpHistoryOpp.roleName;
-        if(detail.score) this.score = detail.score;
+        if(pvpHistoryOpp.lv) this.lv = pvpHistoryOpp.lv;
-        if(detail.pLv) this.pLv = detail.pLv;
+        if(pvpHistoryOpp.title) this.title = pvpHistoryOpp.title;
-        if(detail.defCe) this.defCe = detail.defCe;
+        if(pvpHistoryOpp.head) this.head = pvpHistoryOpp.head;
-        if(detail.heroes) this.heroes = detail.heroes;
+        if(pvpHistoryOpp.frame) this.frame = pvpHistoryOpp.frame;
-        if(detail.rank) this.rank = detail.rank;
+        if(pvpHistoryOpp.spine) this.spine = pvpHistoryOpp.spine;
+        if(pvpHistoryOpp.score) this.score = pvpHistoryOpp.score;
+        if(pvpHistoryOpp.pLv) this.pLv = pvpHistoryOpp.pLv;
+        if(pvpHistoryOpp.defCe) this.defCe = pvpHistoryOpp.defCe;
+    }
+
+    setPlayer(role: RoleType, ) {
+        if(role.roleName) this.roleName = role.roleName;
+        if(role.lv) this.lv = role.lv;
+        if(role.title) this.title = role.title;
+        if(role.head) this.head = role.head;
+        if(role.frame) this.frame = role.frame;
+        if(role.spine) this.spine = role.spine;
+    }
+
+    setCe(ce: number) {
+        this.defCe = ce;
+    }
+
+    setPvpDefense(pvpDefense: PvpDefenseType) {
+        if(pvpDefense.score) this.score = pvpDefense.score;
+        if(pvpDefense.defense && pvpDefense.lineupCe) {
+            let defCe = 0;
+            for(let { actorId } of pvpDefense.defense.heroes) {
+                let lineupCe = pvpDefense.lineupCe.find(cur => cur.hid == actorId);
+                if(lineupCe) defCe += lineupCe.ce;
+            }
+            this.defCe = defCe;
+            this.pLv = pvpDefense.defense.pLv;
+        }
     }
 
     setWarStar?(warStar: WarStar[], pvp: number, tower: number) {