✨ feat(gvg): 组建期

game-server/app/services/checkParam.ts

@@ -1602,6 +1602,13 @@ export function checkRouteParam(route: string, msg: any) {
                 if(!checkNaturalNumbers(msg.stage)) return false;
                 break;
             }
+        case "battle.ladderHandler.getRec":
+            {
+                if(!checkNaturalStrings(msg.name)) return false;
+                if(!checkStringIfExist(msg.notice)) return false;
+                if(!checkNaturalNumbers(msg.icon)) return false;
+                break;
+            }
         case "role.heroHandler.addItem":
             {
                 if(!isDevelopEnv() && !checkNaturalNumbers(msg.id, msg.count)) return false;

game-server/app/services/gmService.ts

@@ -414,4 +414,8 @@ export function getPastTime() {
 
 export function getFutureTime() {
     return moment('2100-01-01').unix();
+}
+
+export function initServerZone() {
+    
 }

game-server/app/services/guildService.ts

@@ -27,6 +27,8 @@ import { RewardInter } from "../pubUtils/interface";
 import { getGuildFundByRefTime } from "./donateService";
 import { BattleRecordModel } from "../db/BattleRecord";
 import { BossInstanceModel } from "../db/BossInstance";
+import { pick } from "underscore";
+import { memberJoinGuildToLeague } from "./gvg/gvgTeamService";
 
 export async function getMyGuildInfo(roleId: string, sid: string, userGuild: UserGuildType, guild: GuildType, serverId: number, session: FrontendOrBackendSession) {
 
@@ -51,7 +53,7 @@ export async function getMyGuildInfo(roleId: string, sid: string, userGuild: Use
     let guildActive = await getTodayGuildActive(guild.code);
 
     // 返回
-    return { hasGuild: true, guildMemberMax, ...guild, activeDaily: guildActive, leader: { ...leader, isOnline: leaderIsOnline }, rank, myInfo: { ...userGuild } };
+    return { hasGuild: true, guildMemberMax, ...guild, activeDaily: guildActive, leader: { ...pick(leader, ['ce', 'lv', 'quitTime', 'roleId', 'roleName', 'head', 'frame', 'spine', 'title', 'isOnline']), isOnline: leaderIsOnline }, rank, myInfo: { ...userGuild } };
 }
 
 /**
@@ -116,6 +118,7 @@ export async function joinGuild(code: string, guildName: string, lv: number, rol
         return { status: -1, resResult: resResult(STATUS.GUILD_HAS_JOIN) };
     }
     await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'guildName', value: guildName }]);
+    await memberJoinGuildToLeague(guild, role);
 
     const userGuild = await UserGuildModel.createUserGuild(guild.code, role, false);
     if (!userGuild) {

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

@@ -0,0 +1,179 @@
+import { pinus } from "pinus";
+import { GVGConfigModel, GVGConfigType } from "../../db/GVGConfig";
+import { getTimeFun, getZeroPoint, getZeroPointOfTime, nowSeconds, WEEK_TO_SECOND } from "../../pubUtils/timeUtil";
+import { getAllServerCreateTime, getServerCreateTime } from "../redisService";
+import { GVG_PERIOD, GVG_SERVER_TYPE, SHOP_REFRESH_TYPE } from "../../consts";
+import { GVGLeagueModel } from "../../db/GVGLeague";
+import { GVGLeaguePrepareModel } from "../../db/GVGLeaguePrepare";
+import { GVGServerGroupModel } from "../../db/GVGServerGroup";
+import { gameData } from "../../pubUtils/data";
+import { getRandSingleEelm } from "../../pubUtils/util";
+import { GVG } from "../../pubUtils/dicParam";
+import { ServerlistModel } from "../../db/Serverlist";
+import { GuildType } from "../../db/Guild";
+
+// 定时器相关
+export async function createNewGVGConfig() {
+    let { teamTime, prepareTime, battleTime, scheduleTime } = getPeriodTime();
+    const config = await GVGConfigModel.createNewConfig(teamTime, prepareTime, battleTime, scheduleTime);
+    setGVGConfigToRemote(config);
+    // TODO 每周自动解散一些联军
+    await pinus.app.rpc.guild.guildRemote.setGVGServerGroup.broadcast();
+    return config;
+}
+
+// 获取各个周期的时间，大约每周日5点的时候刷的
+export function getPeriodTime() {
+    let now = new Date();
+    let curDay = now.getDay(); // 今天星期几
+
+    let teamConfig = gameData.gvgPeriod.get(GVG_PERIOD.TEAM);
+    let prepareConfig = gameData.gvgPeriod.get(GVG_PERIOD.PREPARE);
+    let battleConfig = gameData.gvgPeriod.get(GVG_PERIOD.BATTLE);
+
+    // 如果现在是周日，那么就是本周期的组队开始时间，如果是其他日子（启动初始化），就是下周期的组队开始时间
+    let _teamTime = <number>getTimeFun().getTimeWithWeek(teamConfig.startDay, teamConfig.startHour, teamConfig.startMinute, teamConfig.startSecond); 
+    let _prepareTime = <number>getTimeFun().getTimeWithWeek(prepareConfig.startDay, prepareConfig.startHour, prepareConfig.startMinute, prepareConfig.startSecond);
+    let _battleTime = <number>getTimeFun().getTimeWithWeek(battleConfig.startDay, battleConfig.startHour, battleConfig.startMinute, battleConfig.startSecond);
+    console.log('_teamTime: ', _teamTime);
+
+    let teamTime = curDay == 0? _teamTime: _teamTime - 7 * 86400;
+    let prepareTime = curDay == 0? _prepareTime + 7 * 86400: _prepareTime;
+    let battleTime = curDay == 0? _battleTime + 7 * 86400: _battleTime;
+    let scheduleTime = teamTime + 7 * 86400;
+
+    return { teamTime, prepareTime, battleTime, scheduleTime }
+}
+
+export async function getGVGConfigFromRemote() {
+    let guildServers = pinus.app.getServersByType('guild');
+    let server = getRandSingleEelm(guildServers);
+    return await pinus.app.rpc.guild.guildRemote.getGVGConfig.toServer(server.id);
+}
+
+export function setGVGConfigToRemote(config: GVGConfigType) {
+    if(!config) return null
+    pinus.app.rpc.guild.guildRemote.setGVGConfig.broadcast(config);
+}
+
+export function setGVGConfig(config: GVGConfigType) {
+    if(!config) return null
+    pinus.app.set('gvgConfigId', config.configId);
+    pinus.app.set('gvgTeamTime', config.teamTime);
+    pinus.app.set('gvgPrepareTime', config.prepareTime);
+    pinus.app.set('gvgBattleTime', config.battleTime);
+    pinus.app.set('gvgScheduleTime', config.scheduleTime);
+}
+
+export function getGVGConfig() {
+    let configId = pinus.app.get('gvgConfigId');
+    let teamTime = pinus.app.get('gvgTeamTime');
+    let prepareTime = pinus.app.get('gvgPrepareTime');
+    let battleTime = pinus.app.get('gvgBattleTime');
+    let scheduleTime = pinus.app.get('gvgScheduleTime');
+    return { configId, teamTime, prepareTime, battleTime, scheduleTime }
+}
+
+function getServerTypeByTime(openTime: number) {
+    let today = nowSeconds();
+    if(today - openTime < WEEK_TO_SECOND) return GVG_SERVER_TYPE.NO;
+    let toWeek = getCurrentTeamTime(today);
+    let openWeek = getCurrentTeamTime(openTime);
+    let n = Math.floor((toWeek - openWeek) / WEEK_TO_SECOND);
+    return n <= GVG.GVG_CROSS_SERVICE_STARTTIME? GVG_SERVER_TYPE.SINGLE: GVG_SERVER_TYPE.MULTI;
+}
+
+function getCurrentTeamTime(time: number) {
+    let teamConfig = gameData.gvgPeriod.get(GVG_PERIOD.TEAM);
+    // 本周日
+    let _teamTime = <number>getTimeFun(time).getTimeWithWeek(teamConfig.startDay, teamConfig.startHour, teamConfig.startMinute, teamConfig.startSecond); 
+    return _teamTime > time? _teamTime - WEEK_TO_SECOND: _teamTime;
+}
+
+export async function getGVGServerType(serverId: number) {
+    console.log('#### serverId', serverId)
+    let openTime = await getServerCreateTime(serverId);
+    return getServerTypeByTime(openTime)
+}
+
+export function getGVGPeriodData() {
+    let { configId, teamTime, prepareTime, battleTime, scheduleTime } = getGVGConfig();
+    let period = getCurPeriod();
+    let countdownTime = teamTime;
+    switch(period) {
+        case GVG_PERIOD.TEAM: {
+            countdownTime = prepareTime; break;
+        }
+        case GVG_PERIOD.PREPARE: {
+            countdownTime = battleTime; break;
+        }
+        case GVG_PERIOD.BATTLE: {
+            countdownTime = scheduleTime; break;
+        }
+    }
+    return { configId, period, countdownTime };
+}
+
+export function getCurPeriod() {
+    let { teamTime, prepareTime, battleTime } = getGVGConfig();
+    let now = nowSeconds();
+    if(now >= teamTime && now < prepareTime) {
+        return GVG_PERIOD.TEAM;
+    } else if (now >= prepareTime && now < battleTime) {
+        return GVG_PERIOD.PREPARE;
+    } else {
+        return GVG_PERIOD.BATTLE;
+    }
+}
+
+export async function initLeaguePrepare() {
+    const { configId } = getGVGConfig();
+
+    const leagues = await GVGLeagueModel.findAllLeague();
+    for(let { leagueCode, memberCnt } of leagues) {
+        await GVGLeaguePrepareModel.initData(configId, leagueCode, memberCnt);
+    }
+}
+
+export async function setGVGServerGroup() {
+    const servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
+    const serverGroups = await GVGServerGroupModel.findByTime(nowSeconds());
+    pinus.app.set('gvgServerGroup', servers.map(obj => {
+        let server = serverGroups.find(cur => cur.serverId == obj.serverId);
+        return { serverId: obj.id, groupId: server? server.groupId: obj.groupId }
+    }));
+}
+
+// 查询本小区所在的战区
+// gvgServerGroup: id-小区唯一id serverId-小区在大区下的id
+export async function getGroupIdOfServer(id: number) {
+    let arr: { serverId: number; groupId: number }[] = pinus.app.get('gvgServerGroup')||[];
+    let obj = arr.find(cur => cur.serverId == id);
+    return obj?.groupId||0;
+}
+
+// 查询当前和本小区同一个战区的其他小区
+export async function getServersOfSameGroup(type: GVG_SERVER_TYPE, id: number) {
+    if(type == GVG_SERVER_TYPE.SINGLE) return [id];
+    
+    let groupId = await getGroupIdOfServer(id);
+    let arr: { serverId: number; groupId: number }[] = pinus.app.get('gvgServerGroup')||[];
+    let serverCreateTimes = await getAllServerCreateTime();
+
+    return arr.filter(obj => {
+        let openTime = parseInt(serverCreateTimes[obj.serverId]);
+        return obj.groupId == groupId && getServerTypeByTime(openTime) == type;
+    }).map(obj => obj.serverId);
+}
+
+export async function getGVGInfoInGuild(guild: GuildType) {
+    let hasLeague = !!guild.leagueCode;
+    let serverId = guild.serverId;
+    let { configId, period, countdownTime } = getGVGPeriodData();
+    let type = await getGVGServerType(serverId);
+    return {
+        hasLeague,
+        configId, period, countdownTime,
+        type
+    }
+}

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

@@ -0,0 +1,228 @@
+// 和gvg组建期相关的方法
+
+import { GUILD_AUTH, GVG_APPLY_TYPE, GVG_PERIOD, GVG_SERVER_TYPE, LEAGUE_AUTH, LEAGUE_MANAGE_TYPE, PUSH_ROUTE, STATUS } from "../../consts";
+import { GuildModel, GuildType } from "../../db/Guild";
+import { GVGLeagueModel, GVGLeagueType, GVGLeagueUpdate } from "../../db/GVGLeague";
+import { GVGLeagueApplyModel, GVGLeagueApplyType } from "../../db/GVGLeagueApply";
+import { GVGLeaguePrepareModel, GVGLeaguePrepareType } from "../../db/GVGLeaguePrepare";
+import { RoleType } from "../../db/Role";
+import { UserGuildModel } from "../../db/UserGuild";
+import { LeagueGuildInfo, LeagueListInfo } from "../../domain/gvgField/returnData";
+import { GVG } from "../../pubUtils/dicParam";
+import { getZeroPointD } from "../../pubUtils/timeUtil";
+import { resResult } from "../../pubUtils/util";
+import { sendMessageToUserWithSuc } from "../pushService";
+import { getCurPeriod, getGVGConfig, getGVGPeriodData, getGVGServerType } from "./gvgService";
+
+/**
+ * 自动创建联军
+ * @param guildCode 创建联军的那个军团
+ * @returns GVGLeagueType
+ */
+export async function autoCreateLeague(guildCode: string) {
+    let guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
+    if(!guild || guild.lv < GVG.GVG_ARMY_LEAGUE_TIME) return;
+
+    let period = getCurPeriod();
+    if(period == GVG_PERIOD.PREPARE || period == GVG_PERIOD.BATTLE) {
+        return await createLeague(guild, {});
+    }
+}
+
+/**
+ * 创建联军
+ * @param guild 创建联军的那个军团
+ * @param params 联军的一些初始数据
+ * @returns 
+ */
+export async function createLeague(guild: GuildType, params: GVGLeagueUpdate) {
+    let serverType = await getGVGServerType(guild.serverId);
+    params.type = serverType;
+    params.serverId = guild.serverId; 
+    const league = await GVGLeagueModel.createLeague(guild, params);
+    await GuildModel.joinLeague(guild.code, league.leagueCode);
+    return league;
+}
+
+/**
+ * 获取在联军中的职位
+ * @param league 
+ * @param roleId 
+ * @returns 
+ */
+export function getMyAuth(league: GVGLeagueType, roleId: string) {
+    let members = league.members;
+    let member = members.find(cur => cur.roleId == roleId);
+    return member?.auth?? LEAGUE_AUTH.MEMBER;
+}
+
+/**
+ * 加入联军的当天如果是在准备期，这天不能去参加内政
+ * @param roleId 
+ * @returns 
+ */
+export async function checkCanPrepare(roleId: string) {
+    let userGuild = await UserGuildModel.getMyGuild(roleId, 'createdAt');
+    let today = getZeroPointD();
+    return userGuild.createdAt < today;
+}
+
+/**
+ * 是否可以选择职能，如果选择的人数超过了就不可以选
+ * @param myJob 
+ * @param league 
+ * @returns 
+ */
+export function checkCanChooseJob(myJob: number, league: GVGLeaguePrepareType) {
+    if(myJob > 0) return false;
+    if(!league) return false;
+    let { producerCnt, fighterCnt, maxMemberCnt } = league;
+    return producerCnt + fighterCnt <= maxMemberCnt;
+}
+
+/**
+ * 获取申请数据
+ * @param apply 本条申请原数据
+ * @param serverNames 全服务器的名字from redis
+ * @param invitations 本联军向其他军团发出的邀请
+ * @returns 
+ */
+export function getLeagueApplyData(apply: GVGLeagueApplyType, serverNames: any, invitations: GVGLeagueApplyType[] ) {
+    let data = new LeagueGuildInfo(<GuildType>apply.guild, serverNames);
+    let hasInvited = !!invitations.find(cur => cur.guildCode == apply.guildCode);
+    data.setHasInvited(hasInvited);
+    return data;
+}
+
+/**
+ * 获取邀请数据
+ * @param invite 本条邀请原数据
+ * @param serverNames 全服务器的名字from redis
+ * @param applies 本军团向其他联军发出的申请
+ * @returns 
+ */
+export function getLeagueInviteData(invite: GVGLeagueApplyType, serverNames: any, applies: GVGLeagueApplyType[]) {
+    let data = new LeagueListInfo(<GVGLeagueType>invite.league, serverNames);
+    let hasApply = !!applies.find(cur => cur.leagueCode == invite.guildCode);
+    data.setHasApply(hasApply);
+    return data;
+}
+
+/**
+ * 联军加入军团
+ * @param myLeague 
+ * @param targetGuildCode 
+ * @returns 
+ */
+export async function joinGuildToLeague(league: GVGLeagueType, targetGuildCode: string) {
+    const hasApply = await GVGLeagueApplyModel.checkApply(league.leagueCode, targetGuildCode, GVG_APPLY_TYPE.ALL);
+    if(!hasApply) {
+        return resResult(STATUS.GUILD_NOT_APPLY);
+    }
+    if(league.guildCnt >= GVG.GVG_LEAGUE_COMPOSE) {
+        return resResult(STATUS.LEAGUE_IS_GUILD_MAX);
+    }
+    let hisLeague = await GVGLeagueModel.findLeagueByGuild(targetGuildCode);
+    if(hisLeague) {
+        await GVGLeagueApplyModel.deleteApply(targetGuildCode, league.leagueCode);
+        return resResult(STATUS.TARGET_GUILD_HAS_LEAGUE);
+    }
+
+    const targetGuild = await GuildModel.findByCode(targetGuildCode, null, '+members');
+    if(!targetGuild) return resResult(STATUS.TARGET_GUILD_NOT_FOUND);
+    if(targetGuild.lv < GVG.GVG_ARMY_LEAGUE_TIME) return resResult(STATUS.GUILD_LV_NOT_ENOUGH);
+
+    league = await GVGLeagueModel.joinGuild(league.leagueCode, targetGuild);
+
+    await GuildModel.joinLeague(targetGuildCode, league.leagueCode);
+
+    return resResult(STATUS.SUCCESS, league);
+}
+
+/**
+ * 检查是否可以进行组建联军等操作
+ * @param serverId 
+ * @param serverType 
+ * @returns 
+ */
+export async function checkCanManage(serverId: number, serverType?: number) {
+    if(!serverType) serverType = await getGVGServerType(serverId);
+    if(serverType != GVG_SERVER_TYPE.MULTI) return resResult(STATUS.GVG_TEAM_SERVER_TYPE_ERR);
+    let { period } = getGVGPeriodData();
+    if(period != GVG_PERIOD.TEAM) return resResult(STATUS.GVG_NOT_TEAM_PERIOD);
+    return resResult(STATUS.SUCCESS);
+}
+
+/**
+ * 一些操作只能由军团的团长才能操作
+ * @param guildCode 
+ * @param roleId 
+ * @param guild 
+ * @returns 
+ */
+export async function checkGuildLeader(guildCode: string, roleId: string, guild?: GuildType) {
+    if(!guild) guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
+    if(!guild) return resResult(STATUS.GVG_HAS_NO_AUTH);
+    if(guild.lv < GVG.GVG_ARMY_LEAGUE_TIME) return resResult(STATUS.GUILD_LV_NOT_ENOUGH);
+
+    const userGuild = await UserGuildModel.getMyGuild(roleId, 'auth');
+    if(!userGuild || userGuild.auth != GUILD_AUTH.LEADER) return resResult(STATUS.GVG_HAS_NO_AUTH);
+    return resResult(STATUS.SUCCESS);
+}
+
+/**
+ * 检查联军的操作
+ * @param roleId 
+ * @param myLeague 
+ * @param type 
+ * @returns 
+ */
+export async function checkLeagueAuth(roleId: string, myLeague: GVGLeagueType, type: LEAGUE_MANAGE_TYPE) {
+    const auth = getMyAuth(myLeague, roleId);
+    const needAuth = getAuthFromManageType(type);
+    return needAuth.indexOf(auth) > -1 
+}
+
+function getAuthFromManageType(type: LEAGUE_MANAGE_TYPE) {
+    switch(type) {
+        case LEAGUE_MANAGE_TYPE.HANDLE_APPLY:
+        case LEAGUE_MANAGE_TYPE.INVITE:
+        case LEAGUE_MANAGE_TYPE.KICK:
+        case LEAGUE_MANAGE_TYPE.DISSMISS:
+        case LEAGUE_MANAGE_TYPE.ABDICATE:
+            return [LEAGUE_AUTH.LEADER];
+        case LEAGUE_MANAGE_TYPE.QUIT:
+        case LEAGUE_MANAGE_TYPE.BE_ABDICATED:
+            return [LEAGUE_AUTH.SUB_LEADER];
+        case LEAGUE_MANAGE_TYPE.SET_INFO:
+            return [LEAGUE_AUTH.LEADER, LEAGUE_AUTH.SUB_LEADER];
+    }
+}
+
+export async function memberJoinGuildToLeague(guild: GuildType, role: RoleType) {
+    if(!guild.leagueCode) return;
+    let league = await GVGLeagueModel.joinMember(guild.leagueCode, role.roleId, role.ce);
+    // TODO redis联军更新
+    console.log(league);
+}
+
+export async function memberQuitGuildToLeague(guild: GuildType, role: RoleType) {
+    if(!guild.leagueCode) return;
+    let league = await GVGLeagueModel.quitMember(guild.leagueCode, role.roleId, role.ce);
+    // TODO redis联军更新
+    console.log(league);
+}
+
+export async function guildDismissToLeague(guild: GuildType) {
+    if(!guild.leagueCode) return;
+    let league = await GVGLeagueModel.quitGuild(guild.leagueCode, guild);
+    // TODO redis联军更新
+    console.log(league);
+}
+
+export async function guildAbdicateToLeague(guild: GuildType, fromRoleId: string, toRole: RoleType) {
+    if(!guild.leagueCode) return;
+    let league = await GVGLeagueModel.abdicateGuild(guild.leagueCode, fromRoleId, toRole.roleId, toRole._id);
+    // TODO redis联军更新
+    console.log(league);
+}

game-server/app/services/playerCeService.ts

@@ -20,6 +20,7 @@ import { sendMessageToUserWithSuc } from './pushService';
 import { SkinType } from '../db/Skin';
 import { LadderMatchModel } from '../db/LadderMatch';
 import { ArtifactModelType } from '../db/Artifact';
+import { GVGLeagueModel } from '../db/GVGLeague';
 
 interface Param {
     isInitRole?: boolean,
@@ -454,6 +455,7 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
     roleCe = await RoleCeModel.updateRoleCe(roleId, roleCeUpdate);
     let role = await RoleModel.incRoleInfo(roleId, { ...roleIncUpdate, ce: roleInc }, { ...roleUpdate, topLineup, topLineupCe });
     let guild = await GuildModel.updateCe(roleId, roleInc); // 公会更新战力
+    let league = await GVGLeagueModel.updateCe(roleId, roleInc); // 联军更新战力
 
     saveCeChangeLog(role, roleInc, role.ce, type, ceChangeTxt);
     updateRank(roleId, serverId, topLineupCe, role, pushHeros, guild);
@@ -461,6 +463,9 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
     if(hasTopCeChange) await updateRoleOnlineInfo(roleId, { topLineupCe });
     if(guild) {
         await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]);
+    }
+    if(league) { // TODO 联军排行榜需要更新数据
+
     }
     return { heroes, curRole: role }
 }

game-server/app/services/redisService.ts

@@ -513,7 +513,7 @@ async function setServerList() {
     await redisClient().delAsync(REDIS_KEY.SERVER);
     await redisClient().delAsync(REDIS_KEY.SERVER_OPEN_TIME);
 
-    for(let { id, name, openTime, env } of serverList) {
+    for(let { id, serverId, name, openTime, env } of serverList) {
         if(env == pinus.app.get('env')) {
             // console.log(roleId);
             await redisClient().hsetAsync(REDIS_KEY.SERVER, `${id}`, `${name}`);
@@ -536,7 +536,7 @@ export async function getAllServers() {
 }
 
 export async function getAllServerName() {
-    let servers = await  redisClient().hgetallAsync(REDIS_KEY.SERVER);
+    let servers = await redisClient().hgetallAsync(REDIS_KEY.SERVER);
     return servers;
 }
 
@@ -550,6 +550,11 @@ export async function getServerCreateTime(serverId: number) {
     return parseInt(time);
 }
 
+export async function getAllServerCreateTime() {
+    let servers = await  redisClient().hgetallAsync(REDIS_KEY.SERVER_OPEN_TIME);
+    return servers;
+}
+
 export function redisClient() {
     const client: Redis.RedisClient = pinus.app.get('redis');
     return client;

game-server/app/services/timeTaskService.ts

@@ -42,6 +42,8 @@ import { LadderMatchModel } from '../db/LadderMatch';
 import { getGroupShopTimers, refundGroupShop, setGroupShopToSetSum } from './activity/groupShopService';
 import { HiddenDataModel, HiddenDataModelType } from '../db/HiddenData';
 import { setHiddenData, setHiddenDataToMemory } from './dataService';
+import { GVGConfigModel } from '../db/GVGConfig';
+import { createNewGVGConfig, initLeaguePrepare, setGVGConfigToRemote } from './gvg/gvgService';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
@@ -106,6 +108,9 @@ export async function init() {
 
     // 隐藏数据定时器
     initHiddenDataSchedule(true);
+
+    // gvg每周日
+    initGVGConfigSchedule();
 }
 
 // 每日刷新
@@ -889,4 +894,26 @@ export async function initHiddenDataSchedule(isInit: boolean, data?: HiddenDataM
         });
     }
 }
-// —————————————— 配表兼容 end —————————————— //
+// —————————————— 配表兼容 end —————————————— //
+
+// —————————————— gvg start —————————————— //
+export async function initGVGConfigSchedule() {
+    let config = await GVGConfigModel.findConfig();
+    if(!config) {
+        config = await createNewGVGConfig();
+    }
+    setGVGConfigToRemote(config);
+
+    if(nowSeconds() > config.scheduleTime) {
+        config = await createNewGVGConfig();
+    } else {
+        scheduleJob(`gvgConfig`, config.scheduleTime * 1000, createNewGVGConfig);
+    }
+
+    if(nowSeconds() > config.prepareTime) {
+        initLeaguePrepare();
+    } else {
+        scheduleJob(`gvgPrepare`, config.prepareTime * 1000, initLeaguePrepare);
+    }
+}
+// —————————————— gvg end —————————————— //