活动：限时排行榜

game-server/app/services/activity/activityService.ts

@@ -33,6 +33,7 @@ import { ActivityGroupTypeModel } from '../../db/ActivityGroupType';
 import { ServerlistModel } from '../../db/Serverlist';
 import { ActivityInRemote, transActivityInRemoteToModelType } from '../../domain/activityField/activityField';
 import { getPlayerLuckyTurntableDataShow } from './luckyTurntableService';
+import { getTimeLimitRankDataShow } from './timeLimitRankService';
 
 /**
    * 获取活动数据
@@ -191,6 +192,11 @@ export async function getActivity(serverId: number, roleId: string, activityId:
                 activityData = await getPlayerLuckyTurntableDataShow(activityId, serverId, roleId);
                 break;
             }
+        case ACTIVITY_TYPE.TIME_LIMIT_RANK: // 限时排行
+            {
+                activityData = await getTimeLimitRankDataShow(activityId);
+                break;
+            }
         default: {
             console.log('未知活动类型.........', activityType)
             break;
@@ -241,11 +247,11 @@ export function _getActivityById(activityId: number) {
 export function _getActivitiesByType(serverId: number, type: number) {
     let activityByType = pinus.app.get('activityByType')?.get(serverId)?.get(type)||[];
     let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
-    let result: ActivityInRemote[] = [];
+    let result: ActivityModelType[] = [];
     for(let activityId of activityByType) {
         let activity = activities.get(activityId);
         if(activity && activity.beginTime <= Date.now()) {
-            result.push(activity);
+            result.push(transActivityInRemoteToModelType(activity));
         }
     }
     return result;

game-server/app/services/activity/timeLimitRankService.ts

@@ -0,0 +1,124 @@
+import { ACTIVITY_TYPE, getRedisKeyByRankType, MAIL_TYPE, REDIS_KEY } from "../../consts";
+import { ActivityGroupModel } from "../../db/ActivityGroup";
+import { ActivityTimeLimitRankModel, ActivityTimeLimitRankModelTypeParam } from "../../db/ActivityTimeLimitRank";
+import { GuildModel, GuildType } from "../../db/Guild";
+import { RoleModel } from "../../db/Role";
+import { TimeLimitRankData } from "../../domain/activityField/timeLimitRankField";
+import { GuildRankInfo, RoleRankInfo } from "../../domain/rank";
+import { sendMailByContent, sendMailToGuildByContent } from "../mailService";
+import { Rank } from "../rankService";
+import { getActivitiesByType, getActivityById } from "./activityService";
+import { stringToRewardInter } from "./giftPackageService";
+
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+ export async function getTimeLimitRankData(activityId: number) {
+    let activityData = await getActivityById(activityId);
+
+    let playerData = new TimeLimitRankData(activityData, 0);
+    return playerData;
+}
+
+export async function getTimeLimitRankDataShow(activityId: number) {
+    let playerData = await getTimeLimitRankData(activityId);
+    if(playerData && playerData.canShow && playerData.canShow()) {
+        return playerData.getShowResult();
+    }
+    return null
+}
+
+
+/**
+ * @description 记录每次活动获得的资金排行榜
+ * @param serverId 
+ * @param code 
+ * @param fund 
+ */
+export async function recordGuildFund(serverId: number, guild: GuildType, fund: number) {
+    let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.TIME_LIMIT_RANK);
+    for(let activity of activities) {
+        let playerData = new TimeLimitRankData(activity, 0);
+        if(playerData.canRecord()) {
+            await ActivityTimeLimitRankModel.addGuildScore(serverId, playerData.activityId, playerData.rankType, guild.code, fund, guild._id);
+            
+            let redisKey = getRedisKeyByRankType(playerData.rankType);
+            // 加入排行
+            let r = new Rank(redisKey, { serverId, activityId: playerData.activityId });
+            await r.setRankWithGuildInfo(guild.code, fund, Date.now(), guild, true);
+        }
+    }
+}
+
+/**
+ * 活动结束发送排行榜奖励
+ * @param data {TimeLimitRankData} 活动数据
+ * @returns 
+ */
+export async function sendRankMail(data: TimeLimitRankData) {
+    let redisKey = getRedisKeyByRankType(data.rankType);
+    if (!redisKey) return null;
+    let r = new Rank(redisKey, { activityId: data.activityId });
+    if(r.infoKey == REDIS_KEY.GUILD_INFO) {
+        let allRank = <GuildRankInfo[]>(await r.getRankByRange());
+
+        for(let { rank, code, name } of allRank) {
+            let reward = data.getRewardByRank(rank);
+            if(reward) {
+                await sendMailToGuildByContent(MAIL_TYPE.TIME_LIMIT_RANK, code, {
+                    params: [data.tabName,`${rank}`],
+                    goods: stringToRewardInter(reward.rewards)
+                });
+            }
+        }
+    } else {
+        let allRank = <RoleRankInfo[]>(await r.getRankByRange());
+
+        for(let { rank, roleId } of allRank) {
+            let reward = data.getRewardByRank(rank);
+            if(reward) {
+                await sendMailByContent(MAIL_TYPE.TIME_LIMIT_RANK, roleId, {
+                    params: [data.tabName, `${rank}`],
+                    goods: stringToRewardInter(reward.rewards)
+                });
+            }
+        }
+    }
+}
+
+export async function takeSnapshot(data: TimeLimitRankData, groupId: number) {
+    let redisKey = getRedisKeyByRankType(data.rankType);
+    let targetRedisKey = getRedisKeyByRankType(data.rankType, true);
+    if (!redisKey || !targetRedisKey || redisKey == targetRedisKey) return null;
+
+    let activityGroup = await ActivityGroupModel.findGroupData(groupId);
+    let serverIds = activityGroup? activityGroup.serverIds: [];
+
+    let insertInfos: ActivityTimeLimitRankModelTypeParam[] = [];
+    for(let serverId of serverIds) {
+        let r = new Rank(redisKey, { serverId, activityId: data.activityId });
+        let allRank = await r.getRankDataByRankWithoutDetail();
+        let targetR = new Rank(targetRedisKey, { serverId, activityId: data.activityId });
+        for(let rank of allRank) {
+            await targetR.setRank(rank.myId, rank.scores);
+
+            let insertBaseInfo = {
+                serverId, activityId: data.activityId, rankType: data.rankType, score: rank.scores[0]||0, time: rank.scores[1]||0
+            }
+            if(rank.myId.roleId) {
+                let role = await RoleModel.findByRoleId(rank.myId.roleId, '_id roleId');
+                if(role) insertInfos.push({ ...insertBaseInfo, roleId: role.roleId, role: role._id });
+            } else if(rank.myId.guildCode) {
+                let guild = await GuildModel.findByCode(rank.myId.guildCode, serverId, '_id guildCode');
+                if(guild) insertInfos.push({ ...insertBaseInfo, guildCode: guild.code, guild: guild._id });
+            }
+        }
+    }
+    await ActivityTimeLimitRankModel.insertRanks(insertInfos);
+}