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-03-07 19:50:56 +08:00
parent 52351bdf4e
commit c7eabb44cf
20 changed files with 617 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -69,7 +69,6 @@ export class RechargeMoneyHandler {
item.setHasGet(true);
return resResult(STATUS.SUCCESS, {
goods,
param: { activityId },
item: item
});

88
game-server/app/servers/activity/handler/taskPassHandler.ts Normal file
View File

@@ -0,0 +1,88 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getTaskPassData, getTaskPassDataShow } from '../../../services/activity/taskPassService';
import { ActivityTaskPassModel, ReceivedReward } from '../../../db/ActivityTaskPass';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ItemInter } from '../../../pubUtils/interface';
import { isNumber, pick } from 'underscore';
import { handleCost } from '../../../services/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new TaskPassHandler(app);
}
export class TaskPassHandler {
constructor(private app: Application) {
}
/************************战令系统****************************/
// 获得战令活动数据
public async getTaskPassData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTaskPassDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
// （一键）领取
public async receiveItems(msg: { activityId: number, pageIndex: number, lv: number }, session: BackendSession) {
const { activityId, pageIndex, lv = 0 } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getTaskPassData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(pageIndex, lv);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: ReceivedReward[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push({ pageIndex, lv: item.lv, receiveTime: nowSeconds() });
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityTaskPassModel.receiveItems(serverId, activityId, roleId, playerData.roundIndex, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_DAILY_GK_BATTLE_END);
return resResult(STATUS.SUCCESS, { items, ...result });
}
// 加速
public async speedUp(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
if(count == 0 || !isNumber(count)) return resResult(STATUS.WRONG_PARMS);
let playerData = await getTaskPassData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let cost: ItemInter[] = [];
let consumeArr = stringToConsumeParam(playerData.spdUp.cost);
for(let consume of consumeArr) {
cost.push({ ...consume, count: consume.count * count });
}
let consumeResult = await handleCost(roleId, sid, consumeArr, ITEM_CHANGE_REASON.ACT_DAILY_GK_BATTLE_END);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let addPoint = playerData.spdUp.point * count;
await ActivityTaskPassModel.addPoint(serverId, activityId, roleId, playerData.roundIndex, addPoint, count);
let result = playerData.addPoint(addPoint, count);
return resResult(STATUS.SUCCESS, result);
}
}

2
game-server/app/servers/chat/remote/guildRemote.ts
View File

@@ -42,7 +42,7 @@ export class GuildRemote {
private GUILD_RACE_UPDATE = 'onRaceHorseUpdate'; /// 更新木牛流马
private GUILD_RACE_JOIN = 'onRaceHorseJoin'
private GUILD_RACE_EVENT = 'onRaceEventUpdate'; /// 更新木牛流马
private GUILD_POP_UP_ACTIVITY = 'onActivityUpdate'; /// 向军团成员发送弹窗礼包
private GUILD_POP_UP_ACTIVITY = 'onActivityTaskUpdate'; /// 向军团成员发送弹窗礼包
private GUILD_TRAIN_RESET = 'onGuildTainReset'; // 试炼场重置
private GUILD_BOSS_ENCOURAGE = 'onGuildBossEncourage'; // 鼓舞
private AUCTION_UPDATE = 'onAuctionUpdate'; // 拍卖行更新

12
game-server/app/servers/role/handler/taskHandler.ts
View File

@@ -1,6 +1,6 @@
import { Application, BackendSession, pinus, HandlerService, } from "pinus";
import { resResult, parseGoodStr, getRandSingleEelm } from "../../../pubUtils/util";
import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from "../../../consts";
import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, ACTIVITY_TYPE } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { UserTaskRecModel } from "../../../db/UserTaskRec";
import { addItems } from "../../../services/rewardService";
@@ -9,12 +9,12 @@ import { nowSeconds, getZeroPointD } from "../../../pubUtils/timeUtil";
import { DicDailyTask, DicAchievement, DicMainTask } from "../../../pubUtils/dictionary/DicTask";
import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/taskService";
import { TASK } from "../../../pubUtils/dicParam";
import { newHeroGiftPoint } from "../../../services/activity/newHeroGiftsService";
import { ActivityTaskPointModel, ActivityTaskPointModelType } from "../../../db/ActivityTaskPoint";
import { ItemInter, RewardInter } from "../../../pubUtils/interface";
import { RoleModel } from "../../../db/Role";
import { roleLevelup } from "../../../services/normalBattleService";
import _ = require("underscore");
import { addActvityTaskPoint } from "../../../services/activity/activityService";
export default function (app: Application) {
new HandlerService(app, {});
@@ -79,12 +79,8 @@ export class ShopHandler {
}
//任务完成后关联活动的积分
let activityTaskPoint: ActivityTaskPointModelType[] = await ActivityTaskPointModel.findData(type, id);
for (let obj of activityTaskPoint) {
await newHeroGiftPoint(serverId, obj.activityId, roleId, obj.point);
let uids = [{ uid: roleId, sid }];
this.app.get('channelService').pushMessageByUids('addPoint', resResult(STATUS.SUCCESS, { activityId: obj.activityId, addPoint: point }), uids);
}
await addActvityTaskPoint(type, id, session );
let goods = await addItems(roleId, roleName, sid, taskReward, ITEM_CHANGE_REASON.TASK_REWARD);
if (expItem && expItem.count > 0) {

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

@@ -21,12 +21,12 @@ import { getPlayerDailyGKData } from './dailyGKService';
import { getPlayerRefreshShopData } from './refreshShopService';
import { getPlayerRefreshTaskData } from './refreshTaskService';
import { getPlayerMonopolyData } from './monopolyService';
import { getPlayerNewHeroGiftsData } from './newHeroGiftsService';
import { getPlayerNewHeroGiftsData, newHeroGiftPoint } from './newHeroGiftsService';
import { getPlayerNewHeroGKData } from './newHeroGKService';
import { getPlayerNewHeroGachaData } from './newHeroGachaService';
import { pinus } from 'pinus';
import { BackendSession, pinus } from 'pinus';
import { ActivityModel, ActivityModelType } from '../../db/Activity';
import { getRandSingleEelm } from '../../pubUtils/util';
import { getRandSingleEelm, resResult } from '../../pubUtils/util';
import { SignInData } from '../../domain/activityField/signInField';
import { ActivityGroupModel } from '../../db/ActivityGroup';
import { ActivityGroupTypeModel } from '../../db/ActivityGroupType';
@@ -34,6 +34,9 @@ import { ServerlistModel } from '../../db/Serverlist';
import { ActivityInRemote, transActivityInRemoteToModelType } from '../../domain/activityField/activityField';
import { getPlayerLuckyTurntableDataShow } from './luckyTurntableService';
import { getTimeLimitRankDataShow } from './timeLimitRankService';
import { ActivityTaskPointModel } from '../../db/ActivityTaskPoint';
import { getRoleOnlineInfo } from '../redisService';
import { addTaskPassPoint } from './taskPassService';
/**
* 获取活动数据
@@ -315,11 +318,65 @@ export async function checkActivityGroupType(groupType: number, activities: Acti
let index = dic.findIndex(cur => cur.activityType == type);
if(index == -1) {
return false;
} else {
dic.splice(index, 1);
}
}
}
return true
}
/**
* 达成任务可活动活动积分
* @param type 任务类型，主线、每日、成就
* @param id
* @param point
* @param session
*/
export async function addActvityTaskPoint(type: number, id: number, session: BackendSession) {
let serverId: number = session.get('serverId');
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let activityTaskPoint = await ActivityTaskPointModel.findData(type, id);
let result: pushActivityInter[] = [];
for (let { activityId, activityType, point } of activityTaskPoint) {
console.log('##### activityTaskPoint:', activityId, activityType, point)
if(activityType == ACTIVITY_TYPE.NEW_HERO_GIFTS) { // 新武将活动
let totalPoint = await newHeroGiftPoint(serverId, activityId, roleId, point);
result.push({ activityId, activityType, param: { totalPoint } });
} else if (activityType == ACTIVITY_TYPE.TASK_PASS) {
let totalPoint = await addTaskPassPoint(serverId, activityId, roleId, point);
result.push({ activityId, activityType, param: { totalPoint } });
} else {
break;
}
}
await pushActivities(result, roleId, sid);
}
interface pushActivityParamInter {
ticketCnt?: number; // 木签活动的签数(type21)
totalPoint?: number; // 新将好礼（type37）和战令（type42）更新后的积分
}
export interface pushActivityInter {
activityId: number,
activityType: number,
param: pushActivityParamInter;
}
export async function pushSingleActivity(activityId: number, activityType: number, param: pushActivityParamInter, roleId: string, sid?: string) {
await pushActivities([{ activityId, activityType, param }], roleId, sid);
}
export async function pushActivities(arr: pushActivityInter[], roleId: string, sid?: string) {
if(!sid) {
let onlineUser = await getRoleOnlineInfo(roleId);
sid = onlineUser.sid;
}
pinus.app.get('channelService').pushMessageByUids('onActivityUpdate',
resResult(STATUS.SUCCESS, {
activities: arr
}),
[{ uid: roleId, sid }]);
}

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

@@ -54,5 +54,6 @@ export async function getPlayerNewHeroGiftsData(activityId: number, serverId: nu
*
*/
export async function newHeroGiftPoint(serverId: number, activityId: number, roleId: string, addPoint: number) {
await ActivityNewHeroGiftModel.addPoint(serverId, activityId, roleId, addPoint);
let result = await ActivityNewHeroGiftModel.addPoint(serverId, activityId, roleId, addPoint);
return result.totalPoint;
}

19
game-server/app/services/activity/rechargeMoneyService.ts
View File

@@ -2,7 +2,9 @@ import { ActivityRechargeMoneyModel, ActivityRechargeMoneyModelType } from '../.
import { RechargeMoneyData } from '../../domain/activityField/rechargeMoneyField';
import moment = require('moment');
import { RoleModel } from '../../db/Role';
import { getActivityById } from './activityService';
import { getActivitiesByType, getActivityById, pushActivities, pushActivityInter } from './activityService';
import { ACTIVITY_TYPE } from '../../consts';
import { getRoleOnlineInfo } from '../redisService';
/**
* 玩家活动数据
@@ -43,6 +45,19 @@ export async function getPlayerRechargeMoneyDataShow(activityId: number, serverI
export async function addRechargeMoney(roleId: string, serverId: number, RMB: number) {
let beginTime = moment(new Date()).startOf('d').toDate();
let endTime = moment(new Date()).endOf('d').toDate();
await ActivityRechargeMoneyModel.addRMB(serverId, roleId, RMB, beginTime, endTime);
let result = await ActivityRechargeMoneyModel.addRMB(serverId, roleId, RMB, beginTime, endTime);
if(result.RMB == RMB) { // 获得木签的时候推送给在线玩家
let onlineUser = await getRoleOnlineInfo(roleId);
if(!!onlineUser.sid) {
let result: pushActivityInter[] = [];
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.RECHARGE_MONEY);
for(let { activityId, type: activityType } of activities) {
let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
result.push({ activityId, activityType, param: { ticketCnt: playerData.ticketCnt } });
}
await pushActivities(result, roleId, onlineUser.sid);
}
}
}

70
game-server/app/services/activity/taskPassService.ts Normal file
View File

@@ -0,0 +1,70 @@
import { ACTIVITY_TYPE, STATUS } from "../../consts";
import { ActivityModelType } from "../../db/Activity";
import { ActivityTaskPassModel } from "../../db/ActivityTaskPass";
import { RoleModel } from "../../db/Role";
import { TaskPassData } from "../../domain/activityField/taskPassField";
import { getActivityById } from "./activityService";
export async function getTaskPassData(activityId: number, serverId: number, roleId: string) {
let activityData = await getActivityById(activityId);
let { createTime } = await RoleModel.findByRoleId(roleId);
let playerData = new TaskPassData(activityData, createTime);
let record = await ActivityTaskPassModel.findData(serverId, activityId, roleId, playerData.roundIndex);
playerData.setPlayerRecord(record);
return playerData;
}
export async function getTaskPassDataShow(activityId: number, serverId: number, roleId: string) {
let playerData = await getTaskPassData(activityId, serverId, roleId);
if(playerData && playerData.canShow && playerData.canShow()) {
return playerData.getShowResult();
}
return null
}
/**
* 购买高级战令
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
* @param {string} productID 商品ID
*
*/
export async function makeTaskPass(roleId: string, roleName: string, sid: string, serverId: number, activityId: number, productID: string) {
let activityData: ActivityModelType = await getActivityById(activityId);
if (!activityData) {
return STATUS.ACTIVITY_MISSING;
}
if (activityData.type !== ACTIVITY_TYPE.TASK_PASS) {
return STATUS.ACTIVITY_TYPE_ERROR;
}
let { createTime } = await RoleModel.findByRoleId(roleId);
let playerData = new TaskPassData(activityData, createTime);
let roundIndex = playerData.roundIndex;
await ActivityTaskPassModel.buy(serverId, activityId, roleId, roundIndex, productID);
return {
code: 0,
data: Object.assign({}, { item: { roundIndex }, activityId: activityId })
}
}
/**
* 任务活动完成后会获得点数
*
* @param {number} serverId 区Id
* @param {number} activityId 活动Id
* @param {string} roleId 角色Id
*
*/
export async function addTaskPassPoint(serverId: number, activityId: number, roleId: string, addPoint: number) {
let activity = await getActivityById(activityId);
let { createTime } = await RoleModel.findByRoleId(roleId);
let data = new TaskPassData(activity, createTime);
let result = await ActivityTaskPassModel.addPoint(serverId, activityId, roleId, data.roundIndex, addPoint);
return result.totalPoint;
}

11
game-server/app/services/orderService.ts
View File

@@ -29,6 +29,7 @@ import { PayCallback37Data } from '../domain/sdk';
import { reportTAEvent, reportTAUserSet } from './sdkService';
import { savePayLog } from '../pubUtils/logUtil';
import { recordFirstGift } from './activity/firstGiftService';
import { makeTaskPass } from './activity/taskPassService';
/**
@@ -131,6 +132,12 @@ export async function makeOrder(orderInfo: UserOrderModelType, sid: string) {
rewardResult = await makeRefreshShopReward(roleId, roleInfo.roleName, sid, orderInfo.serverId, orderInfo.activityId, orderInfo.productID, 0)
break;
}
case ACTIVITY_TYPE.TASK_PASS: // 战令-高级卡
{
rewardResult = await makeTaskPass(roleId, roleInfo.roleName, sid, orderInfo.serverId, orderInfo.activityId, orderInfo.productID)
break;
}
default:
rewardResult = STATUS.ERROR_TYPE;
break;
@@ -171,8 +178,8 @@ export async function settleOrder(order: UserOrderModelType, serverId: number, s
}), [{ uid: order.roleId, sid }]);
}
//活动统计
await addRechargeMoney(order.roleId, serverId, order.price);
await addVipRechargeMoney(order.roleId, serverId, order.price);
addRechargeMoney(order.roleId, serverId, order.price);
addVipRechargeMoney(order.roleId, serverId, order.price);
//成长任务
await checkActivityTask(serverId, sid, order.roleId, TASK_TYPE.ACTIVITY_RMB, order.price, { activityId: order.activityId });
if(order.payType != PAY_TYPE.TEST) {

2
game-server/app/services/taskService.ts
View File

@@ -93,7 +93,7 @@ export async function pushActivityUpdate(roleId: string, sid: string, pushMessag
}
if (!!sid) {
let uids = [{ uid: roleId, sid }];
pinus.app.get('channelService').pushMessageByUids('onActivityUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
}
}
}

9
gm-server/app/service/Activity.ts
View File

@@ -162,13 +162,16 @@ export default class Activity extends Service {
});
}
public async createTaskToActivity(taskType: number, activityId: number) {
public async createTaskToActivity(type: number, activityId: number) {
const { ctx } = this;
let dicTask = gameData.tasks.get(taskType);
let dicTask = gameData.tasks.get(type);
if(!dicTask) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let activity = await ActivityModel.findActivity(activityId);
if(!activity) return ctx.service.utils.resResult(STATUS.ACTIVITY_MISSING);
for(let [id, dic] of dicTask) {
await ActivityTaskPointModel.createDataIfNotExist(taskType, id, activityId, dic['point']||0, ctx.user?.uid);
await ActivityTaskPointModel.createDataIfNotExist(type, dic.taskType, id, activityId, activity.type, dic['point']||0, ctx.user?.uid);
}
return ctx.service.utils.resResult(STATUS.SUCCESS);
}

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

@@ -54,6 +54,7 @@ export enum ACTIVITY_TYPE {
NEW_HERO_GACHA = 39, //新将擢迁（新武将抽卡）
LUCKY_TURNTABLE = 40, // 幸运转盘
TIME_LIMIT_RANK = 41, // 限时排行榜
TASK_PASS = 42, // 战令活动
}
/**
@@ -163,3 +164,7 @@ export const DAILYRMBGIFTS_DAYS = 7;//一次性购买*天
export const SIGNIN_OPEN = 1;//*号0点开启
export const SIGNIN_CLOSE = 31;//*号晚上24点结束
export enum TASK_PASS_TYPE {
STANDARD = 1, // 标准版，不付钱
VIP = 2, // 要付钱
}

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

@@ -1003,6 +1003,8 @@ export enum ITEM_CHANGE_REASON {
COMPOSE_STONE = 139, // 合成地玉石
REBIRTH = 140, // 武将重生
ACT_TURNTABLE_PULL = 141, // 转盘
ACT_TASK_PASS = 142, // 活动-战令奖励
ACT_TASK_PASS_SPD_UP = 143, // 活动-战令加速
}
export enum TA_EVENT {

1
shared/consts/statusCode.ts
View File

@@ -448,6 +448,7 @@ export const STATUS = {
NOT_GIFTPACKAGE: { code: 50033, simStr: '非礼包类型' },
SHOP_CLOSED: { code: 50034, simStr: '停业' },
ACTIVITY_RECHARGE_ITEM_NOT_ENOUGH: { code: 50035, simStr: '商品不足' },
ACTIVITY_ITEM_CANNOT_RECEIVE: { code: 50036, simStr: '无可领取物品' },
// GM后台相关状态 60000 - 69999
GM_ERR_PASSWORD: { code: 60001, simStr: '账号或密码错误' },
GM_MISS_API: { code: 60002, simStr: '未找到该接口' },

75
shared/db/ActivityTaskPass.ts Normal file
View File

@@ -0,0 +1,75 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
export class ReceivedReward {
@prop({ required: true })
pageIndex: number;
@prop({ required: true })
lv: number;
@prop({ required: true })
receiveTime: number;
}
/**
* 30天目标活动
*/
@index({ roleId: 1, activityId: 1, serverId: 1 })
export default class Activity_Task_Pass extends BaseModel {
@prop({ required: true })
serverId: number; // 服Id
@prop({ required: true })
activityId: number; // 活动Id
@prop({ required: true })
roleId: string; // 用户Id
@prop({ required: true })
roundIndex: number; // 第几轮
@prop({ required: true, type: String })
productIDs: string[]; // 购买记录
@prop({ required: true, type: ReceivedReward, _id: false })
receivedReward: ReceivedReward[]; // 领取了的奖励
@prop({ required: true })
spdUpCnt: number; // 加速次数
@prop({ required: true })
totalPoint: number; // 获得总点数
// 寻找记录
public static async findData(serverId: number, activityId: number, roleId: string, roundIndex: number) {
let result: ActivityTaskPassModelType = await ActivityTaskPassModel.findOne({ serverId, activityId, roleId, roundIndex }).lean();
return result;
}
// 增加点数
public static async addPoint(serverId: number, activityId: number, roleId: string, roundIndex: number, addPoint: number, spdUpCnt = 0) {
let result: ActivityTaskPassModelType = await ActivityTaskPassModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex },
{ $inc: { totalPoint: addPoint, spdUpCnt } }, { upsert: true, new: true }).lean(true);
return result;
}
//添加购买记录
public static async buy(serverId: number, activityId: number, roleId: string, roundIndex: number, productID: string) {
let result: ActivityTaskPassModelType = await ActivityTaskPassModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex },
{ $addToSet: { productIDs: productID } }, { upsert: true, new: true }).lean(true);
return result;
}
public static async receiveItems(serverId: number, activityId: number, roleId: string, roundIndex: number, receiveReward: ReceivedReward[]) {
let result: ActivityTaskPassModelType = await ActivityTaskPassModel.findOneAndUpdate({ serverId, roleId, activityId, },
{ $push: { receiveReward } }, { upsert: true, new: true }).lean(true);
return result;
}
}
export const ActivityTaskPassModel = getModelForClass(Activity_Task_Pass);
export interface ActivityTaskPassModelType extends Pick<DocumentType<Activity_Task_Pass>, keyof Activity_Task_Pass> { }
export type ActivityTaskPassModelTypeParam = Partial<ActivityTaskPassModelType>; // 将所有字段变成可选项

23
shared/db/ActivityTaskPoint.ts
View File

@@ -11,37 +11,42 @@ export default class Activity_Task_Point extends BaseModel {
// @prop({ required: true })
// serverId: number; // 服Id
@prop({ required: true })
taskType: number; // 任务类型TASK_FUN_TYPE 1.主线，2每日，3.成就
type: number; // 任务类型TASK_FUN_TYPE 1.主线，2每日，3.成就
@prop({ required: true })
taskType: number; // 任务type TASK_TYPE
@prop({ required: true })
taskId: number; // 任务id
@prop({ required: true })
activityId: number; // 关联的活动id
@prop({ required: true })
activityType: number; // 活动类型
@prop({ required: true })
point: number; // 增加点数
//更新活动数据
public static async updateData(taskType: number, taskId: number, activityId: number, point: number, uid = 1) {
public static async updateData(type: number, taskId: number, activityId: number, point: number, uid = 1) {
let result: ActivityTaskPointModelType = await ActivityTaskPointModel.findOneAndUpdate(
{ taskType, taskId, activityId }, { $set: { point, updatedBy: uid }, $setOnInsert: { createdBy: uid } }, { upsert: true, new: true }
{ type, taskId, activityId }, { $set: { point, updatedBy: uid }, $setOnInsert: { createdBy: uid } }, { upsert: true, new: true }
).lean(true);
return result;
}
//查询数据
public static async findData(taskType: number, taskId: number) {
public static async findData(type: number, taskId: number) {
let result: ActivityTaskPointModelType[] = await ActivityTaskPointModel.find(
{ taskType, taskId }).lean(true);
{ type, taskId }).lean(true);
return result;
}
//删除数据
public static async deleteData(taskType: number, taskId: number, activityId: number) {
await ActivityTaskPointModel.deleteOne({ taskType, taskId, activityId });
public static async deleteData(type: number, taskId: number, activityId: number) {
await ActivityTaskPointModel.deleteOne({ type, taskId, activityId });
}
public static async createDataIfNotExist(taskType: number, taskId: number, activityId: number, point: number, uid = 1) {
public static async createDataIfNotExist(type: number, taskType: number, taskId: number, activityId: number, activityType: number, point: number, uid = 1) {
let result: ActivityTaskPointModelType = await ActivityTaskPointModel.findOneAndUpdate(
{ taskType, taskId, activityId }, { $setOnInsert: { point, createdBy: uid, updatedBy: uid } }, { upsert: true, new: true }
{ type, taskId, activityId }, { $setOnInsert: { point, createdBy: uid }, $set: { taskType, activityType, updatedBy: uid } }, { upsert: true, new: true }
).lean(true);
return result;
}

238
shared/domain/activityField/taskPassField.ts Normal file
View File

@@ -0,0 +1,238 @@
import { pick } from 'underscore';
import { TASK_PASS_TYPE } from '../../consts';
import { ActivityModelType } from '../../db/Activity';
import { ActivityTaskPassModelType } from '../../db/ActivityTaskPass';
import { ActivityBase } from './activityField';
interface TaskPassProgressInDb { // 进度
lv: number; // 等级
point: number; // 到达下一级所需的积分
}
interface TaskPassRewardItemInDb {
lv: number;
reward: string;
needShow: boolean;
}
interface TaskPassRewardsInDb {
pageIndex: number;
type: number; // 1-标准版 2-豪华版
price: number; // 花多少钱
productID: string; // 商品id，如果是标准版这里填&
items: TaskPassRewardItemInDb[];
}
interface TaskPassSpdUpInDb {
cost: string;
point: number;
}
interface TaskPassDataInDb {
progress: TaskPassProgressInDb[];
rewards: TaskPassRewardsInDb[];
spdUp: TaskPassSpdUpInDb;
}
export class TaskPassProgress {
lv: number;
point: number;
constructor(data: TaskPassProgressInDb) {
this.lv = data.lv;
this.point = data.point;
}
}
export class TaskPassRewardItem {
lv: number;
reward: string;
needShow: boolean;
hasReceived: boolean = false;
constructor(item: TaskPassRewardItemInDb) {
this.lv = item.lv;
this.reward = item.reward;
this.needShow = item.needShow;
}
setHasReceived(hasReceived: boolean) {
this.hasReceived = hasReceived;
}
}
export class TaskPassReward {
pageIndex: number; // 第几页
type: number; // 1-标准版 2-豪华版
price: number; // 花多少钱
productID: string; // 商品id，如果是标准版这里填&
items: TaskPassRewardItem[] = [];
hasBuy: boolean = false; // 是否购买了
map: Map<number, number> = new Map(); // lv => index
constructor(reward: TaskPassRewardsInDb) {
this.pageIndex = reward.pageIndex;
this.type = reward.type;
this.price = reward.price;
this.productID = reward.productID;
for(let item of reward.items) {
let obj = new TaskPassRewardItem(item);
this.items.push(obj);
this.map.set(obj.lv, this.items.length - 1);
}
}
findItemByLv(lv: number) {
let index = this.map.get(lv);
return this.items[index];
}
setPlayerRecord(record: ActivityTaskPassModelType) {
if(record.productIDs && record.productIDs.indexOf(this.productID) != -1) {
this.hasBuy = true;
}
if(record.receivedReward) {
for(let { pageIndex, lv } of record.receivedReward) {
if(pageIndex == this.pageIndex) {
let item = this.findItemByLv(lv);
item.setHasReceived(true);
}
}
}
}
getShowResult() {
return pick(this, ['pageIndex', 'type', 'price', 'productID', 'items', 'hasBuy']);
}
canReceiveItems() {
if(this.type == TASK_PASS_TYPE.VIP) {
if(!this.hasBuy) return false;
}
return true;
}
}
export class TaskPassSpdUp {
cost: string;
point: number;
spdUpCnt: number = 0; // 加速过的次数
constructor(obj: TaskPassSpdUpInDb) {
this.cost = obj.cost;
this.point = obj.point;
}
setSpdUpCnt(cnt: number) {
this.spdUpCnt = cnt;
}
addSpdUpCnt(cnt: number) {
this.spdUpCnt += cnt;
}
}
// 战令活动数据
export class TaskPassData extends ActivityBase {
progress: TaskPassProgress[] = [];
rewards: TaskPassReward[] = [];
spdUp: TaskPassSpdUp;
lv: number = 1;
totalPoint: number = 0;
map: Map<number, number> = new Map(); // pageIndex => rewards的index
constructor(activityData: ActivityModelType, createTime: number) {
super(activityData, createTime)
this.initData(activityData.data)
}
public initData(data: string) {
let dataObj: TaskPassDataInDb = JSON.parse(data);
for(let obj of dataObj.progress) {
this.progress.push(new TaskPassProgress(obj));
}
for(let obj of dataObj.rewards) {
let reward = new TaskPassReward(obj);
this.rewards.push(reward);
this.map.set(reward.pageIndex, this.rewards.length - 1);
}
this.spdUp = new TaskPassSpdUp(dataObj.spdUp);
}
public setPlayerRecord(record: ActivityTaskPassModelType) {
if(!record) return null;
this.setLvByPoint(record.totalPoint);
for(let reward of this.rewards) {
reward.setPlayerRecord(record);
}
this.spdUp.setSpdUpCnt(record.spdUpCnt);
}
public getShowResult() {
return {
...this.getBaseKeys(),
progress: this.progress,
rewards: this.rewards.map(reward => reward.getShowResult()),
spdUp: this.spdUp,
lv: this.lv,
totalPoint: this.totalPoint,
}
}
private setLvByPoint(totalPoint: number) {
this.totalPoint = totalPoint;
for(let { lv, point } of this.progress) {
this.lv = lv;
totalPoint -= point;
if(totalPoint < 0) break;
}
}
public findRewardByPageIndex(pageIndex: number) {
let index = this.map.get(pageIndex);
return this.rewards[index];
}
// 领取道具
public receiveItems(pageIndex: number, lv: number) {
let reward = this.findRewardByPageIndex(pageIndex);
if(!reward) return false;
if(!reward.canReceiveItems()) return false;
let items: TaskPassRewardItem[] = [];
if(lv == 0) {
for(let item of reward.items) {
if(item.lv <= this.lv && !item.hasReceived) {
item.setHasReceived(true);
items.push(item);
}
}
} else {
let item = reward.findItemByLv(lv);
if(!item.hasReceived) {
item.setHasReceived(true);
items.push(item);
}
}
if(items.length <= 0) return false;
return items
}
// 加速
public addPoint(point: number, count: number) {
this.spdUp.addSpdUpCnt(count)
this.setLvByPoint(this.totalPoint + point);
return {
lv: this.lv,
totalPoint: this.totalPoint,
spdUpCnt: this.spdUp.spdUpCnt
}
}
}

2
shared/pubUtils/roleUtil.ts
View File

@@ -344,7 +344,7 @@ export class CreateHeroes extends UpdateHeroes {
let uids = [{ uid: this.roleId, sid }];
pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: reduceCe(role.ce) , heros: this.pushHeroes.map(cur => { return {...cur, ce: reduceCe(cur.ce), incHeroCe: reduceCe(cur.incHeroCe) }}), topLineupCe: reduceCe(role.topLineupCe) }), uids);
pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, this.taskPushMessage), uids);
pinus.app.get('channelService').pushMessageByUids('onActivityUpdate', resResult(STATUS.SUCCESS, this.activityTaskPushMessage), uids);
pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, this.activityTaskPushMessage), uids);
let figureInfo = combineFigureInfo(this.figureInfos);
if (!!figureInfo && (figureInfo.heads.length > 0 || figureInfo.frames.length > 0 || figureInfo.spines.length > 0)) {
pinus.app.get('channelService').pushMessageByUids('onHeadChange', resResult(STATUS.SUCCESS, { ...figureInfo }), uids);

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

@@ -244,5 +244,11 @@
"activityType": 41,
"name": "TIME_LIMIT_RANK",
"string": "限时排行榜"
},
{
"id": 42,
"activityType": 42,
"name": "TASK_PASS",
"string": "战令"
}
]

177
shared/resource/jsons/dic_zyz_rmb.json
View File

@@ -23,7 +23,7 @@
{
"productID": "com.bantu.sgzzyz.yb4",
"type": 18,
"price": 0.01,
"price": 6,
"message": "充值元宝-购买元宝60",
"gameCoin": 60
},
@@ -46,7 +46,7 @@
"type": 18,
"price": 198,
"message": "充值元宝-购买元宝1980",
"gameCoin": 1980
"gameCoin": 7980
},
{
"productID": "com.bantu.sgzzyz.yb8",
@@ -231,169 +231,15 @@
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-1",
"productID": "com.bantu.sgzzyz.yb34",
"type": 24,
"price": 198,
"message": "弹出礼包-图纸任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-2",
"type": 24,
"price": 198,
"message": "弹出礼包-宝石任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-3",
"type": 24,
"price": 198,
"message": "弹出礼包-将魂任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-4",
"type": 24,
"price": 198,
"message": "弹出礼包-装备任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-5",
"type": 24,
"price": 198,
"message": "弹出礼包-武将任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-6",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-7",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-8",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-9",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-10",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-11",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-12",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-13",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-14",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-15",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-16",
"type": 24,
"price": 198,
"message": "弹出礼包-皮肤任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-17",
"type": 24,
"price": 198,
"message": "弹出礼包-将魂任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-18",
"type": 24,
"price": 98,
"message": "弹出礼包-精炼任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-19",
"type": 24,
"price": 98,
"message": "弹出礼包-图纸任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-20",
"type": 24,
"price": 98,
"message": "弹出礼包-图纸任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-21",
"type": 24,
"price": 98,
"message": "弹出礼包-藏宝图任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-22",
"type": 24,
"price": 98,
"message": "弹出礼包-装备养成任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb34-23",
"type": 24,
"price": 98,
"message": "弹出礼包-功勋任选礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb35",
"type": 5,
"type": 2,
"price": 198,
"message": "高级签到",
"gameCoin": 1
@@ -401,7 +247,7 @@
{
"productID": "com.bantu.sgzzyz.yb36",
"type": 22,
"price": 60,
"price": 10,
"message": "活动每日特惠-一次性买7天",
"gameCoin": 1
},
@@ -615,18 +461,25 @@
"message": "活动-精英成长基金（高阶）",
"gameCoin": 1
},
{
{
"productID": "com.bantu.sgzzyz.yb37-1",
"type": 33,
"price": 98,
"message": "春节节日活动-节日物资装备提升礼包",
"gameCoin": 1
},
{
{
"productID": "com.bantu.sgzzyz.yb37-2",
"type": 33,
"price": 328,
"price": 98,
"message": "春节节日活动-节日物资装备晋升礼包",
"gameCoin": 1
},
{
"productID": "com.bantu.sgzzyz.yb38",
"type": 42,
"price": 198,
"message": "夕蕊令",
"gameCoin": 1
}
]