活动：每日充值

game-server/app/servers/activity/handler/luckyTurntableHandler.ts

@@ -89,7 +89,7 @@ export class LuckyTurntableHandler {
         if(!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
 
         let box = playerData.findBox(boxCount);
-        let rewardArray = stringToRewardParam(box.reward)
+        let rewardArray = stringToRewardParam(box.rewards)
         let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
         await ActivityTurntableModel.receiveBox(serverId, activityId, roleId, boxCount);
 

game-server/app/servers/activity/handler/rechargeMoneyHandler.ts

@@ -1,11 +1,12 @@
 import { Application, BackendSession, HandlerService, } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
 import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
-import { getPlayerRechargeMoneyData } from '../../../services/activity/rechargeMoneyService';
+import { getPlayerRechargeMoneyData, getPlayerRechargeMoneyDataShow } from '../../../services/activity/rechargeMoneyService';
-import { RechargeMoneyItem } from '../../../domain/activityField/rechargeMoneyField';
+import { RechargeMoneyPool } from '../../../domain/activityField/rechargeMoneyField';
 import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
 import { RewardParam } from '../../../domain/activityField/rewardField';
 import { ActivityRechargeMoneyModel } from '../../../db/ActivityRechargeMoney';
+import { addItems } from '../../../services/rewardService';
 
 
 export default function (app: Application) {
@@ -29,9 +30,8 @@ export class RechargeMoneyHandler {
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
 
-        let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
+        let playerData = await getPlayerRechargeMoneyDataShow(activityId, serverId, roleId);
         if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
-        delete playerData.recordArray;
 
         return resResult(STATUS.SUCCESS, playerData);
     }
@@ -41,7 +41,7 @@ export class RechargeMoneyHandler {
    * @param {BackendSession} session
    * @memberof RechargeMoneyHandler
    */
-    async getRechargeMoneyReward(msg: { activityId: number }, session: BackendSession) {
+    async pull(msg: { activityId: number }, session: BackendSession) {
         const { activityId } = msg;
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
@@ -52,30 +52,26 @@ export class RechargeMoneyHandler {
         let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
         if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
 
-        if (playerData.totalCount <= playerData.receiveCount) {
+        if (playerData.ticketCnt <= 0) {
-            return resResult(STATUS.ACTIVITY_RECHARGE_MONEY_NO_REWARD);
+            return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
         }
 
-        let item: RechargeMoneyItem = playerData.randomReward();
+        let item = playerData.pull();
         if (!item) {
-            return resResult(STATUS.ACTIVITY_RECHARGE_MONEY_ERROR);
+            return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
         }
 
-        let recordArray = playerData.recordArray.filter(obj => { return obj && !obj.rewardTime })
+        let notGetRecord = playerData.recordArr[0];
-        let rechargeItem = recordArray[0];
+        console.log('notGetRecord', JSON.stringify(notGetRecord));
-        // console.log('recordArray', JSON.stringify(recordArray));
+        await ActivityRechargeMoneyModel.addRecord(notGetRecord._id, item.id, `${item.gid}&${item.count}`);
-        await ActivityRechargeMoneyModel.addRecord(rechargeItem._id, item.id, item.reward)
+        let goods = await addItems(roleId, roleName, sid, [{ id: item.gid, count: item.count }], ITEM_CHANGE_REASON.RECHARGE_REWARD)
-        let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
-        let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.RECHARGE_REWARD)
-        if (playerData.isLast()) {
-            let _ids = playerData.recordArray.map(a => a._id)
-            await ActivityRechargeMoneyModel.setEndState(serverId, roleId, _ids);
-        }
 
-        item.rewardTime = new Date();
+        item.setHasGet(true);
-        return resResult(STATUS.SUCCESS, Object.assign(result, {
+
+        return resResult(STATUS.SUCCESS, {
+            goods,
             param: { activityId },
             item: item
-        }));
+        });
     }
 }

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

@@ -5,7 +5,7 @@ import { getPlayerGrowthFundData, } from './growthFundService';
 import { getPlayerLimitPackageData, } from './limitPackageService';
 import { getPlayerYuanbaoShopData, } from './yuanbaoService';
 import { getPlayerMonthlyTicketData, } from './monthlyTicketService';
-import { getPlayerRechargeMoneyData, } from './rechargeMoneyService';
+import { getPlayerRechargeMoneyDataShow, } from './rechargeMoneyService';
 import { getPlayerThirtyDaysData, playerThirtyDaysActivityDays, } from './thirtyDaysService';
 import { getPlayerVipRechargeMoneyData, } from './vipRechargeMoneyService';
 import { getPlayerActivityData, } from './selfServiceShopActivityService';
@@ -106,7 +106,7 @@ export async function getActivity(serverId: number, roleId: string, activityId:
             }
         case ACTIVITY_TYPE.RECHARGE_MONEY://累计充值RMB活动 21
             {
-                activityData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
+                activityData = await getPlayerRechargeMoneyDataShow(activityId, serverId, roleId);
                 break;
             }
         case ACTIVITY_TYPE.DAILY_RMB_GIFTS://每日特惠RMB购买，一次性购买7天礼包 22

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

@@ -1,41 +1,9 @@
-import { ACTIVITY_TYPE } from '../../consts';
-import { ActivityModel, ActivityModelType } from '../../db/Activity';
 import { ActivityRechargeMoneyModel, ActivityRechargeMoneyModelType } from '../../db/ActivityRechargeMoney';
 import { RechargeMoneyData } from '../../domain/activityField/rechargeMoneyField';
 import moment = require('moment');
-import { ServerlistModel } from '../../db/Serverlist';
 import { RoleModel } from '../../db/Role';
 import { getActivityById } from './activityService';
 
-/**
-   * 获取活动数据
-   *
-   * @param {number} serverId 区Id
-   * @param {number} type 活动类型 ACTIVITY_TYPE
-   * @param {string} roleId 角色Id
-   *
-   */
-
-export async function rechargeMoneyActivity(serverId: number, roleId: string) {
-    let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
-    let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.RECHARGE_MONEY, new Date())
-
-    let activityData = activityArray[0];
-    let playerRecord: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.findData(serverId, roleId);
-    let { createTime } = await RoleModel.findByRoleId(roleId);
-    let playerData = new RechargeMoneyData(activityData, createTime);
-    playerData.setPlayerRecords(playerRecord);
-    delete playerData.recordArray;
-    return playerData;
-
-    // let playerDataArray = [];
-    // for (let activityData of activityArray) {
-    //     let playerData = await getPlayerRechargeMoneyData(activityData.activityId, serverId, roleId);
-    //     playerDataArray.push(playerData)
-    // }
-    // return playerDataArray
-}
-
 /**
    * 玩家活动数据
    *
@@ -46,15 +14,23 @@ export async function rechargeMoneyActivity(serverId: number, roleId: string) {
    */
 export async function getPlayerRechargeMoneyData(activityId: number, serverId: number, roleId: string) {
     let activityData = await getActivityById(activityId);
-    let playerRecord: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.findData(serverId, roleId);
-
     let { createTime } = await RoleModel.findByRoleId(roleId);
     let playerData = new RechargeMoneyData(activityData, createTime);
+    let beginTime = moment(playerData.beginTime).startOf('d').toDate();
+    let endTime = moment(new Date()).endOf('d').toDate();
+    let playerRecord: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.findDataByTime(serverId, roleId, beginTime, endTime);
+
     playerData.setPlayerRecords(playerRecord);
     return playerData;
 }
 
-
+export async function getPlayerRechargeMoneyDataShow(activityId: number, serverId: number, roleId: string) {
+    let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
+    if(playerData && playerData.canShow && playerData.canShow()) {
+        return playerData.getShowResult();
+    }
+    return null
+}
 
 /**
    * 统计充值金额

shared/consts/statusCode.ts

@@ -431,7 +431,7 @@ export const STATUS = {
     ACTIVITY_FIRST_GIFT_END: { code: 50016, simStr: '首充结束' },
     ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END: { code: 50017, simStr: '新手礼包结束' },
     ACTIVITY_RECHARGE_MONEY_ERROR: { code: 50018, simStr: '充值数据错误' },
-    ACTIVITY_RECHARGE_MONEY_NO_REWARD: { code: 50019, simStr: '没有可领取的奖励' },
+    ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH: { code: 50019, simStr: '签数不足' },
     ACTIVITY_SIGNIN_VIP_CONDITION: { code: 50020, simStr: '开启条件不足' },
     ACTIVITY_SIGNIN_EXPIRE: { code: 50021, simStr: '签到过期，补签' },
     ACTIVITY_POP_UP_SHOP_EXPIRE: { code: 50022, simStr: '弹出商店过期' },
@@ -447,6 +447,7 @@ export const STATUS = {
     MONOPOLY_BANK_SAVE_MAX: { code: 50032, simStr: '超过最大限制数量' },
     NOT_GIFTPACKAGE: { code: 50033, simStr: '非礼包类型' },
     SHOP_CLOSED: { code: 50034, simStr: '停业' },
+    ACTIVITY_RECHARGE_ITEM_NOT_ENOUGH: { code: 50035, simStr: '商品不足' },
     // GM后台相关状态 60000 - 69999
     GM_ERR_PASSWORD: { code: 60001, simStr: '账号或密码错误' },
     GM_MISS_API: { code: 60002, simStr: '未找到该接口' },

shared/db/ActivityRechargeMoney.ts

@@ -19,31 +19,24 @@ export default class Activity_Recharge_Money extends BaseModel {
     @prop({ required: true })
     RMB: number;			// 充值金额
     @prop({ required: true })
-    index: number;		    // 第几个格子
+    poolId: number;		    // 奖池唯一id
     @prop({ required: true })
     reward: string;		    // 领取奖励内容
     @prop({ required: true })
     rewardTime: Date;		    // 领取奖励时间
-    @prop({ required: true })
-    isEnd: boolean;		    // 结束
 
     //添加领取记录
-    public static async addRecord(_id: string, id: number, reward: string) {
+    public static async addRecord(_id: string, poolId: number, reward: string) {
+        console.log(_id, poolId, reward)
         let result: ActivityRechargeMoneyModelType = await ActivityRechargeMoneyModel.findOneAndUpdate({ _id },
-            { $set: { index: id, reward, rewardTime: new Date() } },
+            { $set: { poolId, reward, rewardTime: new Date() } },
             { upsert: true, new: true }).lean(true);
         return result;
     }
 
-    //本轮结束
-    public static async setEndState(serverId: number, roleId: string, _ids: string[]) {
-        await ActivityRechargeMoneyModel.updateMany({ serverId, roleId, _id: { $in: _ids } },
-            { $set: { isEnd: true } }, { multi: true, });
-    }
-
     //查询
-    public static async findData(serverId: number, roleId: string) {
+    public static async findDataByTime(serverId: number, roleId: string, beginTime: Date, endTime: Date) {
-        let result: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.find({ serverId, roleId, isEnd: { $ne: true } }).lean(true);
+        let result: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.find({ serverId, roleId, beginTime: { $gte: beginTime }, endTime: { $lte: endTime } }).sort({ beginTime: 1 }).lean(true);
         return result;
     }
 

shared/domain/activityField/luckyTurntableField.ts

@@ -21,7 +21,7 @@ interface TurntableFloorInDb { // 保底，每sum次必出count个头奖，头
 
 interface TurntableBoxInDb {
     count: number;       // 次数
-    reward: string;      // 奖励 type&id&count
+    rewards: string;      // 奖励 type&id&count
 }
 
 interface TurntableInDb {
@@ -54,13 +54,13 @@ export class LuckyTurntablePool {
 
 export class LuckyTurntableBox {
     count: number;       // 次数
-    reward: string;      // 奖励
+    rewards: string;      // 奖励
 
     isReceived: boolean = false; // 是否已领取
 
     constructor(data: TurntableBoxInDb) {
         this.count = data.count;
-        this.reward = data.reward;
+        this.rewards = data.rewards;
     }
     
     public setReceived(box: number[] = []) {

shared/domain/activityField/rechargeMoneyField.ts

@@ -2,86 +2,160 @@ import moment = require('moment');
 import { random } from 'underscore';
 import { ActivityModelType } from '../../db/Activity';
 import { ActivityRechargeMoneyModelType } from '../../db/ActivityRechargeMoney';
+import { getRandEelmWithWeight, getRandSingleEelm } from '../../pubUtils/util';
 import { ActivityBase } from './activityField';
 
+interface RechargeMoneyPoolInDb {
+    id: number;      // 奖池项唯一id
+    gid: number;
+    count: number;
+    quality: number; // 物品的品级，相同的品级平分概率，不同品级直接按percent来做概率
+}
+
+interface RechargeMoneyWeightInDb {
+    quality: number;  // pool中的品级
+    weight: number;   // 权重，先随机出这个品级的物品的概率，然后再平均随机出这个品级下的物品
+}
+
+interface RechargeMoneyPercentInDb {
+    todayIndex: number;  // 第几天，和前面排名奖励的填法一样，如第1天、第2-10天，只需填todayIndex=1和10的两项
+    data: RechargeMoneyWeightInDb[];  // 这一天的权重
+}
+
+interface RechargeMoneyInDb {
+    pool: RechargeMoneyPoolInDb[];
+    minPrice: number;
+    percent: RechargeMoneyPercentInDb[];
+}
+
 // 充值记录
-export class RechargeMoneyItem {
+export class RechargeMoneyPool {
-    _id: string;      //mongodb 
+    id: number;       // 卡池id
-    id: number;       //商品id
+    gid: number;
-    name: string;      //商品名称
+    count: number;
-    reward: string;   //奖励
+    quality: number;  // 物品的品级
 
-    rewardTime: Date; //领奖时间
+    hasGet: boolean = false; // 是否已经获取过了
 
-    constructor(data: any) {
+    constructor(data: RechargeMoneyPoolInDb) {
         this.id = data.id;
-        this.name = data.name;
+        this.gid = data.gid;
-        this.reward = data.reward;
+        this.count = data.count;
-        this.rewardTime = null;
+        this.quality = data.quality;
+    }
+
+    setHasGet(hasGet: boolean) {
+        this.hasGet = hasGet;
+    }
+}
+
+export class RechargeMoneyWeight {
+    quality: number;
+    weight: number;
+
+    constructor(data: RechargeMoneyWeightInDb) {
+        this.quality = data.quality;
+        this.weight = data.weight;
+    }
+}
+export class RechargeMoneyPercent {
+    todayIndex: number;
+    data: RechargeMoneyWeight[] = [];
+
+    constructor(data: RechargeMoneyPercentInDb) {
+        this.todayIndex = data.todayIndex;
+        for(let obj of data.data) {
+            this.data.push(new RechargeMoneyWeight(obj));
+        }
     }
 }
 
 // 累计充值数据
 export class RechargeMoneyData extends ActivityBase {
-    list: Array<RechargeMoneyItem> = [];//记录
+    private map: Map<number, number> = new Map(); // poolId => index
-    days: number = 0;
+    private percentMap: Map<number, number> = new Map(); // todayIndex => 的index
-    price: number = 0;
+    pool: RechargeMoneyPool[] = [];
+    minPrice: number = 0;
+    percent: RechargeMoneyPercent[] = [];
 
-    totalCount: number = 0;//一共可领取次数
+    ticketCnt: number = 0;         // 签数
-    receiveCount: number = 0;//已经领取次数
+    recordArr: ActivityRechargeMoneyModelType[] = [];
 
-    recordArray: ActivityRechargeMoneyModelType[] = [];
+    private findItemFromPool(poolId: number) {
-
+        let index = this.map.get(poolId);
-    //当前回合最后一个
+        return this.pool[index];
-    public isLast() {
-        let items = this.list.filter(obj => { return obj && !obj.rewardTime });
-        return items.length === 1;
     }
 
-    public randomReward(): RechargeMoneyItem {
+    private findTodayPercent() {
-        let items = this.list.filter(obj => { return obj && (!obj.rewardTime || obj.rewardTime == undefined) })
+        let index = this.percentMap.get(this.todayIndex);
-        if (items.length == 0) {
+        return this.percent[index];
-            return null;
+    }
+
+    public pull() {
+        let percent = this.findTodayPercent();
+        if(!percent) return false;
+        let randPercent = percent.data.filter(cur => {
+            let hasAllGet = true;
+            for(let { quality, hasGet } of this.pool) {
+                if(quality == cur.quality && !hasGet) hasAllGet = false;
+            }
+            return !hasAllGet;
+        });
+        if(randPercent.length <=0) return false; // 全部抽完了
+
+        let qualityResult = getRandEelmWithWeight(randPercent);
+        if(!qualityResult) return false;
+
+        let elems: RechargeMoneyPool[] = [];
+        for(let pool of this.pool) {
+            if(pool && !pool.hasGet && pool.quality == qualityResult.dic.quality) {
+                elems.push(pool);
+            }
         }
-        let index = random(items.length - 1);
+        let result = getRandSingleEelm(elems);
-        return items[index];
+        return result;
     }
 
     //解析玩家购买记录
     public setPlayerRecords(data: ActivityRechargeMoneyModelType[]) {
-        this.todayIndex = 0;
+        if (!data) return;
-        if (!data) {
-            return;
-        }
-        this.recordArray = data.filter(obj => {
-            return obj.RMB >= this.price;
-        }).sort((a, b) => {
-            return moment(a.beginTime).valueOf() - moment(b.beginTime).valueOf()
-        })
 
-        this.totalCount = this.recordArray.length;
+        for(let record of data) {
-        this.receiveCount = 0;
+            if(record.RMB >= this.minPrice) {
-        for (let item of this.list) {
+                if(!record.rewardTime) {
-            let index = this.recordArray.findIndex(obj => { return obj.index === item.id })
+                    this.ticketCnt++;
-            if (index != -1) {
+                    this.recordArr.push(record);
-                this.receiveCount++;
+                }
-                item.rewardTime = this.recordArray[index].rewardTime;
+            } 
+            if(record.poolId) {
+                let pool = this.findItemFromPool(record.poolId);
+                if(pool) pool.setHasGet(true);
             }
         }
     }
 
-    public initData(data: string) {
+    public getShowResult() {
-        let dataObj = JSON.parse(data);
+        return {
-        this.days = dataObj.days;
+            ...this.getBaseKeys(),
-        this.price = dataObj.price;
+            ticketCnt: this.ticketCnt,
-
+            pool: this.pool,
-        let arr = dataObj.data;
+        }
-        for (let obj of arr) {
+    }
-            this.list.push(new RechargeMoneyItem(obj))
+
+    public initData(data: string) {
+        let dataObj: RechargeMoneyInDb = JSON.parse(data);
+        console.log(dataObj);
+        for(let pool of dataObj.pool) {
+            let obj = new RechargeMoneyPool(pool);
+            this.pool.push(obj);
+            this.map.set(obj.id, this.pool.length - 1);
+        }
+        this.minPrice = dataObj.minPrice;
+        for(let percent of dataObj.percent) {
+            let obj = new RechargeMoneyPercent(percent);
+            this.percent.push(obj);
+            this.percentMap.set(obj.todayIndex, this.percent.length - 1);
         }
-        this.list = this.list.sort((a, b) => {
-            return a.id - b.id
-        })
     }
 
     constructor(activityData: ActivityModelType, createTime: number) {