军团活动：粮草先行还缺event记录和权限限制

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

@@ -31,6 +31,7 @@ export class ChatRemote {
 
     private channelService: ChannelService;
     private GUILD_ACTIVITY_END = 'onGuildActivityEnd';
+    private RACE_ACTIVITY_START = 'onRaceStart';
 
     /**
      * 加入世界频道（分服）.
@@ -166,7 +167,6 @@ export class ChatRemote {
 
     }
 
-
     /**
      * @description 全服推送活动结束通知
      * @param serverId 
@@ -177,4 +177,15 @@ export class ChatRemote {
         if (!channel) return;
         channel.pushMessage(this.GUILD_ACTIVITY_END, resResult(STATUS.SUCCESS, { }));
     }
+
+    /**
+     * @description 全服推送竞赛活动开始通知
+     * @param serverId 
+     */
+    public async sendRaceActivityStart(serverId: number) {
+        let roomId = groupRoomId(CHANNEL_PREFIX.WORLD, serverId);
+        let channel = this.channelService.getChannel(roomId, false);
+        if (!channel) return;
+        channel.pushMessage(this.RACE_ACTIVITY_START, resResult(STATUS.SUCCESS, { }));
+    }
 }

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

@@ -5,7 +5,7 @@ import { GuildType } from '../../../db/Guild';
 import { RoleType } from '../../../db/Role';
 import { GuildRecType } from '../../../db/GuildRec';
 import { leaveGuildChannel, groupRoomId } from '../../../services/chatService';
-import { GuildGateRankParam } from '../../../domain/battleField/guildActivity';
+import { GuildRankParams, WoodenHorse, Event } from '../../../domain/battleField/guildActivity';
 
 export default function (app: Application) {
     return new GuildRemote(app);
@@ -31,6 +31,8 @@ export class GuildRemote {
     private GUILD_ACTIVITY_END = 'onGuildActivityEnd';    // 军团活动结束
     private GUILD_CITY_DECLARE = 'onGuildCityDeclare';    // 有军团对这个城池进行宣战了
     private GUILD_CITY_ACT_HP = 'onGuildCityGateHpUpdate'; // 诸侯入侵城门血条
+    private GUILD_RACE_UPDATE = 'onRaceHorseUpdate';   /// 更新木牛流马
+    private GUILD_RACE_EVENT = 'onRaceEventUpdate';   /// 更新木牛流马
 
     /**
      * 封装，军团相关channel名: 'guild'+guildCode
@@ -199,7 +201,7 @@ export class GuildRemote {
      * 向军团推送排行榜名次
      * @param guildCode 
      */
-    public pushRank(guildCode: string, msg: GuildGateRankParam) {
+    public pushRank(guildCode: string, msg: GuildRankParams) {
         this.pushMessage(guildCode, this.GATE_ACT_RANK, msg);
     }
 
@@ -207,7 +209,7 @@ export class GuildRemote {
      * 向军团推送排行榜名次
      * @param guildCode 
      */
-    public pushCityActRank(guildCode: string, msg: GuildGateRankParam) {
+    public pushCityActRank(guildCode: string, msg: GuildRankParams) {
         this.pushMessage(guildCode, this.CITY_ACT_RANK, msg);
     }
 
@@ -236,7 +238,8 @@ export class GuildRemote {
 
     /**
      * @description 推送城池城门血条
-     * @param guildCode 
+     * @param cityId 城池
+     * @param gateHp 血条 
      */
     public async pushCityGateHp(cityId: number, gateHp: number ) {
         this.pushMessageToCity(cityId, this.GUILD_CITY_ACT_HP, {
@@ -244,4 +247,28 @@ export class GuildRemote {
             gateHp
         });
     }
+
+    /**
+     * @description 推送木牛流马状态
+     * @param guildCode 军团
+     * @param woodenHorseList 木马
+     * @param ranks 军团排名和自己所在的排名
+     */
+    public async pushRaceHorseUpdate(guildCode: string, woodenHorseList: WoodenHorse[], ranks: GuildRankParams, events: Event[] ) {
+        this.pushMessage(guildCode, this.GUILD_RACE_UPDATE, {
+            timestamp: Date.now(),
+            woodenHorseList,
+            ...ranks,
+            events
+        });
+    }
+
+    /**
+     * @description 向军团推送事件
+     * @param guildCode 
+     */
+    public async sendRaceEvent(guildCode: string, events: Event[]) {
+        this.pushMessage(guildCode, this.GUILD_RACE_EVENT, { timestamp: Date.now(), events });
+    }
+
 }

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

@@ -306,17 +306,6 @@ export class GateActivityHandler {
             return resResult(STATUS.GUILD_ACTIVITY_IS_OPEN)
         }
 
-        let map = new Map<number, string[]>();
-        let guilds = await GuildModel.findAllGuild('serverId code');
-        for(let { serverId, code } of guilds) {
-            if(map.has(serverId)) {
-                map.get(serverId).push(code);
-            } else {
-                map.set(serverId, [code]);
-            }
-        }
-        await delGuildActivityRank(aid, map);
-
         return resResult(STATUS.SUCCESS);
     }
 
@@ -327,10 +316,27 @@ export class GateActivityHandler {
             await pinus.app.rpc.systimer.systimerRemote.gateActivityEnd.toServer('systimer-server-1');
         } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
             await pinus.app.rpc.systimer.systimerRemote.cityActivityEnd.toServer('systimer-server-1');
+        } else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+            await pinus.app.rpc.systimer.systimerRemote.raceActivityEnd.toServer('systimer-server-1');
         }
         return resResult(STATUS.SUCCESS);
     }
 
+    async debugDelRedis(msg: { aid: number }, session: BackendSession) {
+        let { aid } = msg;
+
+        let map = new Map<number, string[]>();
+        let guilds = await GuildModel.findAllGuild('serverId code');
+        for(let { serverId, code } of guilds) {
+            if(map.has(serverId)) {
+                map.get(serverId).push(code);
+            } else {
+                map.set(serverId, [code]);
+            }
+        }
+        await delGuildActivityRank(aid, map);
+    }
+
     // ! 测试接口 将自己添加进活动roleId里
     async debugAddParticipants(msg: { aid: number }, session: BackendSession) {
         let roleId = session.get('roleId');

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

@@ -1,8 +1,12 @@
 import { Application, ChannelService, BackendSession } from "pinus";
-import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS } from "../../../consts";
+import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, GUILD_POINT_WAYS, REDIS_KEY } from "../../../consts";
 import { resResult } from "../../../pubUtils/util";
 import { getGuildActivityStatus, getRaceActivityObj, getRaceActivityRank, getWoodenHorseList, calWoodenHorseAndSend } from "../../../services/guildActivityService";
 import { UserGuildModel } from "../../../db/UserGuild";
+import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
+import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
+import { addActive } from "../../../services/guildService";
+import { getMyUnionRank } from "../../../services/redisService";
 
 export default function (app: Application) {
     return new RaceActivityHandler(app);
@@ -52,6 +56,7 @@ export class RaceActivityHandler {
         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 statusResult = getGuildActivityStatus(this.aid);
@@ -59,14 +64,26 @@ export class RaceActivityHandler {
 
         let obj = getRaceActivityObj();
 
+        let hasJoin = obj.hasJoin(guildCode, roleId);
+        if(hasJoin) {
+            return resResult(STATUS.RACE_HAS_JOIN);
+        }
+
+
+        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);
+
         let myGuild = await UserGuildModel.getMyGuild(roleId, 'job');
-        let woodenHorse = obj.joinWoodenHorse(guildCode, roleId, roleName, myGuild.job);
+        let woodenHorse = await obj.joinWoodenHorse(guildCode, roleId, roleName, serverId, sid, myGuild.job);
         if(!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         let events = obj.getEvents(guildCode, woodenHorse.distance);
-        let hasJoin = obj.hasJoin(guildCode, roleId);
 
         return resResult(STATUS.SUCCESS, {
+            code: myGuildActivityRec.code,
             ...statusResult,
             hasJoin,
             woodenHorse,
@@ -106,6 +123,46 @@ export class RaceActivityHandler {
         });
     }
 
+
+    // 结束挑战
+    async useItem(msg: { id: number, toGuild: string }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let roleName = session.get('roleName');
+        let guildCode = session.get('guildCode');
+        let serverId = session.get('serverId');
+
+        return resResult(STATUS.SUCCESS);
+    }
+
+    // 结束挑战
+    async battleEnd(msg: { 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 { code, isSuccess } = msg;
+
+        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 myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true });
+        if(!guildActivityRec || !myGuildActivityRec) return resResult(STATUS.INTERNAL_ERR);
+
+        // 发放活跃
+        await addActive(roleId, serverId, GUILD_POINT_WAYS.ACTIVITY);  //获得活跃值
+        // 返回当前军团总军功
+        let myGuildRank = await getMyUnionRank(REDIS_KEY.RACE_ACTIVITY, serverId, guildCode);
+
+        return resResult(STATUS.SUCCESS, {
+            timestamp: Date.now(),
+            woodenHorse: guildActivityRec.woodenHorse,
+            myGuildRank
+        })
+    }
+
     async test(msg: { serverId: number }, session: BackendSession) {
         let {serverId} = msg;
         await calWoodenHorseAndSend(serverId);

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

@@ -1,5 +1,5 @@
 import { Application, ChannelService } from 'pinus';
-import { sendAllGuildRanks, sendGuildActEndMsg, calWoodenHorseAndSend } from '../../../services/guildActivityService';
+import { sendAllGuildRanks, sendGuildActEndMsg, calWoodenHorseAndSend, sendRaceStartMsg } from '../../../services/guildActivityService';
 
 export default function (app: Application) {
     return new GuildActivityRemote(app);
@@ -34,4 +34,11 @@ export class GuildActivityRemote {
     public async calWoodenHorseAndSend(serverId: number) {
         await calWoodenHorseAndSend(serverId);
     }
+
+    /**
+     * 发送粮草先行活动开始通知
+     */
+    async raceActivityStart(serverId: number) {
+        await sendRaceStartMsg(serverId);
+    }
 }

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

@@ -1,5 +1,5 @@
 import { Application, ChannelService } from 'pinus';
-import { resetPvpSeasonTime, setPvpDefResult, guildActivityStart, gateActivityEnd, cityActivityEnd } from '../../../services/timeTaskService';
+import { resetPvpSeasonTime, setPvpDefResult, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd } from '../../../services/timeTaskService';
 import PvpDefenseType from '../../../db/PvpDefense';
 import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
 export default function (app: Application) {
@@ -33,4 +33,8 @@ export class SystimerRemote {
     public async cityActivityEnd() {
         return await cityActivityEnd();
     }
+
+    public async raceActivityEnd() {
+        return await raceActivityEnd();
+    }
 }

game-server/app/services/guildActivityService.ts

@@ -138,7 +138,6 @@ export function getRecordScore(aid: number, round: number, record: { round: numb
             let score = gameData.gateActivityPoint.get(enemyType);
             newRecords.push({ round, dataId, score, enemyType});
             sum += score;
-            console.log('*******', sum, score, enemyType);
 
             historyEnemies.push(dataId);            
         }
@@ -147,7 +146,6 @@ export function getRecordScore(aid: number, round: number, record: { round: numb
     for(let i = curRound + 1; i <= round; i++) {
         sum += gameData.gateActivityPoint.get(GET_POINT_WAYS.ROUND_START);
         memberRecord.round = i;
-        console.log('********', sum, i);
     }
 
     return { score: sum, newRecords, memberRecord }
@@ -313,6 +311,12 @@ export async function sendGuildActEndMsg(aid: number) {
             await autoDeclare(serverId);
         }
         cityActivityObj = new CityActivityObject();
+    } else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+        let obj = getRaceActivityObj();
+        let woodenHorseList = obj.getAllWoodenHorses();
+        for(let [guildCode, woodenHorse] of woodenHorseList) {
+            await raceActivitySettleReward(guildCode, woodenHorse);
+        }
     }
 }
 
@@ -351,6 +355,17 @@ export async function sendSingleCityActEndMsg(cityId: number, serverId: number)
 }
 
 
+/**
+ * 单个军团抵达赛道之后给他发奖励
+ * @param guildCode 军团code
+ */
+export async function sendSingleRaceActEndMsg(guildCode: string, woodenHorse: WoodenHorse) {
+    let chatSid = await getGuildChannelSid(guildCode);
+    pinus.app.rpc.chat.guildRemote.sendGuildActivityEnd.toServer(chatSid, guildCode);
+    await raceActivitySettleReward(guildCode, woodenHorse);
+}
+
+
 /**
  * 结算蛮夷入侵奖励
  * @param guildCode 军团code
@@ -534,14 +549,27 @@ export function getCityStatus(guildCode: string, cityId: number, preCity: number
     return status;
 }
 
+/**
+ * 每秒计算木牛流马状态并下发
+ * @param serverId 区id
+ */
 export async function calWoodenHorseAndSend(serverId: number) {
     console.log('calWoodenHorseAndSend');
     let guildKey = REDIS_KEY.RACE_ACTIVITY;
     let obj = getRaceActivityObj();
     let { ranks } = await getUnionRank(guildKey, serverId, '');
     let map = new Map<number, WoodenHorse[]>();
-    let user = new Map<number, string>();
 
+    let guildRank = new Array<SimpleGuildRankWithTimeParam>();
+    let l = ranks.length > 10?10: ranks.length;
+    for(let i = 0; i < l; i++) {
+        let { rank, code, name, num }  = ranks[i]
+        let _obj = await obj.getWoodenHorse(code, serverId);
+        let param = new SimpleGuildRankWithTimeParam(rank, code, name, num, _obj?_obj.time:0, _obj?_obj.durability:0);
+        guildRank.push(param);
+    }
+
+    // 找到往前和往后2艘船
     for(let i = 0; i < ranks.length; i++) {
         let { code } = ranks[i];
         for(let j = i; j <= i + 2; j++) {
@@ -549,23 +577,28 @@ export async function calWoodenHorseAndSend(serverId: number) {
                 map.set(j, new Array<WoodenHorse>());
             }
         }
-        user.set(i, code);
         for(let [rank, woodenHorseList] of map) {
-            let woodenHorse = await obj.getWoodenHorse(code, serverId);
-            if(woodenHorse) {
-                map.get(rank).push(woodenHorse);
-            } else {
-                map.get(rank).push(new WoodenHorse(rank.toString(), 's',0));
-            }
-            let len = map.get(rank).length;
             let limit = 5;
             if(rank - 2 < 0) limit += rank - 2;
             if(rank + 2 > ranks.length - 1) limit -= (rank + 2) - (ranks.length - 1);
 
+            let woodenHorse = await obj.getWoodenHorse(code, serverId);
+            if(!!woodenHorse) {
+                map.get(rank).push(woodenHorse);
+            } else {
+                limit --; // 理论上不能出现没有woodenHorse的情况，但是如果出现了，以防无返回
+            }
+            let len = map.get(rank).length;
             if( len >= limit) {
                 // 发送
-                let roleId = user.get(rank);
-                console.log('send', roleId, woodenHorseList.length, JSON.stringify(woodenHorseList));
+                console.log('send', woodenHorseList.length);
+                let curRank = ranks[rank];
+                let wh = await obj.getWoodenHorse(curRank.code, serverId);
+                let myGuildRank = new SimpleGuildRankWithTimeParam(curRank.rank, curRank.code, curRank.name, curRank.num, wh?wh.time:0, wh?wh.durability:0);
+
+                let chatSid = await getGuildChannelSid(curRank.code);
+                let events = obj.getEvents(curRank.code, wh?wh.distance:0);
+                pinus.app.rpc.chat.guildRemote.pushRaceHorseUpdate.toServer(chatSid, curRank.code, woodenHorseList, { guildRank, myGuildRank }, events);
 
                 map.delete(rank);
             }
@@ -573,4 +606,53 @@ export async function calWoodenHorseAndSend(serverId: number) {
     }
 
     return ;
+}
+
+/**
+ * 木牛流马活动开始信号
+ */
+export async function sendRaceStartMsg(serverId: number) {
+    let obj = getRaceActivityObj();
+    obj.startRace(); // 设置开启活动
+    
+    let chatSid = await getWorldChannelSid(serverId);
+    pinus.app.rpc.chat.chatRemote.sendRaceActivityStart.toServer(chatSid, serverId);
+    await calWoodenHorseAndSend(serverId);
+}
+
+
+/**
+ * 结算粮草先行奖励
+ * @param cityId 城镇id
+ * @param serverId 服务器id
+ */
+export async function raceActivitySettleReward(guildCode: string, woodenHorse: WoodenHorse) {
+    let { serverId, durability, distance } = woodenHorse;
+    let obj = getRaceActivityObj();
+    // 计算排名，计算耐久，发送奖励
+    let rank = await getMyUnionRank(REDIS_KEY.RACE_ACTIVITY, serverId, guildCode);
+
+    let isSuccess = distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH; // 血条未击破则没有占领军团
+    let myGuildRank = await getMyUnionRank(REDIS_KEY.RACE_ACTIVITY, serverId, guildCode);
+    let members = obj.getMembersOfGuild(guildCode);
+
+    let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, myGuildRank);
+    let rec = await GuildActivityRecordModel.updateInfo(guildCode, { 
+        memberCnt: members.length, members,
+        isSuccess, isCompleted: true, rank: myGuildRank,
+        rewards,
+        woodenHorse, 
+    });
+
+    // 奖励加入拍卖行
+    await genAuction(guildCode, AUCTION_SOURCE.GATE, rec.code, serverId, rewards);
+
+    let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
+    let honour = dic.honour + Math.floor(durability * GUILDACTIVITY.RACEACTIVITY_DURABILITY_REWARD);
+    for(let { roleId } of members) {
+        await updateUserRecAndSendHonour(honour, 0, rank, roleId, members);
+    }
+
+    // 删除数据
+    obj.deleteRecord(guildCode);
 }

game-server/app/services/redisService.ts

@@ -164,9 +164,9 @@ export async function setRank(key: string, serverId: number, myId: string, score
     } else {
         const _score = encodeScoreWithTime(score, timestamp);
         await redisClient().zaddAsync(getKeyName(key, serverId), _score, myId);
+        // 移除100名以外
+        await redisClient().zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
     }
-    // 移除100名以外
-    await redisClient().zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
 
     let infoKey = REDIS_RANK_TO_INFO.get(key)||REDIS_KEY.USER_INFO;
     // 如果没有信息，更新玩家信息
@@ -177,6 +177,21 @@ export async function setRank(key: string, serverId: number, myId: string, score
     return parseInt(newScore.toString());
 }
 
+export async function setRankWithoutUserInfo(key: string, serverId: number, myId: string, score: number, timestamp: number, isAtom = false, isInc = true, limit = 100) {
+    // 更新分数
+    let newScore = score;
+    if(isAtom) {
+        newScore = await updateRankAtom(key, serverId, myId, score, timestamp, isInc);
+    } else {
+        const _score = encodeScoreWithTime(score, timestamp);
+        await redisClient().zaddAsync(getKeyName(key, serverId), _score, myId);
+        // 移除100名以外
+        await redisClient().zremrangebyrankAsync(getKeyName(key, serverId), limit, 10000);
+    }
+
+    return parseInt(newScore.toString());
+}
+
 // 获取排行榜
 export async function getRank(key: string, serverId: number, roleId: string, limit = 100) {
 
@@ -563,14 +578,18 @@ function redisClient() {
  * @param score 得分
  * @param time 事件
  */
-async function updateRankAtom(key: string, serverId: number, field: string, score: number, timestamp: number) {
+async function updateRankAtom(key: string, serverId: number, field: string, score: number, timestamp: number, isInc = true) {
     let originKey = getKeyName(key, serverId);
     let timeKey = getKeyName(key, serverId, 'time');
 
     let timelen = 10;
     let pow = Math.pow(10, timelen + 1);
-
-    let newScore = await redisClient().zincrbyAsync(originKey, score, field);
+    let newScore = 0;
+    if(isInc) {
+        newScore = await redisClient().zincrbyAsync(originKey, score, field);
+    } else {
+        newScore = await redisClient().zaddAsync(originKey, score, field);
+    }
     await redisClient().zaddAsync(timeKey, pow - 1 - Math.floor(timestamp/1000), field);
 
     await redisClient().expireatAsync(originKey, getNextHourPoint(5));
@@ -729,6 +748,12 @@ export async function delGuildActivityRank(aid: number, params: Map<number, stri
                 }
             }
         }
+    } else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+        for(let [serverId] of params) {
+            await redisClient().delAsync(getKeyName(REDIS_KEY.RACE_ACTIVITY, serverId));
+            await redisClient().delAsync(getKeyName(REDIS_KEY.RACE_ACTIVITY, serverId, 'time'));
+            await redisClient().delAsync(getKeyName(REDIS_KEY.RACE_ACTIVITY, serverId, 'union'));
+        }
     }
 }
 

game-server/app/services/timeTaskService.ts

@@ -364,18 +364,25 @@ async function guildActivitySchedule() {
     if(!statusResult) return;
 
     if(statusResult.status == GUILD_ACTIVITY_STATUS.START) {
+        // 断掉活动续期
         if(!guildActSecondsJobId) {
             if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
                 guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/10 * * * * *`, gateActivitySeconds);
             } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
                 guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/10 * * * * *`, cityActivitySeconds);
             } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
-                // guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/1 * * * * *`, raceActivitySeconds);
+                guildActSecondsJobId = scheduleJob('guildActivitySeconds', `*/1 * * * * *`, raceActivitySeconds);
             }
         }
 
         if(!guildActEndJobId) {
-            guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, gateActivityEnd);
+            if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
+                guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, gateActivityEnd);
+            } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
+                guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, cityActivityEnd);
+            } else if(dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
+                guildActEndJobId = scheduleJob('guildActivityEnd', statusResult.time, raceActivityEnd);
+            }
         }
     }
 }
@@ -404,6 +411,17 @@ export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
         guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, cityActivityEnd);
     } else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
 
+        // 开始活动
+        let servers = await getAllServers(); // 玩家serverId列表
+        let guildServers = pinus.app.getServersByType('guild');
+        for(let serverId of servers) {
+            let sid = dispatch(serverId.toString(), guildServers);
+            await pinus.app.rpc.guild.guildActivityRemote.raceActivityStart.toServer(sid.id, serverId);
+        }
+
+        guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/1 * * * * *', raceActivitySeconds);
+        // 结束时间
+        guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, raceActivityEnd);
     }
     return true;
 }
@@ -419,8 +437,14 @@ export async function gateActivityEnd() {
         await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
     }
 
-    if(guildActSecondsJobId) guildActSecondsJobId.cancel();
-    if(guildActEndJobId) guildActEndJobId.cancel();
+    if(guildActSecondsJobId) {
+        guildActSecondsJobId.cancel();
+        guildActSecondsJobId = undefined;
+    }
+    if(guildActEndJobId) {
+        guildActEndJobId.cancel();
+        guildActEndJobId = undefined;
+    }
 }
 
 // 每10秒下发一次的任务
@@ -442,8 +466,14 @@ export async function cityActivityEnd() {
         await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
     }
 
-    if(guildActSecondsJobId) guildActSecondsJobId.cancel();
-    if(guildActEndJobId) guildActEndJobId.cancel();
+    if(guildActSecondsJobId) {
+        guildActSecondsJobId.cancel();
+        guildActSecondsJobId = undefined;
+    }
+    if(guildActEndJobId) {
+        guildActEndJobId.cancel();
+        guildActEndJobId = undefined;
+    }
 }
 
 // 每10秒下发一次的任务
@@ -455,6 +485,26 @@ export async function cityActivitySeconds() {
     }
 }
 
+// 粮草先行
+// 结束军团活动
+export async function raceActivityEnd() {
+    console.log('*****raceActivityEnd');
+    await sendEndMsgToAll();
+    let servers = pinus.app.getServersByType('guild');
+    for(let { id } of servers) {
+        await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.toServer(id, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
+    }
+
+    if(guildActSecondsJobId) {
+        guildActSecondsJobId.cancel();
+        guildActSecondsJobId = undefined;
+    }
+    if(guildActEndJobId) {
+        guildActEndJobId.cancel();
+        guildActEndJobId = undefined;
+    }
+}
+
 // 每10秒下发一次的任务
 export async function raceActivitySeconds() {
     console.log('*****raveActivitySeconds')

game-server/app/util/routeUtil.ts

@@ -80,7 +80,7 @@ export function guild(session: Session, msg: any, app: Application, cb: (err: Er
             } else if (['guild.raceActivityHandler.getRaceActivity',
                  'guild.raceActivityHandler.join',
                  'guild.raceActivityHandler.getRace',
-                ]) {
+                ].indexOf(arg.route) !== -1) {
                     rid = session.get('serverId').toString();
             }
             

shared/consts/statusCode.ts

@@ -207,6 +207,7 @@ export const STATUS = {
     CHALLENGE_TIME_NOT_REACH: { code: 21104, simStr: '挑战冷却中' },
     HAS_NOT_DECLARED: { code: 21105, simStr: '军团还未宣战过' },
     GUILD_ACTIVITY_IS_OPEN: { code: 21106, simStr: '活动已开启' },
+    RACE_HAS_JOIN: { code: 21107, simStr: '已登机' },
 
     // 通用 30000 - 30099
     DIC_DATA_NOT_FOUND: { code: 30000, simStr: '数据表未找到' },

shared/db/GuildActivityRec.ts

@@ -3,7 +3,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
 import { ItemReward } from '../domain/dbGeneral';
 import { getTodayZeroDate } from '../pubUtils/timeUtil';
 import { genCode } from '../pubUtils/util';
-import { Member } from '../domain/battleField/guildActivity'
+import { Member, WoodenHorse } from '../domain/battleField/guildActivity'
 
 
 @index({ code: 1 })
@@ -52,20 +52,11 @@ export default class GuildActivityRecord extends BaseModel {
     cityId: number;           // 诸侯混战占领了的城池
 
     @prop({ required: true })
-    damage: number;           // 对城门造成的伤害
-
-    @prop({ required: true })
-    raceTime: number;           // 粮草先行比赛时间（s)
-
-    @prop({ required: true })
-    distance: number;           // 粮草先行最后的距离
-
-    @prop({ required: true })
-    speed: number;              // 粮草先行最后的速度（m/s)
-
-    @prop({ required: true })
-    durability: number;         // 粮草先行最后的耐久度
+    damage: number;           // 诸侯混战
 
+    @prop({ required: true, _id: false })
+    woodenHorse: WoodenHorse;   // 粮草先行木马
+    
     // 每天一条记录
     public static async getRecord(guildCode: string, serverId: number, aid: number) {
         let today = getTodayZeroDate();

shared/domain/battleField/guildActivity.ts

@@ -1,13 +1,17 @@
 import { GUILDACTIVITY } from "../../pubUtils/dicParam";
 import { SimpleGuildRankParam, SimpleRoleRankParam, GuildRankParam } from '../rank'
 import { prop } from "@typegoose/typegoose";
-import { CITY_STATUS, RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, REDIS_KEY, RACE_EVENT } from "../../consts";
-import { gameData } from "../../pubUtils/data";
+import { CITY_STATUS, RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, REDIS_KEY, RACE_EVENT, STATUS } from "../../consts";
+import { gameData, getRaceEventItems } from "../../pubUtils/data";
 import { GuildModel } from "../../db/Guild";
-import { getRandEelm, sortArrRandom } from "../../pubUtils/util";
+import { getRandEelm, sortArrRandom, resResult } from "../../pubUtils/util";
 import { RoleType } from "../../db/Role";
-import { setRank, getMyUnionRank } from "../../services/redisService";
+import { setRank, getMyUnionRank, setRankWithoutUserInfo } from "../../services/redisService";
 import { RewardInter } from "../../pubUtils/interface";
+import { pinus } from "pinus";
+import { homedir } from "os";
+import { sendSingleRaceActEndMsg } from "../../services/guildActivityService";
+import { getGuildChannelSid } from "../../services/chatService";
 
 export class GateMembersRec {
     roleId: string;
@@ -216,27 +220,39 @@ export class RaceActivityObject {
     private events: Map<string, Event[]> = new Map(); // 每个军团遇到的事件
     private items: Map<string, RewardInter[]> = new Map(); // 每个玩家的道具 roleId => [{id, count}]
 
-    hasJoin(guildCode: string, roleId: string) {
+    // 是否加入过
+    public hasJoin(guildCode: string, roleId: string) {
         let member = this.members.get(guildCode)||[];
         return member.findIndex(cur => cur.roleId == roleId) != -1;
     }
 
-    pushMember(guildCode: string, roleId: string, job: number) {
+    // 加入member
+    private pushMember(guildCode: string, roleId: string, job: number) {
         if(!this.members.has(guildCode)) {
             this.members.set(guildCode, []);
         }
         this.members.get(guildCode).push({roleId, job});
     }
 
-    joinWoodenHorse(guildCode: string, roleId: string, roleName: string, job: number) {
-        if(!this.woodenHorses.has(guildCode)) return false;
-        let woodenHorse = this.woodenHorses.get(guildCode).joinMember(roleId, roleName);
+    public getMembersOfGuild(guildCode: string) {
+        return this.members.get(guildCode)||[];
+    }
+    
+    public getAllWoodenHorses() {
+        return this.woodenHorses;
+    }
+
+    public async joinWoodenHorse(guildCode: string, roleId: string, roleName: string, serverId: number, sid: string, job: number) {
+        let woodenHorse = await this.getWoodenHorse(guildCode, serverId);
+        if(!woodenHorse) return false;
+        woodenHorse.joinMember(roleId, roleName, sid)
         this.pushMember(guildCode, roleId, job);
-        let events = this.events.get(guildCode)||[];
-        return woodenHorse.getCurWoodenHorse(events);
+        this.handleItems(woodenHorse);
+        return woodenHorse;
     } 
 
-    async getWoodenHorse(guildCode: string, serverId: number) {
+    // 获取某个军团的木马状态
+    public async getWoodenHorse(guildCode: string, serverId: number) {
         if(!this.woodenHorses.has(guildCode)) {
             this.initEvents(guildCode);
             let guild = await GuildModel.findByCode(guildCode, serverId);
@@ -245,15 +261,55 @@ export class RaceActivityObject {
             let guildRankParam = new GuildRankParam(guild.icon, guild.name, guild.lv, leader);
             await setRank(REDIS_KEY.RACE_ACTIVITY, serverId, guild.code, 0, Math.pow(10, 11) - guild.guildCe, guildRankParam, true);
             let { name: guildName, guildCe } = guild;
-            this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe))
+            this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId))
         }
         let woodenHorse = this.woodenHorses.get(guildCode);
         let events = this.events.get(guildCode)||[];
-        return woodenHorse.getCurWoodenHorse(events);
+        woodenHorse.calCurWoodenHorse(events);
+        if(woodenHorse.status == 1 || woodenHorse.status == 2) { // 更新距离
+            await setRankWithoutUserInfo(REDIS_KEY.RACE_ACTIVITY, serverId, guildCode, woodenHorse.distance, Math.floor((woodenHorse.time - woodenHorse.startTime)/1000), true, false);
+            if (woodenHorse.status == 2) { // 抵达后发送奖励，发送消息，结算
+                await sendSingleRaceActEndMsg(guildCode, woodenHorse);
+            }
+        }
+        this.handleItems(woodenHorse);
+        return woodenHorse;
+    }
+
+    public async useItem(fromRoleId: string, sid: string, fromGuild: string, toGuild: string, id: number, count: number) {
+        let rec = this.handleItem(fromRoleId, sid, id, count);
+        if(!rec) return rec;
+        let event = new Event(id, fromGuild, toGuild, count);
+        if(!this.events.has(toGuild)) {
+            this.events.set(toGuild, [event]);
+        } else {
+            this.events.get(toGuild).push(event);
+        }
+        let chatSid = await getGuildChannelSid(toGuild);
+        pinus.app.rpc.chat.guildRemote.sendRaceEvent.toServer(chatSid, toGuild, [event]);
+    }
+
+    // 定时任务到，开始比赛，设置开始赛道，发放初始道具
+    public startRace() {
+        let guildCodes = new Array<string>();
+        for(let [code, woodenHorse] of this.woodenHorses) {
+            woodenHorse.status = 1;
+            woodenHorse.time = Date.now();
+            woodenHorse.startTime = Date.now();
+            let members = woodenHorse.members;
+            for(let { roleId, sid } of members) {
+                let item = getRaceEventItems();
+                for(let { id, count } of item) {
+                    this.handleItem(roleId, sid, id, count);
+                }
+            }
+            guildCodes.push(code);
+        }
+        return guildCodes;
     }
     
     // 初始进入就随机9个灵球事件
-    initEvents(guildCode: string) {
+    public initEvents(guildCode: string) {
         if(!this.events.get(guildCode)) {
             this.events.set(guildCode, []);
         }
@@ -279,7 +335,7 @@ export class RaceActivityObject {
         }
     }
 
-    getEvents(guildCode: string, distance: number) {
+    public getEvents(guildCode: string, distance: number) {
         let events = this.events.get(guildCode)||[];
         let result = new Array<Event>();
         for(let event of events) {
@@ -295,7 +351,16 @@ export class RaceActivityObject {
         return result;
     }
 
-    handleItem(roleId: string, id: number, inc: number) {
+    private handleItems(woodenHorse: WoodenHorse) {
+        let { members } = woodenHorse;
+        for(let { roleId, sid, items = [] } of members) {
+            for(let {id, count} of items) {
+                this.handleItem(roleId, sid, id, count);
+            }
+        }
+    }
+
+    private handleItem(roleId: string, sid: string, id: number, inc: number) {
         let items = this.items.get(roleId)||[];
         let curItem = items.find(cur => cur.id == id);
         if(!curItem && inc < 0) return false;
@@ -305,39 +370,90 @@ export class RaceActivityObject {
         }
         if(curItem.count + inc < 0 ) return false;
         curItem.count += inc;
+        let uids = [{uid: roleId, sid}];
+        pinus.app.get('channelService').pushMessageByUids('onRaceItemUpdate', resResult(STATUS.SUCCESS, { items }), uids);
         return items;
     }
+
+    public deleteRecord(guildCode: string) {
+        let members = this.members.get(guildCode);
+        this.woodenHorses.delete(guildCode);
+        this.events.delete(guildCode);
+        for(let roleId of members) {
+            this.items.delete(roleId.roleId);
+        }
+        this.members.delete(guildCode);
+    }
 }
 
 class WoodenHorseMember {
     roleId: string;
     roleName: string;
+    sid: string;
+    items?: RewardInter[];
 }
 
 // 木牛流马
 export class WoodenHorse {
+    @prop({required: true})
+    serverId: number = 0;               // 服务器id
+    @prop({required: true})
     guildCode: string = "";             // 军团code 木马的唯一标识
+    @prop({required: true})
     guildName: string = "";             // 军团名
+    @prop({required: true})
     guildCe: number = 0;                // 军团战力
+    @prop({required: true})
+    status: number = 0;                 // 状态 0-停止 1-开启 2-结束
+    @prop({required: true})
     speed: number = 0;                  // 速度
+    @prop({required: true})
     durability: number = 100;           // 耐久度
+    @prop({required: true})
     distance: number = 0;               // 距离
+    @prop({required: true})
+    startTime: number = 0;              // 开始时间
+    @prop({required: true})
     time: number = 0;                   // 到达时间
+    @prop({required: true})
     memberCnt: number = 0;              // 成员人数
+    @prop({required: true})
     members: WoodenHorseMember[] = [];  // 成员
+    @prop({required: true})
     shield: number = 0;                 // 护盾数量
+    @prop({required: true})
     shieldTime: number = 0;             // 天师盾符
+    @prop({required: true})
+    stopContinueTime: number = 0;           // 鬼手阴符
 
-    constructor(guildCode: string, guildName: string, guildCe: number) {
+    constructor(guildCode: string, guildName: string, guildCe: number, serverId: number) {
         this.guildCode = guildCode;
         this.guildName = guildName;
         this.guildCe = guildCe;
+        this.serverId = serverId;
     }
 
-    getCurWoodenHorse(events: Event[]) {
-        this.distance += (Date.now() - this.time) * this.speed;
+    public calCurWoodenHorse(events: Event[]) {
+        if(this.status == 0 && this.stopContinueTime && Date.now() > this.stopContinueTime) {
+            this.status = 1; this.stopContinueTime = 0;
+        }
+
+        if(this.status == 1) {
+            this.distance += Math.floor((Date.now() - this.time)/1000 * 10 * this.speed)/10; // 1位小数点
+            this.time = Date.now();
+
+            if(this.distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH) {
+                this.distance = GUILDACTIVITY.RACEACTIVITY_LENGTH;
+                // TODO发送结束信号
+                this.status = 2;
+                return false;
+            }
+        }
         let effectiveEvents = new Array<Event>();
-        for(let event of events) {
+        let delEvents = new Array<number>();
+        for(let i = 0; i < events.length; i++) {
+            let event = events[i];
+            console.log('******', this.distance, event.startDistance, event.endDistance)
             if(!event.startTime && event.startDistance && this.distance > event.startDistance) {
                 let startTime = Date.now() - Math.floor((this.distance - event.startDistance) / this.speed);
                 event.setStartTime(startTime); // 距离生效的事件的实际生效时间，主要用于速度叠加顺序
@@ -347,21 +463,24 @@ export class WoodenHorse {
                 isEffective = true;
             } else if (event.startDistance <= this.distance && event.endDistance > this.distance) {
                 isEffective = true;
+            } else if (event.endTime < Date.now() || event.endDistance < this.distance) {
+                delEvents.push(i);
             }
             if(isEffective) {
                 effectiveEvents.push(event);
             }
         }
+        for(let i of delEvents) events.splice(i, 1); // 删除过期事件
         effectiveEvents.sort((a, b) => a.startTime - b.startTime);
-        this.speed = this.memberCnt * 1;
+        this.speed = this.memberCnt * 10;
+        console.log('******', effectiveEvents.length);
         for(let { id, count, endTime } of effectiveEvents) {
             this.calEvent(id, count, endTime);
         }
-
         return this;
     }
 
-    calEvent(id: number, count: number = 1, endTime?: number) {
+    private calEvent(id: number, count: number = 1, endTime?: number) {
         let { effect } = gameData.raceActivityEvents.get(id);
 
         switch (id) {
@@ -375,7 +494,10 @@ export class WoodenHorse {
                 }
                 break;
             case RACE_EVENT.GUISHOUYINFU:
-                if (this.shieldTime > Date.now()) this.speed = 0;
+                if (this.shieldTime > Date.now()) {
+                    this.stopContinueTime = endTime;
+                    this.status = 0;
+                }
                 break;
             case RACE_EVENT.FENGCHE:
             case RACE_EVENT.WUGUIBANYUNFU:
@@ -396,13 +518,25 @@ export class WoodenHorse {
                 this.speed -= effect[0]; break;
             case RACE_EVENT.SHANGHAI_1:
                 this.durability -= effect[0]; break;
+            case RACE_EVENT.ITEM:
+                let ranMember: WoodenHorseMember[] = getRandEelm(this.members, GUILDACTIVITY.RACEACTIVITY_EVENT_MEMBERCNT);
+                if(ranMember.length <= 0) ranMember = this.members;
+                for(let obj of ranMember) {
+                    let item = gameData.raceEventItems;
+                    obj.items = obj.items.concat(item);
+                }
+                for(let obj of this.members) {
+                    let item = getRaceEventItems();
+                    obj.items = obj.items.concat(item);
+                }
+                break;
         }
     }
 
 
-    joinMember(roleId: string, roleName: string) {
+    public joinMember(roleId: string, roleName: string, sid: string) {
         if(this.members.findIndex(cur => cur.roleId == roleId) == -1) {
-            this.members.push({ roleId, roleName });
+            this.members.push({ roleId, roleName, sid });
             this.speed++;
             this.memberCnt++;
         }
@@ -445,10 +579,10 @@ export class Event {
     }
 }
 
-export interface GuildGateRankParam {
+export interface GuildRankParams {
     guildRank: SimpleGuildRankParam[],
     myGuildRank: SimpleGuildRankParam,
-    memberRank: SimpleRoleRankParam[],
+    memberRank?: SimpleRoleRankParam[],
     myMemberRank?: SimpleRoleRankParam
 }
 

shared/pubUtils/data.ts

@@ -67,7 +67,7 @@ import { dicChatAccuse } from "./dictionary/DicChatAccuse";
 import { dicCityActivityReward } from "./dictionary/DicCityActivityReward";
 import { dicRaceActivity, dicRaceTypes } from './dictionary/DicRaceActivity';
 import { GUILDACTIVITY } from "./dicParam";
-import { decodeIdCntArrayStr } from "./util";
+import { decodeIdCntArrayStr, parseGoodStr, decodeArrayListStr, getRandValueByMinMax } from "./util";
 import { GUILD_SELECT, RACE_EVENT_TYPE } from "../consts";
 
 export const gameData = {
@@ -160,6 +160,8 @@ export const gameData = {
     raceActivityEvents: dicRaceActivity,
     raceTypes: dicRaceTypes,
     raceActivityEncounter: decodeRaceActivityEncounter(),
+    raceNormalItems: decodeRaceNormalItems(),
+    raceEventItems: parseGoodStr(GUILDACTIVITY.RACEACTIVITY_EVENT_ITEMS||"")
 };
 
 // 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -509,4 +511,29 @@ function decodeRaceActivityEncounter() {
         newMap.set(parseInt(key), parseInt(value));
     }
     return { events: newMap, eventNum };
+}
+
+function decodeRaceNormalItems() {
+    let str = GUILDACTIVITY.RACEACTIVITY_NORMAL_ITEMS;
+
+    let result = new Array<{ id: number, min: number, max: number }>();
+    if (!str) return result;
+    let decodeArr = decodeArrayListStr(str);
+    for (let [id, min, max] of decodeArr) {
+        if (isNaN(parseInt(id)) || isNaN(parseInt(min)) || isNaN(parseInt(max))) {
+            throw new Error('data table format wrong');
+        }
+        result.push({ id: parseInt(id), min: parseInt(min), max: parseInt(max) });
+    }
+    return result
+}
+
+export function getRaceEventItems() {
+    let items = gameData.raceNormalItems;
+    let result = new Array<RewardInter>();
+    for(let {id, min, max} of items) {
+        let count = getRandValueByMinMax(min, max);
+        result.push({ id, count });
+    }
+    return result;
 }

shared/resource/jsons/dic_zyz_guildActivity.json

@@ -4,8 +4,8 @@
         "name": "蛮夷入侵",
         "openDay": "",
         "duringTime": 900,
-        "startTime": 16,
-        "startMinute": 15,
+        "startTime": 20,
+        "startMinute": 0,
         "countDown": 5,
         "warid": 7001,
         "honour": 500
@@ -15,8 +15,8 @@
         "name": "诸侯混战",
         "openDay": "",
         "duringTime": 900,
-        "startTime": 11,
-        "startMinute": 48,
+        "startTime": 20,
+        "startMinute": 0,
         "countDown": 5,
         "warid": 7002,
         "honour": 500
@@ -25,9 +25,9 @@
         "id": 3,
         "name": "粮草先行",
         "openDay": "1&5&6",
-        "duringTime": 600000,
-        "startTime": 9,
-        "startMinute": 48,
+        "duringTime": 600,
+        "startTime": 20,
+        "startMinute": 0,
         "countDown": 5,
         "warid": 0,
         "honour": 200