名将擂台：更新防守战力

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

@@ -15,6 +15,7 @@ import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS,
 import { getHeroesAttributes } from '../../../services/playerCeService';
 import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
 import { ServerlistModel } from '../../../db/Serverlist';
+import { saveLadderDefCeByData } from '../../../services/redisService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -255,6 +256,7 @@ export class LadderHandler {
         // 返回
         let result = new LadderDataReturn();
         result.setLadderData(ladderData);
+        await saveLadderDefCeByData(roleId, ladderData);
 
         return resResult(STATUS.SUCCESS, pick(result, 'defense'));
     }

game-server/app/services/ladderService.ts

@@ -13,6 +13,7 @@ import { sendMailByContent } from "./mailService";
 import { getHeroesAttributes } from "./playerCeService";
 import { sendMessageToUserWithSuc } from "./pushService";
 import { Rank } from "./rankService";
+import { getLadderDefCe, saveLadderDefCeByData } from "./redisService";
 import { addItems } from "./role/rewardService";
 import { combineItems } from "./role/util";
 import { WarReward } from "./warRewardService";
@@ -122,7 +123,8 @@ async function generateOppPlayer(serverId: number, rank: number, oppPlayers: { r
     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);
+        let defCe = await getLadderDefCe(player.roleId);
+        result.setByRedis(param, defCe);
     } else {
         let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
         result.setByRobot(dicLadderDifficultRatio);
@@ -285,7 +287,8 @@ export async function battleEndWhenChange(ladderMatch: LadderMatchType) {
     // 更新redis
     if(ladderMatch.rank > 0 && ladderMatch.rank < 3001) {
         let r = new Rank(REDIS_KEY.LADDER, { serverId: ladderMatch.serverId });
-        r.setRankWithRoleInfo(ladderMatch.roleId, ladderMatch.rank, 0);
+        await r.setRankWithRoleInfo(ladderMatch.roleId, ladderMatch.rank, 0);
+        await saveLadderDefCeByData(ladderMatch.roleId, ladderMatch);
     }
 
     // 刷新对手

game-server/app/services/playerCeService.ts

@@ -7,7 +7,7 @@ import { EPlace, HeroModel, HeroType, HeroUpdate } from '../db/Hero';
 import { RoleUpdate, RoleType, RoleModel } from '../db/Role';
 import { Rank } from './rankService';
 import { HERO_SYSTEM_TYPE, PUSH_ROUTE, REDIS_KEY } from '../consts';
-import { updateRoleOnlineInfo, updateUserInfo } from './redisService';
+import { saveLadderDefCe, saveLadderDefCeByData, updateRoleOnlineInfo, updateUserInfo } from './redisService';
 import { GuildModel, GuildType } from '../db/Guild';
 import { CalCe } from './role/calCe';
 import { RoleCeModel, RoleCeUpdate } from '../db/RoleCe';
@@ -18,6 +18,7 @@ import { SchoolModel, SchoolType } from '../db/School';
 import { AttributeCal } from '../domain/roleField/attribute';
 import { sendMessageToUserWithSuc } from './pushService';
 import { SkinType } from '../db/Skin';
+import { LadderMatchModel } from '../db/LadderMatch';
 
 interface Param {
     isInitRole?: boolean,
@@ -332,6 +333,7 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
             calCe.setResultHero(hero);
             heroes.push(hero);
             await PvpDefenseModel.updateCe(roleId, hid, ce); // 更新pvp防守阵战力
+            await LadderMatchModel.updateCe(roleId, hid, ce);
             pushHeros.push({ hid, ce, incHeroCe: inc });
             changeHids.push(hid);
         } else {
@@ -343,6 +345,7 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
         if(changeHids.indexOf(hid) == -1) {
             let hero = await HeroModel.updateHeroInfo(roleId, hid, { ce });
             await PvpDefenseModel.updateCe(roleId, hid, ce); // 更新pvp防守阵战力
+            await LadderMatchModel.updateCe(roleId, hid, ce);
             pushHeros.push({ hid, ce: hero.ce, incHeroCe: inc });
             changeHids.push(hid);
         }
@@ -406,7 +409,9 @@ async function updateRank(roleId: string, serverId: number, topLineupCe: number,
     
     // 武将数量
     let r6 = new Rank(REDIS_KEY.HERO_NUM_RANK, { serverId });
-    await r6.setRankWithRoleInfo(roleId, role.heroNum, role.heroNumUpdatedAt, role);    
+    await r6.setRankWithRoleInfo(roleId, role.heroNum, role.heroNumUpdatedAt, role);
+
+    await saveLadderDefCeByData(roleId);
 }
 
 export async function getSumCe(roleId: string) {

game-server/app/services/rankService.ts

@@ -1,6 +1,6 @@
 import { KeyName, KeyNameParam, RankParam, GuildRankParam, RoleRankInfo, LineupParam, myIdInter, GeneralRankParam, ValueConfig, GuildRankInfo, RoleAndGuildRankInfo } from "../domain/rank";
 import { getInfoKeyByRedisKey, ROLE_SELECT, GUILD_SELECT, REDIS_KEY, HERO_SELECT, COMPOSE_FIELD_TYPE, KEY_TO_COMPOSE_FIELD, getRedisKeyByRankType, COUNTER, RANK_TYPE, PUSH_ROUTE } from "../consts";
-import { redisClient, delKeys } from "./redisService";
+import { redisClient, delKeys, saveLadderDefCeByData } from "./redisService";
 import { RoleType, RoleModel } from "../db/Role";
 import { GuildType, GuildModel } from "../db/Guild";
 import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
@@ -1111,6 +1111,7 @@ export async function setRankRedisFromDb(type: string, args?: { serverId?: numbe
         for (let rank of ranks) {
             let role = <RoleType>rank.role;
             await r.setRankWithRoleInfo(rank.roleId, rank.rank, 0, role);
+            await saveLadderDefCeByData(rank.roleId, rank);
         }
     }
 }

game-server/app/services/redisService.ts

@@ -15,6 +15,7 @@ import { ActivityTimeLimitRankModel } from '../db/ActivityTimeLimitRank';
 import { RoleModel, RoleType } from '../db/Role';
 import { GuildType } from '../db/Guild';
 import { ActivityGroupModel } from '../db/ActivityGroup';
+import { LadderMatchModel, LadderMatchType } from '../db/LadderMatch';
 
 /**
  * 在服务重新启动时，将信息存入redis
@@ -521,6 +522,27 @@ export async function hasKey(key: string) {
 
 /**************** 数据库表end */
 
+/**************** 名将擂台防守战力 */
+export async function saveLadderDefCeByData(roleId: string, ladderMatch?: LadderMatchType) {
+    if(!ladderMatch) {
+        ladderMatch = await LadderMatchModel.findByRoleId(roleId);
+        if(!ladderMatch) return;
+    }
+    let heroes = ladderMatch.defense?.heroes||[];
+    let defCe = heroes.reduce((pre, cur) => pre + cur.ce, 0);
+    await saveLadderDefCe(roleId, defCe);
+}
+
+export async function saveLadderDefCe(roleId: string, defCe: number) {
+    await redisClient().hsetAsync(REDIS_KEY.LADDER_DEFCE, `${roleId}`, defCe);
+}
+
+export async function getLadderDefCe(roleId: string) {
+    let defCe = await redisClient().hgetAsync(REDIS_KEY.LADDER_DEFCE, `${roleId}`);
+    return defCe||0;
+}
+
+/**************** 名将擂台防守战力end */
 
 /*************** 将connector服插入redis *******/