✨ feat(gvg): 备战期结束发放未领取邮件

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

@@ -500,7 +500,7 @@ export class GVGProduceHandler {
         if(canReceiveLeagueRanks.length <= 0 && canReceivePlayerRanks.length <= 0) return resResult(STATUS.GVG_RECEIVE_NO_RANK_REWARD);
         
         let { leagueReward, rewards } = calVestigeLeagueBoxRewards(canReceiveLeagueRanks, canReceivePlayerRanks);
-        let leagueGoods = await addGVGReward(roleId, roleName, myLeague.leagueCode, sid, leagueReward, rewards, ITEM_CHANGE_REASON.GVG_VESTIGE_RECEIVE_RANK)
+        let leagueGoods = await addGVGReward(roleId, roleName, myLeague.leagueCode, sid, leagueReward, rewards, ITEM_CHANGE_REASON.GVG_VESTIGE_RECEIVE_RANK);
         await GVGVestigeLeagueRankModel.receiveRanks(canReceiveLeagueRanks.map(cur => cur._id), roleId);
         await GVGVestigeSumRankModel.receiveRanks(canReceivePlayerRanks.map(cur => cur._id));
 

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

@@ -14,7 +14,7 @@ class GVGBattleData {
     public groupKey: string;     // 战区
 
     private teams: Map<string, GVGTeamMem> = new Map(); // 队伍, teamCode => team
-    private rolePoints: Map<string, Map<number, string>> = new Map(); // roleId => pointId[]，用于更新玩家的积分
+    public rolePoints: Map<string, Map<number, string>> = new Map(); // roleId => pointId[]，用于更新玩家的积分
     private roleToTeam: Map<string, string[]> = new Map(); // roleId => teamCode
     private leagueToTeam: Map<string, Set<string>> = new Map(); // leagueCode => teamCode
     public areaToTeams: Map<number, Set<string>> = new Map(); // areaId => teamCode set，用于定时下发地图玩家数据

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

@@ -1,7 +1,7 @@
 // 征战中原相关
 
 import moment = require("moment");
-import { GVG_PERIOD, GVG_RETURN_ITEM_TYPE, REDIS_KEY, VESTIGE_OPP_STATUS, VESTIGE_STATUS } from "../../consts";
+import { GVG_PERIOD, GVG_RETURN_ITEM_TYPE, ITEM_CHANGE_REASON, MAIL_TYPE, REDIS_KEY, VESTIGE_OPP_STATUS, VESTIGE_STATUS } from "../../consts";
 import { ArtifactModel } from "../../db/Artifact";
 import { GVGConfigModel } from "../../db/GVGConfig";
 import { GVGLeagueModel, GVGLeagueType } from "../../db/GVGLeague";
@@ -23,11 +23,12 @@ import { RewardInter } from "../../pubUtils/interface";
 import { getTimeFun, nowSeconds } from "../../pubUtils/timeUtil";
 import { getRandEelm } from "../../pubUtils/util";
 import { getNumberArr, uniqueArr } from "../ladderService";
+import { sendMailByContent } from "../mailService";
 import { getHeroesAttributes } from "../playerCeService";
 import { Rank } from "../rankService";
 import { findKeys, getAllServerName, redisClient } from "../redisService";
 import { isDevelopEnv } from "../utilService";
-import { combinePushItem } from "./gvgItemService";
+import { addGVGReward, combinePushItem } from "./gvgItemService";
 import { addVestigeLeagueRankRec, addVestigeRankMessage } from "./gvgRecService";
 import { getGroupIdOfServer, getGroupKey, getGVGServerType, getPeriodByTime } from "./gvgService";
 
@@ -409,7 +410,7 @@ export async function getVestigeRank(redisKey: REDIS_KEY, isSimple: boolean, key
     return { ranks, myRank }
 }
 
-// systimer 服
+// systimer 服 每天晚上22点
 export async function saveVestigeRankSchedule() {
     let config = await GVGConfigModel.findConfig();
     let period = getPeriodByTime(config.teamTime, config.prepareTime, config.battleTime, config.scheduleTime);
@@ -436,7 +437,60 @@ export async function saveVestigeRankSchedule() {
     await GVGUserDataModel.addVestigeScores(config.configId, playerSumRanks);
 }
 
-export function calVestigeLeagueBoxRewards(canReceiveRanks: GVGVestigeLeagueRankType[], canReceivePlayerRanks: GVGVestigeSumRankType[]) {
+// systimer 服，每周六5点
+export async function sendUngotVestigeReward() {
+    const config = await GVGConfigModel.findConfig();
+    const playerDatas = await GVGVestigeSumRankModel.getAllCanReceiveRanks(config.configId);
+    const leagueCodeByConfig = new Map<number, string[]>();
+    const dataByConfig = new Map<number, Map<string, Map<string, { playerRanks: {_id: string, rank: number }[], leagueRanks: { _id: string, rank: number }[] }>>>(); // configId => leagueCode => playerdata
+    const receiveLeagueParam: { _id: string, roleIds: string[] }[] = [], receivePlayerParam: string[] = [];
+    for(let player of playerDatas) {
+        if(!leagueCodeByConfig.has(player.configId)) leagueCodeByConfig.set(player.configId, []);
+        if(leagueCodeByConfig.get(player.configId).indexOf(player.leagueCode) == -1) {
+            leagueCodeByConfig.get(player.configId).push(player.leagueCode);
+        }
+        if(!dataByConfig.has(player.configId)) dataByConfig.set(player.configId, new Map());
+        if(!dataByConfig.get(player.configId).has(player.leagueCode)) dataByConfig.get(player.configId).set(player.leagueCode, new Map());
+        if(!dataByConfig.get(player.configId).get(player.leagueCode).has(player.roleId)) dataByConfig.get(player.configId).get(player.leagueCode).set(player.roleId, { playerRanks: [], leagueRanks: [] });
+        dataByConfig.get(player.configId).get(player.leagueCode).get(player.roleId).playerRanks.push({ _id: player._id, rank: player.rank });
+
+        receivePlayerParam.push(player._id);
+    }
+    for(let [configId, leagueCodes] of leagueCodeByConfig) {
+        const leagueDatas = await GVGVestigeLeagueRankModel.getAllCanReceiveRanks(configId, leagueCodes);
+        for(let leagueData of leagueDatas) {
+            let players = dataByConfig.get(configId)?.get(leagueData.leagueCode);
+            if(players) {
+                for(let [roleId, data] of players) {
+                    if(leagueData.receiveMembers.indexOf(roleId) == -1) {
+                        data.leagueRanks.push({ _id: leagueData._id, rank: leagueData.rank });
+                        let index = receiveLeagueParam.findIndex(cur => cur._id == leagueData._id);
+                        if(index == -1) {
+                            receiveLeagueParam.push({ _id: leagueData._id, roleIds: [ roleId ] });
+                        } else {
+                            receiveLeagueParam[index].roleIds.push(roleId);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    for(let [configId, leagueMap] of dataByConfig) {
+        for(let [ leagueCode, players ] of leagueMap) {
+            for(let [ roleId, { playerRanks, leagueRanks }] of players) {
+                let { leagueReward, rewards } = calVestigeLeagueBoxRewards(leagueRanks, playerRanks);
+                if(leagueReward.length > 0) await addGVGReward(roleId, '', leagueCode, null, leagueReward, [], ITEM_CHANGE_REASON.GVG_VESTIGE_RECEIVE_RANK);
+                if(rewards.length > 0) await sendMailByContent(MAIL_TYPE.VESTIGE_REWARD, roleId, { params: [`${configId}`], goods: rewards });
+            }
+        }
+    }
+
+    await GVGVestigeSumRankModel.receiveRanks(receivePlayerParam);
+    await GVGVestigeLeagueRankModel.receiveManyRanks(receiveLeagueParam);
+}
+
+export function calVestigeLeagueBoxRewards(canReceiveRanks: { rank: number }[], canReceivePlayerRanks: { rank: number }[]) {
     let rewards: RewardInter[] = [], leagueReward: RewardInter[] = [];
     for(let { rank } of canReceiveRanks) {
         let dicRank = getGVGVestigeLeagueRank(rank);

game-server/app/services/timeTaskService.ts

@@ -44,7 +44,7 @@ import { HiddenDataModel, HiddenDataModelType } from '../db/HiddenData';
 import { setHiddenData, setHiddenDataToMemory } from './dataService';
 import { GVGConfigModel } from '../db/GVGConfig';
 import { createNewGVGConfig, initLeaguePrepare } from './gvg/gvgService';
-import { getFightTimeByPeriod, saveVestigeRankSchedule } from './gvg/gvgFightService';
+import { getFightTimeByPeriod, saveVestigeRankSchedule, sendUngotVestigeReward } from './gvg/gvgFightService';
 import { gvgBattleEnd } from './gvg/gvgBattleService';
 
 const PER_SECOND = 1 * 1000;
@@ -925,6 +925,9 @@ export async function initGVGConfigSchedule() {
     if(scheduledJobs[`gvgFight`]) scheduledJobs[`gvgFight`].cancel();
     scheduleJob(`gvgFight`, '0 0 22 * * ?', saveVestigeRankSchedule);
     
+    if(scheduledJobs[`gvgBattle`]) scheduledJobs[`gvgBattle`].cancel();
+    scheduleJob(`gvgBattle`, config.battleTime * 1000, sendUngotVestigeReward);
+
     let { startFightTime, endFightTime } = getFightTimeByPeriod(GVG_PERIOD.BATTLE, config.battleTime);
 
     if(nowSeconds() > startFightTime - GVG.GVG_GUARD_START_TIME && nowSeconds() < endFightTime) {