活动：大富翁

2021-06-18 19:45:55 +08:00
parent 15ff0938bc
commit b4578f053a
13 changed files with 593 additions and 4 deletions
--- a/game-server/app/servers/activity/handler/activityMonopolyHandler.ts
+++ b/game-server/app/servers/activity/handler/activityMonopolyHandler.ts
@@ -0,0 +1,240 @@
+import { Application, BackendSession } from 'pinus';
+import { resResult } from '../../../pubUtils/util';
+import { ACTIVITY_TYPE, LAND_TYPE, SERVER_OPEN_TIME, STATUS, TASK_TYPE, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE } from '../../../consts';
+import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../../../db/ActivityMonopoly';
+import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../../../db/ActivityMonopolyLand';
+import { ActivityModel } from '../../../db/Activity';
+import { getPlayerMonopolyData, nextPosition } from '../../../services/monopolyService';
+import { random } from 'underscore';
+import { handleCost } from '../../../services/rewardService';
+import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/giftPackageService';
+import { getPlayerRefreshShopData, getPlayerRefreshShopDataByRoundIndex } from '../../../services/refreshShopService';
+import { ActivityRefreshShopModel } from '../../../db/ActivityRefreshShop';
+
+export default function (app: Application) {
+    return new ActivityMonopolyHandler(app);
+}
+
+export class ActivityMonopolyHandler {
+    constructor(private app: Application) {
+    }
+
+
+    /**
+    * @description 获取大富翁活动数据
+    * @param {{activityId: number }} msg
+    * @param {BackendSession} session
+    * @memberof ActivityMonopolyHandler
+    */
+    async getMonopolyActivity(msg: { activityId: number, position: number }, session: BackendSession) {
+        const { activityId, position } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        const sid: string = session.get('sid');
+        const funcs: number[] = session.get('funcs');
+
+        let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
+
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        return resResult(STATUS.SUCCESS, playerData);
+    }
+
+
+    /**
+    * @description 移动
+    * @param {{activityId: number }} msg
+    * @param {BackendSession} session
+    * @memberof ActivityMonopolyHandler
+    */
+    async move(msg: { activityId: number, step: number }, session: BackendSession) {
+        const { activityId, step } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        const sid: string = session.get('sid');
+        const funcs: number[] = session.get('funcs');
+        const roleName = session.get('roleName');
+
+        let moveStep = 0;
+        if (step >= 1 && step <= 6) {//指定
+            //检查资源
+            let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: 1 }]);
+            if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
+            moveStep = step;
+        } else {
+            //检查资源
+            let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: 1 }]);
+            if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
+            moveStep = random(5) + 1;
+        }
+        let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
+
+        let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
+        let oldPosition = playerData.curPosition;
+        let newPosition = nextPosition(oldPosition, moveStep, playerData.list.length);
+        await ActivityMonopolyModel.updatePosition(serverId, activityId, roleId, newPosition, 1)
+
+        let landData = playerData.findMonopolyItem(newPosition);
+        let landReward = null;//土地奖励
+        let bankReward = null;//银行奖励
+        if (landData && landData.landType == LAND_TYPE.BANK_NORMAL) {
+            //土地奖励
+            if (landData.rewards.length > landData.stopCount) {
+                let reward = landData.rewards[landData.level - 1];
+                let rewardArray = stringToRewardParam(reward)
+                landReward = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+            }
+
+            //土地升级
+            if (landData.rewards.length > landData.level) {
+                let newLevel = landData.level + 1;
+                await ActivityMonopolyLandModel.updateLevel(serverId, activityId, roleId, newPosition, newLevel)
+                landData.level = newLevel;
+            }
+
+            //取钱
+            if (landData.record.length > 0) {
+                let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
+                if (records.length < landData.takeOutMax) {
+                    let resource = landData.record[0].resource;
+                    let rewardArray = stringToRewardParam(resource)
+                    bankReward = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+                    let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
+                    landData.record = recordResult.record;
+                }
+            }
+        }
+        await ActivityMonopolyLandModel.updateStopCount(serverId, activityId, roleId, newPosition);
+        return resResult(STATUS.SUCCESS, { landReward, bankReward, landData, moveStep, newPosition, roundIndex: playerData.roundIndex + 1 });
+    }
+
+    /**
+   * @description 存钱
+   * @param {{activityId: number ,addCount: number}} msg
+   * @param {BackendSession} session
+   * @memberof ActivityMonopolyHandler
+   */
+    async bank(msg: { activityId: number, addCount: number }, session: BackendSession) {
+        const { activityId, addCount } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        const sid: string = session.get('sid');
+        const funcs: number[] = session.get('funcs');
+
+        if (addCount > 0) {
+            let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
+            let curPosition = playerData.curPosition;
+            if (curPosition == 0) {
+                return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
+            }
+            let landData = playerData.findMonopolyItem(curPosition);
+            if (landData.landType != LAND_TYPE.BANK_NORMAL
+                && landData.landType != LAND_TYPE.BANK_COIN
+                && landData.landType != LAND_TYPE.BANK_GOLD) {
+                return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
+            }
+            if (landData.record.length != 0) {
+                return resResult(STATUS.MONOPOLY_BANK);
+            }
+            if (addCount > landData.saveMax) {
+                return resResult(STATUS.MONOPOLY_BANK_SAVE_MAX);
+            }
+
+            let resrouseStr = '';
+            if (landData.landType == LAND_TYPE.BANK_COIN
+                || landData.landType == LAND_TYPE.BANK_NORMAL) {
+                resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN)}&${addCount}`
+                //检查资源
+                let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }]);
+                if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
+            } else if (landData.landType == LAND_TYPE.BANK_GOLD) {
+                resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD)}&${addCount}`
+                //检查资源
+                let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }]);
+                if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
+            }
+
+            let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, curPosition, BANK_TYPE.IN, resrouseStr);
+            landData.record = recordResult.record;
+            return resResult(STATUS.SUCCESS, { landData });
+        }
+
+        return resResult(STATUS.MONOPOLY_BANK_COUNT_ERROR);
+
+    }
+
+
+    /**
+    * @description 获取商店数据
+    * @param {{ activityId:number, shopActivityId:number}} msg
+    * @param {BackendSession} session
+    * @memberof RefreshShopHandler
+    */
+    async getRefreshShopActivity(msg: { activityId: number, shopActivityId: number }, session: BackendSession) {
+        const { activityId, shopActivityId } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+
+        let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
+        let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
+        let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, playerLandData.stopCount);
+        if (!playerShopData) {
+            return resResult(STATUS.ACTIVITY_MISSING);
+        }
+        return resResult(STATUS.SUCCESS, { playerShopData });
+    }
+
+
+    /**
+        * @description 购买非RMB商品
+        * @param {{ activityId: number, roundIndex: number, id: number, pageIndex: number}} msg
+        * @param {BackendSession} session
+        * @memberof RefreshShopHandler
+        */
+    async buyGood(msg: { activityId: number, roundIndex: number, id: number, pageIndex: number }, session: BackendSession) {
+        const { activityId, roundIndex, id, pageIndex } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+        const sid = session.get('sid');
+        const roleName = session.get('roleName');
+        const funcs: number[] = session.get('funcs');
+
+        let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
+        let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
+        let playerData = await getPlayerRefreshShopDataByRoundIndex(activityId, serverId, roleId, playerLandData.stopCount);
+        if (!playerData) {
+            return resResult(STATUS.ACTIVITY_MISSING);
+        }
+
+        if (playerData.roundIndex != roundIndex) {
+            return resResult(STATUS.ACTIVITY_EXPIRE);
+        }
+
+        let item = playerData.findItem(id, pageIndex);
+        if (!item) {
+            return resResult(STATUS.ACTIVITY_ID_ERROR);
+        }
+        if (item.countMax > 0 && item.buyCount >= item.countMax) {
+            return resResult(STATUS.ACTIVITY_MAX_COUNT);
+        }
+        if (item.price > 0) {
+            return resResult(STATUS.ACTIVITY_NEED_PAY);
+        }
+
+        //检查资源
+        let consume = stringToConsumeParam(item.consume)
+        let consumeResult = await handleCost(roleId, sid, consume);
+        if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+
+        let rewardArray = stringToRewardParam(item.reward)
+        let result = await addReward(roleId, roleName, sid, serverId, funcs, rewardArray);
+
+        await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id);
+
+        item.buyCount += 1;
+        return resResult(STATUS.SUCCESS, Object.assign(result, {
+            param: { activityId, roundIndex, id },
+            item: item
+        }));
+    }
+}
--- a/game-server/app/servers/activity/handler/dailyCoinHandler.ts
+++ b/game-server/app/servers/activity/handler/dailyCoinHandler.ts
@@ -68,7 +68,6 @@ export class DailyCoinHandler {
        let rateArray = [];//暴击记录
        for (let i = 1; i <= count; i++) {
            let index = curIndex + i;
-            console.log('第几次抽奖', index)
            if (index > playerData.freeCount) {//消耗资源
                let consumeItem: ConsumeExchangeFormulaItem = playerData.findConsumeExchangeFormulaItem(index);
                let times = index;
@@ -79,11 +78,14 @@ export class DailyCoinHandler {
            let rate = playerData.getRate()//翻几倍
            rateArray.push(rate);
            let rewardItem: CoinRewardFormulaItem = playerData.findCoinRewardFormulaItem(index);
+            if (!rewardItem) {
+                return resResult(STATUS.ACTIVITY_DATA_ERROR);
+            }
            let lv = role.lv;//玩家等级
            let coinRewardCount = eval(rewardItem.rewardFormula);

            let baseRewardParamArr: Array<RewardParam> = [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: coinRewardCount, type: ACTIVITY_RESOURCES_TYPE.GOODS }];
-            console.log('基础奖励翻倍', JSON.stringify(baseRewardParamArr), rate)
+            console.log('第几次抽奖:', index, ' 基础奖励翻倍:', rate, JSON.stringify(baseRewardParamArr),)
            for (let reward of baseRewardParamArr) {
                reward.count = reward.count * rate;
            }
--- a/game-server/app/services/activityService.ts
+++ b/game-server/app/services/activityService.ts
@@ -22,6 +22,7 @@ import { getPlayerDailyRMBGiftsData } from './dailyRMBGiftsService';
 import { getPlayerDailyGKData } from './dailyGKService';
 import { getPlayerRefreshShopData } from './refreshShopService';
 import { getPlayerRefreshTaskData } from './refreshTaskService';
+import { getMonopolyActivity, getPlayerMonopolyData } from './monopolyService';

 /**
   * 获取活动数据
@@ -155,6 +156,11 @@ export async function getActivity(serverId: number, roleId: string, activityId:
                activityData = await getPlayerRefreshTaskData(activityId, serverId, roleId);
                break;
            }
+        case ACTIVITY_TYPE.MONOPOLY://大富翁游戏 35
+            {
+                activityData = await getPlayerMonopolyData(activityId, serverId, roleId);
+                break;
+            }
        default: {
            console.log('未知活动类型.........')
            break;
--- a/game-server/app/services/monopolyService.ts
+++ b/game-server/app/services/monopolyService.ts
@@ -0,0 +1,65 @@
+import { ACTIVITY_TYPE } from '../consts';
+import { ActivityModel, ActivityModelType } from '../db/Activity';
+import { ActivityDailyChallengesModel, ActivityDailyChallengesModelType } from '../db/ActivityDailyChallenges';
+import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../db/ActivityMonopoly';
+import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../db/ActivityMonopolyLand';
+import { ServerlistModel } from '../db/Serverlist';
+import { MonopolyData, LandItem } from '../domain/activityField/monopolyField';
+
+
+/**
+   * 获取活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getMonopolyActivity(serverId: number, roleId: string) {
+    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
+    let activityDataArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.MONOPOLY, new Date());
+    if (activityDataArray.length === 0) {
+        return null;
+    }
+    let activityData: ActivityModelType = activityDataArray[0];
+    let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityData.activityId, roleId);
+    let playerLandData: ActivityMonopolyLandModelType[] = await ActivityMonopolyLandModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new MonopolyData(activityData);
+    playerData.setPlayerRecords(playerMonopolyData, playerLandData);
+    return playerData;
+}
+
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerMonopolyData(activityId: number, serverId: number, roleId: string) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    if (!activityData) {
+        return null;
+    }
+    let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityData.activityId, roleId);
+    let playerLandData: ActivityMonopolyLandModelType[] = await ActivityMonopolyLandModel.findData(serverId, activityData.activityId, roleId);
+    let playerData = new MonopolyData(activityData);
+    playerData.setPlayerRecords(playerMonopolyData, playerLandData);
+    return playerData;
+}
+
+/**
+   * 玩家玩家活动数据
+   *
+   * @param {number} position 当前位置
+   * @param {number} addStep 移动步数
+   * @param {number} max 最大位置
+   *
+   */
+export function nextPosition(position: number, addStep: number, max: number) {
+    let temp = (position + addStep) % max;
+    return (temp == 0) ? max : temp;
+}
+
--- a/game-server/app/services/orderService.ts
+++ b/game-server/app/services/orderService.ts
@@ -16,6 +16,9 @@ import { makeGrowthFund } from './growthFundService';
 import { makeLimitPackageReward } from './limitPackageService';
 import { makeShop } from './treasureHuntService';
 import { makeSelfServerShop } from './selfServiceShopActivityService';
+import { makeRefreshShopReward } from './refreshShopService';
+import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../db/ActivityMonopoly';
+import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../db/ActivityMonopolyLand';



@@ -115,6 +118,21 @@ export async function makeOrder(localOrderID: string, sid: string, orderInfo: Us
                rewardResult = await makeSelfServerShop(roleId, roleInfo.roleName, sid, orderInfo.serverId, roleInfo.funcs, orderInfo.activityId, orderInfo.productID)
                break;
            }
+        case ACTIVITY_TYPE.REFRESH_SHOP://通用的刷新商店（分页，可刷新，限制购买次数，支持rmb与资源兑换）
+            {
+                if (orderInfo.paramStr) {//大富翁商店结算
+                    let paramObj = JSON.parse(orderInfo.paramStr);
+                    let activityId = paramObj.activityId;//大富翁活动id；   orderInfo.activityId是大富翁中的商店活动id
+                    let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(orderInfo.serverId, activityId, roleId);
+                    let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(orderInfo.serverId, activityId, roleId, playerMonopolyData.curPosition);
+                    let roundIndex = playerLandData.stopCount;
+                    rewardResult = await makeRefreshShopReward(roleId, roleInfo.roleName, sid, orderInfo.serverId, roleInfo.funcs, orderInfo.activityId, orderInfo.productID, roundIndex)
+
+                } else {//正常商店结算
+                    rewardResult = await makeRefreshShopReward(roleId, roleInfo.roleName, sid, orderInfo.serverId, roleInfo.funcs, orderInfo.activityId, orderInfo.productID, 0)
+                }
+                break;
+            }
        default:
            rewardResult = STATUS.ERROR_TYPE;
            break;
--- a/game-server/app/services/refreshShopService.ts
+++ b/game-server/app/services/refreshShopService.ts
@@ -48,6 +48,23 @@ export async function getPlayerRefreshShopData(activityId: number, serverId: num
    return playerData;
 }

+/**
+   * 玩家商店数据(指定回合数，大富翁商店每回合刷新)
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerRefreshShopDataByRoundIndex(activityId: number, serverId: number, roleId: string, roundIndex: number) {
+    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
+    let playerData = new RefreshShopData(activityData);
+    playerData.roundIndex = roundIndex;
+    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityId, roleId, playerData.roundIndex);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
 /**
   * 玩家活动第几天
   *
@@ -73,10 +90,11 @@ export async function newPlayerActivityDays(roleId: string) {
   * @param {number} activityId 活动Id
   * @param {string} roleId 角色Id
   * @param {string} productID 商品ID
+   * @param {number} roundIndex 大富翁重置回合数
   *
   */
-export async function makeRefreshPackageReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
-    activityId: number, productID: string) {
+export async function makeRefreshShopReward(roleId: string, roleName: string, sid: string, serverId: number, funcs: number[],
+    activityId: number, productID: string, roundIndex: number) {
    let activityData: ActivityModelType = await ActivityModel.findActivity(activityId);
    if (!activityData) {
        return STATUS.ACTIVITY_MISSING;
@@ -85,6 +103,9 @@ export async function makeRefreshPackageReward(roleId: string, roleName: string,
        return STATUS.ACTIVITY_TYPE_ERROR;
    }
    let playerData = new RefreshShopData(activityData);
+    if (roundIndex) {
+        playerData.roundIndex = roundIndex;
+    }

    let playerRecord: ActivityRefreshShopModelType = await ActivityRefreshShopModel.findData(activityData.activityId, roleId, playerData.roundIndex);
    playerData.setPlayerRecords(playerRecord);
--- a/shared/consts/constModules/activityConst.ts
+++ b/shared/consts/constModules/activityConst.ts
@@ -124,6 +124,26 @@ export enum DAILY_MEAL_TYPE {
 }


+/**
+ * 土地类型
+ */
+
+export enum LAND_TYPE {
+    BANK_NORMAL = 1, // 普通土地，银行
+    BANK_COIN = 2, // 铜币银行
+    BANK_GOLD = 3, // 元宝银行
+    SHOP = 4, // 商店
+}
+
+/**
+ * 银行操作
+ */
+
+export enum BANK_TYPE {
+    IN = 1, // 进
+    OUT = 2, // 出
+}
+
 //服务器开服时间
 export const SERVER_OPEN_TIME = '2021-06-06T20:03:16.637+08:00';
 //玩家等级大于等于15级才能开启vip签到
--- a/shared/consts/statusCode.ts
+++ b/shared/consts/statusCode.ts
@@ -363,6 +363,10 @@ export const STATUS = {
    ACTIVITY_NEW_PLAYER_GIFT_END: { code: 50026, simStr: '新手活动结束' },
    ACTIVITY_POP_UP_SHOP_CLOSED: { code: 50027, simStr: '商店已经关闭' },
    ACTIVITY_PRE_UNCOMPLETE: { code: 50028, simStr: '上一个任务还未领取' },
+    MONOPOLY_LAND_TYPE_ERROR: { code: 50029, simStr: '土地类型错误' },
+    MONOPOLY_BANK: { code: 50030, simStr: '已经存过' },
+    MONOPOLY_BANK_COUNT_ERROR: { code: 50031, simStr: '数量错误' },
+    MONOPOLY_BANK_SAVE_MAX: { code: 50032, simStr: '超过最大限制数量' },
    // GM后台相关状态 60000 - 69999
    GM_ERR_PASSWORD: { code: 60001, simStr: '账号或密码错误' },
    GM_MISS_API: { code: 60002, simStr: '未找到该接口' },
--- a/shared/db/ActivityMonopoly.ts
+++ b/shared/db/ActivityMonopoly.ts
@@ -0,0 +1,47 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+
+
+
+/**
+  * 活动系统 - 大富翁
+*/
+@index({ roleId: 1 })
+
+export default class Activity_Monopoly extends BaseModel {
+    @prop({ required: true })
+    serverId: number;				// 服Id
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+    @prop({ required: true, default: 0 })
+    starPosition: number;			// 初始位置
+    @prop({ required: true })
+    curPosition: number;			// 当前位置
+    @prop({ required: true, default: 1 })
+    roundIndex: number;			    // 回合数
+
+    //更新坐标
+    public static async updatePosition(serverId: number, activityId: number, roleId: string, curPosition: number, roundIndex: number) {
+        let result: ActivityMonopolyModelType = await ActivityMonopolyModel.findOneAndUpdate({ serverId, roleId, activityId },
+            { $set: { curPosition }, $inc: { roundIndex } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+    //查询数据
+    public static async findData(serverId: number, activityId: number, roleId: string) {
+        let result: ActivityMonopolyModelType = await ActivityMonopolyModel.findOne({ serverId, roleId, activityId }).lean(true);
+        return result;
+    }
+
+    //删除活动记录
+    public static async deleteActivity(serverId: number, activityId: number, roleId: string) {
+        await ActivityMonopolyModel.deleteMany({ serverId, roleId, activityId });
+    }
+}
+
+export const ActivityMonopolyModel = getModelForClass(Activity_Monopoly);
+
+export interface ActivityMonopolyModelType extends Pick<DocumentType<Activity_Monopoly>, keyof Activity_Monopoly> { }
+export type ActivityMonopolyModelTypeParam = Partial<ActivityMonopolyModelType>; // 将所有字段变成可选项
--- a/shared/db/ActivityMonopolyLand.ts
+++ b/shared/db/ActivityMonopolyLand.ts
@@ -0,0 +1,90 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+
+
+/**
+  * 记录
+*/
+
+export class Record {
+    @prop({ required: true })
+    resource: string; //类型&资源id&数量
+    @prop({ required: true })
+    type: number; //1,存入，2取出
+    @prop({ required: true })
+    time: Date; //购买时间
+}
+
+
+
+/**
+  * 活动系统 - 大富翁
+*/
+@index({ roleId: 1 })
+
+export default class Activity_Monopoly_Land extends BaseModel {
+    @prop({ required: true })
+    serverId: number;				// 服Id
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+    @prop({ required: true })
+    position: number;			    // 位置
+    @prop({ required: true, default: 1 })
+    level: number;			        // 等级
+    @prop({ required: true, default: [] })
+    record: Record[];			    // 记录
+    @prop({ required: true })
+    stopCount: number;			// 停留次数
+
+
+    //更新等级
+    public static async updateLevel(serverId: number, activityId: number, roleId: string, position: number, level: number) {
+        let result: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findOneAndUpdate({
+            serverId, roleId, activityId, position
+        },
+            { $set: { level } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+    //更新停留次数
+    public static async updateStopCount(serverId: number, activityId: number, roleId: string, position: number) {
+        let result: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findOneAndUpdate({
+            serverId, roleId, activityId, position
+        },
+            { $inc: { stopCount: 1 } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+    //添加记录
+    public static async addRecord(serverId: number, activityId: number, roleId: string, position: number, type: number, resource: string) {
+        let result: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findOneAndUpdate({
+            serverId, roleId, activityId, position
+        },
+            { $push: { record: { resource, type, time: new Date() } } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+    //查询数据
+    public static async findData(serverId: number, activityId: number, roleId: string) {
+        let result: ActivityMonopolyLandModelType[] = await ActivityMonopolyLandModel.find({ serverId, roleId, activityId }).lean(true);
+        return result;
+    }
+
+    //查询数据
+    public static async findDataByPosition(serverId: number, activityId: number, roleId: string, position: number) {
+        let result: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findOne({ serverId, roleId, activityId, position }).lean(true);
+        return result;
+    }
+
+    //删除活动记录
+    public static async deleteActivity(serverId: number, activityId: number, roleId: string) {
+        await ActivityMonopolyLandModel.deleteMany({ serverId, roleId, activityId });
+    }
+}
+
+export const ActivityMonopolyLandModel = getModelForClass(Activity_Monopoly_Land);
+
+export interface ActivityMonopolyLandModelType extends Pick<DocumentType<Activity_Monopoly_Land>, keyof Activity_Monopoly_Land> { }
+export type ActivityMonopolyLandModelTypeParam = Partial<ActivityMonopolyLandModelType>; // 将所有字段变成可选项
--- a/shared/domain/activityField/dailyGKField.ts
+++ b/shared/domain/activityField/dailyGKField.ts
@@ -13,6 +13,7 @@ export class DailyGKItem {

    constructor(data: any) {
        this.dayIndex = data.dayIndex;
+        this.gk = data.gk;
        this.name = data.name;
        this.reward = data.reward;
        this.isSuccess = false;
--- a/shared/domain/activityField/monopolyField.ts
+++ b/shared/domain/activityField/monopolyField.ts
@@ -0,0 +1,73 @@
+import { ActivityModelType } from '../../db/Activity';
+import { ActivityMonopolyModelType } from '../../db/ActivityMonopoly';
+import { ActivityMonopolyLandModelType } from '../../db/ActivityMonopolyLand';
+import { ActivityBase } from './activityField';
+
+
+// 地块数据
+export class LandItem {
+    position: number;       // 位置
+    name: string;             // 名字
+    level: number;           // 等级
+    rewards: string[];         // 奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
+    landType: number          //土地性质  LAND_TYPE
+    saveMax: number           //银行存钱最大数额
+    takeOutMax: number        //银行取钱最大次数
+    shopActivityId: number     //商店对应的商店id
+
+    record: any[] = [];     //历史操作
+    stopCount: number        //停留次数
+
+    constructor(data: any) {
+        this.position = data.position;
+        this.name = data.name;
+        this.level = data.level;
+        this.rewards = data.rewards;
+        this.landType = data.landType;
+        this.saveMax = data.saveMax;
+        this.takeOutMax = data.takeOutMax;
+        this.shopActivityId = data.shopActivityId;
+        this.record = [];
+        this.stopCount = 0;
+    }
+}
+
+
+// 活动数据
+export class MonopolyData extends ActivityBase {
+    curPosition: number;			// 当前位置
+    roundIndex: number;			    // 回合数
+    list: Array<LandItem> = [];
+
+    public findMonopolyItem(position: number) {
+        let index = this.list.findIndex(obj => { return obj && obj.position == position })
+        return (index != -1) ? this.list[index] : null;
+    }
+
+    //解析玩家领取记录
+    public setPlayerRecords(data: ActivityMonopolyModelType, landDataArray: ActivityMonopolyLandModelType[]) {
+        this.curPosition = (data && data.curPosition) ? data.curPosition : 0;
+        this.roundIndex = (data && data.roundIndex) ? data.roundIndex : 0;
+
+        for (let landData of landDataArray) {
+            let index = this.list.findIndex(item => { return item.position == landData.position })
+            if (index != -1) {
+                this.list[index].level = landData.level;
+                this.list[index].record = landData.record ? landData.record : [];
+                this.list[index].stopCount = landData.stopCount ? landData.stopCount : 0;
+            }
+        }
+    }
+
+    public initData(data: string) {
+        let arr = JSON.parse(data);
+        for (let obj of arr) {
+            this.list.push(new LandItem(obj))
+        }
+    }
+
+    constructor(activityData: ActivityModelType) {
+        super(activityData)
+        this.initData(activityData.data)
+    }
+}
--- a/shared/domain/activityField/refreshShopField.ts
+++ b/shared/domain/activityField/refreshShopField.ts
@@ -51,6 +51,7 @@ export class RefreshShopPage {

 // 商店数据
 export class RefreshShopData extends ActivityBase {
+    shopType: number = 0;//商店类型，用于客户端显示使用
    name: string = '';//活动名称
    interval: number = 0;//周期间隔（秒）
    list: Array<RefreshShopPage> = [];//商品列表
@@ -96,6 +97,7 @@ export class RefreshShopData extends ActivityBase {
    public initData(data: string) {
        this.nextRefreshTime = this.endTime;
        let dataObj = JSON.parse(data);
+        this.shopType = dataObj.shopType;
        this.name = dataObj.name;
        this.interval = dataObj.interval;