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

新将活动：活动格式

Browse Source
This commit is contained in:
luying
2022-08-01 16:01:55 +08:00
parent ff2f76bba8
commit 8c9e7ae961
17 changed files with 242 additions and 633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
game-server/app/servers/activity/handler/activityHandler.ts
View File

@@ -48,6 +48,7 @@ export class ActivityHandler {
}
}
playerGroupArray.push({
id: groupData.groupId,
type: groupData.type,
activities: playerGroupActivityArray
});

69
game-server/app/servers/activity/handler/newHeroGKHandler.ts
View File

@@ -1,69 +0,0 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGKData } from '../../../services/activity/newHeroGKService';
import { NewHeroGKItem } from '../../../domain/activityField/newHeroGKField';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGKHandler(app);
}
export class NewHeroGKHandler {
constructor(private app: Application) {
}
/************************新将演绎 (通用每日关卡,分页，自定义每个关卡开放的时间长短);(配置N个武将，每个武将有X个关卡；活动期间，*天(时间自定义)开启每个武将对应的一个关卡，只有第一次通关会获得奖励)****************************/
/**
* @description 获取关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGKHandler
*/
async getNewHeroGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, pageIndex: number, index:number}} msg
* @param {BackendSession} session
* @memberof NewHeroGKHandler
*/
async getGK(msg: { activityId: number, pageIndex: number, index: number }, session: BackendSession) {
const { activityId, pageIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerNewHeroGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: NewHeroGKItem = playerData.findNewHeroGKItem(pageIndex, index);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (dailyItemData.begin > playerData.todayIndex || dailyItemData.end < playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
// await challengeNewHeroGK(serverId, roleId, activityId, pageIndex, dailyItemData.gk)
return resResult(STATUS.SUCCESS, {
gkId: dailyItemData.gk
});
}
}

111
game-server/app/servers/activity/handler/newHeroGachaHandler.ts
View File

@@ -1,111 +0,0 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, GACHA_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { getPlayerNewHeroGachaData } from '../../../services/activity/newHeroGachaService';
import { RoleModel } from '../../../db/Role';
import { HeroModel } from '../../../db/Hero';
import { GachaPull } from '../../../services/activity/gachaService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityNewHeroGachaModel } from '../../../db/ActivityNewHeroGacha';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { createHeroes } from '../../../services/role/createHero';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGachaHandler(app);
}
export class NewHeroGachaHandler {
constructor(private app: Application) {
}
/************************新将擢迁, 新武将抽卡****************************/
/**
* @description 获取新武将抽卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGachaHandler
*/
async getNewHeroGachaActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGachaData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 选中武将
* @param {{ activityId: number, hid:number}} msg
* @param {BackendSession} session
* @memberof NewHeroGachaHandler
*/
async selectedHero(msg: { activityId: number, hid: number }, session: BackendSession) {
const { activityId, hid } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
await ActivityNewHeroGachaModel.selectedHero(serverId, activityId, roleId, hid);
return resResult(STATUS.SUCCESS);
}
/**
* @description 抽卡
* @param {{ activityId: number, hid: number, count: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGachaHandler
*/
// async pull(msg: { activityId: number, hid: number, count: number }, session: BackendSession) {
// const { activityId, hid, count } = msg;
// const roleId = session.get('roleId');
// const serverId = session.get('serverId');
// const sid = session.get('sid');
// const roleName = session.get('roleName');
// if(count < 0) return resResult(STATUS.WRONG_PARMS);
// let playerData = await getPlayerNewHeroGachaData(activityId, serverId, roleId)
// if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// let item = playerData.findItem(hid);
// if (!item) {
// return resResult(STATUS.ACTIVITY_DATA_ERROR);
// }
// let userHeroes = await HeroModel.findByRole(roleId);
// let gachaPull = new GachaPull(GACHA_TYPE.TIMELIMIT);
// gachaPull.setByActivity(item);
// let { items, heroInfo, resultList } = gachaPull.pull(count, userHeroes);
// let { hasGetFloor, floorCount } = gachaPull.getActivityParam();
// // 消耗东西
// let cost = item.cost.map(cur => { return { id: cur.id, count: cur.count * count } });
// let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.NEW_HERO_GACHA_PULL);
// if (!costResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
// //记录数据
// await ActivityNewHeroGachaModel.addRecord(serverId, activityId, roleId, hid, floorCount, JSON.stringify(resultList), hasGetFloor);
// // 给东西
// let { heroes, resultHeroes } = await createHeroes(roleId, roleName, sid, serverId, heroInfo);
// await addItems(roleId, roleName, sid, items, ITEM_CHANGE_REASON.GACHA_ITEMS);
// //固定奖励
// let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.commonReward);
// let newRewardParamArr: Array<RewardParam> = rewardParamArr.map(obj => { return { id: obj.id, type: obj.type, count: obj.count * count } });
// let commonResult = await addReward(roleId, roleName, sid, serverId, newRewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_GACHA_PULL)
// return resResult(STATUS.SUCCESS, {
// hid, activityId, count, randomReward: { heroes: resultHeroes.map(cur => ({hid: cur.hid})), result: resultList }, commonReward: commonResult
// });
// }
}

52
game-server/app/servers/activity/handler/newHeroGiftsHandler.ts
View File

@@ -1,7 +1,7 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroGiftsService';
import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityNewHeroGiftModel } from '../../../db/ActivityNewHeroGift';
@@ -42,33 +42,33 @@ export class NewHeroGiftsHandler {
* @memberof NewHeroGiftsHandler
*/
async exchangePoint(msg: { activityId: number, index: number }, session: BackendSession) {
const { activityId, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
// const { activityId, index } = msg;
// const roleId = session.get('roleId');
// const serverId = session.get('serverId');
// const sid = session.get('sid');
// const roleName = session.get('roleName');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
// if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItem(index);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.countMax <= item.buyCount) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.consumePoint + playerData.consumeTotalPoint > playerData.totalPoint) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_EXCHANGE)
await ActivityNewHeroGiftModel.addReceiveRecord(serverId, activityId, roleId, index, item.consumePoint);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, index },
item: item, consumeTotalPoint: playerData.consumeTotalPoint + item.consumePoint
}));
// let item = playerData.findItem(index);
// if (!item) {
// return resResult(STATUS.ACTIVITY_DATA_ERROR);
// }
// if (item.countMax <= item.buyCount) {
// return resResult(STATUS.ACTIVITY_MAX_COUNT);
// }
// if (item.consumePoint + playerData.consumeTotalPoint > playerData.totalPoint) {
// return resResult(STATUS.ACTIVITY_NO_POINT);
// }
// let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
// let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_EXCHANGE)
// await ActivityNewHeroGiftModel.addReceiveRecord(serverId, activityId, roleId, index, item.consumePoint);
// item.buyCount += 1;
// return resResult(STATUS.SUCCESS, Object.assign(result, {
// param: { activityId, index },
// item: item, consumeTotalPoint: playerData.consumeTotalPoint + item.consumePoint
// }));
}
}

2
game-server/app/servers/battle/handler/normalBattleHandler.ts
View File

@@ -23,7 +23,7 @@ import { checkTaskInBattleEnd, checkTaskInBattleStart, checkTaskInBattleSweep }
import { ActivitySelfServiceModel } from '../../../db/ActivitySelfService';
import { getSelfServiceShopActivityData } from '../../../services/activity/selfServiceShopActivityService';
import { challengeDailyGK } from '../../../services/activity/dailyGKService';
import { challengeNewHeroGK } from '../../../services/activity/newHeroGKService';
import { challengeNewHeroGK } from '../../../services/activity/newHeroService';
import { reportTAEvent } from '../../../services/sdkService';
import { getVipRegretCnt } from '../../../services/activity/monthlyTicketService';
import { isArray, isNumber } from 'underscore';

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

@@ -21,16 +21,11 @@ import { getPlayerDailyGKData } from './dailyGKService';
import { getPlayerRefreshShopData } from './refreshShopService';
import { getPlayerRefreshTaskData } from './refreshTaskService';
import { getPlayerMonopolyData } from './monopolyService';
import { getPlayerNewHeroGiftsData, newHeroGiftPoint } from './newHeroGiftsService';
import { getPlayerNewHeroGKData } from './newHeroGKService';
import { getPlayerNewHeroGachaData } from './newHeroGachaService';
import { getPlayerNewHeroGiftsData, newHeroGiftPoint, getPlayerNewHeroGKData, getPlayerNewHeroGachaData } from './newHeroService';
import { BackendSession, pinus } from 'pinus';
import { ActivityModel, ActivityModelType } from '../../db/Activity';
import { getRandSingleEelm, resResult } from '../../pubUtils/util';
import { SignInData } from '../../domain/activityField/signInField';
import { ActivityGroupModel } from '../../db/ActivityGroup';
import { ActivityGroupTypeModel } from '../../db/ActivityGroupType';
import { ServerlistModel } from '../../db/Serverlist';
import { ActivityInRemote, transActivityInRemoteToModelType } from '../../domain/activityField/activityField';
import { getPlayerLuckyTurntableDataShow } from './luckyTurntableService';
import { getTimeLimitRankDataShow } from './timeLimitRankService';

56
game-server/app/services/activity/newHeroGachaService.ts
View File

@@ -1,56 +0,0 @@
import { ACTIVITY_TYPE } from '../../consts';
import { ActivityModel, ActivityModelType } from '../../db/Activity';
import { ActivityNewHeroGachaModel, ActivityNewHeroGachaModelType } from '../../db/ActivityNewHeroGacha';
import { RoleModel } from '../../db/Role';
import { ServerlistModel } from '../../db/Serverlist';
import { NewHeroGachaData } from '../../domain/activityField/newHeroGachaField';
import { getRoleCreateTime, getServerCreateTime } from '../redisService';
import { getActivitiesByType, getActivityById } from './activityService';
/**
* 获取活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function newHeroGachaActivity(serverId: number, roleId: string) {
let activityDataArray = await getActivitiesByType(serverId, ACTIVITY_TYPE.NEW_HERO_GACHA);
if (activityDataArray.length === 0) {
return null;
}
let activityData: ActivityModelType = activityDataArray[0];
let playerRecord: ActivityNewHeroGachaModelType = await ActivityNewHeroGachaModel.findData(serverId, activityData.activityId, roleId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new NewHeroGachaData(activityData, createTime, serverTime);
playerData.setPlayerRecords(playerRecord);
return playerData;
}
/**
* 玩家玩家活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function getPlayerNewHeroGachaData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let playerRecord: ActivityNewHeroGachaModelType = await ActivityNewHeroGachaModel.findData(serverId, activityId, roleId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new NewHeroGachaData(activityData, createTime, serverTime);
playerData.setPlayerRecords(playerRecord);
return playerData;
}

60
game-server/app/services/activity/newHeroGiftsService.ts
View File

@@ -1,60 +0,0 @@
import { ACTIVITY_TYPE } from '../../consts';
import { ActivityModel, ActivityModelType } from '../../db/Activity';
import { ActivityNewHeroGiftModel, ActivityNewHeroGiftModelType } from '../../db/ActivityNewHeroGift';
import { NewHeroGiftData } from '../../domain/activityField/newHeroGiftField';
import { ServerlistModel } from '../../db/Serverlist';
import { RoleModel } from '../../db/Role';
import { getActivitiesByType, getActivityById } from './activityService';
import { getRoleCreateTime, getServerCreateTime } from '../redisService';
/**
* 获取活动数据
*
* @param {number} serverId 区Id
* @param {number} type 活动类型 ACTIVITY_TYPE
* @param {string} roleId 角色Id
*
*/
export async function getNewHeroGiftsActivity(serverId: number, roleId: string) {
let activityArray = await getActivitiesByType(serverId, ACTIVITY_TYPE.DAILY_RMB_GIFTS);
if (activityArray.length == 0) {
return null;
}
let activityData = activityArray[0];
let playerData = await getPlayerNewHeroGiftsData(activityData.activityId, serverId, roleId);
return playerData
}
/**
* 玩家活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function getPlayerNewHeroGiftsData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new NewHeroGiftData(activityData, createTime, serverTime);
let playerRecord: ActivityNewHeroGiftModelType = await ActivityNewHeroGiftModel.findData(serverId, activityId, roleId);
playerData.setPlayerRecords(playerRecord);
return playerData;
}
/**
* 任务活动完成后会获得点数
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function newHeroGiftPoint(serverId: number, activityId: number, roleId: string, addPoint: number) {
let result = await ActivityNewHeroGiftModel.addPoint(serverId, activityId, roleId, addPoint);
return result.totalPoint;
}

69
game-server/app/services/activity/newHeroGKService.ts → game-server/app/services/activity/newHeroService.ts
View File

@@ -1,31 +1,35 @@
import { ACTIVITY_TYPE } from '../../consts';
import { ActivityModel, ActivityModelType } from '../../db/Activity';
import { ActivityNewHeroGiftModel, ActivityNewHeroGiftModelType } from '../../db/ActivityNewHeroGift';
import { ActivityNewHeroGKModel, ActivityNewHeroGKModelType } from '../../db/ActivityNewHeroGK';
import { RoleModel } from '../../db/Role';
import { ServerlistModel } from '../../db/Serverlist';
import { UserGachaModel, UserGachaType } from '../../db/UserGacha';
import { NewHeroGachaData } from '../../domain/activityField/newHeroGachaField';
import { NewHeroGiftData } from '../../domain/activityField/newHeroGiftField';
import { NewHeroGKData } from '../../domain/activityField/newHeroGKField';
import { getRoleCreateTime, getServerCreateTime } from '../redisService';
import { getActivitiesByType, getActivityById } from './activityService';
/**
* 获取活动数据
* 玩家玩家活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function newHeroGKActivity(serverId: number, roleId: string) {
let activityDataArray = await getActivitiesByType(serverId, ACTIVITY_TYPE.DAILY_GK);
if (activityDataArray.length === 0) {
return null;
}
let activityData: ActivityModelType = activityDataArray[0];
let playerRecord: ActivityNewHeroGKModelType = await ActivityNewHeroGKModel.findData(serverId, activityData.activityId, roleId);
export async function getPlayerNewHeroGachaData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new NewHeroGKData(activityData, createTime, serverTime);
let playerData = new NewHeroGachaData(activityData, createTime, serverTime);
let playerRecord: UserGachaType = await UserGachaModel.findByRole(roleId, playerData.gachaId);
playerData.setPlayerRecords(playerRecord);
return playerData;
}
@@ -38,7 +42,7 @@ export async function newHeroGKActivity(serverId: number, roleId: string) {
* @param {string} roleId 角色Id
*
*/
export async function getPlayerNewHeroGKData(activityId: number, serverId: number, roleId: string) {
export async function getPlayerNewHeroGKData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let playerRecord: ActivityNewHeroGKModelType = await ActivityNewHeroGKModel.findData(serverId, activityId, roleId);
@@ -54,10 +58,10 @@ export async function getPlayerNewHeroGKData(activityId: number, serverId: numbe
* 挑战每日关卡成功
*
* @param {number} activityId 活动id
* @param {number} gk 关卡id
* @param {number} warId 关卡id
*
*/
export async function challengeNewHeroGK(serverId: number, roleId: string, activityId: number, pageIndex: number, gk: number) {
export async function challengeNewHeroGK(serverId: number, roleId: string, activityId: number, pageIndex: number, warId: number) {
let isFirst = false;
let activityData: ActivityModelType = await getActivityById(activityId);
let playerRecords = await ActivityNewHeroGKModel.findData(serverId, activityId, roleId);
@@ -66,20 +70,47 @@ export async function challengeNewHeroGK(serverId: number, roleId: string, activ
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new NewHeroGKData(activityData, createTime, serverTime);
let item = playerData.findItemByGK(pageIndex, gk);
let item = playerData.findItemByGK(warId);
if (item) {
let index = item.index;
let recordIndex = records.findIndex(obj => { return obj.pageIndex == pageIndex && obj.index == index });
let recordIndex = records.findIndex(obj => { return obj.warId == warId });
if (recordIndex == -1) {
isFirst = true;
await ActivityNewHeroGKModel.addRecord(serverId, activityId, roleId, pageIndex, index);
await ActivityNewHeroGKModel.addRecord(serverId, activityId, roleId, warId);
}
} else {
console.log('challengeNewHeroGK没有找到对应关卡活动数据', activityId, gk)
console.log('challengeNewHeroGK没有找到对应关卡活动数据', activityId, warId)
}
return isFirst;
}
/**
* 玩家活动数据
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function getPlayerNewHeroGiftsData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new NewHeroGiftData(activityData, createTime, serverTime);
let playerRecord: ActivityNewHeroGiftModelType = await ActivityNewHeroGiftModel.findData(serverId, activityId, roleId);
playerData.setPlayerRecords(playerRecord);
return playerData;
}
/**
* 任务活动完成后会获得点数
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function newHeroGiftPoint(serverId: number, activityId: number, roleId: string, addPoint: number) {
let result = await ActivityNewHeroGiftModel.addPoint(serverId, activityId, roleId, addPoint);
return result.totalPoint;
}

12
shared/db/ActivityNewHeroGK.ts
View File

@@ -4,17 +4,15 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
export class Record {
@prop({ required: true })
pageIndex: number; //第几页
warId: number; //关卡id
@prop({ required: true })
index: number; //下标记录
@prop({ required: true })
time: Date; //兑换时间
time: Date; //时间
}
/**
* 活动系统 - 新将演绎活动
*/
@index({ roleId: 1 })
@index({ serverId: 1, activityId: 1, roleId: 1 })
export default class Activity_New_Hero_GK extends BaseModel {
@prop({ required: true })
@@ -27,9 +25,9 @@ export default class Activity_New_Hero_GK extends BaseModel {
records: Record[]; // 通关记录
//通关记录
public static async addRecord(serverId: number, activityId: number, roleId: string, pageIndex: number, index: number) {
public static async addRecord(serverId: number, activityId: number, roleId: string, warId: number) {
let result: ActivityNewHeroGKModelType = await ActivityNewHeroGKModel.findOneAndUpdate({ serverId, roleId, activityId },
{ $push: { records: { pageIndex, index, time: new Date() } } }, { upsert: true, new: true }).lean(true);
{ $push: { records: { warId, time: new Date() } } }, { upsert: true, new: true }).lean(true);
return result;
}

74
shared/db/ActivityNewHeroGacha.ts
View File

@@ -1,74 +0,0 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
export class Record {
@prop({ required: true })
hid: number; // 选中的武将id
@prop({ required: true })
count: number; // 次数
@prop({ required: true })
reward: string; // 奖励内容
@prop({ required: true })
time: Date; // 抽卡时间
@prop({ required: true })
hasGetFloor: boolean; // 是否抽到保底了
}
/**
* 活动系统 - 每日关卡活动
*/
@index({ roleId: 1 })
export default class Activity_New_Hero_Gacha extends BaseModel {
@prop({ required: true })
serverId: number; // 服id
@prop({ required: true })
activityId: number; // 活动Id
@prop({ required: true })
roleId: string; // 用户Id
@prop({ required: true })
selectedHid: number; // 玩家选中的武将id
@prop({ required: true })
count: number; // 抽卡次数，抽中大奖后重新统计
@prop({ required: true })
records: Record[]; // 抽卡历史记录
@prop({ required: true })
hasGetFloor: boolean; // 是否抽到保底了
//重置统计次数
public static async resetCount(serverId: number, activityId: number, roleId: string, count: number) {
let result: ActivityNewHeroGachaModelType = await ActivityNewHeroGachaModel.findOneAndUpdate({ serverId, roleId, activityId, },
{ $set: { count } }, { upsert: true, new: true }).lean(true);
return result;
}
//抽卡记录
public static async addRecord(serverId: number, activityId: number, roleId: string, hid: number, count: number, reward: string, hasGetFloor: boolean) {
let result: ActivityNewHeroGachaModelType = await ActivityNewHeroGachaModel.findOneAndUpdate({ serverId, roleId, activityId },
{ $set: { count, hasGetFloor }, $push: { records: { hid, count, reward, time: new Date(), hasGetFloor } } }, { upsert: true, new: true }).lean(true);
return result;
}
//设置选中武将
public static async selectedHero(serverId: number, activityId: number, roleId: string, selectedHid: number) {
let result: ActivityNewHeroGachaModelType = await ActivityNewHeroGachaModel.findOneAndUpdate(
{ serverId, roleId, activityId }, { $set: { selectedHid } }, { upsert: true, new: true }).lean(true);
return result;
}
//根据活动id查询活动数据
public static async findData(serverId: number, activityId: number, roleId: string) {
let result: ActivityNewHeroGachaModelType = await ActivityNewHeroGachaModel.findOne({ serverId, roleId, activityId }).lean(true);
return result;
}
//删除活动领取记录
public static async deleteActivity(serverId: number, activityId: number, roleId: string) {
await ActivityNewHeroGachaModel.deleteMany({ serverId, roleId, activityId });
}
}
export const ActivityNewHeroGachaModel = getModelForClass(Activity_New_Hero_Gacha);
export interface ActivityNewHeroGachaModelType extends Pick<DocumentType<Activity_New_Hero_Gacha>, keyof Activity_New_Hero_Gacha> { }
export type ActivityNewHeroGachaModelTypeParam = Partial<ActivityNewHeroGachaModelType>; // 将所有字段变成可选项

4
shared/db/ActivityNewHeroGift.ts
View File

@@ -5,7 +5,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
* 购买记录
*/
export class Record {
export class ActivityNewHeroGiftRecord {
@prop({ required: true })
index: number; //下标记录
@prop({ required: true })
@@ -30,7 +30,7 @@ export default class Activity_New_Hero_Gift extends BaseModel {
@prop({ required: true })
totalPoint: number; // 获得总点数
@prop({ required: true })
records: Record[]; // 兑换红包消耗点数记录
records: ActivityNewHeroGiftRecord[]; // 兑换红包消耗点数记录
//兑换记录
public static async addPoint(serverId: number, activityId: number, roleId: string, addPoint: number) {

140
shared/domain/activityField/newHeroGKField.ts
View File

@@ -1,104 +1,68 @@
import { ActivityModelType } from '../../db/Activity';
import { ActivityNewHeroGKModelType } from '../../db/ActivityNewHeroGK';
import { getTimeFunM } from '../../pubUtils/timeUtil';
import { ActivityBase } from './activityField';
// 每日配置数据
export class NewHeroGKItem {
pageIndex: number;
begin: number; // 第几天开始,从1开始，1表示第一天0点开始
end: number; // 第几天结束,2表示第二天24点结束
index: number; // 下标
gk: number; // 关卡
name: string; // 名称
reward: string; // 奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
isSuccess: boolean; //是否成功
constructor(data: any, pageIndex: number) {
this.pageIndex = pageIndex;
this.begin = data.begin;
this.end = data.end;
this.index = data.index;
this.gk = data.gk;
this.name = data.name;
this.reward = data.reward;
this.isSuccess = false;
}
/******* 存在数据库里的数据 *******/
interface NewHeroGkWarInDb {
warId: number; // 关卡id
icon: string; // 图标文件名
startDay: number; // 活动第几天开启
}
// 每日配置数据
export class NewHeroGKPage {
items: Array<NewHeroGKItem> = [];
pageIndex: number; // 页码
name: string; // 名称
hid: number; //武将id
title: string = '';//客户端用说明文字
constructor(data: any) {
this.pageIndex = data.pageIndex;
this.name = data.name;
this.hid = data.hid;
this.title = data.title;
this.items = [];
for (let obj of data.items) {
this.items.push(new NewHeroGKItem(obj, this.pageIndex))
}
}
interface NewHeroGkDataInDb {
bg: string; // 背景图
wars: NewHeroGkWarInDb[]; // 关卡
}
// 每日关卡活动数据
export class NewHeroGachaWar {
warId: number; // 关卡id
icon: string; // 图标文件名
startTime: number; // 活动第几天开启，13位时间戳
isSuccess: boolean = false; // 是否成功
constructor(data: NewHeroGkWarInDb, beginTime: number) {
this.warId = data.warId;
this.icon = data.icon;
this.startTime = <number>getTimeFunM(beginTime).getAfterDayWithHour(data.startDay - 1);
}
setPlayerRecord(isSuccess: boolean) {
this.isSuccess = isSuccess;
}
}
export class NewHeroGKData extends ActivityBase {
list: Array<NewHeroGKPage> = [];
name: string; // 名称
public findItemByGK(pageIndex: number, gk: number) {
for (let pageData of this.list) {
if (pageData.pageIndex == pageIndex) {
let index = pageData.items.findIndex(obj => { return obj.gk == gk })
return (index != -1) ? pageData.items[index] : null;
}
}
return null;
}
public findNewHeroGKItem(pageIndex: number, dayIndex: number) {
for (let pageData of this.list) {
if (pageData.pageIndex == pageIndex) {
let index = pageData.items.findIndex(obj => { return obj.begin <= dayIndex && obj.end >= dayIndex })
return (index != -1) ? pageData.items[index] : null;
}
}
return null;
}
//解析玩家记录
public setPlayerRecords(data: ActivityNewHeroGKModelType) {
if (!data)
return;
let records = data.records ? data.records : [];
for (let pageData of this.list) {
for (let item of pageData.items) {
let index = records.findIndex(obj => { return pageData.pageIndex == obj.pageIndex && item.index == obj.index })
if (index != -1) {
item.isSuccess = true
}
}
}
}
public initData(data: string) {
let dataObj = JSON.parse(data);
this.name = dataObj.name;
let arr = dataObj.data;
for (let obj of arr) {
this.list.push(new NewHeroGKPage(obj))
}
}
bg: string; // 背景图
wars: NewHeroGachaWar[] = []; // 关卡
constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
public initData(data: string) {
let dataObj: NewHeroGkDataInDb = JSON.parse(data);
this.bg = dataObj.bg;
let arr = dataObj.wars||[];
for (let obj of arr) {
this.wars.push(new NewHeroGachaWar(obj, this.beginTime))
}
}
public findItemByGK(warId: number) {
return this.wars.find(cur => cur.warId == warId);
}
//解析玩家记录
public setPlayerRecords(data: ActivityNewHeroGKModelType) {
if (!data) return;
let records = data.records||[];
for (let data of records) {
let item = this.findItemByGK(data.warId);
if(item) item.setPlayerRecord(true);
}
}
}

103
shared/domain/activityField/newHeroGachaField.ts
View File

@@ -1,79 +1,52 @@
import { ActivityModelType } from '../../db/Activity';
import { ActivityNewHeroGachaModelType } from '../../db/ActivityNewHeroGacha';
import { RewardInter } from '../../pubUtils/interface';
import { parseGoodStr, splitString } from '../../pubUtils/util';
import { UserGachaType } from '../../db/UserGacha';
import { ActivityBase } from './activityField';
// 每个英雄的奖池配置数据
export class NewHeroGachaItem {
selected: boolean = false;//选中武将
floorCount: number = 0;//保底最大的次数,一定会出现一次
count: number = 0;//多少次没有抽中
hasGetFloor: boolean = false; // 是否有抽到保底，伪随机算法，抽到后未到保底次数强制不给
hid: number = 0;//武将id
name: string = '';//名字
cost: RewardInter[];//每次抽卡消耗资源
floorReward: number = 0;//保底奖励，percent下标+1
percent: { id: number, weight: number, goodId: number }[];//奖品百分比 contentId & percent & id(英雄hid，物品id)
commonReward: string = "";//固定奖 格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
constructor(data: any) {
this.hid = data.hid;
this.name = data.name;
this.floorCount = data.floorCount;
this.commonReward = data.commonReward;
this.cost = parseGoodStr(data.cost);
this.percent = [];
this.floorReward = data.floorReward - 1;
this.count = 0;
this.selected = false;
let arr = data.percent.split('|').filter(obj => { return obj && obj != '' });
for (let obj of arr) {
let numArr = splitString(obj, '&');
this.percent.push({
id: numArr[0],
weight: numArr[1],
goodId: numArr.length > 2 ? numArr[2] : 0,
})
}
}
interface NewHeroGachaItemInDb {
hid: number;
position: string; // x&y
}
interface NewHeroGachaDataInDb {
gachaId: number; // dic_zyz_gacha表的id，卡池的概率，消耗都通过这个表读取
icon: string; // 大地图的icon图片文件名
heroes: NewHeroGachaItemInDb[]; // 本期活动pick的武将
bg: string; // 首页背景图片
uiType: number; // 布局格式，具体什么代表什么含义由策划和客户端定
}
// 每日关卡活动数据
export class NewHeroGachaData extends ActivityBase {
list: NewHeroGachaItem[] = [];
public findItem(hid: number) {
let index = this.list.findIndex(obj => { return obj && obj.hid == hid })
return (index != -1) ? this.list[index] : null;
}
//解析玩家记录
public setPlayerRecords(data: ActivityNewHeroGachaModelType) {
if (!data) {
return;
}
for (let item of this.list) {
item.count = data.count ? data.count : 0;
item.hasGetFloor = data.hasGetFloor||false;
item.selected = (data && data.selectedHid == item.hid);
}
}
public initData(data: string) {
let dataObj = JSON.parse(data);
let arr = dataObj;
for (let obj of arr) {
this.list.push(new NewHeroGachaItem(obj))
}
}
gachaId: number;
icon: string;
heroes: NewHeroGachaItemInDb[];
bg: string;
uiType: number;
pickHero: number = 0;
pullCnt: number = 0;
constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
public initData(data: string) {
let dataObj: NewHeroGachaDataInDb = JSON.parse(data);
this.gachaId = dataObj.gachaId;
this.icon = dataObj.icon;
this.heroes = dataObj.heroes;
this.bg = dataObj.bg;
this.uiType = dataObj.uiType;
}
public findItem(hid: number) {
return this.heroes.find(obj => { return obj && obj.hid == hid })
}
//解析玩家记录
public setPlayerRecords(data: UserGachaType) {
if (!data) return;
this.pickHero = data.pickHero;
this.pullCnt = data.pullCnt;
}
}

105
shared/domain/activityField/newHeroGiftField.ts
View File

@@ -2,37 +2,75 @@ import { ActivityModelType } from '../../db/Activity';
import { ActivityNewHeroGiftModelType } from '../../db/ActivityNewHeroGift';
import { ActivityBase } from './activityField';
// 礼包的内容
export class NewHeroGiftItem {
index: number; // 下标
reward: string; //任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
countMax: number = 0; //可购买的最大次数，0表示不限制
name: string; //名字
consumePoint: number; //消耗点数
/******* 存在数据库里的数据 *******/
interface NewHeroGiftExplain {
index: number;
explain: string;
}
buyCount: number = 0; //兑换过的次数
interface NewHeroGiftRewardInDb {
index: number; // 下标
cover: string; // 翻牌背面的图片文件名
reward: string; // 奖励 type&id&count
countMax: number; // 最多抽出次数
}
constructor(data: any) {
interface NewHeroGiftDataInDb {
hid: number; // 左侧的立绘武将
position: string; // 位置 x&y
explain: NewHeroGiftExplain[]; // 玩法说明
rewards: NewHeroGiftRewardInDb[]; // 奖励
consumePoint: number; // 每转一次消耗的点数
}
/******* 返回给客户端的数据 *******/
class NewHeroGiftReward {
index: number; // 下标
cover: string; // 翻牌背面的图片文件名
reward: string; // 奖励 type&id&count
countMax: number; // 最多抽出次数
buyCount: number = 0; // 转出的次数
constructor(data: NewHeroGiftRewardInDb) {
this.index = data.index;
this.cover = data.cover;
this.reward = data.reward;
this.countMax = data.countMax;
this.name = data.name;
this.consumePoint = data.consumePoint;
this.buyCount = 0;
}
addBuyCount() {
this.buyCount++;
}
}
// 新将礼包数据
export class NewHeroGiftData extends ActivityBase {
name: string = '';//活动名称
list: Array<NewHeroGiftItem> = [];//礼包列表
totalPoint: number = 0;//获得总点数
consumeTotalPoint: number = 0;//消耗总点数
explain: { index: number, explain: string }[] = [];//客户端用的说明文字信息
hid: number; // 左侧的立绘武将
position: string; // 位置 x&y
consumePoint: number; // 每转一次消耗的点数
explain: NewHeroGiftExplain[]; // 玩法说明
rewards: NewHeroGiftReward[] = []; // 奖励
totalPoint: number = 0; // 已获得的点数
consumeTotalPoint: number = 0; // 总消耗的点数
constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
public initData(data: string) {
let dataObj: NewHeroGiftDataInDb = JSON.parse(data);
this.hid = dataObj.hid;
this.position = dataObj.position;
this.explain = dataObj.explain
let arr = dataObj.rewards||[];
for (let obj of arr) {
this.rewards.push(new NewHeroGiftReward(obj))
}
}
public findItem(index: number) {
let itemIndex = this.list.findIndex(obj => { return obj && obj.index === index });
return (itemIndex != -1) ? this.list[itemIndex] : null;
return this.rewards.find(obj => { return obj && obj.index === index });
}
//解析玩家购买记录
@@ -40,32 +78,13 @@ export class NewHeroGiftData extends ActivityBase {
if (!data) {
return;
}
this.totalPoint = data.totalPoint ? data.totalPoint : 0;
let records = data.records ? data.records : [];
for (let item of this.list) {
let buyRecords = records.filter(obj => { return obj && obj.index === item.index });
item.buyCount = buyRecords.length;
}
this.totalPoint = data.totalPoint||0;
let records = data.records||[];
for (let obj of records) {
let item = this.findItem(obj.index);
if(item) item.addBuyCount();
this.consumeTotalPoint += obj.point;
}
}
public initData(data: string) {
let dataObj = JSON.parse(data);
this.name = dataObj.name;
this.totalPoint = 0;
this.consumeTotalPoint = 0;
this.explain = dataObj.explain;
let arr = dataObj.data;
for (let obj of arr) {
this.list.push(new NewHeroGiftItem(obj))
}
}
constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
}

2
shared/pubUtils/roleUtil.ts
View File

@@ -36,7 +36,6 @@ import { ActivityGrowthPointModel } from '../db/ActivityGrowthPoint';
import { ActivityMonopolyModel } from '../db/ActivityMonopoly';
import { ActivityMonopolyLandModel } from '../db/ActivityMonopolyLand';
import { ActivityMonthlyTicketModel } from '../db/ActivityMonthlyTicket';
import { ActivityNewHeroGachaModel } from '../db/ActivityNewHeroGacha';
import { ActivityNewHeroGiftModel } from '../db/ActivityNewHeroGift';
import { ActivityNewHeroGKModel } from '../db/ActivityNewHeroGK';
import { ActivityPopUpShopModel } from '../db/ActivityPopUpShop';
@@ -113,7 +112,6 @@ export async function deletRole(roleId: string) {
await ActivityMonopolyModel.deleteMany({ roleId });
await ActivityMonopolyLandModel.deleteMany({ roleId });
await ActivityMonthlyTicketModel.deleteMany({ roleId });
await ActivityNewHeroGachaModel.deleteMany({ roleId });
await ActivityNewHeroGiftModel.deleteMany({ roleId });
await ActivityNewHeroGKModel.deleteMany({ roleId });
await ActivityPopUpShopModel.deleteMany({ roleId });

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

@@ -57,7 +57,7 @@
"id": 13,
"activityType": 13,
"name": "SELF_SERVICE_SHOP",
"string": "自选商店"
"string": "自选商店(糜家商队)"
},
{
"id": 14,
@@ -195,19 +195,19 @@
"id": 37,
"activityType": 37,
"name": "NEW_HERO_GIFTS",
"string": "新将好礼(很多红包，用积分兑换一遍结束)"
"string": "新将好礼"
},
{
"id": 38,
"activityType": 38,
"name": "NEW_HERO_GK",
"string": "新将演绎 (配置N个武将，每个武将有X个关卡；活动期间，*天(时间自定义)开启每个武将对应的一个关卡，只有第一次通关会获得奖励)"
"string": "新将演绎"
},
{
"id": 39,
"activityType": 39,
"name": "NEW_HERO_GACHA",
"string": "新将擢迁（新武将抽取）"
"string": "新将擢迁"
},
{
"id": 40,