diff --git a/game-server/app/servers/activity/handler/forgeHandler.ts b/game-server/app/servers/activity/handler/forgeHandler.ts
index a6dab3dd0..18e610ff8 100644
--- a/game-server/app/servers/activity/handler/forgeHandler.ts
+++ b/game-server/app/servers/activity/handler/forgeHandler.ts
@@ -1,6 +1,6 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
 import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
 import { getMetialStr, getPlayerForgeData, getPlayerForgeDataShow } from '../../../services/activity/forgeService';
 import { ActivityForgeModel } from '../../../db/ActivityForge';
@@ -67,7 +67,7 @@ export class ForgeHandler {
         // 保存数据
         let buildResult = await ActivityForgeModel.build(serverId, activityId, roleId, playerData.roundIndex, id, { todayIndex: playerData.todayIndex, isSuccess, material: getMetialStr(material) });
         // 更新数据
-        manual.setPlayerData(buildResult, playerData.todayIndex);
+        manual.setPlayerData(buildResult, playerData.todayIndex, playerData.hint);
         let activityGoods = undefined;
         if(isSuccess) {
             let { goods } = await addReward(roleId, roleName, sid, serverId, stringToRewardParam(manual.reward), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
diff --git a/game-server/app/servers/activity/handler/miniGameHandler.ts b/game-server/app/servers/activity/handler/miniGameHandler.ts
new file mode 100644
index 000000000..53f22c6af
--- /dev/null
+++ b/game-server/app/servers/activity/handler/miniGameHandler.ts
@@ -0,0 +1,201 @@
+import { Application, BackendSession, HandlerService, } from 'pinus';
+import { resResult } from '../../../pubUtils/util';
+import { ITEM_CHANGE_REASON, REDIS_KEY, STATUS } from '../../../consts';
+import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
+import { getPlayerMiniGameData, getPlayerMiniGameDataShow } from '../../../services/activity/miniGameService';
+import { ActivityMiniGameRecModel } from '../../../db/ActivityMiniGameRec';
+import { ActivityMiniGameModel } from '../../../db/ActivityMiniGame';
+import { handleCost } from '../../../services/role/rewardService';
+import { Rank } from '../../../services/rankService';
+import { nowSeconds } from '../../../pubUtils/timeUtil';
+import { RoleRankInfo } from '../../../domain/rank';
+import { getAllServerName } from '../../../services/redisService';
+
+export default function (app: Application) {
+    new HandlerService(app, {});
+    return new ForgeHandler(app);
+}
+
+export class ForgeHandler {
+    constructor(private app: Application) {
+    }
+
+    /**
+    * @description 小游戏数据
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof ForgeHandler
+    */
+    async getMiniGameActivity(msg: { activityId: number }, session: BackendSession) {
+        const { activityId } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerMiniGameDataShow(activityId, serverId, roleId);
+
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        return resResult(STATUS.SUCCESS, playerData);
+    }
+
+    /**
+    * @description  小游戏开始
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof ForgeHandler
+    */
+    async gameStart(msg: { activityId: number }, session: BackendSession) {
+        const { activityId } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        if(playerData.playCnt >= playerData.buyCnt + playerData.freeCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_COUNT_LACK);
+        let record = await ActivityMiniGameRecModel.gameStart(serverId, activityId, playerData.roundIndex, playerData.todayIndex, roleId);
+
+
+        return resResult(STATUS.SUCCESS, {
+            activityId,
+            gameCode: record.gameCode,
+            playCnt: playerData.playCnt
+        });
+    }
+    
+    /**
+    * @description  小游戏结束
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof ForgeHandler
+    */
+    async gameEnd(msg: { activityId: number, gameCode: string, score: number }, session: BackendSession) {
+        const { activityId, gameCode, score } = msg;
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const sid = session.get('sid');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        // 记录得分&次数
+        let record = await ActivityMiniGameRecModel.gameEnd(activityId, roleId, gameCode, score);
+        if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
+
+        let playerRecord = await ActivityMiniGameModel.incScore(serverId, activityId, playerData.roundIndex, roleId, score, playerData.nextRefreshTime);
+        if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
+        playerData.setPlayerData(playerRecord);
+        playerData.incPlayerCnt();
+
+        let rewards = stringToRewardParam(playerData.reward, playerData.nextRefreshTime);
+        let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
+
+        let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
+        await r.setRankWithRoleInfo(roleId, score, nowSeconds(), null, true);
+
+        return resResult(STATUS.SUCCESS, {
+            activityId,
+            gameCode,
+            score: playerData.score,
+            goods
+        });
+    }
+    
+    /**
+    * @description  购买挑战次数
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof ForgeHandler
+    */
+    async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
+        const { activityId, count } = msg;
+        const roleId = session.get('roleId');
+        const sid = session.get('sid');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+        if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_BUY_COUNT_MAX);
+        // 扣材料
+        let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_MINI_GAME_BUY_CNT);
+        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+
+        let playerRecord = await ActivityMiniGameModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count, playerData.nextRefreshTime);
+        playerData.setPlayerData(playerRecord);
+
+        return resResult(STATUS.SUCCESS, {
+            activityId,
+            buyCnt: playerData.buyCnt,
+            maxBuyCnt: playerData.maxBuyCnt
+        });
+    }
+    
+    /**
+    * @description 领取宝箱
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof ForgeHandler
+    */
+    async receiveBox(msg: { activityId: number, boxId: number }, session: BackendSession) {
+        const { activityId, boxId } = msg;
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const sid = session.get('sid');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+        let box = playerData.findBox(boxId);
+        if(!box) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_NOT_FOUND);
+        if(box.hasReceived) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
+        if(box.score > playerData.score) return resResult(STATUS.ACTIVITY_MINI_GAME_SCORE_NOT_ENOUGH);
+        let result = await ActivityMiniGameModel.receiveBox(serverId, activityId, playerData.roundIndex, roleId, boxId);
+        if(!result) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
+        playerData.setPlayerData(result);
+
+        let rewards = stringToRewardParam(playerData.reward, playerData.nextRefreshTime);
+        let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
+
+        return resResult(STATUS.SUCCESS, {
+            activityId,
+            curBox: playerData.findBox(boxId),
+            goods
+        });
+    }
+    
+    /**
+    * @description 排行榜
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof ForgeHandler
+    */
+    async getRanks(msg: { activityId: number }, session: BackendSession) {
+        const { activityId } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        
+        let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        let serverNames = await getAllServerName();
+        let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
+        r.setGenerFieldsFun((obj => {
+            if(obj instanceof RoleRankInfo) {
+                return { rank: obj.rank, roleId: obj.roleId, name: obj.roleName, serverId: obj.serverId, serverName: serverNames[obj.serverId], num: obj.num }
+            }
+            return null
+        }));
+    
+        let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
+        if (!myRank) {
+            myRank = await r.generMyRankWithRole(roleId, playerData.score, nowSeconds());
+        }
+
+        return resResult(STATUS.SUCCESS, {
+            activityId,
+            gameType: playerData.gameType,
+            ranks, myRank
+        });
+    }
+}
diff --git a/game-server/app/services/activity/activityService.ts b/game-server/app/services/activity/activityService.ts
index 7953a650d..1bc5fbd45 100644
--- a/game-server/app/services/activity/activityService.ts
+++ b/game-server/app/services/activity/activityService.ts
@@ -42,6 +42,7 @@ import { _getActivities, _getActivitiesByServerId, _getActivitiesByType, _getAct
 import { getGroupShopDataShow } from './groupShopService';
 import { getBindPhoneDataShow } from './bindPhoneService';
 import { getPlayerForgeDataShow } from './forgeService';
+import { getPlayerMiniGameDataShow } from './miniGameService';
 
 /**
    * 获取活动数据
@@ -238,6 +239,11 @@ export async function getActivity(serverId: number, roleId: string, uid: number,
                 activityData = await getPlayerForgeDataShow(activityId, serverId, roleId);
                 break
             }
+        case ACTIVITY_TYPE.MINI_GAME:
+            {
+                activityData = await getPlayerMiniGameDataShow(activityId, serverId, roleId);
+                break
+            }
         default: {
             console.log('未知活动类型.........', activityType)
             break;
diff --git a/game-server/app/services/activity/miniGameService.ts b/game-server/app/services/activity/miniGameService.ts
new file mode 100644
index 000000000..c3c7b0036
--- /dev/null
+++ b/game-server/app/services/activity/miniGameService.ts
@@ -0,0 +1,46 @@
+import { ActivityForgeModel } from "../../db/ActivityForge";
+import { ActivityMiniGameModel } from "../../db/ActivityMiniGame";
+import { ActivityMiniGameRecModel } from "../../db/ActivityMiniGameRec";
+import { MiniGameData } from "../../domain/activityField/miniGameField";
+import { getRoleCreateTime, getServerCreateTime } from "../redisService";
+import { getActivityById } from "./activityService";
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerMiniGameData(activityId: number, serverId: number, roleId: string) {
+    let activityData = await getActivityById(activityId);
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new MiniGameData(activityData, createTime, serverTime);
+    let playerRecord = await ActivityMiniGameModel.findData(serverId, activityId, playerData.roundIndex, roleId);
+    let records = await ActivityMiniGameRecModel.findRecords(serverId, activityId, playerData.roundIndex, roleId);
+    playerData.setPlayerData(playerRecord);
+    playerData.setPlayerRecords(records);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerMiniGameDataShow(activityId: number, serverId: number, roleId: string) {
+    let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
+    if(playerData && playerData.canShow && playerData.canShow()) {
+        return playerData.getShowResult();
+    }
+    return null
+}
+
+export function getMetialStr(material: { id: number, count: number }[]) {
+    return material.map(({id, count}) => `${id}&${count}`).join('|')
+}
\ No newline at end of file
diff --git a/game-server/app/services/checkParam.ts b/game-server/app/services/checkParam.ts
index a5e4782f6..824689d48 100644
--- a/game-server/app/services/checkParam.ts
+++ b/game-server/app/services/checkParam.ts
@@ -120,6 +120,7 @@ export function checkRouteParam(route: string, msg: any) {
         case 'activity.groupShopHandler.getGroupShopPage':
         case 'activity.groupShopHandler.leaveGroupShopPage':
         case 'activity.forgeHandler.getForgeActivity':
+        case 'activity.miniGameHandler.getMiniGameActivity':
             {
                 if(!checkNaturalNumbers(msg.activityId)) return false;
                 break;
@@ -442,6 +443,35 @@ export function checkRouteParam(route: string, msg: any) {
                 if(!checkNaturalNumbers(activityId, id, count)) return false;
                 break;
             }
+        case 'activity.miniGameHandler.gameStart':
+            {
+                if(!checkNaturalNumbers(msg.activityId)) return false;
+                break;
+            }
+        case 'activity.miniGameHandler.gameEnd':
+            {
+                let { activityId, gameCode, score } = msg;
+                if(!checkNaturalNumbers(activityId, score)) return false;
+                if(!checkNaturalStrings(gameCode)) return false;
+                break;
+            }
+        case 'activity.miniGameHandler.buyCnt':
+            {
+                let { activityId, count } = msg;
+                if(!checkNaturalNumbers(activityId, count)) return false;
+                break;
+            }
+        case 'activity.miniGameHandler.receiveBox':
+            {
+                let { activityId, boxId } = msg;
+                if(!checkNaturalNumbers(activityId, boxId)) return false;
+                break;
+            }
+        case 'activity.miniGameHandler.getRanks':
+            {
+                if(!checkNaturalNumbers(msg.activityId)) return false;
+                break;
+            }
         case "battle.barrageHandler.getBarrageList":
             {
                 if(!checkNaturalStrings(msg.rid)) return false;
diff --git a/game-server/app/services/rankService.ts b/game-server/app/services/rankService.ts
index 9701127d2..4f75bdb51 100644
--- a/game-server/app/services/rankService.ts
+++ b/game-server/app/services/rankService.ts
@@ -20,6 +20,7 @@ import { GVGVestigeSumRankModel } from "../db/GVGVestigeSumRank";
 import { GVGLeagueModel, GVGLeagueType } from "../db/GVGLeague";
 import { GVGVestigeLeagueRankModel } from "../db/GVGVestigeLeagueRank";
 import { getDayKeyInfo } from "./gvg/gvgFightService";
+import { ActivityMiniGameModel } from "../db/ActivityMiniGame";
 
 
 /**
@@ -1207,6 +1208,16 @@ export async function setRankRedisFromDb(type: string, args?: { serverId?: numbe
                 }
             }
         }
+    } else if (type == REDIS_KEY.ACTIVITY_MINI_GAME) {
+        let ranks = await ActivityMiniGameModel.findRank();
+        for(let { _id: { activityId, roundIndex }, roleIds, arr } of ranks) {
+            let r = new Rank(type, { activityId, roundIndex });
+            let roles = await RoleModel.findByRoleIds(roleIds, ROLE_SELECT.RANK);
+            for(let { roleId, score, updatedAt } of arr) {
+                let role = roles.find(cur => cur.roleId == roleId);
+                if(role) await r.setRankWithRoleInfo(roleId, score, updatedAt.getTime(), role, false);
+            }
+        }
     }
 }
 
diff --git a/game-server/app/services/redisService.ts b/game-server/app/services/redisService.ts
index 5be3fb55e..2d1aef70d 100644
--- a/game-server/app/services/redisService.ts
+++ b/game-server/app/services/redisService.ts
@@ -51,12 +51,14 @@ export async function initAllRank() {
     await delKeys(REDIS_KEY.LADDER);
     await delKeys(REDIS_KEY.GVG_VESTIGE_MEMBER_ALL);
     await delKeys(REDIS_KEY.GVG_VESTIGE_LEAGUE);
+    await delKeys(REDIS_KEY.ACTIVITY_MINI_GAME);
     // 测试服特殊处理，由于重启较频繁且联军数据较少，数据先不删，正式服激战期间不会重启
     if(!isDevelopEnv()) await delKeys(REDIS_KEY.LEAGUE_INFO);
 
     await setRankRedisFromDb(REDIS_KEY.PVP_RANK, {});
     await setRankRedisFromDb(REDIS_KEY.GVG_VESTIGE_MEMBER_ALL, {});
     await setRankRedisFromDb(REDIS_KEY.GVG_VESTIGE_LEAGUE, {});
+    await setRankRedisFromDb(REDIS_KEY.ACTIVITY_MINI_GAME, {});
     
     for(let {id} of serverList) {
         await initRankByServerId(id);
diff --git a/shared/consts/constModules/sysConst.ts b/shared/consts/constModules/sysConst.ts
index b36c8d61a..248c15f1d 100644
--- a/shared/consts/constModules/sysConst.ts
+++ b/shared/consts/constModules/sysConst.ts
@@ -267,6 +267,7 @@ export enum REDIS_KEY {
     GVG_HISTORY_CITY ='gvgHisCity',        // gvg激战期玩家进入的城池
     GVG_SEND_REWARD ='gvgSendReward',        // gvg发放奖励
     GVG_SPINE_CNT ='gvgSpineCnt',        // gvg spine的下发数量
+    ACTIVITY_MINI_GAME ='miniGame',        // 活动小游戏排行榜
 }
 
 // 各排行榜对应hash的key
@@ -329,7 +330,8 @@ export function getInfoKeyByRedisKey(redisKey: REDIS_KEY) {
             return { infoKey: REDIS_KEY.LEAGUE_INFO, extraKey: [] };
         case REDIS_KEY.GVG_BATTLE_LEAGUE_RANK_BY_CITY:   // 激战期联军排行榜
             return { infoKey: REDIS_KEY.LEAGUE_INFO, extraKey: [] };
-            
+        case REDIS_KEY.ACTIVITY_MINI_GAME:
+            return { infoKey: REDIS_KEY.USER_INFO, extraKey: [] };
         default:
             return { infoKey: REDIS_KEY.USER_INFO, extraKey: [] };
     }
@@ -431,7 +433,8 @@ export const KEY_TO_COMPOSE_FIELD = new Map([
     [REDIS_KEY.LEAGUE_INFO, COMPOSE_FIELD_TYPE.LEAGUE],
     [REDIS_KEY.GVG_BATTLE_RANK, COMPOSE_FIELD_TYPE.ROLE],
     [REDIS_KEY.GVG_BATTLE_LEAGUE_RANK, COMPOSE_FIELD_TYPE.LEAGUE],
-    [REDIS_KEY.GVG_BATTLE_LEAGUE_RANK_BY_CITY, COMPOSE_FIELD_TYPE.LEAGUE]
+    [REDIS_KEY.GVG_BATTLE_LEAGUE_RANK_BY_CITY, COMPOSE_FIELD_TYPE.LEAGUE],
+    [REDIS_KEY.ACTIVITY_MINI_GAME, COMPOSE_FIELD_TYPE.ROLE]
 ]);
 
 
@@ -1140,8 +1143,10 @@ export enum ITEM_CHANGE_REASON {
     GVG_REVIVE = 174,                        // gvg复活队伍
     GVG_USE_ITEM = 175,                      // gvg使用连弩
     ARTIFACT_LV_RETURN = 176,                // 宝物继承等级返还
-    ACT_FORGE_BUILD = 177,                  // 火神祭祀锻造
-    ACT_FORGE_HELP = 178,                // 火神祭祀失败补助
+    ACT_FORGE_BUILD = 177,                   // 火神祭祀锻造
+    ACT_FORGE_HELP = 178,                    // 火神祭祀失败补助
+    ACT_MINI_GAME_REWARD = 179,              // 小游戏单局奖励
+    ACT_MINI_GAME_BUY_CNT = 180,             // 小游戏花元宝买
 }
 
 export enum TA_EVENT {
diff --git a/shared/consts/statusCode.ts b/shared/consts/statusCode.ts
index 1b3cc572a..29ca38d3e 100644
--- a/shared/consts/statusCode.ts
+++ b/shared/consts/statusCode.ts
@@ -649,6 +649,12 @@ export const STATUS = {
     ACTIVITY_BUILD_COUNT: { code: 50047, simStr: '铸造次数已满' },
     ACTIVITY_BUY_CNT_MAX: { code: 50048, simStr: '该图谱购买次数已达上限' },
     ACTIVITY_MATERIAL_COUNT_NOT_ZERO: { code: 50049, simStr: '材料数量不可为0' },
+    ACTIVITY_MINI_GAME_COUNT_LACK: { code: 50050, simStr: '次数不足' },
+    ACTIVITY_MINI_GAME_RECORD_NOT_FOUND: { code: 50051, simStr: '未找到这条记录' },
+    ACTIVITY_MINI_GAME_BUY_COUNT_MAX: { code: 50052, simStr: '购买次数不足' },
+    ACTIVITY_MINI_GAME_BOX_NOT_FOUND: { code: 50053, simStr: '未找到该宝箱' },
+    ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED: { code: 50054, simStr: '该宝箱已领取' },
+    ACTIVITY_MINI_GAME_SCORE_NOT_ENOUGH: { code: 50055, simStr: '积分不足' },
 
     // GM后台相关状态 60000 - 69999
     GM_ERR_PASSWORD: { code: 60001, simStr: '账号或密码错误' },
diff --git a/shared/db/ActivityMiniGame.ts b/shared/db/ActivityMiniGame.ts
new file mode 100644
index 000000000..2dd8804d2
--- /dev/null
+++ b/shared/db/ActivityMiniGame.ts
@@ -0,0 +1,72 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+
+/**
+  * 小游戏记录
+*/
+
+@index({ roleId: 1, activityId: 1 })
+@index({ score: -1 })
+
+export default class Activity_MiniGame extends BaseModel {
+    @prop({ required: true })
+    serverId: number;				// 服Id
+
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+
+    @prop({ required: true })
+    roundIndex: number;				// 第几轮
+
+    @prop({ required: true })
+    nextRefreshTime: number;				// 活动结束时间
+
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+
+    @prop({ required: true })
+    buyCnt: number;			        // 小游戏购买次数
+
+    @prop({ required: true, type: Number })
+    receivedBox: number[];			        // 领取宝箱
+
+    @prop({ required: true })
+    score: number;			        // 积分
+
+    public static async findData(serverId: number, activityId: number, roundIndex: number, roleId: string) {
+      let result: ActivityMiniGameModelType = await ActivityMiniGameModel.findOne({ serverId, roleId, activityId, roundIndex }).lean();
+      return result;
+    }
+
+    public static async incScore(serverId: number, activityId: number, roundIndex: number, roleId: string, score: number, nextRefreshTime: number) {
+      let result: ActivityMiniGameModelType = await ActivityMiniGameModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex }, { $inc: { score }, $setOnInsert: { buyCnt: 0, receivedBox: [] }, $set: { nextRefreshTime } }, { new: true, upsert: true }).lean();
+      return result;
+    }
+
+    public static async buyCnt(serverId: number, activityId: number, roundIndex: number, roleId: string, count: number, nextRefreshTime: number) {
+      let result: ActivityMiniGameModelType = await ActivityMiniGameModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex }, { $inc: { buyCnt: count }, $setOnInsert: { score: 0, receivedBox: [] }, $set: { nextRefreshTime } }, { new: true, upsert: true }).lean();
+      return result;
+    }
+
+    public static async receiveBox(serverId: number, activityId: number, roundIndex: number, roleId: string, boxId: number) {
+      let result: ActivityMiniGameModelType = await ActivityMiniGameModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, receivedBox: { $ne: boxId } }, { $push: { receivedBox: boxId } }, { new: true }).lean();
+      return result;
+    }
+
+    public static async findRank() {
+      let result: { _id: { activityId: number, roundIndex: number }, roleIds: string[], arr: { roleId: string, score: number, updatedAt: Date }[] }[] 
+        = await ActivityMiniGameModel.aggregate([
+        { $match: { nextRefreshTime: { $gt: Date.now() } } },
+        { $group: { 
+          _id: { activityId: '$activityId', roundIndex: '$roundIndex' }, 
+          roleIds: { $push: '$roleId' }, arr: { $push: { roleId: '$roleId', score: '$score', updatedAt: '$updatedAt' } } }
+        }
+      ]);
+      return result
+    }
+}
+
+export const ActivityMiniGameModel = getModelForClass(Activity_MiniGame);
+
+export interface ActivityMiniGameModelType extends Pick<DocumentType<Activity_MiniGame>, keyof Activity_MiniGame> { }
+export type ActivityMiniGameModelTypeParam = Partial<ActivityMiniGameModelType>; // 将所有字段变成可选项
\ No newline at end of file
diff --git a/shared/db/ActivityMiniGameRec.ts b/shared/db/ActivityMiniGameRec.ts
new file mode 100644
index 000000000..2ab180269
--- /dev/null
+++ b/shared/db/ActivityMiniGameRec.ts
@@ -0,0 +1,62 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+import { genCode } from '../pubUtils/util';
+
+/**
+  * 小游戏记录
+*/
+
+@index({ roleId: 1, activityId: 1 })
+@index({ gameCode: 1 })
+
+export default class Activity_MiniGame_Rec extends BaseModel {
+    @prop({ required: true })
+    serverId: number;				// 服Id
+
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+
+    @prop({ required: true })
+    roundIndex: number;				// 第几轮
+
+    @prop({ required: true })
+    todayIndex: number;				// 今天第几天
+
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+
+    @prop({ required: true })
+    gameCode: string;	           // 唯一id
+
+    @prop({ required: true })
+    score: number;				    // 这局游戏的得分
+
+    @prop({ required: true })
+    isComplete: boolean;		 // 是否结束
+
+    public static async findRecords(serverId: number, activityId: number, roundIndex: number, roleId: string) {
+        let result: ActivityMiniGameRecModelType[] = await ActivityMiniGameRecModel.find({ serverId, roleId, activityId, roundIndex, isComplete: true }).lean();
+        return result;
+    }
+
+    public static async findByCode(activityId: number, roleId: string, gameCode: string) {
+        let result: ActivityMiniGameRecModelType = await ActivityMiniGameRecModel.findOne({ activityId, roleId, gameCode }).lean();
+        return result;
+    }
+
+    public static async gameStart(serverId: number, activityId: number, roundIndex: number, todayIndex: number, roleId: string) {
+        let gameCode = genCode(10);
+        let result: ActivityMiniGameRecModelType = await ActivityMiniGameRecModel.findOneAndUpdate({ gameCode }, { $set: { serverId, activityId, roundIndex, todayIndex, roleId, score: 0, isComplete: false } }, { new: true, upsert: true }).lean();
+        return result;
+    }
+
+    public static async gameEnd(activityId: number, roleId: string, gameCode: string, score: number) {
+        let result: ActivityMiniGameRecModelType = await ActivityMiniGameRecModel.findOneAndUpdate({ activityId, roleId, gameCode, isComplete: false }, { $set: { score, isComplete: true } }, { new: true }).lean();
+        return result;
+    }
+}
+
+export const ActivityMiniGameRecModel = getModelForClass(Activity_MiniGame_Rec);
+
+export interface ActivityMiniGameRecModelType extends Pick<DocumentType<Activity_MiniGame_Rec>, keyof Activity_MiniGame_Rec> { }
+export type ActivityMiniGameRecModelTypeParam = Partial<ActivityMiniGameRecModelType>; // 将所有字段变成可选项
\ No newline at end of file
diff --git a/shared/domain/activityField/forgeField.ts b/shared/domain/activityField/forgeField.ts
index 3fad6d9f9..6d01601fa 100644
--- a/shared/domain/activityField/forgeField.ts
+++ b/shared/domain/activityField/forgeField.ts
@@ -62,17 +62,18 @@ export class ForgeManual {
         this.quality = data.quality;
     }
 
-    public setPlayerData(playerData: ActivityForgeModelType, todayIndex: number) {
+    public setPlayerData(playerData: ActivityForgeModelType, todayIndex: number, hintDic?: ForgeHintInDb[]) {
         this.buildCnt = playerData.buildCnt||0;
         this.buyCnt = playerData.buyCnt||0;
         let todayFailRecord = playerData.record?.filter(cur => cur.todayIndex == todayIndex && cur.isSuccess == false)||[];
-        this.failCnt = todayFailRecord.length;
+        this.failCnt = todayFailRecord.length;   
+        if(hintDic) this.calHintType(hintDic);
     }
 
     public calHintType(hintDic: ForgeHintInDb[]) {
         for(let { failCnt, hintType } of hintDic) {
-            if(this.failCnt < failCnt) {
-                this.hintType = hintType; break;
+            if(this.failCnt >= failCnt) {
+                this.hintType = hintType;
             }
         }
     }
diff --git a/shared/domain/activityField/miniGameField.ts b/shared/domain/activityField/miniGameField.ts
new file mode 100644
index 000000000..9b315093d
--- /dev/null
+++ b/shared/domain/activityField/miniGameField.ts
@@ -0,0 +1,109 @@
+// 节日活动 - 小游戏
+import { pick } from 'underscore';
+import { ActivityModelType } from '../../db/Activity';
+import { ActivityMiniGameModelType } from '../../db/ActivityMiniGame';
+import { ActivityMiniGameRecModelType } from '../../db/ActivityMiniGameRec';
+import { ActivityBase } from './activityField';
+
+// 后台格式
+
+interface MiniGameBuyCountInDb {
+    day: number;      // 第几天
+    buyCnt: number;    // 可以购买的次数（累积）
+    freeCnt: number;   // 免费次数（每日刷新）
+}
+
+interface MiniGameBoxInDb {
+    id: number;   // 宝箱id
+    score: number; // 分数
+    reward: string; // type&id&count
+}
+
+interface MiniGameDataInDb {
+    gameType: number;     // 小游戏类型 1-消消乐 2-射箭
+    buyCounts: MiniGameBuyCountInDb[];         // 可购买次数
+    consume: string;     // 购买次数的花费 type&id&count
+    reward: string;      // 每局的参与奖励 type&id&count
+    box: MiniGameBoxInDb[]; // 宝箱
+}
+
+class MiniGameBox {
+    id: number;   // 宝箱id
+    score: number; // 分数/成功次数
+    reward: string; // type&id&count
+    hasReceived: boolean = false; // 是否已领取
+
+    constructor(data: MiniGameBoxInDb) {
+        this.id = data.id;
+        this.score = data.score;
+        this.reward = data.reward;
+    }
+
+    public setReceive(box: number[]) {
+        if(box.indexOf(this.id) != -1) this.hasReceived = true;
+    }
+}
+
+export class MiniGameData extends ActivityBase {
+    gameType: number;     // 小游戏类型 1-消消乐 2-射箭
+    consume: string;     // 购买次数的消耗 type&id&count
+    reward: string;      // 单局游戏的参与奖励 type&id&count
+    freeCnt: number = 0;      // 今天的免费次数
+    maxBuyCnt: number = 0;      // 今天可以购买的次数
+    box: MiniGameBox[] = [];    // 宝箱
+
+    playCnt: number = 0;   // 已玩次数，当 playCnt < freeCnt + buyCnt 时可以玩
+    buyCnt: number = 0;      // 已购买次数
+    score: number = 0;    // 当前总分
+
+    constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
+        super(activityData, createTime, serverTime)
+        this.initData(activityData.data)
+    }
+
+    public initData(data: string): void {
+        let dataObj: MiniGameDataInDb = JSON.parse(data);
+        if(!dataObj) return;
+        
+        this.gameType = dataObj.gameType;
+        this.consume = dataObj.consume;
+        this.reward = dataObj.reward;
+
+        for(let { day, buyCnt, freeCnt } of (dataObj.buyCounts||[])) {
+            if(day == this.todayIndex) this.freeCnt = freeCnt;
+            if(day <= this.todayIndex) this.maxBuyCnt += buyCnt;
+        }
+
+        for(let data of (dataObj.box||[])) {
+            this.box.push(new MiniGameBox(data));
+        }
+    }
+
+    public setPlayerData(playerData: ActivityMiniGameModelType) {
+        if(!playerData) return;
+        this.buyCnt = playerData.buyCnt||0;
+        this.score = playerData.score||0;
+        for(let box of this.box) {
+            box.setReceive(playerData.receivedBox||[]);
+        }
+    }
+
+    public setPlayerRecords(records: ActivityMiniGameRecModelType[]) {
+        this.playCnt = records.length;
+    }
+
+    public incPlayerCnt() {
+        this.playCnt++;
+    }
+
+    public findBox(boxId: number) {
+        return this.box.find(cur => cur.id == boxId);
+    }
+
+    public getShowResult() {
+        return {
+            ...this.getBaseKeys(),
+            ...pick(this, ['gameType', 'consume', 'reward', 'freeCnt', 'maxBuyCnt', 'box', 'playCnt', 'buyCnt', 'score'])
+        }
+    }
+}
\ No newline at end of file
diff --git a/shared/domain/rank.ts b/shared/domain/rank.ts
index 9850f6f30..472a3a371 100644
--- a/shared/domain/rank.ts
+++ b/shared/domain/rank.ts
@@ -361,6 +361,7 @@ export class KeyName {
     hid?: number;
     seasonNum?: number;
     activityId?: number;
+    roundIndex?: number;
     index?: number;  // 军团活动第几期
     vestigeId?: number;
     groupKey?: string;
@@ -380,6 +381,7 @@ export class KeyName {
         if(param.groupKey) this.groupKey = param.groupKey;
         if(param.day) this.day = param.day;
         if(param.configId) this.configId = param.configId;
+        if(param.roundIndex) this.roundIndex = param.roundIndex;
     }
 
     public getName() {
@@ -424,6 +426,8 @@ export class KeyName {
                 return `${this.key}:${this.configId}:${this.groupKey}`;
             case REDIS_KEY.GVG_BATTLE_LEAGUE_RANK_BY_CITY:
                 return `${this.key}:${this.configId}:${this.groupKey}:${this.cityId}`;
+            case REDIS_KEY.ACTIVITY_MINI_GAME:
+                return `${this.key}:${this.activityId}:${this.roundIndex}`;
             default:
                  return this.key;
         }