diff --git a/game-server/app/servers/guild/handler/raceActivityHandler.ts b/game-server/app/servers/guild/handler/raceActivityHandler.ts
index e6f4f6e56..e26c7490e 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 } from "../../../consts";
+import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, GUILD_POINT_WAYS, REDIS_KEY, TASK_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS } from "../../../consts";
 import { resResult } from "../../../pubUtils/util";
-import { getGuildActivityStatus, getRaceActivityObj, getRaceActivityRank, getWoodenHorseList, calWoodenHorseAndSend, raceActivitySettleReward } from "../../../services/guildActivity/guildActivityService";
+import { getGuildActivityStatus, getRaceActivityObj, getWoodenHorseList, calWoodenHorseAndSend, raceActivitySettleReward } from "../../../services/guildActivity/guildActivityService";
 import { UserGuildModel } from "../../../db/UserGuild";
 import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
 import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -12,6 +12,8 @@ import { guildInter } from "../../../pubUtils/interface";
 import { getGuildChannelSid } from "../../../services/chatService";
 import { ServerRecordModel } from "../../../db/ServerRecords";
 import { sendMessageToGuildWithSuc } from "../../../services/pushService";
+import { RaceActivityRankParam } from "../../../domain/battleField/guildActivity";
+import { GuildRankInfo } from "../../../domain/rank";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -43,9 +45,21 @@ export class RaceActivityHandler {
         if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         let events = obj.getEvents(guildCode, woodenHorse.distance);
-        let ranks = await getRaceActivityRank(guildCode, serverId);
+        let ranks: { myGuildRank?: RaceActivityRankParam, guildRank?: RaceActivityRankParam[] } = {};
         let hasJoin = obj.getMember(guildCode, roleId);
 
+        if(obj.status == RACE_ACTIVITY_STATUS.START) {
+            ranks = await obj.getRanks(serverId, guildCode);
+        } else {
+            let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
+            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 };
+            });
+            let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
+            ranks = { guildRank, myGuildRank }
+        }
+
 
         return resResult(STATUS.SUCCESS, {
             ...statusResult,
@@ -185,15 +199,23 @@ export class RaceActivityHandler {
             await UserGuildActivityRecModel.updateInfo(code, { hasShow: true });
         }
 
+        // 返回当前军团总军功
         let obj = getRaceActivityObj();
+        let myGuildRank = 0;
         let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
-        if(!woodenHorse) { // 已被结算
+        if(obj.status == RACE_ACTIVITY_STATUS.START) {
+            let { myGuildRank: rank, guildRank } = await obj.getRanks(serverId, guildCode);
+            console.log('#', JSON.stringify(guildRank))
+            myGuildRank = rank?.rank||0;
+            if(woodenHorse) {
+                console.log('########', woodenHorse.time - woodenHorse.allStartTime, rank.sortTime);
+                woodenHorse = woodenHorse.getTreatTime();
+            }
+        } else {
             woodenHorse = guildActivityRec.woodenHorse;
+            myGuildRank = guildActivityRec.rank;
         }
 
-        // 返回当前军团总军功
-        let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
-        let myGuildRank = await r.getMyRank({ guildCode });
 
         return resResult(STATUS.SUCCESS, {
             timestamp: Date.now(),
diff --git a/game-server/app/services/guildActivity/guildActivityService.ts b/game-server/app/services/guildActivity/guildActivityService.ts
index b0f83737a..eaf97519b 100644
--- a/game-server/app/services/guildActivity/guildActivityService.ts
+++ b/game-server/app/services/guildActivity/guildActivityService.ts
@@ -8,8 +8,7 @@ import { Record, UserGuildActivityRecModel } from "../../db/UserGuildActivityRec
 import { GateMembersRec, CityParam, Member, WoodenHorse } from "../../domain/battleField/guildActivity";
 import { DicGuildActivity } from "../../pubUtils/dictionary/DicGuildActivity";
 import { getAllServers, getRoleOnlineInfo } from "../redisService";
-import { SimpleGuildRankParam, SimpleRoleRankParam, SimpleGuildRankWithTimeParam, GuildRankInfo, RoleRankInfo } from "../../domain/rank";
-import { getGuildChannelSid, getWorldChannelSid, getCityChannelSid } from "../chatChannelService";
+import { SimpleGuildRankParam, SimpleRoleRankParam, GuildRankInfo, RoleRankInfo } from "../../domain/rank";
 import { pinus } from "pinus";
 import { GuildActivityRecordModel } from "../../db/GuildActivityRec";
 import { genAuction } from "../auctionService";
@@ -22,7 +21,6 @@ import { RaceActivityObject } from "./raceActivityObj";
 import { Rank } from "../rankService";
 import { BossInstanceModel } from "../../db/BossInstance";
 import { UserGuildModel } from "../../db/UserGuild";
-import { raceActivityEnd } from "../timeTaskService";
 import { addActive } from "../guildService";
 import { ActivePlayer, GuildRecord, ServerRecordModel } from "../../db/ServerRecords";
 import { Attack } from "../../domain/battleField/pvp";
@@ -222,25 +220,6 @@ export async function getCityActivityRank(guildCode: string, serverId: number, c
 
     return { guildRank, myGuildRank, memberRank, myMemberRank }
 }
-
-export async function getRaceActivityRank(guildCode: string, serverId: number) {
-    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId }, true);
-    r.setGenerFieldsFun(generField);
-    let { myRank, ranks } = await r.getRankListWithMyRank({ guildCode });
-    if (!myRank) {
-        myRank = await r.generMyRankWithGuild(guildCode, 0, 0);
-    }
-
-    return { guildRank: ranks, myGuildRank: myRank }
-}
-
-
-function generField(params: GuildRankInfo) {
-    let { rank, code, name, num, time } = params;
-    let param = new SimpleGuildRankWithTimeParam(rank, code, name, { distance: num / 1000, time: Math.floor(time), startTime: 0, durability: 0 });
-    return param;
-}
-
 /**
  * 获取和自己同屏的5个木牛流马
  * @param guildCode 
@@ -248,17 +227,18 @@ function generField(params: GuildRankInfo) {
  */
 export async function getWoodenHorseList(guildCode: string, serverId: number) {
     let obj = getRaceActivityObj();
-    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId }, true, 5);
+    let { myGuildRank, guildRank } = await obj.getRanks(serverId, guildCode);
 
-    let myRank = await r.getMyRank({ guildCode });
+    let myRank = myGuildRank?.rank||0;
     let startRank = myRank - 2 > 0 ? myRank - 2 : 1;
     let endRank = startRank + 4;
-    let range = <GuildRankInfo[]>await r.getRankByRange(startRank, endRank);
     let woodenHorseList = new Array<WoodenHorse>();
-    for (let { code } of range) {
-        let woodenHorse = await obj.getWoodenHorse(code, serverId);
-        if (woodenHorse) {
-            woodenHorseList.push(woodenHorse);
+    for (let { rank, code } of guildRank) {
+        if(rank >= startRank && rank <= endRank) {
+            let woodenHorse = await obj.getWoodenHorse(code, serverId);
+            if (woodenHorse) {
+                woodenHorseList.push(woodenHorse);
+            }
         }
     }
     return woodenHorseList;
@@ -618,33 +598,10 @@ export async function sendGuildCityDeclare(cityId: number, declareGuildCode: str
  */
 export async function calWoodenHorseAndSend(serverId: number) {
     console.log('calWoodenHorseAndSend');
-    let guildKey = REDIS_KEY.RACE_ACTIVITY;
     let obj = getRaceActivityObj();
-    let calResult = new Map<string, WoodenHorse>();
-    for(let [code] of obj.getAllWoodenHorses()) {
-        let _obj = await obj.getWoodenHorse(code, serverId);
-        if(_obj) calResult.set(code, _obj);
-    }
+    let { guildRank: ranks } = await obj.getRanks(serverId);
 
-    let fun = async function (param: GuildRankInfo) {
-        let { rank, code, name } = param;
-        let _obj = calResult.get(code);
-        return new SimpleGuildRankWithTimeParam(rank, code, name, _obj);
-    }
-    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId }, true);
-    r.setGenerFieldsFun(fun);
-    let ranks = <GuildRankInfo[]>await r.getRankByRange();
     let map = new Map<number, WoodenHorse[]>();
-
-    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, _obj);
-        guildRank.push(param);
-    }
-
     // 找到往前和往后2艘船
     for (let i = 0; i < ranks.length; i++) {
         let { code } = ranks[i];
@@ -670,15 +627,13 @@ export async function calWoodenHorseAndSend(serverId: number) {
                 // 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, wh);
                 let events = obj.getEvents(curRank.code, wh ? wh.distance : 0);
-                await sendMessageToGuildWithSuc(curRank.code, PUSH_ROUTE.GUILD_RACE_UPDATE, { timestamp: Date.now(), woodenHorseList, guildRank, myGuildRank, events });
+                await sendMessageToGuildWithSuc(curRank.code, PUSH_ROUTE.GUILD_RACE_UPDATE, { timestamp: Date.now(), woodenHorseList, guildRank: ranks, myGuildRank: curRank, events });
 
                 map.delete(rank);
             }
         }
     }
-    calResult.clear();
     return;
 }
 
@@ -703,17 +658,21 @@ export async function raceActivitySettleReward(guildCode: string, woodenHorse: W
     let { serverId, durability, distance } = woodenHorse;
     let obj = getRaceActivityObj();
     // 计算排名，计算耐久，发送奖励
-    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId }, true);
+    let { guildRank, myGuildRank } = await obj.getRanks(serverId, guildCode);
+    let rank = myGuildRank?.rank||0;
+
+    let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
+    await r.setRankWithGuildInfo2(guildCode, myGuildRank.num, myGuildRank.sortTime, myGuildRank.durability);
+
     let isSuccess = distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH; // 血条未击破则没有占领军团
-    let myGuildRank = await r.getMyRank({ guildCode });
     let members = obj.getMembersOfGuild(guildCode);
 
-    let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, myGuildRank);
+    let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, rank);
     let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, {
         memberCnt: members.length, members,
-        isSuccess, isCompleted: true, rank: myGuildRank,
+        isSuccess, isCompleted: true, rank,
         rewards: rewards.map(cur => cur.goods),
-        woodenHorse,
+        woodenHorse: woodenHorse.getTreatTime(),
     });
     if (rec) {
         // 奖励加入拍卖行
@@ -723,9 +682,7 @@ export async function raceActivitySettleReward(guildCode: string, woodenHorse: W
         let honour = dic.honour + Math.floor(durability * GUILDACTIVITY.RACEACTIVITY_DURABILITY_REWARD);
 
         for(let { roleId } of members) {
-            await updateUserRecAndSendHonour(honour, 0, myGuildRank, roleId, members);
-            
-            let onlineUser = await getRoleOnlineInfo(roleId);
+            await updateUserRecAndSendHonour(honour, 0, rank, roleId, members);
             // 发放活跃
             await addActive(roleId, serverId, GUILD_POINT_WAYS.ACTIVITY);  //获得活跃值
         }
diff --git a/game-server/app/services/guildActivity/raceActivityObj.ts b/game-server/app/services/guildActivity/raceActivityObj.ts
index c9a0b9e39..55aeb9a0d 100644
--- a/game-server/app/services/guildActivity/raceActivityObj.ts
+++ b/game-server/app/services/guildActivity/raceActivityObj.ts
@@ -1,22 +1,19 @@
 
 // 军团活动蛮夷入侵城门血量等数据存储
 
-import { Member, GateMembersRec, WoodenHorse, Event, WoodenHorseMember } from "../../domain/battleField/guildActivity";
+import { Member, GateMembersRec, WoodenHorse, Event, WoodenHorseMember, RaceActivityRankParam } from "../../domain/battleField/guildActivity";
 import { RewardInter } from "../../pubUtils/interface";
 import { getRaceEventItems, gameData } from "../../pubUtils/data";
 import { GuildModel } from "../../db/Guild";
 import { sendSingleRaceActEndMsg } from "./guildActivityService";
-import { REDIS_KEY, RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, RACE_EVENT, STATUS, RACE_ACTIVITY_STATUS, PUSH_ROUTE } from "../../consts";
-import { getGuildChannelSid } from "../chatService";
-import { pinus } from "pinus";
+import { REDIS_KEY, RACE_EVENT_TYPE, RACE_EVENT_EFFECT_TYPE, RACE_EVENT, STATUS, RACE_ACTIVITY_STATUS, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../consts";
 import { getRandEelm, sortArrRandom, resResult, getRandResultByMember } from "../../pubUtils/util";
-import { Rank } from "../rankService";
-import { getTimeFun } from "../../pubUtils/timeUtil";
 import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from "../pushService";
 
 // 粮草先行
 export class RaceActivityObject {
-    private status = RACE_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
+    public status = RACE_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束 
+    private allStartTime = 0; // 开启时间，每天晚上8点
     public guildList: Array<{ serverId: number, guildCode: string }> = []; // 所有军团
     private members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
     private woodenHorses: Map<string, WoodenHorse> = new Map(); // 每个军团的木牛流马 guildCode => WoodenHorse
@@ -50,6 +47,39 @@ export class RaceActivityObject {
         return this.woodenHorses;
     }
 
+    public async getRanks(serverId: number, guildCode?: string) {
+        let myRank: RaceActivityRankParam = null;
+        let ranks: RaceActivityRankParam[] = [];
+        for(let [_, _wh] of this.woodenHorses) {
+            if(_wh.serverId == serverId && _wh.status != GUILD_ACTIVITY_STATUS.WAITING) {
+                let wh = await this.getWoodenHorse(_wh.guildCode, _wh.serverId);
+                if(wh) {
+                    ranks.push(new RaceActivityRankParam(wh));
+                }
+            }
+        }
+        ranks.sort((a, b) => {
+            if(a.sortDistance == b.sortDistance) {
+                return a.sortTime - b.sortTime;
+            } else {
+                return b.sortDistance - a.sortDistance;
+            }
+        }).map((wh, index) => {
+            wh.setRank(index + 1);
+            if(guildCode && wh.code == guildCode) {
+                myRank = wh;
+            }
+            return wh
+        });
+
+        if(!myRank && guildCode) {
+            let myWoodenHorse = await this.getWoodenHorse(guildCode, serverId);
+            if(myWoodenHorse) myRank = new RaceActivityRankParam(myWoodenHorse);
+        }
+
+        return { guildRank: ranks, myGuildRank: myRank }
+    }
+
     public async joinWoodenHorse(guildCode: string, roleId: string, roleName: string, serverId: number, sid: string, job: number, code: string) {
         let woodenHorse = await this.getWoodenHorse(guildCode, serverId);
         if(!woodenHorse) return false;
@@ -70,23 +100,16 @@ export class RaceActivityObject {
             let guild = await GuildModel.findByCode(guildCode, serverId);
             if(!guild) return false;
             let { name: guildName, guildCe } = guild;
-            this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId));
+            this.woodenHorses.set(guildCode, new WoodenHorse(guildCode, guildName, guildCe, serverId, this.allStartTime));
             this.guildList.push({guildCode, serverId});
         }
         let woodenHorse = this.woodenHorses.get(guildCode);
         let events = this.events.get(guildCode)||[];
         let needSendEnd = woodenHorse.calCurWoodenHorse(events);
-
-        if(woodenHorse.status == RACE_ACTIVITY_STATUS.START || woodenHorse.status == RACE_ACTIVITY_STATUS.END) { // 更新距离 
-            let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId }, true, 5);
-            await r.setRank({guildCode}, [Math.floor(woodenHorse.distance * 1000), woodenHorse.time], false);
-            let tomorrow = <number>getTimeFun().getAfterDayWithHour();
-            await r.setExpire(tomorrow);
-
-            if (needSendEnd) { // 抵达后发送奖励，发送消息，结算
-                await sendSingleRaceActEndMsg(guildCode, woodenHorse);
-            }
+        if (needSendEnd) { // 抵达后发送奖励，发送消息，结算
+            await sendSingleRaceActEndMsg(guildCode, woodenHorse);
         }
+            
         this.handleItemsByWoodenHorse(woodenHorse);
         return woodenHorse;
     }
@@ -109,6 +132,7 @@ export class RaceActivityObject {
     // 定时任务到，开始比赛，设置开始赛道，发放初始道具
     public startRace() {
         this.status = RACE_ACTIVITY_STATUS.START;
+        if(this.allStartTime == 0) this.allStartTime = Date.now();
         let guildCodes = new Array<string>();
         for(let [code, woodenHorse] of this.woodenHorses) {
             if(woodenHorse.memberCnt > 0) {
@@ -120,9 +144,7 @@ export class RaceActivityObject {
     }
 
     private woodenHorseStartRace(woodenHorse: WoodenHorse) {
-        woodenHorse.status = RACE_ACTIVITY_STATUS.START;
-        woodenHorse.time = Date.now();
-        woodenHorse.startTime = Date.now();
+        woodenHorse.startRace(this.allStartTime);
         let members = woodenHorse.members;
         let normalItems = getRaceEventItems();
         this.sendRandItemsToMembers(members, woodenHorse, normalItems);
diff --git a/game-server/app/services/rankService.ts b/game-server/app/services/rankService.ts
index 3bf6416a7..c463390f2 100644
--- a/game-server/app/services/rankService.ts
+++ b/game-server/app/services/rankService.ts
@@ -62,8 +62,9 @@ export class Rank {
                 break;
             case REDIS_KEY.RACE_ACTIVITY:
                 this.valueConfig = [
-                    new ValueConfig(true, 'score', 0, false, false),
-                    new ValueConfig(false, 'time', 10, true, true)
+                    new ValueConfig(true, 'distance', 0, false, false),
+                    new ValueConfig(false, 'time', 6, true, true),
+                    new ValueConfig(false, 'durability', 3, false, false),
                 ];
                 break;
             case REDIS_KEY.GUILD_LV_RANK:
@@ -83,7 +84,7 @@ export class Rank {
         for(let i = 0; i < this.valueConfig.length; i++) {
             let weight = 0;
             for(let j = i + 1; j < this.valueConfig.length; j++) {
-                weight = this.valueConfig[j].len;
+                weight += this.valueConfig[j].len;
             }
             this.valueConfig[i].setWeight(weight);
         }
@@ -155,8 +156,8 @@ export class Rank {
         return await this.setRankWithGuildInfoArrParam(guildCode, [score, timestamp], guild, isInc);
     }
 
-    public async setRankWithGuildInfo2(guildCode: string, lv: number, active: number, timestamp: number, guild?: GuildType, isInc = false) {
-        return await this.setRankWithGuildInfoArrParam(guildCode, [lv, active, timestamp], guild, isInc);
+    public async setRankWithGuildInfo2(guildCode: string, num1: number, num2: number, num3: number, guild?: GuildType, isInc = false) {
+        return await this.setRankWithGuildInfoArrParam(guildCode, [num1, num2, num3], guild, isInc);
     }
 
     public async setRankWithGuildInfoArrParam(guildCode: string, scores: number[], guild?: GuildType, isInc = false) {
@@ -640,7 +641,7 @@ export class Rank {
 
     public async getRankListWithMyRank(myId: myIdInter) {
         let ranks = await this.getRankByRange();
-        let newRanks = [], newMyRank: RoleRankInfo | GuildRankInfo;
+        let newRanks = [], newMyRank: any;
         let myRank = ranks.find(cur => {
             return cur.isMyInfo(myId);
         });
@@ -714,7 +715,7 @@ export class Rank {
                 param = new RoleRankInfo(userInfo);
                 param.setInfo(Math.floor(ii / 2) + 1, myId, scores[0], scores[1]);
             } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
-                if(this.key == REDIS_KEY.GUILD_LV_RANK) {
+                if(this.key == REDIS_KEY.GUILD_LV_RANK|| this.key == REDIS_KEY.RACE_ACTIVITY) {
                     param = new GuildRankInfo(userInfo);
                     param.setInfo2(Math.floor(ii / 2) + 1, myId, scores[0], scores[1], scores[2]);
                 } else {
@@ -847,15 +848,19 @@ export class Rank {
     // 有序排行综合时间和得分排序
     private encodeScore(scores: number[]) {
         let encodeResult = 0;
-        this.valueConfig.forEach(({ reverse, isTimestamp, len, weight }, index) => {
+        console.log('#### decoencodeResultdeScore', this.key, scores, this.valueConfig);
+        this.valueConfig.forEach(({ name, reverse, isTimestamp, len, weight }, index) => {
             let score = scores[index];
+            console.log('*** 1', name, len, weight, score, encodeResult)
             if(isTimestamp) score = this.handleTimestamp(score, len);
+            console.log('*** 2', name, len, weight, score, encodeResult)
             if(!reverse) {
                 encodeResult += score * Math.pow(10, weight);
             } else {
                 let pow = Math.pow(10, len);
-                encodeResult += pow - 1 - score;
+                encodeResult += (pow - 1 - score) * Math.pow(10, weight);
             }
+            console.log('*** 3', name, len, weight, score, encodeResult)
         })
         return encodeResult
     }
@@ -863,17 +868,21 @@ export class Rank {
     private decodeScore(num: string) {
         let _num = parseInt(num);
         let scores: number[] = [];
-        this.valueConfig.forEach(({ reverse, isTimestamp, len, weight }) => {
+        this.valueConfig.forEach(({ name, reverse, isTimestamp, len, weight }) => {
             let pow = Math.pow(10, weight);
             let score = Math.floor(_num / pow);
+            console.log('*** 1', name, len, weight, score)
             _num -= pow * score;
             if(isTimestamp) score = this.handleTimestamp(score, len);
+            console.log('*** 2', name, len, weight, score)
             if(reverse) {
                 let pow = Math.pow(10, len);
                 score = pow - 1 - score;
             }
+            console.log('*** 3', name, len, weight, score)
             scores.push(score);
         })
+        console.log('#### decodeScore', this.key, scores, this.valueConfig);
         return scores;
     }
 
diff --git a/shared/domain/battleField/guildActivity.ts b/shared/domain/battleField/guildActivity.ts
index f3471ced0..16dd8c624 100644
--- a/shared/domain/battleField/guildActivity.ts
+++ b/shared/domain/battleField/guildActivity.ts
@@ -76,6 +76,8 @@ export class WoodenHorse {
     @prop({required: true})
     distance: number = 0;               // 距离
     @prop({required: true})
+    allStartTime: number = 0;              // 全服开启世界
+    @prop({required: true})
     startTime: number = 0;              // 开始时间
     @prop({required: true})
     time: number = 0;                   // 到达时间
@@ -92,11 +94,19 @@ export class WoodenHorse {
 
     remainItems: Map<number, { total: number, max: number }> = new Map();
 
-    constructor(guildCode: string, guildName: string, guildCe: number, serverId: number) {
+    constructor(guildCode: string, guildName: string, guildCe: number, serverId: number, allStartTime: number) {
         this.guildCode = guildCode;
         this.guildName = guildName;
         this.guildCe = guildCe;
         this.serverId = serverId;
+        this.allStartTime = allStartTime;
+    }
+
+    public startRace(allStartTime: number) {
+        this.status = RACE_ACTIVITY_STATUS.START;
+        this.time = Date.now();
+        this.startTime = Date.now();
+        this.allStartTime = allStartTime;
     }
 
     /**
@@ -249,6 +259,12 @@ export class WoodenHorse {
     public setRemainItem(id: number, remain: number, max: number) {
         this.remainItems.set(id, { total: remain, max });
     }
+
+    public getTreatTime() {
+        console.log('#######', this.time, this.allStartTime)
+        return {...this, time: this.time - this.allStartTime }
+    }
+
 }
 
 export class Event {
@@ -319,4 +335,29 @@ export class CityParam {
     constructor(cityId: number) {
         this.cityId = cityId;
     }
-} 
\ No newline at end of file
+} 
+
+export class RaceActivityRankParam {
+    rank: number = 0;
+    code: string;
+    name: string;
+    time: number;
+    sortTime: number;
+    sortDistance: number;
+    num: number;
+    durability: number;
+
+    constructor(woodenHorse: WoodenHorse) {
+        this.code = woodenHorse.guildCode;
+        this.name = woodenHorse.guildName;
+        this.durability = woodenHorse.durability;
+        this.sortDistance = woodenHorse.distance
+        this.sortTime = woodenHorse.time - woodenHorse.allStartTime;
+        this.num = Math.floor(woodenHorse.distance);
+        this.time = Math.floor((woodenHorse.time - woodenHorse.allStartTime)/1000)
+    }
+
+    setRank(rank: number) {
+        this.rank = rank;
+    }
+}
\ No newline at end of file
diff --git a/shared/domain/rank.ts b/shared/domain/rank.ts
index 80ddb13c6..6b2935956 100644
--- a/shared/domain/rank.ts
+++ b/shared/domain/rank.ts
@@ -188,7 +188,8 @@ export class GuildRankInfo extends GuildRankParam {
     code: string;
     num: number;
     time: number;
-    active?: number;
+    num1?: number;
+    num2?: number;
     
     setInfo(rank: number, myId: myIdInter, num: number, time: number) {
         this.rank = rank;
@@ -197,12 +198,12 @@ export class GuildRankInfo extends GuildRankParam {
         this.time = time;
     }
 
-    setInfo2(rank: number, myId: myIdInter, num: number, active: number, time: number) {
+    setInfo2(rank: number, myId: myIdInter, num: number, num1: number, num2: number) {
         this.rank = rank;
         this.code = myId.guildCode;
         this.num = num;
-        this.time = time;
-        this.active = active;
+        this.num1 = num1;
+        this.num2 = num2;
     }
 
     isMyInfo(myId: myIdInter) {
@@ -258,21 +259,6 @@ export class SimpleGuildRankParam {
     }
 }
 
-export class SimpleGuildRankWithTimeParam extends SimpleGuildRankParam {
-    time: number = 0;
-    durability: number = 0;
-    
-    constructor(rank: number, code: string, name: string, obj: WoodenHorse|{distance: number, time: number, startTime: number, durability: number}|false) {
-        super(rank, code, name, obj?obj.distance:0);
-        // console.log(JSON.stringify(obj));
-        if(obj) {
-            this.num = obj.distance;
-            this.time = Math.floor((obj.time - obj.startTime)/1000);
-            this.durability = obj.durability;
-        }
-    }
-}
-
 export class SimpleRoleRankParam {
     rank: number;
     roleId: string;