活动：大富翁

2021-06-18 19:45:55 +08:00
parent 15ff0938bc
commit b4578f053a
13 changed files with 593 additions and 4 deletions
@@ -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
+        }));
+    }
+}
@@ -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;
            }
@@ -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;
@@ -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;
+}
+
@@ -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;
@@ -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);