diff --git a/game-server/app/servers/gm/handler/gmHandler.ts b/game-server/app/servers/gm/handler/gmHandler.ts
index 49473adf1..5be4e34b9 100644
--- a/game-server/app/servers/gm/handler/gmHandler.ts
+++ b/game-server/app/servers/gm/handler/gmHandler.ts
@@ -315,14 +315,6 @@ export class GmHandler {
         await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(aid);
         await pinus.app.rpc.guild.guildActivityRemote.clearActivityObj.broadcast();
 
-        // 清空旧数据
-        if (day <= 2) {
-            await GuildActivityCityModel.clearGuardAndStartNext();
-            await GuildActivityCityDeclareModel.clearDeclare();
-        }
-        if(aid != 0) await delGuildActivityRank(aid);
-        await GuildActivityRecordModel.updateTodayInfo({ status: 2 });
-
         // 开启定时器
         await pinus.app.rpc.systimer.systimerRemote.setAuctionSchedule.broadcast();
         await pinus.app.rpc.systimer.systimerRemote.setGuildActivitySchedule.broadcast();
diff --git a/game-server/app/servers/guild/handler/cityActivityHandler.ts b/game-server/app/servers/guild/handler/cityActivityHandler.ts
index 4ea39a41f..ac89cbbc8 100644
--- a/game-server/app/servers/guild/handler/cityActivityHandler.ts
+++ b/game-server/app/servers/guild/handler/cityActivityHandler.ts
@@ -1,16 +1,15 @@
 import { Application, ChannelService, BackendSession, pinus, HandlerService, } from "pinus";
-import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, GUILD_POINT_WAYS, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../../consts";
+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 { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, getPreDayActiveData, sendGuildCityDeclare, declareCity, autoDeclareMyCity } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, getPreDayActiveData, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex } from "../../../services/guildActivity/guildActivityService";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { gameData } from "../../../pubUtils/data";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
-import { leaveCityChannel, addRoleToCityChannel, getCityChannelSid } from "../../../services/chatService";
+import { leaveCityChannel, addRoleToCityChannel } from "../../../services/chatService";
 import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
 import { nowSeconds, getTimeFun } from "../../../pubUtils/timeUtil";
 import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
 import { getGoldObject, handleCost } from "../../../services/role/rewardService";
-import { addActive } from "../../../services/guildService";
 import { Rank } from "../../../services/rankService";
 import { checkTask } from "../../../services/task/taskService";
 import { guildInter } from "../../../pubUtils/interface";
@@ -36,22 +35,28 @@ export class CityActivityHandler {
     // 进入诸侯混战
     async getCityActivity(msg: {}, session: BackendSession) {
         const roleId = session.get('roleId');
-        // const roleName = session.get('roleName');
+        const roleName = session.get('roleName');
         const serverId = session.get('serverId');
         const guildCode = session.get('guildCode');
+        let index = getGAIndexInPinus(this.aid);
+        let declareIndex = getDeclareIndex();
 
         let statusResult = getGuildActivityStatus(this.aid);
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
         
-        if(statusResult.status == GUILD_ACTIVITY_STATUS.START) {
-            await autoDeclareMyCity(serverId, roleId, guildCode);
+        let obj = getCityActivityObj();
+        if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) {
+            await autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
         }
-        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
         let cities = getCities(guildCode, dbCities);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
+        let ranks = await getCityActivityRank(guildCode, serverId, guildActivityRec?.challengeCityId, roleId, roleName);
 
         return resResult(STATUS.SUCCESS, {
             ...statusResult,
-            cities
+            cities,
+            ...ranks
         });
     }
 
@@ -65,6 +70,8 @@ export class CityActivityHandler {
         let sid = session.get('sid');
 
         const { cityId } = msg;
+        let index = getGAIndexInPinus(this.aid);
+        let declareIndex = getDeclareIndex();
 
         let statusResult = getGuildActivityStatus(this.aid);
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
@@ -74,7 +81,7 @@ export class CityActivityHandler {
         let obj = getCityActivityObj();
         let {gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId);
 
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
         if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
 
         let myGuildActivityRec = await UserGuildActivityRecModel.findByRoleId(roleId, guildActivityRec.code);
@@ -83,7 +90,7 @@ export class CityActivityHandler {
             challengeTime = myGuildActivityRec.challengeTime;
         }
 
-        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
         let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
         if (cityStatus == CITY_STATUS.DECLARED) {
             obj.pushGuild(guildCode, serverId, cityId);
@@ -120,17 +127,18 @@ export class CityActivityHandler {
         let dicCity = gameData.cityActivity.get(cityId);
         if (dicCity.preCity.length > 0) return resResult(STATUS.CAN_NOT_DECLARE);
 
-        let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode);
+        let declareIndex = getDeclareIndex();
+        let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
         if (!!checkResult) return resResult(STATUS.HAS_DECLARED);
-        let curCity = await GuildActivityCityModel.getCity(serverId, cityId);
+        let curCity = await GuildActivityCityModel.getCity(serverId, cityId, declareIndex);
         if (curCity && curCity.guardGuildCode) {
             return resResult(STATUS.CITY_IS_GUARD);
         }
 
-        let declareResult = await declareCity(serverId, roleId, guildCode, cityId, false);
+        let declareResult = await declareCity(serverId, roleId, guildCode, cityId, false, declareIndex);
         if(!declareResult) return resResult(STATUS.HAS_DECLARED);
 
-        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
         let cities = getCities(guildCode, dbCities);
         return resResult(STATUS.SUCCESS, { cities });
     }
@@ -145,10 +153,12 @@ export class CityActivityHandler {
         const serverId = session.get('serverId');
         const guildCode = session.get('guildCode');
         const sid = session.get('sid');
+        let index = getGAIndexInPinus(this.aid);
+        let declareIndex = getDeclareIndex();
 
         if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode);
+        let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
         if (!checkResult) return resResult(STATUS.HAS_NOT_DECLARED);
 
         let obj = getCityActivityObj();
@@ -162,7 +172,7 @@ export class CityActivityHandler {
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
         if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
 
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index, [], cityId);
         if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
 
         let { code: sourceCode } = guildActivityRec;
@@ -180,10 +190,10 @@ export class CityActivityHandler {
         obj.pushMembers(guildCode, roleId, userGuild.job, myGuildActivityRec.code);
 
         // 返回当前军团总军功
-        let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
+        let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
         let guildScore = await r.getMyScore({ guildCode });
 
-        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
         let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
         // 全服活跃统计
         await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
@@ -212,10 +222,11 @@ export class CityActivityHandler {
         const serverId = session.get('serverId');
         const guildCode = session.get('guildCode');
         const sid = session.get('sid');
+        let index = getGAIndexInPinus(this.aid);
 
         if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
         if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
 
         let { code: sourceCode } = guildActivityRec;
@@ -261,18 +272,27 @@ export class CityActivityHandler {
             })
         }
 
-        let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage });
+        let challengeTime = nowSeconds() + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
+        if(isDebugTime()) {
+            let guilds = pinus.app.getServersByType('guild');
+            let guild = dispatch(roleId, guilds, 'guild');
+            let currentTime = await pinus.app.rpc.guild.guildActivityRemote.getCurrentTime.toServer(guild.id);
+            challengeTime = Math.floor(currentTime/1000) + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
+        }
+
+        let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage }, challengeTime);
         if (!pushResult) return resResult(STATUS.WRONG_PARMS);
 
-        let tomorrow = <number>getTimeFun().getAfterDayWithHour();
+        let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
         // 更新redis数据
-        let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
+        let index = getGAIndexInPinus(this.aid);
+        let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
         let myScore = await myR.setRankWithRoleInfo(roleId, damage, obj.getTimeGap(), null, true);
-        await myR.setExpire(tomorrow);
+        await myR.setExpire(nextWeek);
 
-        let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
+        let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
         let guildScore = await r.setRankWithGuildInfo(guildCode, damage, obj.getTimeGap(), null, true);
-        await r.setExpire(tomorrow);
+        await r.setExpire(nextWeek);
 
         ({gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId, -1 * damage));
         if (gateHp <= 0) {
@@ -322,9 +342,10 @@ export class CityActivityHandler {
         if (!myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
 
         // 返回当前军团总军功
-        let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
+        let index = getGAIndexInPinus(this.aid);
+        let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
         let myScore = await myR.getMyScore({ roleId });
-        let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
+        let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
         let guildScore = await r.getMyScore({ guildCode });
         let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
 
@@ -339,16 +360,4 @@ export class CityActivityHandler {
             challengeTime: myGuildActivityRec.challengeTime
         });
     }
-
-    // ! 测试接口
-    async debugResetCity(msg: { }, session: BackendSession) {
-        let guildCode = session.get('guildCode');
-        await GuildActivityCityDeclareModel.clearDeclare();
-        await GuildActivityCityModel.findOneAndUpdate(
-            { declareGuilds: { $in: [guildCode] } }, 
-            { $set: { guardGuildCode: "", guardGuildName: "", declareCount: 0, declareGuilds: [] } }, 
-            { new: true }).lean();
-
-        return resResult(STATUS.SUCCESS);
-    }
 }
\ No newline at end of file
diff --git a/game-server/app/servers/guild/handler/gateActivityHandler.ts b/game-server/app/servers/guild/handler/gateActivityHandler.ts
index f60646604..2b4fa3d0e 100644
--- a/game-server/app/servers/guild/handler/gateActivityHandler.ts
+++ b/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 } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getRecordScore, getGateActivityObj, participants, getGateActivityRank, getCityActivityObj, 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";
@@ -36,12 +36,13 @@ export class GateActivityHandler {
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');
         const guildCode = session.get('guildCode');
+        let index = getGAIndexInPinus(this.aid);
         if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         let statusResult = getGuildActivityStatus(this.aid);
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
 
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
         if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
 
         let { code: sourceCode } = guildActivityRec;
@@ -69,12 +70,13 @@ export class GateActivityHandler {
         const sid = session.get('sid');
         if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
         let obj = getGateActivityObj();
+        let index = getGAIndexInPinus(this.aid);
 
         let statusResult = getGuildActivityStatus(this.aid);
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
         if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
 
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
         if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
 
         let { code: sourceCode } = guildActivityRec;
@@ -89,7 +91,7 @@ export class GateActivityHandler {
         obj.pushMembers(guildCode, serverId, roleId, userGuild.job, code);
 
         // 返回当前军团总军功
-        let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
+        let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
         let guildScore = await r.getMyScore({ guildCode });
         // 全服活跃统计
         await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
@@ -132,15 +134,17 @@ export class GateActivityHandler {
         let { score, newRecords, memberRecord: newMemberRecord } = scoreResult;
         obj.setMemberRecord(code, newMemberRecord);
 
-        let tomorrow = <number>getTimeFun().getAfterDayWithHour();
+        let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
+        console.log('####### nextWeek', nextWeek)
+        let index = getGAIndexInPinus(this.aid);
         // 更新redis数据
-        let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
+        let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
         let myScore = await myR.setRankWithRoleInfo(roleId, score, obj.getTimeGap(), null, true);
-        await myR.setExpire(tomorrow);
+        await myR.setExpire(nextWeek);
 
-        let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
+        let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
         let guildScore = await r.setRankWithGuildInfo(guildCode, score, obj.getTimeGap(), null, true);
-        await r.setExpire(tomorrow);
+        await r.setExpire(nextWeek);
 
         // 更新数据库
         let rec = await UserGuildActivityRecModel.pushRecord(code, newRecords, round);
@@ -183,7 +187,8 @@ export class GateActivityHandler {
             }
         }
 
-        let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
+        let index = getGAIndexInPinus(this.aid);
+        let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
         let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
         if (isSuccess && statusResult.status == GUILD_ACTIVITY_STATUS.START) {
             let obj = getGateActivityObj();
@@ -263,7 +268,6 @@ export class GateActivityHandler {
         for (let server of guildServers) {
             pinus.app.rpc.guild.guildActivityRemote.updateGuildActivityData.toServer(server.id, aid, true);
         }
-        await GuildActivityRecordModel.updateTodayInfo({ status: 2 });
 
         return resResult(STATUS.SUCCESS);
     }
@@ -317,9 +321,10 @@ export class GateActivityHandler {
         if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
         let serverId = session.get('serverId');
         let { aid } = msg;
-        await GuildActivityRecordModel.getRecord(guildCode, serverId, aid);
+        let index = getGAIndexInPinus(aid);
+        await GuildActivityRecordModel.getRecord(guildCode, serverId, aid, index);
         let userGuild = await UserGuildModel.getMyGuild(roleId);
-        let result = await GuildActivityRecordModel.updateInfo(guildCode, aid, { memberCnt: 1, members: [{ roleId, job: userGuild.job, code: '' }], auctionType: aid + 1 });
+        let result = await GuildActivityRecordModel.updateInfo(guildCode, aid, index, { memberCnt: 1, members: [{ roleId, job: userGuild.job, code: '' }], auctionType: aid + 1 });
 
         return resResult(STATUS.SUCCESS, {
             sourceType: result.auctionType,
diff --git a/game-server/app/servers/guild/handler/raceActivityHandler.ts b/game-server/app/servers/guild/handler/raceActivityHandler.ts
index 9cc63d3f4..124c4b11a 100644
--- a/game-server/app/servers/guild/handler/raceActivityHandler.ts
+++ b/game-server/app/servers/guild/handler/raceActivityHandler.ts
@@ -1,7 +1,7 @@
 import { Application, ChannelService, BackendSession, HandlerService, } 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, calWoodenHorseAndSend, raceActivitySettleReward } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getRaceActivityObj, getWoodenHorseList, calWoodenHorseAndSend, raceActivitySettleReward, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -51,7 +51,8 @@ export class RaceActivityHandler {
         if(obj.status == RACE_ACTIVITY_STATUS.START) {
             ranks = await obj.getRanks(serverId, guildCode);
         } else {
-            let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
+            let index = getGAIndexInPinus(this.aid);
+            let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId, index });
             r.setGenerFieldsFun(function (param: GuildRankInfo) {
                 let { rank, code, name, num, num1, num2 } = param;
                 return { rank, code, name, num, time: Math.floor(num1/1000), durability: num2 };
@@ -80,6 +81,7 @@ export class RaceActivityHandler {
         const guildCode = session.get('guildCode');
         const sid = session.get('sid');
         if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
+        let index = getGAIndexInPinus(this.aid);
 
         let statusResult = getGuildActivityStatus(this.aid);
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
@@ -92,7 +94,7 @@ export class RaceActivityHandler {
         }
 
 
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, obj.getEvents(guildCode, 0));
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index, obj.getEvents(guildCode, 0));
         if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
 
         let { code: sourceCode } = guildActivityRec;
@@ -160,6 +162,7 @@ export class RaceActivityHandler {
         let serverId = session.get('serverId');
         let guildCode = session.get('guildCode');
         let sid = session.get('sid');
+        let index = getGAIndexInPinus(this.aid);
 
         let { id, count, toGuild } = msg;
         if (!count || count < 0) return resResult(STATUS.WRONG_PARMS);
@@ -170,7 +173,7 @@ export class RaceActivityHandler {
         let event = await obj.useItem(serverId, roleId, sid, guildCode, toGuild, id, count);
         if (!event) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
 
-        await GuildActivityRecordModel.pushEvent(guildCode, this.aid, event);
+        await GuildActivityRecordModel.pushEvent(guildCode, this.aid, index, event);
 
         return resResult(STATUS.SUCCESS, {
             timestamp: Date.now(),
@@ -183,14 +186,14 @@ export class RaceActivityHandler {
         let guildCode = session.get('guildCode');
         let serverId = session.get('serverId');
         
-
         let { code, isSuccess } = msg;
+        let index = getGAIndexInPinus(this.aid);
 
         let statusResult = getGuildActivityStatus(this.aid);
         if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
 
         // 更新userGuildActivityRecord
-        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
         let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true });
         if (!guildActivityRec || !myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
 
diff --git a/game-server/app/servers/guild/remote/guildActivityRemote.ts b/game-server/app/servers/guild/remote/guildActivityRemote.ts
index f2e5c5cd3..4dd7a7d1f 100644
--- a/game-server/app/servers/guild/remote/guildActivityRemote.ts
+++ b/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, gateActivityStart, cityActivityStart, clearActivityObj } from '../../../services/guildActivity/guildActivityService';
+import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, clearActivityObj, getGAPinusName, getCurGuildActivityIndexByDb, initGuildActivityIndexInPinus, setGuildActivityIndexInPinus, guildActivityStart } from '../../../services/guildActivity/guildActivityService';
 import { gameData } from '../../../pubUtils/data';
 import { setWeek } from '../../../pubUtils/timeUtil';
 import { sendUngotDividend } from '../../../services/auctionService';
@@ -15,6 +15,7 @@ export class GuildActivityRemote {
 
     constructor(private app: Application) {
         this.app = app;
+        initGuildActivityIndexInPinus();
     }
 
     private currentTime: number = Date.now();
@@ -61,13 +62,9 @@ export class GuildActivityRemote {
     /**
      * 诸侯混战和蛮夷入侵开始
      */
-     async gateAndCityActivityStart(aid: number) {
+     async guildActivityStart(aid: number) {
         try {
-            if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
-                await gateActivityStart();
-            } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
-                await cityActivityStart();
-            }
+            await guildActivityStart(aid);
         } catch(e) {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
@@ -184,4 +181,12 @@ export class GuildActivityRemote {
             errlogger.error(`remote ${__filename} \n ${e.stack}`);
         }
     }
+
+    async setGuildActivityIndex(aid: number, index: number) {
+        try {
+            setGuildActivityIndexInPinus(aid, index);
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
 }
\ No newline at end of file
diff --git a/game-server/app/servers/systimer/remote/systimerRemote.ts b/game-server/app/servers/systimer/remote/systimerRemote.ts
index 4a0eff63d..b1e99e864 100644
--- a/game-server/app/servers/systimer/remote/systimerRemote.ts
+++ b/game-server/app/servers/systimer/remote/systimerRemote.ts
@@ -4,7 +4,7 @@ import PvpDefenseType from '../../../db/PvpDefense';
 import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
 import { reloadResources } from '../../../pubUtils/data';
 import { setMarquee, cancelMarquee } from '../../../services/gmService';
-import { setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivity/guildActivityService';
+import { initGuildActivityIndexInPinus, setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivity/guildActivityService';
 import { setWeek } from '../../../pubUtils/timeUtil';
 import { ServerlistType } from '../../../db/Serverlist';
 import { MarqueeType } from '../../../db/Marquee';
@@ -15,7 +15,7 @@ import { MailType } from '../../../db/Mail';
 import { GroupMailType } from '../../../db/GroupMail';
 import { ServerMailType } from '../../../db/ServerMail';
 import { ActivityModelType } from '../../../db/Activity';
-import { LADDER_STATUS } from '../../../consts';
+import { GUILD_ACTIVITY_TYPE, LADDER_STATUS } from '../../../consts';
 
 export default function (app: Application) {
     return new SystimerRemote(app);
@@ -26,6 +26,7 @@ export class SystimerRemote {
     constructor(private app: Application) {
         this.app = app;
         this.channelService = app.get('channelService');
+        initGuildActivityIndexInPinus();
     }
     private channelService: ChannelService;
 
diff --git a/game-server/app/services/guildActivity/cityActivityObj.ts b/game-server/app/services/guildActivity/cityActivityObj.ts
index 729d5b9b5..878e8d8f2 100644
--- a/game-server/app/services/guildActivity/cityActivityObj.ts
+++ b/game-server/app/services/guildActivity/cityActivityObj.ts
@@ -1,10 +1,12 @@
 // 军团活动蛮夷入侵城门血量等数据存储
 
+import { GUILD_ACTIVITY_STATUS } from "../../consts";
 import { Member } 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}]
@@ -39,6 +41,11 @@ export class CityActivityObject {
 
     public startActivity() {
         this.startTime = Date.now();
+        this.guildActivityStatus = GUILD_ACTIVITY_STATUS.START;
+    }
+
+    public endActivity() {
+        this.guildActivityStatus = GUILD_ACTIVITY_STATUS.END;
     }
 
     public getTimeGap() {
diff --git a/game-server/app/services/guildActivity/guildActivityService.ts b/game-server/app/services/guildActivity/guildActivityService.ts
index bf344ad12..5096c261b 100644
--- a/game-server/app/services/guildActivity/guildActivityService.ts
+++ b/game-server/app/services/guildActivity/guildActivityService.ts
@@ -3,7 +3,7 @@ import { RoleModel } from "../../db/Role";
 import { GUILDACTIVITY } from "../../pubUtils/dicParam";
 import { gameData, getGuildAuctionRewards, getCityActivityRewards, getGuildAuctionBasicNum } from "../../pubUtils/data";
 import { getCurDay, nowSeconds, getTimeFun, getZeroPoint } from "../../pubUtils/timeUtil";
-import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS, DEBUG_MAGIC_WORD, GUILD_POINT_WAYS, TASK_TYPE, AUCTION_TIME, CITY_ACTIVITY_DOOR, ABI_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS, SHOP_REFRESH_TYPE } from "../../consts";
+import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS, DEBUG_MAGIC_WORD, GUILD_POINT_WAYS, TASK_TYPE, AUCTION_TIME, CITY_ACTIVITY_DOOR, ABI_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS, SHOP_REFRESH_TYPE, COUNTER } from "../../consts";
 import { Record, UserGuildActivityRecModel } from "../../db/UserGuildActivityRec";
 import { GateMembersRec, CityParam, Member, WoodenHorse, RaceActivityRankParam } from "../../domain/battleField/guildActivity";
 import { DicGuildActivity } from "../../pubUtils/dictionary/DicGuildActivity";
@@ -29,6 +29,7 @@ import { sendMessageToCityWithSuc, sendMessageToGuildWithSuc, sendMessageToServe
 import { saveGuildGateHpLog } from "../../pubUtils/logUtil";
 import { GuildActivityCityDeclareModel } from "../../db/GuildActivityCityDeclare";
 import { getRandSingleEelm } from "../../pubUtils/util";
+import { CounterModel } from "../../db/Counter";
 
 let gateActivityObj: GateActivityObject;
 let cityActivityObj: CityActivityObject;
@@ -116,10 +117,11 @@ export function getGuildActivityStatus(id: number) {
 export async function getAllGuildActivityStatus(guildCode: string, serverId: number) {
     let guildActivities: { aid: number, status: number, time: number, isOpen: boolean, isCompleted?: boolean }[] = [];
     for(let [ aid, dicGuildActivity ] of gameData.guildActivity) {
+        let index = getGAIndexInPinus(aid);
         let res = getGuildActivityByDic(dicGuildActivity);
         let isCompleted = res.isOpen;
         if(res.status == GUILD_ACTIVITY_STATUS.START && guildCode) {
-            let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, aid);
+            let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, aid, index);
             if(guildActivityRec) isCompleted = guildActivityRec.isCompleted;
         }
         guildActivities.push({aid, ...res, isCompleted});
@@ -193,14 +195,15 @@ export function getRecordScore(aid: number, round: number, record: { round: numb
 
 export async function getGateActivityRank(guildCode: string, serverId: number, roleId?: string, roleName?: string) {
 
-    let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
+    let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
+    let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
     r.setGenerFieldsFun(generGuildActivityRankField);
     let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
     if (!myGuildRank) {
         myGuildRank = await r.generMyRankWithGuild(guildCode, 0, 0);
     }
 
-    let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
+    let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
     myR.setGenerFieldsFun(generGuildActivityMemberRankField);
     let { ranks: memberRank, myRank: myMemberRank } = await myR.getRankListWithMyRank({ roleId });
     if (roleName && !myMemberRank) {
@@ -212,14 +215,18 @@ export async function getGateActivityRank(guildCode: string, serverId: number, r
 
 export async function getCityActivityRank(guildCode: string, serverId: number, cityId: number, roleId?: string, roleName?: string) {
 
-    let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
+    if(!cityId) {
+        return { guildRank: [], myGuildRank: undefined, memberRank: [], myMemberRank: undefined }
+    }
+    let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
+    let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
     r.setGenerFieldsFun(generGuildActivityRankField);
     let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
     if (!myGuildRank) {
         myGuildRank = await r.generMyRankWithGuild(guildCode, 0, 0);
     }
 
-    let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
+    let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
     myR.setGenerFieldsFun(generGuildActivityMemberRankField);
     let { ranks: memberRank, myRank: myMemberRank } = await myR.getRankListWithMyRank({ roleId });
     if (roleName && !myMemberRank) {
@@ -306,6 +313,7 @@ export async function settleGuildActivityReward(aid: number) {
         }
     } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
         let obj = getCityActivityObj();
+        obj.endActivity();
         let { cities } = obj.getAllCities();
         for (let { serverId, cityId } of cities) {
             await cityActivitySettleReward(cityId, serverId);
@@ -376,7 +384,8 @@ export async function gateActivitySettleReward(guildCode: string, serverId: numb
     let { members } = obj.getObj(guildCode, serverId);
     // console.log('***** gateHp', gateHp, 'members', members);
 
-    let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
+    let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
+    let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
     let rank = await r.getMyRank({ guildCode });
     let guildScore = await r.getMyScore({ guildCode });
     // console.log('****** ranks', rank, 'guildScore', guildScore);
@@ -384,7 +393,7 @@ export async function gateActivitySettleReward(guildCode: string, serverId: numb
     let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, rank);
     // console.log('***** rewards', JSON.stringify(rewards));
 
-    let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, {
+    let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, index, {
         isSuccess: true,
         isCompleted: true,
         rank, score: guildScore,
@@ -395,7 +404,7 @@ export async function gateActivitySettleReward(guildCode: string, serverId: numb
     // 结算功勋等奖励
     let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
 
-    let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
+    let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
 
     let hasSentMember: string[] = [];
     let ranks = <RoleRankInfo[]>await myR.getRankByRange();
@@ -444,21 +453,23 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
     let {gateHp} = await obj.getGateHpAndInc(serverId, cityId);
     let isSuccess = gateHp <= 0; // 血条未击破则没有占领军团
 
-    let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
+    let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
+    let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
     let ranks = <GuildRankInfo[]>await r.getRankByRange();
+    console.log('###### cityActivitySettleReward', ranks)
     for (let { rank: guildRank, code: guildCode, name, num } of ranks) {
         if (guildRank == 1) {
             if (isSuccess) {
-                await GuildActivityCityModel.guard(serverId, cityId, guildCode, name); // 占领
-                await declareCity(serverId, "", guildCode, dicCity.nextCity, true);
+                await GuildActivityCityModel.guard(serverId, cityId, guildCode, name, index + 1); // 占领
+                await declareCity(serverId, "", guildCode, dicCity.nextCity, true, index + 1);
             } else {
-                await GuildActivityCityModel.guard(serverId, cityId, "", ""); // 无人能占领
+                await GuildActivityCityModel.guard(serverId, cityId, "", "", index + 1); // 无人能占领
             }
         }
         let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, guildRank, cityId);
         let members = obj.getMembersOfGuild(guildCode);
 
-        let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, {
+        let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, index, {
             memberCnt: members.length, members,
             isSuccess, isCompleted: true,
             rank: guildRank, damage: num, remainGateHp: gateHp,
@@ -470,7 +481,7 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
         await genAuction(guildCode, AUCTION_SOURCE.CITY, rec.code, serverId, rewards);
 
         let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
-        let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
+        let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
         let ranks = <RoleRankInfo[]>await myR.getRankByRange();
         let userRank = 0;
         let hasSentMember: string[] = [];
@@ -496,12 +507,7 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
     obj.delCityRecord(cityId, serverId);
 }
 
-/**
- * 清空完declareGuilds之后，做下一次活动的自动宣战
- */
 export async function autoDeclare(serverId: number) {
-    await GuildActivityCityModel.clearGuardAndStartNext(serverId);
-    await GuildActivityCityDeclareModel.clearDeclare(serverId);
     for(let [ cityId ] of gameData.cityActivity) {
         let msg = { cityId, declareGuildCode: "", declareCount: 0 };
         await sendMessageToCityWithSuc(cityId, PUSH_ROUTE.GUILD_CITY_DECLARE, msg);
@@ -533,7 +539,7 @@ export async function participants(guildCode: string, sourceType: number, source
         let rec = await GuildActivityRecordModel.findBySourceCode(guildCode, sourceType, sourceCode);
         if (!rec) return [];
 
-        let baseNum = getGuildAuctionBasicNum(rec.aid, rec.rank, rec.cityId);
+        let baseNum = getGuildAuctionBasicNum(rec.aid, rec.rank, rec.challengeCityId);
         let members = rec.members || [];
         return members.map(cur => {
             return { roleId: cur.roleId, job: cur.job, baseNum }
@@ -594,7 +600,7 @@ export function getCityStatus(guildCode: string, cityId: number, dic: DicCityAct
     if (curCity) {
         if (curCity.guardGuildCode == guildCode) {
             status = CITY_STATUS.GUARD;
-        } else if (curCity.declareGuilds.includes(guildCode)) {
+        } else if (curCity.declareGuilds?.includes(guildCode)) {
             status = CITY_STATUS.DECLARED;
         }
     }
@@ -640,14 +646,15 @@ export async function sendRaceStartMsg(serverId: number) {
     await calWoodenHorseAndSend(serverId);
 }
 
-export async function cityActivityStart() {
-    let obj = getCityActivityObj();
-    obj.startActivity();
-}
-
-export async function gateActivityStart() {
-    let obj = getGateActivityObj();
-    obj.startActivity();
+export async function guildActivityStart(aid: number) {
+    if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
+        let obj = getGateActivityObj();
+        obj.startActivity();
+    } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
+        let obj = getCityActivityObj();
+        obj.startActivity();
+    } else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+    }
 }
 
 /**
@@ -663,16 +670,17 @@ export async function raceActivitySettleReward(guildCode: string, woodenHorse: W
     let { guildRank, myGuildRank } = await obj.getRanks(serverId, guildCode);
     let rank = myGuildRank?.rank||0;
 
-    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
+    let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
+    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId, index });
     await r.setRankWithGuildInfo2(guildCode, myGuildRank.num, myGuildRank.sortTime, myGuildRank.durability);
-    let tomorrow = <number>getTimeFun().getAfterDayWithHour();
-    await r.setExpire(tomorrow);
+    let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
+    await r.setExpire(nextWeek);
 
     let isSuccess = distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH; // 血条未击破则没有占领军团
     let members = obj.getMembersOfGuild(guildCode);
 
     let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, rank);
-    let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, {
+    let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, index, {
         memberCnt: members.length, members,
         isSuccess, isCompleted: true, rank,
         rewards: rewards.map(cur => cur.goods),
@@ -788,11 +796,11 @@ export async function getCityActivityGateHp(serverId: number, cityId: number) {
     return gateHp;
 }
 
-export async function declareCity(serverId: number, roleId: string, guildCode: string, cityId: number, isAutoDeclare: boolean) {
+export async function declareCity(serverId: number, roleId: string, guildCode: string, cityId: number, isAutoDeclare: boolean, declareIndex: number) {
     let declareTime = Date.now();
-    let declareInfo = await GuildActivityCityDeclareModel.declareIfNot(serverId, guildCode, cityId, roleId, declareTime, isAutoDeclare);
+    let declareInfo = await GuildActivityCityDeclareModel.declareIfNot(serverId, guildCode, cityId, roleId, declareTime, isAutoDeclare, declareIndex);
     if(!!declareInfo && declareInfo.declareTime == declareTime) { // 确实没有人宣战过，自己是第一个
-        let cityRec = await GuildActivityCityModel.declare(serverId, cityId, guildCode);
+        let cityRec = await GuildActivityCityModel.declare(serverId, cityId, guildCode, declareIndex);
         await sendGuildCityDeclare(cityId, guildCode, cityRec.declareCount);
         return true;
     }
@@ -800,17 +808,66 @@ export async function declareCity(serverId: number, roleId: string, guildCode: s
 }
 
 // 非军团长的团员自动宣战
-export async function autoDeclareMyCity(serverId: number, roleId: string, guildCode: string) {
-    let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode);
+export async function autoDeclareMyCity(serverId: number, roleId: string, guildCode: string, declareIndex: number) {
+    let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
     if(checkResult) return false
 
     let cityIds = gameData.juniorCities;
-    let cities = await GuildActivityCityModel.findMinDeclareCountCity(serverId, cityIds);
+    let cities = await GuildActivityCityModel.findMinDeclareCountCity(serverId, cityIds, declareIndex);
     let notDeclaredCitites = cityIds.filter(curCityId => {
         return cities.findIndex(city => city.cityId == curCityId) == -1;
     });
     let cityId = notDeclaredCitites.length > 0? getRandSingleEelm(notDeclaredCitites): cities[0].cityId;
     if(!cityId) return false;
 
-    return declareCity(serverId, roleId, guildCode, cityId, true);
+    return declareCity(serverId, roleId, guildCode, cityId, true, declareIndex);
+}
+
+function getCounterName(aid: GUILD_ACTIVITY_TYPE) {
+    switch(aid) {
+        case GUILD_ACTIVITY_TYPE.GATE_ACTIVITY:
+            return COUNTER.GATE_ACTIVITY;
+        case GUILD_ACTIVITY_TYPE.CITY_ACTIVITY:
+            return COUNTER.CITY_ACTIVITY;
+        case GUILD_ACTIVITY_TYPE.RACE_ACTIVITY:
+            return COUNTER.RACE_ACTIVITY;
+    }
+}
+
+export async function incCurGuildActivityIndex(aid: number) {
+    let name = getCounterName(aid);
+    let index = await CounterModel.getNewCounter(name);
+    setGuildActivityIndexInPinus(aid, index); // systime
+    pinus.app.rpc.guild.guildActivityRemote.setGuildActivityIndex.broadcast(aid, index);
+}
+
+export async function initGuildActivityIndexInPinus() {
+    for(let aid = GUILD_ACTIVITY_TYPE.GATE_ACTIVITY; aid <= GUILD_ACTIVITY_TYPE.RACE_ACTIVITY; aid++){
+        let index = await getCurGuildActivityIndexByDb(aid);
+        setGuildActivityIndexInPinus(aid, index);
+    }
+}
+
+export async function getCurGuildActivityIndexByDb(aid: number) {
+    let name = getCounterName(aid);
+    return await CounterModel.getCounter(name);
+}
+
+export function getGAPinusName(aid: number) {
+    return `guildact${aid}`;
+}
+
+export function setGuildActivityIndexInPinus(aid: number, index: number) {
+    pinus.app.set(getGAPinusName(aid), index);
+}
+
+export function getGAIndexInPinus(aid: number) {
+    return pinus.app.get(getGAPinusName(aid));
+}
+
+export function getDeclareIndex() {
+    let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
+    let obj = getCityActivityObj();
+    if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) return index;
+    return index + 1;
 }
\ No newline at end of file
diff --git a/game-server/app/services/timeTaskService.ts b/game-server/app/services/timeTaskService.ts
index 046453096..f4858d366 100644
--- a/game-server/app/services/timeTaskService.ts
+++ b/game-server/app/services/timeTaskService.ts
@@ -9,7 +9,7 @@ import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE,
 import { pinus } from 'pinus';
 import { settleGuildWeekly } from './guildService';
 import { SendMailFun, sendMailsByGmMail, } from './mailService';
-import { sendEndMsgToAllServer, autoDeclare, sendGuildActivityStatus, setPreDayActiveData } from './guildActivity/guildActivityService';
+import { sendEndMsgToAllServer, autoDeclare, sendGuildActivityStatus, setPreDayActiveData, incCurGuildActivityIndex } from './guildActivity/guildActivityService';
 import { sendUngotDividendJob, startGuildAuction, startWorldAuction, stopAuction } from './auctionService';
 import { DicGuildActivity } from '../pubUtils/dictionary/DicGuildActivity';
 import { dispatch } from '../pubUtils/dispatcher';
@@ -246,8 +246,6 @@ export async function guildActivitySchedule() {
     }
 
     let dicGuildActivity = getTodayGuildActivity();
-    await delGuildActivityRank(dicGuildActivity.id);
-
     // console.log(dicGuildActivity)
 
     guildActStartJobId = scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule);
@@ -274,17 +272,20 @@ export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
         guildActEndJobId.cancel();
         guildActEndJobId = undefined;
     }
-    if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
-        await pinus.app.rpc.guild.guildActivityRemote.gateAndCityActivityStart.broadcast(dicGuildActivity.id);
+
+    let aid = dicGuildActivity.id;
+    await incCurGuildActivityIndex(aid);
+    await pinus.app.rpc.guild.guildActivityRemote.guildActivityStart.broadcast(aid);
+
+    if (aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
         guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', gateActivitySeconds);
         // 结束时间
         guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, gateActivityEnd);
-    } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
-        await pinus.app.rpc.guild.guildActivityRemote.gateAndCityActivityStart.broadcast(dicGuildActivity.id);
+    } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
         guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', cityActivitySeconds);
         // 结束时间
         guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, cityActivityEnd);
-    } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+    } else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
 
         // 开始活动
         let guildServers = pinus.app.getServersByType('guild');
diff --git a/shared/consts/constModules/sysConst.ts b/shared/consts/constModules/sysConst.ts
index e7b6895fa..4e443d220 100644
--- a/shared/consts/constModules/sysConst.ts
+++ b/shared/consts/constModules/sysConst.ts
@@ -48,7 +48,10 @@ export const COUNTER = {
     NOTICE: { name: 'notice', def: 1 },
     GIFT_CODE: { name: 'giftCode', def: 1 },
     PVP_SEASON_NUM: { name: 'pvpSeason', def: 1 },
-    REGION: { name: 'region', def: 1 }
+    REGION: { name: 'region', def: 1 },
+    GATE_ACTIVITY: { name: 'guildAct', def: 1 },
+    CITY_ACTIVITY: { name: 'cityAct', def: 1 },
+    RACE_ACTIVITY: { name: 'raceAct', def: 1 }
 };
 
 export const DEFAULT_HEROES = [19, 53,];
diff --git a/shared/db/Counter.ts b/shared/db/Counter.ts
index 6ac266312..0b0733309 100644
--- a/shared/db/Counter.ts
+++ b/shared/db/Counter.ts
@@ -23,9 +23,9 @@ export default class Counter extends BaseModel {
   }
 
   public static async getCounter(param:{name: string, def: number}, lean = true) {
-    let {name, def:defaultVal} = param;
+    let {name} = param;
     let counter: CounterType = await CounterModel.findOne({ name }).lean(lean);
-    return counter?.seq||defaultVal;
+    return counter?.seq||0;
   }
 
 }
diff --git a/shared/db/GuildActivityCity.ts b/shared/db/GuildActivityCity.ts
index 446c7cc3a..0f610c4e7 100644
--- a/shared/db/GuildActivityCity.ts
+++ b/shared/db/GuildActivityCity.ts
@@ -10,6 +10,9 @@ export default class GuildActivityCity extends BaseModel {
     @prop({ required: true })
     cityId: number;       // 城池id
 
+    @prop({ required: true })
+    declareIndex: number;       // 城池id
+
     @prop({ required: true, type: String, default: [] })
     declareGuilds: string[];       // 宣战的公会的code
 
@@ -29,28 +32,27 @@ export default class GuildActivityCity extends BaseModel {
     status: number;       // 0-过去的 1-现在的 2-未来的
 
     // 每天宣战一次
-    public static async getAllCities(serverId: number) {
-        let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, status: 1 }).lean();
+    public static async getAllCities(serverId: number, declareIndex: number) {
+        let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, status: 1, declareIndex }).lean();
         
         return rec;
     }
 
-    public static async findMinDeclareCountCity(serverId: number, cityIds: number[]) {
-        let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, cityId: { $in: cityIds }, status: 1 }).sort({ declareCount: 1 }).lean();
+    public static async findMinDeclareCountCity(serverId: number, cityIds: number[], declareIndex: number) {
+        let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, cityId: { $in: cityIds }, status: 1, declareIndex }).sort({ declareCount: 1 }).lean();
         return rec;
     }
 
-    public static async getCity(serverId: number, cityId: number) {
-        let rec: GuildActivityCityType = await GuildActivityCityModel.findOne({ serverId, cityId, status: 1}).lean();
+    public static async getCity(serverId: number, cityId: number, declareIndex: number) {
+        let rec: GuildActivityCityType = await GuildActivityCityModel.findOne({ serverId, cityId, status: 1, declareIndex }).lean();
         
         return rec;
     }
 
-
     // 宣言
-    public static async declare(serverId: number, cityId: number, guildCode: string) {
+    public static async declare(serverId: number, cityId: number, guildCode: string, declareIndex: number) {
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
-            { serverId, cityId, status: 1 }, 
+            { serverId, cityId, status: 1, declareIndex }, 
             { $push: { declareGuilds: guildCode }, $inc: {declareCount: 1 } }, 
             {new: true, upsert: true}).lean();
 
@@ -58,24 +60,13 @@ export default class GuildActivityCity extends BaseModel {
     }
 
     // 占领
-    public static async guard(serverId: number, cityId: number, guildCode: string, guildName: string) {
+    public static async guard(serverId: number, cityId: number, guildCode: string, guildName: string, declareIndex: number) {
         let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
-            { serverId, cityId, status: 1 }, 
+            { serverId, cityId, status: 1, declareIndex }, 
             { $set: { guardGuildCode: guildCode, guardGuildName: guildName, guardTime: new Date()} }, 
-            { new: true }).lean();
+            { new: true, upsert: true }).lean();
         return rec;
     }
-
-    // 活动结束后需要清空占领情况
-    public static async clearGuardAndStartNext(serverId?: number) {
-        if(serverId) {
-            await GuildActivityCityModel.updateMany({ serverId, status: 1 }, { $set: { status: 0 } });
-            await GuildActivityCityModel.updateMany({ serverId, status: 2 }, { $set: { status: 1 } });
-        } else {
-            await GuildActivityCityModel.updateMany({ status: 1 }, { $set: { status: 0 } });
-            await GuildActivityCityModel.updateMany({ status: 2 }, { $set: { status: 1 } });
-        }
-    }
 }
 
 export const GuildActivityCityModel = getModelForClass(GuildActivityCity);
diff --git a/shared/db/GuildActivityCityDeclare.ts b/shared/db/GuildActivityCityDeclare.ts
index f6b3931d6..831ceaa52 100644
--- a/shared/db/GuildActivityCityDeclare.ts
+++ b/shared/db/GuildActivityCityDeclare.ts
@@ -10,6 +10,9 @@ export default class GuildActivityCityDeclare extends BaseModel {
     @prop({ required: true })
     cityId: number;       // 城池id
 
+    @prop({ required: true })
+    declareIndex: number;       // 城池id
+
     @prop({ required: true })
     guildCode: string;       // 宣战的公会的code
 
@@ -26,25 +29,16 @@ export default class GuildActivityCityDeclare extends BaseModel {
     status: number;       // 状态 1-当前 0-失效，当活动结束时定时任务设为0
 
     // 宣战
-    public static async declareIfNot(serverId: number, guildCode: string, cityId: number, roleId: string, declareTime: number, isAutoDeclare: boolean) {
-        let rec: GuildActivityCityDeclareType = await GuildActivityCityDeclareModel.findOneAndUpdate({ serverId, guildCode, status: 1 }, { $setOnInsert: { cityId, declareMember: roleId, declareTime, isAutoDeclare } }, { new: true, upsert: true }).lean();
+    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();
         return rec;
     }
 
     // 检查是否宣战过
-    public static async checkDeclartion(serverId: number, guildCode: string) {
-        let rec = await GuildActivityCityDeclareModel.exists({ serverId, status: 1, guildCode});
+    public static async checkDeclartion(serverId: number, guildCode: string, declareIndex: number) {
+        let rec = await GuildActivityCityDeclareModel.exists({ serverId, status: 1, guildCode, declareIndex});
         return rec;
     }
-
-    // 清空今天的宣战
-    public static async clearDeclare(serverId?: number) {
-        if(serverId) {
-            await GuildActivityCityDeclareModel.updateMany({ serverId, status: 1}, { status: 0 });
-        } else {
-            await GuildActivityCityDeclareModel.updateMany({ status: 1}, { status: 0 });
-        }
-    }
 }
 
 export const GuildActivityCityDeclareModel = getModelForClass(GuildActivityCityDeclare);
diff --git a/shared/db/GuildActivityRec.ts b/shared/db/GuildActivityRec.ts
index 3c0d873a0..40cad09d6 100644
--- a/shared/db/GuildActivityRec.ts
+++ b/shared/db/GuildActivityRec.ts
@@ -1,7 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 import { ItemReward } from '../domain/dbGeneral';
-import { getZeroPointD } from '../pubUtils/timeUtil';
 import { genCode } from '../pubUtils/util';
 import { Member, WoodenHorse, Event } from '../domain/battleField/guildActivity'
 
@@ -11,7 +10,7 @@ export default class GuildActivityRecord extends BaseModel {
 
     @prop({ required: true })
     code: string;            // 本次记录唯一值
-    
+
     @prop({ required: true })
     guildCode: string;       // 军团code
 
@@ -24,6 +23,9 @@ export default class GuildActivityRecord extends BaseModel {
     @prop({ required: true })
     aid: number;             // 军团活动id
 
+    @prop({ required: true })
+    index: number;            // 第几次这个类型的军团活动
+
     @prop({ required: true })
     auctionType: number;             // 转为拍卖行的类型
 
@@ -51,6 +53,9 @@ export default class GuildActivityRecord extends BaseModel {
     @prop({ required: true })
     remainGateHp: number;           // 城门剩余血量
 
+    @prop({ required: true })
+    challengeCityId: number;           // 诸侯混战占领了的城池
+
     @prop({ required: true })
     cityId: number;           // 诸侯混战占领了的城池
 
@@ -64,42 +69,30 @@ export default class GuildActivityRecord extends BaseModel {
     events: Event[];   // 粮草先行木马
 
     // 每天一条记录
-    public static async getRecord(guildCode: string, serverId: number, aid: number, events?: Event[]) {
-        let today = getZeroPointD();
+    public static async getRecord(guildCode: string, serverId: number, aid: number, index: number, events?: Event[], cityId?: number) {
         let docs = new GuildActivityRecordModel();
         let code = genCode(10);
-        let update = Object.assign(docs, { code, guildCode, serverId, aid, createdAt: new Date(), auctionType: aid + 1 });
-        if(events) update = Object.assign(update, { events });
+        let insert = Object.assign(docs, { code, guildCode, serverId, aid, createdAt: new Date(), auctionType: aid + 1 });
+        if(events) insert = Object.assign(insert, { events });
+        let update: GuildActivityRecordUpdateParam = {};
+        if(cityId) update = Object.assign(update, { challengeCityId: cityId });
         let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
-            { aid, guildCode, createdAt: { $gte: today }, status: 1}, 
-            { $setOnInsert: update }, 
+            { aid, guildCode, index, status: 1}, 
+            { $setOnInsert: insert, $set: update }, 
             {new: true, upsert: true}).lean();
         return rec;
     }
     
-    public static async updateInfo(guildCode: string, aid: number, update: GuildActivityRecordUpdateParam) {
-        let today = getZeroPointD();
-
+    public static async updateInfo(guildCode: string, aid: number, index: number, update: GuildActivityRecordUpdateParam) {
         let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
-            { guildCode, aid, createdAt: { $gte: today }, status: 1 }, 
+            { guildCode, aid, index, status: 1 }, 
             { $set: update }, { new: true }).lean();
         return rec;
     }
 
-    public static async updateTodayInfo(update: GuildActivityRecordUpdateParam) {
-        let today = getZeroPointD();
-
-        let rec = await GuildActivityRecordModel.updateMany(
-            { createdAt: { $gte: today } }, 
-            { $set: update }, { new: true }).lean();
-        return rec;
-    }
-
-    public static async pushEvent(guildCode: string, aid: number, event: Event) {
-        let today = getZeroPointD();
-
+    public static async pushEvent(guildCode: string, aid: number, index: number, event: Event) {
         let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
-            { guildCode, createdAt: { $gte: today }, aid, status: 1 }, 
+            { guildCode, index, aid, status: 1 }, 
             { $push: { events: event } }, { new: true }).lean();
         return rec;
     }
diff --git a/shared/db/UserGuildActivityRec.ts b/shared/db/UserGuildActivityRec.ts
index 2e78204c3..bd95c56aa 100644
--- a/shared/db/UserGuildActivityRec.ts
+++ b/shared/db/UserGuildActivityRec.ts
@@ -129,10 +129,10 @@ export default class UserGuildActivityRec extends BaseModel {
         return rec;
     }
 
-    public static async pushCityRecord(code: string, damageRecord: DamageRecord) {
+    public static async pushCityRecord(code: string, damageRecord: DamageRecord, challengeTime: number) {
         let rec: UserGuildActivityRecType = await UserGuildActivityRecModel.findOneAndUpdate(
             { code }, 
-            { $push: { damageRecord }},
+            { $push: { damageRecord }, $set: { challengeTime }},
             { new: true }
         ).lean();
         return rec;
diff --git a/shared/domain/rank.ts b/shared/domain/rank.ts
index beaab9fb9..2e47fc6f0 100644
--- a/shared/domain/rank.ts
+++ b/shared/domain/rank.ts
@@ -289,6 +289,7 @@ export class KeyName {
     hid?: number;
     seasonNum?: number;
     activityId?: number;
+    index?: number;  // 军团活动第几期
 
     constructor(key: string, param: KeyNameParam) {
         this.key = key;
@@ -298,6 +299,7 @@ export class KeyName {
         if(param.hid) this.hid = param.hid;
         if(param.seasonNum) this.seasonNum = param.seasonNum;
         if(param.activityId) this.activityId = param.activityId;
+        if(param.index) this.index = param.index;
     }
 
     public getName() {
@@ -311,8 +313,6 @@ export class KeyName {
             case REDIS_KEY.MAIN_ELITE_RANK:
             case REDIS_KEY.GUILD_LV_RANK:
             case REDIS_KEY.GUILD_ACTIVE_RANK:
-            case REDIS_KEY.GATE_ACTIVITY:
-            case REDIS_KEY.RACE_ACTIVITY:
             case REDIS_KEY.TOWER_RANK:
             case REDIS_KEY.LADDER:
                 return `${this.key}:${this.serverId}`;
@@ -320,11 +320,14 @@ export class KeyName {
                 return `${this.key}:${this.serverId}:${this.hid}`;
             case REDIS_KEY.PVP_RANK:
                 return `${this.key}:${this.seasonNum}`;
+            case REDIS_KEY.GATE_ACTIVITY:
+            case REDIS_KEY.RACE_ACTIVITY:
+                return `${this.key}:${this.serverId}:${this.index}`;
             case REDIS_KEY.CITY_ACTIVITY:
-                return `${this.key}:${this.serverId}:${this.cityId}`;
+                return `${this.key}:${this.serverId}:${this.index}:${this.cityId}`;
             case REDIS_KEY.USER_CITY_ACTIVITY:
             case REDIS_KEY.USER_GATE_ACTIVITY:
-                return `${this.key}:${this.serverId}:${this.guildCode}`;
+                return `${this.key}:${this.serverId}:${this.index}:${this.guildCode}`;
             case REDIS_KEY.GUILD_FUND:
             case REDIS_KEY.SUM_CE_SNAPSHOT:
                 return `${this.key}:${this.serverId}:${this.activityId}`;
diff --git a/shared/pubUtils/data.ts b/shared/pubUtils/data.ts
index abda360eb..cb26a1747 100644
--- a/shared/pubUtils/data.ts
+++ b/shared/pubUtils/data.ts
@@ -662,7 +662,6 @@ export function getGuildAuctionRewards(aid: number, rank: number, cityId: number
 }
 
 export function getGuildAuctionBasicNum(aid: number, rank: number, cityId: number = 0) {
-    console.log('###### getGuildAuctionBasicNum', aid, rank, cityId)
     let dic = getGuildAuction(aid, rank, cityId);
     return dic?.basicDividend||0;
 }