军团活动：诸侯混战露出的接口

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

@@ -27,7 +27,9 @@ export class GuildRemote {
     private GUILD_REC_ADD = 'onGuildRecAdd';
     private GUILD_ACT_RANK = 'onGuildGateRankUpdate';    // 军团活动排行榜
     private GUILD_GATE_ACT_HP = 'onGuildGateHpUpdate';   // 军团活动蛮夷入侵排行榜
-    private GUILD_ACTIVITY_END = 'onGuildActivityEnd';
+    private GUILD_ACTIVITY_END = 'onGuildActivityEnd';    // 军团活动结束
+    private GUILD_CITY_DECLARE = 'onGuildCityDeclare';    // 有军团对这个城池进行宣战了
+    private GUILD_CITY_ACT_HP = 'onGuildCityGateHpUpdate'; // 诸侯入侵城门血条
 
     /**
      * 封装，军团相关channel名: 'guild'+guildCode
@@ -76,6 +78,31 @@ export class GuildRemote {
         return channel
     }
     
+    /**
+     * 诸侯混战，按城池区分channel
+     * @param cityId 城池id
+     * @param create 是否创建channel 
+     */
+    private getCityChannel(cityId: number, create: boolean = false) {
+        let channelName = groupRoomId(CHANNEL_PREFIX.CITY, cityId);
+        let channel = this.channelService.getChannel(channelName, create);
+        return channel
+    }
+
+    /**
+     * 封装，向channel发推送
+     * @param cityId 城池id
+     * @param path 推送地址
+     * @param message 推送信息
+     */
+    private pushMessageToCity(cityId: number, path: string, message: any) {
+        let channel = this.getCityChannel(cityId);
+        if(!!channel) {
+            channel.pushMessage(path, resResult(STATUS.SUCCESS, message));
+        }
+        return channel
+    }
+
     /**
      * 踢出某个成员
      * @param guildCode 军团code
@@ -163,8 +190,8 @@ export class GuildRemote {
      * 向军团推送城门血量
      * @param guildCode 
      */
-    public pushGateHp(guildCode: string, msg: GuildGateRankParam) {
-        this.pushMessage(guildCode, this.GUILD_GATE_ACT_HP, msg);
+    public pushGateHp(guildCode: string, gateHp: number) {
+        this.pushMessage(guildCode, this.GUILD_GATE_ACT_HP, { gateHp });
     }
 
     /**
@@ -183,4 +210,29 @@ export class GuildRemote {
         console.log("MSG END")
         this.pushMessage(guildCode, this.GUILD_ACTIVITY_END, {});
     }
+
+    /**
+     * @description 向城池推送有宣战
+     * @param cityId 城池
+     * @param declareGuildCode 宣战的军团code
+     * @param declareCount 宣战数量
+     */
+    public async sendGuildCityDeclare(cityId: number, declareGuildCode: string, declareCount: number ) {
+        this.pushMessageToCity(cityId, this.GUILD_CITY_DECLARE, {
+            cityId,
+            declareGuildCode,
+            declareCount
+        });
+    }
+
+    /**
+     * @description 推送城池城门血条
+     * @param guildCode 
+     */
+    public async pushCityGateHp(cityId: number, gateHp: number ) {
+        this.pushMessageToCity(cityId, this.GUILD_CITY_ACT_HP, {
+            cityId,
+            gateHp
+        });
+    }
 }

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

@@ -1,10 +1,22 @@
-import { Application, ChannelService, BackendSession } from "pinus";
-import { GUILD_ACTIVITY_TYPE, STATUS, CITY_STATUS } from "../../../consts";
+import { Application, ChannelService, BackendSession, pinus } from "pinus";
+import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, GUILD_POINT_WAYS } from "../../../consts";
 import { resResult } from "../../../pubUtils/util";
-import { getGuildActivityStatus } from "../../../services/guildActivityService";
+import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank } from "../../../services/guildActivityService";
 import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
-import { CityParam } from "../../../domain/battleField/guildActivity";
 import { gameData } from "../../../pubUtils/data";
+import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
+import { leaveCityChannel, addRoleToCityChannel, getCityChannelSid } from "../../../services/chatService";
+import { UserGuildModel } from "../../../db/UserGuild";
+import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
+import { nowSeconds, getBeforeMinuteSeconds } from "../../../pubUtils/timeUtil";
+import { getGoldObject } from "../../../pubUtils/itemUtils";
+import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
+import { handleCost } from "../../../services/rewardService";
+import { getRankScore, getCityKeyName, getGuildKeyName, setGuildActivityRank, setRank } from "../../../services/redisService";
+import { RoleModel, RoleType } from "../../../db/Role";
+import { RankParam, GuildRankParam } from "../../../domain/rank";
+import { GuildModel } from "../../../db/Guild";
+import { addActive } from "../../../services/guildService";
 
 export default function (app: Application) {
     return new CityActivityHandler(app);
@@ -30,36 +42,7 @@ export class CityActivityHandler {
         if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
 
         const dbCities = await GuildActivityCityModel.getAllCities(serverId);
-
-        let cities = new Array<CityParam>();
-        for(let [ cityId, dic ] of gameData.cityActivity) {
-            let param = new CityParam(cityId);
-            let curCity = dbCities.find(cur => cur.cityId == cityId);
-
-            let preCity = dic.preCity;
-            if(preCity && preCity.length) {
-                let hasGuardCity = dbCities.find(cur => {
-                    return preCity.includes(cur.cityId) && cur.guardGuildCode == guildCode;
-                });
-                if(!!hasGuardCity) {
-                    param.status = CITY_STATUS.CAN_DECLARE;
-                }
-            } else {
-                param.status = CITY_STATUS.CAN_DECLARE;
-            }
-
-            if(curCity) {
-                if(curCity.guardGuildCode == guildCode) {
-                    param.status = CITY_STATUS.GUARD;
-                } else if (curCity.declareGuilds.includes(guildCode)) {
-                    param.status = CITY_STATUS.DECLARED;
-                }
-                param.guardGuildCode = curCity.guardGuildCode;
-                param.guardGuildName = curCity.guardGuildName;
-                param.declareCount = curCity.declareCount;
-            }
-            cities.push(param);
-        }
+        let cities = getCities(guildCode, dbCities); 
 
         return resResult(STATUS.SUCCESS, {
             ...statusResult,
@@ -68,27 +51,234 @@ export class CityActivityHandler {
     }
 
     // 获取单个城池状态
-    async getCityStatus(msg: {}, session: BackendSession) {
+    async getCityStatus(msg: { cityId: number }, session: BackendSession) {
+
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const serverId = session.get('serverId');
+        const guildCode = session.get('guildCode');
+        let sid = session.get('sid');
+
+        const { cityId } = msg;
+
+        let statusResult = getGuildActivityStatus(this.aid);
+        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        let dicCity = gameData.cityActivity.get(cityId);
+        if(!dicCity) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+        let obj = getCityActivityObj();
+        let gateHp = obj.getGateHpAndInc(serverId, cityId, dicCity.hp);
+
+        let myGuildActivityRec = await UserGuildActivityRecModel.findByRoleId(roleId, this.aid);
+        let challengeTime = 0;
+        if(myGuildActivityRec) {
+            challengeTime = myGuildActivityRec.challengeTime;
+        }
+
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity.preCity, dbCities);
+
+        let historyCity = obj.getHistoryCity(roleId);
+        if(historyCity) {
+            await leaveCityChannel(roleId, sid, historyCity);
+        }
+        await addRoleToCityChannel(roleId, sid, cityId);
+        obj.setHistoryCity(roleId, cityId);
+
         
+        let ranks = await getCityActivityRank(guildCode, serverId, cityId, roleId, roleName);
+
+        return resResult(STATUS.SUCCESS, {
+            cityId,
+            ...statusResult,
+            cityStatus,
+            gateHp,
+            challengeTime,
+            ...ranks
+        });
     }
 
     // 宣战
-    async declareCity(msg: {}, session: BackendSession) {
+    async declareCity(msg: { cityId: number }, session: BackendSession) {
+        // const roleId = session.get('roleId');
+        // const roleName = session.get('roleName');
+        const serverId = session.get('serverId');
+        const guildCode = session.get('guildCode');
 
+        //TODO 权限校验
+
+        let { cityId } = msg;
+        let checkResult = await GuildActivityCityModel.checkDeclartion(serverId, guildCode);
+        if(!!checkResult) return resResult(STATUS.HAS_DECLARED);
+
+        let rec = await GuildActivityCityModel.declare(serverId, cityId, guildCode);
+
+        let chatSid = await getCityChannelSid(guildCode);
+        pinus.app.rpc.chat.guildRemote.sendGuildCityDeclare.toServer(chatSid, cityId, guildCode, rec.declareCount);
+
+        let obj = getCityActivityObj();
+        obj.pushGuild(guildCode, serverId, cityId);
+
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        let cities = getCities(guildCode, dbCities); 
+        return resResult(STATUS.SUCCESS, { cities });
     }
 
     // 开始挑战
-    async checkBattle(msg: {}, session: BackendSession) {
+    async checkBattle(msg: {cityId: number, costGold: boolean, heroes: number[]}, session: BackendSession) {
+        let { cityId, costGold, heroes } = msg;
+        if(!heroes || heroes.length <= 0) return resResult(STATUS.WRONG_PARMS);
 
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        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 obj = getCityActivityObj();
+
+        const dicCity = gameData.cityActivity.get(cityId);
+
+        let gateHp = obj.getGateHpAndInc(serverId, cityId, dicCity.hp);
+        if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
+
+        let statusResult = getGuildActivityStatus(this.aid);
+        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+        // TODO 测试完成后去掉这条判断
+        // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
+
+        let userGuild = await UserGuildModel.getMyGuild(roleId, 'job');
+
+        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
+        if(!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
+
+        let { code: sourceCode } = guildActivityRec;
+        
+        let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
+        if(costGold) {
+            let goldObj = getGoldObject(GUILDACTIVITY.CITYACTIVITY_CD_COST);
+            const costRes = await handleCost(roleId, sid, [goldObj]);
+            if (!costRes) {
+                return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
+            }
+        } else {
+            if(myGuildActivityRec.challengeTime > nowSeconds()) {
+                return resResult(STATUS.CHALLENGE_TIME_NOT_REACH);
+            }
+        }
+        myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
+
+        let { code } = myGuildActivityRec; 
+
+        // 更新公会参与的玩家
+        obj.pushMembers(guildCode, roleId, userGuild.job);
+
+        // // 返回当前军团总军功
+        let guildScore = await getRankScore(getCityKeyName(REDIS_KEY.CITY_ACTIVITY, cityId), serverId, guildCode);
+
+        const dbCities = await GuildActivityCityModel.getAllCities(serverId);
+        let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity.preCity, dbCities);
+
+        return resResult(STATUS.SUCCESS, {
+            code,
+            cityId,
+            cityStatus,
+            ...statusResult,
+            gateHp,
+            guildScore,
+            myScore: 0
+        });
     }
 
     // 上报城门受到伤害
-    async hitGate(msg: {}, session: BackendSession) {
+    async hitGate(msg: { cityId: number, code: string, damage: number, hid: number, round: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const serverId = session.get('serverId');
+        const guildCode = session.get('guildCode');
+        const sid = session.get('sid');
 
+        let { cityId, code, damage, hid, round } = msg;
+        if(!damage || damage < 0) return resResult(STATUS.WRONG_PARMS);
+
+        const dicCity = gameData.cityActivity.get(cityId);
+        let obj = getCityActivityObj();
+        let gateHp = obj.getGateHpAndInc(serverId, cityId, dicCity.hp);
+        if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
+
+        let statusResult = getGuildActivityStatus(this.aid);
+        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+        // TODO 测试完成后去掉这条判断
+        // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
+
+        let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage });
+        if(!pushResult) return resResult(STATUS.WRONG_PARMS);
+
+        gateHp = obj.getGateHpAndInc(serverId, cityId, -1 * damage);
+        if(gateHp <= 0) {
+            // TODO 推送 停止活动并结算奖励
+        }
+        // 推送 城门血量
+        let chatSid = await getCityChannelSid(cityId);
+        pinus.app.rpc.chat.guildRemote.pushCityGateHp.toServer(chatSid, cityId, gateHp);
+
+        // 更新redis数据
+        let role = await RoleModel.findByRoleId(roleId);
+        let { lv, vLv, head, frame, spine, title } = role;
+        let userParam = new RankParam(roleName, lv, vLv, head, frame, spine, title);
+        let myScore = await setGuildActivityRank(REDIS_KEY.USER_CITY_ACTIVITY, guildCode, serverId, roleId, damage, Date.now(), userParam);
+
+        let guild = await GuildModel.findByCode(guildCode, serverId);
+        let leader = <RoleType>guild.leader;
+        let params = new GuildRankParam(guild.icon, guild.name, guild.lv, leader);
+        let guildScore = await setRank(REDIS_KEY.GATE_ACTIVITY, serverId, guild.code, damage, Date.now(), params, true);
+        
+        return resResult(STATUS.SUCCESS, {
+            code,
+            ...statusResult,
+            guildScore,
+            myScore,
+            gateHp
+        })
     }
 
     // 结束挑战
-    async battleEnd(msg: {}, session: BackendSession) {
+    async battleEnd(msg: { cityId: number, code: string, isSuccess: boolean }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let roleName = session.get('roleName');
+        let guildCode = session.get('guildCode');
+        let serverId = session.get('serverId');
 
+        let { cityId, code, isSuccess } = msg;
+        let obj = getCityActivityObj();
+        
+        let statusResult = getGuildActivityStatus(this.aid);
+        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        let dicCity = gameData.cityActivity.get(cityId);
+        if(!dicCity) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        // 更新userGuildActivityRecord
+        let challengeTime = getBeforeMinuteSeconds(-1 * GUILDACTIVITY.CITYACTIVITY_CD_COST); 
+        let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true, cityId, challengeTime });
+        if(!myGuildActivityRec) return resResult(STATUS.INTERNAL_ERR);
+
+        // 发放活跃
+        await addActive(roleId, serverId, GUILD_POINT_WAYS.ACTIVITY);  //获得活跃值
+        // 返回当前军团总军功
+        let guildScore = await getRankScore(getCityKeyName(REDIS_KEY.CITY_ACTIVITY, cityId), serverId, guildCode);
+        let myScore = await getRankScore(getGuildKeyName(REDIS_KEY.USER_CITY_ACTIVITY, guildCode), serverId, roleId, true);
+        let gateHp = obj.getGateHpAndInc(serverId, cityId, dicCity.hp);
+
+        return resResult(STATUS.SUCCESS, {
+            isSuccess,
+            code,
+            ...statusResult,
+            guildScore,
+            myScore,
+            gateHp,
+            challengeTime: myGuildActivityRec.challengeTime
+        });
     }
 }

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

@@ -1,13 +1,12 @@
 import { Application, BackendSession, ChannelService, pinus } from "pinus";
-import { setMedianCe, getMedianCe, getGuildActivityStatus, getRecordScore, getGuildActivityObj, getGuildActivityRank, sendSingleGuildGateActEndMsg, sendGuildActEndMsg, participants } from "../../../services/guildActivityService";
+import { getMedianCe, getGuildActivityStatus, getRecordScore, getGateActivityObj, sendSingleGuildGateActEndMsg, sendGuildActEndMsg, participants, getGateActivityRank } from "../../../services/guildActivityService";
 import { resResult } from "../../../pubUtils/util";
 import { STATUS, GUILD_ACTIVITY_TYPE, GUILD_POINT_WAYS, ENEMIES_TYPE, GET_POINT_WAYS } from "../../../consts";
 import { GameModel } from "../../../db/Game";
 import { ServerlistModel } from "../../../db/Serverlist";
-import { UserGuildActivityRecModel, Record } from "../../../db/UserGuildActivityRec";
+import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
 import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
 import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
-import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { RoleModel, RoleType } from "../../../db/Role";
 import { GuildModel } from "../../../db/Guild";
 import { RankParam, GuildRankParam } from "../../../domain/rank";
@@ -49,7 +48,7 @@ export class GateActivityHandler {
         let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
         let { challengeCnt } = myGuildActivityRec; 
 
-        let ranks = await getGuildActivityRank(guildCode, serverId, roleId, roleName);
+        let ranks = await getGateActivityRank(guildCode, serverId, roleId, roleName);
 
         return resResult(STATUS.SUCCESS, {
             ...statusResult,
@@ -68,7 +67,7 @@ export class GateActivityHandler {
         const serverId = session.get('serverId');
         const guildCode = session.get('guildCode');
         if(!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-        let obj = getGuildActivityObj(this.aid);
+        let obj = getGateActivityObj();
 
         let gateHp = obj.getGateHpAndInc(guildCode);
         if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
@@ -88,7 +87,7 @@ export class GateActivityHandler {
         if(myGuildActivityRec.challengeCnt > 0) {
             return resResult(STATUS.CHALLENGE_CNT_NOT_ENOUGH);
         }
-        await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
+        myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
         let { code, challengeCnt } = myGuildActivityRec; 
 
         // 更新公会参与的玩家
@@ -119,7 +118,7 @@ export class GateActivityHandler {
         let serverId = session.get('serverId');
 
         let { code, record } = msg;
-        let obj = getGuildActivityObj(this.aid);
+        let obj = getGateActivityObj();
 
         let statusResult = getGuildActivityStatus(this.aid);
         if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
@@ -166,7 +165,7 @@ export class GateActivityHandler {
         let serverId = session.get('serverId');
 
         let { code, damage } = msg;
-        let obj = getGuildActivityObj(this.aid);
+        let obj = getGateActivityObj();
         let gateHp = obj.getGateHpAndInc(guildCode);
         if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
 
@@ -182,7 +181,7 @@ export class GateActivityHandler {
         }
         // 推送 城门血量
         let chatSid = await getGuildChannelSid(guildCode);
-        pinus.app.rpc.chat.guildRemote.pushGateHp.toServer(chatSid, guildCode, { gateHp });
+        pinus.app.rpc.chat.guildRemote.pushGateHp.toServer(chatSid, guildCode, gateHp);
 
         // 返回当前军团总军功
         let guildScore = await getRankScore(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);
@@ -205,7 +204,7 @@ export class GateActivityHandler {
         let serverId = session.get('serverId');
 
         let { code, isSuccess } = msg;
-        let obj = getGuildActivityObj(this.aid);
+        let obj = getGateActivityObj();
         
         let statusResult = getGuildActivityStatus(this.aid);
         if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
@@ -280,7 +279,7 @@ export class GateActivityHandler {
         let guildCode = session.get('guildCode');
         console.log(guildCode);
         let serverId = session.get('serverId');
-        let res = getGuildActivityObj(this.aid).getObj(guildCode, serverId);
+        let res = getGateActivityObj().getObj(guildCode, serverId);
         return resResult(STATUS.SUCCESS, res)
     }
 

game-server/app/services/chatChannelService.ts

@@ -41,6 +41,11 @@ export async function addRoleToGuildChannel(roleId: string, sid: string, guildCo
     await addRoleToChannel(roomId, roleId, sid);
 }
 
+export async function addRoleToCityChannel(roleId: string, sid: string, cityId: number) {
+    const roomId = groupRoomId(CHANNEL_PREFIX.CITY, cityId);
+    await addRoleToChannel(roomId, roleId, sid);
+}
+
 async function leaveChannel(roomId: string, roleId: string, sid: string) {
     const channelSid = await channelServer(roomId);
     await pinus.app.rpc.chat.chatRemote.leaveChannel.toServer(channelSid, roomId, roleId, sid);
@@ -56,6 +61,12 @@ export async function leaveWorldChannel(roleId: string, sid: string, serverId: n
     await leaveChannel(roomId, roleId, sid);
 }
 
+export async function leaveCityChannel(roleId: string, sid: string, cityId: number) {
+    const roomId = groupRoomId(CHANNEL_PREFIX.CITY, cityId);
+    await leaveChannel(roomId, roleId, sid);
+}
+
+
 export async function leaveGuildChannel(roleId: string, sid: string) {
     const { guildCode } = await RoleModel.findByRoleId(roleId, 'guildCode');
     if (!guildCode) return;
@@ -74,3 +85,9 @@ export async function getGuildChannelSid(guildCode: string) {
     const channelSid = await channelServer(roomId);
     return channelSid;
 }
+
+export async function getCityChannelSid(cityId: number) {
+    const roomId = groupRoomId(CHANNEL_PREFIX.CITY, cityId);
+    const channelSid = await channelServer(roomId);
+    return channelSid;
+}

game-server/app/services/guildActivityService.ts

@@ -2,14 +2,14 @@ import { ServerlistModel } from "../db/Serverlist";
 import { RoleModel } from "../db/Role";
 import { reduceCe } from "../pubUtils/util";
 import { GUILDACTIVITY } from "../pubUtils/dicParam";
-import { gameData, getGuildAuctionRewards, getTodayGuildActivity } from "../pubUtils/data";
+import { gameData, getGuildAuctionRewards } from "../pubUtils/data";
 import { getCurHourPoint, getCutDay, nowSeconds } from "../pubUtils/timeUtil";
-import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE } from "../consts";
+import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS } from "../consts";
 import { Record, UserGuildActivityRecModel } from "../db/UserGuildActivityRec";
-import { GateMembersRec, GateActivityObject } from "../domain/battleField/guildActivity";
+import { GateMembersRec, GateActivityObject, CityActivityObject, CityParam } from "../domain/battleField/guildActivity";
 import { DicGuildActivity } from "../pubUtils/dictionary/DicGuildActivity";
-import { getUnionRank, getRank, getGuildKeyName, getMyUnionRank, getRankScore } from "./redisService";
-import Guild, { GuildModel } from "../db/Guild";
+import { getUnionRank, getRank, getGuildKeyName, getMyUnionRank, getRankScore, getCityKeyName } from "./redisService";
+import { GuildModel } from "../db/Guild";
 import { SimpleGuildRankParam, SimpleRoleRankParam } from "../domain/rank";
 import { getGuildChannelSid, getWorldChannelSid } from "./chatChannelService";
 import { pinus } from "pinus";
@@ -18,15 +18,22 @@ import { uniq } from 'underscore'
 import { genAuction } from "./auctionService";
 import { sendMail } from "./mailService";
 import { getHonourObject } from '../pubUtils/itemUtils';
+import { GuildActivityCityType } from "../db/GuildActivityCity";
 
 let gateActivityObj: GateActivityObject;
-export function getGuildActivityObj(aid: number) {
-    if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
-        if(!gateActivityObj) {
-            gateActivityObj = new GateActivityObject()
-        }
-        return gateActivityObj;
+let cityActivityObj: CityActivityObject;
+export function getGateActivityObj() {
+    if(!gateActivityObj) {
+        gateActivityObj = new GateActivityObject();
     }
+    return gateActivityObj;
+}
+
+export function getCityActivityObj() {
+    if(!cityActivityObj) {
+        cityActivityObj = new CityActivityObject();
+    }
+    return cityActivityObj
 }
 
 /**
@@ -137,6 +144,20 @@ export function getRecordScore(aid: number, record: { round: number, dataId: num
     return { score: sum, newRecords, memberRecord }
 }
 
+export async function getGateActivityRank(guildCode: string, serverId: number, roleId?: string, roleName?: string) {
+    let guildKey = REDIS_KEY.GATE_ACTIVITY;
+    let memberKey = getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode);
+    let rec = await getGuildActivityRank(guildKey, memberKey, guildCode, serverId, roleId, roleName);
+    return rec;
+}
+
+export async function getCityActivityRank(guildCode: string, serverId: number, cityId: number, roleId?: string, roleName?: string) {
+    let guildKey = getCityKeyName(REDIS_KEY.USER_CITY_ACTIVITY, cityId);
+    let memberKey = getGuildKeyName(REDIS_KEY.USER_CITY_ACTIVITY, guildCode);
+    let rec = await getGuildActivityRank(guildKey, memberKey, guildCode, serverId, roleId, roleName);
+    return rec;
+}
+
 /**
  * 获得军团活动排行榜
  * @param guildCode 
@@ -144,9 +165,9 @@ export function getRecordScore(aid: number, record: { round: number, dataId: num
  * @param roleId 
  * @param roleName 
  */
-export async function getGuildActivityRank(guildCode: string, serverId: number, roleId?: string, roleName?: string) {
+export async function getGuildActivityRank(guildKey: string, memberKey: string, guildCode: string, serverId: number, roleId?: string, roleName?: string) {
     
-    let guildRankResult = await getUnionRank(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);
+    let guildRankResult = await getUnionRank(guildKey, serverId, guildCode);
     let guildRank = new Array<SimpleGuildRankParam>();
     for(let { rank, code, name, num } of guildRankResult.ranks) {
         let param = new SimpleGuildRankParam(rank, code, name, num);
@@ -161,7 +182,7 @@ export async function getGuildActivityRank(guildCode: string, serverId: number,
         myGuildRank = new SimpleGuildRankParam(0, guildCode, guild.name, 0);
     }
 
-    let memberRankResult = await getRank(getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode), serverId, roleId);
+    let memberRankResult = await getRank(memberKey, serverId, roleId);
     let memberRank = new Array<SimpleRoleRankParam>();
     for(let { rank, roleId, roleName, num } of memberRankResult.ranks) {
         let param = new SimpleRoleRankParam(rank, roleId, roleName, num);
@@ -185,14 +206,16 @@ export async function getGuildActivityRank(guildCode: string, serverId: number,
  * @param aid 活动类型
  */
 export async function sendAllGuildRanks(aid: number) {
-    let obj = getGuildActivityObj(aid);
-    let guilds = obj.getGuilds();
-    for(let [ serverId, guildCodes ] of guilds) {
-        // TODO 不需要每个军团都排序一次
-        for(let guildCode of guildCodes) {
-            let ranks =  await getGuildActivityRank(guildCode, serverId);
-            let chatSid = await getGuildChannelSid(guildCode);
-            pinus.app.rpc.chat.guildRemote.pushRank.toServer(chatSid, guildCode, ranks);
+    if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
+        let obj = getGateActivityObj();
+        let guilds = obj.getGuilds();
+        for(let [ serverId, guildCodes ] of guilds) {
+            // TODO 不需要每个军团都排序一次
+            for(let guildCode of guildCodes) {
+                let ranks =  await getGateActivityRank(guildCode, serverId);
+                let chatSid = await getGuildChannelSid(guildCode);
+                pinus.app.rpc.chat.guildRemote.pushRank.toServer(chatSid, guildCode, ranks);
+            }
         }
     }
 }
@@ -202,7 +225,7 @@ export async function sendAllGuildRanks(aid: number) {
  * @param aid 活动类型
  */
 export async function sendGuildActEndMsg(aid: number) {
-    let obj = getGuildActivityObj(aid);
+    let obj = getGateActivityObj();
     let guilds = obj.getGuilds();
     for(let [ serverId, guildCodes ] of guilds) {
         let chatSid = await getWorldChannelSid(serverId);
@@ -232,7 +255,7 @@ export async function sendSingleGuildGateActEndMsg(guildCode: string, serverId:
  * @param serverId 
  */
 export async function gateActivitySettleReward(guildCode: string, serverId: number) {
-    let obj = getGuildActivityObj(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
+    let obj = getGateActivityObj();
     let { gateHp, members } = obj.getObj(guildCode, serverId);
     members = uniq(members, cur => cur.roleId);
 
@@ -277,4 +300,54 @@ export async function participants(guildCode: string, sourceType: number, source
     if(!rec) return [];
 
     return rec.members||[];
+}
+
+export function getCities(guildCode: string, dbCities: GuildActivityCityType[]) {
+
+    let cities = new Array<CityParam>();
+    for(let [ cityId, dic ] of gameData.cityActivity) {
+        let param = new CityParam(cityId);
+        let curCity = dbCities.find(cur => cur.cityId == cityId);
+
+        if(curCity) {
+            param.guardGuildCode = curCity.guardGuildCode;
+            param.guardGuildName = curCity.guardGuildName;
+            param.declareCount = curCity.declareCount;
+        }
+
+        param.status = getCityStatus(guildCode, cityId, dic.preCity, dbCities);
+        cities.push(param);
+    }
+    return cities
+}
+
+
+/**
+ * 诸侯混战 获取城池状态
+ * @param guildCode 
+ * @param cityId 
+ * @param preCity 
+ * @param dbCities 
+ */
+export function getCityStatus(guildCode: string, cityId: number, preCity: number[], dbCities: GuildActivityCityType[]) {
+    let status = CITY_STATUS.NOT_OPEN;
+    if(preCity && preCity.length) {
+        let hasGuardCity = dbCities.find(cur => {
+            return preCity.includes(cur.cityId) && cur.guardGuildCode == guildCode;
+        });
+        if(!!hasGuardCity) {
+            status = CITY_STATUS.CAN_DECLARE;
+        }
+    } else {
+        status = CITY_STATUS.CAN_DECLARE;
+    }
+    let curCity = dbCities.find(cur => cur.cityId == cityId);
+    if(curCity) {
+        if(curCity.guardGuildCode == guildCode) {
+            status = CITY_STATUS.GUARD;
+        } else if (curCity.declareGuilds.includes(guildCode)) {
+            status = CITY_STATUS.DECLARED;
+        }
+    }
+    return status;
 }

game-server/app/services/redisService.ts

@@ -182,7 +182,8 @@ export async function getRank(key: string, serverId: number, roleId: string, lim
     let ranks = [], myRank = null;
     const rankFromDb = await redisClient().zrevrangebyscoreAsync(getKeyName(key, serverId), '+inf', '-inf', "WITHSCORES", "LIMIT", 0, limit);
 
-    let infoKey = REDIS_RANK_TO_INFO.get(key)||REDIS_KEY.USER_INFO;
+    let _key = key.split(':')[0];
+    let infoKey = REDIS_RANK_TO_INFO.get(_key)||REDIS_KEY.USER_INFO;
 
     for(let ii = 0; ii < rankFromDb.length; ii+=2) {
         const _roleId = rankFromDb[ii];
@@ -604,7 +605,8 @@ export async function getUnionRank(key: string, serverId: number, roleId: string
     let unionKey = await generateUnionRank(key, serverId);
     const rankFromDb = await redisClient().zrevrangebyscoreAsync(unionKey, '+inf', '-inf', "WITHSCORES", "LIMIT", 0, limit);
 
-    let infoKey = REDIS_RANK_TO_INFO.get(key)||REDIS_KEY.USER_INFO;
+    let _key = key.split(':')[0];
+    let infoKey = REDIS_RANK_TO_INFO.get(_key)||REDIS_KEY.USER_INFO;
 
     for(let ii = 0; ii < rankFromDb.length; ii+=2) {
         const _roleId = rankFromDb[ii];
@@ -661,6 +663,10 @@ export function getGuildKeyName(key: string, guildCode: string) {
     return `${key}:${guildCode}`;
 }
 
+export function getCityKeyName(key: string, cityId: number) {
+    return `${key}:${cityId}`;
+}
+
 /** 
  * debug接口使用，直接删除排行榜数据
  * @param params serverId => guildCodes
@@ -676,4 +682,5 @@ export async function delGuildActivityRank(params: Map<number, string[]>) {
         }
     }
 }
+
 /**************** 军团活动排行end */

game-server/app/services/timeTaskService.ts

@@ -20,7 +20,7 @@ import { STATUS } from '../consts/statusCode';
 import { getMailContent, sendMail } from './mailService';
 import { reportOnline } from '../pubUtils/httpUtil';
 import User, { UserModel } from '../db/User';
-import { getGuildActivityByDic, getGuildActivityRank, setMedianCe } from './guildActivityService';
+import { getGuildActivityByDic, setMedianCe } from './guildActivityService';
 import { sendUngotDividend, startGuildAuction, startWorldAuction, stopAuction } from './auctionService';
 import { DicGuildActivity } from '../pubUtils/dictionary/DicGuildActivity';
 const PER_SECOND = 1 * 1000;