军团活动：修复粮草先行重启问题，诸侯混战宣战问题

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

@@ -1,6 +1,6 @@
 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 { resResult } from "../../../pubUtils/util";
+import { genCode, resResult } from "../../../pubUtils/util";
 import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex } from "../../../services/guildActivity/guildActivityService";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { gameData } from "../../../pubUtils/data";
@@ -18,6 +18,7 @@ import { ServerRecordModel } from "../../../db/ServerRecords";
 import { sendMessageToCityWithSuc } from "../../../services/pushService";
 import { isDebugTime } from "../../../pubUtils/sdkUtil";
 import { GuildActivityCityDeclareModel } from "../../../db/GuildActivityCityDeclare";
+import { GuildModel } from "../../../db/Guild";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -353,4 +354,53 @@ export class CityActivityHandler {
             challengeTime: myGuildActivityRec.challengeTime
         });
     }
+
+    async debugTestAutoDeclare(msg: {  }, session: BackendSession) {
+        let serverId = session.get('serverId');
+        let roleId = session.get('roleId');
+        let guildCode = session.get('guildCode');
+        let declareIndex = getDeclareIndex();
+        for(let i = 0; i < 1000; i++) {
+            autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
+        }
+        return resResult(STATUS.SUCCESS)
+    }
+
+    private interval: NodeJS.Timer;
+    async debugStartHitGate(msg: { param: number  }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        let { param = 1000 } = msg;
+
+
+        let statusResult = getGuildActivityStatus(this.aid);
+        if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+        if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
+        if(statusResult.status != GUILD_ACTIVITY_STATUS.START) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
+
+        if(this.interval) {
+            clearInterval(this.interval);
+        }
+
+        let fun = async () => {
+            for(let [cityId] of gameData.cityActivity) {
+                let guilds = pinus.app.getServersByType('guild');
+                let guild = dispatch(`${cityId}`, guilds);
+                await pinus.app.rpc.guild.guildActivityRemote.debugSendGateHp.toServer(guild.id, serverId, cityId);
+            }
+            await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.broadcast(this.aid);
+        };
+        await fun();
+        this.interval = setInterval(fun, param)
+        return resResult(STATUS.SUCCESS)
+    }
+
+    async debugStopHitGate(msg: { magicWord: string }, session: BackendSession) {
+        
+        if(this.interval) {
+            clearInterval(this.interval);
+        }
+
+        return resResult(STATUS.SUCCESS);
+    }
 }

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

@@ -1,4 +1,4 @@
-import { Application, ChannelService, BackendSession, HandlerService, } from "pinus";
+import { Application, ChannelService, BackendSession, HandlerService, pinus, } from "pinus";
 import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, GUILD_POINT_WAYS, REDIS_KEY, TASK_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS, DEBUG_MAGIC_WORD } from "../../../consts";
 import { genCode, resResult } from "../../../pubUtils/util";
 import { getGuildActivityStatus, getRaceActivityObj, getWoodenHorseList, getGAIndexInPinus, getJoinIndex } from "../../../services/guildActivity/guildActivityService";
@@ -14,6 +14,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 { RoleModel } from "../../../db/Role";
+import { dispatch } from "../../../pubUtils/dispatcher";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -35,6 +38,8 @@ export class RaceActivityHandler {
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const guildCode = session.get('guildCode');
+        const sid = session.get('sid');
+
         if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         let statusResult = getGuildActivityStatus(this.aid);
@@ -46,7 +51,7 @@ export class RaceActivityHandler {
 
         let events = obj.getEvents(guildCode, woodenHorse.distance);
         let ranks: { myGuildRank?: RaceActivityRankParam, guildRank?: RaceActivityRankParam[] } = {};
-        let hasJoin = obj.getMember(guildCode, roleId);
+        let hasJoin = await obj.updateMemberSid(guildCode, serverId, roleId, sid);
 
         if(obj.status == GUILD_ACTIVITY_STATUS.START) {
             ranks = await obj.getRanks(serverId, guildCode);
@@ -247,4 +252,17 @@ export class RaceActivityHandler {
 
         return resResult(STATUS.SUCCESS);
     }
+
+    // 加入木马
+    async debugResetJoin(msg: { magicWord: string }, session: BackendSession) {
+
+        let servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
+        let guild = pinus.app.getServersByType('guild');
+        for(let { id: serverId } of servers) {
+            let sid = dispatch(`${serverId}`, guild);
+            pinus.app.rpc.guild.guildActivityRemote.debugResetJoin.toServer(sid.id, serverId);
+        }
+
+        return resResult(STATUS.SUCCESS);
+    }
 }

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

@@ -1,5 +1,5 @@
 import { Application, ChannelService, HandlerService, } from 'pinus';
-import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, clearActivityObj, getGAPinusName, getCurGuildActivityIndexByDb, initGuildActivityIndexInPinus, setGuildActivityIndexInPinus, guildActivityStart } from '../../../services/guildActivity/guildActivityService';
+import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, clearActivityObj, getGAPinusName, getCurGuildActivityIndexByDb, initGuildActivityIndexInPinus, setGuildActivityIndexInPinus, guildActivityStart, debugResetJoin, debugSendGateHp } from '../../../services/guildActivity/guildActivityService';
 import { gameData } from '../../../pubUtils/data';
 import { setWeek } from '../../../pubUtils/timeUtil';
 import { sendUngotDividend } from '../../../services/auctionService';
@@ -189,4 +189,20 @@ export class GuildActivityRemote {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
     }
+
+    async debugResetJoin(serverId: number) {
+        try {
+            await debugResetJoin(serverId);
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
+
+    public async debugSendGateHp(serverId: number, cityId: number) {
+        try {
+            await debugSendGateHp(serverId, cityId);
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
 }

game-server/app/services/checkParam.ts

@@ -1629,6 +1629,9 @@ export function checkRouteParam(route: string, msg: any) {
         case "guild.raceActivityHandler.debugAddHorse":
         case "activity.gachaHandler.debugClearGachaRecord":
         case "battle.eventBattleHandler.debugRefEvent":
+        case "guild.raceActivityHandler.debugResetJoin":
+        case "guild.cityActivityHandler.debugStartHitGate":
+        case "guild.cityActivityHandler.debugStopHitGate":
             {
                 if (msg.magicWord !== DEBUG_MAGIC_WORD || !isDevelopEnv()) return false;
                 break;

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

@@ -868,4 +868,37 @@ export function getJoinIndex() {
     let obj = getRaceActivityObj();
     if(obj.status == GUILD_ACTIVITY_STATUS.START) return index;
     return index + 1;
+}
+
+
+export async function debugResetJoin(serverId: number) {
+
+    let serverRecord = await ServerRecordModel.findTomorrowData(serverId);
+    let members = serverRecord?.activeGuildMembers||[];
+
+    let joinIndex = getJoinIndex();
+    let obj = getRaceActivityObj();
+    for(let roleId of members) {
+        let role = await RoleModel.findByRoleId(roleId);
+        if(role) {
+            let guildCode = role.guildCode;
+            let roleName = role.roleName;
+            let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, joinIndex, obj.getEvents(guildCode, 0));
+            if (!guildActivityRec) return false;
+    
+            let { code: sourceCode } = guildActivityRec;
+            let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
+            let myGuild = await UserGuildModel.getMyGuild(roleId, 'job');
+            let woodenHorse = await obj.joinWoodenHorse(guildCode, roleId, roleName, serverId, '', myGuild.job, myGuildActivityRec.code);            
+    
+        }
+    }
+    return true
+}
+
+export async function debugSendGateHp(serverId: number, cityId: number) {
+    let obj = getCityActivityObj();
+    let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
+    await sendMessageToCityWithSuc(cityId, PUSH_ROUTE.GUILD_CITY_ACT_HP, { cityId, gateHp: gateHp + 1000, maxHp });
+
 }

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

@@ -31,6 +31,14 @@ export class RaceActivityObject {
         return member.find(cur => cur.roleId == roleId);
     }
 
+    public async updateMemberSid(guildCode: string, serverId: number, roleId: string, sid: string) {
+        let hasJoin = this.getMember(guildCode, roleId);
+        if(!hasJoin) return hasJoin;
+        let wh = await this.getWoodenHorse(guildCode, serverId);
+        wh.updateMemberSid(roleId, sid);
+        return hasJoin
+    }
+
     // 加入member
     private pushMember(guildCode: string, roleId: string, job: number, code: string) {
         if(!this.members.has(guildCode)) {

shared/consts/constModules/sysConst.ts

@@ -554,6 +554,7 @@ export const FILENAME = {
     DIC_LADDER_RANKREWARD: 'dic_zyz_ladder_rankReward',
     DIC_GK_LADDER: 'dic_zyz_gk_ladder',
     DIC_LADDER_MATCH: 'dic_zyz_ladderMatch',
+    DIC_GK_BRANCH_ELITE: 'dic_zyz_gk_branchElite',
 }
 
 export const WAR_RELATE_TABLES = [
@@ -576,6 +577,7 @@ export const WAR_RELATE_TABLES = [
     FILENAME.DIC_GK_ARMY_TRAIN,
     FILENAME.DIC_GK_ARMY_BOSS,
     FILENAME.DIC_GK_LADDER,
+    FILENAME.DIC_GK_BRANCH_ELITE,
 ]
 
 // 装备栏强化类型

shared/db/GuildActivityCityDeclare.ts

@@ -1,7 +1,7 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
-@index({ serverId: 1, cityId: 1, createdAt: 1   })
+@index({ serverId: 1, guildCode: 1, status: 1, declareIndex: 1  })
 export default class GuildActivityCityDeclare extends BaseModel {
 
     @prop({ required: true })
@@ -30,7 +30,7 @@ export default class GuildActivityCityDeclare extends BaseModel {
 
     // 宣战
     public static async declareIfNot(serverId: number, guildCode: string, cityId: number, roleId: string, declareTime: number, isAutoDeclare: boolean, declareIndex: number) {
-        let rec: GuildActivityCityDeclareType = await GuildActivityCityDeclareModel.findOneAndUpdate({ serverId, guildCode, cityId, status: 1, declareIndex }, { $setOnInsert: { declareMember: roleId, declareTime, isAutoDeclare } }, { new: true, upsert: true }).lean();
+        let rec: GuildActivityCityDeclareType = await GuildActivityCityDeclareModel.findOneAndUpdate({ serverId, guildCode, status: 1, declareIndex }, { $setOnInsert: { declareMember: roleId, declareTime, isAutoDeclare, cityId } }, { new: true, upsert: true }).lean();
         return rec;
     }
 

shared/db/ServerRecords.ts

@@ -77,6 +77,11 @@ export default class ServerRecord extends BaseModel {
     return rec;
   }
 
+  public static async findTomorrowData(serverId: number) {
+    let tomorrow = getZeroPoint() + 86400;
+    let rec: ServerRecordType = await ServerRecordModel.findOne({ serverId, today: tomorrow }).lean();
+    return rec;
+  }
 }
 
 export const ServerRecordModel = getModelForClass(ServerRecord);

shared/domain/battleField/guildActivity.ts

@@ -55,6 +55,10 @@ export class WoodenHorseMember {
     setReceived(hasReceiveInitItems: boolean) {
         this.hasReceiveInitItems = hasReceiveInitItems;
     }
+
+    updateSid(sid: string) {
+        this.sid = sid;
+    }
 }
 
 // 木牛流马
@@ -267,6 +271,13 @@ export class WoodenHorse {
         }
     }
 
+    public updateMemberSid(roleId: string, sid: string) {
+        let index = this.members.findIndex(cur => cur.roleId == roleId);
+        if(index != -1) {
+            this.members[index].updateSid(sid);
+        }
+    }
+
     public setRemainItem(id: number, remain: number, max: number) {
         this.remainItems.set(id, { total: remain, max });
     }