xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
luying
2023-05-22 21:08:28 +08:00
parent 8e53bff441
commit b158099101
10 changed files with 379 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
game-server/app/servers/activity/handler/dragonBoatHandler.ts Normal file
View File

@@ -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
});
}
}

6
game-server/app/services/activity/activityService.ts
View File

@@ -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;

38
game-server/app/services/activity/dragonBoatService.ts Normal file
View File

@@ -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
}

1
shared/consts/constModules/activityConst.ts
View File

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

2
shared/consts/constModules/sysConst.ts
View File

@@ -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 {

16
shared/consts/statusCode.ts
View File

@@ -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_PUBLIC_ACCOUNT_WAIT: { code: 60064, simStr: '请在公众号输入口令' },
ACTIVITY_PUBLIC_ACCOUNT_RECEIVED: { code: 60065, simStr: '已领取' },
ACTIVITY_REBATE_DAY_NOT_REACH: { code: 60066, simStr: '暂不可领取' },
ACTIVITY_REBATE_HAS_RECEIVED: { code: 60067, simStr: '奖励已领取' },
ACTIVITY_MONTHLY_FUND_HAS_SIGN: { code: 50063, simStr: '本次签到奖励已领取' },
ACTIVITY_PUBLIC_ACCOUNT_WAIT: { code: 50064, simStr: '请在公众号输入口令' },
ACTIVITY_PUBLIC_ACCOUNT_RECEIVED: { code: 50065, simStr: '已领取' },
ACTIVITY_REBATE_DAY_NOT_REACH: { code: 50066, 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: '账号或密码错误' },

69
shared/db/ActivityDragonBoat.ts Normal file
View File

@@ -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>; // 将所有字段变成可选项

109
shared/domain/activityField/dragonBoatField.ts Normal file
View File

@@ -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()),
}
}
}

5
shared/domain/activityField/refreshShopField.ts
View File

@@ -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;
}
}

6
shared/resource/jsons/dic_zyz_activityType.json
View File

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