✨ feat(节日活动): 添加划龙舟活动

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

@@ -0,0 +1,133 @@
+import { Application, BackendSession, HandlerService, } from 'pinus';
+import { resResult } from '../../../pubUtils/util';
+import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
+import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
+import { getPlayerDragonBoatData, getPlayerDragonBoatDataShow } from '../../../services/activity/dragonBoatService';
+import { ActivityDragonBoatModel } from '../../../db/ActivityDragonBoat';
+import { handleCost } from '../../../services/role/rewardService';
+
+export default function (app: Application) {
+    new HandlerService(app, {});
+    return new DragonBoatHandler(app);
+}
+
+export class DragonBoatHandler {
+    constructor(private app: Application) {
+    }
+
+    /**
+    * @description 获取火神祭祀活动数据
+    * @param {{ activityId: number}} msg
+    * @param {BackendSession} session
+    * @memberof DragonBoatHandler
+    */
+    async getDragonBoatActivity(msg: { activityId: number }, session: BackendSession) {
+        const { activityId } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerDragonBoatDataShow(activityId, serverId, roleId);
+
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        return resResult(STATUS.SUCCESS, playerData);
+    }
+
+    /**
+    * @description 挑战开始
+    * @param {{ activityId: number, id: number}} msg
+    * @param {BackendSession} session
+    * @memberof DragonBoatHandler
+    */
+    async gameStart(msg: { activityId: number, id: number }, session: BackendSession) {
+        const { activityId, id } = msg;
+        const roleId = session.get('roleId');
+        const roleName = session.get('roleName');
+        const sid = session.get('sid');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+        // 挑战次数
+        if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_COUNT_OVER);
+
+        let route = playerData.findRoute(id);
+        if(!route) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND);
+        if(route.hasPass) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_HAS_PASS);
+        if(route.preId) {
+            let preRoute = playerData.findRoute(route.preId);
+            if(!preRoute || !preRoute.hasPass) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_PRE_NOT_PASS);
+        } 
+        let rewards = stringToRewardParam(route.reward);
+        let playerRecord = await ActivityDragonBoatModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex: playerData.todayIndex, id, time: new Date(), rewards })
+        playerData.setPlayerRecords(playerRecord);
+
+        await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_DRAGON_BOAT);
+        return resResult(STATUS.SUCCESS, { 
+            activityId,
+            todayPlayCnt: playerData.todayPlayCnt,
+            playCnt: playerData.playCnt,
+            route: playerData.findRoute(id)?.getShowResult()
+        });
+    }
+
+    /**
+    * @description 挑战结束
+    * @param {{ activityId: number, id: number, count: number}} msg
+    * @param {BackendSession} session
+    * @memberof DragonBoatHandler
+    */
+    async gameEnd(msg: { activityId: number, id: number }, session: BackendSession) {
+        const { activityId, id } = msg;
+        const roleId = session.get('roleId');
+        const serverId = session.get('serverId');
+
+        let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        let route = playerData.findRoute(id);
+        if(!route) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND);
+
+        return resResult(STATUS.SUCCESS, { 
+            activityId,
+            todayPlayCnt: playerData.todayPlayCnt,
+            playCnt: playerData.playCnt,
+            route: route.getShowResult(), 
+            goods: route.resultReward
+        });
+    }
+
+    /**
+    * @description 购买次数
+    * @param {{ activityId: number, id: number, count: number}} msg
+    * @param {BackendSession} session
+    * @memberof DragonBoatHandler
+    */
+    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 getPlayerDragonBoatData(activityId, serverId, roleId);
+        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
+
+        // 可购买次数
+        if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_BUY_COUNT_OVER);
+        if(playerData.todayPlayCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_CANNOT_BUY);
+        // 扣材料
+        let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_DRAGON_BOAT_BUY_COST);
+        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+
+        // 保存数据
+        let buildResult = await ActivityDragonBoatModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
+        // 更新数据
+        playerData.setPlayerRecords(buildResult);
+
+        return resResult(STATUS.SUCCESS, { 
+            activityId,
+            maxBuyCnt: playerData.maxBuyCnt,
+            buyCnt: playerData.buyCnt
+         });
+    }
+}

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

@@ -47,6 +47,7 @@ import { getWeeklyFundDataShow } from './weeklyFundService';
 import { getMonthlyFundData } from './monthlyFundService';
 import { getPlayerRebateDataShow } from './rebateService';
 import { getWebviewDataShow } from './webviewService';
+import { getPlayerDragonBoatDataShow } from './dragonBoatService';
 
 /**
    * 获取活动数据
@@ -268,6 +269,11 @@ export async function getActivity(serverId: number, roleId: string, uid: number,
                 activityData = await getWebviewDataShow(activityId, serverId, roleId);
                 break
             }
+        case ACTIVITY_TYPE.DRAGON_BOAT:
+            {
+                activityData = await getPlayerDragonBoatDataShow(activityId, serverId, roleId);
+                break
+            }
         default: {
             console.log('未知活动类型.........', activityType)
             break;

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

@@ -0,0 +1,38 @@
+import { ActivityDragonBoatModel } from "../../db/ActivityDragonBoat";
+import { DragonBoatData } from "../../domain/activityField/dragonBoatField";
+import { getRoleCreateTime, getServerCreateTime } from "../redisService";
+import { getActivityById } from "./activityService";
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDragonBoatData(activityId: number, serverId: number, roleId: string) {
+    let activityData = await getActivityById(activityId);
+    let createTime = await getRoleCreateTime(roleId);
+    let serverTime = await getServerCreateTime(serverId);
+    let playerData = new DragonBoatData(activityData, createTime, serverTime);
+    let playerRecord = await ActivityDragonBoatModel.findData(serverId, activityId, playerData.roundIndex, roleId);
+    playerData.setPlayerRecords(playerRecord);
+    return playerData;
+}
+
+/**
+   * 玩家活动数据
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function getPlayerDragonBoatDataShow(activityId: number, serverId: number, roleId: string) {
+    let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
+    if(playerData && playerData.canShow && playerData.canShow()) {
+        return playerData.getShowResult();
+    }
+    return null
+}

shared/consts/constModules/activityConst.ts

@@ -67,6 +67,7 @@ export enum ACTIVITY_TYPE {
     MONTHLY_FUND = 52,   // 月基金
     REBATE = 53,         // 返利
     WEBVIEW = 54,        // 平台活动页面
+    DRAGON_BOAT = 55,        // 龙舟
 }
 
 /**

shared/consts/constModules/sysConst.ts

@@ -1161,6 +1161,8 @@ export enum ITEM_CHANGE_REASON {
     ACT_MONTHLY_FUND_BUY = 183,               // 月基金一次性购买
     ACT_MONTHLY_FUND_SIGN = 184,              // 月基金签到
     RECEIVE_REBATE = 185,                    // 领取返利
+    ACT_DRAGON_BOAT = 186,                    // 龙舟奖励
+    ACT_DRAGON_BOAT_BUY_COST = 187,           // 购买龙舟挑战奖励
 }
 
 export enum TA_EVENT {

shared/consts/statusCode.ts

@@ -672,11 +672,17 @@ export const STATUS = {
     ACTIVITY_MONTHLY_FUND_NOT_BOUGHT: { code: 50060, simStr: '月基金未购买' },
     ACTIVITY_MONTHLY_FUND_NOT_FOUND: { code: 50061, simStr: '未找到该配置' },
     ACTIVITY_MONTHLY_FUND_LOCK: { code: 50062, simStr: '本次签到暂未解锁' },
-    ACTIVITY_MONTHLY_FUND_HAS_SIGN: { code: 60063, simStr: '本次签到奖励已领取' },
+    ACTIVITY_MONTHLY_FUND_HAS_SIGN: { code: 50063, simStr: '本次签到奖励已领取' },
-    ACTIVITY_PUBLIC_ACCOUNT_WAIT: { code: 60064, simStr: '请在公众号输入口令' },
+    ACTIVITY_PUBLIC_ACCOUNT_WAIT: { code: 50064, simStr: '请在公众号输入口令' },
-    ACTIVITY_PUBLIC_ACCOUNT_RECEIVED: { code: 60065, simStr: '已领取' },
+    ACTIVITY_PUBLIC_ACCOUNT_RECEIVED: { code: 50065, simStr: '已领取' },
-    ACTIVITY_REBATE_DAY_NOT_REACH: { code: 60066, simStr: '暂不可领取' },
+    ACTIVITY_REBATE_DAY_NOT_REACH: { code: 50066, simStr: '暂不可领取' },
-    ACTIVITY_REBATE_HAS_RECEIVED: { code: 60067, simStr: '奖励已领取' },
+    ACTIVITY_REBATE_HAS_RECEIVED: { code: 50067, simStr: '奖励已领取' },
+    ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND: { code: 50068, simStr: '未找到该节点' },
+    ACTIVITY_DRAGON_BOAT_COUNT_OVER: { code: 50069, simStr: '挑战次数不足' },
+    ACTIVITY_DRAGON_BOAT_PRE_NOT_PASS: { code: 50070, simStr: '前置节点未挑战' },
+    ACTIVITY_DRAGON_BOAT_ROUTE_HAS_PASS: { code: 50071, simStr: '该节点已经挑战过了' },
+    ACTIVITY_DRAGON_BOAT_BUY_COUNT_OVER: { code: 50072, simStr: '购买挑战次数不足' },
+    ACTIVITY_DRAGON_BOAT_CANNOT_BUY: { code: 50073, simStr: '不可在免费次数未用完的时候购买次数' },
 
     // GM后台相关状态 60000 - 69999
     GM_ERR_PASSWORD: { code: 60001, simStr: '账号或密码错误' },

shared/db/ActivityDragonBoat.ts

@@ -0,0 +1,69 @@
+import BaseModel from './BaseModel';
+import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+
+
+/**
+  * 划龙舟
+*/
+class RecordReward {
+  @prop({ required: true })
+  id: number;
+  @prop({ required: true })
+  count: number;
+}
+
+class BoatRecord {
+    @prop({ required: true })
+    todayIndex: number;
+
+    @prop({ required: true })
+    id: number;      // 划过的节点
+
+    @prop({ required: true })
+    time: Date;      // 时间
+
+    @prop({ required: true, type: RecordReward, _id: false })
+    rewards: RecordReward[];      // 奖励
+}
+
+@index({ roleId: 1, activityId: 1 })
+
+export default class Activity_Dragon_Boat extends BaseModel {
+    @prop({ required: true })
+    serverId: number;				// 服Id
+
+    @prop({ required: true })
+    activityId: number;				// 活动Id
+
+    @prop({ required: true })
+    roundIndex: number;				// 第几轮
+
+    @prop({ required: true })
+    roleId: string;			        // 用户Id
+
+    @prop({ required: true })
+    buyCnt: number;			        // 购买次数
+
+    @prop({ required: true, type: BoatRecord, _id: false })
+    record: BoatRecord[];           // 划船记录
+
+    public static async findData(serverId: number, activityId: number, roundIndex: number, roleId: string) {
+      let result: ActivityDragonBoatModelType = await ActivityDragonBoatModel.findOne({ serverId, roleId, activityId, roundIndex }).lean();
+      return result;
+    }
+
+    public static async record(serverId: number, activityId: number, roundIndex: number, roleId: string, record: BoatRecord) {
+      let result: ActivityDragonBoatModelType = await ActivityDragonBoatModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex }, { $push: { record }, $setOnInsert: { buyCnt: 0 } }, { new: true, upsert: true }).lean();
+      return result;
+    }
+
+    public static async buyCnt(serverId: number, activityId: number, roundIndex: number, roleId: string, count: number) {
+      let result: ActivityDragonBoatModelType = await ActivityDragonBoatModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex }, { $inc: { buyCnt: count }, $setOnInsert: { record: [] } }, { new: true, upsert: true }).lean();
+      return result;
+    }
+}
+
+export const ActivityDragonBoatModel = getModelForClass(Activity_Dragon_Boat);
+
+export interface ActivityDragonBoatModelType extends Pick<DocumentType<Activity_Dragon_Boat>, keyof Activity_Dragon_Boat> { }
+export type ActivityDragonBoatModelTypeParam = Partial<ActivityDragonBoatModelType>; // 将所有字段变成可选项

shared/domain/activityField/dragonBoatField.ts

@@ -0,0 +1,109 @@
+// 节日活动 - 划龙舟
+import { ActivityModelType } from '../../db/Activity';
+import { ActivityDragonBoatModelType } from '../../db/ActivityDragonBoat';
+import { ActivityBase } from './activityField';
+
+// 后台格式
+interface RouteInDb {
+    id: number;       // 唯一id，对应 dic_zyz_duanwu_dragonBoat的id
+    preId: number;    // 前一个的节点，对应dic_zyz_duanwu_dragonBoat的id
+    type: number;     // 节点显示类型，1-普通奖励 2-高级奖励 3-漩涡
+    reward: string;   // 到了这个节点可以获得的奖励，type&id&count
+}
+
+interface DragonBoatDataInDb {
+    buyCost: string;      // 购买一次划船次数的消耗，type&id&count
+    dailyBuyCnt: number;    // 每天可以购买的次数
+    freeCnt: number;      // 每天可以免费划船的次数
+    routes: RouteInDb[];   // 划船路径
+}
+
+class RouteData {
+    id: number;    // 唯一id，对应 dic_zyz_duanwu_dragonBoat的id
+    preId: number;    // 前一个的节点，对应dic_zyz_duanwu_dragonBoat的id
+    type: number;   // 节点显示类型，1-普通奖励 2-高级奖励 3-漩涡
+    reward: string;  // 到了这个节点可以获得的奖励，type&id&count
+    resultReward: {id: number, count: number}[];
+
+    hasPass: boolean = false; // 是否经过过这个点
+
+    constructor(data: RouteInDb) {
+        this.id = data.id;
+        this.preId = data.preId;
+        this.type = data.type;
+        this.reward = data.reward;
+    }
+
+    public setPass(reward: {id: number, count: number}[]) {
+        this.hasPass = true;
+        this.resultReward = reward;
+    }
+
+    public getShowResult() {
+        let { id, type, reward, hasPass } = this;
+        return { id, type, reward, hasPass }
+    }
+}
+
+export class DragonBoatData extends ActivityBase {
+    buyCost: string;      // 购买一次划船次数的消耗，type&id&count
+    dailyBuyCnt: number;  // 每天可以购买的次数
+    freeCnt: number;      // 每天可以免费划船的次数
+    routes: RouteData[] = [];  // 划船路径
+
+    maxBuyCnt: number = 0;    // 累积到现在可以购买的次数
+    buyCnt: number = 0;       // 累积到现在已经购买了的次数
+    todayPlayCnt: number = 0; // 今天玩的次数
+    playCnt: number = 0;      // 总计玩的次数
+
+
+    constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
+        super(activityData, createTime, serverTime)
+        this.initData(activityData.data)
+    }
+
+    public initData(data: string): void {
+        let dataObj: DragonBoatDataInDb = JSON.parse(data);
+        if(!dataObj) return;
+
+        this.buyCost = dataObj.buyCost||'&';
+        this.dailyBuyCnt = dataObj.dailyBuyCnt||0;
+        this.freeCnt = dataObj.freeCnt||0;
+        this.maxBuyCnt = this.todayIndex * this.dailyBuyCnt;
+        for(let data of (dataObj.routes||[])) {
+            this.routes.push(new RouteData(data));
+        }
+    }
+
+    public setPlayerRecords(playerData: ActivityDragonBoatModelType) {
+        if(!playerData) return;
+        this.buyCnt = playerData.buyCnt||0;
+        this.todayPlayCnt = 0;
+        this.playCnt = 0;
+        for(let { id, todayIndex, rewards } of (playerData.record||[])) {
+            if(todayIndex == this.todayIndex) this.todayPlayCnt ++;
+            this.playCnt ++;
+            let route = this.routes.find(cur => cur.id == id);
+            if(route) route.setPass(rewards);
+        }
+    }
+
+    public findRoute(id: number) {
+        return this.routes.find(cur => cur.id == id);
+    }
+
+    public getShowResult() {
+        return {
+            ...this.getBaseKeys(),
+            buyCost: this.buyCost,
+            dailyBuyCnt: this.dailyBuyCnt,
+            freeCnt: this.freeCnt,
+            maxBuyCnt: this.maxBuyCnt,
+            buyCnt: this.buyCnt,
+            todayPlayCnt: this.todayPlayCnt,
+            playCnt: this.playCnt,
+            routes: this.routes.map(route => route.getShowResult()),
+        
+        }
+    }
+}

shared/domain/activityField/refreshShopField.ts

@@ -15,7 +15,8 @@ interface RefreshShopPageInDb {
     viewcount: number;
     preNeedBuyCnt: number;  // 添加：上一页需要购买的
     name: string;
-    items: RefreshShopItemInDb[]
+    items: RefreshShopItemInDb[];
+    type: number;
 }
 
 interface RefreshShopItemInDb {
@@ -91,6 +92,7 @@ export class RefreshShopPage {
     viewCount: number;       //随机可购买的商品个数
     preNeedBuyCnt: number;  // 添加：上一页需要购买的   
     items: Array<RefreshShopItem> = [];//商品列表
+    type: number = 1;           // 1-限时商店 2-限时返场商店
     constructor(data: RefreshShopPageInDb) {
         this.pageIndex = data.pageIndex;
         this.name = data.name;
@@ -99,6 +101,7 @@ export class RefreshShopPage {
         }
         this.preNeedBuyCnt = data.preNeedBuyCnt;
         this.viewCount = data.viewcount ? data.viewcount : this.items.length;
+        if(data.type) this.type = data.type;
     }
 }
 

shared/resource/jsons/dic_zyz_activityType.json

@@ -298,5 +298,11 @@
         "activityType": 54,
         "name": "WEBVIEW",
         "string": "平台活动网页"
+    },
+    {
+        "id": 55,
+        "activityType": 55,
+        "name": "DRAGON_BOAT",
+        "string": "龙舟"
     }
 ]