✨ feat(gvg): 遗迹生成数据

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

@@ -1,4 +1,14 @@
 import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
+import { GVG_PERIOD, STATUS } from "../../../consts";
+import { GVGVestigeRankModel } from "../../../db/GVGVestigeRank";
+import { HeroModel } from "../../../db/Hero";
+import { RoleModel } from "../../../db/Role";
+import { GVGVestigeOppLineup } from "../../../domain/gvgField/returnData";
+import { gameData } from "../../../pubUtils/data";
+import { resResult } from "../../../pubUtils/util";
+import { checkVestige, getOppPlayerByRanks, refreshVestigeOppRanks } from "../../../services/gvg/gvgFightService";
+import { getGroupIdOfServer, getGVGPeriodData } from "../../../services/gvg/gvgService";
+import { getAllServerName } from "../../../services/redisService";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -18,7 +28,40 @@ export class GVGProduceHandler {
 
     // 遗迹页面
     async getVestige(msg: { vestigeId: number }, session: BackendSession) {
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        const { vestigeId } = msg;
 
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let groupId = await getGroupIdOfServer(serverId);
+        if(!await checkVestige(groupId, vestigeId)) {
+            return resResult(STATUS.GVG_VESTIGE_ERR);
+        }
+        let dicRankMap = gameData.gvgVestige.get(vestigeId);
+        if(!dicRankMap) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        let myVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
+        if(!myVestigateRank) {
+            let role = await RoleModel.findByRoleId(roleId, 'roleId');
+            let oppRanks = refreshVestigeOppRanks(-1);
+            myVestigateRank = await GVGVestigeRankModel.initRank(configId, vestigeId, groupId, role, oppRanks );
+        }
+        let { rank, lineup, oppRanks, refreshCnt } = myVestigateRank;
+        let score = dicRankMap?.get(rank)||0;
+
+        let lineupCe = lineup.reduce((pre, cur) => pre + cur.ce, 0);
+        let oppPlayers = await getOppPlayerByRanks(serverId, groupId, vestigeId, oppRanks);
+
+        return resResult(STATUS.SUCCESS, {
+            vestigeId,
+            myRank: rank,
+            score,
+            lineup, lineupCe,
+            oppPlayers,
+            refreshCnt
+        })
     }
 
     // 编辑阵容
@@ -28,7 +71,36 @@ export class GVGProduceHandler {
 
     // 获取对手阵容消息
     async getOppLineup(msg: { vestigeId: number, roleId: string, rank: number }, session: BackendSession) {
+        const roleId: string = session.get('roleId');
+        const serverId: number = session.get('serverId');
 
+        let { vestigeId, roleId: targetRoleId, rank } = msg;
+        let myVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
+
+        const serverNames = await getAllServerName();
+
+        let isRobot = targetRoleId.startsWith('robot');
+        let result = new GVGVestigeOppLineup(vestigeId);
+        result.setMyRank(myVestigateRank?.rank||0);
+        let dicGVGVestige = gameData.gvgVestige.get(vestigeId)?.get(rank);
+        if(!dicGVGVestige) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        if(isRobot) {
+            let dicWar = gameData.war.get(dicGVGVestige?.warId);
+            let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
+            result.setRobot(dicGVGVestige, dicWarJson, serverNames[serverId]);
+        } else {
+            let hisVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
+            if(!hisVestigateRank) return resResult(STATUS.GVG_VESTIGE_TARGET_NOT_FOUND);
+
+            let role = await RoleModel.findByRoleId(hisVestigateRank.roleId, 'roleId roleName serverId guildName title lv heads head spines spine frames frame')
+            if(!hisVestigateRank) return resResult(STATUS.GVG_VESTIGE_TARGET_NOT_FOUND);
+
+            let hids = hisVestigateRank.lineup?.map(cur => cur.actorId)||[];
+            let heroes = await HeroModel.findByHidRange(hids, roleId, 'hid skinId quality star colorStar lv');
+            result.setPlayer(dicGVGVestige, role, heroes, serverNames);
+        }
+        return resResult(STATUS.SUCCESS, result);
     }
 
     // 刷新对手

game-server/app/services/gvg/gvgFightService.ts

@@ -2,9 +2,16 @@
 
 import { GVG_PERIOD } from "../../consts";
 import { GVGVestigeModel } from "../../db/GVGVestige";
-import { gameData } from "../../pubUtils/data";
+import { GVGVestigeRankModel } from "../../db/GVGVestigeRank";
+import { HeroModel } from "../../db/Hero";
+import { RoleType } from "../../db/Role";
+import { GVGVestigeOppPlayer } from "../../domain/gvgField/returnData";
+import { gameData, getGVGVestigeRange } from "../../pubUtils/data";
 import { getTimeFun } from "../../pubUtils/timeUtil";
-import { getRandEelm } from "../../pubUtils/util";
+import { getRandEelm, getRandValueByMinMax } from "../../pubUtils/util";
+import { getNumberArr, uniqueArr } from "../ladderService";
+import { calLineupScore } from "../pvpService";
+import { getAllServerName } from "../redisService";
 import { getGroupIdOfServer, getGVGServerType } from "./gvgService";
 
 // 备战期的遗迹和激战期的开始结束战斗时间
@@ -30,4 +37,53 @@ export async function getVestiges(serverId: number) {
         vestige = await GVGVestigeModel.initTodayVestigate(groupId, serverType, randResult);
     }
     return vestige.vestiges||[];
+}
+
+export async function checkVestige(groupId: number, vestigeId: number) {
+    let todayVestige = await GVGVestigeModel.getVestigate(groupId);
+    if(!todayVestige) return false;
+    return !!todayVestige.vestiges.find(cur => cur.vestigeId == vestigeId);
+}
+
+// 根据自己排名随机出对手排名
+export function refreshVestigeOppRanks(rank: number) {
+    let dicRange = getGVGVestigeRange(rank);
+    if(!dicRange) return [];
+    
+    let { rangeBeforeFrom, rangeBeforeTo, rangeBeforeNum, rangeAfterFrom, rangeAfterTo, rangeAfterNum } = dicRange;
+    let beforeRanks = randomRank(rangeBeforeFrom == -1? rank: rangeBeforeFrom, rangeBeforeTo == -1? rank: rangeBeforeTo, rangeBeforeNum);
+    let afterRanks = randomRank(rangeAfterFrom == -1? rank: rangeAfterFrom, rangeAfterTo == -1? rank: rangeAfterTo, rangeAfterNum);
+
+    let topRanks = getNumberArr(dicRange.topChallengeFrom + 1, dicRange.topChallengeTo);
+    let ranks = [...topRanks, ...beforeRanks, ...afterRanks];
+    return uniqueArr(ranks.sort((a, b) => a - b));
+}
+
+function randomRank(min: number, max: number, len: number) {
+    if(min == max || len == 0) return [];
+    let arr = getNumberArr(min + 1, max);
+    return getRandEelm(arr, len);
+}
+
+export async function getOppPlayerByRanks(serverId: number, groupId: number, vestigeId: number, ranks: number[]) {
+    let serverNames = await getAllServerName();
+    let opps = await GVGVestigeRankModel.findByRanks(groupId, vestigeId, ranks);
+    let dicRankMap = gameData.gvgVestige.get(vestigeId);
+    if(!dicRankMap) return [];
+    let result: GVGVestigeOppPlayer[] = [];
+    for(let rank of ranks) {
+        let obj = new GVGVestigeOppPlayer(rank);
+        let opp = opps.find(cur => cur.rank == rank);
+        let dicCurRank = dicRankMap.get(rank);
+        if(opp) {
+            let role = <RoleType>opp.role;
+            let lineupce = opp.lineup.reduce((pre, cur) => pre + cur.ce, 0);
+            obj.setByRole(role, serverNames, lineupce, dicCurRank?.score||0);
+        } else {
+            obj.setByDic(dicCurRank, serverNames[serverId]);
+        }
+        result.push(obj);
+    }
+    
+    return result;
 }

game-server/app/services/playerCeService.ts

@@ -21,6 +21,7 @@ import { SkinType } from '../db/Skin';
 import { LadderMatchModel } from '../db/LadderMatch';
 import { ArtifactModelType } from '../db/Artifact';
 import { GVGLeagueModel } from '../db/GVGLeague';
+import { GVGVestigeRankModel } from '../db/GVGVestigeRank';
 
 interface Param {
     isInitRole?: boolean,
@@ -442,6 +443,7 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
             let hero = await HeroModel.updateHeroInfo(roleId, hid, { ce });
             await PvpDefenseModel.updateCe(roleId, hid, ce); // 更新pvp防守阵战力
             await LadderMatchModel.updateCe(roleId, hid, ce);
+            await GVGVestigeRankModel.updateCe(roleId, hid, ce);
             pushHeros.push({ hid, ce: hero.ce, incHeroCe: inc });
         }
     }

shared/consts/constModules/sysConst.ts

@@ -577,6 +577,7 @@ export const FILENAME = {
     DIC_GVG_TASK: 'dic_zyz_GVGTask',
     DIC_GVG_VESTIGE_TYPE: 'dic_zyz_GVGVestigeType',
     DIC_GVG_VESTIGE: 'dic_zyz_GVGVestige',
+    DIC_GVG_VESTIGE_RANGE: 'dic_zyz_GVGVestigeRange',
     DIC_GVG_VESTIGE_LEAGUE_RANK: 'dic_zyz_GVGVestigeLeagueRank',
 }
 

shared/consts/statusCode.ts

@@ -336,6 +336,8 @@ export const STATUS = {
     GVG_TASK_HAS_RECEIVED: { code: 21330, simStr: '任务已领取过' },
     GVG_BATTLE_CITY_FULL: { code: 21331, simStr: '城市已满员' },
     GVG_BATTLE_TEAM_INVALID: { code: 21332, simStr: '无效的队伍' },
+    GVG_VESTIGE_ERR: { code: 21333, simStr: '今日未开放该遗迹' },
+    GVG_VESTIGE_TARGET_NOT_FOUND: { code: 21334, simStr: '对手未找到' },
 
     // 通用 30000 - 30099
     DIC_DATA_NOT_FOUND: { code: 30000, simStr: '数据表未找到' },

shared/db/GVGVestigeRank.ts

@@ -1,9 +1,22 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
-import Role from './Role';
+import Role, { RoleType } from './Role';
+import { getZeroPoint } from '../pubUtils/timeUtil';
 
-@index({ groupId: 1, vestigeId: 1 })
+class Lineup {
-export default class GVGVestige extends BaseModel {
+    @prop({ required: true })
+    actorId: number; // 武将
+    @prop({ required: true })
+    dataId: number;  // 出兵表上所占位置
+    @prop({ required: true })
+    order: number;   // 行动顺序
+    @prop({ required: true })
+    ce: number;      // 战力
+}
+
+@index({ day: 1, groupId: 1, vestigeId: 1, rank: 1 })
+@index({ roleId: 1 })
+export default class GVGVestigeRank extends BaseModel {
 
     @prop({ required: true })
     configId: number;       // 赛期
@@ -24,21 +37,60 @@ export default class GVGVestige extends BaseModel {
     role: Ref<Role>;
 
     @prop({ required: true, default: 0 })
-    rank: number;				    // 排名
+    rank: number;          // 排名
     
     @prop({ required: true, default: 0 })
-    oldRank: number;				 // 交换前排名
+    oldRank: number;       // 交换前排名
     
     @prop({ required: true, default: 0 })
-    historyRank: number;		    // 历史最高排名
+    historyRank: number;   // 历史最高排名
 
     @prop({ required: true, default: 0 })
-    locked: number;  // 是否被挑战
+    locked: number;        // 是否被挑战
+
+    @prop({ required: true, default: false })
+    hasAdjustLineup: boolean;  // 是否调整过阵容
+
+    @prop({ required: true, type: Lineup, default: [] })
+    lineup: Lineup[];         // 阵容
+
+    @prop({ required: true, type: Number, default: [] })
+    oppRanks: number[];         // 对手的排名
+
+    @prop({ required: true, default: 0 })
+    refreshCnt: number;         // 刷新次数
+
+    public static async findRankByRole(vestigeId: number, roleId: string) {
+        let today = getZeroPoint();
+        let result: GVGVestigeRankType = await GVGVestigeRankModel.findOne({ day: today, vestigeId, roleId }).lean();
+        return result;
+    }
+
+    public static async initRank(configId: number, vestigeId: number, groupId: number, role: RoleType, oppRanks: number[]) {
+        let today = getZeroPoint();
+        let doc = new GVGVestigeRankModel();
+        let update = Object.assign(doc.toJSON(), { role: role._id, configId, groupId, oppRanks });
+        let result: GVGVestigeRankType = await GVGVestigeRankModel.findOneAndUpdate({ day: today, vestigeId, roleId: role.roleId }, { $setOnInsert: update }, { new: true, upsert: true }).lean();
+        return result;
+    }
+
+    public static async findByRanks(groupId: number, vestigeId: number, ranks: number[]) {
+        let today = getZeroPoint();
+        let result: GVGVestigeRankType[] = await GVGVestigeRankModel.find({ day: today, vestigeId, groupId, rank: { $in: ranks } })
+        .populate('role', 'roleId roleName head frame spine heads frames spines title lv guildName serverId updatedAt')
+        .lean();
+        return result;
+    }
+
+    public static async updateCe(roleId: string, hid: number, ce: number) {
+        let today = getZeroPoint();
+        await GVGVestigeRankModel.updateMany({ day: today, roleId, 'lineup.hid': hid }, { $set: { 'lineupCe.$.ce': ce } });
+    }
 }
 
-export const GVGVestigeModel = getModelForClass(GVGVestige);
+export const GVGVestigeRankModel = getModelForClass(GVGVestigeRank);
 
-export interface GVGVestigeType extends Pick<DocumentType<GVGVestige>, keyof GVGVestige> {
+export interface GVGVestigeRankType extends Pick<DocumentType<GVGVestigeRank>, keyof GVGVestigeRank> {
     id: number;
 };
-export type GVGVestigeUpdate = Partial<GVGVestigeType>; // 将所有字段变成可选项
+export type GVGVestigeRankUpdate = Partial<GVGVestigeRankType>; // 将所有字段变成可选项

shared/domain/gvgField/returnData.ts

@@ -1,11 +1,15 @@
 import { RoleType } from "../../db/Role";
 import { GVGLeagueType } from "../../db/GVGLeague";
 import { GVGLeaguePrepareType } from "../../db/GVGLeaguePrepare";
-import { Distribute, GVGUserDataType } from "../../db/GVGUserData";
+import { GVGUserDataType } from "../../db/GVGUserData";
 import { GuildType } from "../../db/Guild";
-import { LEAGUE_JOB } from "../../consts";
 import { GVGLeagueFarmType } from "../../db/GVGLeagueFarm";
 import { nowSeconds } from "../../pubUtils/timeUtil";
+import { DicGVGVestige } from "../../pubUtils/dictionary/DicGVGVestige";
+import { EXTERIOR, GVG } from "../../pubUtils/dicParam";
+import { DicWarJson } from "../../pubUtils/dictionary/DicWarJson";
+import { gameData } from "../../pubUtils/data";
+import { HeroType } from "../../db/Hero";
 
 class LeagueLeaderInfo {
     name: string;        // 盟主名
@@ -353,3 +357,161 @@ export interface LeagueGood {
     id: number,
     count: number
 }
+
+export class GVGVestigeOppPlayer {
+    rank: number;
+    roleId: string;
+    roleName: string;
+    lv: number;
+    head: number;
+    frame: number;
+    spine: number;
+    title: number;
+    guildName: string;
+    serverName: string;
+    lineupCe: number;
+    score: number;
+
+    constructor(rank: number) {
+        this.rank = rank;
+    }
+
+    setByRole(role: RoleType, serverNames: any, lineupCe: number, score: number) {
+        this.roleId = role.roleId;
+        this.roleName = role.roleName;
+        this.lv = role.lv;
+        this.head = role.head;
+        this.frame = role.frame;
+        this.spine = role.spine;
+        this.title = role.title;
+        this.guildName = role.guildName;
+        this.serverName = serverNames[role.serverId];
+        this.lineupCe = lineupCe;
+        this.score = score;
+    }
+
+    setByDic(dic: DicGVGVestige, serverName: string) {
+        this.lineupCe = dic.ce;
+        this.roleId = `robot${this.rank}`;
+        this.roleName = GVG.GVG_ROBOT_NAME;
+        this.lv = dic.level;
+        this.head = dic.head;
+        this.frame = EXTERIOR.EXTERIOR_FACECASE;
+        this.spine = dic.spine;
+        this.title = 1;
+        this.guildName = '';
+        this.serverName = serverName;
+        this.lineupCe = dic.ce;
+        this.score = dic.score;
+    }
+}
+
+// getOppLineup返回
+export class GVGVestigeOppLineupHero {
+    hid: number;   // 武将
+    skinId: number;    // 皮肤id
+    quality: number;   // 品质
+    star: number;      // 星级
+    colorStar: number; // 彩星
+    lv: number;        // 等级
+
+    setByWarJson(warJson: DicWarJson) {
+        this.hid = warJson.actorId;
+        this.skinId = warJson.actorId;
+        this.lv = warJson.lv;
+        let dicHero = gameData.hero.get(warJson.actorId);
+        if(dicHero) {
+            this.quality = dicHero.quality;
+            if(this.quality == 4) {
+                this.star = 6;
+                this.colorStar = warJson.star;
+            } else {
+                this.star = warJson.star;
+                this.colorStar = 0;
+            }
+        }
+    }
+
+
+    setByDefenseHero(hero: HeroType) {
+        this.hid = hero.hid;
+        this.skinId = hero.skinId;
+        this.quality = hero.quality;
+        this.star = hero.star;
+        this.colorStar = hero.colorStar;
+        this.lv = hero.lv;
+    }
+}
+
+export class GVGVestigeOppLineup {
+    vestigeId: number;  // 遗迹id
+    myRank: number;
+    rank: number;
+    score: number;
+    isRobot: boolean;
+    roleId: string;
+    roleName: string;
+    serverName: string;
+    guildName: string;
+    lv: number;
+    head: number;
+    frame: number;
+    spine: number;
+    title: number;
+    lineupCe: number = 0;   // 阵容战力
+    heroes: GVGVestigeOppLineupHero[] = [];
+
+    constructor(vestigeId: number) {
+        this.vestigeId = vestigeId;
+    }
+
+    setMyRank(myRank: number) {
+        this.myRank = myRank;
+    }
+
+    setRobot(dic: DicGVGVestige, warJsons: DicWarJson[], serverName: string) {
+        this.isRobot = true;
+        this.rank = dic.rank;
+        this.score = dic.score;
+        this.roleId = `robot${dic.rank}`;
+        this.roleName = GVG.GVG_ROBOT_NAME;
+        this.serverName = serverName;
+        this.guildName = '';
+        this.lineupCe = dic.ce;
+        this.lv = dic.level;
+        this.head = dic.head;
+        this.frame = EXTERIOR.EXTERIOR_FACECASE;
+        this.spine = dic.spine;
+        this.title = 1;
+
+        for(let warJson of warJsons) {
+            if(warJson.relation == 2) {
+                let hero = new GVGVestigeOppLineupHero();
+                hero.setByWarJson(warJson);
+                this.heroes.push(hero);
+            }
+        }
+    }
+
+    setPlayer(dic: DicGVGVestige, role: RoleType, heroes: HeroType[], serverNames: any) {
+        this.isRobot = false;
+        this.rank = dic.rank;
+        this.score = dic.score;
+        this.roleId = role.roleId;
+        this.roleName = role.roleName;
+        this.serverName = serverNames[role.serverId];
+        this.guildName = role.guildName;
+        this.title = role.title;
+        this.lv = role.lv;
+        this.head = role.head;
+        this.frame = role.frame;
+        this.spine = role.spine;
+
+        for(let hero of heroes) {
+            this.lineupCe += hero.ce;
+            let obj = new GVGVestigeOppLineupHero();
+            obj.setByDefenseHero(hero);
+            this.heroes.push(obj);
+        }
+    }
+}

shared/pubUtils/data.ts

@@ -129,6 +129,7 @@ import { dicGVGCityAdd, loadGVGCityAdd } from './dictionary/DicGVGCityAdd';
 import { dicGVGTask, dicGVGTaskByType, loadGVGTask } from './dictionary/DicGVGTask';
 import { dicGVGVestigeByType, loadGVGVestigeType } from './dictionary/DicGVGVestigeType';
 import { dicGVGVestige, loadGVGVestige } from './dictionary/DicGVGVestige';
+import { DicGVGVestigeRange, dicGVGVestigeRange, loadGVGVestigeRange } from './dictionary/DicGVGVestigeRange';
 
 export const gameData = {
     daily: dicDaily,
@@ -325,6 +326,7 @@ export const gameData = {
     gvgVestigeByServerType: dicGVGVestigeByType,
     gvgVestigeCntByServerType: new Map<number, number>(), // 单服or跨服 => 遗迹数量
     gvgVestige: dicGVGVestige,
+    gvgVestigeRange: dicGVGVestigeRange,
 };
 
 // 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -1169,6 +1171,18 @@ function parseGVGVestigeCnt() {
     }
 }
 
+export function getGVGVestigeRange(myRank: number) {
+    let latestRank: DicGVGVestigeRange;
+    for(let dic of gameData.gvgVestigeRange) {
+        latestRank = dic;
+        let { rankMin, rankMax } = dic;
+        if((rankMin < myRank && (rankMax >= myRank || rankMax == -1))) {
+            return dic;
+        }
+    }
+    return latestRank
+}
+
 // 初始加载
 function initDatas() {
     parseDicParam();
@@ -1379,6 +1393,7 @@ function loadDatas() {
     loadGVGTask();
     loadGVGVestigeType();
     loadGVGVestige();
+    loadGVGVestigeRange();
 }
 
 // 重载dicParam

shared/pubUtils/dicParam.ts

@@ -391,6 +391,8 @@ export const GVG = {
   GVG_FARM_LOCK_TIME: 300, // 农田锁定时间（秒）
   GVG_MINE_LOCK_TIME: 300, // 矿山锁定时间（秒）
   GVG_FORESTRY_LOCK_TIME: 300, // 林场锁定时间（秒）
-  GVG_FIELD_TYPE_RATIO: '1&5|2&10|3&10', // 全联盟的特殊格子上限百分比（a%的格子为小麦这个）1&a|2&b|3&c 
+  GVG_FIELD_TYPE_RATIO: '1&5%|2&10%|3&10%', // 全联盟的特殊格子上限百分比（a%的格子为小麦这个）1&a|2&b|3&c 
-  GVG_SP_FIELD_RATIO: '10&30', // 分配给玩家的时候有多少特殊格子 min&max 填最大最小百分比即可
+  GVG_SP_FIELD_RATIO: '10%&30%', // 分配给玩家的时候有多少特殊格子 min&max 填最大最小百分比即可
+  GVG_REFRESH_TIME: 5, // 0
+  GVG_ROBOT_NAME: '遗迹守护者', // 0
 };

shared/pubUtils/dictionary/DicGVGVestige.ts

@@ -12,12 +12,12 @@ export interface DicGVGVestige {
     readonly rank: number;
     // 驻扎分
     readonly score: number;
-    // 机器人的名字
-    readonly name: string;
-    // 显示在上面的形象
-    readonly spine: number;
     // 显示在详情的头像
     readonly head: number;
+    // 显示在上面的形象
+    readonly spine: number;
+    // 显示的机器人的等级
+    readonly level: number;
     // 显示战力
     readonly ce: number;
     // 突破奖励
@@ -42,6 +42,7 @@ export function loadGVGVestige() {
         o.onceLeagueReward = parseGoodStr(o.onceLeagueReward);
         o.battleReward = parseGoodStr(o.battleReward);
         o.battleLeagueReward = parseGoodStr(o.battleLeagueReward);
+        o.warId = parseInt(o.warId);
         if(!dicGVGVestige.has(o.vestigeId)) {
             dicGVGVestige.set(o.vestigeId, new Map());
         }

shared/pubUtils/dictionary/DicGVGVestigeRange.ts

@@ -0,0 +1,39 @@
+// GVG遗迹
+import { FILENAME } from '../../consts'
+import { readFileAndParse } from '../util'
+
+export interface DicGVGVestigeRange {
+     // id
+    id: number;
+     // 最低排名(不含)
+    rankMin: number;
+    // 最高排名(含)
+    rankMax: number; 
+    // 往前随机的排名最高是多少名
+    rangeBeforeFrom: number; 
+    // 往前随机的排名最低是多少名
+    rangeBeforeTo: number; 
+    // 往前随机的排名里随机多少个
+    rangeBeforeNum: number; 
+    // 往后随机的排名最高是多少名
+    rangeAfterFrom: number; 
+    // 往后随机的排名最低是多少名
+    rangeAfterTo: number; 
+    // 往后随机的排名最低是多少名
+    rangeAfterNum: number; 
+    // 是否显示前十名/前五名
+    topChallengeFrom: number; 
+    // 是否显示前十名/前五名
+    topChallengeTo: number; 
+}
+
+export const dicGVGVestigeRange: DicGVGVestigeRange[] = [];
+export function loadGVGVestigeRange() {
+    dicGVGVestigeRange.splice(0, dicGVGVestigeRange.length);
+    
+    let arr = readFileAndParse(FILENAME.DIC_GVG_VESTIGE_RANGE);
+    arr.forEach(o => {
+        dicGVGVestigeRange.push(o);
+    });
+    arr = undefined;
+}