🦄 refactor(热更新): 分割状态代码和功能代码

game-server/app.ts

@@ -25,17 +25,17 @@ import * as redlockCacheService from './app/services/redlockCacheService';
 import * as redLockService from './app/services/redLockService';
 // TODO 需要整理。
 import _pinus = require('pinus');
-import { updateTeamStatus } from './app/services/comBattleService';
+import { updateTeamStatus } from './app/services/battle/comBattleService';
 import { resResult, genCode } from './app/pubUtils/util';
 import { errlogger, infologger, loadLogger } from './app/util/logger';
 import { connectThinkingData, getTire } from './app/services/sdkService';
 import { loadSubDb, loadGmDb } from './app/db';
-import { loadActivities } from './app/services/activity/activityRemoteService';
+import { loadActivities } from './app/services/memoryCache/activityData';
 import { checkAndSetApiIsClose } from './app/services/chatService';
 import { initGuildActivityIndexInPinus, resetJoinWoodenHorse } from './app/services/guildActivity/guildActivityService';
 import { setGVGConfig } from './app/services/gvg/gvgService';
 import { isDevelopEnv } from './app/services/utilService';
-import { initTeamToMem } from './app/services/gvg/gvgBattleMemory';
+import { initTeamToMem } from './app/services/gvg/gvgBattleService';
 import { setServerGroup } from './app/services/serverService';
 
 const filePath = (_pinus as any).FILEPATH;

game-server/app/servers/activity/remote/activityRemote.ts

@@ -7,12 +7,12 @@ import { taflush } from '../../../services/sdkService';
 import { ActivityInRemote } from '../../../domain/activityField/activityField';
 import { errlogger } from '../../../util/logger';
 import { ActivityGroupModel } from '../../../db/ActivityGroup';
-import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId, saveGroupToServer, addServerToGroup } from '../../../services/activity/activityRemoteService';
+import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId, saveGroupToServer, addServerToGroup } from '../../../services/memoryCache/activityData';
 import { saveActivityMemory } from '../../../services/log/memoryLogService';
 import { setApiIsClose } from '../../../services/chatService';
-import { setHiddenData } from '../../../services/dataService';
 import { setKvToMemory } from '../../../services/pushService';
 import { sendPublicAccountGift } from '../../../services/activity/bindPhoneService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

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

@@ -15,7 +15,7 @@ import { RoleStatus, ComBattleTeamModel, ComBattleTeamType, BossHp, ComRoleStatu
 import { ItemModel, ItemType } from '../../../db/Item';
 import { addItems, handleCost } from '../../../services/role/rewardService';
 import { checkRoleInQueue, getServerName, rmCreatedTeamFromRedis, rmRoleFromQueue, setTeamSearchReq } from '../../../services/redisService';
-import { getRandBlueprtId, clearComBtlTimer, getFrd, updateRobotHurtByTime, comBtlLvInvalid, clearRobotHurtTimer, setDismissTimer, dismissTeam, handleComBtlProgress, getComBattleFriendAdd, teammateInBlackList, blueprtIdValid, hasEnoughBlueprt, addRoleToTeam, addRoleStToTeam, addValidSearchingRoles, validToJoin, addRobotsToTeam, addRobotsLater, teamIsFullToStart, oneTeamNotInBlack, getAllAssistCnt, checkHasMyTeam, checkTeamStatusAndSend, getComBtlLvByPlayerLv, addToSearchingTeams, getCapFrd, getCapExtraCnt } from '../../../services/comBattleService';
+import { getRandBlueprtId,  getFrd, updateRobotHurtByTime, comBtlLvInvalid, clearRobotHurtTimer, setDismissTimer, dismissTeam, handleComBtlProgress, getComBattleFriendAdd, teammateInBlackList, blueprtIdValid, hasEnoughBlueprt, addRoleToTeam, addRoleStToTeam, addValidSearchingRoles, validToJoin, addRobotsToTeam, addRobotsLater, teamIsFullToStart, oneTeamNotInBlack, getAllAssistCnt, checkHasMyTeam, checkTeamStatusAndSend, getComBtlLvByPlayerLv, addToSearchingTeams, getCapFrd, getCapExtraCnt, startTeam } from '../../../services/battle/comBattleService';
 import { setAp } from '../../../services/actionPointService';
 import { roleLevelup } from '../../../services/normalBattleService';
 import { getSimpleRoleInfo } from '../../../services/roleService';
@@ -30,19 +30,14 @@ import { addUserToTeamChannel, delTeamChannel, removeFromTeamChannel, sendMessag
 import { getFriendRelationType, getRecommendType } from '../../../services/friendService';
 import { FriendRelationModel } from '../../../db/FriendRelation';
 import { isHeroHidden } from '../../../services/dataService';
+import { addComTeam, clearComBtlTimer,deleteComBattle,getComTeamByCode } from '../../../services/memoryCache/comBattleData';
 
 export default function(app: Application) {
     return new ComBattleHandler(app);
 }
 export class ComBattleHandler {
     constructor(private app: Application) {
-        this.app.set('teamMap', this.teamMap);
-        this.app.set('teamDisTimer', this.teamDisTimer);
-        this.app.set('robotHurtTimer', this.robotHurtTimer);
     }
-    private teamMap: Map<string, MemComBtlTeam> = new Map();
-    private teamDisTimer: Map<string, NodeJS.Timer> = new Map();
-    private robotHurtTimer: Map<string, NodeJS.Timer> = new Map();
 
     /**
      * @description 队长创建队伍
@@ -85,13 +80,13 @@ export class ComBattleHandler {
             delTeamChannel(teamCode);
             return resResult(STATUS.COM_BATTLE_CREATE_ERR);
         }
-        this.teamMap.set(teamCode, comTeam);
+        addComTeam(teamCode, comTeam)
 
         // 倒计时一定时间给队长匹配机器人
         if (pub === true) {
-            await addRobotsLater(comTeam, roleInfo, this.teamMap, this.teamDisTimer);
+            await addRobotsLater(comTeam, roleInfo);
         }
-        setDismissTimer(comTeam, this.teamMap, roleId, this.teamDisTimer);
+        setDismissTimer(comTeam, roleId);
         return resResult(STATUS.SUCCESS, { teamCode, roleStatus: comTeam.roleStatus });
     }
 
@@ -146,10 +141,10 @@ export class ComBattleHandler {
             addUserToTeamChannel(teamCode, true, roleId, sid);
 
             // 创建并添加机器人
-            await addRobotsToTeam(comTeam, roleId, topLineupCe, playerLv, thiz.teamMap, thiz.teamDisTimer, 2);
+            await addRobotsToTeam(comTeam, roleId, topLineupCe, playerLv, 2);
 
             await ComBattleTeamModel.createTeam(comTeam);
-            thiz.teamMap.set(teamCode, comTeam);
+            addComTeam(teamCode, comTeam);
             // 机器人队伍 3 秒直接开战
             setTimeout(async () => {
                 thiz.startBattle({teamCode}, session);
@@ -183,7 +178,7 @@ export class ComBattleHandler {
         let roleId = session.get('roleId');
         let sid = session.get('sid');
         let { teamCode, isFrd } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
         if(teamStatus.status !== COM_TEAM_STATUS.DEFAULT) return resResult(STATUS.COM_BATTLE_TEAM_NOT_DEFAULT);
         if (teamIsFullToStart(teamStatus)) return resResult(STATUS.COM_BATTLE_MEMBER_LIMIT);
@@ -214,7 +209,7 @@ export class ComBattleHandler {
         addUserToTeamChannel(teamCode, false, roleId, sid);
         sendMessageToTeam(teamCode, PUSH_ROUTE.TEAM_JOIN, { teamInfo: teamStatus });
 
-        setDismissTimer(teamStatus, this.teamMap, roleId, this.teamDisTimer);
+        setDismissTimer(teamStatus, roleId);
         return resResult(STATUS.SUCCESS, { teamInfo: teamStatus});
     }
 
@@ -229,7 +224,7 @@ export class ComBattleHandler {
         let roleId = session.get('roleId');
         let { isFrd, teamCode } = msg;
         const isFrdPre = isFrd;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus || teamStatus.status !== COM_TEAM_STATUS.DEFAULT) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
         if (teamStatus.capId === roleId) return resResult(STATUS.COM_BATTLE_SET_FRD_ERR);
         if (!isFrd) {
@@ -305,7 +300,7 @@ export class ComBattleHandler {
         let { teamCode, heroes: hids, battleCode = 'default' } = msg;
         if (!hids || hids.length === 0) return resResult(STATUS.COM_BATTLE_HEROES_ERR);
         if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
 
         const heroDBs = await HeroModel.findByHidRange(hids, roleId);
@@ -337,7 +332,7 @@ export class ComBattleHandler {
     async rmTeammate(msg: {teamCode: string, roleIdToRm: string}, session: BackendSession) {
         let roleId = session.get('roleId');
         let { teamCode, roleIdToRm } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
         if (roleId === teamStatus.capId && roleId === roleIdToRm) return resResult(STATUS.COM_BATTLE_RM_SELF); // 队长移除自己视为解散，提示确认
         if (roleId !== teamStatus.capId && roleId !== roleIdToRm) return resResult(STATUS.COM_BATTLE_CAN_NOT_RM);
@@ -360,10 +355,10 @@ export class ComBattleHandler {
         // 先推送离队消息，再将玩家从房间中移除
         sendMessageToTeam(teamCode, PUSH_ROUTE.LEAVE_TEAM, {teamCode, roleId: roleIdToRm});
         removeFromTeamChannel(teamCode, roleIdToRm);
-        clearComBtlTimer(teamCode, this.teamDisTimer); // 移除队员停止解散计时
+        clearComBtlTimer(teamCode); // 移除队员停止解散计时
         let thiz = this;
         setTimeout(async () => {
-            let curTeamStatus = thiz.teamMap.get(teamCode);
+            let curTeamStatus = getComTeamByCode(teamCode);
             if (validToJoin(curTeamStatus)) {
                 let roleSt: RoleStatus;
                 for (let st of curTeamStatus.roleStatus) {
@@ -373,7 +368,7 @@ export class ComBattleHandler {
                 }
                 if (!roleSt) return;
                 let { roleId, topLineupCe, lv } = roleSt;
-                await addRobotsToTeam(curTeamStatus, roleId, topLineupCe, lv, thiz.teamMap, thiz.teamDisTimer, 3 - curTeamStatus.roleIds.length);
+                await addRobotsToTeam(curTeamStatus, roleId, topLineupCe, lv, 3 - curTeamStatus.roleIds.length);
             }
         }, COM_BTL_CONST.ASSIST_TIME);
         return resResult(STATUS.SUCCESS);
@@ -389,9 +384,9 @@ export class ComBattleHandler {
     async dismiss(msg: {teamCode: string}, session: BackendSession) {
         let roleId = session.get('roleId');
         let { teamCode } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if(!teamStatus) return resResult(STATUS.SUCCESS);
-        let result = await dismissTeam(teamStatus, this.teamMap, roleId, this.teamDisTimer);
+        let result = await dismissTeam(teamStatus, roleId);
         return result;
     }
 
@@ -407,35 +402,35 @@ export class ComBattleHandler {
         let roleName = session.get('roleName');
         let sid = session.get('sid');
         let { teamCode } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
         if (teamStatus.capId !== roleId && teamStatus.capId !== 'robot') return resResult(STATUS.COM_BATTLE_CAP_ONLY);
         if (teamStatus.status !== COM_TEAM_STATUS.DEFAULT) return resResult(STATUS.COM_BATTLE_ALREADY_START);
 
-        teamStatus.startTeam();
+        startTeam(teamStatus);
         let team = await ComBattleTeamModel.updateStatusByCode(teamCode, teamStatus.status, teamStatus.startTime, teamStatus.endTime, teamStatus.hasTimeExtraReward);
         if (!team) return resResult(STATUS.COM_BATTLE_START_ERR);
 
         rmCreatedTeamFromRedis(teamCode, teamStatus.lv);
-        clearComBtlTimer(teamCode, this.teamDisTimer); // 战斗开始停止解散计时
+        clearComBtlTimer(teamCode); // 战斗开始停止解散计时
         await getComBattleFriendAdd(teamStatus.roleStatus);
         sendMessageToTeam(teamCode, PUSH_ROUTE.COMBATTLE_START, {teamCode, roleStatus: teamStatus.roleStatus});
         // 每场倒计时结算
         let thiz = this;
         setTimeout(async () => {
-            let teamStatus = thiz.teamMap.get(teamCode);
+            let teamStatus = getComTeamByCode(teamCode);
             if (teamStatus && teamStatus.status === COM_TEAM_STATUS.FIGHTING) {
-                clearRobotHurtTimer(teamStatus, this.robotHurtTimer);
+                clearRobotHurtTimer(teamStatus);
                 let team = await ComBattleTeamModel.syncTeamData({teamCode, status: COM_TEAM_STATUS.LOOSE, roleStatus: teamStatus.roleStatus, bossHpArr: teamStatus.bossHpArr}, true);
                 if (!team) return resResult(STATUS.COM_BATTLE_RESULT_ERR);
                 teamStatus.timeout = true;
                 sendMessageToTeam(teamCode, PUSH_ROUTE.TEAM_COMPLETE, {teamCode, result: false, timeout: true});
-                thiz.teamMap.delete(teamCode);
+                deleteComBattle(teamCode);
             }
         }, COM_BTL_CONST.BTL_TIME_LMT);
         teamStatus.roleStatus.forEach((st, idx) => {
             if (st.isRobot === true) {
-                updateRobotHurtByTime(teamStatus, st, COM_BTL_CONST.ROBOT_BASE_TIME_INTERVAL + idx, this.robotHurtTimer, this.teamMap);
+                updateRobotHurtByTime(teamStatus, st, COM_BTL_CONST.ROBOT_BASE_TIME_INTERVAL + idx);
             }
         });
         await checkTaskInComBattleStart(teamStatus.roleStatus, teamStatus.capId, teamStatus.blueprtId);
@@ -453,7 +448,7 @@ export class ComBattleHandler {
         let roleId = session.get('roleId');
         let sid = session.get('sid');
         let { teamCode, killed, bossHurts, curRnd } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) {
             checkTeamStatusAndSend(teamCode, roleId, sid);
             return resResult(STATUS.SUCCESS);
@@ -502,7 +497,7 @@ export class ComBattleHandler {
         // 推送本次行动情况
         const roleStatus = teamStatus.roleStatus.map(st => {return {roleId: st.roleId, totalDmg: st.totalDmg, killed: st.killed}});
         sendMessageToTeam(teamCode, PUSH_ROUTE.TEAMMATE_ACT, { teamCode, bossCurHp: teamStatus.bossCurHp, bossHpArr: teamStatus.bossHpArr, roleStatus, actRoleId: roleId, actBossHurts });
-        const result = await handleComBtlProgress(teamStatus, this.robotHurtTimer, this.teamMap);
+        const result = await handleComBtlProgress(teamStatus);
         if (result && result.code !== 0) return result;
         return resResult(STATUS.SUCCESS);
     }
@@ -550,7 +545,7 @@ export class ComBattleHandler {
         
         let { teamCode } = msg;
         let team = await ComBattleTeamModel.getTeamByCode(teamCode);
-        clearRobotHurtTimer(team, this.robotHurtTimer);
+        clearRobotHurtTimer(team);
         if (!team || team.status !== COM_TEAM_STATUS.WIN) return resResult(STATUS.COM_BATTLE_REWARD_ERR);
         let { roleStatus, blueprtId, status, bossHpArr } = team;
         let roleSt = roleStatus.find(st => st && st.roleId === roleId);
@@ -567,7 +562,7 @@ export class ComBattleHandler {
         let sid = session.get('sid');
         
         let { teamCode } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) {
             checkTeamStatusAndSend(teamCode, roleId, sid);
             return resResult(STATUS.SUCCESS);
@@ -576,13 +571,13 @@ export class ComBattleHandler {
             return resResult(STATUS.COM_BATTLE_RETREAT_ERR)
         }
 
-        clearRobotHurtTimer(teamStatus, this.robotHurtTimer);
+        clearRobotHurtTimer(teamStatus);
 
         let team = await ComBattleTeamModel.syncTeamData({ teamCode, status: COM_TEAM_STATUS.LOOSE, roleStatus: teamStatus.roleStatus, bossHpArr: teamStatus.bossHpArr, endTime: Date.now() }, false, true);
         if (!team) return resResult(STATUS.COM_BATTLE_RESULT_ERR);
         sendMessageToTeam(teamCode, PUSH_ROUTE.TEAM_COMPLETE, { teamCode, result: false });
 
-        this.teamMap.delete(teamCode);
+        deleteComBattle(teamCode);
 
         return resResult(STATUS.SUCCESS, { teamInfo: pick(team, ['status', 'teamCode', 'roleStatus', 'bossHpArr']) });
     }
@@ -590,7 +585,7 @@ export class ComBattleHandler {
     async getComBtlStatus(msg: {teamCode: string}, session: BackendSession) {
         let { teamCode } = msg;
         let roleStatus: RoleStatus[], status: number, bossHpArr: BossHp[], timeout: boolean, endTime = 0;
-        let memTeam = this.teamMap.get(teamCode);
+        let memTeam = getComTeamByCode(teamCode);
         if (memTeam) {
             ({ roleStatus, status, bossHpArr, timeout, endTime } = memTeam);
         } else {
@@ -693,7 +688,7 @@ export class ComBattleHandler {
         if (!guildCode) return resResult(STATUS.COM_BATTLE_INVITE_GUILD_ERR);
 
         const { teamCode } = msg;
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if(!teamStatus) return resResult(STATUS.WRONG_PARMS);
         await pushTeamInviteMsg(roleId, roleName, guildCode, teamCode, teamStatus.blueprtId, teamStatus.lv, teamStatus.ceLimit);
         await ComBattleTeamModel.invite(teamCode, guildCode);
@@ -712,7 +707,7 @@ export class ComBattleHandler {
         let guildCode = session.get('guildCode');
         const { teamCode, targetRoleId } = msg;
         
-        let teamStatus = this.teamMap.get(teamCode);
+        let teamStatus = getComTeamByCode(teamCode);
         if(!teamStatus) return resResult(STATUS.WRONG_PARMS);
 
         let role = await RoleModel.findByRoleId(targetRoleId, 'lv');

game-server/app/servers/battle/remote/battleRemote.ts

@@ -2,7 +2,6 @@ import { Application, ChannelService, HandlerService, } from 'pinus';
 import { PVPConfigModel, PVPConfigType } from '../../../db/PvpConfig';
 import { reloadResources } from '../../../pubUtils/data';
 import { setApiIsClose } from '../../../services/chatService';
-import { setHiddenData } from '../../../services/dataService';
 import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 import { setServerGroup } from '../../../services/serverService';
 import { savePvpSeasonMemory } from '../../../services/log/memoryLogService';
@@ -11,6 +10,7 @@ import { getPvpTime } from '../../../services/pvpService';
 import { taflush } from '../../../services/sdkService';
 import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
 import { errlogger } from '../../../util/logger';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/battle/remote/comBattleRemote.ts

@@ -1,7 +1,7 @@
 import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, pinus, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
 import { STATUS } from '../../../consts';
-import { handleComBtlProgress, _addToSearchingTeams } from '../../../services/comBattleService';
+import { handleComBtlProgress, _addToSearchingTeams } from '../../../services/battle/comBattleService';
 import { MemComBtlTeam } from '../../../domain/battleField/ComBattleTeamField';
 import { errlogger } from '../../../util/logger';
 import { saveComBattleMemory } from '../../../services/log/memoryLogService';

game-server/app/servers/chat/remote/chatRemote.ts

@@ -5,8 +5,8 @@ import { getServerMainten, setServerMainten, stopServerMainten } from '../../../
 import { errlogger } from '../../../util/logger';
 import { addUserToChannel, sendMessageToChannel, sendMessgeToChannelByBatch, setKvToMemory } from '../../../services/pushService';
 import { setApiIsClose } from '../../../services/chatService';
-import { setHiddenData } from '../../../services/dataService';
 import { setServerGroup } from '../../../services/serverService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/connector/handler/entryHandler.ts

@@ -23,9 +23,9 @@ import { saveLoginAndOutLog } from '../../../pubUtils/logUtil';
 import { sendMessageToAllWithSuc, sendMessageToUserWithSuc } from '../../../services/pushService';
 import { checkServerIsOpen, getIpLocation } from '../../../services/roleService';
 import { leaveRaceActivityToRemote } from '../../../services/guildActivity/guildActivityService';
-import { getHiddenData } from '../../../services/dataService';
 import { leaveCity } from '../../../services/gvg/gvgBattleService';
 import { autoCreateServerWhenRoleInit } from '../../../services/serverService';
+import { getHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/connector/remote/connectorRemote.ts

@@ -11,9 +11,9 @@ import { setWeek } from '../../../pubUtils/timeUtil';
 import { savePvpSeasonMemory } from '../../../services/log/memoryLogService';
 import { setApiIsClose } from '../../../services/chatService';
 import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
-import { setHiddenData } from '../../../services/dataService';
 import { setKvToMemory } from '../../../services/pushService';
 import { setServerGroup } from '../../../services/serverService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/gm/remote/gmRemote.ts

@@ -1,7 +1,7 @@
 import { Application, ChannelService, HandlerService, } from 'pinus';
-import { setHiddenData } from '../../../services/dataService';
 import { setServerGroup } from '../../../services/serverService';
 import { errlogger } from '../../../util/logger';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/guild/handler/cityActivityHandler.ts

@@ -1,7 +1,7 @@
 import { Application, ChannelService, BackendSession, pinus, HandlerService, } from "pinus";
 import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../../consts";
 import { genCode, resResult } from "../../../pubUtils/util";
-import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex, sendCityGuildRankToUser } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex, sendCityGuildRankToUser } from "../../../services/guildActivity/guildActivityService";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { gameData } from "../../../pubUtils/data";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -21,6 +21,7 @@ import { GuildActivityCityDeclareModel } from "../../../db/GuildActivityCityDecl
 import { GuildModel } from "../../../db/Guild";
 import { getHistoryCity, redisClient, setHistoryCity } from "../../../services/redisService";
 import { HeroModel } from "../../../db/Hero";
+import { getCityActivityObj } from "../../../services/memoryCache/guildActivityData";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -48,7 +49,7 @@ export class CityActivityHandler {
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
         
         let obj = getCityActivityObj();
-        if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) {
+        if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
             await autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
         }
         const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);

game-server/app/servers/guild/handler/gateActivityHandler.ts

@@ -1,5 +1,5 @@
 import { Application, BackendSession, ChannelService, pinus, HandlerService, } from "pinus";
-import { getGuildActivityStatus, getRecordScore, getGateActivityObj, participants, getGateActivityRank, getCityActivityObj, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getRecordScore, participants, getGateActivityRank, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
 import { resResult } from "../../../pubUtils/util";
 import { STATUS, GUILD_ACTIVITY_TYPE, GUILD_POINT_WAYS, ENEMIES_TYPE, GET_POINT_WAYS, TASK_TYPE, GUILD_ACTIVITY_STATUS } from "../../../consts";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -15,6 +15,7 @@ import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
 import { checkTask } from "../../../services/task/taskService";
 import { guildInter } from "../../../pubUtils/interface";
 import { ServerRecordModel } from "../../../db/ServerRecords";
+import { getGateActivityObj } from "../../../services/memoryCache/guildActivityData";
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/guild/handler/gvgBattleHandler.ts

@@ -8,7 +8,7 @@ import { resResult, genCode, getRandSingleEelm } from "../../../pubUtils/util";
 import { GVGLeagueModel } from '../../../db/GVGLeague';
 import { getGroupKey, getGVGConfig, getGVGPeriodData, getGVGServerType } from '../../../services/gvg/gvgService';
 import { redisAddBattleScore, battleEndSendMessage, calBattleScoreByCe, checkAreaIsInCity, checkGVGBattleStart, checkMoveStatus, getBattleRanksByCity, getBirthAreaOfCity, getGVGWarId, getOppHeroes, getTechKnifeHurt, getTechReviveMinus, initRobots, pushTeamMoveMessage, getAllGVGCitiesInfo, leaveCity, refreshTeams, checkEnterCityTime, generNewLineup, getBattleRank, checkSettleStatus, getSpineCnt } from '../../../services/gvg/gvgBattleService';
-import { getGVGBattleData } from '../../../services/gvg/gvgBattleMemory';
+import { getGVGBattleData } from '../../../services/memoryCache/gvgBattleData';
 import { GVGBattleRecModel } from '../../../db/GVGBattleRec';
 import { getFightTimeByPeriod } from '../../../services/gvg/gvgFightService';
 import { gameData, getReviveGold } from '../../../pubUtils/data';

game-server/app/servers/guild/handler/raceActivityHandler.ts

@@ -1,7 +1,7 @@
 import { Application, ChannelService, BackendSession, HandlerService, pinus, } from "pinus";
 import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, REDIS_KEY, TASK_TYPE, PUSH_ROUTE, DEBUG_MAGIC_WORD } from "../../../consts";
 import { genCode, resResult } from "../../../pubUtils/util";
-import { getGuildActivityStatus, getRaceActivityObj, getWoodenHorseList, getGAIndexInPinus, getJoinIndex, leaveRaceActivity } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getWoodenHorseList, getGAIndexInPinus, getJoinIndex, leaveRaceActivity } from "../../../services/guildActivity/guildActivityService";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -11,9 +11,9 @@ import { ServerRecordModel } from "../../../db/ServerRecords";
 import { sendMessageToGuildWithSuc } from "../../../services/pushService";
 import { RaceActivityRankParam } from "../../../domain/battleField/guildActivity";
 import { GuildRankInfo } from "../../../domain/rank";
-import { ServerlistModel } from "../../../db/Serverlist";
 import { dispatch } from "../../../pubUtils/dispatcher";
 import { redisClient } from "../../../services/redisService";
+import { getRaceActivityObj } from "../../../services/memoryCache/guildActivityData";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -50,7 +50,7 @@ export class RaceActivityHandler {
         let ranks: { myGuildRank?: RaceActivityRankParam, guildRank?: RaceActivityRankParam[] } = {};
         let hasJoin = await obj.updateMemberSid(guildCode, serverId, roleId, sid);
 
-        if(obj.status == GUILD_ACTIVITY_STATUS.START) {
+        if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
             ranks = await obj.getRanks(serverId, guildCode);
         } else {
             let index = getGAIndexInPinus(this.aid);
@@ -219,7 +219,7 @@ export class RaceActivityHandler {
         let obj = getRaceActivityObj();
         let myGuildRank = 0;
         let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
-        if(obj.status == GUILD_ACTIVITY_STATUS.START) {
+        if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
             let { myGuildRank: rank, guildRank } = await obj.getRanks(serverId, guildCode);
             // console.log('#', JSON.stringify(guildRank))
             myGuildRank = rank?.rank||0;
@@ -259,6 +259,7 @@ export class RaceActivityHandler {
         if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
         if(statusResult.status != GUILD_ACTIVITY_STATUS.START) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
 
+        
         let guild = pinus.app.getServersByType('guild');
         let sid = await dispatch(redisClient(), `${serverId}`, guild, 'guild');
         pinus.app.rpc.guild.guildActivityRemote.debugAddHorse.toServer(sid.id, serverId, guildCode, memberCnt, itemInterval)

game-server/app/servers/guild/remote/guildActivityRemote.ts

@@ -1,11 +1,12 @@
 import { Application, ChannelService, HandlerService, } from 'pinus';
-import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, clearActivityObj, setGuildActivityIndexInPinus, guildActivityStart, debugSendGateHp, debugAddHorse, leaveRaceActivity, leaveRaceWhenQuitGuild, leaveRaceWhenDismiss } from '../../../services/guildActivity/guildActivityService';
+import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, setGuildActivityIndexInPinus, guildActivityStart, debugSendGateHp, debugAddHorse, leaveRaceActivity, leaveRaceWhenQuitGuild, leaveRaceWhenDismiss } from '../../../services/guildActivity/guildActivityService';
 import { gameData } from '../../../pubUtils/data';
 import { setWeek } from '../../../pubUtils/timeUtil';
 import { sendUngotDividend } from '../../../services/auctionService';
 import { errlogger } from '../../../util/logger';
 import { GUILD_ACTIVITY_TYPE } from '../../../consts';
 import { saveGuildActivityIndexMemory } from '../../../services/log/memoryLogService';
+import { clearActivityObj } from '../../../services/memoryCache/guildActivityData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/guild/remote/guildRemote.ts

@@ -4,15 +4,15 @@ import { taflush, treatGuildName } from '../../../services/sdkService';
 import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
 import { errlogger } from '../../../util/logger';
 import { setApiIsClose } from '../../../services/chatService';
-import { setHiddenData } from '../../../services/dataService';
 import { setKvToMemory } from '../../../services/pushService';
 import { getGVGConfig, setGVGConfig } from '../../../services/gvg/gvgService';
 import { GVGConfigType } from '../../../db/GVGConfig';
 import { catapultHurt, gvgBattleEnd, gvgBattleSeconds, gvgBattleStart, initCatapult, leaveCityMem } from '../../../services/gvg/gvgBattleService';
-import { clearBattleMemory } from '../../../services/gvg/gvgBattleMemory';
+import { clearBattleMemory } from '../../../services/memoryCache/gvgBattleData';
 import { updateLeagueNameMem, updateTeamRoleInfoMem } from '../../../services/gvg/gvgTeamService';
 import { resetPeriodTime, setPeriodTime } from '../../../services/gvg/gvgFightService';
 import { setServerGroup } from '../../../services/serverService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/order/remote/orderRemote.ts

@@ -5,8 +5,8 @@ import { getServerMainten, setServerMainten, stopServerMainten } from '../../../
 import { taflush } from '../../../services/sdkService';
 import { errlogger } from '../../../util/logger';
 import { setApiIsClose } from '../../../services/chatService';
-import { setHiddenData } from '../../../services/dataService';
 import { setKvToMemory } from '../../../services/pushService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/role/remote/roleRemote.ts

@@ -8,8 +8,8 @@ import { getServerMainten, setServerMainten, stopServerMainten } from '../../../
 import { errlogger } from '../../../util/logger';
 import { setApiIsClose } from '../../../services/chatService';
 import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
-import { setHiddenData } from '../../../services/dataService';
 import { setKvToMemory } from '../../../services/pushService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/systimer/remote/systimerRemote.ts

@@ -17,9 +17,9 @@ import { ServerMailType } from '../../../db/ServerMail';
 import { ActivityModelType } from '../../../db/Activity';
 import { GUILD_ACTIVITY_TYPE, LADDER_STATUS } from '../../../consts';
 import { setApiIsClose } from '../../../services/chatService';
-import { setHiddenData } from '../../../services/dataService';
 import { setKvToMemory } from '../../../services/pushService';
 import { setServerGroup } from '../../../services/serverService';
+import { setHiddenData } from '../../../services/memoryCache/hiddenData';
 
 export default function (app: Application) {
     return new SystimerRemote(app);

game-server/app/services/activity/activityService.ts

@@ -38,7 +38,7 @@ import { UserOrderModelType } from '../../db/UserOrder';
 import { isArray } from 'underscore';
 import { getGuideGachaData } from './gachaService';
 import { getPopNoticeData } from './popNoticeService';
-import { _getActivities, _getActivitiesByServerId, _getActivitiesByType, _getActivityById } from './activityRemoteService';
+import { _getActivities, _getActivitiesByServerId, _getActivitiesByType, _getActivityById } from '../memoryCache/activityData';
 import { getGroupShopDataShow } from './groupShopService';
 import { getAllSnsLinkDataShow } from './bindPhoneService';
 import { getPlayerForgeDataShow } from './forgeService';

game-server/app/services/battle/comBattleService.ts

@@ -1,27 +1,27 @@
-import { MemComBtlTeam } from './../domain/battleField/ComBattleTeamField';
-import { ItemModel } from './../db/Item';
-import { BATTLE_REWARD_TYPE, ITEM_CHANGE_REASON, IT_TYPE, PUSH_ROUTE } from './../consts';
-import { FriendRelationModel } from './../db/FriendRelation';
-import { RoleModel, RoleType } from './../db/Role';
-import { EquipPrintDropType, EquipPrintDropModel } from './../db/EquipPrintDrop';
-import { STATUS } from './../consts/statusCode';
-import { COM_TEAM_STATUS, FRIEND_DROP_TYPE, COM_BTL_CONST, FRIEND_DROP_MAX } from './../consts';
-import { RoleStatus, ComBattleTeamModel, ComBattleTeamType, ComBattleReward } from './../db/ComBattleTeam';
-import { getRandEelm, getRandValue, resResult, ratioReward, getRandValueByMinMax, getRandEelmWithWeight, getRobotInfo, getRandSingleEelm } from "../pubUtils/util";
-import { getRandRobot } from "./battleService";
+import { MemComBtlTeam } from '../../domain/battleField/ComBattleTeamField';
+import { ItemModel } from '../../db/Item';
+import { BATTLE_REWARD_TYPE, ITEM_CHANGE_REASON, IT_TYPE, PUSH_ROUTE } from '../../consts';
+import { FriendRelationModel } from '../../db/FriendRelation';
+import { RoleModel, RoleType } from '../../db/Role';
+import { STATUS } from '../../consts/statusCode';
+import { COM_TEAM_STATUS, FRIEND_DROP_TYPE, COM_BTL_CONST, FRIEND_DROP_MAX } from '../../consts';
+import { RoleStatus, ComBattleTeamModel, ComBattleTeamType, ComBattleReward } from '../../db/ComBattleTeam';
+import { getRandEelm, getRandValue, resResult, ratioReward, getRandValueByMinMax, getRandEelmWithWeight, getRobotInfo, getRandSingleEelm } from "../../pubUtils/util";
+import { getRandRobot } from "../battleService";
 import { Channel, ChannelService, pinus } from 'pinus';
-import { TREASURE, EXTERIOR, FRIEND } from '../pubUtils/dicParam';
-import { getFriendLvAdd } from './friendService';
-import { getRoleIds } from '../pubUtils/friendUtil';
-import { getComTeamSidByCode, getCreatedTeamByLv, getTeamSearchByLv, rmCreatedTeamFromRedis, rmRoleFromQueue, setCreatedTeamToRedis } from './redisService';
-import { getRewardByBlueprtId, gameData, getBossHpByBlueprtId, getDicBlueprtById } from '../pubUtils/data';
-import { getZeroPointD, nowSeconds } from '../pubUtils/timeUtil';
-import { addItems, getFriendPointObject, handleCost } from './role/rewardService';
-import { addUserToTeamChannel, delTeamChannel, sendMessageToTeam, sendMessageToUsersWithSuc, sendMessageToUserWithSuc } from './pushService';
-import { checkTaskInComBattleEnd } from './task/taskService';
-import moment = require('moment');
-import { RewardInter } from '../pubUtils/interface';
-import { FriendPointModel } from '../db/FriendPoint';
+import { TREASURE, EXTERIOR, FRIEND } from '../../pubUtils/dicParam';
+import { getFriendLvAdd } from '../friendService';
+import { getRoleIds } from '../../pubUtils/friendUtil';
+import { getComTeamSidByCode, getCreatedTeamByLv, getTeamSearchByLv, rmCreatedTeamFromRedis, rmRoleFromQueue, setCreatedTeamToRedis } from '../redisService';
+import { getRewardByBlueprtId, gameData, getBossHpByBlueprtId, getDicBlueprtById } from '../../pubUtils/data';
+import { getZeroPointD, nowSeconds } from '../../pubUtils/timeUtil';
+import { addItems, getFriendPointObject, handleCost } from '../role/rewardService';
+import { addUserToTeamChannel, delTeamChannel, sendMessageToTeam, sendMessageToUsersWithSuc, sendMessageToUserWithSuc } from '../pushService';
+import { checkTaskInComBattleEnd } from '../task/taskService';
+import { RewardInter } from '../../pubUtils/interface';
+import { FriendPointModel } from '../../db/FriendPoint';
+import { isComBattleTimeLimit } from '../../pubUtils/battleUtils';
+import { clearComBtlTimer, deleteComBattle, getComTeamByCode, getComTeamTimerByCode, getRobotHurtTimer, setComTeamTimer, setRobotHurtTimerIfNotExist } from '../memoryCache/comBattleData';
 
 /**
  * 在给定的品质列表中随机返回一定数量的藏宝图Id
@@ -142,21 +142,6 @@ export function checkComBattleResult(teamStatus) {
 //     return { status: 0, fixReward };
 // }
 
-export function clearComBtlTimer(teamCode: string, timerMap: Map<string, NodeJS.Timer>) {
-    let timer = timerMap.get(teamCode);
-    if (timer) {
-        clearTimeout(timer);
-    }
-}
-
-export function setComBtlTimer(teamCode: string, timer: NodeJS.Timer, timerMap: Map<string, NodeJS.Timer>) {
-    let preTimer = timerMap.get(teamCode);
-    if (preTimer) {
-        clearTimeout(preTimer);
-    }
-    timerMap.set(teamCode, timer);
-}
-
 export async function getRealReward(blueprtId: number, roleSts: RoleStatus[], roleSt: RoleStatus, hasTimeExtraReward: boolean): Promise<ComBattleReward[]> {
     let dicReward = getRewardByBlueprtId(blueprtId);
     if(!dicReward) return [];
@@ -270,7 +255,7 @@ function updateRobotKilled(bossHp: number, roleSt: RoleStatus) {
     }
 }
 
-export async function handleComBtlProgress(teamStatus: MemComBtlTeam, robotHurtTimer: Map<string, NodeJS.Timer>, teamMap: Map<string, MemComBtlTeam>) {
+export async function handleComBtlProgress(teamStatus: MemComBtlTeam) {
     const { teamCode } = teamStatus;
     // 判断战斗是否结束
     let battleSt = checkComBattleResult(teamStatus);
@@ -295,10 +280,10 @@ export async function handleComBtlProgress(teamStatus: MemComBtlTeam, robotHurtT
             if (res === false) return resResult(STATUS.COM_BATTLE_BLUEPRT_NOT_ENOUGH);
         }
 
-        clearRobotHurtTimer(teamStatus, robotHurtTimer);
+        clearRobotHurtTimer(teamStatus);
         sendMessageToTeam(teamCode, PUSH_ROUTE.TEAM_COMPLETE, { teamCode, result });
 
-        teamMap.delete(teamCode);
+        deleteComBattle(teamCode);
     }
 }
 
@@ -342,35 +327,31 @@ export function updateRobotHurt(teamStatus: MemComBtlTeam, roleSt: RoleStatus) {
  * @param {RoleStatus} roleSt
  * @param {number} interval
  * @param {Channel} channel
- * @param {Map<string, NodeJS.Timer>} robotHurtTimer
  */
-export function updateRobotHurtByTime(teamStatus: MemComBtlTeam, roleSt: RoleStatus, interval: number, robotHurtTimer: Map<string, NodeJS.Timer>, teamMap: Map<string, MemComBtlTeam>) {
-    const timerKey = `${teamStatus.teamCode}_${roleSt.roleId}`;
+export function updateRobotHurtByTime(teamStatus: MemComBtlTeam, roleSt: RoleStatus, interval: number) {
     const robotTimer = setInterval(() => {
         const robotTotalHurt = teamStatus.bossHp * COM_BTL_CONST.ROBOT_HURT_RATIO;
-        if (roleSt.totalDmg < robotTotalHurt && teamStatus.bossCurHp > 0 && teamMap.has(teamStatus.teamCode)) {
+        let team = getComTeamByCode(teamStatus.teamCode);
+        if (roleSt.totalDmg < robotTotalHurt && teamStatus.bossCurHp > 0 && team) {
             updateRobotHurt(teamStatus, roleSt);
-            handleComBtlProgress(teamStatus, robotHurtTimer, teamMap);
+            handleComBtlProgress(teamStatus);
         } else {
             clearInterval(robotTimer);
         }
     }, interval * 1000);
-    if (!robotHurtTimer.has(timerKey)) {
-        robotHurtTimer.set(timerKey, robotTimer);
-    }
+    setRobotHurtTimerIfNotExist(teamStatus.teamCode, roleSt.roleId, robotTimer);
 }
 
 /**
  * @description 清理机器人伤害的 timer
  * @export
- * @param {*} teamStatus 寻宝队伍状态
- * @param {Map<string, NodeJS.Timer>} robotHurtTimer
+ * @param {MemComBtlTeam} teamStatus 寻宝队伍状态
  */
-export function clearRobotHurtTimer(teamStatus, robotHurtTimer: Map<string, NodeJS.Timer>) {
+export function clearRobotHurtTimer(teamStatus: { teamCode: string, roleStatus: RoleStatus[] }) {
     teamStatus.roleStatus.forEach(st => {
-        const timerKey = `${teamStatus.teamCode}_${st.roleId}`;
-        if (st.isRobot === true && robotHurtTimer.has(timerKey)) {
-            clearInterval(robotHurtTimer.get(timerKey));
+        let robotHurtTimer = getRobotHurtTimer(teamStatus.teamCode, st.roleId);
+        if (st.isRobot === true && robotHurtTimer) {
+            clearInterval(robotHurtTimer);
         }
     });
 }
@@ -402,7 +383,7 @@ export function getComBtlLvByPlayerLv(playerLv: number) {
     return { minLv, maxLv }
 }
 
-export async function dismissTeam(teamStatus: MemComBtlTeam, teamMap: Map<string, MemComBtlTeam>, roleId: string, teamDisTimer: Map<string, NodeJS.Timer>) {
+export async function dismissTeam(teamStatus: MemComBtlTeam, roleId: string) {
     const { teamCode } = teamStatus;
     if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
     if (teamStatus.status !== COM_TEAM_STATUS.DEFAULT) return resResult(STATUS.COM_BATTLE_DISSMISS_ERR);
@@ -411,23 +392,23 @@ export async function dismissTeam(teamStatus: MemComBtlTeam, teamMap: Map<string
     let team = await ComBattleTeamModel.removeTeam(teamCode);
     if (!team) return resResult(STATUS.COM_BATTLE_DISSMISS_ERR);
 
-    let rmSt = teamMap.delete(teamCode);
+    let rmSt = deleteComBattle(teamCode);
     if (!rmSt) return resResult(STATUS.COM_BATTLE_DISSMISS_ERR);
 
     rmCreatedTeamFromRedis(teamCode, teamStatus.lv);
     sendMessageToTeam(teamCode, PUSH_ROUTE.TEAM_DISMISS, { teamCode });
     delTeamChannel(teamCode);
-    clearComBtlTimer(teamCode, teamDisTimer); // 队伍解散停止解散计时
+    clearComBtlTimer(teamCode); // 队伍解散停止解散计时
     return resResult(STATUS.SUCCESS);
 }
 
-export function setDismissTimer(teamStatus: MemComBtlTeam, teamMap: Map<string, MemComBtlTeam>, roleId: string, teamDisTimer: Map<string, NodeJS.Timer>) {
+export function setDismissTimer(teamStatus: MemComBtlTeam, roleId: string) {
     // if (teamIsFullToStart(teamStatus)) {
-        clearComBtlTimer(teamStatus.teamCode, teamDisTimer);
+        clearComBtlTimer(teamStatus.teamCode);
         let timer = setTimeout(async () => {
-            await dismissTeam(teamStatus, teamMap, roleId, teamDisTimer);
+            await dismissTeam(teamStatus, roleId);
         }, COM_BTL_CONST.CAP_START_TIME);
-        teamDisTimer.set(teamStatus.teamCode, timer);
+        setComTeamTimer(teamStatus.teamCode, timer);;
     // }
 }
 
@@ -640,7 +621,7 @@ export function teamIsFullToStart(comTeam: MemComBtlTeam) {
  * @param {number} roleLv 真实玩家等级，用来做机器人等级基准
  * @param {number} [count=1]
  */
-export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, roleCe: number, roleLv: number, teamMap: Map<string, MemComBtlTeam>, teamDisTimer: Map<string, NodeJS.Timer>, count = 1) {
+export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, roleCe: number, roleLv: number, count = 1) {
     const { teamCode, roleStatus } = comTeam;
     let hasCap = roleStatus.findIndex(cur => cur.isCap) != -1;
     const { robotStArr, robotIdArr } = getRandComBtlRobots(roleCe, comTeam.ceLimit, roleLv, count);
@@ -653,7 +634,7 @@ export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, ro
         await ComBattleTeamModel.addRole(teamCode, st);
     }
     sendMessageToTeam(teamCode, PUSH_ROUTE.TEAM_JOIN, { teamInfo: comTeam })
-    setDismissTimer(comTeam, teamMap, roleId, teamDisTimer);
+    setDismissTimer(comTeam, roleId);
 }
 
 /**
@@ -664,7 +645,7 @@ export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, ro
  * @param {Map<string, MemComBtlTeam>} teamMap
  * @param {Map<string, NodeJS.Timer>} teamDisTimer
  */
-export async function addRobotsLater(comTeam: MemComBtlTeam, roleInfo: RoleType, teamMap: Map<string, MemComBtlTeam>, teamDisTimer: Map<string, NodeJS.Timer>) {
+export async function addRobotsLater(comTeam: MemComBtlTeam, roleInfo: RoleType) {
     const teamStatus = comTeam;
     const { teamCode, lv: blueprtLv } = teamStatus;
     const { roleId, lv } = roleInfo;
@@ -677,9 +658,9 @@ export async function addRobotsLater(comTeam: MemComBtlTeam, roleInfo: RoleType,
         for (let robotIdx = 0; robotIdx < robotCnt; robotIdx++) {
             const joinTime = getRandValueByMinMax(COM_BTL_CONST.MIN_CAP_TIME, COM_BTL_CONST.MAX_CAP_TIME, 0);
             setTimeout(async () => {
-                const curTeamStatus = teamMap.get(teamCode);
+                const curTeamStatus = getComTeamByCode(teamCode);
                 if (validToJoin(curTeamStatus)) {
-                    await addRobotsToTeam(curTeamStatus, roleId, topLineupCe, lv, teamMap, teamDisTimer, 1);
+                    await addRobotsToTeam(curTeamStatus, roleId, topLineupCe, lv, 1);
                 }
             }, joinTime);
         }
@@ -718,4 +699,11 @@ export async function checkTeamStatusAndSend(teamCode: string, roleId: string, s
     if(team && (team.status == 2|| team.status == 3)) {
         await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.TEAM_COMPLETE, { teamCode, result: team.status == 2? true: false, timeout: team.timeout }, sid);
     }
+}
+
+export async function startTeam(team: MemComBtlTeam) {
+    team.status = COM_TEAM_STATUS.FIGHTING;
+    team.startTime = nowSeconds();
+    team.endTime = nowSeconds() + COM_BTL_CONST.BTL_TIME_LMT/1000;
+    team.hasTimeExtraReward = isComBattleTimeLimit();
 }

game-server/app/services/chatService.ts

@@ -3,7 +3,6 @@ import { PrivateChatRec } from './../db/ChatInfo';
 import { RoleModel } from './../db/Role';
 import { GroupMessageModel } from './../db/GroupMessage';
 import { CounterModel } from './../db/Counter';
-import { STATUS } from './../consts/statusCode';
 import { PrivateMessageModel, PrivateMessageParam, PrivateMessageType } from './../db/PrivateMessage';
 import { GroupMessageParam, GroupMessageType } from '../db/GroupMessage';
 import { genCode, resResult } from '../pubUtils/util';
@@ -14,8 +13,6 @@ import { ChatInfoModel } from '../db/ChatInfo';
 import { AccuseRecModel, AccueseParam } from '../db/AccuseRec';
 import { getSimpleRoleInfo, getSimpleRoleInfos } from './roleService';
 import { sendMessageToAllWithSuc, sendMessageToCityWithSuc, sendMessageToGuildWithSuc,  sendMessageToServerWithSuc, sendMessageToTeam, sendMessageToUserWithSuc } from './pushService';
-import { comBtlLvInvalid } from './comBattleService';
-import { gameData } from '../pubUtils/data';
 import { RegionModel } from '../db/Region';
 import { getAllGroupOfServer, getGVGGroupIdOfServer, getGVGServersByGroupId } from './serverService';
 import { GVGLeagueModel } from '../db/GVGLeague';

game-server/app/services/connectorService.ts

@@ -15,9 +15,8 @@ import { getFriendList, getApplyList } from './friendService';
 import { getDailyBattleList } from './dailyBattleService';
 import { getExpeditionStatus } from './expeditionService';
 import { getTowerStatus, getHungupRewards, getTasks } from './battleService';
-import { getAllAssistCnt, getCapExtraCnt, getComBtlLvByPlayerLv } from './comBattleService';
+import { getAllAssistCnt, getCapExtraCnt, getComBtlLvByPlayerLv } from './battle/comBattleService';
 import { getDungeonData } from './dungeonService';
-import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
 import { nowSeconds, getZeroPoint } from '../pubUtils/timeUtil';
 import { getGachaList, getVisitedHeroList } from './activity/gachaService';
 import { getSchoolList } from './roleService';
@@ -49,10 +48,10 @@ import { INFO_WINDOW } from '../pubUtils/dicParam';
 import { getLadderData } from './ladderService';
 import { dispatch } from '../pubUtils/dispatcher';
 import { PvpDataReturn } from '../domain/battleField/pvp';
-import { getHiddenData } from './dataService';
 import { ArtifactModel } from '../db/Artifact';
 import { ActivityItemModel } from '../db/ActivityItem';
 import { LinkModel } from '../db/Link';
+import { getHiddenData } from './memoryCache/hiddenData';
 
 /**
  * init: 初始的时候是否推送 true-推 false-不推

game-server/app/services/dataService.ts

@@ -4,12 +4,7 @@ import { ITEM_CHANGE_REASON, PUSH_ROUTE } from '../consts';
 import { HiddenDataModelType } from '../db/HiddenData';
 import { sendMessageToAllServersWithSuc } from './pushService';
 import { itemLogger } from '../util/logger';
-
-export function setHiddenData(heroes: number[], goods: number[], refTime: number) {
-    pinus.app.set('hiddenHeroees', heroes||[]);
-    pinus.app.set('hiddenGoods', goods||[]);
-    pinus.app.set('hiddenRefTime', refTime||0);
-}
+import { getHiddenData, setHiddenData } from './memoryCache/hiddenData';
 
 export async function setHiddenDataToMemory(data: HiddenDataModelType, nextData: HiddenDataModelType) {
     let heroes = data?.heroes??[];
@@ -40,15 +35,6 @@ async function sendUpdateMessage(origin: {heroes: number[], items: number[], ref
     }
 }
 
-export function getHiddenData() {
-    let heroes: number[] = pinus.app.get('hiddenHeroees')||[];
-    let goods: number[] = pinus.app.get('hiddenGoods')||[];
-    let refTime = pinus.app.get('hiddenRefTime')||0;
-    return {
-        refTime, heroes, items: goods
-    }
-}
-
 export function filterHeroes<T>(arr: T[], cb?: (obj: T) => number, roleId?: string) {
     return arr.filter(obj => {
         let hid = cb? cb(obj): (typeof obj == 'number'? obj: 0);

game-server/app/services/guildActivity/cityActivityObj.ts

@@ -1,25 +1,19 @@
 // 军团活动蛮夷入侵城门血量等数据存储
 
 import { GUILD_ACTIVITY_STATUS } from "../../consts";
-import { Member } from "../../domain/battleField/guildActivity";
+import { CityActivityData } from "../../domain/battleField/guildActivity";
 import { getCityActivityGateHp } from "./guildActivityService";
 
 // 军团诸侯混战等数据
 export class CityActivityObject {
-    public guildActivityStatus = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
-    private gateHp: Map<string, number> = new Map(); // 城门血条，每个cityId有一条血条 serverId&cityId => gateHp
-    private maxHp: Map<string, number> = new Map(); // 城门血条，每个cityId最大城门血量 serverId&cityId => gateHp
-    private members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
-    private cities: Map<string, string[]> = new Map(); // 各个城池参与的军团 serverId&cityId => [guildCode]
-    private guilds: Map<string, number> = new Map();  // 军团所在的城池 guildCode => cityId
-    private sentCity: string[] = [];
-    private startTime: number = 0;
+    data: CityActivityData = new CityActivityData();
 
-    private getKey(serverId: number, cityId: number) {
+
+    public getKey(serverId: number, cityId: number) {
         return `${serverId}_${cityId}`;
     }
 
-    private decodeKey(key: string) {
+    public decodeKey(key: string) {
         let arr = key.split('_');
         return {
             serverId: parseInt(arr[0]),
@@ -30,25 +24,29 @@ export class CityActivityObject {
     public getObj( serverId: number, cityId: number, guildCode: string) {
         let key = this.getKey(serverId, cityId);
         return {
-            gateHp: this.gateHp.get(key),
-            maxHp: this.maxHp.get(key),
-            members: this.members.get(guildCode),
-            city: this.cities.get(key),
-            guild: this.guilds.get(guildCode)
+            gateHp: this.data.gateHp.get(key),
+            maxHp: this.data.maxHp.get(key),
+            members: this.data.members.get(guildCode),
+            city: this.data.cities.get(key),
+            guild: this.data.guilds.get(guildCode)
         }
     }
 
     public startActivity() {
-        this.startTime = Date.now();
-        this.guildActivityStatus = GUILD_ACTIVITY_STATUS.START;
+        this.data.startTime = Date.now();
+        this.data.guildActivityStatus = GUILD_ACTIVITY_STATUS.START;
     }
 
     public endActivity() {
-        this.guildActivityStatus = GUILD_ACTIVITY_STATUS.END;
+        this.data.guildActivityStatus = GUILD_ACTIVITY_STATUS.END;
+    }
+
+    public getStatus() {
+        return this.data.guildActivityStatus;
     }
 
     public getTimeGap() {
-        return Math.floor((Date.now() - this.startTime)/1000);
+        return Math.floor((Date.now() - this.data.startTime)/1000);
     }
 
     public lockCity(serverId: number, cityId: number) {
@@ -65,18 +63,18 @@ export class CityActivityObject {
         //     this.guilds.delete(guildCode);
         // }
         // this.cities.delete(key);
-        this.sentCity.push(key);
+        this.data.sentCity.push(key);
     }
 
     public hasSent(serverId: number, cityId: number) {
         let key = this.getKey(serverId, cityId);
-        return this.sentCity.indexOf(key) != -1;
+        return this.data.sentCity.indexOf(key) != -1;
     }
 
     public getAllCities() {
         let allCities = new Array<{ serverId: number, cityId: number, guildCodes: string[]}>();
         let serverlists = new Array<number>();
-        for(let [key, guildCodes] of this.cities) {
+        for(let [key, guildCodes] of this.data.cities) {
             let { serverId, cityId } = this.decodeKey(key);
             if(!this.hasSent(serverId, cityId)) {
                 allCities.push({ serverId, cityId, guildCodes });
@@ -88,53 +86,53 @@ export class CityActivityObject {
 
     public getGuildsInCity(serverId: number, cityId: number) {
         let key = this.getKey(serverId, cityId);
-        return this.cities.get(key)||[];
+        return this.data.cities.get(key)||[];
     }
 
     public getMembersOfGuild(guildCode: string) {
-        return this.members.get(guildCode)||[];
+        return this.data.members.get(guildCode)||[];
     }
 
     public async getGateHpAndInc(serverId: number, cityId: number, inc: number = 0) {
         let key = this.getKey(serverId, cityId);
-        let gateHp = this.gateHp.get(key);
-        if(!this.gateHp.has(key)) {
+        let gateHp = this.data.gateHp.get(key);
+        if(!this.data.gateHp.has(key)) {
             gateHp = await getCityActivityGateHp(serverId, cityId);
-            this.gateHp.set(key, gateHp);
-            this.maxHp.set(key, gateHp);
+            this.data.gateHp.set(key, gateHp);
+            this.data.maxHp.set(key, gateHp);
         }
         if(inc != 0) {
             gateHp += inc;
-            this.gateHp.set(key, gateHp);
+            this.data.gateHp.set(key, gateHp);
         }
         if(gateHp <= 0) gateHp = 0;
-        return { gateHp, maxHp: this.maxHp.get(key)||0 }
+        return { gateHp, maxHp: this.data.maxHp.get(key)||0 }
     }
 
     public pushMembers(guildCode: string, roleId: string, job: number, code: string) {
 
-        if(this.members.has(guildCode)) {
-            let members = this.members.get(guildCode);
+        if(this.data.members.has(guildCode)) {
+            let members = this.data.members.get(guildCode);
             if(members.findIndex(cur => cur.roleId == roleId) == -1) {
                 members.push({ roleId, job, code });
             }
         } else {
             let arr = new Array<string>();
             arr.push(roleId);
-            this.members.set(guildCode, [{ roleId, job, code }]);
+            this.data.members.set(guildCode, [{ roleId, job, code }]);
         }
     }
 
     public pushGuild(guildCode: string, serverId: number, cityId: number) {
         let key = this.getKey(serverId, cityId);
-        if(!this.cities.has(key)) {
-            this.cities.set(key, [guildCode]);
+        if(!this.data.cities.has(key)) {
+            this.data.cities.set(key, [guildCode]);
         } else {
-            let arr = this.cities.get(key);
+            let arr = this.data.cities.get(key);
             if(!arr.includes(guildCode)) {
                 arr.push(guildCode);
             }
         }
-        this.guilds.set(guildCode, cityId);
+        this.data.guilds.set(guildCode, cityId);
     }
 }

game-server/app/services/guildActivity/gateActivityObj.ts

@@ -1,75 +1,72 @@
 
 // 军团活动蛮夷入侵城门血量等数据存储
 
-import { Member, GateMembersRec } from "../../domain/battleField/guildActivity";
+import { Member, GateMembersRec, GateActivityData } from "../../domain/battleField/guildActivity";
 
 export class GateActivityObject {
-    public startTime: number;
-    private members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
-    private membersRecord: Map<string, GateMembersRec> = new Map(); // 每个成员的回合数和敌军数，防刷 recCode => GateMembersRec
-    private guilds: Map<number, string[]> = new Map(); // 参加的所有军团 server => [guildCode]
-    
+    data: GateActivityData = new GateActivityData();
+
     public getObj(guildCode: string, serverId: number) {
         // console.log(guildCode, serverId)
         return {
-            members: this.members.get(guildCode)||[],
-            memberesRecord: [...this.membersRecord],
-            guilds: this.guilds.get(serverId)||[]
+            members: this.data.members.get(guildCode)||[],
+            memberesRecord: [...this.data.membersRecord],
+            guilds: this.data.guilds.get(serverId)||[]
         }
     }
 
     public startActivity() {
-        this.startTime = Date.now();
+        this.data.startTime = Date.now();
     }
     
     public getTimeGap() {
-        return Math.floor((Date.now() - this.startTime)/1000);
+        return Math.floor((Date.now() - this.data.startTime)/1000);
     }
 
     public getGuilds() {
-        return this.guilds;
+        return this.data.guilds;
     }
 
     public pushMembers(guildCode: string, serverId: number, roleId: string, job: number, code: string) {
         let member: Member;
-        if(this.members.has(guildCode)) {
-            let members = this.members.get(guildCode);
+        if(this.data.members.has(guildCode)) {
+            let members = this.data.members.get(guildCode);
             if(members.findIndex(cur => cur.roleId == roleId) == -1) {
                 member = { roleId, job, code }
                 members.push(member);
             }
         } else {
             member = { roleId, job, code }
-            this.members.set(guildCode, [member]);
+            this.data.members.set(guildCode, [member]);
         }
-        if(this.guilds.has(serverId)) {
-            let arr = this.guilds.get(serverId);
+        if(this.data.guilds.has(serverId)) {
+            let arr = this.data.guilds.get(serverId);
             if(!arr.includes(guildCode)) arr.push(guildCode);
-            this.guilds.set(serverId, arr);
+            this.data.guilds.set(serverId, arr);
         } else {
-            this.guilds.set(serverId, [guildCode]);
+            this.data.guilds.set(serverId, [guildCode]);
         }
         return member;
     }
 
     public getMemberRecord(recCode: string, roleId: string) {
-        return this.membersRecord.get(recCode)||new GateMembersRec(roleId)
+        return this.data.membersRecord.get(recCode)||new GateMembersRec(roleId)
     }
 
     public setMemberRecord(recCode: string, newMemberRecord: GateMembersRec) {
-        this.membersRecord.set(recCode, newMemberRecord);
+        this.data.membersRecord.set(recCode, newMemberRecord);
     }
 
     public delMemberRecord(recCode: string) {
-        this.membersRecord.delete(recCode);
+        this.data.membersRecord.delete(recCode);
     }
 
     public delGuildRecord(guildCode: string, serverId: number) {
-        let guildList = this.guilds.get(serverId);
+        let guildList = this.data.guilds.get(serverId);
         if(guildList) {
             let index = guildList.indexOf(guildCode);
             guildList.splice(index, 1);
         }
-        this.members.delete(guildCode);
+        this.data.members.delete(guildCode);
     }
 }

game-server/app/services/guildActivity/guildActivityService.ts

@@ -15,15 +15,11 @@ import { genAuction, getGuildAuctionBasicNum, getGuildAuctionRewards, getRewardT
 import { sendMailByContent } from "../mailService";
 import { GuildActivityCityType, GuildActivityCityModel } from "../../db/GuildActivityCity";
 import { DicCityActivity } from "../../pubUtils/dictionary/DicCityActivity";
-import { CityActivityObject } from "./cityActivityObj";
-import { GateActivityObject } from "./gateActivityObj";
-import { RaceActivityObject } from "./raceActivityObj";
 import { Rank } from "../rankService";
 import { BossInstanceModel } from "../../db/BossInstance";
 import { UserGuildModel } from "../../db/UserGuild";
 import { addActive } from "../guildService";
 import { ActivePlayer, GuildRecord, ServerRecordModel } from "../../db/ServerRecords";
-import { Attack } from "../../domain/battleField/pvp";
 import { getHonourObject } from "../role/rewardService";
 import { sendMessageToCityWithSuc, sendMessageToGuildWithSuc, sendMessageToServerWithSuc, sendMessageToUserWithSuc } from "../pushService";
 import { saveGuildGateHpLog } from "../../pubUtils/logUtil";
@@ -31,39 +27,10 @@ import { GuildActivityCityDeclareModel } from "../../db/GuildActivityCityDeclare
 import { getRandSingleEelm } from "../../pubUtils/util";
 import { CounterModel } from "../../db/Counter";
 import { setInterval } from "timers";
-import { DicRaceActivity } from "../../pubUtils/dictionary/DicRaceActivity";
 import { dispatch } from "../../pubUtils/dispatcher";
 import { GuildModel } from "../../db/Guild";
+import { getCityActivityObj, getGateActivityObj, getRaceActivityObj } from "../memoryCache/guildActivityData";
 
-let gateActivityObj: GateActivityObject;
-let cityActivityObj: CityActivityObject;
-let raceActivityObj: RaceActivityObject;
-export function getGateActivityObj() {
-    if (!gateActivityObj) {
-        gateActivityObj = new GateActivityObject();
-    }
-    return gateActivityObj;
-}
-
-export function getCityActivityObj() {
-    if (!cityActivityObj) {
-        cityActivityObj = new CityActivityObject();
-    }
-    return cityActivityObj;
-}
-
-export function getRaceActivityObj() {
-    if (!raceActivityObj) {
-        raceActivityObj = new RaceActivityObject();
-    }
-    return raceActivityObj;
-}
-
-export function clearActivityObj() {
-    gateActivityObj = undefined;
-    cityActivityObj = undefined;
-    raceActivityObj = undefined;
-}
 
 /**
  * 定时任务，获得前一天的活跃玩家中位数武将战力
@@ -878,14 +845,14 @@ export function getGAIndexInPinus(aid: number) {
 export function getDeclareIndex() {
     let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
     let obj = getCityActivityObj();
-    if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) return index;
+    if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) return index;
     return index + 1;
 }
 
 export function getJoinIndex() {
     let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
     let obj = getRaceActivityObj();
-    if(obj.status == GUILD_ACTIVITY_STATUS.START || obj.status == GUILD_ACTIVITY_STATUS.END) return index;
+    if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START || obj.getStatus() == GUILD_ACTIVITY_STATUS.END) return index;
     return index + 1;
 }
 

game-server/app/services/guildActivity/raceActivityObj.ts

@@ -1,63 +1,30 @@
 
 // 军团活动蛮夷入侵城门血量等数据存储
 
-import { Member, GateMembersRec, WoodenHorse, Event, WoodenHorseMember, RaceActivityRankParam } from "../../domain/battleField/guildActivity";
-import { RewardInter } from "../../pubUtils/interface";
+import {  WoodenHorse, Event, WoodenHorseMember, RaceActivityRankParam, RaceActivityData, MemberInfo, GuildInfo } from "../../domain/battleField/guildActivity";
 import { getRaceEventItems, gameData } from "../../pubUtils/data";
 import { GuildModel } from "../../db/Guild";
 import { sendSingleRaceActEndMsg } from "./guildActivityService";
-import { REDIS_KEY, RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, RACE_EVENT, STATUS, PUSH_ROUTE, GUILD_ACTIVITY_STATUS, DEBUG_MAGIC_WORD } from "../../consts";
-import { getRandEelm, sortArrRandom, resResult, getRandResultByMember } from "../../pubUtils/util";
-import { sendMessageToGuildWithSuc, sendMessageToServerWithSuc, sendMessageToUserWithSuc } from "../pushService";
-
-class MemberInfo extends Member {
-    isQuit: boolean = false;
-
-    constructor(roleId: string, job: number, code: string) {
-        super();
-        this.roleId = roleId;
-        this.job = job;
-        this.code = code;
-    }
-
-    public quit() {
-        this.isQuit = true;
-    }
-}
-
-class GuildInfo {
-    serverId: number;
-    guildCode: string;
-    isDissmiss: boolean = false;
-
-    constructor(serverId: number, guildCode: string) {
-        this.serverId = serverId;
-        this.guildCode = guildCode;
-    }
-
-    dismiss() {
-        this.isDissmiss = true;
-    }
-}
+import { RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, RACE_EVENT, PUSH_ROUTE, GUILD_ACTIVITY_STATUS, RACE_ACTIVITY_STATUS } from "../../consts";
+import { getRandEelm, sortArrRandom, getRandResultByMember } from "../../pubUtils/util";
+import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from "../pushService";
+import { GUILDACTIVITY } from "../../pubUtils/dicParam";
 
 // 粮草先行
 export class RaceActivityObject {
-    public status = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
-    private allStartTime = 0; // 开启时间，每天晚上8点
-    private guildList: GuildInfo[] = []; // 所有军团
-    private members: Map<string, MemberInfo[]> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
-    private woodenHorses: Map<string, WoodenHorse> = new Map(); // 每个军团的木牛流马 guildCode => WoodenHorse
-    private events: Map<string, Event[]> = new Map(); // 每个军团遇到的事件
-    private items: Map<string, RewardInter[]> = new Map(); // 每个玩家的道具 roleId => [{id, count}]
-    private hasSentGuild: string[] = [];
+    data: RaceActivityData = new RaceActivityData();
+
+    public getStatus() {
+        return this.data.status;
+    }
 
     public getItem(roleId: string) {
-        return this.items.get(roleId)||[]
+        return this.data.items.get(roleId)||[]
     }
 
     // 是否加入过
     public getMember(guildCode: string, roleId: string) {
-        let member = this.members.get(guildCode)||[];
+        let member = this.data.members.get(guildCode)||[];
         return member.find(cur => cur.roleId == roleId);
     }
 
@@ -65,7 +32,11 @@ export class RaceActivityObject {
         let member = this.getMember(guildCode, roleId);
         if(!member) return member;
         let wh = await this.getWoodenHorse(guildCode, serverId);
-        wh.updateMemberSid(roleId, sid);
+        let index = wh.members.findIndex(cur => cur.roleId == roleId);
+        if(index != -1) {
+            wh.members[index].updateSid(sid);
+        }
+
         return member
     }
 
@@ -73,7 +44,7 @@ export class RaceActivityObject {
         let member = this.getMember(guildCode, roleId);
         if(!member) return member;
         let wh = await this.getWoodenHorse(guildCode, serverId);
-        wh.leaveMemberSid(roleId);
+        this.leaveMemberSid(wh, roleId);
 
         return member
     }
@@ -83,42 +54,42 @@ export class RaceActivityObject {
         if(!member) return;
         member.quit();
         let wh = await this.getWoodenHorse(guildCode, serverId);
-        wh.leaveMemberSid(roleId, true);
+        this.leaveMemberSid(wh, roleId, true);
     }
 
     public dismiss(guildCode: string) {
-        let guild = this.guildList.find(guild => guild.guildCode == guildCode);
+        let guild = this.data.guildList.find(guild => guild.guildCode == guildCode);
         if(!guild) return;
         guild.dismiss();
-        this.woodenHorses.delete(guildCode);
+        this.data.woodenHorses.delete(guildCode);
     }
 
     // 加入member
     private pushMember(guildCode: string, roleId: string, job: number, code: string) {
-        if(!this.members.has(guildCode)) {
-            this.members.set(guildCode, []);
+        if(!this.data.members.has(guildCode)) {
+            this.data.members.set(guildCode, []);
         }
-        this.members.get(guildCode).push(new MemberInfo(roleId, job, code));
+        this.data.members.get(guildCode).push(new MemberInfo(roleId, job, code));
     }
 
     public getGuilds() {
-        return this.guildList.filter(cur => !cur.isDissmiss);
+        return this.data.guildList.filter(cur => !cur.isDissmiss);
     }
 
     public getMembersOfGuild(guildCode: string) {
-        let members = this.members.get(guildCode)||[];
+        let members = this.data.members.get(guildCode)||[];
         return members.filter(cur => !cur.isQuit);
     }
     
     public getAllWoodenHorses() {
-        return this.woodenHorses;
+        return this.data.woodenHorses;
     }
 
     public async getRanks(serverId: number, guildCode?: string) {
         let myRank: RaceActivityRankParam = null;
         let ranks: RaceActivityRankParam[] = [];
         let myIndex = -1;
-        for(let [_, _wh] of this.woodenHorses) {
+        for(let [_, _wh] of this.data.woodenHorses) {
             if(_wh.serverId == serverId && _wh.status != GUILD_ACTIVITY_STATUS.WAITING) {
                 let wh = await this.getWoodenHorse(_wh.guildCode, _wh.serverId);
                 if(wh) {
@@ -152,10 +123,10 @@ export class RaceActivityObject {
     public async joinWoodenHorse(guildCode: string, roleId: string, roleName: string, serverId: number, sid: string, job: number, code: string, isDebug = false) {
         let woodenHorse = await this.getWoodenHorse(guildCode, serverId, isDebug);
         if(!woodenHorse) return false;
-        woodenHorse.joinMember(roleId, roleName, sid, code)
+        this.joinMember(woodenHorse, roleId, roleName, sid, code)
         this.pushMember(guildCode, roleId, job, code);
 
-        if(this.status == GUILD_ACTIVITY_STATUS.START) {
+        if(this.data.status == GUILD_ACTIVITY_STATUS.START) {
             // this.sendRandItemsToMembers([member], woodenHorse, woodenHorse.remainItems);
             this.woodenHorseStartRace(woodenHorse);
         } 
@@ -164,22 +135,22 @@ export class RaceActivityObject {
 
     // 获取某个军团的木马状态
     public async getWoodenHorse(guildCode: string, serverId: number, isDebug: boolean = false) {
-        if(!this.woodenHorses.has(guildCode)) {
+        if(!this.data.woodenHorses.has(guildCode)) {
             this.initEvents(guildCode);
             if(isDebug) {
-                this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildCode, 0, serverId, this.allStartTime, false));
-                this.guildList.push(new GuildInfo(serverId, guildCode));
+                this.data.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildCode, 0, serverId, this.data.allStartTime, false));
+                this.data.guildList.push(new GuildInfo(serverId, guildCode));
             } else {
                 let guild = await GuildModel.findByCode(guildCode, serverId);
                 if(!guild) return undefined;
                 let { name: guildName, guildCe } = guild;
-                this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId, this.allStartTime, false));
-                this.guildList.push(new GuildInfo(serverId, guildCode));
+                this.data.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId, this.data.allStartTime, false));
+                this.data.guildList.push(new GuildInfo(serverId, guildCode));
             }
         }
-        let woodenHorse = this.woodenHorses.get(guildCode);
-        let events = this.events.get(guildCode)||[];
-        let needSendEnd = woodenHorse.calCurWoodenHorse(events);
+        let woodenHorse = this.data.woodenHorses.get(guildCode);
+        let events = this.data.events.get(guildCode)||[];
+        let needSendEnd = this.calCurWoodenHorse(woodenHorse, events);
         if (needSendEnd) { // 抵达后发送奖励，发送消息，结算
             await sendSingleRaceActEndMsg(guildCode, woodenHorse);
         }
@@ -194,12 +165,12 @@ export class RaceActivityObject {
             if(!rec) return false;
         }
         let event = new Event(id, fromGuild, toGuild, count);
-        if(!this.events.has(toGuild)) {
-            this.events.set(toGuild, [event]);
+        if(!this.data.events.has(toGuild)) {
+            this.data.events.set(toGuild, [event]);
         } else {
-            let events = this.events.get(toGuild)||[];
+            let events = this.data.events.get(toGuild)||[];
             events.push(event);
-            this.events.set(toGuild, events);
+            this.data.events.set(toGuild, events);
         }
         let { guildRank, myGuildRank, myIndex } = await this.getRanks(serverId, toGuild);
         if(myGuildRank) {
@@ -219,10 +190,10 @@ export class RaceActivityObject {
 
     // 定时任务到，开始比赛，设置开始赛道，发放初始道具
     public startRace() {
-        this.status = GUILD_ACTIVITY_STATUS.START;
-        if(this.allStartTime == 0) this.allStartTime = Date.now();
+        this.data.status = GUILD_ACTIVITY_STATUS.START;
+        if(this.data.allStartTime == 0) this.data.allStartTime = Date.now();
         let guildCodes = new Array<string>();
-        for(let [code, woodenHorse] of this.woodenHorses) {
+        for(let [code, woodenHorse] of this.data.woodenHorses) {
             if(woodenHorse.memberCnt > 0) {
                 this.woodenHorseStartRace(woodenHorse);
                 guildCodes.push(code);
@@ -232,14 +203,18 @@ export class RaceActivityObject {
     }
 
     public stopRace() {
-        this.status = GUILD_ACTIVITY_STATUS.END;
-        for(let [_, woodenHorse] of this.woodenHorses) {
-            woodenHorse.stopRace();
+        this.data.status = GUILD_ACTIVITY_STATUS.END;
+        for(let [_, woodenHorse] of this.data.woodenHorses) {
+            woodenHorse.status = RACE_ACTIVITY_STATUS.END;
         }
     }
 
     private woodenHorseStartRace(woodenHorse: WoodenHorse) {
-        woodenHorse.startRace(this.allStartTime);
+        woodenHorse.status = RACE_ACTIVITY_STATUS.START;
+        woodenHorse.time = Date.now();
+        woodenHorse.startTime = Date.now();
+        woodenHorse.allStartTime = this.data.allStartTime;
+
         let members = woodenHorse.members;
         let normalItems = getRaceEventItems();
         this.sendRandItemsToMembers(members, woodenHorse, normalItems);
@@ -262,7 +237,7 @@ export class RaceActivityObject {
                     addItems.get(member.roleId).items.push({ id, count });
                 }
             }
-            woodenHorse.setRemainItem(id, randResult.remain, max);
+            this.setRemainItem(woodenHorse, id, randResult.remain, max);
         }
         for(let [_roleId, {member, items}] of addItems) {
             member.setReceived(true);
@@ -272,8 +247,8 @@ export class RaceActivityObject {
     
     // 初始进入就随机9个灵球事件
     public initEvents(guildCode: string) {
-        if(!this.events.get(guildCode)) {
-            this.events.set(guildCode, []);
+        if(!this.data.events.get(guildCode)) {
+            this.data.events.set(guildCode, []);
         }
         let dicEncounter = gameData.raceActivityEncounter; // 距离=>事件类型
         let goodEventNum = Math.floor(dicEncounter.eventNum/2);
@@ -288,17 +263,17 @@ export class RaceActivityObject {
         for(let [distance, type] of dicEncounter.events) {
             if(type == RACE_EVENT_TYPE.ITEM) {
                 let event = new Event(RACE_EVENT.ITEM, guildCode, guildCode, 1, distance);
-                this.events.get(guildCode).push(event);
+                this.data.events.get(guildCode).push(event);
             } else if (type == RACE_EVENT_TYPE.EVENT) {
                 let event = new Event(events[index], guildCode, guildCode, 1, distance);
-                this.events.get(guildCode).push(event);
+                this.data.events.get(guildCode).push(event);
                 index ++;
             }
         }
     }
 
     public getEvents(guildCode: string, distance: number) {
-        let events = this.events.get(guildCode)||[];
+        let events = this.data.events.get(guildCode)||[];
         let result = new Array<Event>();
         for(let event of events) {
             let { endTime, endDistance } = event;
@@ -323,7 +298,7 @@ export class RaceActivityObject {
     }
 
     private handleItems(roleId: string, sid: string, incItems: {id: number, count: number}[]) {
-        let items = this.items.get(roleId)||[];
+        let items = this.data.items.get(roleId)||[];
         let sendItems = new Array<{id: number, count: number}>();
         for(let {id, count: inc} of incItems) {
             let curItem = items.find(cur => cur.id == id);
@@ -337,17 +312,17 @@ export class RaceActivityObject {
                 sendItems.push({ id, count: curItem.count });
             }
         }
-        this.items.set(roleId, items);
+        this.data.items.set(roleId, items);
         sendMessageToUserWithSuc(roleId, PUSH_ROUTE.RACE_ITEM_UPDATE, { items: sendItems }, sid);
         return items;
     }
 
     public send(guildCode: string) {
-        this.hasSentGuild.push(guildCode);
+        this.data.hasSentGuild.push(guildCode);
     }
 
     public hasSend(guildCode: string) {
-        return this.hasSentGuild.indexOf(guildCode) != -1;
+        return this.data.hasSentGuild.indexOf(guildCode) != -1;
     }
 
     public async calServerHorses(serverId: number) {
@@ -408,5 +383,178 @@ export class RaceActivityObject {
         }
         return woodenHorseList
     }
+
+
+    /**
+     * 根据时间计算当前木马速度距离耐久等
+     * @param events 
+     * @returns {boolean} needSendEnd 是否跑到终点发送结束新号 
+     */
+    public calCurWoodenHorse(woodenHorse: WoodenHorse, events: Event[]): boolean {
+        if(woodenHorse.status == RACE_ACTIVITY_STATUS.END) return false;
+
+        if(woodenHorse.status == RACE_ACTIVITY_STATUS.START) {
+            if(woodenHorse.distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH) {
+                woodenHorse.distance = GUILDACTIVITY.RACEACTIVITY_LENGTH;
+                woodenHorse.status = RACE_ACTIVITY_STATUS.END;
+                woodenHorse.speed = 0;
+                return true;
+            }
+
+            woodenHorse.distance = Math.floor((woodenHorse.distance + (Date.now() - woodenHorse.time)/1000 * woodenHorse.speed ) * 1000)/1000; // 1位小数点
+            woodenHorse.time = Date.now();
+        }
+        let effectiveEvents = new Array<Event>();
+        for(let i = 0; i < events.length; i++) {
+            let event = events[i];
+            if(event.useDistance() && event.startDistance && woodenHorse.distance > event.startDistance) {
+                let startTime = Date.now() - Math.floor((woodenHorse.distance - event.startDistance) / woodenHorse.speed);
+                event.setStartTime(startTime); // 距离生效的事件的实际生效时间，主要用于速度叠加顺序
+            }
+            let isEffective = false;
+            if(event.useTime()) {
+                if(event.startTime <= Date.now() && event.endTime > Date.now()) {
+                    isEffective = true;
+                }
+                if(event.endTime < Date.now()) {
+                    if(event.endTime && event.startTime == event.endTime) {
+                        isEffective = true;
+                    }
+                    let index = events.findIndex(cur => cur.id == event.id);
+                    events.splice(index, 1);
+                }
+            }
+            if(event.useDistance()) {
+                if(event.startDistance <= woodenHorse.distance && event.endDistance > woodenHorse.distance) {
+                    isEffective = true;
+                }
+                if(event.endDistance < woodenHorse.distance) {
+                    if(event.endDistance && event.startDistance == event.endDistance) {
+                        isEffective = true;
+                    }
+                    let index = events.findIndex(cur => cur.id == event.id);
+                    events.splice(index, 1);
+                }
+            }
+
+            if(isEffective) {
+                effectiveEvents.push(event);
+            }
+        }
+
+        effectiveEvents.sort((a, b) => a.startTime - b.startTime);
+        woodenHorse.speed = GUILDACTIVITY.RACE_INIT_SPEED + woodenHorse.memberCnt * GUILDACTIVITY.RACE_PER_SPEED;
+        for(let { id, count, endTime } of effectiveEvents) {
+            this.calEvent(woodenHorse, id, count, endTime);
+        }
+        if(woodenHorse.durability <= 0) {
+            woodenHorse.status = RACE_ACTIVITY_STATUS.BREAK;
+            woodenHorse.speed = 0;
+        } 
+        return false;
+    }
+
+    private calEvent(woodenHorse: WoodenHorse, id: number, count: number = 1, endTime?: number) {
+        let { effect } = gameData.raceActivityEvents.get(id);
+
+        switch (id) {
+            case RACE_EVENT.LIANNU:
+                if (woodenHorse.shieldTime < Date.now()) {
+                    if (woodenHorse.shield >= count) {
+                        woodenHorse.shield -= count;
+                    } else {
+                        woodenHorse.shield = 0;
+                        woodenHorse.durability -= (count - woodenHorse.shield) * effect[0];
+                        if(woodenHorse.durability > 100) woodenHorse.durability = 100;
+                        if(woodenHorse.durability < 0) woodenHorse.durability = 0;
+                    }
+                }
+                break;
+            case RACE_EVENT.GUISHOUYINFU:
+                if (woodenHorse.shieldTime < Date.now()) {
+                    woodenHorse.time = endTime;
+                    woodenHorse.speed = effect[1]||0.1;
+                }
+                break;
+            case RACE_EVENT.FENGCHE:
+            case RACE_EVENT.WUGUIBANYUNFU:
+                woodenHorse.speed *= Math.pow(1 + effect[0] / 100, count); break;
+            case RACE_EVENT.LUDUN:
+                woodenHorse.shield += count * effect[0]; break;
+            case RACE_EVENT.TIANSHIDUNFU:
+                woodenHorse.shieldTime = endTime; break;
+            case RACE_EVENT.JIASU_1:
+                woodenHorse.speed *= Math.pow(1 + effect[0] / 100, count); break;
+            case RACE_EVENT.JIASU_2:
+                woodenHorse.speed += effect[0]; break;
+            case RACE_EVENT.HUIFU_1:
+                woodenHorse.durability += effect[0]; 
+                if(woodenHorse.durability > 100) woodenHorse.durability = 100;
+                if(woodenHorse.durability < 0) woodenHorse.durability = 0;
+                break;
+            case RACE_EVENT.JIANSU_1:
+                woodenHorse.speed *= Math.pow(1 - effect[0] / 100, count); break;
+            case RACE_EVENT.JIANSU_2:
+                woodenHorse.speed -= effect[0]; 
+                if(woodenHorse.speed < 0) woodenHorse.speed = 0;
+                break;
+            case RACE_EVENT.SHANGHAI_1:
+                woodenHorse.durability -= effect[0]; 
+                if(woodenHorse.durability > 100) woodenHorse.durability = 100;
+                if(woodenHorse.durability < 0) woodenHorse.durability = 0;
+                break;
+            case RACE_EVENT.ITEM:
+                let onlineMembers = woodenHorse.members.filter(member => member.isOnline);
+                let memberCnt = onlineMembers.length;
+                console.log('##### HANDLE_ITEM', memberCnt, onlineMembers)
+        
+                let ranMember: WoodenHorseMember[] = getRandEelm(onlineMembers, GUILDACTIVITY.RACEACTIVITY_EVENT_MEMBERCNT);
+                if(ranMember.length <= 0) ranMember = onlineMembers;
+                for(let member of ranMember) {
+                    let item = gameData.raceEventItems;
+                    member.addTempItems(item);
+                }
+                let normalItems = getRaceEventItems();
+                
+                for(let [id, {total, max}] of normalItems) {
+                    let randResult = getRandResultByMember(total, max, memberCnt);
+                    for(let i = 0; i < onlineMembers.length; i++) {
+                        let count = randResult.arr[i]||0;
+                        if(count > 0) {
+                            onlineMembers[i].addTempItem({ id, count });
+                            normalItems.get(id).total -= count;
+                        }
+                    }
+                }
+                break;
+        }
+    }
+
+    public joinMember(woodenHorse: WoodenHorse, roleId: string, roleName: string, sid: string, code: string) {
+        let index = woodenHorse.members.findIndex(cur => cur.roleId == roleId)
+        if(index == -1) {
+            let member = new WoodenHorseMember(roleId, roleName, sid, code);
+            woodenHorse.members.push(member);
+            woodenHorse.speed++;
+            woodenHorse.memberCnt++;
+            return member;
+        } else {
+            return woodenHorse.members[index];
+        }
+    }
+
+    public leaveMemberSid(woodenHorse: WoodenHorse, roleId: string, isQuit = false) {
+        let index = woodenHorse.members.findIndex(cur => cur.roleId == roleId);
+        if(index != -1) {
+            woodenHorse.members[index].leave();
+        }
+        if(isQuit) woodenHorse.memberCnt--;
+        if(woodenHorse.memberCnt < 0) woodenHorse.memberCnt = 0;
+    }
+
+    public setRemainItem(woodenHorse: WoodenHorse, id: number, remain: number, max: number) {
+        woodenHorse.remainItems.set(id, { total: remain, max });
+    }
+
 }
 

game-server/app/services/gvg/gvgBattleMemory.ts

@@ -1,17 +1,10 @@
 // 存在激战期的内存数据
 
-import { pinus } from "pinus";
-import { GVG_CATAPULT, GVG_PERIOD } from "../../consts";
-import { GVGTeamModel, GVGTeamType } from "../../db/GVGTeam";
+import { GVG_CATAPULT } from "../../consts";
+import { GVGTeamType } from "../../db/GVGTeam";
 import { GVGTeamMem } from "../../domain/battleField/gvgBattle";
-import { dispatch } from "../../pubUtils/dispatcher";
-import { getGVGPeriodData } from "./gvgService";
-import { redisClient } from "../redisService";
 
-// 积分点占领情况，groupId_serverType_cityId -> GVGBattleData
-const gvgBattleMap: Map<string, GVGBattleData> = new Map();
-
-class GVGBattleData {
+export class GVGBattleData {
     public groupKey: string;     // 战区
 
     private teams: Map<string, GVGTeamMem> = new Map(); // 队伍, teamCode => team
@@ -224,34 +217,4 @@ class GVGBattleData {
     public setLeagueTech(leagueCode: string, activeTech: number[]) {
         this.leagueActiveTech.set(leagueCode, activeTech);
     }
-}
-
-export function getGVGBattleData(groupKey: string) {
-    if(!gvgBattleMap.has(groupKey)) {
-        gvgBattleMap.set(groupKey, new GVGBattleData(groupKey));
-    }
-    return gvgBattleMap.get(groupKey);
-}
-
-export function getGVGBattleMap() {
-    return gvgBattleMap;
-}
-
-export async function initTeamToMem() {
-    let sid = pinus.app.getServerId();
-    let servers = pinus.app.getServersByType('guild');
-    let { configId, period } = getGVGPeriodData();
-    if(period != GVG_PERIOD.BATTLE) return;
-    let teams = await GVGTeamModel.findByConfigId(configId);
-    for(let team of teams) {
-        if(team.isBroken) continue;
-        if((await dispatch(redisClient(), team.cityId.toString(), servers, 'guild'))?.id == sid) {
-            let teamObj = getGVGBattleData(team.groupKey);
-            teamObj.enterCity(team);
-        }
-    }
-}
-
-export function clearBattleMemory() {
-    gvgBattleMap.clear();
 }

game-server/app/services/gvg/gvgBattleService.ts

@@ -6,7 +6,7 @@ import { gameData, getGVGBattleRankReward } from "../../pubUtils/data";
 import { COUNTER, GVG_AREA_TYPE, GVG_ATTACK_TYPE, GVG_BATTLE_RANK_TYPE, GVG_PERIOD, GVG_POINT_TYPE, GVG_TECH_TYPE, MAIL_TYPE, PUSH_ROUTE, REDIS_KEY, STATUS } from "../../consts";
 import { getTimeFun, nowSeconds } from "../../pubUtils/timeUtil";
 import { DicGVGAreaPoint } from "../../pubUtils/dictionary/DicGVGAreaPoint";
-import { getGVGBattleData, getGVGBattleMap } from "./gvgBattleMemory";
+import { getGVGBattleData, getGVGBattleMap } from "../memoryCache/gvgBattleData";
 import { GVGAttackSpine, GVGCityMapInfo, GVGTeamInList, GVGTeamInListOnPoint, GVGTeamSpineInMap } from "../../domain/gvgField/returnData";
 import { GVG } from "../../pubUtils/dicParam";
 import { GVGHeroInfo, PvpEnemies, PvpHeroInfo } from "../../domain/dbGeneral";
@@ -516,6 +516,7 @@ export async function gvgBattleSeconds() {
                 await redisAddSettleScore(team, addScore);
             }
         }
+        
         // 向下推送区域数据
         let spinesByCity = new Map<number, GVGTeamSpineInMap[]>();
         for(let areaId of teamObj.findAreas()) {
@@ -758,4 +759,19 @@ export async function getBattleRank(redisKey: REDIS_KEY, keyParam: KeyNameParam,
         }
     }
     return { ranks, myRank }
+}
+
+export async function initTeamToMem() {
+    let sid = pinus.app.getServerId();
+    let servers = pinus.app.getServersByType('guild');
+    let { configId, period } = getGVGPeriodData();
+    if(period != GVG_PERIOD.BATTLE) return;
+    let teams = await GVGTeamModel.findByConfigId(configId);
+    for(let team of teams) {
+        if(team.isBroken) continue;
+        if((await dispatch(redisClient(), team.cityId.toString(), servers, 'guild'))?.id == sid) {
+            let teamObj = getGVGBattleData(team.groupKey);
+            teamObj.enterCity(team);
+        }
+    }
 }

game-server/app/services/gvg/gvgTeamService.ts

@@ -16,9 +16,8 @@ import { LeagueLeader } from "../../domain/rank";
 import { GVG } from "../../pubUtils/dicParam";
 import { getZeroPointD } from "../../pubUtils/timeUtil";
 import { resResult } from "../../pubUtils/util";
-import { sendMessageToUserWithSuc } from "../pushService";
 import { updateUserInfo } from "../redisService";
-import { getGVGBattleData } from "./gvgBattleMemory";
+import { getGVGBattleData } from "../memoryCache/gvgBattleData";
 import { guildJoinLeagueRecord } from "./gvgRecService";
 import { calLeagueCe, getCurPeriod, getGroupKey, getGVGConfig, getGVGPeriodData, getGVGServerType } from "./gvgService";
 

game-server/app/services/memoryCache/comBattleData.ts

@@ -0,0 +1,57 @@
+import { pinus } from "pinus";
+import { MemComBtlTeam } from "../../domain/battleField/ComBattleTeamField";
+
+let teamMap = new Map<string, MemComBtlTeam>();
+let teamDisTimer = new Map<string, NodeJS.Timer>();
+let robotHurtTimer = new Map<string, NodeJS.Timer>();
+
+
+export function addComTeam(teamCode: string, team: MemComBtlTeam) {
+    teamMap.set(teamCode, team);
+    pinus.app.set('teamMap', teamMap);
+    return teamMap
+}
+
+export function getTeamMap() {
+    return teamMap;
+}
+
+export function getComTeamByCode(teamCode: string) {
+    return teamMap.get(teamCode);
+}
+
+export function deleteComBattle(teamCode: string) {
+    let rmSt = teamMap.delete(teamCode);
+    return rmSt
+}
+
+export function getComTeamTimerByCode(teamCode: string) {
+    return teamDisTimer.get(teamCode)
+}
+
+export function setComTeamTimer(teamCode: string, timer: NodeJS.Timer) {
+    teamDisTimer.set(teamCode, timer);
+    pinus.app.set('teamDisTimer', teamDisTimer);
+}
+
+export function clearComBtlTimer(teamCode: string) {
+    let timer = getComTeamTimerByCode(teamCode);
+    if (timer) {
+        clearTimeout(timer);
+        teamDisTimer.delete(teamCode)
+    }
+    pinus.app.set('teamDisTimer', teamDisTimer);
+}
+
+export function getRobotHurtTimer(teamCode: string, roleId: string) {
+    const timerKey = `${teamCode}_${roleId}`;
+    return robotHurtTimer.get(timerKey);
+}
+
+export function setRobotHurtTimerIfNotExist(teamCode: string, roleId: string, robotTimer: NodeJS.Timer) {
+    const timerKey = `${teamCode}_${roleId}`;
+    if(!robotHurtTimer.has(timerKey)) {
+        robotHurtTimer.set(timerKey, robotTimer);
+        pinus.app.set('robotHurtTimer', robotHurtTimer);
+    }
+}

game-server/app/services/memoryCache/guildActivityData.ts

@@ -0,0 +1,38 @@
+import { pinus } from "pinus";
+import { CityActivityObject } from "../guildActivity/cityActivityObj";
+import { GateActivityObject } from "../guildActivity/gateActivityObj";
+import { RaceActivityObject } from "../guildActivity/raceActivityObj";
+
+let gateActivityObj: GateActivityObject = null;
+let cityActivityObj: CityActivityObject = null;
+let raceActivityObj: RaceActivityObject = null;
+
+export function getGateActivityObj() {
+    if (!gateActivityObj) {
+        gateActivityObj = new GateActivityObject();
+        pinus.app.set('gateActivityObj', gateActivityObj);
+    }
+    return gateActivityObj;
+}
+
+export function getCityActivityObj() {
+    if (!cityActivityObj) {
+        cityActivityObj = new CityActivityObject();
+        pinus.app.set('cityActivityObj', cityActivityObj);
+    }
+    return cityActivityObj;
+}
+
+export function getRaceActivityObj() {
+    if (!raceActivityObj) {
+        raceActivityObj = new RaceActivityObject();
+        pinus.app.set('raceActivityObj', raceActivityObj);
+    }
+    return raceActivityObj;
+}
+
+export function clearActivityObj() {
+    gateActivityObj = undefined;
+    cityActivityObj = undefined;
+    raceActivityObj = undefined;
+}

game-server/app/services/memoryCache/gvgBattleData.ts

@@ -0,0 +1,21 @@
+import { pinus } from "pinus";
+import { GVGBattleData } from "../gvg/gvgBattleMemory";
+
+// 积分点占领情况，groupId_serverType_cityId -> GVGBattleData
+const gvgBattleMap: Map<string, GVGBattleData> = new Map();
+
+export function getGVGBattleData(groupKey: string) {
+    if(!gvgBattleMap.has(groupKey)) {
+        gvgBattleMap.set(groupKey, new GVGBattleData(groupKey));
+        pinus.app.set('gvgBattleMap', gvgBattleMap);
+    }
+    return gvgBattleMap.get(groupKey);
+}
+
+export function getGVGBattleMap() {
+    return gvgBattleMap;
+}
+
+export function clearBattleMemory() {
+    gvgBattleMap.clear();
+}

game-server/app/services/memoryCache/hiddenData.ts

@@ -0,0 +1,17 @@
+import { pinus } from "pinus";
+
+
+export function setHiddenData(heroes: number[], goods: number[], refTime: number) {
+    pinus.app.set('hiddenHeroees', heroes||[]);
+    pinus.app.set('hiddenGoods', goods||[]);
+    pinus.app.set('hiddenRefTime', refTime||0);
+}
+
+export function getHiddenData() {
+    let heroes: number[] = pinus.app.get('hiddenHeroees')||[];
+    let goods: number[] = pinus.app.get('hiddenGoods')||[];
+    let refTime = pinus.app.get('hiddenRefTime')||0;
+    return {
+        refTime, heroes, items: goods
+    }
+}

game-server/app/services/timeTaskService.ts

@@ -41,7 +41,7 @@ import { LadderMatchRecModel } from '../db/LadderMatchRec';
 import { LadderMatchModel } from '../db/LadderMatch';
 import { getGroupShopTimers, refundGroupShop, setGroupShopToSetSum } from './activity/groupShopService';
 import { HiddenDataModel, HiddenDataModelType } from '../db/HiddenData';
-import { setHiddenData, setHiddenDataToMemory } from './dataService';
+import { setHiddenDataToMemory } from './dataService';
 import { GVGConfigModel } from '../db/GVGConfig';
 import { createNewGVGConfig, initLeaguePrepare } from './gvg/gvgService';
 import { getFightTimeByPeriod, saveVestigeRankSchedule, gvgBattlePeriodSchedule } from './gvg/gvgFightService';
@@ -52,6 +52,7 @@ import { MonthlyFundData } from "../domain/activityField/monthlyFundField";
 import { RewardInter } from '../pubUtils/interface';
 import { stringToRewardInter } from './activity/giftPackageService';
 import { autoCreateServerSchedule } from './serverService';
+import { setHiddenData } from './memoryCache/hiddenData';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;

shared/domain/battleField/ComBattleTeamField.ts

@@ -1,23 +1,8 @@
-import { COM_BTL_CONST, COM_TEAM_STATUS } from '../../consts';
-import { gameData, getBossHpByBlueprtId, getDicBlueprtById } from '../../pubUtils/data';
+import { COM_TEAM_STATUS } from '../../consts';
+import { getBossHpByBlueprtId, getDicBlueprtById } from '../../pubUtils/data';
 import ComBattleTeam from './../../db/ComBattleTeam';
-import { cloneDeep } from 'lodash'
 import { FriendParams } from '../roleField/friend';
-import { nowSeconds } from '../../pubUtils/timeUtil';
-import moment = require('moment');
-
-/**
- * 拷贝敌军数组并添加当前血量字段
- * @param source 原敌军数组，不包含当前血量字段
- */
- export function transBossHpArr(source: Array<{ dataId: number, hp: number, actorId: number }>): Array<{ dataId: number, hp: number, curHp: number, actorId: number }> {
-    let desArr = [];
-    source.forEach(elem => {
-        let { hp } = elem;
-        desArr.push(Object.assign(elem, { curHp: hp }));
-    });
-    return cloneDeep(desArr);
-}
+import { transBossHpArr } from '../../pubUtils/battleUtils';
 
 
 export class MemComBtlTeam extends ComBattleTeam  { 
@@ -50,13 +35,6 @@ export class MemComBtlTeam extends ComBattleTeam  {
     findMemberByRoleId(roleId: string) {
         return this.roleStatus.find(cur => cur.roleId == roleId);
     }
-
-    startTeam() {
-        this.status = COM_TEAM_STATUS.FIGHTING;
-        this.startTime = nowSeconds();
-        this.endTime = nowSeconds() + COM_BTL_CONST.BTL_TIME_LMT/1000;
-        this.hasTimeExtraReward = isComBattleTimeLimit();
-    }
  };
 
 
@@ -75,18 +53,3 @@ export class MemComBtlTeam extends ComBattleTeam  {
         this.status = comBattle.status;
     }
  }
-
- 
-/**
- * 当前是否是有加成的特殊时间
- */
-export function isComBattleTimeLimit() {
-    let arr = gameData.comBattleRewardTime;
-    for(let { from, to } of arr) {
-        let fromTime = moment(moment().format(`YYYY-MM-DD ${from}`)).valueOf();
-        let toTime = moment(moment().format(`YYYY-MM-DD ${to}`)).valueOf();
-        let now = moment().valueOf();
-        if(fromTime <= now && toTime >= now) return true;
-    }
-    return false;
-}

shared/domain/battleField/guildActivity.ts

@@ -1,20 +1,11 @@
 import { GUILDACTIVITY } from "../../pubUtils/dicParam";
 import { SimpleGuildRankParam, SimpleRoleRankParam } from '../rank'
 import { prop } from "@typegoose/typegoose";
-import { CITY_STATUS, RACE_ACTIVITY_STATUS, RACE_EVENT, RACE_EVENT_TYPE } from "../../consts";
+import { CITY_STATUS, RACE_ACTIVITY_STATUS, RACE_EVENT, RACE_EVENT_TYPE, GUILD_ACTIVITY_STATUS } from "../../consts";
 import { gameData, getRaceEventItems } from "../../pubUtils/data";
 import { getRandEelm, getRandResultByMember, } from "../../pubUtils/util";
 import { RewardInter } from "../../pubUtils/interface";
 
-export class GateMembersRec {
-    roleId: string;
-    round: number = 0;
-    enemies: number[] = [];
-    constructor(roleId: string) {
-        this.roleId = roleId;
-    }
-}
-
 export class WoodenHorseMember {
     roleId: string;
     roleName: string;
@@ -113,196 +104,6 @@ export class WoodenHorse {
         this.isRobot = isRobot;
     }
 
-    public startRace(allStartTime: number) {
-        this.status = RACE_ACTIVITY_STATUS.START;
-        this.time = Date.now();
-        this.startTime = Date.now();
-        this.allStartTime = allStartTime;
-    }
-
-    public stopRace() {
-        this.status = RACE_ACTIVITY_STATUS.END;
-    }
-
-    /**
-     * 根据时间计算当前木马速度距离耐久等
-     * @param events 
-     * @returns {boolean} needSendEnd 是否跑到终点发送结束新号 
-     */
-    public calCurWoodenHorse(events: Event[]): boolean {
-        if(this.status == RACE_ACTIVITY_STATUS.END) return false;
-
-        if(this.status == RACE_ACTIVITY_STATUS.START) {
-            if(this.distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH) {
-                this.distance = GUILDACTIVITY.RACEACTIVITY_LENGTH;
-                this.status = RACE_ACTIVITY_STATUS.END;
-                this.speed = 0;
-                return true;
-            }
-
-            this.distance = Math.floor((this.distance + (Date.now() - this.time)/1000 * this.speed ) * 1000)/1000; // 1位小数点
-            this.time = Date.now();
-        }
-        let effectiveEvents = new Array<Event>();
-        for(let i = 0; i < events.length; i++) {
-            let event = events[i];
-            if(event.useDistance() && event.startDistance && this.distance > event.startDistance) {
-                let startTime = Date.now() - Math.floor((this.distance - event.startDistance) / this.speed);
-                event.setStartTime(startTime); // 距离生效的事件的实际生效时间，主要用于速度叠加顺序
-            }
-            let isEffective = false;
-            if(event.useTime()) {
-                if(event.startTime <= Date.now() && event.endTime > Date.now()) {
-                    isEffective = true;
-                }
-                if(event.endTime < Date.now()) {
-                    if(event.endTime && event.startTime == event.endTime) {
-                        isEffective = true;
-                    }
-                    let index = events.findIndex(cur => cur.id == event.id);
-                    events.splice(index, 1);
-                }
-            }
-            if(event.useDistance()) {
-                if(event.startDistance <= this.distance && event.endDistance > this.distance) {
-                    isEffective = true;
-                }
-                if(event.endDistance < this.distance) {
-                    if(event.endDistance && event.startDistance == event.endDistance) {
-                        isEffective = true;
-                    }
-                    let index = events.findIndex(cur => cur.id == event.id);
-                    events.splice(index, 1);
-                }
-            }
-
-            if(isEffective) {
-                effectiveEvents.push(event);
-            }
-        }
-
-        effectiveEvents.sort((a, b) => a.startTime - b.startTime);
-        this.speed = GUILDACTIVITY.RACE_INIT_SPEED + this.memberCnt * GUILDACTIVITY.RACE_PER_SPEED;
-        for(let { id, count, endTime } of effectiveEvents) {
-            this.calEvent(id, count, endTime);
-        }
-        if(this.durability <= 0) {
-            this.status = RACE_ACTIVITY_STATUS.BREAK;
-            this.speed = 0;
-        } 
-        return false;
-    }
-
-    private calEvent(id: number, count: number = 1, endTime?: number) {
-        let { effect } = gameData.raceActivityEvents.get(id);
-
-        switch (id) {
-            case RACE_EVENT.LIANNU:
-                if (this.shieldTime < Date.now()) {
-                    if (this.shield >= count) {
-                        this.shield -= count;
-                    } else {
-                        this.shield = 0;
-                        this.durability -= (count - this.shield) * effect[0];
-                        if(this.durability > 100) this.durability = 100;
-                        if(this.durability < 0) this.durability = 0;
-                    }
-                }
-                break;
-            case RACE_EVENT.GUISHOUYINFU:
-                if (this.shieldTime < Date.now()) {
-                    this.time = endTime;
-                    this.speed = effect[1]||0.1;
-                }
-                break;
-            case RACE_EVENT.FENGCHE:
-            case RACE_EVENT.WUGUIBANYUNFU:
-                this.speed *= Math.pow(1 + effect[0] / 100, count); break;
-            case RACE_EVENT.LUDUN:
-                this.shield += count * effect[0]; break;
-            case RACE_EVENT.TIANSHIDUNFU:
-                this.shieldTime = endTime; break;
-            case RACE_EVENT.JIASU_1:
-                this.speed *= Math.pow(1 + effect[0] / 100, count); break;
-            case RACE_EVENT.JIASU_2:
-                this.speed += effect[0]; break;
-            case RACE_EVENT.HUIFU_1:
-                this.durability += effect[0]; 
-                if(this.durability > 100) this.durability = 100;
-                if(this.durability < 0) this.durability = 0;
-                break;
-            case RACE_EVENT.JIANSU_1:
-                this.speed *= Math.pow(1 - effect[0] / 100, count); break;
-            case RACE_EVENT.JIANSU_2:
-                this.speed -= effect[0]; 
-                if(this.speed < 0) this.speed = 0;
-                break;
-            case RACE_EVENT.SHANGHAI_1:
-                this.durability -= effect[0]; 
-                if(this.durability > 100) this.durability = 100;
-                if(this.durability < 0) this.durability = 0;
-                break;
-            case RACE_EVENT.ITEM:
-                let onlineMembers = this.members.filter(member => member.isOnline);
-                let memberCnt = onlineMembers.length;
-                console.log('##### HANDLE_ITEM', memberCnt, onlineMembers)
-        
-                let ranMember: WoodenHorseMember[] = getRandEelm(onlineMembers, GUILDACTIVITY.RACEACTIVITY_EVENT_MEMBERCNT);
-                if(ranMember.length <= 0) ranMember = onlineMembers;
-                for(let member of ranMember) {
-                    let item = gameData.raceEventItems;
-                    member.addTempItems(item);
-                }
-                let normalItems = getRaceEventItems();
-                
-                for(let [id, {total, max}] of normalItems) {
-                    let randResult = getRandResultByMember(total, max, memberCnt);
-                    for(let i = 0; i < onlineMembers.length; i++) {
-                        let count = randResult.arr[i]||0;
-                        if(count > 0) {
-                            onlineMembers[i].addTempItem({ id, count });
-                            normalItems.get(id).total -= count;
-                        }
-                    }
-                }
-                break;
-        }
-    }
-
-
-    public joinMember(roleId: string, roleName: string, sid: string, code: string) {
-        let index = this.members.findIndex(cur => cur.roleId == roleId)
-        if(index == -1) {
-            let member = new WoodenHorseMember(roleId, roleName, sid, code);
-            this.members.push(member);
-            this.speed++;
-            this.memberCnt++;
-            return member;
-        } else {
-            return this.members[index];
-        }
-    }
-
-    public updateMemberSid(roleId: string, sid: string) {
-        let index = this.members.findIndex(cur => cur.roleId == roleId);
-        if(index != -1) {
-            this.members[index].updateSid(sid);
-        }
-    }
-
-    public leaveMemberSid(roleId: string, isQuit = false) {
-        let index = this.members.findIndex(cur => cur.roleId == roleId);
-        if(index != -1) {
-            this.members[index].leave();
-        }
-        if(isQuit) this.memberCnt--;
-        if(this.memberCnt < 0) this.memberCnt = 0;
-    }
-
-    public setRemainItem(id: number, remain: number, max: number) {
-        this.remainItems.set(id, { total: remain, max });
-    }
-
     public getTreatTime() {
         return {...this, time: this.time - this.allStartTime }
     }
@@ -425,4 +226,72 @@ export class RaceActivityRankParam {
     setRank(rank: number) {
         this.rank = rank;
     }
+}
+
+export class CityActivityData {
+    public guildActivityStatus = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
+    public gateHp: Map<string, number> = new Map(); // 城门血条，每个cityId有一条血条 serverId&cityId => gateHp
+    public maxHp: Map<string, number> = new Map(); // 城门血条，每个cityId最大城门血量 serverId&cityId => gateHp
+    public members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
+    public cities: Map<string, string[]> = new Map(); // 各个城池参与的军团 serverId&cityId => [guildCode]
+    public guilds: Map<string, number> = new Map();  // 军团所在的城池 guildCode => cityId
+    public sentCity: string[] = [];
+    public startTime: number = 0;
+}
+
+export class GateMembersRec {
+    roleId: string;
+    round: number = 0;
+    enemies: number[] = [];
+    constructor(roleId: string) {
+        this.roleId = roleId;
+    }
+}
+
+export class GateActivityData {
+    public startTime: number;
+    public members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
+    public membersRecord: Map<string, GateMembersRec> = new Map(); // 每个成员的回合数和敌军数，防刷 recCode => GateMembersRec
+    public guilds: Map<number, string[]> = new Map(); // 参加的所有军团 server => [guildCode]
+}
+
+export class MemberInfo extends Member {
+    isQuit: boolean = false;
+
+    constructor(roleId: string, job: number, code: string) {
+        super();
+        this.roleId = roleId;
+        this.job = job;
+        this.code = code;
+    }
+
+    public quit() {
+        this.isQuit = true;
+    }
+}
+
+export class GuildInfo {
+    serverId: number;
+    guildCode: string;
+    isDissmiss: boolean = false;
+
+    constructor(serverId: number, guildCode: string) {
+        this.serverId = serverId;
+        this.guildCode = guildCode;
+    }
+
+    dismiss() {
+        this.isDissmiss = true;
+    }
+}
+
+export class RaceActivityData {
+    public status = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
+    public allStartTime = 0; // 开启时间，每天晚上8点
+    public guildList: GuildInfo[] = []; // 所有军团
+    public members: Map<string, MemberInfo[]> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
+    public woodenHorses: Map<string, WoodenHorse> = new Map(); // 每个军团的木牛流马 guildCode => WoodenHorse
+    public events: Map<string, Event[]> = new Map(); // 每个军团遇到的事件
+    public items: Map<string, RewardInter[]> = new Map(); // 每个玩家的道具 roleId => [{id, count}]
+    public hasSentGuild: string[] = [];
 }

shared/pubUtils/battleUtils.ts

@@ -1,5 +1,8 @@
 import * as crc from 'crc';
 import { md5 } from './sdkUtil';
+import { gameData } from './data';
+import moment = require('moment');
+import { cloneDeep } from 'lodash';
 
 const BATTLE_CLASS_MOD = 100; // 存档分类模数
 const CDN_URL_PREFIX_SQ = 'https://download-sgzzyz.yev242.com'; // sq cdn 服务器地址前缀
@@ -79,4 +82,32 @@ export function getLocalImgUrl(curEnv: string, type: string) {
 export function getRemoteImgUrl(curEnv: string, fileName: string, type: string) {
     const rplUrl = `${getPrefixByEnv(curEnv)}/img/${type}/` + fileName;
     return rplUrl;
+}
+
+ 
+/**
+ * 寻宝当前是否是有加成的特殊时间
+ */
+export function isComBattleTimeLimit() {
+    let arr = gameData.comBattleRewardTime;
+    for(let { from, to } of arr) {
+        let fromTime = moment(moment().format(`YYYY-MM-DD ${from}`)).valueOf();
+        let toTime = moment(moment().format(`YYYY-MM-DD ${to}`)).valueOf();
+        let now = moment().valueOf();
+        if(fromTime <= now && toTime >= now) return true;
+    }
+    return false;
+}
+
+/**
+ * 拷贝敌军数组并添加当前血量字段
+ * @param source 原敌军数组，不包含当前血量字段
+ */
+ export function transBossHpArr(source: Array<{ dataId: number, hp: number, actorId: number }>): Array<{ dataId: number, hp: number, curHp: number, actorId: number }> {
+    let desArr = [];
+    source.forEach(elem => {
+        let { hp } = elem;
+        desArr.push(Object.assign(elem, { curHp: hp }));
+    });
+    return cloneDeep(desArr);
 }