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

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

@@ -0,0 +1,178 @@
+import { pinus, } from 'pinus';
+import { ActivityModel } from '../../db/Activity';
+import { ActivityInRemote } from '../../domain/activityField/activityField';
+import { ActivityGroupModel } from '../../db/ActivityGroup';
+
+const activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
+const activities: Map<number, ActivityInRemote> = new Map(); // activityId => activity
+const activityByType: Map<number, Map<number, number[]>> = new Map(); // serverId => type => activityId[];
+const groupToServer: Map<number, number[]> = new Map(); // group => serverId[];
+
+export function clearData() {
+    activityByServer.clear();
+    activities.clear();
+    activityByType.clear();
+    groupToServer.clear();
+}
+
+function updateActivityByType(_activityByType: Map<number, Map<number, number[]>>) {
+    activityByType.clear();
+    for(let [serverId, map] of _activityByType) {
+        activityByType.set(serverId, map);
+    }
+    pinus.app.set('activityByServer', activityByType);
+}
+
+function updateActivityByServer(_activityByServer: Map<number, number[]>) {
+    activityByServer.clear();
+    for(let [serverId, arr] of _activityByServer) {
+        activityByServer.set(serverId, arr);
+    }
+    pinus.app.set('activityByServer', activityByServer);
+}
+
+export async function loadActivities() {
+    clearData();
+    let activityGroup = await ActivityGroupModel.findAllActivityGroup();
+    for(let { groupId, serverIds } of activityGroup) {
+        for(let serverId of serverIds) {
+            if(!groupToServer.has(groupId)) {
+                groupToServer.set(groupId, []);
+            }
+            groupToServer.get(groupId).push(serverId);
+        }
+    }
+
+    let activityDb = await ActivityModel.findOpenAndComingActivityes();
+    let activityIds: number[] = [];
+    for(let activity of activityDb) {
+        activities.set(activity.activityId, new ActivityInRemote(activity));
+        activityIds.push(activity.activityId);
+    }
+    setActivityTypeAndServer();
+
+    pinus.app.set('activityByServer', activityByServer);
+    pinus.app.set('activityByType', activityByType);
+    pinus.app.set('activities', activities);
+    pinus.app.set('groupToServer', groupToServer);
+}
+
+export async function setActivityTypeAndServer() {
+    let _activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
+    let _activityByType: Map<number, Map<number, number[]>> = new Map();
+
+    for(let [_, activity] of activities) {
+        let servers = groupToServer.get(activity.groupId)||[];
+        for(let serverId of servers) {
+            if(!_activityByServer.has(serverId)) {
+                _activityByServer.set(serverId, []);
+            }
+            _activityByServer.get(serverId).push(activity.activityId);
+
+            if(!_activityByType.has(serverId)) {
+                _activityByType.set(serverId, new Map());
+            }
+            if(!_activityByType.get(serverId).has(activity.type)) {
+                _activityByType.get(serverId).set(activity.type, []);
+            }
+            _activityByType.get(serverId).get(activity.type).push(activity.activityId);
+        }
+    }
+    updateActivityByServer(_activityByServer);
+    updateActivityByType(_activityByType);
+    
+
+}
+
+export function updateActivities(activityDb: ActivityInRemote[]) {
+    // console.log('******* activities', activities)
+    let activityIds: number[] = [];
+    for(let activity of activityDb) {
+        activities.set(activity.activityId, activity);
+        activityIds.push(activity.activityId);
+    }
+    setActivityTypeAndServer();
+}
+
+export function deleteActivities(activityIds: number[]) {
+
+    for(let activityId of activityIds) {
+        activities.delete(activityId);
+    }
+    setActivityTypeAndServer();
+}
+
+export function saveGroupToServer(groupIds: number[], serverIds: number[]) {
+    for(let groupId of groupIds) {
+        groupToServer.set(groupId, serverIds);
+    }
+    setActivityTypeAndServer();
+}
+
+export function addServerToGroup(groupIds: number[], serverIds: number[]) {
+    for(let groupId of groupIds) {
+
+        if(!groupToServer.has(groupId)) {
+            groupToServer.set(groupId, []);
+        }
+        for(let serverId of serverIds) {
+            let arr = groupToServer.get(groupId)||[];
+            if(arr.indexOf(serverId) == -1) {
+                groupToServer.get(groupId).push(serverId);
+            }
+        }
+    }
+    setActivityTypeAndServer();
+}
+
+export function saveActivitiesToGroup(groupId: number, activityDb: number[]) {
+    for(let activityId of activityDb) {
+        if(activities.get(activityId)) {
+            activities.get(activityId).groupId = groupId;
+        }
+    }
+    setActivityTypeAndServer();
+}
+
+export function _getActivityById(activityId: number) {
+    return <ActivityInRemote>activities?.get(activityId);
+}
+
+export function _getActivitiesByType(serverId: number, type: number) {
+    let activityByTypeData = activityByType?.get(serverId)?.get(type)??[];
+    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
+    let result: ActivityInRemote[] = [];
+    for(let activityId of activityByTypeData) {
+        let activity = activities.get(activityId);
+        if(activity && activity.isEnable) {
+            result.push(activity);
+        }
+    }
+    return result;
+}
+
+export function _getActivitiesByServerId(serverId: number) {
+    let activityByServerId = activityByServer?.get(serverId)||[]
+    let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
+    let result: ActivityInRemote[] = [];
+    for(let activityId of activityByServerId) {
+        let activity = activities.get(activityId);
+        if(activity && activity.isEnable) {
+            result.push(activity);
+        }
+    }
+    return result;
+}
+
+export function _getActivities() {
+    try {
+        // console.log('***** activities', activities);
+        let result: ActivityInRemote[] = [];
+        for(let [_, activity] of activities) {
+            result.push(activity);
+        }
+        return result;
+    } catch(e) {
+        console.log('******** activity e', e)
+    }
+}

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
+    }
+}