This commit is contained in:
xy
2026-03-13 01:38:40 +00:00
parent e6e4f88257
commit 28855885cd
311 changed files with 89544 additions and 94350 deletions

View File

@@ -12,7 +12,7 @@
`cd game-server && node tsrun.js`
## 运行 web-server
`cd web-server && node app`
`cd web-server && node dev`
cd 到 web-server下面
`npm run stop && npm run tsc && npm run start`
@@ -28,3 +28,12 @@ cd 到 web-server下面
`pm2 start ./dist/app.js --name="activity-server-2" -x -- env=dev id=activity-server-2 host=172.26.145.171 port=9061 serverType=activity`
`pm2 start ./dist/app.js --name="connector-server-4" -x -- env=alpha id=connector-server-4 host=172.26.145.171 port=9062 clientHost=121.89.211.172 clientPort=3050 serverType=connector frontend=true`
8.主机部分的server.ts内的server如果需要做rpc remotehost需要从127.0.0.1改为私网地址
---
web-server
`cd web-server`
`HOME=/root node node_modules/.bin/egg-bin dev`

View File

@@ -1,7 +1,7 @@
require('xprofiler').start({
log_dir: '/zyz_logs/xprofiler',
});
import { COM_TEAM_STATUS, STATUS } from './app/consts';
import { COM_TEAM_STATUS, STATUS } from '@consts';
import {
createTcpAcceptor,
createTcpMailBox,
@@ -19,17 +19,17 @@ import { preload } from './preload';
import { globalFilter } from'./app/servers/connector/filter/global';
import { guildAuthFilter } from'./app/servers/guild/filter/guildAuthFilter';
import { tokenFilter } from'./app/servers/gm/filter/tokenFilter';
import { connectRedis } from './app/pubUtils/redis';
import { connectRedis } from '@pubUtils/redis';
import * as timeTaskService from './app/services/timeTaskService';
import * as redlockCacheService from './app/services/redlockCacheService';
import * as redLockService from './app/services/redLockService';
// TODO 需要整理。
import _pinus = require('pinus');
import { updateTeamStatus } from './app/services/battle/comBattleService';
import { resResult, genCode } from './app/pubUtils/util';
import { resResult, genCode } from '@pubUtils/util';
import { errlogger, infologger, loadLogger } from './app/util/logger';
import { connectThinkingData, getTire } from './app/services/sdkService';
import { loadSubDb, loadGmDb } from './app/db';
import { loadSubDb, loadGmDb } from '@db';
import { loadActivities } from './app/services/memoryCache/activityData';
import { checkAndSetApiIsClose } from './app/services/chatService';
import { initGuildActivityIndexInPinus, resetJoinWoodenHorse } from './app/services/guildActivity/guildActivityService';
@@ -307,6 +307,7 @@ function setupFilters(app: _pinus.Application) {
app.filter(new pinus.filters.time());
app.filter(new pinus.filters.timeout());
// @ts-ignore
app.filter(globalFilter(app));
app.globalAfter((err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, cb: HandlerCallback) => {
if (err) infologger.debug(err);

View File

@@ -1,43 +1,43 @@
import { Application, IComponent } from "pinus";
export class EvalComponent implements IComponent {
name = "EvalComponent";
app: Application;
constructor(app: Application) {
this.app = app;
this.app.set(this.name, this);
}
start(cb: () => void) {
console.log("EvalComponent start", this.app.getServerId());
cb();
}
stop(force: boolean, cb: () => void) {
console.log("EvalComponent stop", force, this.app.getServerId());
cb();
}
eval(script: string, cb: (err, res?) => void) {
try {
// 检查 script 的开头是否由 MagicCode 开头
const MagicCode = "BantuYJZ23:";
if (!script.startsWith(MagicCode)) {
// 没有权限
cb("auth failed");
return;
}
// 去掉 MagicCodesubstr 已经不被支持
const code = script.slice(MagicCode.length);
// ! 执行代码
const result = eval(code);
cb(null, result);
} catch (error) {
console.log("EvalComponent eval", this.app.getServerId(), error)
cb(error);
return;
}
}
}
import { Application, IComponent } from "pinus";
export class EvalComponent implements IComponent {
name = "EvalComponent";
app: Application;
constructor(app: Application) {
this.app = app;
this.app.set(this.name, this);
}
start(cb: () => void) {
console.log("EvalComponent start", this.app.getServerId());
cb();
}
stop(force: boolean, cb: () => void) {
console.log("EvalComponent stop", force, this.app.getServerId());
cb();
}
eval(script: string, cb: (err, res?) => void) {
try {
// 检查 script 的开头是否由 MagicCode 开头
const MagicCode = "BantuYJZ23:";
if (!script.startsWith(MagicCode)) {
// 没有权限
cb("auth failed");
return;
}
// 去掉 MagicCodesubstr 已经不被支持
const code = script.slice(MagicCode.length);
// ! 执行代码
const result = eval(code);
cb(null, result);
} catch (error) {
console.log("EvalComponent eval", this.app.getServerId(), error)
cb(error);
return;
}
}
}

View File

@@ -1,49 +1,49 @@
import { Application, IComponent, manualReloadCrons, manualReloadHandlers, manualReloadRemoters } from "pinus";
export class UpdateComponent implements IComponent {
name = "UpdateComponent";
app: Application;
constructor(app: Application) {
this.app = app;
this.app.set(this.name, this);
}
start(cb: () => void) {
console.log("UpdateComponent start", this.app.getServerId());
cb();
}
stop(force: boolean, cb: () => void) {
console.log("UpdateComponent stop", force, this.app.getServerId());
cb();
}
hotupdate(files: string, cb: (err, res?) => void) {
try {
const filelist = files.split(",");
for (let i = 0; i < filelist.length; i++) {
const file = this.app.getBase() + filelist[i];
if (!file || !require.cache[file]) {
console.log("UpdateComponent hotupdate", this.app.getServerId(), "file not exist", file);
cb("file not exist");
return;
}
}
for (let i = 0; i < filelist.length; i++) {
const file = this.app.getBase() + filelist[i];
delete require.cache[file];
console.log("UpdateComponent hotupdate", this.app.getServerId(), file)
}
manualReloadHandlers(this.app);
manualReloadRemoters(this.app);
manualReloadCrons(this.app);
cb(null, "success");
} catch (error) {
console.log("UpdateComponent hotupdate", this.app.getServerId(), error)
cb(error);
return;
}
}
}
import { Application, IComponent, manualReloadCrons, manualReloadHandlers, manualReloadRemoters } from "pinus";
export class UpdateComponent implements IComponent {
name = "UpdateComponent";
app: Application;
constructor(app: Application) {
this.app = app;
this.app.set(this.name, this);
}
start(cb: () => void) {
console.log("UpdateComponent start", this.app.getServerId());
cb();
}
stop(force: boolean, cb: () => void) {
console.log("UpdateComponent stop", force, this.app.getServerId());
cb();
}
hotupdate(files: string, cb: (err, res?) => void) {
try {
const filelist = files.split(",");
for (let i = 0; i < filelist.length; i++) {
const file = this.app.getBase() + filelist[i];
if (!file || !require.cache[file]) {
console.log("UpdateComponent hotupdate", this.app.getServerId(), "file not exist", file);
cb("file not exist");
return;
}
}
for (let i = 0; i < filelist.length; i++) {
const file = this.app.getBase() + filelist[i];
delete require.cache[file];
console.log("UpdateComponent hotupdate", this.app.getServerId(), file)
}
manualReloadHandlers(this.app);
manualReloadRemoters(this.app);
manualReloadCrons(this.app);
cb(null, "success");
} catch (error) {
console.log("UpdateComponent hotupdate", this.app.getServerId(), error)
cb(error);
return;
}
}
}

View File

@@ -1,76 +1,76 @@
import { Application, IModule, MonitorCallback, MasterCallback, MonitorAgent, MasterAgent } from "pinus";
export class UsrAdminModule implements IModule {
app: Application;
root: string;
static moduleId = 'UsrAdmin';
constructor(opts: { app: Application, path: string }) {
this.app = opts.app;
this.root = opts.path;
}
masterHandler(agent: MasterAgent, msg: any, cb: MasterCallback) {
console.log("enter masterHandler", msg);
}
monitorHandler(agent: MonitorAgent, msg: { action: string, script: string, serverId: string }, cb: MonitorCallback) {
console.log("enter monitorHandler", msg);
if (['master'].includes(this.app.getServerType())) {
console.log('scripts module can not be loaded on master');
return;
}
switch (msg.action) {
case 'hotupdate':
this.app.get('UpdateComponent').hotupdate(msg.script, (err, res) => {
if (err) {
console.log("hotupdate error", err);
cb(err);
return;
}
console.log("hotupdate success", res);
cb(null, res);
});
break;
case 'eval':
this.app.get('EvalComponent').eval(msg.script, (err, res) => {
if (err) {
console.log("eval error", err);
cb(err);
return;
}
console.log("eval success", res);
cb(null, res);
});
break;
default:
break;
}
}
clientHandler(agent: MasterAgent, msg: { action: string, script: string, serverId: string }, cb: MasterCallback) {
const { action, serverId } = msg;
switch (action) {
case 'hotupdate':
agent.notifyAll(UsrAdminModule.moduleId, msg);
cb(null, 'success notifyAll servers');
break;
case 'eval':
agent.request(serverId, UsrAdminModule.moduleId, msg, (err, res) => {
if (err) {
console.log("eval error", err);
cb(err, res);
return;
}
console.log("eval success", res);
cb(null, res);
});
break;
default:
break;
}
}
}
import { Application, IModule, MonitorCallback, MasterCallback, MonitorAgent, MasterAgent } from "pinus";
export class UsrAdminModule implements IModule {
app: Application;
root: string;
static moduleId = 'UsrAdmin';
constructor(opts: { app: Application, path: string }) {
this.app = opts.app;
this.root = opts.path;
}
masterHandler(agent: MasterAgent, msg: any, cb: MasterCallback) {
console.log("enter masterHandler", msg);
}
monitorHandler(agent: MonitorAgent, msg: { action: string, script: string, serverId: string }, cb: MonitorCallback) {
console.log("enter monitorHandler", msg);
if (['master'].includes(this.app.getServerType())) {
console.log('scripts module can not be loaded on master');
return;
}
switch (msg.action) {
case 'hotupdate':
this.app.get('UpdateComponent').hotupdate(msg.script, (err, res) => {
if (err) {
console.log("hotupdate error", err);
cb(err);
return;
}
console.log("hotupdate success", res);
cb(null, res);
});
break;
case 'eval':
this.app.get('EvalComponent').eval(msg.script, (err, res) => {
if (err) {
console.log("eval error", err);
cb(err);
return;
}
console.log("eval success", res);
cb(null, res);
});
break;
default:
break;
}
}
clientHandler(agent: MasterAgent, msg: { action: string, script: string, serverId: string }, cb: MasterCallback) {
const { action, serverId } = msg;
switch (action) {
case 'hotupdate':
agent.notifyAll(UsrAdminModule.moduleId, msg);
cb(null, 'success notifyAll servers');
break;
case 'eval':
agent.request(serverId, UsrAdminModule.moduleId, msg, (err, res) => {
if (err) {
console.log("eval error", err);
cb(err, res);
return;
}
console.log("eval success", res);
cb(null, res);
});
break;
default:
break;
}
}
}

View File

@@ -1,118 +1,119 @@
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ENCRYPT_IV, ENCRYPT_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { getActivitiesWithOrder, getActivity, getActivityById, getActivityByServerId, shouldReplace } from '../../../services/activity/activityService';
import { ActivityModelType } from '../../../db/Activity';
import { UserOrderModel } from '../../../db/UserOrder';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityHandler(app);
}
export class ActivityHandler {
constructor(private app: Application) {
}
/**
* @description 活动是否开启总接口
* @param {{ }} msg
* @param {BackendSession} session
* @memberof ActivityHandler
*/
async getAllOpenActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid: number = session.get('userid');
const sid: string = session.get('sid');
let originActivities = await getActivityByServerId(serverId);
let maxIdByType = new Map<number, number>(); // type => max
let activityById = new Map<number, any>(); // id => activity
for(let activity of originActivities) {
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activity.activityId, activity.type);
if(!playerActivityData) continue;
let shouldPush = true;
if(shouldReplace(playerActivityData.type)) { // 该类型只能有一个id选最大的那个
let max = maxIdByType.get(playerActivityData.type)||0;
if(playerActivityData.activityId > max) {
activityById.delete(max);
maxIdByType.set(playerActivityData.type, playerActivityData.activityId);
} else {
shouldPush = false;
}
}
if(shouldPush) activityById.set(activity.activityId, playerActivityData);
}
let groups = await ActivityGroupModel.findByServerId(serverId);
let playerGroupArray = [];
for (let groupData of groups) {
let playerGroupActivityArray = [];
for (let activityId of groupData.activities) {
let playerActivityData = activityById.get(activityId);
if(playerActivityData) {
playerGroupActivityArray.push(playerActivityData);
}
}
if(playerGroupActivityArray.length > 0)
playerGroupArray.push({
id: groupData.groupId,
type: groupData.type,
activities: playerGroupActivityArray
});
console.log(`${roleId} 活动合集 groupId:${groupData.groupId}, 合集类型${groupData.type}, 一共${playerGroupActivityArray.length}`)
}
return resResult(STATUS.SUCCESS, { playerActivityArray: [], playerGroupArray });
}
async getActivitiesByOrder(msg: { localOrderID: string }, session: BackendSession) {
const { localOrderID } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid = session.get('userid');
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo || orderInfo.roleId != roleId) {
return resResult(STATUS.NO_ORDER);
}
let activities: ActivityModelType[] = await getActivitiesWithOrder(orderInfo);
let result = [];
for(let activityData of activities) {
if (!activityData) continue;
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activityData.activityId, activityData.type);
if(playerActivityData) {
result.push(playerActivityData);
}
}
return resResult(STATUS.SUCCESS, { activities: result });
}
async debugActivityMemory(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let activities = pinus.app.get('activities');
let activityByType = pinus.app.get('activityByType');
let activityByServer = pinus.app.get('activityByServer');
let groupToServer = pinus.app.get('groupToServer');
console.log('****** activities', activities);
console.log('****** activityByType', activityByType);
console.log('****** activityByServer', activityByServer);
console.log('****** groupToServer', groupToServer);
return resResult(STATUS.SUCCESS, { activities: [...activities], activityByType: [...activityByType], activityByServer: [...activityByServer], groupToServer: [...groupToServer] });
}
}
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ENCRYPT_IV, ENCRYPT_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { getActivitiesWithOrder, getActivity, getActivityById, getActivityByServerId, shouldReplace } from '../../../services/activity/activityService';
import { ActivityModelType } from '@db/Activity';
import { UserOrderModel } from '@db/UserOrder';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityHandler(app);
}
export class ActivityHandler {
constructor(private app: Application) {
}
/**
* @description 活动是否开启总接口
* @param {{ }} msg
* @param {BackendSession} session
* @memberof ActivityHandler
*/
async getAllOpenActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid: number = session.get('userid');
const sid: string = session.get('sid');
let originActivities = await getActivityByServerId(serverId);
let maxIdByType = new Map<number, number>(); // type => max
let activityById = new Map<number, any>(); // id => activity
for(let activity of originActivities) {
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activity.activityId, activity.type);
if(!playerActivityData) continue;
let shouldPush = true;
if(shouldReplace(playerActivityData.type)) { // 该类型只能有一个id选最大的那个
let max = maxIdByType.get(playerActivityData.type)||0;
if(playerActivityData.activityId > max) {
activityById.delete(max);
maxIdByType.set(playerActivityData.type, playerActivityData.activityId);
} else {
shouldPush = false;
}
}
if(shouldPush) activityById.set(activity.activityId, playerActivityData);
}
let groups = await ActivityGroupModel.findByServerId(serverId);
let playerGroupArray = [];
for (let groupData of groups) {
let playerGroupActivityArray = [];
for (let activityId of groupData.activities) {
let playerActivityData = activityById.get(activityId);
if(playerActivityData) {
playerGroupActivityArray.push(playerActivityData);
}
}
if(playerGroupActivityArray.length > 0)
playerGroupArray.push({
id: groupData.groupId,
type: groupData.type,
activities: playerGroupActivityArray
});
console.log(`${roleId} 活动合集 groupId:${groupData.groupId}, 合集类型${groupData.type}, 一共${playerGroupActivityArray.length}`)
}
return resResult(STATUS.SUCCESS, { playerActivityArray: [], playerGroupArray });
}
async getActivitiesByOrder(msg: { localOrderID: string }, session: BackendSession) {
const { localOrderID } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid = session.get('userid');
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo || orderInfo.roleId != roleId) {
return resResult(STATUS.NO_ORDER);
}
let activities: ActivityModelType[] = await getActivitiesWithOrder(orderInfo);
let result = [];
for(let activityData of activities) {
if (!activityData) continue;
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activityData.activityId, activityData.type);
if(playerActivityData) {
result.push(playerActivityData);
}
}
return resResult(STATUS.SUCCESS, { activities: result });
}
async debugActivityMemory(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let activities = pinus.app.get('activities');
let activityByType = pinus.app.get('activityByType');
let activityByServer = pinus.app.get('activityByServer');
let groupToServer = pinus.app.get('groupToServer');
console.log('****** activities', activities);
console.log('****** activityByType', activityByType);
console.log('****** activityByServer', activityByServer);
console.log('****** groupToServer', groupToServer);
return resResult(STATUS.SUCCESS, { activities: [...activities], activityByType: [...activityByType], activityByServer: [...activityByServer], groupToServer: [...groupToServer] });
}
}

View File

@@ -1,251 +1,252 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { LAND_TYPE, STATUS, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../../../db/ActivityMonopoly';
import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../../../db/ActivityMonopolyLand';
import { getPlayerMonopolyData, nextPosition } from '../../../services/activity/monopolyService';
import { random } from 'underscore';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRefreshShopDataByRoundIndex } from '../../../services/activity/refreshShopService';
import { ActivityRefreshShopModel } from '../../../db/ActivityRefreshShop';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityMonopolyHandler(app);
}
export class ActivityMonopolyHandler {
constructor(private app: Application) {
}
/**
* @description 获取大富翁活动数据
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async getMonopolyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 移动
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async move(msg: { activityId: number, step: number }, session: BackendSession) {
const { activityId, step } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
const roleName = session.get('roleName');
let moveStep = 0;
if (step >= 1 && step <= 6) {//指定,天机骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.SPECIAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = step;
} else {//普通骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.NORMAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = random(5) + 1;
}
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let oldPosition = playerData.curPosition;
let newPosition = nextPosition(oldPosition, moveStep, playerData.list.length);
await ActivityMonopolyModel.updatePosition(serverId, activityId, roleId, newPosition, 1)
let landData = playerData.findMonopolyItem(newPosition);
let landReward = null;//土地奖励
let bankReward = null;//银行奖励
if (landData && landData.landType == LAND_TYPE.BANK_NORMAL) {
//土地奖励
if (landData.rewards.length > landData.stopCount) {
let reward = landData.rewards[landData.level - 1];
let rewardArray = stringToRewardParam(reward)
landReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
}
//土地升级
if (landData.rewards.length > landData.level) {
let newLevel = landData.level + 1;
await ActivityMonopolyLandModel.updateLevel(serverId, activityId, roleId, newPosition, newLevel)
landData.level = newLevel;
}
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
} else if (landData && ((landData.landType == LAND_TYPE.BANK_COIN) || (landData.landType == LAND_TYPE.BANK_GOLD))) {
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
}
await ActivityMonopolyLandModel.updateStopCount(serverId, activityId, roleId, newPosition);
landData.stopCount += 1;
return resResult(STATUS.SUCCESS, { landReward, bankReward, landData, moveStep, newPosition, roundIndex: playerData.roundIndex + 1, });
}
/**
* @description 存钱
* @param {{activityId: number ,addCount: number}} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async bank(msg: { activityId: number, addCount: number }, session: BackendSession) {
const { activityId, addCount } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let curPosition = playerData.curPosition;
if (curPosition == 0) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
let landData = playerData.findMonopolyItem(curPosition);
if (landData.landType != LAND_TYPE.BANK_NORMAL
&& landData.landType != LAND_TYPE.BANK_COIN
&& landData.landType != LAND_TYPE.BANK_GOLD) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
if (landData.record.length != 0) {
return resResult(STATUS.MONOPOLY_BANK);
}
if (addCount > landData.saveMax) {
return resResult(STATUS.MONOPOLY_BANK_SAVE_MAX);
}
let resrouseStr = '';
if (landData.landType == LAND_TYPE.BANK_COIN
|| landData.landType == LAND_TYPE.BANK_NORMAL) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (landData.landType == LAND_TYPE.BANK_GOLD) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, curPosition, BANK_TYPE.IN, resrouseStr);
landData.record = recordResult.record;
return resResult(STATUS.SUCCESS, { landData });
}
/**
* @description 获取商店数据
* @param {{ activityId:number, shopActivityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number, shopActivityId: number }, session: BackendSession) {
const { activityId, shopActivityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, playerLandData.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerShopData });
}
/**
* @description 购买非RMB商品
* @param {{ monopolyActivityId:number, shopActivityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { monopolyActivityId, shopActivityId: number, roundIndex: number, id: number, pageIndex: number }, session: BackendSession) {
const { monopolyActivityId, shopActivityId, roundIndex, id, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, monopolyActivityId, roleId);
let playerData = await getPlayerMonopolyData(monopolyActivityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let landItem = playerData.findMonopolyItem(playerMonopolyData.curPosition)
if (landItem.stopCount > landItem.shoppingCountMax) {
return resResult(STATUS.SHOP_CLOSED);
}
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, landItem.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerShopData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerShopData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
await ActivityRefreshShopModel.addRecord(shopActivityId, roleId, roundIndex, pageIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { shopActivityId, monopolyActivityId, roundIndex, id },
item: item
}));
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { LAND_TYPE, STATUS, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { ActivityMonopolyModel, ActivityMonopolyModelType } from '@db/ActivityMonopoly';
import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '@db/ActivityMonopolyLand';
import { getPlayerMonopolyData, nextPosition } from '../../../services/activity/monopolyService';
import { random } from 'underscore';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRefreshShopDataByRoundIndex } from '../../../services/activity/refreshShopService';
import { ActivityRefreshShopModel } from '@db/ActivityRefreshShop';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityMonopolyHandler(app);
}
export class ActivityMonopolyHandler {
constructor(private app: Application) {
}
/**
* @description 获取大富翁活动数据
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async getMonopolyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 移动
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async move(msg: { activityId: number, step: number }, session: BackendSession) {
const { activityId, step } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
const roleName = session.get('roleName');
let moveStep = 0;
if (step >= 1 && step <= 6) {//指定,天机骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.SPECIAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = step;
} else {//普通骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.NORMAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = random(5) + 1;
}
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let oldPosition = playerData.curPosition;
let newPosition = nextPosition(oldPosition, moveStep, playerData.list.length);
await ActivityMonopolyModel.updatePosition(serverId, activityId, roleId, newPosition, 1)
let landData = playerData.findMonopolyItem(newPosition);
let landReward = null;//土地奖励
let bankReward = null;//银行奖励
if (landData && landData.landType == LAND_TYPE.BANK_NORMAL) {
//土地奖励
if (landData.rewards.length > landData.stopCount) {
let reward = landData.rewards[landData.level - 1];
let rewardArray = stringToRewardParam(reward)
landReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
}
//土地升级
if (landData.rewards.length > landData.level) {
let newLevel = landData.level + 1;
await ActivityMonopolyLandModel.updateLevel(serverId, activityId, roleId, newPosition, newLevel)
landData.level = newLevel;
}
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
} else if (landData && ((landData.landType == LAND_TYPE.BANK_COIN) || (landData.landType == LAND_TYPE.BANK_GOLD))) {
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
}
await ActivityMonopolyLandModel.updateStopCount(serverId, activityId, roleId, newPosition);
landData.stopCount += 1;
return resResult(STATUS.SUCCESS, { landReward, bankReward, landData, moveStep, newPosition, roundIndex: playerData.roundIndex + 1, });
}
/**
* @description 存钱
* @param {{activityId: number ,addCount: number}} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async bank(msg: { activityId: number, addCount: number }, session: BackendSession) {
const { activityId, addCount } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let curPosition = playerData.curPosition;
if (curPosition == 0) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
let landData = playerData.findMonopolyItem(curPosition);
if (landData.landType != LAND_TYPE.BANK_NORMAL
&& landData.landType != LAND_TYPE.BANK_COIN
&& landData.landType != LAND_TYPE.BANK_GOLD) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
if (landData.record.length != 0) {
return resResult(STATUS.MONOPOLY_BANK);
}
if (addCount > landData.saveMax) {
return resResult(STATUS.MONOPOLY_BANK_SAVE_MAX);
}
let resrouseStr = '';
if (landData.landType == LAND_TYPE.BANK_COIN
|| landData.landType == LAND_TYPE.BANK_NORMAL) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (landData.landType == LAND_TYPE.BANK_GOLD) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, curPosition, BANK_TYPE.IN, resrouseStr);
landData.record = recordResult.record;
return resResult(STATUS.SUCCESS, { landData });
}
/**
* @description 获取商店数据
* @param {{ activityId:number, shopActivityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number, shopActivityId: number }, session: BackendSession) {
const { activityId, shopActivityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, playerLandData.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerShopData });
}
/**
* @description 购买非RMB商品
* @param {{ monopolyActivityId:number, shopActivityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { monopolyActivityId, shopActivityId: number, roundIndex: number, id: number, pageIndex: number }, session: BackendSession) {
const { monopolyActivityId, shopActivityId, roundIndex, id, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, monopolyActivityId, roleId);
let playerData = await getPlayerMonopolyData(monopolyActivityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let landItem = playerData.findMonopolyItem(playerMonopolyData.curPosition)
if (landItem.stopCount > landItem.shoppingCountMax) {
return resResult(STATUS.SHOP_CLOSED);
}
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, landItem.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerShopData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerShopData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
await ActivityRefreshShopModel.addRecord(shopActivityId, roleId, roundIndex, pageIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { shopActivityId, monopolyActivityId, roundIndex, id },
item: item
}));
}
}

View File

@@ -1,65 +1,66 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { getPlayerAuthorGachaDataShow } from "../../../services/activity/authorGachaService";
import { parseGoodStrWithType, resResult } from "../../../pubUtils/util";
import { ITEM_CHANGE_REASON, STATUS } from "../../../consts";
import { AuthorGachaData } from "../../../domain/activityField/authorGachaField";
import { addReward } from "../../../services/activity/giftPackageService";
import { ActivityAuthorGachaRecModel } from "../../../db/AuthorGachaRec";
export default function (app: Application) {
new HandlerService(app, {});
return new AuthorGachaHandler(app);
}
export class AuthorGachaHandler {
constructor(private app: Application) {
}
/**
* 祈灵获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const { activityId } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { ...playerData });
}
/**
* 祈灵获取奖励
* @param msg
* @param session
* @returns
*/
async receiveBox(msg: { activityId: number, count: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { activityId, count } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.box.find(cur => cur.count == count);
if (box == undefined || box.hasReceived) return resResult(STATUS.ACTIVITY_REWARDED);
box.hasReceived = true;
let rewards = parseGoodStrWithType(box.rewards);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.AUTHOR_GACHA_REWARD);
await ActivityAuthorGachaRecModel.record(serverId, activityId, playerData.roundIndex, roleId, count);
return resResult(STATUS.SUCCESS, { goods: result.goods, curBox: playerData.box })
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { getPlayerAuthorGachaDataShow } from "../../../services/activity/authorGachaService";
import { parseGoodStrWithType, resResult } from "@pubUtils/util";
import { ITEM_CHANGE_REASON, STATUS } from "../../../consts";
import { AuthorGachaData } from "@domain/activityField/authorGachaField";
import { addReward } from "../../../services/activity/giftPackageService";
import { ActivityAuthorGachaRecModel } from "@db/AuthorGachaRec";
export default function (app: Application) {
new HandlerService(app, {});
return new AuthorGachaHandler(app);
}
export class AuthorGachaHandler {
constructor(private app: Application) {
}
/**
* 祈灵获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const { activityId } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { ...playerData });
}
/**
* 祈灵获取奖励
* @param msg
* @param session
* @returns
*/
async receiveBox(msg: { activityId: number, count: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { activityId, count } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.box.find(cur => cur.count == count);
if (box == undefined || box.hasReceived) return resResult(STATUS.ACTIVITY_REWARDED);
box.hasReceived = true;
let rewards = parseGoodStrWithType(box.rewards);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.AUTHOR_GACHA_REWARD);
await ActivityAuthorGachaRecModel.record(serverId, activityId, playerData.roundIndex, roleId, count);
return resResult(STATUS.SUCCESS, { goods: result.goods, curBox: playerData.box })
}
}

View File

@@ -1,156 +1,157 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { BIND_PHONE_STATUS, ITEM_CHANGE_REASON, PUSH_ROUTE, SNS_LINK_TYPE, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '../../../domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
import { getBindPhoneData, getAllSnsLinkDataShow, getPublicAccountData } from '../../../services/activity/bindPhoneService';
import { ActivityBindPhoneRewardModel } from '../../../db/ActivityBindPhoneReward';
import { ActivityPublicAccountCodeModel } from '../../../db/ActivityPublicAccountCode';
import { UserModel } from '../../../db/User';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new BindPhoneHandler(app);
}
export class BindPhoneHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getAllSnsLinkDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/************************绑定手机****************************/
/**
* @description 绑定手机数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async bind(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status != BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_HAS_BIND);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.HAS_BIND, { roleId, roleName, serverId });
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.HAS_BIND
});
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_BIND_ERR);
if(bindPhoneData.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_BIND_RECEIVED);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.RECEIVED, { roleId, roleName, serverId });
let rewardArray = stringToRewardParam(bindPhoneData.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 领取公众号口令奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveGiftCode(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
let playerData = await getPublicAccountData(activityId, roleId, serverId, user);
let data = playerData?.wxPublicAccount;
if(!data) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(data.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_WAIT);
if(data.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_RECEIVED);
await ActivityPublicAccountCodeModel.receive(activityId, user.channelId);
let rewardArray = stringToRewardParam(data.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 前往论坛,用于前往论坛任务
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async skipOutSide(msg: { activityId: number }, session: BackendSession) {
return resResult(STATUS.SUCCESS);
}
/**
* 公众号设置成可以领取的状态
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async debugSetGiftCodeStatus(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
await ActivityPublicAccountCodeModel.findOneAndUpdate({ activityId, channelId: user.channelId }, { $set: { serverId, roleId, orderId: 'test', hasReceived: false } }, { new: true, upsert: true }).lean();
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PUBLIC_ACCOUNT_GIFT, { activityId, type: SNS_LINK_TYPE.WX_PUBLIC_ACCOUNT, status: BIND_PHONE_STATUS.HAS_BIND });
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { BIND_PHONE_STATUS, ITEM_CHANGE_REASON, PUSH_ROUTE, SNS_LINK_TYPE, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '@domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
import { getBindPhoneData, getAllSnsLinkDataShow, getPublicAccountData } from '../../../services/activity/bindPhoneService';
import { ActivityBindPhoneRewardModel } from '@db/ActivityBindPhoneReward';
import { ActivityPublicAccountCodeModel } from '@db/ActivityPublicAccountCode';
import { UserModel } from '@db/User';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new BindPhoneHandler(app);
}
export class BindPhoneHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getAllSnsLinkDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/************************绑定手机****************************/
/**
* @description 绑定手机数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async bind(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status != BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_HAS_BIND);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.HAS_BIND, { roleId, roleName, serverId });
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.HAS_BIND
});
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_BIND_ERR);
if(bindPhoneData.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_BIND_RECEIVED);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.RECEIVED, { roleId, roleName, serverId });
let rewardArray = stringToRewardParam(bindPhoneData.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 领取公众号口令奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveGiftCode(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
let playerData = await getPublicAccountData(activityId, roleId, serverId, user);
let data = playerData?.wxPublicAccount;
if(!data) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(data.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_WAIT);
if(data.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_RECEIVED);
await ActivityPublicAccountCodeModel.receive(activityId, user.channelId);
let rewardArray = stringToRewardParam(data.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 前往论坛,用于前往论坛任务
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async skipOutSide(msg: { activityId: number }, session: BackendSession) {
return resResult(STATUS.SUCCESS);
}
/**
* 公众号设置成可以领取的状态
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async debugSetGiftCodeStatus(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
await ActivityPublicAccountCodeModel.findOneAndUpdate({ activityId, channelId: user.channelId }, { $set: { serverId, roleId, orderId: 'test', hasReceived: false } }, { new: true, upsert: true }).lean();
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PUBLIC_ACCOUNT_GIFT, { activityId, type: SNS_LINK_TYPE.WX_PUBLIC_ACCOUNT, status: BIND_PHONE_STATUS.HAS_BIND });
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,165 +1,166 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerChongYangData, getPlayerChongYangDataShow } from '../../../services/activity/chongyangService';
import { ActivityChongYangRecModel, ChongYangGameRecord } from '../../../db/ActivityChongYangRec';
import { RewardInter } from '../../../pubUtils/interface';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';
export default function (app: Application) {
new HandlerService(app, {});
return new ChongYangHandler(app);
}
export class ChongYangHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
async gameStart(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
const gameCode = genCode(10);
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, dayIndex, isSkip: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode });
}
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean, dayIndex: number }, session: BackendSession) {
const { activityId, gameCode, isSuccess, dayIndex } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
let curRecord = playerData.gameRecords.find(cur => cur.gameCode == gameCode);
if (!curRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
if (curRecord.isSuccess) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_USE);
let playerRecord = await ActivityChongYangRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), scene.rewards);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
let goods: RewardInter[] = [];
if (isSuccess) {
goods = await addItems(roleId, roleName, sid, stringToRewardParam(scene.rewards), ITEM_CHANGE_REASON.CHONGYANG_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
gameCode,
goods
});
}
async buyCnt(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测购买次数
if (scene.buyCnt + count > scene.dailyBuyCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_BUY_COUNT_OVER);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(scene.buyCost), ITEM_CHANGE_REASON.CHONGYANG_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let playerRecord = await ActivityChongYangRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, { dayIndex, buyCnt: count }, scene.isPushBuyRecord);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, { activityId, dailyBuyCnt: scene.dailyBuyCnt, buyCnt: scene.buyCnt, });
}
async gameSweep(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt + count > scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 检测通关
let isHasPass = playerData.gameRecords.find(cur => cur.dayIndex == dayIndex && cur.isSuccess && !cur.isSkip && (getZeroPoint() * 1000 <= cur.time.getTime()));
if (!isHasPass) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMESWEEP_LOCK);
let rewards: RewardInter[] = [];
let records: ChongYangGameRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: scene.rewards, isSuccess: true, dayIndex, isSkip: true })
rewards.push(...stringToRewardParam(scene.rewards));
}
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.CHONGYANG_REWARD)
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
goods
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerChongYangData, getPlayerChongYangDataShow } from '../../../services/activity/chongyangService';
import { ActivityChongYangRecModel, ChongYangGameRecord } from '@db/ActivityChongYangRec';
import { RewardInter } from '@pubUtils/interface';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getZeroPoint } from '@pubUtils/timeUtil';
export default function (app: Application) {
new HandlerService(app, {});
return new ChongYangHandler(app);
}
export class ChongYangHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
async gameStart(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
const gameCode = genCode(10);
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, dayIndex, isSkip: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode });
}
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean, dayIndex: number }, session: BackendSession) {
const { activityId, gameCode, isSuccess, dayIndex } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
let curRecord = playerData.gameRecords.find(cur => cur.gameCode == gameCode);
if (!curRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
if (curRecord.isSuccess) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_USE);
let playerRecord = await ActivityChongYangRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), scene.rewards);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
let goods: RewardInter[] = [];
if (isSuccess) {
goods = await addItems(roleId, roleName, sid, stringToRewardParam(scene.rewards), ITEM_CHANGE_REASON.CHONGYANG_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
gameCode,
goods
});
}
async buyCnt(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测购买次数
if (scene.buyCnt + count > scene.dailyBuyCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_BUY_COUNT_OVER);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(scene.buyCost), ITEM_CHANGE_REASON.CHONGYANG_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let playerRecord = await ActivityChongYangRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, { dayIndex, buyCnt: count }, scene.isPushBuyRecord);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, { activityId, dailyBuyCnt: scene.dailyBuyCnt, buyCnt: scene.buyCnt, });
}
async gameSweep(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt + count > scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 检测通关
let isHasPass = playerData.gameRecords.find(cur => cur.dayIndex == dayIndex && cur.isSuccess && !cur.isSkip && (getZeroPoint() * 1000 <= cur.time.getTime()));
if (!isHasPass) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMESWEEP_LOCK);
let rewards: RewardInter[] = [];
let records: ChongYangGameRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: scene.rewards, isSuccess: true, dayIndex, isSkip: true })
rewards.push(...stringToRewardParam(scene.rewards));
}
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.CHONGYANG_REWARD)
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
goods
});
}
}

View File

@@ -1,80 +1,81 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '../../../domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyChallengesHandler(app);
}
export class DailyChallengesHandler {
constructor(private app: Application) {
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengesActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyItem = playerData.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '@domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyChallengesHandler(app);
}
export class DailyChallengesHandler {
constructor(private app: Application) {
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengesActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyItem = playerData.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
}

View File

@@ -1,166 +1,167 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, DAILY_COIN_BOX_STATUS, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyCoinData, mergeData } from '../../../services/activity/dailyCoinService';
import { ConsumeExchangeFormulaItem, CoinRewardFormulaItem } from '../../../domain/activityField/dailyCoinField';
import { ActivityDailyCoinModel } from '../../../db/ActivityDailyCoin';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ItemInter } from '../../../pubUtils/interface';
import { RoleModel } from '../../../db/Role';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyCoinHandler(app);
}
export class DailyCoinHandler {
constructor(private app: Application) {
}
/************************每日兑换铜币****************************/
/**
* @description 获取每日铜币活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async getDailyCoinActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 兑换
* @param {{ activityId: number, count:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async exchangeCoin(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let curIndex = playerData.exchangeCount;
if (curIndex + count > playerData.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let allConsume: Array<ItemInter> = []
let allReward: Array<RewardParam> = [];
let role = await RoleModel.findByRoleId(roleId)
let rateArray = [];//暴击记录
for (let i = 1; i <= count; i++) {
let index = curIndex + i;
if (index > playerData.freeCount) {//消耗资源
let consumeItem: ConsumeExchangeFormulaItem = playerData.findConsumeExchangeFormulaItem(index);
let times = index;
let consumeCount = eval(consumeItem.consumeFormula)
let consume = getGoldObject(consumeCount)
allConsume = allConsume.concat(consume)
}
let rate = playerData.getRate()//翻几倍
rateArray.push(rate);
let lv = role.lv;//玩家等级
let rewardItem: CoinRewardFormulaItem = playerData.findCoinRewardFormulaItem(lv);
if (!rewardItem) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let coinRewardCount = eval(rewardItem.rewardFormula);
// console.log('******** coinReward', lv, rewardItem.rewardFormula, coinRewardCount)
let baseRewardParamArr: Array<RewardParam> = [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: coinRewardCount, type: ACTIVITY_RESOURCES_TYPE.GOODS }];
// console.log('第几次抽奖:', index, ' 基础奖励翻倍:', rate, JSON.stringify(baseRewardParamArr),)
for (let reward of baseRewardParamArr) {
reward.count = reward.count * rate;
}
allReward = allReward.concat(baseRewardParamArr);
}
let newConsume = mergeData(allConsume);
let newReward = mergeData(allReward);
// console.log('所有消耗', JSON.stringify(newConsume))
// console.log('所有奖励', JSON.stringify(newReward))
//检查资源
let consumeResult = await handleCost(roleId, sid, newConsume, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
let addCoin = 0
let coinId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN);
for (let obj of newReward) {
if (obj.id === coinId) {
addCoin += obj.count;
}
}
let consumeGold = 0;
let goldId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD);
for (let obj of newConsume) {
if (obj.id === goldId) {
consumeGold += obj.count;
}
}
//免费期间
let time = moment(new Date()).valueOf();
let result = await addReward(roleId, roleName, sid, serverId, newReward, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
let extraReward = playerData.addExchangeCount(count);
await ActivityDailyCoinModel.addExchangeRecord(serverId, activityId, roleId, playerData.roundIndex, count, addCoin, `${count}&${consumeGold}&${addCoin}&${time}`, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, count, extraReward },
item: { exchangeCount: playerData.exchangeCount, recordMsg: `${count}&${consumeGold}&${addCoin}&${time}`, rateArray },
}));
}
/**
* @description 领取宝箱
* @param {{ activityId: number, cellIndex:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async receiveExtraReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = await playerData.findBoxByCellIndex(cellIndex);
if(!box) return resResult(STATUS.DAILY_COIN_BOX_NOT_FOUND);
if(box.status != DAILY_COIN_BOX_STATUS.CAN_OPEN) return resResult(STATUS.DAILY_COIN_BOX_CANNOT_RECEIVE);
let rewardArray = stringToRewardParam(box.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_DAILY_COIN_RECEIVE_BOX);
let item = playerData.receiveBox(cellIndex);
await ActivityDailyCoinModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, cellIndex, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
item,
param: { activityId },
}));
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, DAILY_COIN_BOX_STATUS, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyCoinData, mergeData } from '../../../services/activity/dailyCoinService';
import { ConsumeExchangeFormulaItem, CoinRewardFormulaItem } from '@domain/activityField/dailyCoinField';
import { ActivityDailyCoinModel } from '@db/ActivityDailyCoin';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ItemInter } from '@pubUtils/interface';
import { RoleModel } from '@db/Role';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyCoinHandler(app);
}
export class DailyCoinHandler {
constructor(private app: Application) {
}
/************************每日兑换铜币****************************/
/**
* @description 获取每日铜币活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async getDailyCoinActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 兑换
* @param {{ activityId: number, count:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async exchangeCoin(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let curIndex = playerData.exchangeCount;
if (curIndex + count > playerData.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let allConsume: Array<ItemInter> = []
let allReward: Array<RewardParam> = [];
let role = await RoleModel.findByRoleId(roleId)
let rateArray = [];//暴击记录
for (let i = 1; i <= count; i++) {
let index = curIndex + i;
if (index > playerData.freeCount) {//消耗资源
let consumeItem: ConsumeExchangeFormulaItem = playerData.findConsumeExchangeFormulaItem(index);
let times = index;
let consumeCount = eval(consumeItem.consumeFormula)
let consume = getGoldObject(consumeCount)
allConsume = allConsume.concat(consume)
}
let rate = playerData.getRate()//翻几倍
rateArray.push(rate);
let lv = role.lv;//玩家等级
let rewardItem: CoinRewardFormulaItem = playerData.findCoinRewardFormulaItem(lv);
if (!rewardItem) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let coinRewardCount = eval(rewardItem.rewardFormula);
// console.log('******** coinReward', lv, rewardItem.rewardFormula, coinRewardCount)
let baseRewardParamArr: Array<RewardParam> = [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: coinRewardCount, type: ACTIVITY_RESOURCES_TYPE.GOODS }];
// console.log('第几次抽奖:', index, ' 基础奖励翻倍:', rate, JSON.stringify(baseRewardParamArr),)
for (let reward of baseRewardParamArr) {
reward.count = reward.count * rate;
}
allReward = allReward.concat(baseRewardParamArr);
}
let newConsume = mergeData(allConsume);
let newReward = mergeData(allReward);
// console.log('所有消耗', JSON.stringify(newConsume))
// console.log('所有奖励', JSON.stringify(newReward))
//检查资源
let consumeResult = await handleCost(roleId, sid, newConsume, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
let addCoin = 0
let coinId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN);
for (let obj of newReward) {
if (obj.id === coinId) {
addCoin += obj.count;
}
}
let consumeGold = 0;
let goldId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD);
for (let obj of newConsume) {
if (obj.id === goldId) {
consumeGold += obj.count;
}
}
//免费期间
let time = moment(new Date()).valueOf();
let result = await addReward(roleId, roleName, sid, serverId, newReward, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
let extraReward = playerData.addExchangeCount(count);
await ActivityDailyCoinModel.addExchangeRecord(serverId, activityId, roleId, playerData.roundIndex, count, addCoin, `${count}&${consumeGold}&${addCoin}&${time}`, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, count, extraReward },
item: { exchangeCount: playerData.exchangeCount, recordMsg: `${count}&${consumeGold}&${addCoin}&${time}`, rateArray },
}));
}
/**
* @description 领取宝箱
* @param {{ activityId: number, cellIndex:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async receiveExtraReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = await playerData.findBoxByCellIndex(cellIndex);
if(!box) return resResult(STATUS.DAILY_COIN_BOX_NOT_FOUND);
if(box.status != DAILY_COIN_BOX_STATUS.CAN_OPEN) return resResult(STATUS.DAILY_COIN_BOX_CANNOT_RECEIVE);
let rewardArray = stringToRewardParam(box.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_DAILY_COIN_RECEIVE_BOX);
let item = playerData.receiveBox(cellIndex);
await ActivityDailyCoinModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, cellIndex, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
item,
param: { activityId },
}));
}
}

View File

@@ -1,77 +1,78 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerDailyGKData } from '../../../services/activity/dailyGKService';
import { DailyGKItem } from '../../../domain/activityField/dailyGKField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGKHandler(app);
}
export class DailyGKHandler {
constructor(private app: Application) {
}
/************************每日关卡;按日开启,每日开启一关****************************/
/**
* @description 获取每日关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getDailyGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getGK(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let dailyItemData: DailyGKItem = playerData.findDailyGKItem(dayIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
// if (dailyItemData.isSuccess) {//已经达成
// return resResult(STATUS.ACTIVITY_REWARDED);
// }
// await ActivityDailyGKModel.addRecord(serverId, activityId, roleId, dayIndex);
// let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
// let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
// dailyItemData.isSuccess = true;
return resResult(STATUS.SUCCESS, {
gkId: dailyItemData.gk
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerDailyGKData } from '../../../services/activity/dailyGKService';
import { DailyGKItem } from '@domain/activityField/dailyGKField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGKHandler(app);
}
export class DailyGKHandler {
constructor(private app: Application) {
}
/************************每日关卡;按日开启,每日开启一关****************************/
/**
* @description 获取每日关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getDailyGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getGK(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let dailyItemData: DailyGKItem = playerData.findDailyGKItem(dayIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
// if (dailyItemData.isSuccess) {//已经达成
// return resResult(STATUS.ACTIVITY_REWARDED);
// }
// await ActivityDailyGKModel.addRecord(serverId, activityId, roleId, dayIndex);
// let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
// let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
// dailyItemData.isSuccess = true;
return resResult(STATUS.SUCCESS, {
gkId: dailyItemData.gk
});
}
}

View File

@@ -1,93 +1,94 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyGiftsData } from '../../../services/activity/dailyGiftsService';
import { DailyGiftItem } from '../../../domain/activityField/dailyGiftsField';
import { ActivityDailyGiftsModel } from '../../../db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGiftsHandler(app);
}
export class DailyGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async getDailyGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyGiftItem = playerData.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyGiftsData } from '../../../services/activity/dailyGiftsService';
import { DailyGiftItem } from '@domain/activityField/dailyGiftsField';
import { ActivityDailyGiftsModel } from '@db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGiftsHandler(app);
}
export class DailyGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async getDailyGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyGiftItem = playerData.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}

View File

@@ -1,88 +1,89 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyMealData } from '../../../services/activity/dailyMealService';
import { DailyMealItem } from '../../../domain/activityField/dailyMealField';
import { ActivityDailyMealModel } from '../../../db/ActivityDailyMeal';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyMealHandler(app);
}
export class DailyMealHandler {
constructor(private app: Application) {
}
/************************每日午饭/晚饭****************************/
/**
* @description 获取每日午饭/晚饭活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealReward(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let itemData: DailyMealItem = playerData.findItem(type);
if (!itemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (itemData.isReceive) {//最大次数
return resResult(STATUS.ACTIVITY_REWARDED);
}
let curDate = moment(new Date()).valueOf();
if (curDate < itemData.beginTime) {//没到饭点
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
if (curDate > itemData.endTime) {//补领
//检查资源
let consume = stringToConsumeParam(itemData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE_REPAIRE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
//免费期间
let rewardParamArr: Array<RewardParam> = stringToRewardParam(itemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE);
await ActivityDailyMealModel.addReceiveRecord(serverId, activityId, roleId, type, curDate, playerData.roundIndex);
itemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, type },
item: itemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyMealData } from '../../../services/activity/dailyMealService';
import { DailyMealItem } from '@domain/activityField/dailyMealField';
import { ActivityDailyMealModel } from '@db/ActivityDailyMeal';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyMealHandler(app);
}
export class DailyMealHandler {
constructor(private app: Application) {
}
/************************每日午饭/晚饭****************************/
/**
* @description 获取每日午饭/晚饭活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealReward(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let itemData: DailyMealItem = playerData.findItem(type);
if (!itemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (itemData.isReceive) {//最大次数
return resResult(STATUS.ACTIVITY_REWARDED);
}
let curDate = moment(new Date()).valueOf();
if (curDate < itemData.beginTime) {//没到饭点
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
if (curDate > itemData.endTime) {//补领
//检查资源
let consume = stringToConsumeParam(itemData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE_REPAIRE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
//免费期间
let rewardParamArr: Array<RewardParam> = stringToRewardParam(itemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE);
await ActivityDailyMealModel.addReceiveRecord(serverId, activityId, roleId, type, curDate, playerData.roundIndex);
itemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, type },
item: itemData,
}));
}
}

View File

@@ -1,95 +1,96 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerDailyRMBGiftsData } from '../../../services/activity/dailyRMBGiftsService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityDailyRMBGiftsModel } from '../../../db/ActivityDailyRMBGifts';
import moment = require('moment');
import { DailyRMBGiftsItem } from '../../../domain/activityField/dailyRMBGiftsField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyRMBGiftsHandler(app);
}
export class DailyRMBGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包RMB购买4挡有可能免费,一次性支付购买7天,每天只能领取当天的礼包奖励****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 一次性购买7天后获取当天的礼包
* @param {{ activityId: number, id:number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items: DailyRMBGiftsItem[] = [];
if(id > 0) {
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (!playerData.isBuy && item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
items.push(item);
} else {
if (!playerData.isBuy) {
return resResult(STATUS.ACTIVITY_UNOPENED);
}
items.push(...playerData.unReceiveItem());
}
if (items.length == 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let ids: number[] = []
for (let item of items) {
ids.push(item.id);
rewardArray.push(...stringToRewardParam(item.reward));
}
let resultItems = playerData.receiveItems(ids);
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, ids);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, unReceiveCount: playerData.unReceiveCount, buttonStatus: playerData.buttonStatus },
items: resultItems
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerDailyRMBGiftsData } from '../../../services/activity/dailyRMBGiftsService';
import { RewardParam } from '@domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityDailyRMBGiftsModel } from '@db/ActivityDailyRMBGifts';
import moment = require('moment');
import { DailyRMBGiftsItem } from '@domain/activityField/dailyRMBGiftsField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyRMBGiftsHandler(app);
}
export class DailyRMBGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包RMB购买4挡有可能免费,一次性支付购买7天,每天只能领取当天的礼包奖励****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 一次性购买7天后获取当天的礼包
* @param {{ activityId: number, id:number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items: DailyRMBGiftsItem[] = [];
if(id > 0) {
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (!playerData.isBuy && item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
items.push(item);
} else {
if (!playerData.isBuy) {
return resResult(STATUS.ACTIVITY_UNOPENED);
}
items.push(...playerData.unReceiveItem());
}
if (items.length == 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let ids: number[] = []
for (let item of items) {
ids.push(item.id);
rewardArray.push(...stringToRewardParam(item.reward));
}
let resultItems = playerData.receiveItems(ids);
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, ids);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, unReceiveCount: playerData.unReceiveCount, buttonStatus: playerData.buttonStatus },
items: resultItems
}));
}
}

View File

@@ -1,137 +1,138 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { parseNumberList, 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 getData(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 && route.preId != '&') {
let preIds = parseNumberList(route.preId);
let hasPass = preIds.find(preId => {
let preRoute = playerData.findRoute(preId);
return preRoute && preRoute.hasPass;
});
if(!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
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { parseNumberList, 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 getData(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 && route.preId != '&') {
let preIds = parseNumberList(route.preId);
let hasPass = preIds.find(preId => {
let preRoute = playerData.findRoute(preId);
return preRoute && preRoute.hasPass;
});
if(!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
});
}
}

View File

@@ -1,132 +1,133 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getRandSingleEelm, parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerEntertainData, getPlayerEntertainDataShow } from '../../../services/activity/entertainService';
import { ActivityEntertainRecModel } from '../../../db/ActivityEntertainRec';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new EntertainHandler(app);
}
export class EntertainHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 宴请
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async invite(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let pool = playerData.heroes.filter(hero => {
if(hero.num >= hero.maxNum) return false;
for(let condition of hero.conditionArr) {
if(condition.type == 1 && playerData.invitedHeroNum < condition.param) return false;
if(condition.type == 2 && playerData.invitedHids.indexOf(condition.param) == -1) return false;
}
return true;
});
if(pool.length <= 0) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let randResult = getRandSingleEelm(pool);
if(!randResult) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let rewards = stringToRewardParam(randResult.reward);
let todayIndex = playerData.todayIndex; // 免费挑战算在第几天
if(playerData.todayPlayCnt >= playerData.freeCntDaily && playerData.playCnt < playerData.freeCnt) {
let playerRecord = await ActivityEntertainRecModel.findData(serverId, activityId, playerData.roundIndex, roleId);
let records = playerRecord?.record||[];
for(let i = 1; i <= todayIndex; i++) {
let times = records.filter(cur => cur.todayIndex == i).length;
playerData.playCnt += times;
if(times < playerData.freeCntDaily) {
todayIndex = i; break;
}
}
}
let playerRecord = await ActivityEntertainRecModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex, id: randResult.id, hid: randResult.hid, index: randResult.index, time: new Date(), reward: randResult.reward })
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_ENTERTAIN);
playerData.todayPlayCnt = 0;
playerData.playCnt = 0;
playerData.freeCnt = playerData.freeCntDaily * playerData.todayIndex;
for(let hero of playerData.heroes) hero.num = 0;
playerData.setPlayerRecords(playerRecord);
let newRandResult = playerData.heroes.find(cur => cur.id == randResult.id);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
curHero: newRandResult?.getShowResult(),
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
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 getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_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_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityEntertainRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updateBuyCnt(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getRandSingleEelm, parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerEntertainData, getPlayerEntertainDataShow } from '../../../services/activity/entertainService';
import { ActivityEntertainRecModel } from '@db/ActivityEntertainRec';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new EntertainHandler(app);
}
export class EntertainHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 宴请
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async invite(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let pool = playerData.heroes.filter(hero => {
if(hero.num >= hero.maxNum) return false;
for(let condition of hero.conditionArr) {
if(condition.type == 1 && playerData.invitedHeroNum < condition.param) return false;
if(condition.type == 2 && playerData.invitedHids.indexOf(condition.param) == -1) return false;
}
return true;
});
if(pool.length <= 0) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let randResult = getRandSingleEelm(pool);
if(!randResult) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let rewards = stringToRewardParam(randResult.reward);
let todayIndex = playerData.todayIndex; // 免费挑战算在第几天
if(playerData.todayPlayCnt >= playerData.freeCntDaily && playerData.playCnt < playerData.freeCnt) {
let playerRecord = await ActivityEntertainRecModel.findData(serverId, activityId, playerData.roundIndex, roleId);
let records = playerRecord?.record||[];
for(let i = 1; i <= todayIndex; i++) {
let times = records.filter(cur => cur.todayIndex == i).length;
playerData.playCnt += times;
if(times < playerData.freeCntDaily) {
todayIndex = i; break;
}
}
}
let playerRecord = await ActivityEntertainRecModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex, id: randResult.id, hid: randResult.hid, index: randResult.index, time: new Date(), reward: randResult.reward })
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_ENTERTAIN);
playerData.todayPlayCnt = 0;
playerData.playCnt = 0;
playerData.freeCnt = playerData.freeCntDaily * playerData.todayIndex;
for(let hero of playerData.heroes) hero.num = 0;
playerData.setPlayerRecords(playerRecord);
let newRandResult = playerData.heroes.find(cur => cur.id == randResult.id);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
curHero: newRandResult?.getShowResult(),
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
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 getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_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_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityEntertainRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updateBuyCnt(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}

View File

@@ -1,92 +1,93 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerFirstGiftData, getPlayerFirstGiftDataShow } from '../../../services/activity/firstGiftService';
import { RoleModel } from '../../../db/Role';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityFirstGiftModel } from '../../../db/ActivityFirstGift';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new FirstGiftHandler(app);
}
export class FirstGiftHandler {
constructor(private app: Application) {
}
/************************首充礼包****************************/
/**首冲活动按玩家注册时间
* 不充,首充活动就一直在那里
* @description 获取首充礼包数据
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerFirstGiftDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let { totalPay } = await RoleModel.findByRoleId(roleId);
if (totalPay > 0) {//奖励开启
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 领取礼包奖励
* @param {{ activityId: number, index: number}} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftReward(msg: { activityId: number, pageIndex: number }, session: BackendSession) {
const { activityId, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerFirstGiftData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let playerPageData = playerData.findPageByIndex(pageIndex);
if (playerPageData.state === FIRST_GIFT_STATE.NOT_PAY) {
return resResult(STATUS.ACTIVITY_FIRST_GIFT_NOT_OPEN);
}
let items = playerPageData.getCanReceiveItems();
if (items.length === 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let indexArray: number[] = [];
for (let item of items) {
rewardArray.push(...stringToRewardParam(item.reward));
indexArray.push(item.index)
item.isReceive = true;
}
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.FIRST_GIFT);
let isOver = playerPageData.isComplete();
let playerRecord = await ActivityFirstGiftModel.addRecord(activityId, roleId, pageIndex, indexArray, isOver);
playerPageData.setPlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, state: playerPageData.state },
items: items
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerFirstGiftData, getPlayerFirstGiftDataShow } from '../../../services/activity/firstGiftService';
import { RoleModel } from '@db/Role';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityFirstGiftModel } from '@db/ActivityFirstGift';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new FirstGiftHandler(app);
}
export class FirstGiftHandler {
constructor(private app: Application) {
}
/************************首充礼包****************************/
/**首冲活动按玩家注册时间
* 不充,首充活动就一直在那里
* @description 获取首充礼包数据
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerFirstGiftDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let { totalPay } = await RoleModel.findByRoleId(roleId);
if (totalPay > 0) {//奖励开启
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 领取礼包奖励
* @param {{ activityId: number, index: number}} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftReward(msg: { activityId: number, pageIndex: number }, session: BackendSession) {
const { activityId, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerFirstGiftData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let playerPageData = playerData.findPageByIndex(pageIndex);
if (playerPageData.state === FIRST_GIFT_STATE.NOT_PAY) {
return resResult(STATUS.ACTIVITY_FIRST_GIFT_NOT_OPEN);
}
let items = playerPageData.getCanReceiveItems();
if (items.length === 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let indexArray: number[] = [];
for (let item of items) {
rewardArray.push(...stringToRewardParam(item.reward));
indexArray.push(item.index)
item.isReceive = true;
}
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.FIRST_GIFT);
let isOver = playerPageData.isComplete();
let playerRecord = await ActivityFirstGiftModel.addRecord(activityId, roleId, pageIndex, indexArray, isOver);
playerPageData.setPlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, state: playerPageData.state },
items: items
}));
}
}

View File

@@ -1,117 +1,118 @@
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 { getMetialStr, getPlayerForgeData, getPlayerForgeDataShow } from '../../../services/activity/forgeService';
import { ActivityForgeModel } from '../../../db/ActivityForge';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getForgeActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 铸造
* @param {{ activityId: number, id: number, material: {id: number, count: number}[]}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async build(msg: { activityId: number, id: number, material: {id: number, count: number}[] }, session: BackendSession) {
const { activityId, id, material } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let materialCnt = material.reduce((pre, cur) => pre + cur.count, 0);
if(materialCnt <= 0) return resResult(STATUS.ACTIVITY_MATERIAL_COUNT_NOT_ZERO);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MANUAL_DAY_LOCK);
// 铸造次数
if(manual.buildCnt >= manual.freeCnt + manual.buyCnt) return resResult(STATUS.ACTIVITY_BUILD_COUNT);
// 配比是否正确
let isSuccess = manual.checkMaterial(material);
// 扣材料
let costResult = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.build(serverId, activityId, roleId, playerData.roundIndex, id, { todayIndex: playerData.todayIndex, isSuccess, material: getMetialStr(material) });
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex, playerData.hint);
let activityGoods = undefined;
if(isSuccess) {
let { goods } = await addReward(roleId, roleName, sid, serverId, stringToRewardParam(manual.reward), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
activityGoods = goods;
}
return resResult(STATUS.SUCCESS, {
isSuccess,
curManual: manual,
activityGoods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, id: number, count: number }, session: BackendSession) {
const { activityId, id, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.buyCnt >= manual.maxBuyCnt) return resResult(STATUS.ACTIVITY_BUY_CNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.buyCnt(serverId, activityId, roleId, playerData.roundIndex, id, count);
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex);
return resResult(STATUS.SUCCESS, {
curManual: manual
});
}
}
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 { getMetialStr, getPlayerForgeData, getPlayerForgeDataShow } from '../../../services/activity/forgeService';
import { ActivityForgeModel } from '@db/ActivityForge';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getForgeActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 铸造
* @param {{ activityId: number, id: number, material: {id: number, count: number}[]}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async build(msg: { activityId: number, id: number, material: {id: number, count: number}[] }, session: BackendSession) {
const { activityId, id, material } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let materialCnt = material.reduce((pre, cur) => pre + cur.count, 0);
if(materialCnt <= 0) return resResult(STATUS.ACTIVITY_MATERIAL_COUNT_NOT_ZERO);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MANUAL_DAY_LOCK);
// 铸造次数
if(manual.buildCnt >= manual.freeCnt + manual.buyCnt) return resResult(STATUS.ACTIVITY_BUILD_COUNT);
// 配比是否正确
let isSuccess = manual.checkMaterial(material);
// 扣材料
let costResult = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.build(serverId, activityId, roleId, playerData.roundIndex, id, { todayIndex: playerData.todayIndex, isSuccess, material: getMetialStr(material) });
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex, playerData.hint);
let activityGoods = undefined;
if(isSuccess) {
let { goods } = await addReward(roleId, roleName, sid, serverId, stringToRewardParam(manual.reward), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
activityGoods = goods;
}
return resResult(STATUS.SUCCESS, {
isSuccess,
curManual: manual,
activityGoods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, id: number, count: number }, session: BackendSession) {
const { activityId, id, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.buyCnt >= manual.maxBuyCnt) return resResult(STATUS.ACTIVITY_BUY_CNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.buyCnt(serverId, activityId, roleId, playerData.roundIndex, id, count);
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex);
return resResult(STATUS.SUCCESS, {
curManual: manual
});
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,152 +1,153 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { STATUS, ITEM_CHANGE_REASON, GROUP_SHOP_PRICE_STATUS, PUSH_ROUTE, ACTIVITY_TYPE, } from "../../../consts";
import { getGroupShopData, getGroupShopDataShow, getGroupShopPriceStatus, getGroupShopServerData, refundGroupShop } from "../../../services/activity/groupShopService";
import { addItems, getGoldObject, handleCost } from "../../../services/role/rewardService";
import { ActivityGroupShopUserRecModel, GroupShopBuyRecord } from "../../../db/ActivityGroupShopUserRec";
import { ActivityGroupShopRecModel, GroupShopRecord } from "../../../db/ActivityGroupShopRec";
import { pick } from "underscore";
import { addRoleToGroupShopChannel, leaveGroupShopChannel } from "../../../services/chatChannelService";
import { sendMessageToGroupShopWithSuc } from "../../../services/pushService";
import { getActivitiesByType } from "../../../services/activity/activityService";
import { GroupShopData } from "../../../domain/activityField/groupShopField";
export default function (app: Application) {
new HandlerService(app, {});
return new GroupShopHandler(app);
}
export class GroupShopHandler {
constructor(private app: Application) {
}
/**
* @description 1. 进入团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async getGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let playerData = await getGroupShopDataShow(activityId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
await addRoleToGroupShopChannel(roleId, sid);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 2. 离开团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async leaveGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
await leaveGroupShopChannel(roleId, sid)
return resResult(STATUS.SUCCESS);
}
/**
* @description 3. 购买
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async buy(msg: { activityId: number, price: number, itemId: number, buyCnt: number }, session: BackendSession) {
const { activityId, price: clientPrice, itemId, buyCnt } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let playerData = await getGroupShopData(activityId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItemById(itemId);
if (!item) return resResult(STATUS.ACTIVITY_GROUP_SHOP_ITEM_NOT_FOUND);
if(!item.checkBuyCnt(buyCnt)) return resResult(STATUS.ACTIVITY_GROUP_SHOP_BUY_CNT_MAX);
let curDiscount = item.getCurDiscount();
let priceStatus = getGroupShopPriceStatus(clientPrice, curDiscount.price);
if(priceStatus == GROUP_SHOP_PRICE_STATUS.NOT_ENOUGH) return resResult(STATUS.ACTIVITY_GROUP_SHOP_PRICE_ERR);
let cost = [getGoldObject(curDiscount.price)];
let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
if(!result) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
// 玩家添加次数
let playerRecord = await ActivityGroupShopUserRecModel.incBuyCnt(activityId, roleId, itemId, item.id, buyCnt, new GroupShopBuyRecord(curDiscount, buyCnt));
playerData.setPlayerRecord([playerRecord]);
// 全服添加次数
let serverRecord = await ActivityGroupShopRecModel.incBuyCnt(activityId, itemId, item.id, buyCnt);
let isRankUp = playerData.incAllRecord(serverRecord);
item = playerData.findItemById(itemId);
let nextDiscount = item.getCurDiscount();
if(isRankUp) {
await ActivityGroupShopRecModel.addRecord(activityId, itemId, new GroupShopRecord(nextDiscount));
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId, itemId, sum: item.sum, curDiscount: nextDiscount });
}
let reward = [{ id: item.id, count: item.count * buyCnt }];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
return resResult(STATUS.SUCCESS, {
curItem: pick(item, ['itemId', 'id', 'sum', 'hasBoughtCnt']),
goods,
status: priceStatus,
oldDiscount: curDiscount,
nextDiscount
});
}
async debugRefund(msg: {}, session: BackendSession) {
await refundGroupShop(true);
return resResult(STATUS.SUCCESS);
}
async debugSetSum(msg: { itemId: number, sum: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let { itemId = 0, sum = 0 } = msg;
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
let recs = await ActivityGroupShopRecModel.debugSetSum(activityData.activityId, itemId, sum);
let playerData = new GroupShopData(activityData, 0, 0);
playerData.setRecords(recs);
let items = itemId == 0? playerData.items: [playerData.findItemById(itemId)];
for(let item of items) {
if(!item) continue;
let nextDiscount = item.getCurDiscount();
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId: activityData.activityId, itemId: item.itemId, sum: item.sum, curDiscount: nextDiscount });
}
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
async debugClearCnt(msg: { }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
await ActivityGroupShopUserRecModel.clearCnt(activityData.activityId, roleId);
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { resResult } from "@pubUtils/util";
import { STATUS, ITEM_CHANGE_REASON, GROUP_SHOP_PRICE_STATUS, PUSH_ROUTE, ACTIVITY_TYPE, } from "../../../consts";
import { getGroupShopData, getGroupShopDataShow, getGroupShopPriceStatus, getGroupShopServerData, refundGroupShop } from "../../../services/activity/groupShopService";
import { addItems, getGoldObject, handleCost } from "../../../services/role/rewardService";
import { ActivityGroupShopUserRecModel, GroupShopBuyRecord } from "@db/ActivityGroupShopUserRec";
import { ActivityGroupShopRecModel, GroupShopRecord } from "@db/ActivityGroupShopRec";
import { pick } from "underscore";
import { addRoleToGroupShopChannel, leaveGroupShopChannel } from "../../../services/chatChannelService";
import { sendMessageToGroupShopWithSuc } from "../../../services/pushService";
import { getActivitiesByType } from "../../../services/activity/activityService";
import { GroupShopData } from "@domain/activityField/groupShopField";
export default function (app: Application) {
new HandlerService(app, {});
return new GroupShopHandler(app);
}
export class GroupShopHandler {
constructor(private app: Application) {
}
/**
* @description 1. 进入团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async getGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let playerData = await getGroupShopDataShow(activityId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
await addRoleToGroupShopChannel(roleId, sid);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 2. 离开团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async leaveGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
await leaveGroupShopChannel(roleId, sid)
return resResult(STATUS.SUCCESS);
}
/**
* @description 3. 购买
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async buy(msg: { activityId: number, price: number, itemId: number, buyCnt: number }, session: BackendSession) {
const { activityId, price: clientPrice, itemId, buyCnt } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let playerData = await getGroupShopData(activityId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItemById(itemId);
if (!item) return resResult(STATUS.ACTIVITY_GROUP_SHOP_ITEM_NOT_FOUND);
if(!item.checkBuyCnt(buyCnt)) return resResult(STATUS.ACTIVITY_GROUP_SHOP_BUY_CNT_MAX);
let curDiscount = item.getCurDiscount();
let priceStatus = getGroupShopPriceStatus(clientPrice, curDiscount.price);
if(priceStatus == GROUP_SHOP_PRICE_STATUS.NOT_ENOUGH) return resResult(STATUS.ACTIVITY_GROUP_SHOP_PRICE_ERR);
let cost = [getGoldObject(curDiscount.price)];
let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
if(!result) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
// 玩家添加次数
let playerRecord = await ActivityGroupShopUserRecModel.incBuyCnt(activityId, roleId, itemId, item.id, buyCnt, new GroupShopBuyRecord(curDiscount, buyCnt));
playerData.setPlayerRecord([playerRecord]);
// 全服添加次数
let serverRecord = await ActivityGroupShopRecModel.incBuyCnt(activityId, itemId, item.id, buyCnt);
let isRankUp = playerData.incAllRecord(serverRecord);
item = playerData.findItemById(itemId);
let nextDiscount = item.getCurDiscount();
if(isRankUp) {
await ActivityGroupShopRecModel.addRecord(activityId, itemId, new GroupShopRecord(nextDiscount));
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId, itemId, sum: item.sum, curDiscount: nextDiscount });
}
let reward = [{ id: item.id, count: item.count * buyCnt }];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
return resResult(STATUS.SUCCESS, {
curItem: pick(item, ['itemId', 'id', 'sum', 'hasBoughtCnt']),
goods,
status: priceStatus,
oldDiscount: curDiscount,
nextDiscount
});
}
async debugRefund(msg: {}, session: BackendSession) {
await refundGroupShop(true);
return resResult(STATUS.SUCCESS);
}
async debugSetSum(msg: { itemId: number, sum: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let { itemId = 0, sum = 0 } = msg;
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
let recs = await ActivityGroupShopRecModel.debugSetSum(activityData.activityId, itemId, sum);
let playerData = new GroupShopData(activityData, 0, 0);
playerData.setRecords(recs);
let items = itemId == 0? playerData.items: [playerData.findItemById(itemId)];
for(let item of items) {
if(!item) continue;
let nextDiscount = item.getCurDiscount();
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId: activityData.activityId, itemId: item.itemId, sum: item.sum, curDiscount: nextDiscount });
}
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
async debugClearCnt(msg: { }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
await ActivityGroupShopUserRecModel.clearCnt(activityData.activityId, roleId);
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
}

View File

@@ -1,84 +1,85 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthFundData } from '../../../services/activity/growthFundService';
import { GrowthFundItem } from '../../../domain/activityField/growthFundField';
import { ActivityGrowthFundModel } from '../../../db/ActivityGrowthFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthFundHandler(app);
}
export class GrowthFundHandler {
constructor(private app: Application) {
}
/************************成长基金****************************/
/**
* @description 获取成长基金活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_GROWTH_FUND_END);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长基金奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.isVipActivity() && !playerData.isBuy(pageIndex)) {//vip高阶活动需要购买
return resResult(STATUS.ACTIVITY_NEED_BUY);
}
let growthFundItemData: GrowthFundItem = playerData.findGrowthFundItem(pageIndex, cellIndex);
if (!growthFundItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthFundItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
let hasReceive = await ActivityGrowthFundModel.exists({ roleId, activityId, pageIndex, cellIndex });
if (hasReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthFundModel.addRecord(activityId, roleId, pageIndex, cellIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthFundItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_FUND)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: growthFundItemData
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthFundData } from '../../../services/activity/growthFundService';
import { GrowthFundItem } from '@domain/activityField/growthFundField';
import { ActivityGrowthFundModel } from '@db/ActivityGrowthFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthFundHandler(app);
}
export class GrowthFundHandler {
constructor(private app: Application) {
}
/************************成长基金****************************/
/**
* @description 获取成长基金活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_GROWTH_FUND_END);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长基金奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.isVipActivity() && !playerData.isBuy(pageIndex)) {//vip高阶活动需要购买
return resResult(STATUS.ACTIVITY_NEED_BUY);
}
let growthFundItemData: GrowthFundItem = playerData.findGrowthFundItem(pageIndex, cellIndex);
if (!growthFundItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthFundItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
let hasReceive = await ActivityGrowthFundModel.exists({ roleId, activityId, pageIndex, cellIndex });
if (hasReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthFundModel.addRecord(activityId, roleId, pageIndex, cellIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthFundItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_FUND)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: growthFundItemData
}));
}
}

View File

@@ -1,124 +1,125 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthData } from '../../../services/activity/growthService';
import { GrowthItem, PointRewardItem } from '../../../domain/activityField/growthField';
import { ActivityGrowthModel } from '../../../db/ActivityGrowth';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityGrowthPointModel } from '../../../db/ActivityGrowthPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthHandler(app);
}
export class GrowthHandler {
constructor(private app: Application) {
}
/************************成长任务****************************/
/**
* @description 获取成长任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: GrowthItem = playerData.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if(growthItemData.dayIndex < playerData.today()) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: PointRewardItem = playerData.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthData } from '../../../services/activity/growthService';
import { GrowthItem, PointRewardItem } from '@domain/activityField/growthField';
import { ActivityGrowthModel } from '@db/ActivityGrowth';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityGrowthPointModel } from '@db/ActivityGrowthPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthHandler(app);
}
export class GrowthHandler {
constructor(private app: Application) {
}
/************************成长任务****************************/
/**
* @description 获取成长任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: GrowthItem = playerData.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if(growthItemData.dayIndex < playerData.today()) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: PointRewardItem = playerData.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
}

View File

@@ -1,86 +1,87 @@
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { isNumber } from 'underscore';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityGuildPayRecordModel } from '../../../db/ActivityGuildPayRecord';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { resResult } from '../../../pubUtils/util';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getGuildPayDataShow, getGuildPayData } from '../../../services/activity/guildPayService';
export default function (app: Application) {
return new GuildPayHandler(app);
}
export class GuildPayHandler {
constructor(private app: Application) {
}
/**
* @description 获取活动数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async getGuildPayData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayDataShow(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description (一键)领取奖励
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async receiveItems(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
if(!isNumber(cellIndex)) return resResult(STATUS.WRONG_PARMS);
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(cellIndex);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: number[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push(item.cellIndex);
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityGuildPayRecordModel.receiveItems(serverId, activityId, playerData.roundIndex, roleId, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_GUILD_PAY_REWARD);
return resResult(STATUS.SUCCESS, { items, ...result });
}
async getGuildPayMembers(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {
payMemberCnt: playerData.payMemberCnt,
payRecord: playerData.payRecord
});
}
}
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { isNumber } from 'underscore';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityGuildPayRecordModel } from '@db/ActivityGuildPayRecord';
import { RewardParam } from '@domain/activityField/rewardField';
import { resResult } from '@pubUtils/util';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getGuildPayDataShow, getGuildPayData } from '../../../services/activity/guildPayService';
export default function (app: Application) {
return new GuildPayHandler(app);
}
export class GuildPayHandler {
constructor(private app: Application) {
}
/**
* @description 获取活动数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async getGuildPayData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayDataShow(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description (一键)领取奖励
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async receiveItems(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
if(!isNumber(cellIndex)) return resResult(STATUS.WRONG_PARMS);
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(cellIndex);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: number[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push(item.cellIndex);
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityGuildPayRecordModel.receiveItems(serverId, activityId, playerData.roundIndex, roleId, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_GUILD_PAY_REWARD);
return resResult(STATUS.SUCCESS, { items, ...result });
}
async getGuildPayMembers(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {
payMemberCnt: playerData.payMemberCnt,
payRecord: playerData.payRecord
});
}
}

View File

@@ -1,134 +1,135 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { newPlayerLimitPackageActivity, getPlayerLimitPackageData } from '../../../services/activity/limitPackageService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityShopModel } from '../../../db/ActivityShop';
import moment = require('moment');
import { RoleModel } from '../../../db/Role';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new LimitPackageHandler(app);
}
export class LimitPackageHandler {
constructor(private app: Application) {
}
/************************新手限定礼包****************************/
/**
* @description 获取新手限定活动数据 开服1-7天可以购买第8天0-5点只能看不能买
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getNewPlayerLimitPackageActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_GIFT_END);
}
let playerData = await newPlayerLimitPackageActivity(serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/************************每日每周限购礼包****************************/
/**
* @description 获取每日/每周限购礼包数据
* @param {{ activityId:number, type:number }} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getLimitPackageActivity(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, id: number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number }, session: BackendSession) {
const { activityId, roundIndex, id, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
switch (playerData.type) {
case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE:
{
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END);
}
break;
}
default:
break;
}
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
await ActivityShopModel.addRecord(activityId, roleId, roundIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { newPlayerLimitPackageActivity, getPlayerLimitPackageData } from '../../../services/activity/limitPackageService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityShopModel } from '@db/ActivityShop';
import moment = require('moment');
import { RoleModel } from '@db/Role';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new LimitPackageHandler(app);
}
export class LimitPackageHandler {
constructor(private app: Application) {
}
/************************新手限定礼包****************************/
/**
* @description 获取新手限定活动数据 开服1-7天可以购买第8天0-5点只能看不能买
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getNewPlayerLimitPackageActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_GIFT_END);
}
let playerData = await newPlayerLimitPackageActivity(serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/************************每日每周限购礼包****************************/
/**
* @description 获取每日/每周限购礼包数据
* @param {{ activityId:number, type:number }} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getLimitPackageActivity(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, id: number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number }, session: BackendSession) {
const { activityId, roundIndex, id, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
switch (playerData.type) {
case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE:
{
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END);
}
break;
}
default:
break;
}
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
await ActivityShopModel.addRecord(activityId, roleId, roundIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}

View File

@@ -1,98 +1,99 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyDataShow, getPlayerLuckyData } from '../../../services/activity/luckyService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityLuckyModel } from '../../../db/ActivityLuckyRec';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableNewHandler(app);
}
export class LuckyTurntableNewHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async pull(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');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult, pool, floor } = playerData.pull(roleName, count);
await ActivityLuckyModel.updateData(serverId, activityId, roleId, playerData.roundIndex, { ...pick(playerData, ['todayCount', 'count', 'records', 'floorRecord']), refTodayCount: new Date() });
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count, pool, floor });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if (!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityLuckyModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: { ...box, isReceived: true } });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyDataShow, getPlayerLuckyData } from '../../../services/activity/luckyService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityLuckyModel } from '@db/ActivityLuckyRec';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableNewHandler(app);
}
export class LuckyTurntableNewHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async pull(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');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult, pool, floor } = playerData.pull(roleName, count);
await ActivityLuckyModel.updateData(serverId, activityId, roleId, playerData.roundIndex, { ...pick(playerData, ['todayCount', 'count', 'records', 'floorRecord']), refTodayCount: new Date() });
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count, pool, floor });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if (!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityLuckyModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: { ...box, isReceived: true } });
}
}

View File

@@ -1,98 +1,99 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyTurntableDataShow, getPlayerLuckyTurntableData } from '../../../services/activity/luckyTurntableService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityTurntableModel } from '../../../db/ActivityTurntableRec';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableHandler(app);
}
export class LuckyTurntableHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async pull(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');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult } = playerData.pull(roleName, count);
await ActivityTurntableModel.updateData(serverId, activityId, roleId, playerData.roundIndex, {...pick(playerData, ['todayCount', 'count', 'records', 'greatRewardCount']), refTodayCount: new Date()});
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if(!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityTurntableModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: {...box, isReceived: true} });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyTurntableDataShow, getPlayerLuckyTurntableData } from '../../../services/activity/luckyTurntableService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityTurntableModel } from '@db/ActivityTurntableRec';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableHandler(app);
}
export class LuckyTurntableHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async pull(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');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult } = playerData.pull(roleName, count);
await ActivityTurntableModel.updateData(serverId, activityId, roleId, playerData.roundIndex, {...pick(playerData, ['todayCount', 'count', 'records', 'greatRewardCount']), refTodayCount: new Date()});
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if(!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityTurntableModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: {...box, isReceived: true} });
}
}

View File

@@ -1,183 +1,184 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityMidAutumnRecModel } from '../../../db/ActivityMidAutumnRec';
import { RewardInter } from '../../../pubUtils/interface';
import { getPlayerMidAutumnData, getPlayerMidAutumnDataShow } from '../../../services/activity/midAutumnService';
import { combineItems } from '../../../services/role/util';
export default function (app: Application) {
new HandlerService(app, {});
return new MidAutumnHandler(app);
}
export class MidAutumnHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 游戏开始
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, hasPass: false, isSkip: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode
});
}
/**
* @description 游戏结束
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityMidAutumnRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), playerData.rewards);
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(isSuccess) {
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.MID_AUTUMN_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number, count: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let rewards: RewardInter[] = [];
for(let i = 0; i < count; i++) {
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.rewards, isSuccess: true, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
rewards.push(...stringToRewardParam(playerData.rewards));
}
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.MID_AUTUMN_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
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 getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityMidAutumnRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityMidAutumnRecModel } from '@db/ActivityMidAutumnRec';
import { RewardInter } from '@pubUtils/interface';
import { getPlayerMidAutumnData, getPlayerMidAutumnDataShow } from '../../../services/activity/midAutumnService';
import { combineItems } from '../../../services/role/util';
export default function (app: Application) {
new HandlerService(app, {});
return new MidAutumnHandler(app);
}
export class MidAutumnHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 游戏开始
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, hasPass: false, isSkip: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode
});
}
/**
* @description 游戏结束
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityMidAutumnRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), playerData.rewards);
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(isSuccess) {
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.MID_AUTUMN_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number, count: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let rewards: RewardInter[] = [];
for(let i = 0; i < count; i++) {
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.rewards, isSuccess: true, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
rewards.push(...stringToRewardParam(playerData.rewards));
}
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.MID_AUTUMN_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
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 getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityMidAutumnRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}

View File

@@ -1,217 +1,218 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, MINI_GAME_TYPE, REDIS_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerMiniGameData, getPlayerMiniGameDataShow } from '../../../services/activity/miniGameService';
import { ActivityMiniGameRecModel } from '../../../db/ActivityMiniGameRec';
import { ActivityMiniGameModel } from '../../../db/ActivityMiniGame';
import { handleCost } from '../../../services/role/rewardService';
import { Rank } from '../../../services/rankService';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { RoleRankInfo } from '../../../domain/rank';
import { getAllServerName } from '../../../services/redisService';
import { checkTask } from '../../../services/task/taskService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 小游戏数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getMiniGameActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 小游戏开始
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.playCnt >= playerData.buyCnt + playerData.freeCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_COUNT_LACK);
let record = await ActivityMiniGameRecModel.gameStart(serverId, activityId, playerData.roundIndex, playerData.todayIndex, roleId, playerData.gameType);
return resResult(STATUS.SUCCESS, {
activityId,
gameCode: record.gameCode,
playCnt: playerData.playCnt
});
}
/**
* @description 小游戏结束
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, score: number, params: number[] }, session: BackendSession) {
let { activityId, gameCode, score, params } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 记录得分&次数
let record = await ActivityMiniGameRecModel.gameEnd(activityId, roleId, gameCode, score, params);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI && score > 100) score = 100;
let playerRecord = await ActivityMiniGameModel.incScore(serverId, activityId, playerData.roundIndex, roleId, score, playerData.nextRefreshTime);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
playerData.setPlayerData(playerRecord);
playerData.incPlayCnt();
let rewards = stringToRewardParam(playerData.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
await r.setRankWithRoleInfo(roleId, score, nowSeconds(), null, true);
if(playerData.gameType == MINI_GAME_TYPE.SHOOT) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SHOOT, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.ERASE) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_ERASE, { step: params[0] });
} else if(playerData.gameType == MINI_GAME_TYPE.EAT_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_EAT_ZONGZI, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_CATCH_ZONGZI, { score });
} else {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SCORE, { gameType: playerData.gameType, score });
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_STEP, { gameType: playerData.gameType, step: params[0] });
}
return resResult(STATUS.SUCCESS, {
activityId,
gameCode,
playCnt: playerData.playCnt,
score: playerData.score,
goods
});
}
/**
* @description 购买挑战次数
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
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 getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_BUY_COUNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_MINI_GAME_BUY_CNT);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let playerRecord = await ActivityMiniGameModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count, playerData.nextRefreshTime);
playerData.setPlayerData(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
buyCnt: playerData.buyCnt,
maxBuyCnt: playerData.maxBuyCnt
});
}
/**
* @description 领取宝箱
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async receiveBox(msg: { activityId: number, boxId: number }, session: BackendSession) {
const { activityId, boxId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.findBox(boxId);
if(!box) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_NOT_FOUND);
if(box.hasReceived) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
if(box.score > playerData.score) return resResult(STATUS.ACTIVITY_MINI_GAME_SCORE_NOT_ENOUGH);
let result = await ActivityMiniGameModel.receiveBox(serverId, activityId, playerData.roundIndex, roleId, boxId);
if(!result) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
playerData.setPlayerData(result);
let rewards = stringToRewardParam(box.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
curBox: playerData.findBox(boxId),
goods
});
}
/**
* @description 排行榜
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getRanks(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let serverNames = await getAllServerName();
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
r.setGenerFieldsFun((obj => {
if(obj instanceof RoleRankInfo) {
return { rank: obj.rank, roleId: obj.roleId, name: obj.roleName, serverId: obj.serverId, serverName: serverNames[obj.serverId], num: obj.num }
}
return null
}));
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
if (!myRank) {
myRank = await r.generMyRankWithRole(roleId, playerData.score, nowSeconds());
}
return resResult(STATUS.SUCCESS, {
activityId,
gameType: playerData.gameType,
ranks, myRank
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, MINI_GAME_TYPE, REDIS_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerMiniGameData, getPlayerMiniGameDataShow } from '../../../services/activity/miniGameService';
import { ActivityMiniGameRecModel } from '@db/ActivityMiniGameRec';
import { ActivityMiniGameModel } from '@db/ActivityMiniGame';
import { handleCost } from '../../../services/role/rewardService';
import { Rank } from '../../../services/rankService';
import { nowSeconds } from '@pubUtils/timeUtil';
import { RoleRankInfo } from '@domain/rank';
import { getAllServerName } from '../../../services/redisService';
import { checkTask } from '../../../services/task/taskService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 小游戏数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getMiniGameActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 小游戏开始
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.playCnt >= playerData.buyCnt + playerData.freeCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_COUNT_LACK);
let record = await ActivityMiniGameRecModel.gameStart(serverId, activityId, playerData.roundIndex, playerData.todayIndex, roleId, playerData.gameType);
return resResult(STATUS.SUCCESS, {
activityId,
gameCode: record.gameCode,
playCnt: playerData.playCnt
});
}
/**
* @description 小游戏结束
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, score: number, params: number[] }, session: BackendSession) {
let { activityId, gameCode, score, params } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 记录得分&次数
let record = await ActivityMiniGameRecModel.gameEnd(activityId, roleId, gameCode, score, params);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI && score > 100) score = 100;
let playerRecord = await ActivityMiniGameModel.incScore(serverId, activityId, playerData.roundIndex, roleId, score, playerData.nextRefreshTime);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
playerData.setPlayerData(playerRecord);
playerData.incPlayCnt();
let rewards = stringToRewardParam(playerData.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
await r.setRankWithRoleInfo(roleId, score, nowSeconds(), null, true);
if(playerData.gameType == MINI_GAME_TYPE.SHOOT) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SHOOT, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.ERASE) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_ERASE, { step: params[0] });
} else if(playerData.gameType == MINI_GAME_TYPE.EAT_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_EAT_ZONGZI, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_CATCH_ZONGZI, { score });
} else {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SCORE, { gameType: playerData.gameType, score });
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_STEP, { gameType: playerData.gameType, step: params[0] });
}
return resResult(STATUS.SUCCESS, {
activityId,
gameCode,
playCnt: playerData.playCnt,
score: playerData.score,
goods
});
}
/**
* @description 购买挑战次数
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
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 getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_BUY_COUNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_MINI_GAME_BUY_CNT);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let playerRecord = await ActivityMiniGameModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count, playerData.nextRefreshTime);
playerData.setPlayerData(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
buyCnt: playerData.buyCnt,
maxBuyCnt: playerData.maxBuyCnt
});
}
/**
* @description 领取宝箱
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async receiveBox(msg: { activityId: number, boxId: number }, session: BackendSession) {
const { activityId, boxId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.findBox(boxId);
if(!box) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_NOT_FOUND);
if(box.hasReceived) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
if(box.score > playerData.score) return resResult(STATUS.ACTIVITY_MINI_GAME_SCORE_NOT_ENOUGH);
let result = await ActivityMiniGameModel.receiveBox(serverId, activityId, playerData.roundIndex, roleId, boxId);
if(!result) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
playerData.setPlayerData(result);
let rewards = stringToRewardParam(box.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
curBox: playerData.findBox(boxId),
goods
});
}
/**
* @description 排行榜
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getRanks(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let serverNames = await getAllServerName();
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
r.setGenerFieldsFun((obj => {
if(obj instanceof RoleRankInfo) {
return { rank: obj.rank, roleId: obj.roleId, name: obj.roleName, serverId: obj.serverId, serverName: serverNames[obj.serverId], num: obj.num }
}
return null
}));
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
if (!myRank) {
myRank = await r.generMyRankWithRole(roleId, playerData.score, nowSeconds());
}
return resResult(STATUS.SUCCESS, {
activityId,
gameType: playerData.gameType,
ranks, myRank
});
}
}

View File

@@ -1,86 +1,87 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getMonthlyFundData, getMonthlyFundDataShow } from '../../../services/activity/monthlyFundService';
import { ActivityWeeklyFundModel } from '../../../db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityMonthlyFundModel } from '../../../db/ActivityMonthlyFund';
import { monthlyFundSchedule } from '../../../services/timeTaskService';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyFundHandler(app);
}
export class MonthlyFundHandler {
constructor(private app: Application) {
}
/************************月基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async sign(msg: { activityId: number, pageIndex: number, dayIndex: number }, session: BackendSession) {
const { activityId, pageIndex, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pageData = playerData.findPage(pageIndex);
if (!pageData) return resResult(STATUS.ACTIVITY_MISSING);
if(!pageData.hasBought) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_BOUGHT);
let signReward = pageData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_LOCK);
let record = await ActivityMonthlyFundModel.sign(serverId, activityId, roleId, playerData.roundIndex, pageIndex, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
pageData.setPlayerRecord(record);
if(pageData.hasReceivedAll()) {
await ActivityMonthlyFundModel.setReceivedAll(serverId, activityId, roleId, playerData.roundIndex, pageIndex);
}
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_MONTHLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, pageIndex, goods, addHeros
});
}
async debugSendMonthlyFundReward(msg: {}, session: BackendSession) {
await monthlyFundSchedule(parseInt(moment().format('YYYYMM')));
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getMonthlyFundData, getMonthlyFundDataShow } from '../../../services/activity/monthlyFundService';
import { ActivityWeeklyFundModel } from '@db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityMonthlyFundModel } from '@db/ActivityMonthlyFund';
import { monthlyFundSchedule } from '../../../services/timeTaskService';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyFundHandler(app);
}
export class MonthlyFundHandler {
constructor(private app: Application) {
}
/************************月基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async sign(msg: { activityId: number, pageIndex: number, dayIndex: number }, session: BackendSession) {
const { activityId, pageIndex, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pageData = playerData.findPage(pageIndex);
if (!pageData) return resResult(STATUS.ACTIVITY_MISSING);
if(!pageData.hasBought) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_BOUGHT);
let signReward = pageData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_LOCK);
let record = await ActivityMonthlyFundModel.sign(serverId, activityId, roleId, playerData.roundIndex, pageIndex, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
pageData.setPlayerRecord(record);
if(pageData.hasReceivedAll()) {
await ActivityMonthlyFundModel.setReceivedAll(serverId, activityId, roleId, playerData.roundIndex, pageIndex);
}
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_MONTHLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, pageIndex, goods, addHeros
});
}
async debugSendMonthlyFundReward(msg: {}, session: BackendSession) {
await monthlyFundSchedule(parseInt(moment().format('YYYYMM')));
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,54 +1,55 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, } from '../../../consts';
import { getPlayerMonthlyTicketData, getPlayerMonthlyTicketDayReward } from '../../../services/activity/monthlyTicketService';
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyTicketHandler(app);
}
export class MonthlyTicketHandler {
constructor(private app: Application) {
}
/************************月卡活动****************************/
/**
* @description 获取月卡活动数据
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMonthlyTicketData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取月卡奖品
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let result = await getPlayerMonthlyTicketDayReward(roleId, roleName, sid, serverId, activityId)
if (result) {
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
}));
}
return resResult(STATUS.NO_MOTHLY_TICKET_REWARD);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, } from '../../../consts';
import { getPlayerMonthlyTicketData, getPlayerMonthlyTicketDayReward } from '../../../services/activity/monthlyTicketService';
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyTicketHandler(app);
}
export class MonthlyTicketHandler {
constructor(private app: Application) {
}
/************************月卡活动****************************/
/**
* @description 获取月卡活动数据
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMonthlyTicketData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取月卡奖品
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let result = await getPlayerMonthlyTicketDayReward(roleId, roleName, sid, serverId, activityId)
if (result) {
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
}));
}
return resResult(STATUS.NO_MOTHLY_TICKET_REWARD);
}
}

View File

@@ -1,74 +1,75 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGKData } from '../../../services/activity/newHeroGKService';
import { ActivityNewHeroGKModel } from '../../../db/ActivityNewHeroGK';
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);
}
async debugResetGK(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
await ActivityNewHeroGKModel.deleteMany({ roleId });
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGKData } from '../../../services/activity/newHeroGKService';
import { ActivityNewHeroGKModel } from '@db/ActivityNewHeroGK';
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);
}
async debugResetGK(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
await ActivityNewHeroGKModel.deleteMany({ roleId });
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,33 +1,34 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGachaData } from '../../../services/activity/newHeroService';
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 getData(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);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGachaData } from '../../../services/activity/newHeroService';
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 getData(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);
}
}

View File

@@ -1,73 +1,74 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityNewHeroGiftModel } from '../../../db/ActivityNewHeroGift';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGiftsHandler(app);
}
export class NewHeroGiftsHandler {
constructor(private app: Application) {
}
/************************新将好礼,很多红包,用积分兑换一遍结束****************************/
/**
* @description 获取新将好礼活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGiftsHandler
*/
async getNewHeroGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 兑换点数
* @param {{ activityId: number, index:number}} msg
* @param {BackendSession} session
* @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');
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 (playerData.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, playerData.consumePoint);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, index },
item: item, consumeTotalPoint: playerData.consumeTotalPoint + playerData.consumePoint
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroService';
import { RewardParam } from '@domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityNewHeroGiftModel } from '@db/ActivityNewHeroGift';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGiftsHandler(app);
}
export class NewHeroGiftsHandler {
constructor(private app: Application) {
}
/************************新将好礼,很多红包,用积分兑换一遍结束****************************/
/**
* @description 获取新将好礼活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGiftsHandler
*/
async getNewHeroGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 兑换点数
* @param {{ activityId: number, index:number}} msg
* @param {BackendSession} session
* @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');
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 (playerData.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, playerData.consumePoint);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, index },
item: item, consumeTotalPoint: playerData.consumeTotalPoint + playerData.consumePoint
}));
}
}

View File

@@ -1,170 +1,171 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getPlayerNovemberData, getPlayerNovemberDataShow } from '../../../services/activity/novemberServices';
import { genCode, getRandSingleEelm, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityNovemberRecModel, NovemberRecord } from '../../../db/ActivityNovemberRec';
import { RewardInter } from '../../../pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';
/**
* 辜月集会
* @param app
* @returns
*/
export default function (app: Application) {
new HandlerService(app, {});
return new NovemberHandler(app);
}
export class NovemberHandler {
constructor(private app: Application) {
}
/**
* 获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* 开始游戏
* @param msg
* @param session
* @returns
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData || playerData.menuIds.length == 0) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
const gameCode = genCode(10);
const menuId = getRandSingleEelm(playerData.menuIds);
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, isSkip: false, menuId, hasPass: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode, menuId });
}
/**
* 结束游戏
* @param msg
* @param session
* @returns
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.records || playerData.records.length == 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
let record = playerData.records.find(cur => cur.gameCode == gameCode);
if (!record) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
if (record.hasPass) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_USE);
let menuId = record.menuId;
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: string = playerData.successRewards;
if (!isSuccess) rewards = '&';//playerData.failRewards;
let playerRecord = await ActivityNovemberRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), rewards, true);
if (!playerRecord) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
let goods: RewardInter[] = await addItems(roleId, roleName, sid, stringToRewardParam(rewards), ITEM_CHANGE_REASON.NOVEMBER_REWARD);
return resResult(STATUS.SUCCESS, { activityId, menuId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, freeCnt: playerData.freeCnt, goods });
}
/**
* 购买次数
* @param msg
* @param session
* @returns
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.NOVEMBER_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let buyResult = await ActivityNovemberRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
if (!buyResult) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, buyCnt: playerData.buyCnt, maxBuyCnt: playerData.maxBuyCnt });
}
/**
* 扫荡
* @param msg
* @param session
* @returns
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.menuIds.length == 0) return (STATUS.ACTIVITY_NOVEMBER_MENU_NOT_FIND)
if (playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMESWEEP_LOCK);
if (playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: RewardInter[] = [];
let records: NovemberRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.successRewards, isSuccess: true, isSkip: true, menuId: 0, hasPass: true })
rewards.push(...stringToRewardParam(playerData.successRewards));
}
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.NOVEMBER_REWARD)
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, goods });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getPlayerNovemberData, getPlayerNovemberDataShow } from '../../../services/activity/novemberServices';
import { genCode, getRandSingleEelm, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityNovemberRecModel, NovemberRecord } from '@db/ActivityNovemberRec';
import { RewardInter } from '@pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getZeroPoint } from '@pubUtils/timeUtil';
/**
* 辜月集会
* @param app
* @returns
*/
export default function (app: Application) {
new HandlerService(app, {});
return new NovemberHandler(app);
}
export class NovemberHandler {
constructor(private app: Application) {
}
/**
* 获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* 开始游戏
* @param msg
* @param session
* @returns
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData || playerData.menuIds.length == 0) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
const gameCode = genCode(10);
const menuId = getRandSingleEelm(playerData.menuIds);
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, isSkip: false, menuId, hasPass: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode, menuId });
}
/**
* 结束游戏
* @param msg
* @param session
* @returns
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.records || playerData.records.length == 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
let record = playerData.records.find(cur => cur.gameCode == gameCode);
if (!record) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
if (record.hasPass) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_USE);
let menuId = record.menuId;
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: string = playerData.successRewards;
if (!isSuccess) rewards = '&';//playerData.failRewards;
let playerRecord = await ActivityNovemberRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), rewards, true);
if (!playerRecord) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
let goods: RewardInter[] = await addItems(roleId, roleName, sid, stringToRewardParam(rewards), ITEM_CHANGE_REASON.NOVEMBER_REWARD);
return resResult(STATUS.SUCCESS, { activityId, menuId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, freeCnt: playerData.freeCnt, goods });
}
/**
* 购买次数
* @param msg
* @param session
* @returns
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.NOVEMBER_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let buyResult = await ActivityNovemberRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
if (!buyResult) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, buyCnt: playerData.buyCnt, maxBuyCnt: playerData.maxBuyCnt });
}
/**
* 扫荡
* @param msg
* @param session
* @returns
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.menuIds.length == 0) return (STATUS.ACTIVITY_NOVEMBER_MENU_NOT_FIND)
if (playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMESWEEP_LOCK);
if (playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: RewardInter[] = [];
let records: NovemberRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.successRewards, isSuccess: true, isSkip: true, menuId: 0, hasPass: true })
rewards.push(...stringToRewardParam(playerData.successRewards));
}
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.NOVEMBER_REWARD)
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, goods });
}
}

View File

@@ -1,197 +1,198 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, } from '../../../pubUtils/util';
import { STATUS, ITEM_CHANGE_REASON, POP_UP_SHOP_CONDITION_TYPE, ACTIVITY_TYPE, DEBUG_MAGIC_WORD, PUSH_ROUTE, } from '../../../consts';
import { checkPopUpCondition, getPopUpShopData, getPopUpShopDataShow } from '../../../services/activity/popUpShopService';
import { ActivityPopUpShopModel } from '../../../db/ActivityPopUpShop';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { handleCost } from '../../../services/role/rewardService';
import { setInterval } from 'timers';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new PopUpShopHandler(app);
}
export class PopUpShopHandler {
constructor(private app: Application) {
}
/************************弹出式商店****************************/
/**
* @description 获取弹出式商店数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async getPopUpShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPopUpShopDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData });
}
async checkPopUpCondition(msg: { conditionType: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { conditionType } = msg;
if(
conditionType != POP_UP_SHOP_CONDITION_TYPE.GACHA_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.TERAPH_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.STONE_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EQUIP_STAR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.FAVOR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EXP_NOT_ENOUGH
) {
return resResult(STATUS.WRONG_PARMS);
}
await checkPopUpCondition(serverId, roleId, conditionType, {});
return resResult(STATUS.SUCCESS);
}
/**
* @description 购买礼包
* @param {{ activityId: number, id: number, beginTimeStamp: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async buyGift(msg: { activityId: number, id: number, code: string }, session: BackendSession) {
const { activityId, code, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPopUpShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.type !== ACTIVITY_TYPE.POP_UP_SHOP) {
return resResult(STATUS.ACTIVITY_TYPE_ERROR);
}
let record = await ActivityPopUpShopModel.findByCode(serverId, activityId, roleId, code);
if(!record) return resResult(STATUS.ACTIVITY_TASK_NOT_COMPLETE);
let pkg = playerData.findPackageById(record.id);
let item = pkg?.findItemById(id);
if(!item) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if(item.productID) {
return resResult(STATUS.ACTIVITY_POP_UP_MUST_BUY);
}
let consume = stringToConsumeParam(item.consume);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
record = await ActivityPopUpShopModel.addRecordById(serverId, activityId, roleId, code, id);
let showItem = playerData.updateRecordById(record, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)
return resResult(STATUS.SUCCESS, {
...result, param: { activityId, id },
item: showItem
});
}
// 客户端展示弹出礼包的通知
async showGift(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let rec = await ActivityPopUpShopModel.show(code);
if (!rec) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS);
}
async debugPushPopUpShop(msg: { conditionType: number, magicWord: string, param: number, needDelete: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
let serverId = session.get('serverId');
const { magicWord, conditionType, param } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
// let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.POP_UP_SHOP);
// for(let { activityId } of activities) {
// let playerData = await getPopUpShopData(activityId, serverId, roleId);
// for(let pkg of playerData.packages) {
// if(pkg.conditionType == conditionType) {
// await ActivityPopUpShopModel.deleteMany({ roleId, activityId, id: pkg.id });
// }
// }
// }
let arr = await checkPopUpCondition(serverId, roleId, conditionType, {
oldLv: param? param - 1: 0,
newLv: param||100,
quality: param||3,
warId: param||128,
seasonWinNum: param||10,
equipStar: param||10
});
return resResult(STATUS.SUCCESS, { activities:arr });
}
private interval: NodeJS.Timer;
private pushId = 0;
async debugPushPopUpInterval(msg: { magicWord: string }, session: BackendSession) {
const roleId = session.get('roleId');
let sid = session.get('sid');
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
let fun = async () => {
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_UPDATE, {
activities: [{
activityId: 25,
activityType: 24,
param: { popUpShopItems: [
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":1,"name":"超值第一章通关礼包","price":6,"productID":"com.bantu.sgzzyz.yb34-20","consume":"&","reward":"2&11002&20|2&22001&2|2&31001&10000","rebate":1000,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":2,"name":"超值第一章通关礼包","price":30,"productID":"com.bantu.sgzzyz.yb34-21","consume":"&","reward":"2&11002&40|2&22001&10|2&31001&20000","rebate":850,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":3,"name":"超值第一章通关礼包","price":68,"productID":"com.bantu.sgzzyz.yb34-22","consume":"&","reward":"2&11003&20|2&22001&25|2&31001&40000","rebate":950,"buyCnt":1,"hasBoughtCnt":0}
]},
}],
pushId: ++this.pushId
}, sid);
};
await fun();
this.interval = setInterval(fun, 60000)
return resResult(STATUS.SUCCESS);
}
async debugStopPupUpInterval(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
this.pushId = 0;
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, } from '@pubUtils/util';
import { STATUS, ITEM_CHANGE_REASON, POP_UP_SHOP_CONDITION_TYPE, ACTIVITY_TYPE, DEBUG_MAGIC_WORD, PUSH_ROUTE, } from '../../../consts';
import { checkPopUpCondition, getPopUpShopData, getPopUpShopDataShow } from '../../../services/activity/popUpShopService';
import { ActivityPopUpShopModel } from '@db/ActivityPopUpShop';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { handleCost } from '../../../services/role/rewardService';
import { setInterval } from 'timers';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new PopUpShopHandler(app);
}
export class PopUpShopHandler {
constructor(private app: Application) {
}
/************************弹出式商店****************************/
/**
* @description 获取弹出式商店数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async getPopUpShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPopUpShopDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData });
}
async checkPopUpCondition(msg: { conditionType: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { conditionType } = msg;
if(
conditionType != POP_UP_SHOP_CONDITION_TYPE.GACHA_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.TERAPH_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.STONE_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EQUIP_STAR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.FAVOR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EXP_NOT_ENOUGH
) {
return resResult(STATUS.WRONG_PARMS);
}
await checkPopUpCondition(serverId, roleId, conditionType, {});
return resResult(STATUS.SUCCESS);
}
/**
* @description 购买礼包
* @param {{ activityId: number, id: number, beginTimeStamp: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async buyGift(msg: { activityId: number, id: number, code: string }, session: BackendSession) {
const { activityId, code, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPopUpShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.type !== ACTIVITY_TYPE.POP_UP_SHOP) {
return resResult(STATUS.ACTIVITY_TYPE_ERROR);
}
let record = await ActivityPopUpShopModel.findByCode(serverId, activityId, roleId, code);
if(!record) return resResult(STATUS.ACTIVITY_TASK_NOT_COMPLETE);
let pkg = playerData.findPackageById(record.id);
let item = pkg?.findItemById(id);
if(!item) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if(item.productID) {
return resResult(STATUS.ACTIVITY_POP_UP_MUST_BUY);
}
let consume = stringToConsumeParam(item.consume);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
record = await ActivityPopUpShopModel.addRecordById(serverId, activityId, roleId, code, id);
let showItem = playerData.updateRecordById(record, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)
return resResult(STATUS.SUCCESS, {
...result, param: { activityId, id },
item: showItem
});
}
// 客户端展示弹出礼包的通知
async showGift(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let rec = await ActivityPopUpShopModel.show(code);
if (!rec) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS);
}
async debugPushPopUpShop(msg: { conditionType: number, magicWord: string, param: number, needDelete: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
let serverId = session.get('serverId');
const { magicWord, conditionType, param } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
// let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.POP_UP_SHOP);
// for(let { activityId } of activities) {
// let playerData = await getPopUpShopData(activityId, serverId, roleId);
// for(let pkg of playerData.packages) {
// if(pkg.conditionType == conditionType) {
// await ActivityPopUpShopModel.deleteMany({ roleId, activityId, id: pkg.id });
// }
// }
// }
let arr = await checkPopUpCondition(serverId, roleId, conditionType, {
oldLv: param? param - 1: 0,
newLv: param||100,
quality: param||3,
warId: param||128,
seasonWinNum: param||10,
equipStar: param||10
});
return resResult(STATUS.SUCCESS, { activities:arr });
}
private interval: NodeJS.Timer;
private pushId = 0;
async debugPushPopUpInterval(msg: { magicWord: string }, session: BackendSession) {
const roleId = session.get('roleId');
let sid = session.get('sid');
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
let fun = async () => {
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_UPDATE, {
activities: [{
activityId: 25,
activityType: 24,
param: { popUpShopItems: [
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":1,"name":"超值第一章通关礼包","price":6,"productID":"com.bantu.sgzzyz.yb34-20","consume":"&","reward":"2&11002&20|2&22001&2|2&31001&10000","rebate":1000,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":2,"name":"超值第一章通关礼包","price":30,"productID":"com.bantu.sgzzyz.yb34-21","consume":"&","reward":"2&11002&40|2&22001&10|2&31001&20000","rebate":850,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":3,"name":"超值第一章通关礼包","price":68,"productID":"com.bantu.sgzzyz.yb34-22","consume":"&","reward":"2&11003&20|2&22001&25|2&31001&40000","rebate":950,"buyCnt":1,"hasBoughtCnt":0}
]},
}],
pushId: ++this.pushId
}, sid);
};
await fun();
this.interval = setInterval(fun, 60000)
return resResult(STATUS.SUCCESS);
}
async debugStopPupUpInterval(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
this.pushId = 0;
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,186 +1,187 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getPlayerQixiData, getPlayerQixiDataShow } from '../../../services/activity/qixiService';
import { ActivityQixiRecModel } from '../../../db/ActivityQixiRec';
import { RewardInter } from '../../../pubUtils/interface';
export default function (app: Application) {
new HandlerService(app, {});
return new QiXiHandler(app);
}
export class QiXiHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameStart(msg: { activityId: number, progress: number }, session: BackendSession) {
const { activityId, progress } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', progress, afterProgress: progress, hasPass: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress
});
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, progress: number, addProgress: number }, session: BackendSession) {
const { activityId, gameCode, progress, addProgress } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityQixiRecModel.addProgress(serverId, activityId, playerData.roundIndex, roleId, gameCode, addProgress, new Date());
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(playerData.progress >= playerData.maxProgress) {
await ActivityQixiRecModel.recordReward(serverId, activityId, playerData.roundIndex, roleId, gameCode, playerData.rewards);
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameSweep(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: '', time: new Date(), rewards: playerData.rewards, progress: 0, afterProgress: playerData.maxProgress, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let rewards = stringToRewardParam(playerData.rewards);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
progress: playerData.progress,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
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 getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// if(playerData.playCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityQixiRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getPlayerQixiData, getPlayerQixiDataShow } from '../../../services/activity/qixiService';
import { ActivityQixiRecModel } from '@db/ActivityQixiRec';
import { RewardInter } from '@pubUtils/interface';
export default function (app: Application) {
new HandlerService(app, {});
return new QiXiHandler(app);
}
export class QiXiHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameStart(msg: { activityId: number, progress: number }, session: BackendSession) {
const { activityId, progress } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', progress, afterProgress: progress, hasPass: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress
});
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, progress: number, addProgress: number }, session: BackendSession) {
const { activityId, gameCode, progress, addProgress } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityQixiRecModel.addProgress(serverId, activityId, playerData.roundIndex, roleId, gameCode, addProgress, new Date());
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(playerData.progress >= playerData.maxProgress) {
await ActivityQixiRecModel.recordReward(serverId, activityId, playerData.roundIndex, roleId, gameCode, playerData.rewards);
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameSweep(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: '', time: new Date(), rewards: playerData.rewards, progress: 0, afterProgress: playerData.maxProgress, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let rewards = stringToRewardParam(playerData.rewards);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
progress: playerData.progress,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
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 getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// if(playerData.playCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityQixiRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}

View File

@@ -1,78 +1,79 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRebateDataShow, getPlayerRebateData } from '../../../services/activity/rebateService';
import { HistoryOrderModel } from '../../../db/HistoryOrder';
import { UserModel } from '../../../db/User';
export default function (app: Application) {
new HandlerService(app, {});
return new RebateHandler(app);
}
export class RebateHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getPlayerRebateDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RebateHandler
*/
async receiveReward(msg: { activityId: number, day: number }, session: BackendSession) {
const { activityId, day } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getPlayerRebateData(activityId, roleId, serverId, uid);
let item = playerData.findRebateByDay(day);
if(!item) return resResult(STATUS.WRONG_PARMS);
if(item.day > playerData.todayIndex) return resResult(STATUS.ACTIVITY_REBATE_DAY_NOT_REACH);
if(item.hasReceived) return resResult(STATUS.ACTIVITY_REBATE_HAS_RECEIVED);
// console.log('####', playerData.channelId, roleId, day)
await HistoryOrderModel.receive(playerData.channelId, roleId, day);
let rewardArray = stringToRewardParam(item.rewards);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.RECEIVE_REBATE);
return resResult(STATUS.SUCCESS, {
activityId, day,
hasReceived: true,
goods, addHeros
});
}
// debug接口让自己能返利
async debugSetRebate(msg: { totalPay: number }, session: BackendSession) {
const { totalPay } = msg;
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
if(!user.channelId) {
user = await UserModel.findOneAndUpdate({ uid }, { $set: { channelId: genCode(10) } }, { new: true }).lean();
}
await HistoryOrderModel.deleteMany({ channelId: user.channelId });
await HistoryOrderModel.insertMany([{ channelId: user.channelId, totalPay }]);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { genCode, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRebateDataShow, getPlayerRebateData } from '../../../services/activity/rebateService';
import { HistoryOrderModel } from '@db/HistoryOrder';
import { UserModel } from '@db/User';
export default function (app: Application) {
new HandlerService(app, {});
return new RebateHandler(app);
}
export class RebateHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getPlayerRebateDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RebateHandler
*/
async receiveReward(msg: { activityId: number, day: number }, session: BackendSession) {
const { activityId, day } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getPlayerRebateData(activityId, roleId, serverId, uid);
let item = playerData.findRebateByDay(day);
if(!item) return resResult(STATUS.WRONG_PARMS);
if(item.day > playerData.todayIndex) return resResult(STATUS.ACTIVITY_REBATE_DAY_NOT_REACH);
if(item.hasReceived) return resResult(STATUS.ACTIVITY_REBATE_HAS_RECEIVED);
// console.log('####', playerData.channelId, roleId, day)
await HistoryOrderModel.receive(playerData.channelId, roleId, day);
let rewardArray = stringToRewardParam(item.rewards);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.RECEIVE_REBATE);
return resResult(STATUS.SUCCESS, {
activityId, day,
hasReceived: true,
goods, addHeros
});
}
// debug接口让自己能返利
async debugSetRebate(msg: { totalPay: number }, session: BackendSession) {
const { totalPay } = msg;
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
if(!user.channelId) {
user = await UserModel.findOneAndUpdate({ uid }, { $set: { channelId: genCode(10) } }, { new: true }).lean();
}
await HistoryOrderModel.deleteMany({ channelId: user.channelId });
await HistoryOrderModel.insertMany([{ channelId: user.channelId, totalPay }]);
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,75 +1,76 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRechargeMoneyData, getPlayerRechargeMoneyDataShow } from '../../../services/activity/rechargeMoneyService';
import { RechargeMoneyPool } from '../../../domain/activityField/rechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityRechargeMoneyModel } from '../../../db/ActivityRechargeMoney';
import { addItems } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RechargeMoneyHandler(app);
}
export class RechargeMoneyHandler {
constructor(private app: Application) {
}
/************************每日累计充值****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async getRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRechargeMoneyDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {playerData});
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async pull(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.ticketCnt <= 0) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let item = playerData.pull();
if (!item) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let notGetRecord = playerData.recordArr[0];
// console.log('notGetRecord', JSON.stringify(notGetRecord));
await ActivityRechargeMoneyModel.addRecord(notGetRecord._id, item.id, `${item.gid}&${item.count}`);
let goods = await addItems(roleId, roleName, sid, [{ id: item.gid, count: item.count }], ITEM_CHANGE_REASON.RECHARGE_REWARD)
return resResult(STATUS.SUCCESS, {
param: { activityId },
item: item,
ticketCnt: playerData.ticketCnt,
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRechargeMoneyData, getPlayerRechargeMoneyDataShow } from '../../../services/activity/rechargeMoneyService';
import { RechargeMoneyPool } from '@domain/activityField/rechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityRechargeMoneyModel } from '@db/ActivityRechargeMoney';
import { addItems } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RechargeMoneyHandler(app);
}
export class RechargeMoneyHandler {
constructor(private app: Application) {
}
/************************每日累计充值****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async getRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRechargeMoneyDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {playerData});
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async pull(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.ticketCnt <= 0) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let item = playerData.pull();
if (!item) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let notGetRecord = playerData.recordArr[0];
// console.log('notGetRecord', JSON.stringify(notGetRecord));
await ActivityRechargeMoneyModel.addRecord(notGetRecord._id, item.id, `${item.gid}&${item.count}`);
let goods = await addItems(roleId, roleName, sid, [{ id: item.gid, count: item.count }], ITEM_CHANGE_REASON.RECHARGE_REWARD)
return resResult(STATUS.SUCCESS, {
param: { activityId },
item: item,
ticketCnt: playerData.ticketCnt,
});
}
}

View File

@@ -1,91 +1,92 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshShopData } from '../../../services/activity/refreshShopService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityRefreshShopModel } from '../../../db/ActivityRefreshShop';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshShopHandler(app);
}
export class RefreshShopHandler {
constructor(private app: Application) {
}
/************************通用的刷新商店分页可刷新限制购买次数支持rmb与资源兑换****************************/
/**
* @description 获取商店数据
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买
* @param {{ activityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number, pageIndex: number, count: number }, session: BackendSession) {
const { activityId, roundIndex, id, pageIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consumeArr = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeArr);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id, count);
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshShopData } from '../../../services/activity/refreshShopService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityRefreshShopModel } from '@db/ActivityRefreshShop';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshShopHandler(app);
}
export class RefreshShopHandler {
constructor(private app: Application) {
}
/************************通用的刷新商店分页可刷新限制购买次数支持rmb与资源兑换****************************/
/**
* @description 获取商店数据
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买
* @param {{ activityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number, pageIndex: number, count: number }, session: BackendSession) {
const { activityId, roundIndex, id, pageIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consumeArr = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeArr);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id, count);
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}

View File

@@ -1,123 +1,124 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshTaskData } from '../../../services/activity/refreshTaskService';
import { RefreshTaskItem } from '../../../domain/activityField/refreshTaskField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityRefreshTaskModel } from '../../../db/ActivityRefreshTask';
import { ActivityRefreshTaskPointModel } from '../../../db/ActivityRefreshTaskPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshTaskHandler(app);
}
export class RefreshTaskHandler {
constructor(private app: Application) {
}
/************************通用的刷新任务(分页,可刷新,限制领取次数)****************************/
/**
* @description 获取任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getRefreshTaskActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {{ activityId: number, roundIndex: number, pageIndex: number,id: number, type: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getReward(msg: { activityId: number, roundIndex: number, pageIndex: number, id: number, type: number }, session: BackendSession) {
const { activityId, roundIndex, pageIndex, id, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let dailyItemData: RefreshTaskItem = playerData.findItem(pageIndex, id, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (dailyItemData.totalCount < dailyItemData.condition) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (dailyItemData.receiveRewardCount) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, dailyItemData.getRefTime(), 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
//获得点数
await ActivityRefreshTaskPointModel.addPoint(serverId, activityId, roleId, dailyItemData.point);
dailyItemData.receiveRewardCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, pageIndex, id, type },
item: dailyItemData,
totalPoint: playerData.totalPoint + dailyItemData.point,
}));
}
/**
* @description 兑换点数
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async exchangePoint(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
if ((playerData.totalPoint - playerData.exchangePoint) < playerData.consumePoint) {//点数不够
return resResult(STATUS.ACTIVITY_NO_POINT);
}
await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
playerData.exchangePoint += playerData.consumePoint;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex },
item: { exchangePoint: playerData.exchangePoint },
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshTaskData } from '../../../services/activity/refreshTaskService';
import { RefreshTaskItem } from '@domain/activityField/refreshTaskField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityRefreshTaskModel } from '@db/ActivityRefreshTask';
import { ActivityRefreshTaskPointModel } from '@db/ActivityRefreshTaskPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshTaskHandler(app);
}
export class RefreshTaskHandler {
constructor(private app: Application) {
}
/************************通用的刷新任务(分页,可刷新,限制领取次数)****************************/
/**
* @description 获取任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getRefreshTaskActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {{ activityId: number, roundIndex: number, pageIndex: number,id: number, type: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getReward(msg: { activityId: number, roundIndex: number, pageIndex: number, id: number, type: number }, session: BackendSession) {
const { activityId, roundIndex, pageIndex, id, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let dailyItemData: RefreshTaskItem = playerData.findItem(pageIndex, id, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (dailyItemData.totalCount < dailyItemData.condition) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (dailyItemData.receiveRewardCount) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, dailyItemData.getRefTime(), 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
//获得点数
await ActivityRefreshTaskPointModel.addPoint(serverId, activityId, roleId, dailyItemData.point);
dailyItemData.receiveRewardCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, pageIndex, id, type },
item: dailyItemData,
totalPoint: playerData.totalPoint + dailyItemData.point,
}));
}
/**
* @description 兑换点数
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async exchangePoint(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
if ((playerData.totalPoint - playerData.exchangePoint) < playerData.consumePoint) {//点数不够
return resResult(STATUS.ACTIVITY_NO_POINT);
}
await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
playerData.exchangePoint += playerData.consumePoint;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex },
item: { exchangePoint: playerData.exchangePoint },
}));
}
}

View File

@@ -1,173 +1,174 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, splitString } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { SelfServiceShopData } from '../../../domain/activityField/selfServiceShopField';
import { handleCost } from '../../../services/role/rewardService';
import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '../../../db/ActivitySelfServiceShop';
import { ActivitySelfServiceModel } from '../../../db/ActivitySelfService';
import { ActivitySelfServiceGoodsModel } from '../../../db/ActivitySelfServiceGoods';
import { ActivityModelType } from '../../../db/Activity';
import { addSelfServiceShopGiftReward, getSelfServiceShopActivityData, getPlayerActivityData } from '../../../services/activity/selfServiceShopActivityService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { random } from 'underscore';
import { getActivityById } from '../../../services/activity/activityService';
import { getRoleCreateTime, getServerCreateTime } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new SelfServiceShopHandler(app);
}
export class SelfServiceShopHandler {
constructor(private app: Application) {
}
/************************自助商店、糜家商队****************************/
/**
* @description 获取自助商店数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getSelfServiceShopActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getSelfServiceShopActivityData(serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let playerGoods = await ActivitySelfServiceGoodsModel.findData(playerData.activityId, roleId, playerData.roundIndex, true);
return resResult(STATUS.SUCCESS, { playerData, playerGoods: playerGoods ? playerGoods : [] });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, index: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyGift(msg: { activityId: number, roundIndex: number, index: number }, session: BackendSession) {
const { activityId, roundIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let item = playerData.getItem(index);
if (item.countMax > 0) {//限制购买次数
let playerRecords: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.findDataByIndex(serverId, activityId, roleId, playerData.roundIndex, index);
if (playerRecords.length >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
}
let price = item.price;
if (price > 0) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_GIFT);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, activityId, roundIndex, index, item);
return resResult(STATUS.SUCCESS, Object.assign(result, {}));
}
/**
* @description 操作礼包
* @param {{ data:Array<{activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number}>}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async saveGood(msg: { data: Array<{ activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number }> }, session: BackendSession) {
const { data } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
for (let obj of data) {
await ActivitySelfServiceGoodsModel.addGoods(obj.activityId, roleId, obj.roundIndex, obj.index, obj.cellIndex, obj.rewardIndex);
}
return resResult(STATUS.SUCCESS, { data });
}
/**
* @description 购买代币资源
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyRecources(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData: ActivityModelType = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let unitPrice = playerData.unitPrice;//购买价格
let unitCountMax = playerData.unitCountMax;//最大购买次数
let unitReward = playerData.unitReward;//购买获得资源
let playerSelfServerData = await ActivitySelfServiceModel.findData(serverId, activityId, roleId, roundIndex);
let buyCount = (playerSelfServerData && playerSelfServerData.unitBuyCount) ? playerSelfServerData.unitBuyCount : 0;
if (buyCount >= unitCountMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
//检查资源
let consume = stringToConsumeParam(unitPrice)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
await ActivitySelfServiceModel.addBuyRecord(serverId, activityId, roleId, roundIndex, 1);
let rewardArray = stringToRewardParam(unitReward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
return resResult(STATUS.SUCCESS, Object.assign(result, { unitBuyCount: buyCount + 1 }));
}
/**
* @description 获取关卡id
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getWarId(msg: { activityId: number, }, session: BackendSession) {
const { activityId, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerActivityData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.challengeCount >= playerData.count) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let warIdArray = splitString(playerData.warid, '&')
let index = random(warIdArray.length - 1);
let warId = warIdArray[index];
return resResult(STATUS.SUCCESS, { warId });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, splitString } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { SelfServiceShopData } from '@domain/activityField/selfServiceShopField';
import { handleCost } from '../../../services/role/rewardService';
import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '@db/ActivitySelfServiceShop';
import { ActivitySelfServiceModel } from '@db/ActivitySelfService';
import { ActivitySelfServiceGoodsModel } from '@db/ActivitySelfServiceGoods';
import { ActivityModelType } from '@db/Activity';
import { addSelfServiceShopGiftReward, getSelfServiceShopActivityData, getPlayerActivityData } from '../../../services/activity/selfServiceShopActivityService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { random } from 'underscore';
import { getActivityById } from '../../../services/activity/activityService';
import { getRoleCreateTime, getServerCreateTime } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new SelfServiceShopHandler(app);
}
export class SelfServiceShopHandler {
constructor(private app: Application) {
}
/************************自助商店、糜家商队****************************/
/**
* @description 获取自助商店数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getSelfServiceShopActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getSelfServiceShopActivityData(serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let playerGoods = await ActivitySelfServiceGoodsModel.findData(playerData.activityId, roleId, playerData.roundIndex, true);
return resResult(STATUS.SUCCESS, { playerData, playerGoods: playerGoods ? playerGoods : [] });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, index: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyGift(msg: { activityId: number, roundIndex: number, index: number }, session: BackendSession) {
const { activityId, roundIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let item = playerData.getItem(index);
if (item.countMax > 0) {//限制购买次数
let playerRecords: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.findDataByIndex(serverId, activityId, roleId, playerData.roundIndex, index);
if (playerRecords.length >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
}
let price = item.price;
if (price > 0) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_GIFT);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, activityId, roundIndex, index, item);
return resResult(STATUS.SUCCESS, Object.assign(result, {}));
}
/**
* @description 操作礼包
* @param {{ data:Array<{activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number}>}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async saveGood(msg: { data: Array<{ activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number }> }, session: BackendSession) {
const { data } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
for (let obj of data) {
await ActivitySelfServiceGoodsModel.addGoods(obj.activityId, roleId, obj.roundIndex, obj.index, obj.cellIndex, obj.rewardIndex);
}
return resResult(STATUS.SUCCESS, { data });
}
/**
* @description 购买代币资源
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyRecources(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData: ActivityModelType = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let unitPrice = playerData.unitPrice;//购买价格
let unitCountMax = playerData.unitCountMax;//最大购买次数
let unitReward = playerData.unitReward;//购买获得资源
let playerSelfServerData = await ActivitySelfServiceModel.findData(serverId, activityId, roleId, roundIndex);
let buyCount = (playerSelfServerData && playerSelfServerData.unitBuyCount) ? playerSelfServerData.unitBuyCount : 0;
if (buyCount >= unitCountMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
//检查资源
let consume = stringToConsumeParam(unitPrice)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
await ActivitySelfServiceModel.addBuyRecord(serverId, activityId, roleId, roundIndex, 1);
let rewardArray = stringToRewardParam(unitReward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
return resResult(STATUS.SUCCESS, Object.assign(result, { unitBuyCount: buyCount + 1 }));
}
/**
* @description 获取关卡id
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getWarId(msg: { activityId: number, }, session: BackendSession) {
const { activityId, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerActivityData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.challengeCount >= playerData.count) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let warIdArray = splitString(playerData.warid, '&')
let index = random(warIdArray.length - 1);
let warId = warIdArray[index];
return resResult(STATUS.SUCCESS, { warId });
}
}

View File

@@ -1,221 +1,222 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { ActivityGrowthModel } from '../../../db/ActivityGrowth';
import { ActivityDailyGiftsModel } from '../../../db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
import { ActivityGrowthPointModel } from '../../../db/ActivityGrowthPoint';
import { getPlayerSevenDaysData, getPlayerSevenDaysGrowthData, getPlayerSevenDaysDailyChallengesData, getPlayerSevenDaysDailyGiftsData } from '../../../services/activity/sevenDaysService';
import { SevenDaysGrowthItem, SevenDaysPointRewardItem, SevenDaysDailyItem, SevenDaysDailyGiftItem } from '../../../domain/activityField/sevenDaysField';
export default function (app: Application) {
new HandlerService(app, {});
return new SevenDaysHandler(app);
}
export class SevenDaysHandler {
constructor(private app: Application) {
}
/**
* @description 获取七天乐活动总的数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getSevenDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerSevenDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/************************成长任务****************************/
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: SevenDaysGrowthItem = playerData.growth.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: SevenDaysPointRewardItem = playerData.growth.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.growth.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyItem = playerData.dailyChallenge.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
/************************每日特惠礼包****************************/
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyGiftItem = playerData.dailyGift.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { ActivityGrowthModel } from '@db/ActivityGrowth';
import { ActivityDailyGiftsModel } from '@db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
import { ActivityGrowthPointModel } from '@db/ActivityGrowthPoint';
import { getPlayerSevenDaysData, getPlayerSevenDaysGrowthData, getPlayerSevenDaysDailyChallengesData, getPlayerSevenDaysDailyGiftsData } from '../../../services/activity/sevenDaysService';
import { SevenDaysGrowthItem, SevenDaysPointRewardItem, SevenDaysDailyItem, SevenDaysDailyGiftItem } from '@domain/activityField/sevenDaysField';
export default function (app: Application) {
new HandlerService(app, {});
return new SevenDaysHandler(app);
}
export class SevenDaysHandler {
constructor(private app: Application) {
}
/**
* @description 获取七天乐活动总的数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getSevenDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerSevenDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/************************成长任务****************************/
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: SevenDaysGrowthItem = playerData.growth.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: SevenDaysPointRewardItem = playerData.growth.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.growth.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyItem = playerData.dailyChallenge.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
/************************每日特惠礼包****************************/
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyGiftItem = playerData.dailyGift.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}

View File

@@ -1,112 +1,113 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_TYPE, SERVER_OPEN_TIME, ITEM_CHANGE_REASON, } from '../../../consts';
import { canBuyVip, getPlayerSignInData } from '../../../services/activity/signInService';
import { handleCost } from '../../../services/role/rewardService';
import { SignInItem } from '../../../domain/activityField/signInField';
import { ActivitySignInModel } from '../../../db/ActivitySignIn';
import moment = require('moment');
import { RoleModel } from '../../../db/Role';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new SignInHandler(app);
}
export class SignInHandler {
constructor(private app: Application) {
}
/************************签到活动****************************/
/**
* @description 获取普通签到活动数据
* @param {BackendSession} session
* @param {{ activityId: number}} msg
* @memberof SignInHandler
*/
async getSignInActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let curDate = moment(new Date()).valueOf();
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (curDate < playerData.beginTime || curDate > playerData.endTime) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到获得奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof SignInHandler
*/
async getSignInReward(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.canShow()) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let isDelay = false;//补签
if(dayIndex < playerData.todayIndex) {
isDelay = true;
}
let roundIndex = playerData.roundIndex;
//高级签到开启条件
let { lv } = await RoleModel.findByRoleId(roleId);
if (playerData.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
if (!canBuyVip(lv))
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
if (!playerData.isVip) {
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
}
}
if(playerData.price > 0 && !playerData.isVip) return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
let signinItemData: SignInItem = playerData.findDayItem(dayIndex);
if (!signinItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!signinItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (isDelay) {
let consume = stringToConsumeParam(playerData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.REPAIRE_SIGNIN);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, dayIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex },
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_TYPE, SERVER_OPEN_TIME, ITEM_CHANGE_REASON, } from '../../../consts';
import { canBuyVip, getPlayerSignInData } from '../../../services/activity/signInService';
import { handleCost } from '../../../services/role/rewardService';
import { SignInItem } from '@domain/activityField/signInField';
import { ActivitySignInModel } from '@db/ActivitySignIn';
import moment = require('moment');
import { RoleModel } from '@db/Role';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new SignInHandler(app);
}
export class SignInHandler {
constructor(private app: Application) {
}
/************************签到活动****************************/
/**
* @description 获取普通签到活动数据
* @param {BackendSession} session
* @param {{ activityId: number}} msg
* @memberof SignInHandler
*/
async getSignInActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let curDate = moment(new Date()).valueOf();
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (curDate < playerData.beginTime || curDate > playerData.endTime) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到获得奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof SignInHandler
*/
async getSignInReward(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.canShow()) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let isDelay = false;//补签
if(dayIndex < playerData.todayIndex) {
isDelay = true;
}
let roundIndex = playerData.roundIndex;
//高级签到开启条件
let { lv } = await RoleModel.findByRoleId(roleId);
if (playerData.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
if (!canBuyVip(lv))
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
if (!playerData.isVip) {
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
}
}
if(playerData.price > 0 && !playerData.isVip) return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
let signinItemData: SignInItem = playerData.findDayItem(dayIndex);
if (!signinItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!signinItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (isDelay) {
let consume = stringToConsumeParam(playerData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.REPAIRE_SIGNIN);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, dayIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex },
}));
}
}

View File

@@ -1,87 +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/role/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: item.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_TASK_PASS);
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');
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, cost, ITEM_CHANGE_REASON.ACT_TASK_PASS_SPD_UP);
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);
}
}
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/role/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: item.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_TASK_PASS);
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');
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, cost, ITEM_CHANGE_REASON.ACT_TASK_PASS_SPD_UP);
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);
}
}

View File

@@ -1,142 +1,143 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { getPlayerThirtyDaysData } from '../../../services/activity/thirtyDaysService';
import { ThirtyDaysData, ThirtyDaysItem, ThirtyDaysPointItem } from '../../../domain/activityField/thirtyDaysField';
import { ActivityThirtyDaysModel } from '../../../db/ActivityThirtyDays';
import { ActivityThirtyDaysPointRewardModel } from '../../../db/ActivityThirtyDaysPointReward';
import { ActivityModel, ActivityModelType } from '../../../db/Activity';
import { ServerlistModel } from '../../../db/Serverlist';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new ThirtyDaysHandler(app);
}
export class ThirtyDaysHandler {
constructor(private app: Application) {
}
/************************30天大目标****************************/
/**
* @description 获取30目标活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData, todayIndex: playerData.todayIndex });
}
/**
* @description 获取30天完成任务的奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number,tab: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number, tab: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex, tab } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (tab > 1) {
let item = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab - 1)
if (!item.isReceive) {
return resResult(STATUS.ACTIVITY_PRE_UNCOMPLETE);
}
}
let thirtyDaysItemData: ThirtyDaysItem = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab);
if (!thirtyDaysItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!thirtyDaysItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (thirtyDaysItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (0 < playerData.todayIndex && playerData.todayIndex <= playerData.days) {//时间正常范围内
} else if (playerData.todayIndex > playerData.days) {//活动已经过期
// console.log('过期奖励')
let expiredItems: Array<ThirtyDaysPointItem> = playerData.needMark();
let cells = expiredItems.map(obj => obj.cellIndex)
await ActivityThirtyDaysPointRewardModel.setExpired(activityId, roleId, cells);
} else {//活动未到开启时间
return resResult(STATUS.ACTIVITY_TIME_ERROR);
}
await ActivityThirtyDaysModel.addRecord(serverId, activityId, roleId, pageIndex, cellIndex, tab);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(thirtyDaysItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_TASK)
thirtyDaysItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: thirtyDaysItemData,
}));
}
/**
* @description 点数兑换奖励
* @param {{ activityId: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysPointReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let thirtyDaysPointItemData: ThirtyDaysPointItem = playerData.findThirtyDaysPointItem(cellIndex);
if (!thirtyDaysPointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalPoint < thirtyDaysPointItemData.consumePoint) {//点数不足
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (thirtyDaysPointItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityThirtyDaysPointRewardModel.addRecord(activityId, roleId, cellIndex);
let reward = thirtyDaysPointItemData.reward
if (thirtyDaysPointItemData.isExpired && thirtyDaysPointItemData.expiredReward && thirtyDaysPointItemData.expiredReward != '') {//过期奖励
reward = thirtyDaysPointItemData.expiredReward;
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_EXCHANGE)
thirtyDaysPointItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: thirtyDaysPointItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { getPlayerThirtyDaysData } from '../../../services/activity/thirtyDaysService';
import { ThirtyDaysData, ThirtyDaysItem, ThirtyDaysPointItem } from '@domain/activityField/thirtyDaysField';
import { ActivityThirtyDaysModel } from '@db/ActivityThirtyDays';
import { ActivityThirtyDaysPointRewardModel } from '@db/ActivityThirtyDaysPointReward';
import { ActivityModel, ActivityModelType } from '@db/Activity';
import { ServerlistModel } from '@db/Serverlist';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new ThirtyDaysHandler(app);
}
export class ThirtyDaysHandler {
constructor(private app: Application) {
}
/************************30天大目标****************************/
/**
* @description 获取30目标活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData, todayIndex: playerData.todayIndex });
}
/**
* @description 获取30天完成任务的奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number,tab: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number, tab: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex, tab } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (tab > 1) {
let item = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab - 1)
if (!item.isReceive) {
return resResult(STATUS.ACTIVITY_PRE_UNCOMPLETE);
}
}
let thirtyDaysItemData: ThirtyDaysItem = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab);
if (!thirtyDaysItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!thirtyDaysItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (thirtyDaysItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (0 < playerData.todayIndex && playerData.todayIndex <= playerData.days) {//时间正常范围内
} else if (playerData.todayIndex > playerData.days) {//活动已经过期
// console.log('过期奖励')
let expiredItems: Array<ThirtyDaysPointItem> = playerData.needMark();
let cells = expiredItems.map(obj => obj.cellIndex)
await ActivityThirtyDaysPointRewardModel.setExpired(activityId, roleId, cells);
} else {//活动未到开启时间
return resResult(STATUS.ACTIVITY_TIME_ERROR);
}
await ActivityThirtyDaysModel.addRecord(serverId, activityId, roleId, pageIndex, cellIndex, tab);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(thirtyDaysItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_TASK)
thirtyDaysItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: thirtyDaysItemData,
}));
}
/**
* @description 点数兑换奖励
* @param {{ activityId: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysPointReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let thirtyDaysPointItemData: ThirtyDaysPointItem = playerData.findThirtyDaysPointItem(cellIndex);
if (!thirtyDaysPointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalPoint < thirtyDaysPointItemData.consumePoint) {//点数不足
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (thirtyDaysPointItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityThirtyDaysPointRewardModel.addRecord(activityId, roleId, cellIndex);
let reward = thirtyDaysPointItemData.reward
if (thirtyDaysPointItemData.isExpired && thirtyDaysPointItemData.expiredReward && thirtyDaysPointItemData.expiredReward != '') {//过期奖励
reward = thirtyDaysPointItemData.expiredReward;
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_EXCHANGE)
thirtyDaysPointItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: thirtyDaysPointItemData,
}));
}
}

View File

@@ -1,100 +1,101 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { DEBUG_MAGIC_WORD, getRedisKeyByRankType, HERO_SELECT, ITEM_CHANGE_REASON, RANK_TYPE, ROLE_SELECT, STATUS } from '../../../consts';
import { pick } from 'underscore';
import { getTimeLimitRankData, getTimeLimitRankDataShow, sendRankMail, takeSnapshot } from '../../../services/activity/timeLimitRankService';
import { getRankInHandler, Rank } from '../../../services/rankService';
import { getActivityById } from '../../../services/activity/activityService';
import { TimeLimitRankData } from '../../../domain/activityField/timeLimitRankField';
import { getServerCreateTime, hasKey } from '../../../services/redisService';
import { KeyName } from '../../../domain/rank';
export default function (app: Application) {
new HandlerService(app, {});
return new TimeLimitRankHandler(app);
}
export class TimeLimitRankHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getTimeLimitRankData(msg: { activityId: number }, session: BackendSession) {
const serverId = session.get('serverId');
const { activityId } = msg;
let playerData = await getTimeLimitRankDataShow(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 获得排行榜
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getRank(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTimeLimitRankData(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let type = playerData.rankType;
let redisKey = getRedisKeyByRankType(type, true);
let keyName = new KeyName(redisKey, { serverId, activityId });
if(!(await hasKey(keyName.getName()))) {
redisKey = getRedisKeyByRankType(type);
}
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId, activityId: playerData.activityId }, session);
if(!result) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, {
...pick(playerData, ['activityId', 'tabName', 'beginTime', 'endTime', 'rankEndTime', 'rankType', 'rankRewards']),
...result
});
}
async debugSendMail(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let playerData = await getTimeLimitRankData(activityId, serverId);
await sendRankMail(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
async debugTakeSnapshot(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let activityData = await getActivityById(activityId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new TimeLimitRankData(activityData, 0, serverTime);
if(!playerData.needSnapshot) return resResult(STATUS.WRONG_PARMS);
await takeSnapshot(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { DEBUG_MAGIC_WORD, getRedisKeyByRankType, HERO_SELECT, ITEM_CHANGE_REASON, RANK_TYPE, ROLE_SELECT, STATUS } from '../../../consts';
import { pick } from 'underscore';
import { getTimeLimitRankData, getTimeLimitRankDataShow, sendRankMail, takeSnapshot } from '../../../services/activity/timeLimitRankService';
import { getRankInHandler, Rank } from '../../../services/rankService';
import { getActivityById } from '../../../services/activity/activityService';
import { TimeLimitRankData } from '@domain/activityField/timeLimitRankField';
import { getServerCreateTime, hasKey } from '../../../services/redisService';
import { KeyName } from '@domain/rank';
export default function (app: Application) {
new HandlerService(app, {});
return new TimeLimitRankHandler(app);
}
export class TimeLimitRankHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getTimeLimitRankData(msg: { activityId: number }, session: BackendSession) {
const serverId = session.get('serverId');
const { activityId } = msg;
let playerData = await getTimeLimitRankDataShow(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 获得排行榜
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getRank(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTimeLimitRankData(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let type = playerData.rankType;
let redisKey = getRedisKeyByRankType(type, true);
let keyName = new KeyName(redisKey, { serverId, activityId });
if(!(await hasKey(keyName.getName()))) {
redisKey = getRedisKeyByRankType(type);
}
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId, activityId: playerData.activityId }, session);
if(!result) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, {
...pick(playerData, ['activityId', 'tabName', 'beginTime', 'endTime', 'rankEndTime', 'rankType', 'rankRewards']),
...result
});
}
async debugSendMail(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let playerData = await getTimeLimitRankData(activityId, serverId);
await sendRankMail(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
async debugTakeSnapshot(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let activityData = await getActivityById(activityId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new TimeLimitRankData(activityData, 0, serverTime);
if(!playerData.needSnapshot) return resResult(STATUS.WRONG_PARMS);
await takeSnapshot(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,232 +1,233 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerTreasureHuntData, getPlayerTreasureHuntShopData, getPlayerTreasureHuntTaskData, getPlayerTreasureHuntTreasureShopData, getPlayerTreasureHuntChallengeData, getPlayerTreasureHuntFirstPageData } from '../../../services/activity/treasureHuntService';
import { ActivityTreasureHuntShopModel } from '../../../db/ActivityTreasureHuntShop';
import { ActivityTreasureHuntTaskModel } from '../../../db/ActivityTreasureHuntTask';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityTreasureHuntTreasureShopModel } from '../../../db/ActivityTreasureHuntTreasureShop';
import { ActivityTreasureHuntFirstPageModel } from '../../../db/ActivityTreasureHuntFirstPage';
import { CheckMeterial } from '../../../services/role/checkMaterial';
import { ActivityTreasureHuntChallengeModel } from '../../../db/ActivityTreasureHuntChallenge';
export default function (app: Application) {
new HandlerService(app, {});
return new TreasureHuntHandler(app);
}
export class TreasureHuntHandler {
constructor(private app: Application) {
}
/************************寻宝骑兵活动****************************/
/**
* 每日物资:商店
寻宝备战:完成任务获得奖励,(奖品达到一定数量后开启 “寻宝大冒险”)
寻宝大冒险:完成战棋关卡获得奖励
天子宝库:物品兑换奖励
* @description 获取寻宝骑兵活动的数据
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTreasureHuntActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerTreasureHuntData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 寻宝骑兵获取首页的奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getFirstPageReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntFirstPageData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.firstPage.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
//添加领取记录
await ActivityTreasureHuntFirstPageModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.firstPage.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_FIRST_PAGE_REWARD)
playerData.firstPage.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
item: playerData.firstPage,
}));
}
/**
* @description 寻宝骑兵购买每日商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.shop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStr = item.getConsume(count);
let consume = stringToConsumeParam(...consumeStr);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, playerData.roundIndex, playerData.todayIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵获取寻宝备战的任务奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTaskReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTaskData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.tasks.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.condition > item.totalCount) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED, {});
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED, {});
}
//添加购买记录
await ActivityTreasureHuntTaskModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_TASK_REWARD)
item.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵寻宝大冒险挑战
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async challenge(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntChallengeData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let challengeData = playerData.challenge;
//消耗资源
let consumeStr = challengeData.consume;
let consume = stringToConsumeParam(consumeStr)
let check = new CheckMeterial(roleId);
let isEnough = await check.decrease(consume);
if (!isEnough) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let warId = playerData.challenge.resultWarId;
if(!warId) {
warId = playerData.challenge.randomGK();
await ActivityTreasureHuntChallengeModel.setWarId(serverId, activityId, roleId, playerData.roundIndex, warId);
}
return resResult(STATUS.SUCCESS, Object.assign({ warId }, {
param: { activityId },
}));
}
/**
* @description 寻宝骑兵购买天子宝库商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyTreasureShopGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTreasureShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.treasureShop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStrs = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeStrs);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntTreasureShopModel.addRecord(activityId, roleId, playerData.roundIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count}));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerTreasureHuntData, getPlayerTreasureHuntShopData, getPlayerTreasureHuntTaskData, getPlayerTreasureHuntTreasureShopData, getPlayerTreasureHuntChallengeData, getPlayerTreasureHuntFirstPageData } from '../../../services/activity/treasureHuntService';
import { ActivityTreasureHuntShopModel } from '@db/ActivityTreasureHuntShop';
import { ActivityTreasureHuntTaskModel } from '@db/ActivityTreasureHuntTask';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityTreasureHuntTreasureShopModel } from '@db/ActivityTreasureHuntTreasureShop';
import { ActivityTreasureHuntFirstPageModel } from '@db/ActivityTreasureHuntFirstPage';
import { CheckMeterial } from '../../../services/role/checkMaterial';
import { ActivityTreasureHuntChallengeModel } from '@db/ActivityTreasureHuntChallenge';
export default function (app: Application) {
new HandlerService(app, {});
return new TreasureHuntHandler(app);
}
export class TreasureHuntHandler {
constructor(private app: Application) {
}
/************************寻宝骑兵活动****************************/
/**
* 每日物资:商店
寻宝备战:完成任务获得奖励,(奖品达到一定数量后开启 “寻宝大冒险”)
寻宝大冒险:完成战棋关卡获得奖励
天子宝库:物品兑换奖励
* @description 获取寻宝骑兵活动的数据
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTreasureHuntActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerTreasureHuntData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 寻宝骑兵获取首页的奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getFirstPageReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntFirstPageData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.firstPage.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
//添加领取记录
await ActivityTreasureHuntFirstPageModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.firstPage.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_FIRST_PAGE_REWARD)
playerData.firstPage.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
item: playerData.firstPage,
}));
}
/**
* @description 寻宝骑兵购买每日商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.shop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStr = item.getConsume(count);
let consume = stringToConsumeParam(...consumeStr);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, playerData.roundIndex, playerData.todayIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵获取寻宝备战的任务奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTaskReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTaskData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.tasks.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.condition > item.totalCount) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED, {});
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED, {});
}
//添加购买记录
await ActivityTreasureHuntTaskModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_TASK_REWARD)
item.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵寻宝大冒险挑战
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async challenge(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntChallengeData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let challengeData = playerData.challenge;
//消耗资源
let consumeStr = challengeData.consume;
let consume = stringToConsumeParam(consumeStr)
let check = new CheckMeterial(roleId);
let isEnough = await check.decrease(consume);
if (!isEnough) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let warId = playerData.challenge.resultWarId;
if(!warId) {
warId = playerData.challenge.randomGK();
await ActivityTreasureHuntChallengeModel.setWarId(serverId, activityId, roleId, playerData.roundIndex, warId);
}
return resResult(STATUS.SUCCESS, Object.assign({ warId }, {
param: { activityId },
}));
}
/**
* @description 寻宝骑兵购买天子宝库商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyTreasureShopGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTreasureShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.treasureShop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStrs = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeStrs);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntTreasureShopModel.addRecord(activityId, roleId, playerData.roundIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count}));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
}

View File

@@ -1,111 +1,112 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerVipRechargeMoneyData, } from '../../../services/activity/vipRechargeMoneyService';
import { VipRechargeMoneyItem } from '../../../domain/activityField/vipRechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityVipRechargeMoneyModel } from '../../../db/ActivityVipRechargeMoney';
import { UserOrderModel } from '../../../db/UserOrder';
import { dicRMB } from '../../../pubUtils/dictionary/DicRMB';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new VipRechargeMoneyHandler(app);
}
export class VipRechargeMoneyHandler {
constructor(private app: Application) {
}
/************************vip累计充值奖励****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item: VipRechargeMoneyItem = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalRMB < item.condition) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (item.receiveCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
await ActivityVipRechargeMoneyModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.VIP_RECHARGE_MONEY)
item.receiveCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: item
}));
}
/**
* @description 获取订单记录
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getOrderList(msg: { begin: number, count: number }, session: BackendSession) {
const { begin, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
if (begin > 0 && count > 0) {
let orders = await UserOrderModel.findOrderList(serverId, roleId, begin - 1, count)
for (let order of orders) {
let productInfo = dicRMB.get(order.productID)
if (productInfo) {
order['message'] = productInfo.message;
}
order['time'] = moment(order.createdAt).valueOf();
delete order.createdAt;
delete order.productID;
delete order._id;
}
return resResult(STATUS.SUCCESS, { orders });
}
return resResult(STATUS.WRONG_PARMS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerVipRechargeMoneyData, } from '../../../services/activity/vipRechargeMoneyService';
import { VipRechargeMoneyItem } from '@domain/activityField/vipRechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityVipRechargeMoneyModel } from '@db/ActivityVipRechargeMoney';
import { UserOrderModel } from '@db/UserOrder';
import { dicRMB } from '@pubUtils/dictionary/DicRMB';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new VipRechargeMoneyHandler(app);
}
export class VipRechargeMoneyHandler {
constructor(private app: Application) {
}
/************************vip累计充值奖励****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item: VipRechargeMoneyItem = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalRMB < item.condition) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (item.receiveCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
await ActivityVipRechargeMoneyModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.VIP_RECHARGE_MONEY)
item.receiveCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: item
}));
}
/**
* @description 获取订单记录
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getOrderList(msg: { begin: number, count: number }, session: BackendSession) {
const { begin, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
if (begin > 0 && count > 0) {
let orders = await UserOrderModel.findOrderList(serverId, roleId, begin - 1, count)
for (let order of orders) {
let productInfo = dicRMB.get(order.productID)
if (productInfo) {
order['message'] = productInfo.message;
}
order['time'] = moment(order.createdAt).valueOf();
delete order.createdAt;
delete order.productID;
delete order._id;
}
return resResult(STATUS.SUCCESS, { orders });
}
return resResult(STATUS.WRONG_PARMS);
}
}

View File

@@ -1,68 +1,69 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getWeeklyFundDataShow, getWeeklyFundData } from '../../../services/activity/weeklyFundService';
import { ActivityWeeklyFundModel } from '../../../db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new WeeklyFundHandler(app);
}
export class WeeklyFundHandler {
constructor(private app: Application) {
}
/************************周基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async sign(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(!playerData.hasBought) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_BOUGHT);
let signReward = playerData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_LOCK);
let record = await ActivityWeeklyFundModel.sign(serverId, activityId, roleId, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_WEEKLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, goods, addHeros
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getWeeklyFundDataShow, getWeeklyFundData } from '../../../services/activity/weeklyFundService';
import { ActivityWeeklyFundModel } from '@db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new WeeklyFundHandler(app);
}
export class WeeklyFundHandler {
constructor(private app: Application) {
}
/************************周基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async sign(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(!playerData.hasBought) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_BOUGHT);
let signReward = playerData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_LOCK);
let record = await ActivityWeeklyFundModel.sign(serverId, activityId, roleId, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_WEEKLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, goods, addHeros
});
}
}

View File

@@ -1,33 +1,34 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerYuanbaoShopData } from '../../../services/activity/yuanbaoService';
export default function (app: Application) {
new HandlerService(app, {});
return new YuanbaoShopHandler(app);
}
export class YuanbaoShopHandler {
constructor(private app: Application) {
}
/************************元宝商店****************************/
/**
* @description 获取商店活动数据
* @param {BackendSession} session
* @memberof YuanbaoShopHandler
*/
async getShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerYuanbaoShopData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerYuanbaoShopData } from '../../../services/activity/yuanbaoService';
export default function (app: Application) {
new HandlerService(app, {});
return new YuanbaoShopHandler(app);
}
export class YuanbaoShopHandler {
constructor(private app: Application) {
}
/************************元宝商店****************************/
/**
* @description 获取商店活动数据
* @param {BackendSession} session
* @memberof YuanbaoShopHandler
*/
async getShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerYuanbaoShopData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
}

View File

@@ -1,212 +1,213 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { ActivityModel, ActivityModelType } from '../../../db/Activity';
import { ServerlistModel } from '../../../db/Serverlist';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { ActivityInRemote } from '../../../domain/activityField/activityField';
import { errlogger } from '../../../util/logger';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId, saveGroupToServer, addServerToGroup } from '../../../services/memoryCache/activityData';
import { saveActivityMemory } from '../../../services/log/memoryLogService';
import { setApiIsClose } from '../../../services/chatService';
import { setKvToMemory } from '../../../services/pushService';
import { sendPublicAccountGift } from '../../../services/activity/bindPhoneService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityRemote(app);
}
export class ActivityRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
/**
* 重载json资源
*/
public reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async updateActivities(activities: ActivityInRemote[]) {
try {
// console.log('******* activities', activities)
updateActivities(activities);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async deleteActivities(activityIds: number[]) {
try {
deleteActivities(activityIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async saveGroupToServer(groupId: number[], serverIds: number[]) {
try {
saveGroupToServer(groupId, serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async addServerToGroup(groupId: number[], serverIds: number[]) {
try {
addServerToGroup(groupId, serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async saveActivitiesToGroup(groupId: number, activities: number[]) {
try {
saveActivitiesToGroup(groupId, activities);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivityById(activityId: number) {
try {
return _getActivityById(activityId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivitiesByType(serverId: number, type: number) {
try {
return _getActivitiesByType(serverId, type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivitiesByServerId(serverId: number) {
try {
return _getActivitiesByServerId(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivities() {
try {
return _getActivities();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public saveActivityMemory() {
try {
return saveActivityMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async sendPublicAccountGift(message: string) {
try {
await sendPublicAccountGift(message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { ActivityModel, ActivityModelType } from '@db/Activity';
import { ServerlistModel } from '@db/Serverlist';
import { gameData, reloadResources } from '@pubUtils/data';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { ActivityInRemote } from '@domain/activityField/activityField';
import { errlogger } from '../../../util/logger';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { deleteActivities, loadActivities, saveActivitiesToGroup, updateActivities, _getActivityById, _getActivitiesByType, _getActivities, _getActivitiesByServerId, saveGroupToServer, addServerToGroup } from '../../../services/memoryCache/activityData';
import { saveActivityMemory } from '../../../services/log/memoryLogService';
import { setApiIsClose } from '../../../services/chatService';
import { setKvToMemory } from '../../../services/pushService';
import { sendPublicAccountGift } from '../../../services/activity/bindPhoneService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityRemote(app);
}
export class ActivityRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
/**
* 重载json资源
*/
public reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async updateActivities(activities: ActivityInRemote[]) {
try {
// console.log('******* activities', activities)
updateActivities(activities);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async deleteActivities(activityIds: number[]) {
try {
deleteActivities(activityIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async saveGroupToServer(groupId: number[], serverIds: number[]) {
try {
saveGroupToServer(groupId, serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async addServerToGroup(groupId: number[], serverIds: number[]) {
try {
addServerToGroup(groupId, serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async saveActivitiesToGroup(groupId: number, activities: number[]) {
try {
saveActivitiesToGroup(groupId, activities);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivityById(activityId: number) {
try {
return _getActivityById(activityId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivitiesByType(serverId: number, type: number) {
try {
return _getActivitiesByType(serverId, type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivitiesByServerId(serverId: number) {
try {
return _getActivitiesByServerId(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivities() {
try {
return _getActivities();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public saveActivityMemory() {
try {
return saveActivityMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async sendPublicAccountGift(message: string) {
try {
await sendPublicAccountGift(message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,55 +1,56 @@
import { Application, BackendSession } from "pinus";
import { ScriptBarrageModel } from "../../../db/ScriptBarrage";
import { BarrageReturn } from '../../../domain/roleField/barrage';
import { resResult, getRandEelm } from "../../../pubUtils/util";
import { STATUS } from "../../../consts";
import { closeScriptBarrage } from "../../../pubUtils/sdkUtil";
export default function(app: Application) {
return new BarrageHandler(app);
}
export class BarrageHandler {
constructor(private app: Application) {
}
public async sendBarrage(msg: { warId: number, rid: string, index: string, content: string }, session: BackendSession) {
if(closeScriptBarrage()) return resResult(STATUS.FUNCTION_CLOSE);
const roleId: string = session.get('roleId');
const { warId, rid, index, content } = msg;
const result = await ScriptBarrageModel.createBarrage(roleId, warId, rid, index, content);
let barrageList: BarrageReturn[] = [];
let bs = new BarrageReturn(result);
barrageList.push(bs);
return resResult(STATUS.SUCCESS, { barrageList });
}
public async getBarrageList(msg: {rid: string}, session: BackendSession) {
if(closeScriptBarrage()) return resResult(STATUS.SUCCESS, { barrageList: [] });
// const roleId: string = session.get('roleId');
const { rid } = msg;
const result = await ScriptBarrageModel.getBarrageList(rid, 1000);
const perMax = 10, max = 50; // 每个对话最大数量,每个剧本最大数量
let map = new Map<string, BarrageReturn[]>(); // index => BarrageReturn[]
for(let barrage of result) {
let { index } = barrage;
if(!map.has(index)) {
map.set(index, []);
}
map.get(index).push(new BarrageReturn(barrage));
}
let ratio = result.length > max? max/result.length: 1;
let barrageList: BarrageReturn[] = [];
for(let [_, barrages] of map) {
let count = Math.ceil(barrages.length * ratio);
if(count > perMax) count = perMax;
let curBarrages = getRandEelm(barrages, count);
barrageList = barrageList.concat(curBarrages);
}
return resResult(STATUS.SUCCESS, { barrageList });
}
}
import { Application, BackendSession } from "pinus";
import { ScriptBarrageModel } from "@db/ScriptBarrage";
import { BarrageReturn } from '@domain/roleField/barrage';
import { resResult, getRandEelm } from "@pubUtils/util";
import { STATUS } from "../../../consts";
import { closeScriptBarrage } from "@pubUtils/sdkUtil";
export default function(app: Application) {
return new BarrageHandler(app);
}
export class BarrageHandler {
constructor(private app: Application) {
}
public async sendBarrage(msg: { warId: number, rid: string, index: string, content: string }, session: BackendSession) {
if(closeScriptBarrage()) return resResult(STATUS.FUNCTION_CLOSE);
const roleId: string = session.get('roleId');
const { warId, rid, index, content } = msg;
const result = await ScriptBarrageModel.createBarrage(roleId, warId, rid, index, content);
let barrageList: BarrageReturn[] = [];
let bs = new BarrageReturn(result);
barrageList.push(bs);
return resResult(STATUS.SUCCESS, { barrageList });
}
public async getBarrageList(msg: {rid: string}, session: BackendSession) {
if(closeScriptBarrage()) return resResult(STATUS.SUCCESS, { barrageList: [] });
// const roleId: string = session.get('roleId');
const { rid } = msg;
const result = await ScriptBarrageModel.getBarrageList(rid, 1000);
const perMax = 10, max = 50; // 每个对话最大数量,每个剧本最大数量
let map = new Map<string, BarrageReturn[]>(); // index => BarrageReturn[]
for(let barrage of result) {
let { index } = barrage;
if(!map.has(index)) {
map.set(index, []);
}
map.get(index).push(new BarrageReturn(barrage));
}
let ratio = result.length > max? max/result.length: 1;
let barrageList: BarrageReturn[] = [];
for(let [_, barrages] of map) {
let count = Math.ceil(barrages.length * ratio);
if(count > perMax) count = perMax;
let curBarrages = getRandEelm(barrages, count);
barrageList = barrageList.concat(curBarrages);
}
return resResult(STATUS.SUCCESS, { barrageList });
}
}

View File

@@ -1,70 +1,71 @@
import { Application, BackendSession } from 'pinus';
import { DailyRecordModel } from '../../../db/DailyRecord';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { RoleModel } from '../../../db/Role';
import { getDailyNum, getDailyBattleList, getDailyBuyCountCost } from '../../../services/dailyBattleService';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { gameData } from '../../../pubUtils/data';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
export default function(app: Application) {
return new DailyBattleHandler(app);
}
export class DailyBattleHandler {
constructor(private app: Application) {
}
// 获取关卡列表
async getData(msg: { }, session: BackendSession) {
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId);
let result = await getDailyBattleList(role);
return resResult(STATUS.SUCCESS, { list: result });
}
// 购买每日次数
async buyNum(msg: { type: number, count: number }, session: BackendSession) {
let {type, count} = msg;
if( !count || count < 0) return resResult(STATUS.WRONG_PARMS);
const roleId = session.get('roleId');
const sid = session.get('sid');
const curDaily = gameData.daily.find(cur => cur.dailyType == type);
if(!curDaily) return resResult(STATUS.DAILY_TYPE_NOT_FOUND);
let { buyCount = 0 } = await DailyRecordModel.refreshRecord(roleId, type);
if(buyCount + count > curDaily.timesCanBuy ) {
return resResult(STATUS.DAILY_REFRESH_TIMES_LACK)
}
let buyCost = 0;
for(let i = 1; i <= count; i++) {
let num = buyCount + i;
buyCost += getDailyBuyCountCost(num);
}
let role = await RoleModel.findByRoleId(roleId);
if(buyCost > role.gold) {
return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
}
await handleCost(roleId, sid, [getGoldObject(buyCost)], ITEM_CHANGE_REASON.DAILY_BATTLE_BUY_CNT);
let newDailyRecord = await DailyRecordModel.increseBuyCount(roleId, type, count);
let checkDailyResult = await getDailyNum(newDailyRecord, role);
return resResult(STATUS.SUCCESS, { type, ...checkDailyResult, buyCost});
}
async debugResetNum(msg: { magicWord: string, type: number }, session: BackendSession) {
const { magicWord, type } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
await DailyRecordModel.deleteAccount(roleId);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession } from 'pinus';
import { DailyRecordModel } from '@db/DailyRecord';
import { STATUS } from '@consts/statusCode';
import { resResult } from '@pubUtils/util';
import { RoleModel } from '@db/Role';
import { getDailyNum, getDailyBattleList, getDailyBuyCountCost } from '../../../services/dailyBattleService';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { gameData } from '@pubUtils/data';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
export default function(app: Application) {
return new DailyBattleHandler(app);
}
export class DailyBattleHandler {
constructor(private app: Application) {
}
// 获取关卡列表
async getData(msg: { }, session: BackendSession) {
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId);
let result = await getDailyBattleList(role);
return resResult(STATUS.SUCCESS, { list: result });
}
// 购买每日次数
async buyNum(msg: { type: number, count: number }, session: BackendSession) {
let {type, count} = msg;
if( !count || count < 0) return resResult(STATUS.WRONG_PARMS);
const roleId = session.get('roleId');
const sid = session.get('sid');
const curDaily = gameData.daily.find(cur => cur.dailyType == type);
if(!curDaily) return resResult(STATUS.DAILY_TYPE_NOT_FOUND);
let { buyCount = 0 } = await DailyRecordModel.refreshRecord(roleId, type);
if(buyCount + count > curDaily.timesCanBuy ) {
return resResult(STATUS.DAILY_REFRESH_TIMES_LACK)
}
let buyCost = 0;
for(let i = 1; i <= count; i++) {
let num = buyCount + i;
buyCost += getDailyBuyCountCost(num);
}
let role = await RoleModel.findByRoleId(roleId);
if(buyCost > role.gold) {
return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
}
await handleCost(roleId, sid, [getGoldObject(buyCost)], ITEM_CHANGE_REASON.DAILY_BATTLE_BUY_CNT);
let newDailyRecord = await DailyRecordModel.increseBuyCount(roleId, type, count);
let checkDailyResult = await getDailyNum(newDailyRecord, role);
return resResult(STATUS.SUCCESS, { type, ...checkDailyResult, buyCost});
}
async debugResetNum(msg: { magicWord: string, type: number }, session: BackendSession) {
const { magicWord, type } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
await DailyRecordModel.deleteAccount(roleId);
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,87 +1,88 @@
import { Application, BackendSession } from 'pinus';
import { STATUS } from '../../../consts/statusCode';
import { resResult, shouldRefresh } from '../../../pubUtils/util';
import { RoleModel } from '../../../db/Role';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getDungeonData, getDungeonBuyCountCost } from '../../../services/dungeonService';
import * as dicParam from '../../../pubUtils/dicParam';
import { DungeonFirstModel } from '../../../db/DungeonFirst';
import { DungeonResultParam } from '../../../domain/battleField/dungeon';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
import { getVipDungeonCnt } from '../../../services/activity/monthlyTicketService';
export default function(app: Application) {
return new DungeonBattleHandler(app);
}
export class DungeonBattleHandler {
constructor(private app: Application) {
}
// 获取关卡列表
async getData(msg: { }, session: BackendSession) {
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId);
let res = await getDungeonData(role);
return resResult(STATUS.SUCCESS, res);
}
// 购买每日次数
async buyNum(msg: { count: number }, session: BackendSession) {
let { count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
let { dungeonCnt = 0, dungeonBuyCnt = 0, dungeonRefTime } = await RoleModel.findByRoleId(roleId);
let curTime = new Date();
let needRefresh = shouldRefresh(dungeonRefTime, curTime);
if(needRefresh) {
dungeonCnt = 0; dungeonBuyCnt = 0;
}
let timesCanBuy = dicParam.DUNGEON_CONST.DUNGEON_CONST_BUY;
if(dungeonBuyCnt + count > timesCanBuy ) {
return resResult(STATUS.DUNGEON_REFRESH_TIMES_LACK)
}
let buyCost = 0;
for(let i = 1; i <= count; i++) {
buyCost += getDungeonBuyCountCost(dungeonBuyCnt + i);
}
let {gold} = await RoleModel.findByRoleId(roleId);
if(buyCost > gold) {
return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
}
await handleCost(roleId, sid, [getGoldObject(buyCost)], ITEM_CHANGE_REASON.DUNGEON_BATTLE_BUY_CNT);
await RoleModel.buyCnt(roleId, needRefresh, count, curTime);
let nextCostGold = getDungeonBuyCountCost(dungeonBuyCnt + count + 1);
let freeCount = getVipDungeonCnt(session.get('vipStartTime'));
return resResult(STATUS.SUCCESS, {
costGold: buyCost,
nextCostGold,
battleCount: freeCount + dungeonBuyCnt + count - dungeonCnt,
buyCount: dicParam.DUNGEON_CONST.DUNGEON_CONST_BUY - dungeonBuyCnt - count
});
}
// 购买每日次数
async getFirstInfo(msg: { movePoint: number }, session: BackendSession) {
const { movePoint } = msg;
const serverId: number = session.get('serverId');
const firstInfos = await DungeonFirstModel.findByMovePoint(serverId, movePoint);
let result: DungeonResultParam[] = firstInfos.map(firstInfo => {
return new DungeonResultParam(firstInfo);
});
return resResult(STATUS.SUCCESS, { infos: result });
}
async debugResetRefTime(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
await RoleModel.updateRoleInfo(roleId, { dungeonRefTime: new Date(Date.now() - 86400000) });
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession } from 'pinus';
import { STATUS } from '@consts/statusCode';
import { resResult, shouldRefresh } from '@pubUtils/util';
import { RoleModel } from '@db/Role';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getDungeonData, getDungeonBuyCountCost } from '../../../services/dungeonService';
import * as dicParam from '@pubUtils/dicParam';
import { DungeonFirstModel } from '@db/DungeonFirst';
import { DungeonResultParam } from '@domain/battleField/dungeon';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON } from '../../../consts';
import { getVipDungeonCnt } from '../../../services/activity/monthlyTicketService';
export default function(app: Application) {
return new DungeonBattleHandler(app);
}
export class DungeonBattleHandler {
constructor(private app: Application) {
}
// 获取关卡列表
async getData(msg: { }, session: BackendSession) {
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId);
let res = await getDungeonData(role);
return resResult(STATUS.SUCCESS, res);
}
// 购买每日次数
async buyNum(msg: { count: number }, session: BackendSession) {
let { count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
let { dungeonCnt = 0, dungeonBuyCnt = 0, dungeonRefTime } = await RoleModel.findByRoleId(roleId);
let curTime = new Date();
let needRefresh = shouldRefresh(dungeonRefTime, curTime);
if(needRefresh) {
dungeonCnt = 0; dungeonBuyCnt = 0;
}
let timesCanBuy = dicParam.DUNGEON_CONST.DUNGEON_CONST_BUY;
if(dungeonBuyCnt + count > timesCanBuy ) {
return resResult(STATUS.DUNGEON_REFRESH_TIMES_LACK)
}
let buyCost = 0;
for(let i = 1; i <= count; i++) {
buyCost += getDungeonBuyCountCost(dungeonBuyCnt + i);
}
let {gold} = await RoleModel.findByRoleId(roleId);
if(buyCost > gold) {
return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
}
await handleCost(roleId, sid, [getGoldObject(buyCost)], ITEM_CHANGE_REASON.DUNGEON_BATTLE_BUY_CNT);
await RoleModel.buyCnt(roleId, needRefresh, count, curTime);
let nextCostGold = getDungeonBuyCountCost(dungeonBuyCnt + count + 1);
let freeCount = getVipDungeonCnt(session.get('vipStartTime'));
return resResult(STATUS.SUCCESS, {
costGold: buyCost,
nextCostGold,
battleCount: freeCount + dungeonBuyCnt + count - dungeonCnt,
buyCount: dicParam.DUNGEON_CONST.DUNGEON_CONST_BUY - dungeonBuyCnt - count
});
}
// 购买每日次数
async getFirstInfo(msg: { movePoint: number }, session: BackendSession) {
const { movePoint } = msg;
const serverId: number = session.get('serverId');
const firstInfos = await DungeonFirstModel.findByMovePoint(serverId, movePoint);
let result: DungeonResultParam[] = firstInfos.map(firstInfo => {
return new DungeonResultParam(firstInfo);
});
return resResult(STATUS.SUCCESS, { infos: result });
}
async debugResetRefTime(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
await RoleModel.updateRoleInfo(roleId, { dungeonRefTime: new Date(Date.now() - 86400000) });
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,161 +1,162 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { EventRecordModel } from '../../../db/EventRecord';
import { RoleModel } from '../../../db/Role';
import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS, TASK_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, EVENT_TYPE, EVENT_QUIZ_NUM } from '../../../consts';
import { checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz, startEvent, refreshEvent, getEventTime, randomPosition, randomQuestion } from '../../../services/eventSercive';
import { addItems } from '../../../services/role/rewardService';
import { STATUS } from '../../../consts/statusCode';
import { genCode, resResult } from '../../../pubUtils/util';
import { checkTask } from '../../../services/task/taskService';
import { gameData } from '../../../pubUtils/data';
export default function (app: Application) {
new HandlerService(app, {});
return new EventBattleHandler(app);
}
export class EventBattleHandler {
constructor(private app: Application) {
}
// 主动获取奇遇事件
async getEvents(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let eventStatus = session.get('eventStatus');
let event = eventStatus == EVENT_STATUS.WAITING? await startEvent(session): await getEvent(eventStatus, roleId, roleName);
return resResult(STATUS.SUCCESS, { list: event });
}
// 回答问题
async checkAnswer(msg: { eventId: number, eventCode: string, questionId: number, answer: number }, session: BackendSession) {
const { eventId, eventCode, questionId, answer } = msg;
let roleId = session.get('roleId');
// let roleName = session.get('roleName');
// let eventStatus = session.get('eventStatus');
let event = await EventRecordModel.getEventRecordByCode(roleId, eventCode);
if (!event) {
return resResult(STATUS.EVENT_RECORD_NOT_FOUND);
}
let { status, type, eventId: dataEventId, question } = event;
if (status != EVENT_RECORD_STATUS.WAITING) {
return resResult(STATUS.EVENT_STATUS_ERROR);
}
if (dataEventId != eventId) {
return resResult(STATUS.EVENT_WRONG_ID);
}
let curQuestion = question.find(cur => cur.id == questionId);
if (!curQuestion) return resResult(STATUS.EVENT_QUESTION_NOT_FOUND);
let { isCorrect, answerNo } = checkQuiz(questionId, answer);
let result = await EventRecordModel.saveEventAnswer(eventCode, questionId, isCorrect ? EVENT_ANSWER_STATUS.CORRECT : EVENT_ANSWER_STATUS.WRONG);
if (!result) {
return resResult(STATUS.EVENT_RECORD_NOT_FOUND);
}
let { question: newQuestion } = result;
let isClear = true, allCorrect = true;
for (let { status } of newQuestion) {
if (status) {
if (status == EVENT_ANSWER_STATUS.WRONG) {
allCorrect = false;
}
} else {
isClear = false; allCorrect = false;
}
}
if (isClear) {
await EventRecordModel.setStatusByCode(roleId, eventCode, allCorrect ? EVENT_RECORD_STATUS.BATTLE_SUCCESS : EVENT_RECORD_STATUS.BATTLE_FAIL);
}
return resResult(STATUS.SUCCESS, { eventCode, eventId, questionId, isCorrect, answerNo });
}
// 获取关卡列表
async receiveEventReward(msg: { eventId: number, eventCode: string }, session: BackendSession) {
const { eventId, eventCode } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let eventStatus = session.get('eventStatus');
let sid = session.get('sid');
const serverId = session.get('serverId');
let event = await EventRecordModel.getEventRecordByCode(roleId, eventCode);
if (!event) {
return resResult(STATUS.EVENT_RECORD_NOT_FOUND);
}
let { status, type, eventId: dataEventId, question } = event;
let flag = checkEventStatus(type, status);
if (!flag) {
return resResult(STATUS.EVENT_STATUS_ERROR);
}
let checkResult = getEventSuccessStatus(type, status, question);
if (checkResult.status == -1) {
return resResult(STATUS.EVENT_QUESTION_NO_ANSWER);
}
let isSuccess = checkResult.isSuccess;
if (dataEventId != eventId) {
return resResult(STATUS.EVENT_WRONG_ID);
}
let dicEvent = gameData.event.get(eventId);
if (!dicEvent) {
return resResult(STATUS.EVENT_INFO_NOT_FOUND);
}
// 保存状态
let result = await EventRecordModel.setStatusByCode(roleId, eventCode, isSuccess ? EVENT_RECORD_STATUS.SUCCESS_RECEIVED : EVENT_RECORD_STATUS.FAIL_RECEIVED);
// 保存奖励
let reward = isSuccess ? dicEvent.winReward : dicEvent.loseReward;
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.EVENT_REWARD);
if (eventStatus == EVENT_STATUS.STARTING) { // 如果是第一次开启的挑战,保存成开启状态
await RoleModel.setEventStatus(roleId, EVENT_STATUS.OPEN);
// 第一场时间挑战完,开始正常刷新事件,所以刷新时间也重置起来
session.set('eventStatus', EVENT_STATUS.OPEN);
session.push('eventStatus', () => { });
}
// 推送消息刷新
// await checkEvent(session, true);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.BATTLE_EVENT, { eventType: dicEvent.eventType });
return resResult(STATUS.SUCCESS, {
isSuccess,
eventCode: result.eventCode,
eventId: result.eventId,
status: result.status,
goods
});
}
async debugRefEvent(msg: { magicWord: string, eventId: number }, session: BackendSession) {
const { magicWord, eventId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let now = new Date();
let curTime = getEventTime(now); // 这次的时间节点 0-12前一天的18 12-1812 18-24 18
await EventRecordModel.updateMany({ roleId }, { $set: {status: -1} });
let dic = gameData.event.get(eventId);
let point = randomPosition(dic.movePointArray, [], []);
if(!point) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let question = dic.eventType == EVENT_TYPE.QUIZ?randomQuestion(EVENT_QUIZ_NUM): undefined;
let eventCode = genCode(8);
await EventRecordModel.saveEventRecord(eventCode, {
roleId, refTime: curTime, eventId: dic.eventID,
roleName, turn: 1, type: dic.eventType, battleId: dic.warId||0, quality: dic.quality,
status: EVENT_RECORD_STATUS.WAITING,
point, question
});
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { EventRecordModel } from '@db/EventRecord';
import { RoleModel } from '@db/Role';
import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS, TASK_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, EVENT_TYPE, EVENT_QUIZ_NUM } from '../../../consts';
import { checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz, startEvent, refreshEvent, getEventTime, randomPosition, randomQuestion } from '../../../services/eventSercive';
import { addItems } from '../../../services/role/rewardService';
import { STATUS } from '@consts/statusCode';
import { genCode, resResult } from '@pubUtils/util';
import { checkTask } from '../../../services/task/taskService';
import { gameData } from '@pubUtils/data';
export default function (app: Application) {
new HandlerService(app, {});
return new EventBattleHandler(app);
}
export class EventBattleHandler {
constructor(private app: Application) {
}
// 主动获取奇遇事件
async getEvents(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let eventStatus = session.get('eventStatus');
let event = eventStatus == EVENT_STATUS.WAITING? await startEvent(session): await getEvent(eventStatus, roleId, roleName);
return resResult(STATUS.SUCCESS, { list: event });
}
// 回答问题
async checkAnswer(msg: { eventId: number, eventCode: string, questionId: number, answer: number }, session: BackendSession) {
const { eventId, eventCode, questionId, answer } = msg;
let roleId = session.get('roleId');
// let roleName = session.get('roleName');
// let eventStatus = session.get('eventStatus');
let event = await EventRecordModel.getEventRecordByCode(roleId, eventCode);
if (!event) {
return resResult(STATUS.EVENT_RECORD_NOT_FOUND);
}
let { status, type, eventId: dataEventId, question } = event;
if (status != EVENT_RECORD_STATUS.WAITING) {
return resResult(STATUS.EVENT_STATUS_ERROR);
}
if (dataEventId != eventId) {
return resResult(STATUS.EVENT_WRONG_ID);
}
let curQuestion = question.find(cur => cur.id == questionId);
if (!curQuestion) return resResult(STATUS.EVENT_QUESTION_NOT_FOUND);
let { isCorrect, answerNo } = checkQuiz(questionId, answer);
let result = await EventRecordModel.saveEventAnswer(eventCode, questionId, isCorrect ? EVENT_ANSWER_STATUS.CORRECT : EVENT_ANSWER_STATUS.WRONG);
if (!result) {
return resResult(STATUS.EVENT_RECORD_NOT_FOUND);
}
let { question: newQuestion } = result;
let isClear = true, allCorrect = true;
for (let { status } of newQuestion) {
if (status) {
if (status == EVENT_ANSWER_STATUS.WRONG) {
allCorrect = false;
}
} else {
isClear = false; allCorrect = false;
}
}
if (isClear) {
await EventRecordModel.setStatusByCode(roleId, eventCode, allCorrect ? EVENT_RECORD_STATUS.BATTLE_SUCCESS : EVENT_RECORD_STATUS.BATTLE_FAIL);
}
return resResult(STATUS.SUCCESS, { eventCode, eventId, questionId, isCorrect, answerNo });
}
// 获取关卡列表
async receiveEventReward(msg: { eventId: number, eventCode: string }, session: BackendSession) {
const { eventId, eventCode } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let eventStatus = session.get('eventStatus');
let sid = session.get('sid');
const serverId = session.get('serverId');
let event = await EventRecordModel.getEventRecordByCode(roleId, eventCode);
if (!event) {
return resResult(STATUS.EVENT_RECORD_NOT_FOUND);
}
let { status, type, eventId: dataEventId, question } = event;
let flag = checkEventStatus(type, status);
if (!flag) {
return resResult(STATUS.EVENT_STATUS_ERROR);
}
let checkResult = getEventSuccessStatus(type, status, question);
if (checkResult.status == -1) {
return resResult(STATUS.EVENT_QUESTION_NO_ANSWER);
}
let isSuccess = checkResult.isSuccess;
if (dataEventId != eventId) {
return resResult(STATUS.EVENT_WRONG_ID);
}
let dicEvent = gameData.event.get(eventId);
if (!dicEvent) {
return resResult(STATUS.EVENT_INFO_NOT_FOUND);
}
// 保存状态
let result = await EventRecordModel.setStatusByCode(roleId, eventCode, isSuccess ? EVENT_RECORD_STATUS.SUCCESS_RECEIVED : EVENT_RECORD_STATUS.FAIL_RECEIVED);
// 保存奖励
let reward = isSuccess ? dicEvent.winReward : dicEvent.loseReward;
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.EVENT_REWARD);
if (eventStatus == EVENT_STATUS.STARTING) { // 如果是第一次开启的挑战,保存成开启状态
await RoleModel.setEventStatus(roleId, EVENT_STATUS.OPEN);
// 第一场时间挑战完,开始正常刷新事件,所以刷新时间也重置起来
session.set('eventStatus', EVENT_STATUS.OPEN);
session.push('eventStatus', () => { });
}
// 推送消息刷新
// await checkEvent(session, true);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.BATTLE_EVENT, { eventType: dicEvent.eventType });
return resResult(STATUS.SUCCESS, {
isSuccess,
eventCode: result.eventCode,
eventId: result.eventId,
status: result.status,
goods
});
}
async debugRefEvent(msg: { magicWord: string, eventId: number }, session: BackendSession) {
const { magicWord, eventId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let now = new Date();
let curTime = getEventTime(now); // 这次的时间节点 0-12前一天的18 12-1812 18-24 18
await EventRecordModel.updateMany({ roleId }, { $set: {status: -1} });
let dic = gameData.event.get(eventId);
let point = randomPosition(dic.movePointArray, [], []);
if(!point) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let question = dic.eventType == EVENT_TYPE.QUIZ?randomQuestion(EVENT_QUIZ_NUM): undefined;
let eventCode = genCode(8);
await EventRecordModel.saveEventRecord(eventCode, {
roleId, refTime: curTime, eventId: dic.eventID,
roleName, turn: 1, type: dic.eventType, battleId: dic.warId||0, quality: dic.quality,
status: EVENT_RECORD_STATUS.WAITING,
point, question
});
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,420 +1,421 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { ExpeditionRecordModel } from '../../../db/ExpeditionRecord';
import { ExpeditionWarRecordModel } from '../../../db/ExpeditionWarRecord';
import { ExpeditionPointModel } from '../../../db/ExpeditionPoint';
import { RoleModel } from '../../../db/Role';
import { genCode, getWarTypeName } from '../../../pubUtils/util';
import { getPointRewardStatus, getResetRemainCnt, findOrCreateEnemies, getExpeditionStatus } from '../../../services/expeditionService';
import { DEBUG_MAGIC_WORD, EXPEDITION_WAR_RECORD_STATUS, ITEM_CHANGE_REASON, KING_EXP_RATIO_TYPE, TASK_TYPE, TA_EVENT } from '../../../consts';
import { WarReward } from '../../../services/warRewardService';
import { addItems } from '../../../services/role/rewardService';
import { getAp, setAp } from '../../../services/actionPointService';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { calculateWarStar, checkBattleHeroes, getBattleRecordParam, roleLevelup } from '../../../services/normalBattleService';
import { checkTask, checkTaskInBattleEnd, checkTaskInBattleStart, checkTaskInSkipExpedition } from '../../../services/task/taskService';
import { gameData } from '../../../pubUtils/data';
import * as dicParam from '../../../pubUtils/dicParam';
import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
import { reportTAEvent } from '../../../services/sdkService';
import { getSumCe } from '../../../services/playerCeService';
import { vipCanSkipExpedition } from '../../../services/activity/monthlyTicketService';
import { isHeroHidden } from '../../../services/dataService';
import { pvpEndParamInter } from '../../../pubUtils/interface';
export default function (app: Application) {
new HandlerService(app, {});
return new ExpeditionBattleHandler(app);
}
export class ExpeditionBattleHandler {
constructor(private app: Application) {
}
/**
* 获取初始数据
* 获取当前远征挑战情况,远征点数,点数宝箱领取情况 */
async getStatus(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let res = await getExpeditionStatus(roleId, roleName);
if (!res) return resResult(STATUS.ROLE_IS_NOT_INIT);
return resResult(STATUS.SUCCESS, res);
}
/**
* 重置远征本
* 每天5点可以重置远征本 */
async resetStatus(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let curTime = new Date();
let { needRefresh, resetCnt } = await getResetRemainCnt(curTime, roleId);
if (resetCnt <= 0) {
return resResult(STATUS.EXPEDITION_RESET_NUM_NOT_ENOUGH)
}
await ExpeditionRecordModel.hideRecord(roleId); // 刷掉旧关卡
// 我方战力
let myCe = await getSumCe(roleId);
// 每一关的挑战状态
let { expeditionCode, heroes } = await ExpeditionRecordModel.createRecord({
roleId, roleName, heroes: [], myCe
});
await findOrCreateEnemies(roleId, myCe, expeditionCode, 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
await RoleModel.increaseExpeditionResetCnt(roleId, needRefresh, curTime);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCode(expeditionCode);
let curLv = 0;
if (expeditionWarRecord.length > 0) {
curLv = expeditionWarRecord[expeditionWarRecord.length - 1].expeditionId;
}
return resResult(STATUS.SUCCESS, {
expeditionCode,
curLv,
expeditionWarRecord,
heroes,
resetCnt: resetCnt - 1
});
}
/**
* 获取敌军数据
* 匹配其他玩家,或机器人数据
*/
async getEnemies(msg: { expeditionCode: string, expeditionId: number }, session: BackendSession) {
const roleId = session.get('roleId');
// const roleName = session.get('roleName');
const { expeditionCode, expeditionId } = msg;
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (expeditionWarRecord && (expeditionWarRecord.battleStatus == EXPEDITION_WAR_RECORD_STATUS.SUCCESS)) {
return resResult(STATUS.EXPEDITION_DUPLICATE_CHALLENGE);
}
let { myCe } = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let curExpeditionWarRecord = await findOrCreateEnemies(roleId, myCe, expeditionCode, expeditionId, EXPEDITION_WAR_RECORD_STATUS.WAITING);
if (!curExpeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MATCH_NO_PLAYER);
}
let { battleId, mapseid, enemyFrom, enemies, battleStatus, ce: curCe } = curExpeditionWarRecord;
let nextCe = 0; // 下一关战力
if (gameData.expedition.has(expeditionId + 1)) {
let nextExpeditionWarRecord = await findOrCreateEnemies(roleId, myCe, expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.HIDE);
if (nextExpeditionWarRecord) nextCe = nextExpeditionWarRecord.ce;
}
return resResult(STATUS.SUCCESS, {
expeditionCode, expeditionId, battleId, mapseid,
battleStatus,
enemyFrom,
enemies,
curCe,
nextCe
});
}
/**
* 进入战斗
* 记录我军数据,生成战斗唯一表示,记录状态
*/
async checkBattle(msg: { expeditionCode: string, expeditionId: number, battleId: number, heroes: number[] }, session: BackendSession) {
const { expeditionCode, expeditionId, battleId, heroes: seqIds = [] } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let ip = session.get('ip');
let serverId = session.get('serverId');
let sid = session.get('sid');
let warInfo = gameData.war.get(battleId);
if (!warInfo) {
return resResult(STATUS.BATTLE_MISS_INFO);
}
let role = await RoleModel.findByRoleId(roleId, 'lv warStar');
let apJson = await getAp(roleId, ip, role.lv);
let { ap } = apJson;
if (ap < warInfo.cost) {
return resResult(STATUS.BATTLE_ACTION_POINT_LACK);
}
// 前置关卡是否挑战过
let previousGk = warInfo.previousGk;
if (previousGk) {
let preBattle = role.warStar.findIndex(cur => cur.id == previousGk);
if (preBattle == -1) return resResult(STATUS.BATTLE_NEED_PREVIOUS_GK);
}
let { isOK, hids } = await checkBattleHeroes(roleId, seqIds);
if (!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (!expeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MISS_WAR_RECORD);
}
if (expeditionWarRecord.battleStatus == EXPEDITION_WAR_RECORD_STATUS.SUCCESS) {
return resResult(STATUS.EXPEDITION_DUPLICATE_CHALLENGE);
}
const battleCode = genCode(8);
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId,
status: 0,
warName: warInfo.gk_name,
warType: warInfo.warType,
record: { heroes: hids, seqIds }
}
}, true);
let result = await ExpeditionWarRecordModel.updateBattleCode(expeditionCode, expeditionId, EXPEDITION_WAR_RECORD_STATUS.WAITING, battleCode);
await checkTaskInBattleStart(serverId, roleId, sid, battleId);
return resResult(STATUS.SUCCESS, {
expeditionCode,
expeditionId,
battleId,
battleCode,
battleStatus: result.battleStatus
});
}
/**
* 跳过
*/
async skipExpedition(msg: { expeditionCode: string, expeditionId: number, battleId: number }, session: BackendSession) {
const { expeditionCode, expeditionId, battleId } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let sid = session.get('sid');
let dicExpedition = gameData.expedition.get(expeditionId);
if(dicExpedition.warId != battleId) return resResult(STATUS.WRONG_PARMS);
let dicWar = gameData.war.get(battleId);
if(!dicWar) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 前置关卡是否挑战过
let role = await RoleModel.findByRoleId(roleId, 'warStar topLineupCe vipStartTime')
let { warStar, topLineupCe, vipStartTime } = role;
let previousGk = dicWar.previousGk;
if (previousGk) {
let preBattle = warStar.findIndex(cur => cur.id == previousGk);
if (preBattle == -1) return resResult(STATUS.BATTLE_NEED_PREVIOUS_GK);
}
// 检查record
let expeditionRecord = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (!expeditionRecord || !expeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MISS_WAR_RECORD);
}
if(expeditionWarRecord.battleStatus == EXPEDITION_WAR_RECORD_STATUS.SUCCESS) {
return resResult(STATUS.EXPEDITION_DUPLICATE_CHALLENGE);
}
// 检查战力是否足够
if(!vipCanSkipExpedition(expeditionWarRecord.ce, topLineupCe, vipStartTime)) {
return resResult(STATUS.EXPEDITION_SKIP_POWER_NOT_ENOUGH)
}
// 更新敌人剩余状态及战斗状态
expeditionWarRecord = await ExpeditionWarRecordModel.updateEnemiesStatus(expeditionCode, expeditionId, EXPEDITION_WAR_RECORD_STATUS.SUCCESS, []);
// 更新点数
role = await RoleModel.increaseExpeditionPoint(roleId, dicParam.EXPEDITION_CONST.EXPEDITION_CONST_POINTS);
// 关卡奖励
let warReward = new WarReward(roleId, roleName, sid, battleId, true);
let reward = await warReward.saveReward(1);
let curWarStar = warStar.find(cur => cur.id == battleId);
let { newWarStars, newStar } = calculateWarStar(warStar, battleId, []);
if (!curWarStar || newStar > curWarStar.star) {
role = await RoleModel.updateRoleInfo(roleId, { warStar: newWarStars });
}
// 更新下一关状态
if (gameData.expedition.has(expeditionId + 1)) {
await findOrCreateEnemies(roleId, expeditionRecord.myCe, expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
}
await checkTaskInSkipExpedition(serverId, roleId, sid, battleId);
return resResult(STATUS.SUCCESS, {
expeditionCode,
expeditionId,
battleId,
goods: reward,
expeditionPoint: role.expeditionPoint
});
}
/**
* 战斗结算
* 结算战斗奖励,更新远征状态
*/
async battleEnd(msg: { expeditionCode: string, expeditionId: number, battleCode: string, battleId: number, isSuccess: boolean, heroes: Array<{ dataId: number, hp: number, ap: number, shield: number, others: string }>, enemies: Array<{ dataId: number, hp: number, ap: number }>, star: number, stars: number[], damageRecords: pvpEndParamInter[], round: number }, session: BackendSession) {
const { expeditionCode, battleCode, battleId, expeditionId, isSuccess, heroes = [], star, stars = [], enemies, damageRecords, round } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
const serverId = session.get('serverId');
let sid = session.get('sid');
let ip = session.get('ip');
let warInfo = gameData.war.get(battleId);
if (!warInfo) {
return resResult(STATUS.BATTLE_MISS_INFO);
}
const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode);
if (!BattleRecord || BattleRecord.status != 0) {
return resResult(STATUS.BATTLE_STATUS_WRONG);
}
let flag = 1; // 对比hero信息
let { record: { heroes: dbHeroes, seqIds: dbSeqIds }, createdAt } = BattleRecord;
for (let { dataId } of heroes) {
if (dbSeqIds.indexOf(dataId) == -1) flag = 0;
}
if (!flag) {
return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
}
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await setAp(serverId, roleId, ip, role.lv, isSuccess?-1 * warInfo.cost: 0, sid, ITEM_CHANGE_REASON.EXPEDITION_BATTLE_END); // 扣除体力
if (!apJson) {
return resResult(STATUS.BATTLE_ACTION_POINT_LACK);
}
// 检查record
let expeditionRecord = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (!expeditionRecord || !expeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MISS_WAR_RECORD);
}
// 更新我方剩余血量
await ExpeditionRecordModel.updateHeroStatus(expeditionCode, expeditionRecord.heroes, heroes);
// 更新敌人剩余状态及战斗状态
let battleStatus = isSuccess ? EXPEDITION_WAR_RECORD_STATUS.SUCCESS : EXPEDITION_WAR_RECORD_STATUS.FAIL;
expeditionWarRecord = await ExpeditionWarRecordModel.updateEnemiesStatus(expeditionCode, expeditionId, battleStatus, enemies);
// 更新battleRecord状态
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess ? 1 : 2, star, ...getBattleRecordParam(damageRecords, round) }
}, true);
// 更新点数
role = await RoleModel.increaseExpeditionPoint(roleId, isSuccess ? dicParam.EXPEDITION_CONST.EXPEDITION_CONST_POINTS : 0);
let { expeditionPoint = 0, warStar = [] } = role;
// 关卡奖励
let warReward = new WarReward(roleId, roleName, sid, battleId, isSuccess);
let reward = await warReward.saveReward(1);
let actordata = await roleLevelup(KING_EXP_RATIO_TYPE.BATTLE, roleId, isSuccess ? warInfo.kingExp : 0, session);// 主公升级经验
let curWarStar = warStar.find(cur => cur.id == battleId);
let { newWarStars, newStar } = calculateWarStar(warStar, battleId, stars);
if (isSuccess) {
// 更新下一关状态
await ExpeditionWarRecordModel.updateStatus(expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
if(!curWarStar) { // 首通
reportTAEvent(roleId, TA_EVENT.GK_FIRST_PASS, { war_id: battleId, war_type: getWarTypeName(warInfo.warType), pass_time: Date.now(), pass_duration: nowSeconds() - getSeconds(createdAt), hero_list: dbHeroes });
}
if (!curWarStar || newStar > curWarStar.star) {
await RoleModel.updateRoleInfo(roleId, { warStar: newWarStars });
}
}
await checkTaskInBattleEnd(serverId, roleId, sid, battleId, dbHeroes, star, isSuccess);
return resResult(STATUS.SUCCESS, {
expeditionCode, expeditionId,
battleCode, battleId,
battleStatus: expeditionWarRecord.battleStatus,
battleGoods: reward,
expeditionPoint,
createdAt: getSeconds(createdAt),
...actordata
});
}
/**
* 领取点数宝箱
* 领取点数宝箱,不扣除点数,那么就需要记录领取状态并且有返回
*/
async pointReward(msg: { point: number }, session: BackendSession) {
const { point } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
const serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId);
let { expeditionPoint } = role;
let dicExpeditionPoint = gameData.expeditionPoint;
let curDicExpeditionPoint = dicExpeditionPoint.get(point);
if (!curDicExpeditionPoint) {
return resResult(STATUS.EXPEDITION_MISS_POINT_INFO);
}
if (point > expeditionPoint) {
return resResult(STATUS.EXPEDITION_POINT_NOT_ENOUGH);
}
let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
if (pointStatusInDatabase) {
let { rewards } = pointStatusInDatabase;
let curReward = rewards.find(cur => cur.point == point);
if (curReward && curReward.received) {
return resResult(STATUS.EXPEDITION_WRONG_RECEIVE_STATUS);
}
}
// 标记状态
let { rewards: resultRewards } = await ExpeditionPointModel.updatePointStatus(roleId, point, curDicExpeditionPoint.reward);
let hasReceivedAll = true, maxPoint = 0;
for (let [point] of dicExpeditionPoint) {
let curReward = resultRewards.find(cur => cur.point == point);
if (!curReward || !curReward.received) {
hasReceivedAll = false;
}
if (point > maxPoint) maxPoint = point;
}
if (hasReceivedAll) { // 全部领取了,刷新
await ExpeditionPointModel.completeStatus(roleId);
await RoleModel.increaseExpeditionPoint(roleId, maxPoint * -1);
}
let pointRewards = await getPointRewardStatus(roleId);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.BATTLE_EXPEDITION_BOX, { point });
let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward, ITEM_CHANGE_REASON.EXPEDITION_POINT_REWARD);
return resResult(STATUS.SUCCESS, {
costPoint: hasReceivedAll ? maxPoint : 0,
pointRewards,
goods
})
}
async debugResetResetNum(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
await RoleModel.updateRoleInfo(roleId, { expeditionResetCnt: 0 });
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { BattleRecordModel } from '@db/BattleRecord';
import { ExpeditionRecordModel } from '@db/ExpeditionRecord';
import { ExpeditionWarRecordModel } from '@db/ExpeditionWarRecord';
import { ExpeditionPointModel } from '@db/ExpeditionPoint';
import { RoleModel } from '@db/Role';
import { genCode, getWarTypeName } from '@pubUtils/util';
import { getPointRewardStatus, getResetRemainCnt, findOrCreateEnemies, getExpeditionStatus } from '../../../services/expeditionService';
import { DEBUG_MAGIC_WORD, EXPEDITION_WAR_RECORD_STATUS, ITEM_CHANGE_REASON, KING_EXP_RATIO_TYPE, TASK_TYPE, TA_EVENT } from '../../../consts';
import { WarReward } from '../../../services/warRewardService';
import { addItems } from '../../../services/role/rewardService';
import { getAp, setAp } from '../../../services/actionPointService';
import { STATUS } from '@consts/statusCode';
import { resResult } from '@pubUtils/util';
import { calculateWarStar, checkBattleHeroes, getBattleRecordParam, roleLevelup } from '../../../services/normalBattleService';
import { checkTask, checkTaskInBattleEnd, checkTaskInBattleStart, checkTaskInSkipExpedition } from '../../../services/task/taskService';
import { gameData } from '@pubUtils/data';
import * as dicParam from '@pubUtils/dicParam';
import { getSeconds, nowSeconds } from '@pubUtils/timeUtil';
import { reportTAEvent } from '../../../services/sdkService';
import { getSumCe } from '../../../services/playerCeService';
import { vipCanSkipExpedition } from '../../../services/activity/monthlyTicketService';
import { isHeroHidden } from '../../../services/dataService';
import { pvpEndParamInter } from '@pubUtils/interface';
export default function (app: Application) {
new HandlerService(app, {});
return new ExpeditionBattleHandler(app);
}
export class ExpeditionBattleHandler {
constructor(private app: Application) {
}
/**
* 获取初始数据
* 获取当前远征挑战情况,远征点数,点数宝箱领取情况 */
async getStatus(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let res = await getExpeditionStatus(roleId, roleName);
if (!res) return resResult(STATUS.ROLE_IS_NOT_INIT);
return resResult(STATUS.SUCCESS, res);
}
/**
* 重置远征本
* 每天5点可以重置远征本 */
async resetStatus(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let curTime = new Date();
let { needRefresh, resetCnt } = await getResetRemainCnt(curTime, roleId);
if (resetCnt <= 0) {
return resResult(STATUS.EXPEDITION_RESET_NUM_NOT_ENOUGH)
}
await ExpeditionRecordModel.hideRecord(roleId); // 刷掉旧关卡
// 我方战力
let myCe = await getSumCe(roleId);
// 每一关的挑战状态
let { expeditionCode, heroes } = await ExpeditionRecordModel.createRecord({
roleId, roleName, heroes: [], myCe
});
await findOrCreateEnemies(roleId, myCe, expeditionCode, 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
await RoleModel.increaseExpeditionResetCnt(roleId, needRefresh, curTime);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCode(expeditionCode);
let curLv = 0;
if (expeditionWarRecord.length > 0) {
curLv = expeditionWarRecord[expeditionWarRecord.length - 1].expeditionId;
}
return resResult(STATUS.SUCCESS, {
expeditionCode,
curLv,
expeditionWarRecord,
heroes,
resetCnt: resetCnt - 1
});
}
/**
* 获取敌军数据
* 匹配其他玩家,或机器人数据
*/
async getEnemies(msg: { expeditionCode: string, expeditionId: number }, session: BackendSession) {
const roleId = session.get('roleId');
// const roleName = session.get('roleName');
const { expeditionCode, expeditionId } = msg;
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (expeditionWarRecord && (expeditionWarRecord.battleStatus == EXPEDITION_WAR_RECORD_STATUS.SUCCESS)) {
return resResult(STATUS.EXPEDITION_DUPLICATE_CHALLENGE);
}
let { myCe } = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let curExpeditionWarRecord = await findOrCreateEnemies(roleId, myCe, expeditionCode, expeditionId, EXPEDITION_WAR_RECORD_STATUS.WAITING);
if (!curExpeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MATCH_NO_PLAYER);
}
let { battleId, mapseid, enemyFrom, enemies, battleStatus, ce: curCe } = curExpeditionWarRecord;
let nextCe = 0; // 下一关战力
if (gameData.expedition.has(expeditionId + 1)) {
let nextExpeditionWarRecord = await findOrCreateEnemies(roleId, myCe, expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.HIDE);
if (nextExpeditionWarRecord) nextCe = nextExpeditionWarRecord.ce;
}
return resResult(STATUS.SUCCESS, {
expeditionCode, expeditionId, battleId, mapseid,
battleStatus,
enemyFrom,
enemies,
curCe,
nextCe
});
}
/**
* 进入战斗
* 记录我军数据,生成战斗唯一表示,记录状态
*/
async checkBattle(msg: { expeditionCode: string, expeditionId: number, battleId: number, heroes: number[] }, session: BackendSession) {
const { expeditionCode, expeditionId, battleId, heroes: seqIds = [] } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let ip = session.get('ip');
let serverId = session.get('serverId');
let sid = session.get('sid');
let warInfo = gameData.war.get(battleId);
if (!warInfo) {
return resResult(STATUS.BATTLE_MISS_INFO);
}
let role = await RoleModel.findByRoleId(roleId, 'lv warStar');
let apJson = await getAp(roleId, ip, role.lv);
let { ap } = apJson;
if (ap < warInfo.cost) {
return resResult(STATUS.BATTLE_ACTION_POINT_LACK);
}
// 前置关卡是否挑战过
let previousGk = warInfo.previousGk;
if (previousGk) {
let preBattle = role.warStar.findIndex(cur => cur.id == previousGk);
if (preBattle == -1) return resResult(STATUS.BATTLE_NEED_PREVIOUS_GK);
}
let { isOK, hids } = await checkBattleHeroes(roleId, seqIds);
if (!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (!expeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MISS_WAR_RECORD);
}
if (expeditionWarRecord.battleStatus == EXPEDITION_WAR_RECORD_STATUS.SUCCESS) {
return resResult(STATUS.EXPEDITION_DUPLICATE_CHALLENGE);
}
const battleCode = genCode(8);
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId,
status: 0,
warName: warInfo.gk_name,
warType: warInfo.warType,
record: { heroes: hids, seqIds }
}
}, true);
let result = await ExpeditionWarRecordModel.updateBattleCode(expeditionCode, expeditionId, EXPEDITION_WAR_RECORD_STATUS.WAITING, battleCode);
await checkTaskInBattleStart(serverId, roleId, sid, battleId);
return resResult(STATUS.SUCCESS, {
expeditionCode,
expeditionId,
battleId,
battleCode,
battleStatus: result.battleStatus
});
}
/**
* 跳过
*/
async skipExpedition(msg: { expeditionCode: string, expeditionId: number, battleId: number }, session: BackendSession) {
const { expeditionCode, expeditionId, battleId } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let sid = session.get('sid');
let dicExpedition = gameData.expedition.get(expeditionId);
if(dicExpedition.warId != battleId) return resResult(STATUS.WRONG_PARMS);
let dicWar = gameData.war.get(battleId);
if(!dicWar) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 前置关卡是否挑战过
let role = await RoleModel.findByRoleId(roleId, 'warStar topLineupCe vipStartTime')
let { warStar, topLineupCe, vipStartTime } = role;
let previousGk = dicWar.previousGk;
if (previousGk) {
let preBattle = warStar.findIndex(cur => cur.id == previousGk);
if (preBattle == -1) return resResult(STATUS.BATTLE_NEED_PREVIOUS_GK);
}
// 检查record
let expeditionRecord = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (!expeditionRecord || !expeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MISS_WAR_RECORD);
}
if(expeditionWarRecord.battleStatus == EXPEDITION_WAR_RECORD_STATUS.SUCCESS) {
return resResult(STATUS.EXPEDITION_DUPLICATE_CHALLENGE);
}
// 检查战力是否足够
if(!vipCanSkipExpedition(expeditionWarRecord.ce, topLineupCe, vipStartTime)) {
return resResult(STATUS.EXPEDITION_SKIP_POWER_NOT_ENOUGH)
}
// 更新敌人剩余状态及战斗状态
expeditionWarRecord = await ExpeditionWarRecordModel.updateEnemiesStatus(expeditionCode, expeditionId, EXPEDITION_WAR_RECORD_STATUS.SUCCESS, []);
// 更新点数
role = await RoleModel.increaseExpeditionPoint(roleId, dicParam.EXPEDITION_CONST.EXPEDITION_CONST_POINTS);
// 关卡奖励
let warReward = new WarReward(roleId, roleName, sid, battleId, true);
let reward = await warReward.saveReward(1);
let curWarStar = warStar.find(cur => cur.id == battleId);
let { newWarStars, newStar } = calculateWarStar(warStar, battleId, []);
if (!curWarStar || newStar > curWarStar.star) {
role = await RoleModel.updateRoleInfo(roleId, { warStar: newWarStars });
}
// 更新下一关状态
if (gameData.expedition.has(expeditionId + 1)) {
await findOrCreateEnemies(roleId, expeditionRecord.myCe, expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
}
await checkTaskInSkipExpedition(serverId, roleId, sid, battleId);
return resResult(STATUS.SUCCESS, {
expeditionCode,
expeditionId,
battleId,
goods: reward,
expeditionPoint: role.expeditionPoint
});
}
/**
* 战斗结算
* 结算战斗奖励,更新远征状态
*/
async battleEnd(msg: { expeditionCode: string, expeditionId: number, battleCode: string, battleId: number, isSuccess: boolean, heroes: Array<{ dataId: number, hp: number, ap: number, shield: number, others: string }>, enemies: Array<{ dataId: number, hp: number, ap: number }>, star: number, stars: number[], damageRecords: pvpEndParamInter[], round: number }, session: BackendSession) {
const { expeditionCode, battleCode, battleId, expeditionId, isSuccess, heroes = [], star, stars = [], enemies, damageRecords, round } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
const serverId = session.get('serverId');
let sid = session.get('sid');
let ip = session.get('ip');
let warInfo = gameData.war.get(battleId);
if (!warInfo) {
return resResult(STATUS.BATTLE_MISS_INFO);
}
const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode);
if (!BattleRecord || BattleRecord.status != 0) {
return resResult(STATUS.BATTLE_STATUS_WRONG);
}
let flag = 1; // 对比hero信息
let { record: { heroes: dbHeroes, seqIds: dbSeqIds }, createdAt } = BattleRecord;
for (let { dataId } of heroes) {
if (dbSeqIds.indexOf(dataId) == -1) flag = 0;
}
if (!flag) {
return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
}
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await setAp(serverId, roleId, ip, role.lv, isSuccess?-1 * warInfo.cost: 0, sid, ITEM_CHANGE_REASON.EXPEDITION_BATTLE_END); // 扣除体力
if (!apJson) {
return resResult(STATUS.BATTLE_ACTION_POINT_LACK);
}
// 检查record
let expeditionRecord = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if (!expeditionRecord || !expeditionWarRecord) {
return resResult(STATUS.EXPEDITION_MISS_WAR_RECORD);
}
// 更新我方剩余血量
await ExpeditionRecordModel.updateHeroStatus(expeditionCode, expeditionRecord.heroes, heroes);
// 更新敌人剩余状态及战斗状态
let battleStatus = isSuccess ? EXPEDITION_WAR_RECORD_STATUS.SUCCESS : EXPEDITION_WAR_RECORD_STATUS.FAIL;
expeditionWarRecord = await ExpeditionWarRecordModel.updateEnemiesStatus(expeditionCode, expeditionId, battleStatus, enemies);
// 更新battleRecord状态
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess ? 1 : 2, star, ...getBattleRecordParam(damageRecords, round) }
}, true);
// 更新点数
role = await RoleModel.increaseExpeditionPoint(roleId, isSuccess ? dicParam.EXPEDITION_CONST.EXPEDITION_CONST_POINTS : 0);
let { expeditionPoint = 0, warStar = [] } = role;
// 关卡奖励
let warReward = new WarReward(roleId, roleName, sid, battleId, isSuccess);
let reward = await warReward.saveReward(1);
let actordata = await roleLevelup(KING_EXP_RATIO_TYPE.BATTLE, roleId, isSuccess ? warInfo.kingExp : 0, session);// 主公升级经验
let curWarStar = warStar.find(cur => cur.id == battleId);
let { newWarStars, newStar } = calculateWarStar(warStar, battleId, stars);
if (isSuccess) {
// 更新下一关状态
await ExpeditionWarRecordModel.updateStatus(expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
if(!curWarStar) { // 首通
reportTAEvent(roleId, TA_EVENT.GK_FIRST_PASS, { war_id: battleId, war_type: getWarTypeName(warInfo.warType), pass_time: Date.now(), pass_duration: nowSeconds() - getSeconds(createdAt), hero_list: dbHeroes });
}
if (!curWarStar || newStar > curWarStar.star) {
await RoleModel.updateRoleInfo(roleId, { warStar: newWarStars });
}
}
await checkTaskInBattleEnd(serverId, roleId, sid, battleId, dbHeroes, star, isSuccess);
return resResult(STATUS.SUCCESS, {
expeditionCode, expeditionId,
battleCode, battleId,
battleStatus: expeditionWarRecord.battleStatus,
battleGoods: reward,
expeditionPoint,
createdAt: getSeconds(createdAt),
...actordata
});
}
/**
* 领取点数宝箱
* 领取点数宝箱,不扣除点数,那么就需要记录领取状态并且有返回
*/
async pointReward(msg: { point: number }, session: BackendSession) {
const { point } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
const serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId);
let { expeditionPoint } = role;
let dicExpeditionPoint = gameData.expeditionPoint;
let curDicExpeditionPoint = dicExpeditionPoint.get(point);
if (!curDicExpeditionPoint) {
return resResult(STATUS.EXPEDITION_MISS_POINT_INFO);
}
if (point > expeditionPoint) {
return resResult(STATUS.EXPEDITION_POINT_NOT_ENOUGH);
}
let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
if (pointStatusInDatabase) {
let { rewards } = pointStatusInDatabase;
let curReward = rewards.find(cur => cur.point == point);
if (curReward && curReward.received) {
return resResult(STATUS.EXPEDITION_WRONG_RECEIVE_STATUS);
}
}
// 标记状态
let { rewards: resultRewards } = await ExpeditionPointModel.updatePointStatus(roleId, point, curDicExpeditionPoint.reward);
let hasReceivedAll = true, maxPoint = 0;
for (let [point] of dicExpeditionPoint) {
let curReward = resultRewards.find(cur => cur.point == point);
if (!curReward || !curReward.received) {
hasReceivedAll = false;
}
if (point > maxPoint) maxPoint = point;
}
if (hasReceivedAll) { // 全部领取了,刷新
await ExpeditionPointModel.completeStatus(roleId);
await RoleModel.increaseExpeditionPoint(roleId, maxPoint * -1);
}
let pointRewards = await getPointRewardStatus(roleId);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.BATTLE_EXPEDITION_BOX, { point });
let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward, ITEM_CHANGE_REASON.EXPEDITION_POINT_REWARD);
return resResult(STATUS.SUCCESS, {
costPoint: hasReceivedAll ? maxPoint : 0,
pointRewards,
goods
})
}
async debugResetResetNum(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
await RoleModel.updateRoleInfo(roleId, { expeditionResetCnt: 0 });
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,61 +1,62 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { LadderMatchModel } from '../../../db/LadderMatch';
import { HeroModel, HeroType } from '../../../db/Hero';
import { ArtifactModel } from '../../../db/Artifact';
import { getHeroesAttributes } from '../../../services/playerCeService';
import { gameData } from '../../../pubUtils/data';
import { LadderOppDetailHeroReturn } from '../../../domain/battleField/ladder';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { RoleType } from '../../../db/Role';
import { FRIEND_BATTLE_DISPATCH_JSONID } from '../../../consts';
import { getLadderDefCe } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new FriendBattleHandler(app);
}
export class FriendBattleHandler {
constructor(private app: Application) {
}
async getFriendOpp(msg: { roleId: string }, session: BackendSession) {
const { roleId: targetRoleId, } = msg;
let hisLadderData = await LadderMatchModel.findByRoleIdAndInclude(targetRoleId);
if (!hisLadderData || !hisLadderData.defense || !hisLadderData.defense.heroes) return resResult(STATUS.LADDER_NOT_OPEN);
let artifactSeids = [], subHids: number[] = [];
for (let { hero, subHid } of hisLadderData.defense.heroes) {
let dbHero = <HeroType>hero;
if (dbHero) artifactSeids.push(dbHero.artifact);
if (subHid) subHids.push(subHid);
}
let artifacts = await ArtifactModel.findbySeqIds(targetRoleId, artifactSeids);
let subHeroes = await HeroModel.findByHidRange(subHids, targetRoleId, 'hid skinId');
let attrByHid = await getHeroesAttributes(targetRoleId);
let dicWarJson = gameData.warJson.get(FRIEND_BATTLE_DISPATCH_JSONID);
let result: LadderOppDetailHeroReturn[] = [];
for (let obj of hisLadderData.defense.heroes) {
const { dataId, subHid, actorId } = obj;
let warJson = dicWarJson.find(cur => cur.dataId == dataId);
if (warJson) {
let subHero = subHeroes.find(sub => sub.hid == subHid);
let rec = new LadderOppDetailHeroReturn(warJson, obj, artifacts, subHero);
let attr = attrByHid.get(actorId);
if (attr) {
rec.setAttribute(attr.getAttributesToString());
}
result.push(rec);
}
}
const role = <RoleType>hisLadderData.role;
const title = role?.title || 1;
const combo = hisLadderData.defense.combo || [];
const defCe = await getLadderDefCe(targetRoleId);
return resResult(STATUS.SUCCESS, { title, combo, defCe, heroes: result })
}
}
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { LadderMatchModel } from '@db/LadderMatch';
import { HeroModel, HeroType } from '@db/Hero';
import { ArtifactModel } from '@db/Artifact';
import { getHeroesAttributes } from '../../../services/playerCeService';
import { gameData } from '@pubUtils/data';
import { LadderOppDetailHeroReturn } from '@domain/battleField/ladder';
import { resResult } from '@pubUtils/util';
import { STATUS } from '@consts/statusCode';
import { RoleType } from '@db/Role';
import { FRIEND_BATTLE_DISPATCH_JSONID } from '../../../consts';
import { getLadderDefCe } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new FriendBattleHandler(app);
}
export class FriendBattleHandler {
constructor(private app: Application) {
}
async getFriendOpp(msg: { roleId: string }, session: BackendSession) {
const { roleId: targetRoleId, } = msg;
let hisLadderData = await LadderMatchModel.findByRoleIdAndInclude(targetRoleId);
if (!hisLadderData || !hisLadderData.defense || !hisLadderData.defense.heroes) return resResult(STATUS.LADDER_NOT_OPEN);
let artifactSeids = [], subHids: number[] = [];
for (let { hero, subHid } of hisLadderData.defense.heroes) {
let dbHero = <HeroType>hero;
if (dbHero) artifactSeids.push(dbHero.artifact);
if (subHid) subHids.push(subHid);
}
let artifacts = await ArtifactModel.findbySeqIds(targetRoleId, artifactSeids);
let subHeroes = await HeroModel.findByHidRange(subHids, targetRoleId, 'hid skinId');
let attrByHid = await getHeroesAttributes(targetRoleId);
let dicWarJson = gameData.warJson.get(FRIEND_BATTLE_DISPATCH_JSONID);
let result: LadderOppDetailHeroReturn[] = [];
for (let obj of hisLadderData.defense.heroes) {
const { dataId, subHid, actorId } = obj;
let warJson = dicWarJson.find(cur => cur.dataId == dataId);
if (warJson) {
let subHero = subHeroes.find(sub => sub.hid == subHid);
let rec = new LadderOppDetailHeroReturn(warJson, obj, artifacts, subHero);
let attr = attrByHid.get(actorId);
if (attr) {
rec.setAttribute(attr.getAttributesToString());
}
result.push(rec);
}
}
const role = <RoleType>hisLadderData.role;
const title = role?.title || 1;
const combo = hisLadderData.defense.combo || [];
const defCe = await getLadderDefCe(targetRoleId);
return resResult(STATUS.SUCCESS, { title, combo, defCe, heroes: result })
}
}

View File

@@ -1,455 +1,456 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { isArray, pick } from 'underscore';
import { gameData } from '../../../pubUtils/data';
import { STATUS } from '../../../consts/statusCode';
import { arrToMap, resResult } from '../../../pubUtils/util';
import { getTimeFunM } from '../../../pubUtils/timeUtil';
import { LadderMatchModel, LadderUpdateInter } from '../../../db/LadderMatch';
import { battleEndWhenChange, checkRank, generateInitRecInfo, generateOppPlayers, getBuyCntCost, getLadderData, getLadderEnemies, getLadderOppDetailData, getLadderOppStatus, getNumberArr, ladderBattleEndReward, pushLadderIconShow, refreshLadderDaily, refreshLadderEnemies, sendLadderDailyReward, uniqueArr } from '../../../services/ladderService';
import { LadderDataReturn, LadderDefense, LadderDefenseHero, LadderOppDetailReturn, LadderOppLineupReturn, LadderOppPlayerHeroInfo, LadderOppPlayerReturn } from '../../../domain/battleField/ladder';
import { LadderMatchRecModel } from '../../../db/LadderMatchRec';
import { HeroModel } from '../../../db/Hero';
import { LADDER } from '../../../pubUtils/dicParam';
import { handleCost } from '../../../services/role/rewardService';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS, REDIS_KEY, WAR_TYPE } from '../../../consts';
import { checkBattleHeroesByHid, getBattleRecordParam } from '../../../services/normalBattleService';
import { ServerlistModel } from '../../../db/Serverlist';
import { saveLadderDefCeByData } from '../../../services/redisService';
import { pushLadderTopChangeMsg } from '../../../services/sysChatService';
import { checkTaskInLadderEnd, checkTaskInLadderStart, checkTaskInLadderSweep } from '../../../services/task/taskService';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { isHeroHidden } from '../../../services/dataService';
import { getRemoteRplFilePath, getRemoteRplPrefix } from '../../../pubUtils/battleUtils';
import { pvpEndParamInter } from '../../../pubUtils/interface';
import { Combo } from '../../../domain/battleField/pvp';
export default function (app: Application) {
new HandlerService(app, {});
return new LadderHandler(app);
}
export class LadderHandler {
constructor(private app: Application) {
}
// 1. 获取主界面
async getData(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let result = await getLadderData(roleId, true)
return resResult(STATUS.SUCCESS, result);
}
// 2. 获取对手阵容信息
async getOppLineup(msg: { roleId: string, rank: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { roleId: targetRoleId, rank } = msg;
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let isRobot = targetRoleId.startsWith('robot');
let result = new LadderOppLineupReturn();
result.setMyRank(ladderData.rank);
if(isRobot) {
let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
let dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
result.setRobot(dicLadderDifficultRatio, dicWarJson);
} else {
let hisLadderData = await LadderMatchModel.findOne({ roleId: targetRoleId })
.populate('role', 'roleId roleName head frame spine heads frames spines title lv guildName updatedAt')
.populate('defense.heroes.hero', 'hid skinId quality star colorStar lv skins job artifact subHid subActorId')
.lean();
result.setPlayer(hisLadderData);
}
return resResult(STATUS.SUCCESS, result);
}
// 3. 点击挑战
async chooseOpp(msg: { roleId: string, rank: number, myRank: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let sid = session.get('sid');
let { roleId: targetRoleId, rank, myRank } = msg;
// 检查双方排名等,不行的刷新对手回去
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
if(!checkRank(myRank, rank)) return resResult(STATUS.LADDER_RANK_ERROR);
let { status, isRobot, hisLadderData } = await getLadderOppStatus(ladderData, targetRoleId, myRank, rank);
if(status != LADDER_OPP_STATUS.BATTLE) {
// await LadderMatchModel.unlock(serverId, targetRoleId);
let oppPlayers = await refreshLadderEnemies(ladderData);
return resResult(STATUS.SUCCESS, {
status, oppPlayers
});
}
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
let update: LadderUpdateInter = {};
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.challengeCnt + 1 > LADDER.LADDER_CHALLENGE_FREE_TIMES + refOppObj.buyCnt) {
await LadderMatchModel.unlock(serverId, targetRoleId);
return resResult(STATUS.LADDER_CHALLENGE_CNT_MAX);
}
update.challengeCnt = refOppObj.challengeCnt + 1;
ladderData = await LadderMatchModel.updateByRoleIdAndInclude(roleId, update);
// 创建ladderMatchRec发行battleCode
let attackInfo = await generateInitRecInfo(false, false, ladderData.rank, ladderData);
let defenseInfo = await generateInitRecInfo(isRobot, true, rank, hisLadderData);
let rec = await LadderMatchRecModel.createRec(serverId, roleId, targetRoleId, hisLadderData?.defense, attackInfo, defenseInfo);
// 倒计时倒计时结束没有check设为失败并发失败通知
pinus.app.rpc.systimer.systimerRemote.setLadderCountDown.broadcast(rec.battleCode, rec.checkTime, LADDER_STATUS.CHECK);
let result = await getLadderOppDetailData(rec);
await checkTaskInLadderStart(serverId, roleId, sid);
return resResult(STATUS.SUCCESS, {
status,
challengeCnt: ladderData.challengeCnt,
...result
});
}
// 4. 出战撤退
async giveupCheck(msg: { battleCode: string }, session: BackendSession) {
let roleId = session.get('roleId');
let { battleCode } = msg;
// 更新ladderMatchRec
let rec = await LadderMatchRecModel.giveup(roleId, battleCode);
if(rec) {
pinus.app.rpc.systimer.systimerRemote.cancelLadderCountDown.broadcast(rec.battleCode);
if(rec.defenseInfo && !rec.defenseInfo.isRobot) await LadderMatchModel.unlock(rec.serverId, rec.defenseInfo.roleId);
}
return resResult(STATUS.SUCCESS, { status: 0, time: 0 });
}
// 5. 获取对手具体战场数据
async getOppData(msg: { battleCode: string }, session: BackendSession) {
let roleId = session.get('roleId');
let { battleCode } = msg;
let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
if(rec.status == LADDER_STATUS.COMPLETE || rec.status == LADDER_STATUS.NO) return resResult(STATUS.LADDER_REC_STATUS_IS_COMPLETE);
let result = await getLadderOppDetailData(rec);
return resResult(STATUS.SUCCESS, result);
}
// 6. 布完阵开始挑战
async checkBattle(msg: { battleCode: string, battleId: number, heroes: { actorId: number, order: number }[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleId');
let { battleId, battleCode, heroes } = msg;
let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
if(rec.status != LADDER_STATUS.CHECK) return resResult(STATUS.LADDER_REC_STATUS_ERR);
for(let { actorId } of heroes) {
if(isHeroHidden(actorId)) return resResult(STATUS.HERO_IS_HIDDEN);
}
let { isOK, heroes: dbHeroes } = await checkBattleHeroesByHid(roleId, heroes.map(cur => cur.actorId));
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
let attackHeroes = dbHeroes.map(hero => {
let heroInfo = new LadderOppPlayerHeroInfo();
heroInfo.setByDefenseHero(hero);
return heroInfo;
});
let warInfo = gameData.war.get(battleId);
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId,
status: 0,
warName: warInfo?.gk_name,
warType: warInfo?.warType,
}
});
rec = await LadderMatchRecModel.startBattle(battleCode, attackHeroes);
pinus.app.rpc.systimer.systimerRemote.setLadderCountDown.broadcast(rec.battleCode, rec.battleTime, LADDER_STATUS.BATTLE);
return resResult(STATUS.SUCCESS, {
time: Math.floor(rec.battleTime/1000) + LADDER.LADDER_BATTLE_COUNTDOWN,
battleCode: rec.battleCode
})
}
// 7. 挑战结算
async battleEnd(msg: { battleCode: string, isSuccess: boolean, damageRecords: pvpEndParamInter[], round: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let sid = session.get('sid');
let { battleCode, isSuccess, damageRecords, round } = msg;
let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
if(rec.status != LADDER_STATUS.BATTLE) return resResult(STATUS.LADDER_REC_STATUS_ERR);
let rank = rec.defenseInfo.oldRank;
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
// 取消 checkBattle 的倒计时
pinus.app.rpc.systimer.systimerRemote.cancelLadderCountDown.broadcast(battleCode);
let result = new LadderDataReturn();
// 交换双方排名, transaction
let { isChange, atkLadderMatch, defLadderMatch, endTime } = await LadderMatchModel.changeRank(isSuccess, rec.attackInfo, rec.defenseInfo);
if(isChange) {
let oppPlayers = await battleEndWhenChange(atkLadderMatch, defLadderMatch, true);
result.setOppPlayers(oppPlayers);
rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess, endTime, atkLadderMatch.rank, defLadderMatch? defLadderMatch.rank: rec.attackInfo.oldRank);
if(atkLadderMatch.rank == 1) {
pushLadderTopChangeMsg(roleId, roleName, serverId);
}
} else {
rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess, endTime);
let oppPlayers = await getLadderEnemies(atkLadderMatch);
result.setOppPlayers(oppPlayers);
}
await BattleRecordModel.updateBattleRecordByCode(battleCode, { $set: { status: isSuccess? 1: 2, ...getBattleRecordParam(damageRecords, round) } });
if(defLadderMatch) {
await LadderMatchModel.unlock(defLadderMatch.serverId, defLadderMatch.roleId);
}
let historyRank = ladderData.historyRank;
ladderData = await LadderMatchModel.updateByRoleId(roleId, { historyRank: (historyRank > atkLadderMatch.rank || historyRank == 0)? atkLadderMatch.rank: historyRank });
result.setLadderData(ladderData, rec);
// 获取奖励
let rewardResult = await ladderBattleEndReward(roleId, roleName, sid, ladderData.historyRank, isSuccess, historyRank, 1);
let { battleGoods = [], breakGoods = [] } = rewardResult||{};
await checkTaskInLadderEnd(serverId, roleId, sid, isSuccess, historyRank, atkLadderMatch.rank);
if (isSuccess && (!rec.defenseInfo?.isRobot) && rec.defenseInfo.oldRank < rec.defenseInfo.newRank) await pushLadderIconShow(rec.roleId2, true);
return resResult(STATUS.SUCCESS, {...pick(result, ['rank', 'historyRank', 'challengeCnt','status', 'time', 'oppPlayers']), battleGoods, breakGoods});
}
// 8. 战5次扫荡
async battleSweep(msg: { roleId: string, rank: number, count: number }, session: BackendSession) {
let serverId = session.get('serverId');
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { roleId: targetRoleId, rank, count } = msg;
if(count > LADDER.LADDER_INITIAL_CHALLENGE_TIMES) {
return resResult(STATUS.LADDER_SWEEP_TIMES_OVER);
}
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
if(ladderData.rank >= rank) return resResult(STATUS.LADDER_RANK_ERR);
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
let update: LadderUpdateInter = {};
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.challengeCnt + count > LADDER.LADDER_CHALLENGE_FREE_TIMES + refOppObj.buyCnt) {
return resResult(STATUS.LADDER_CHALLENGE_CNT_MAX);
}
update.challengeCnt = refOppObj.challengeCnt + count;
ladderData = await LadderMatchModel.updateByRoleIdAndInclude(roleId, update);
// 获取奖励
let { battleGoods } = await ladderBattleEndReward(roleId, roleName, sid, rank, true, rank, count);
await checkTaskInLadderSweep(serverId, roleId, sid, count)
return resResult(STATUS.SUCCESS, {
challengeCnt: ladderData.challengeCnt,
battleGoods
});
}
// 9. 设置防守阵容
async saveDefense(msg: { warId: number, heroes: { actorId: number, ai: number, dataId: number, order: number, subHid?: number }[], combo: Combo[] }, session: BackendSession) {
let { warId, heroes, combo } = msg;
let roleId = session.get('roleId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let hids: number[] = heroes.map(cur => cur.actorId);
if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
for(let { actorId, subHid } of heroes) {
let dicHero = gameData.hero.get(actorId);
if(subHid && (!dicHero || dicHero.urType != 1)) return resResult(STATUS.HERO_CAN_NOT_SET_SUB);
if(subHid && hids.indexOf(subHid) != -1) return resResult(STATUS.HERO_SUB_DUPLICATE);
}
let dbHeroes = await HeroModel.findByHidRange(hids, roleId, '_id hid ce', true);
let defenseHeroes = heroes.map(cur => {
let dbHero = dbHeroes.find(ccur => ccur.hid == cur.actorId);
return dbHero && new LadderDefenseHero(cur, dbHero._id, dbHero.ce);
}).filter(cur => cur);
let defense = new LadderDefense(defenseHeroes, warId, combo);
ladderData = await LadderMatchModel.updateByRoleId(roleId, { defense, hasDefense: true });
// 返回
let result = new LadderDataReturn();
result.setLadderData(ladderData);
await saveLadderDefCeByData(roleId, ladderData);
return resResult(STATUS.SUCCESS, pick(result, 'defense'));
}
// 10. 刷新对手
async refreshOppPlayers(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let update: LadderUpdateInter = {};
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.refOppCnt + 1 > LADDER.LADDER_REFRESH_TIMES) {
return resResult(STATUS.LADDER_REFRESH_CNT_MAX);
}
update.refOppCnt = refOppObj.refOppCnt + 1;
let oppPlayers = await refreshLadderEnemies(ladderData, update);
// 返回
return resResult(STATUS.SUCCESS, { refOppCnt: update.refOppCnt, oppPlayers });
}
// 11. 购买次数
async buyCnt(msg: { count: number }, session: BackendSession) {
let { count } = msg;
let roleId = session.get('roleId');
let sid = session.get('sid');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let update: LadderUpdateInter = {};
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.buyCnt + count > LADDER.LADDER_CHALLENGE_COST_TIMES) {
return resResult(STATUS.LADDER_BUY_MAX);
}
let consumes = getBuyCntCost(refOppObj.buyCnt, count);
if(!consumes) return resResult(STATUS.LADDER_BUY_MAX);
let consumeResult = await handleCost(roleId, sid, consumes||[], ITEM_CHANGE_REASON.LADDER_BUY_CNT);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
update.buyCnt = refOppObj.buyCnt + count;
ladderData = await LadderMatchModel.updateByRoleId(roleId, update);
// 返回
let result = new LadderDataReturn();
result.setLadderData(ladderData);
return resResult(STATUS.SUCCESS, pick(result, ['buyCnt', 'challengeCnt']));
}
// 12. 获取战报信息2天内
async getRec(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let list = await LadderMatchRecModel.findRecentRec(roleId, <number>getTimeFunM().getBeforeDay(2));
return resResult(STATUS.SUCCESS, {
list: list.map(rec => {
const { roleId1, battleCode, hasRpl, remoteUrl } = rec;
const rplFileUrl = battleCode && hasRpl ? remoteUrl : '';
return { ...rec, rplFileUrl };
}),
rplPrefixUrl: getRemoteRplPrefix(pinus.app.get('env'))
});
}
// debug接口
// 重置挑战次数 & 购买次数
async resetCnt(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
await LadderMatchModel.updateByRoleId(roleId, { refDaily: new Date(Date.now() - 86400000) });
return resResult(STATUS.SUCCESS);
}
async setMyRank(msg: { magicWord: string, rank: number }, session: BackendSession) {
const { magicWord, rank } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let atkLadderMatch = await LadderMatchModel.findByRoleId(roleId);
if(!atkLadderMatch || !atkLadderMatch.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let myRank = atkLadderMatch.rank;
let defLadderMatch = await LadderMatchModel.findByRank(serverId, rank);
if(defLadderMatch) {
atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { rank, oldRank: myRank, historyRank: rank } }, { new: true }).lean();
defLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: defLadderMatch.roleId }, { $set: { rank: myRank, oldRank: rank } }, { new: true }).lean();
} else {
atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { rank, oldRank: atkLadderMatch.rank, historyRank: rank } }, { new: true }).lean();
}
await battleEndWhenChange(atkLadderMatch, defLadderMatch, true);
return resResult(STATUS.SUCCESS);
}
async setMyOpp(msg: { magicWord: string, oppRanks: number[] }, session: BackendSession) {
const { magicWord, oppRanks } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.WRONG_PARMS);
}
if(!isArray(oppRanks) || oppRanks.length <= 0) return resResult(STATUS.WRONG_PARMS);
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let topTen = getNumberArr(1, 10);
let ranks = [...topTen, ...oppRanks];
let newRanks = uniqueArr(ranks.sort((a, b) => a - b));
await generateOppPlayers(newRanks, serverId, roleId);
return resResult(STATUS.SUCCESS);
}
async sendDailyReward(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
for(let { id } of servers) {
await sendLadderDailyReward(id);
}
return resResult(STATUS.SUCCESS)
}
}
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { isArray, pick } from 'underscore';
import { gameData } from '@pubUtils/data';
import { STATUS } from '@consts/statusCode';
import { arrToMap, resResult } from '@pubUtils/util';
import { getTimeFunM } from '@pubUtils/timeUtil';
import { LadderMatchModel, LadderUpdateInter } from '@db/LadderMatch';
import { battleEndWhenChange, checkRank, generateInitRecInfo, generateOppPlayers, getBuyCntCost, getLadderData, getLadderEnemies, getLadderOppDetailData, getLadderOppStatus, getNumberArr, ladderBattleEndReward, pushLadderIconShow, refreshLadderDaily, refreshLadderEnemies, sendLadderDailyReward, uniqueArr } from '../../../services/ladderService';
import { LadderDataReturn, LadderDefense, LadderDefenseHero, LadderOppDetailReturn, LadderOppLineupReturn, LadderOppPlayerHeroInfo, LadderOppPlayerReturn } from '@domain/battleField/ladder';
import { LadderMatchRecModel } from '@db/LadderMatchRec';
import { HeroModel } from '@db/Hero';
import { LADDER } from '@pubUtils/dicParam';
import { handleCost } from '../../../services/role/rewardService';
import { DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS, REDIS_KEY, WAR_TYPE } from '../../../consts';
import { checkBattleHeroesByHid, getBattleRecordParam } from '../../../services/normalBattleService';
import { ServerlistModel } from '@db/Serverlist';
import { saveLadderDefCeByData } from '../../../services/redisService';
import { pushLadderTopChangeMsg } from '../../../services/sysChatService';
import { checkTaskInLadderEnd, checkTaskInLadderStart, checkTaskInLadderSweep } from '../../../services/task/taskService';
import { BattleRecordModel } from '@db/BattleRecord';
import { isHeroHidden } from '../../../services/dataService';
import { getRemoteRplFilePath, getRemoteRplPrefix } from '@pubUtils/battleUtils';
import { pvpEndParamInter } from '@pubUtils/interface';
import { Combo } from '@domain/battleField/pvp';
export default function (app: Application) {
new HandlerService(app, {});
return new LadderHandler(app);
}
export class LadderHandler {
constructor(private app: Application) {
}
// 1. 获取主界面
async getData(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let result = await getLadderData(roleId, true)
return resResult(STATUS.SUCCESS, result);
}
// 2. 获取对手阵容信息
async getOppLineup(msg: { roleId: string, rank: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { roleId: targetRoleId, rank } = msg;
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let isRobot = targetRoleId.startsWith('robot');
let result = new LadderOppLineupReturn();
result.setMyRank(ladderData.rank);
if(isRobot) {
let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
let dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
result.setRobot(dicLadderDifficultRatio, dicWarJson);
} else {
let hisLadderData = await LadderMatchModel.findOne({ roleId: targetRoleId })
.populate('role', 'roleId roleName head frame spine heads frames spines title lv guildName updatedAt')
.populate('defense.heroes.hero', 'hid skinId quality star colorStar lv skins job artifact subHid subActorId')
.lean();
result.setPlayer(hisLadderData);
}
return resResult(STATUS.SUCCESS, result);
}
// 3. 点击挑战
async chooseOpp(msg: { roleId: string, rank: number, myRank: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let sid = session.get('sid');
let { roleId: targetRoleId, rank, myRank } = msg;
// 检查双方排名等,不行的刷新对手回去
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
if(!checkRank(myRank, rank)) return resResult(STATUS.LADDER_RANK_ERROR);
let { status, isRobot, hisLadderData } = await getLadderOppStatus(ladderData, targetRoleId, myRank, rank);
if(status != LADDER_OPP_STATUS.BATTLE) {
// await LadderMatchModel.unlock(serverId, targetRoleId);
let oppPlayers = await refreshLadderEnemies(ladderData);
return resResult(STATUS.SUCCESS, {
status, oppPlayers
});
}
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
let update: LadderUpdateInter = {};
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.challengeCnt + 1 > LADDER.LADDER_CHALLENGE_FREE_TIMES + refOppObj.buyCnt) {
await LadderMatchModel.unlock(serverId, targetRoleId);
return resResult(STATUS.LADDER_CHALLENGE_CNT_MAX);
}
update.challengeCnt = refOppObj.challengeCnt + 1;
ladderData = await LadderMatchModel.updateByRoleIdAndInclude(roleId, update);
// 创建ladderMatchRec发行battleCode
let attackInfo = await generateInitRecInfo(false, false, ladderData.rank, ladderData);
let defenseInfo = await generateInitRecInfo(isRobot, true, rank, hisLadderData);
let rec = await LadderMatchRecModel.createRec(serverId, roleId, targetRoleId, hisLadderData?.defense, attackInfo, defenseInfo);
// 倒计时倒计时结束没有check设为失败并发失败通知
pinus.app.rpc.systimer.systimerRemote.setLadderCountDown.broadcast(rec.battleCode, rec.checkTime, LADDER_STATUS.CHECK);
let result = await getLadderOppDetailData(rec);
await checkTaskInLadderStart(serverId, roleId, sid);
return resResult(STATUS.SUCCESS, {
status,
challengeCnt: ladderData.challengeCnt,
...result
});
}
// 4. 出战撤退
async giveupCheck(msg: { battleCode: string }, session: BackendSession) {
let roleId = session.get('roleId');
let { battleCode } = msg;
// 更新ladderMatchRec
let rec = await LadderMatchRecModel.giveup(roleId, battleCode);
if(rec) {
pinus.app.rpc.systimer.systimerRemote.cancelLadderCountDown.broadcast(rec.battleCode);
if(rec.defenseInfo && !rec.defenseInfo.isRobot) await LadderMatchModel.unlock(rec.serverId, rec.defenseInfo.roleId);
}
return resResult(STATUS.SUCCESS, { status: 0, time: 0 });
}
// 5. 获取对手具体战场数据
async getOppData(msg: { battleCode: string }, session: BackendSession) {
let roleId = session.get('roleId');
let { battleCode } = msg;
let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
if(rec.status == LADDER_STATUS.COMPLETE || rec.status == LADDER_STATUS.NO) return resResult(STATUS.LADDER_REC_STATUS_IS_COMPLETE);
let result = await getLadderOppDetailData(rec);
return resResult(STATUS.SUCCESS, result);
}
// 6. 布完阵开始挑战
async checkBattle(msg: { battleCode: string, battleId: number, heroes: { actorId: number, order: number }[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleId');
let { battleId, battleCode, heroes } = msg;
let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
if(rec.status != LADDER_STATUS.CHECK) return resResult(STATUS.LADDER_REC_STATUS_ERR);
for(let { actorId } of heroes) {
if(isHeroHidden(actorId)) return resResult(STATUS.HERO_IS_HIDDEN);
}
let { isOK, heroes: dbHeroes } = await checkBattleHeroesByHid(roleId, heroes.map(cur => cur.actorId));
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
let attackHeroes = dbHeroes.map(hero => {
let heroInfo = new LadderOppPlayerHeroInfo();
heroInfo.setByDefenseHero(hero);
return heroInfo;
});
let warInfo = gameData.war.get(battleId);
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId,
status: 0,
warName: warInfo?.gk_name,
warType: warInfo?.warType,
}
});
rec = await LadderMatchRecModel.startBattle(battleCode, attackHeroes);
pinus.app.rpc.systimer.systimerRemote.setLadderCountDown.broadcast(rec.battleCode, rec.battleTime, LADDER_STATUS.BATTLE);
return resResult(STATUS.SUCCESS, {
time: Math.floor(rec.battleTime/1000) + LADDER.LADDER_BATTLE_COUNTDOWN,
battleCode: rec.battleCode
})
}
// 7. 挑战结算
async battleEnd(msg: { battleCode: string, isSuccess: boolean, damageRecords: pvpEndParamInter[], round: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let sid = session.get('sid');
let { battleCode, isSuccess, damageRecords, round } = msg;
let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
if(!rec || rec.roleId1 != roleId) return resResult(STATUS.LADDER_REC_NOT_FOUND);
if(rec.status != LADDER_STATUS.BATTLE) return resResult(STATUS.LADDER_REC_STATUS_ERR);
let rank = rec.defenseInfo.oldRank;
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
// 取消 checkBattle 的倒计时
pinus.app.rpc.systimer.systimerRemote.cancelLadderCountDown.broadcast(battleCode);
let result = new LadderDataReturn();
// 交换双方排名, transaction
let { isChange, atkLadderMatch, defLadderMatch, endTime } = await LadderMatchModel.changeRank(isSuccess, rec.attackInfo, rec.defenseInfo);
if(isChange) {
let oppPlayers = await battleEndWhenChange(atkLadderMatch, defLadderMatch, true);
result.setOppPlayers(oppPlayers);
rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess, endTime, atkLadderMatch.rank, defLadderMatch? defLadderMatch.rank: rec.attackInfo.oldRank);
if(atkLadderMatch.rank == 1) {
pushLadderTopChangeMsg(roleId, roleName, serverId);
}
} else {
rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess, endTime);
let oppPlayers = await getLadderEnemies(atkLadderMatch);
result.setOppPlayers(oppPlayers);
}
await BattleRecordModel.updateBattleRecordByCode(battleCode, { $set: { status: isSuccess? 1: 2, ...getBattleRecordParam(damageRecords, round) } });
if(defLadderMatch) {
await LadderMatchModel.unlock(defLadderMatch.serverId, defLadderMatch.roleId);
}
let historyRank = ladderData.historyRank;
ladderData = await LadderMatchModel.updateByRoleId(roleId, { historyRank: (historyRank > atkLadderMatch.rank || historyRank == 0)? atkLadderMatch.rank: historyRank });
result.setLadderData(ladderData, rec);
// 获取奖励
let rewardResult = await ladderBattleEndReward(roleId, roleName, sid, ladderData.historyRank, isSuccess, historyRank, 1);
let { battleGoods = [], breakGoods = [] } = rewardResult||{};
await checkTaskInLadderEnd(serverId, roleId, sid, isSuccess, historyRank, atkLadderMatch.rank);
if (isSuccess && (!rec.defenseInfo?.isRobot) && rec.defenseInfo.oldRank < rec.defenseInfo.newRank) await pushLadderIconShow(rec.roleId2, true);
return resResult(STATUS.SUCCESS, {...pick(result, ['rank', 'historyRank', 'challengeCnt','status', 'time', 'oppPlayers']), battleGoods, breakGoods});
}
// 8. 战5次扫荡
async battleSweep(msg: { roleId: string, rank: number, count: number }, session: BackendSession) {
let serverId = session.get('serverId');
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { roleId: targetRoleId, rank, count } = msg;
if(count > LADDER.LADDER_INITIAL_CHALLENGE_TIMES) {
return resResult(STATUS.LADDER_SWEEP_TIMES_OVER);
}
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
if(ladderData.rank >= rank) return resResult(STATUS.LADDER_RANK_ERR);
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
let update: LadderUpdateInter = {};
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.challengeCnt + count > LADDER.LADDER_CHALLENGE_FREE_TIMES + refOppObj.buyCnt) {
return resResult(STATUS.LADDER_CHALLENGE_CNT_MAX);
}
update.challengeCnt = refOppObj.challengeCnt + count;
ladderData = await LadderMatchModel.updateByRoleIdAndInclude(roleId, update);
// 获取奖励
let { battleGoods } = await ladderBattleEndReward(roleId, roleName, sid, rank, true, rank, count);
await checkTaskInLadderSweep(serverId, roleId, sid, count)
return resResult(STATUS.SUCCESS, {
challengeCnt: ladderData.challengeCnt,
battleGoods
});
}
// 9. 设置防守阵容
async saveDefense(msg: { warId: number, heroes: { actorId: number, ai: number, dataId: number, order: number, subHid?: number }[], combo: Combo[] }, session: BackendSession) {
let { warId, heroes, combo } = msg;
let roleId = session.get('roleId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let hids: number[] = heroes.map(cur => cur.actorId);
if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
for(let { actorId, subHid } of heroes) {
let dicHero = gameData.hero.get(actorId);
if(subHid && (!dicHero || dicHero.urType != 1)) return resResult(STATUS.HERO_CAN_NOT_SET_SUB);
if(subHid && hids.indexOf(subHid) != -1) return resResult(STATUS.HERO_SUB_DUPLICATE);
}
let dbHeroes = await HeroModel.findByHidRange(hids, roleId, '_id hid ce', true);
let defenseHeroes = heroes.map(cur => {
let dbHero = dbHeroes.find(ccur => ccur.hid == cur.actorId);
return dbHero && new LadderDefenseHero(cur, dbHero._id, dbHero.ce);
}).filter(cur => cur);
let defense = new LadderDefense(defenseHeroes, warId, combo);
ladderData = await LadderMatchModel.updateByRoleId(roleId, { defense, hasDefense: true });
// 返回
let result = new LadderDataReturn();
result.setLadderData(ladderData);
await saveLadderDefCeByData(roleId, ladderData);
return resResult(STATUS.SUCCESS, pick(result, 'defense'));
}
// 10. 刷新对手
async refreshOppPlayers(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let update: LadderUpdateInter = {};
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.refOppCnt + 1 > LADDER.LADDER_REFRESH_TIMES) {
return resResult(STATUS.LADDER_REFRESH_CNT_MAX);
}
update.refOppCnt = refOppObj.refOppCnt + 1;
let oppPlayers = await refreshLadderEnemies(ladderData, update);
// 返回
return resResult(STATUS.SUCCESS, { refOppCnt: update.refOppCnt, oppPlayers });
}
// 11. 购买次数
async buyCnt(msg: { count: number }, session: BackendSession) {
let { count } = msg;
let roleId = session.get('roleId');
let sid = session.get('sid');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let update: LadderUpdateInter = {};
// 刷新次数
let refOppObj = refreshLadderDaily(ladderData);
if(refOppObj.shouldRefOpp) {
update = { ...refOppObj };
}
if(refOppObj.buyCnt + count > LADDER.LADDER_CHALLENGE_COST_TIMES) {
return resResult(STATUS.LADDER_BUY_MAX);
}
let consumes = getBuyCntCost(refOppObj.buyCnt, count);
if(!consumes) return resResult(STATUS.LADDER_BUY_MAX);
let consumeResult = await handleCost(roleId, sid, consumes||[], ITEM_CHANGE_REASON.LADDER_BUY_CNT);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
update.buyCnt = refOppObj.buyCnt + count;
ladderData = await LadderMatchModel.updateByRoleId(roleId, update);
// 返回
let result = new LadderDataReturn();
result.setLadderData(ladderData);
return resResult(STATUS.SUCCESS, pick(result, ['buyCnt', 'challengeCnt']));
}
// 12. 获取战报信息2天内
async getRec(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let list = await LadderMatchRecModel.findRecentRec(roleId, <number>getTimeFunM().getBeforeDay(2));
return resResult(STATUS.SUCCESS, {
list: list.map(rec => {
const { roleId1, battleCode, hasRpl, remoteUrl } = rec;
const rplFileUrl = battleCode && hasRpl ? remoteUrl : '';
return { ...rec, rplFileUrl };
}),
rplPrefixUrl: getRemoteRplPrefix(pinus.app.get('env'))
});
}
// debug接口
// 重置挑战次数 & 购买次数
async resetCnt(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
await LadderMatchModel.updateByRoleId(roleId, { refDaily: new Date(Date.now() - 86400000) });
return resResult(STATUS.SUCCESS);
}
async setMyRank(msg: { magicWord: string, rank: number }, session: BackendSession) {
const { magicWord, rank } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let atkLadderMatch = await LadderMatchModel.findByRoleId(roleId);
if(!atkLadderMatch || !atkLadderMatch.defense) return resResult(STATUS.LADDER_NOT_OPEN);
let myRank = atkLadderMatch.rank;
let defLadderMatch = await LadderMatchModel.findByRank(serverId, rank);
if(defLadderMatch) {
atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { rank, oldRank: myRank, historyRank: rank } }, { new: true }).lean();
defLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: defLadderMatch.roleId }, { $set: { rank: myRank, oldRank: rank } }, { new: true }).lean();
} else {
atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { rank, oldRank: atkLadderMatch.rank, historyRank: rank } }, { new: true }).lean();
}
await battleEndWhenChange(atkLadderMatch, defLadderMatch, true);
return resResult(STATUS.SUCCESS);
}
async setMyOpp(msg: { magicWord: string, oppRanks: number[] }, session: BackendSession) {
const { magicWord, oppRanks } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.WRONG_PARMS);
}
if(!isArray(oppRanks) || oppRanks.length <= 0) return resResult(STATUS.WRONG_PARMS);
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
let topTen = getNumberArr(1, 10);
let ranks = [...topTen, ...oppRanks];
let newRanks = uniqueArr(ranks.sort((a, b) => a - b));
await generateOppPlayers(newRanks, serverId, roleId);
return resResult(STATUS.SUCCESS);
}
async sendDailyReward(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
for(let { id } of servers) {
await sendLadderDailyReward(id);
}
return resResult(STATUS.SUCCESS)
}
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,399 +1,400 @@
import { STATUS } from './../../../consts/statusCode';
import { HANG_UP_CONSTS, ITEM_CHANGE_REASON, MSG_SOURCE, POP_UP_SHOP_CONDITION_TYPE, REDIS_KEY } from './../../../consts';
import { TaskHero, TowerTaskRecModel, TowerTaskRecType } from './../../../db/TowerTaskRec';
import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
import { HangUpRecordModel } from './../../../db/HangUpRecord';
import { RoleModel } from './../../../db/Role';
import { TowerRecordModel, WarStatus } from './../../../db/TowerRecord';
import { Application, BackendSession } from 'pinus';
import { resResult, genCode, shouldRefresh } from '../../../pubUtils/util';
import { calcuHangUpReward, refreshTasks, treatTask, getRemainTime, getTowerStatus, getHungupRewards, getTasks, checkTaskRewards, getTowerTaskCostGold, getManyHangSpdUpCostGold, getTaskStatus, checkForbiddenChar, checkAndStartHungUp, createNewTowerRecord, getTowerRecByLv, getTowerStatusByWarId, getTowerHeroCe, getWarStatusByLv } from '../../../services/battleService';
import { addItems, getGoldObject, handleCost } from '../../../services/role/rewardService';
import { checkBattleHeroes } from '../../../services/normalBattleService';
import { gameData } from '../../../pubUtils/data';
import * as dicParam from '../../../pubUtils/dicParam';
import { HeroModel } from '../../../db/Hero';
import { vipCanSkipTower } from '../../../services/activity/monthlyTicketService';
import { pushTowerMsg } from '../../../services/sysChatService';
import { WarStar } from '../../../domain/dbGeneral';
import { ItemInter, RewardInter } from '../../../pubUtils/interface';
import { combineItems } from '../../../services/role/util';
import { checkTaskInSkipTower } from '../../../services/task/taskService';
import { Rank } from '../../../services/rankService';
import { checkPopUpCondition } from '../../../services/activity/popUpShopService';
import { isHeroHidden } from '../../../services/dataService';
export default function(app: Application) {
return new TowerBattleHandler(app);
}
export class TowerBattleHandler {
constructor(private app: Application) {
}
/**
* 获取天梯当前挑战状态
* @param session
*/
async getStatus(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'roleId serverId towerLv towerReceived');
let data = await getTowerStatus(role);
return resResult(STATUS.SUCCESS, data);
}
/**
* 重置天梯当前层的挑战记录
* @param towerLv 要重置的天梯层数
* @param session
*/
async resetLv(msg: {towerLv: number}, session: BackendSession) {
let roleId = session.get('roleId');
let { towerLv } = await RoleModel.findByRoleId(roleId);
if (msg.towerLv !== towerLv) {
return resResult(STATUS.TOWER_RESET_ERR);
}
const record = await TowerRecordModel.resetRecordByLv(roleId, towerLv);
if (!record) {
return resResult(STATUS.TOWER_NOT_FOUND);
}
return resResult(STATUS.SUCCESS, {
roleId: record.roleId,
curLv: record.lv,
heroes: record.heroes,
warStatus: record.warStatus,
speedUpCnt: record.speedUpCnt,
speedUpTime: record.speedUpTime,
hangUpTime: record.hangUpTime,
passed: record.passed
});
}
/**
* 查询当前挂机可得奖励
* @param msg
* @param session
* @returns
*/
async checkHangUpRewards(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let result = await getHungupRewards(roleId);
if(!result) {
return resResult(STATUS.TOWER_HANG_UP_NOT_START);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* 领取当前挂机可得奖励
* @param msg
* @param session
* @returns
*/
async recHangUpRewards(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let role = await RoleModel.findByRoleId(roleId);
const result = await calcuHangUpReward(role);
if(!result) {
return resResult(STATUS.TOWER_HANG_UP_NOT_START);
}
let { timeReward, endLv, endTime, deltaTime, needReceiveGoods } = result;
const goods = await addItems(roleId, roleName, sid, timeReward, ITEM_CHANGE_REASON.TOWER_HUNG_UP_REWARD);
await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime, needReceiveGoods);
return resResult(STATUS.SUCCESS, { endTime, hangUpPassTime: Math.floor((deltaTime%HANG_UP_CONSTS.UNIT_TIME)/1000), goods });
}
/**
* 加速挂机
* @param {{speedUpCnt: number}} msg 加速次数
* @param session
* @returns
*/
async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { speedUpCnt } = msg;
const curTime = new Date();
let role = await RoleModel.findByRoleId(roleId);
let { hangUpSpdUpCnt, gold, lastSpdUpTime } = role;
if (shouldRefresh(lastSpdUpTime, curTime)) {
hangUpSpdUpCnt = 0;
}
if (speedUpCnt + hangUpSpdUpCnt > dicParam.TOWER_BOOST.TOWER_BOOSTTIME) {
return resResult(STATUS.TOWER_NOT_ENOUGH_HANG_UP_TIME)
}
const calResult = await calcuHangUpReward(role, true, msg.speedUpCnt, curTime);
if(!calResult) {
return resResult(STATUS.TOWER_HANG_UP_FAILED);
}
let { timeReward, endLv, deltaTime, needReceiveGoods } = calResult;
const costGold = getManyHangSpdUpCostGold(hangUpSpdUpCnt, msg.speedUpCnt);
if(costGold > gold) {
return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
}
await handleCost(roleId, sid, [getGoldObject(costGold)], ITEM_CHANGE_REASON.TOWER_HUNG_UP_SDP_UP)
const spdUpResult = await RoleModel.hangUpSpdUp(roleId, msg.speedUpCnt, curTime);
if (!spdUpResult) {
return resResult(STATUS.TOWER_HANG_UP_FAILED);
}
const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, msg.speedUpCnt, endLv, needReceiveGoods);
const goods = await addItems(roleId, roleName, sid, timeReward, ITEM_CHANGE_REASON.TOWER_HUNG_UP_REWARD);
let nextCostGold = getManyHangSpdUpCostGold(spdUpResult.hangUpSpdUpCnt, 1);
return resResult(STATUS.SUCCESS, { goods, hangUpSpdUpCnt: dicParam.TOWER_BOOST.TOWER_BOOSTTIME - spdUpResult.hangUpSpdUpCnt, nextCostGold, hangUpPassTime: Math.floor(deltaTime/1000), rewardLv: endLv, costGold });
}
async getTasks(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let result = await getTasks(roleId);
return resResult(STATUS.SUCCESS, result);
}
async refreshTasks(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let curTime = new Date();
let { towerLv, towerTaskRefTime, towerTaskReCnt=0 } = await RoleModel.findByRoleId(roleId);
if(towerTaskReCnt >= dicParam.TOWER_SEARCH.TOWER_SEARCH_REFRESHRULE) { // 付费刷新次数
return resResult(STATUS.TOWER_REF_CNT_NOT_ENOUGH);
}
let costGold = getTowerTaskCostGold(towerTaskReCnt, towerTaskRefTime);
let {gold} = await RoleModel.findByRoleId(roleId);
if(costGold > gold) {
return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
}
// 只刷掉当前面板上没有做派遣的任务
let batchCode = genCode(8);
let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
for(let task of curTasks) {
if(task) batchCode = task.batchCode;
}
curTasks = await refreshTasks(towerLv, batchCode, roleId, roleName, curTasks);
let newRole = await RoleModel.increaseTowerRefCnt(roleId, 1);
let refRemainTime = getRemainTime(curTime);
let nextCostGold = getTowerTaskCostGold(newRole.towerTaskReCnt, newRole.towerTaskRefTime);
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), costGold, nextCostGold, refRemainTime, towerTaskReCnt: newRole.towerTaskReCnt });
}
async sendTaskHero(msg: {batchCode: string, tasks: {taskCode: string, heroes: number[]}[]}, session: BackendSession) {
let roleId = session.get('roleId');
let batchCode = msg.batchCode;
const curTime = new Date();
let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前一批的任务
if (!curTasks || curTasks.length == 0) {
return resResult(STATUS.TOWER_TASK_NOT_FOUND);
}
let usedHeroes: number[] = [], tasks: {taskCode:string, heroes: TaskHero[], completeTime: number}[] = [];
const tasksCode: string[] = [];
const taskMap = new Map<string, any>()
curTasks.forEach(task => {
let getStatusResult = getTaskStatus(task.status, task.completeTime, curTime);
if(getStatusResult.status == 1) {
for(let { seqId } of task.heroes) {
usedHeroes.push(seqId);
}
}
tasksCode.push(task.taskCode);
taskMap.set(task.taskCode, task);
batchCode = task.batchCode;
});
for (let { taskCode, heroes: seqIds } of msg.tasks) {
let curTask = taskMap.get(taskCode); // 数据库中,这个任务的数据
if(!curTask) {
return resResult(STATUS.TOWER_TASK_MISSING)
}
let dicTask = gameData.towerTask.get(curTask.taskId);
if (seqIds.length !== dicTask.actorNeeded) { // 武将数,从策划表中读取
return resResult(STATUS.TOWER_TASK_MAX_HERO);
}
let { isOK, heroes, hids } = await checkBattleHeroes(roleId, seqIds);
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
if (tasksCode.indexOf(taskCode) === -1) {
return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);
}
if (usedHeroes.length > 0) { // 是否在其他任务重使用了武将
let used = !!seqIds.find(seqId => usedHeroes.indexOf(seqId) !== -1);
if (used) {
return resResult(STATUS.TOWER_TASK_HERO_HAS_USED);
}
}
let taskHeroes = heroes.map(hero => {
return new TaskHero(hero);
});
tasks.push({ taskCode, heroes: taskHeroes, completeTime: dicTask.completeTime})
}
const recs = await TowerTaskRecModel.sendHeroes(roleId, batchCode, tasks, curTime,);
if (!recs || recs.length === 0) {
return resResult(STATUS.TOWER_TASK_SEND_ERR);
}
let role = await RoleModel.increaseTowerCnt(roleId, tasks.length)
let refRemainTime = getRemainTime(curTime);
curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
let costGold = getTowerTaskCostGold(role.towerTaskReCnt, role.towerTaskRefTime);
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), refRemainTime, nextCostGold: costGold });
}
async settleTask(msg: {batchCode: string, taskCode: string}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
const { batchCode, taskCode } = msg;
let allFlag = !taskCode;
const curTime = new Date();
let tasks: TowerTaskRecType[] = [];
if(allFlag) {
tasks = await TowerTaskRecModel.getCurTasks(roleId);
} else {
let task = await TowerTaskRecModel.getTaskByCode(roleId, taskCode);
if(task) tasks.push(task);
}
if (!tasks || tasks.length == 0) {
return resResult(STATUS.TOWER_TASK_NOT_FOUND);
}
const checkResult = checkTaskRewards(batchCode, tasks);
if (!checkResult) {
return resResult(STATUS.TOWER_TASK_CANNOT_RECEIVE);
}
const { compTasks, rewards } = checkResult;
if(compTasks.length <= 0) return resResult(STATUS.TOWER_TASK_CANNOT_RECEIVE)
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.TOWER_TASK_REWARD);
await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
let refRemainTime = getRemainTime(curTime);
let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
let role = await RoleModel.findByRoleId(roleId);
let costGold = getTowerTaskCostGold(role.towerTaskReCnt, role.towerTaskRefTime);
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), goods, refRemainTime, nextCostGold: costGold });
}
async skipTower(msg: { toLv: number }, session: BackendSession) {
const { toLv } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let sid = session.get('sid');
let role = await RoleModel.findByRoleId(roleId);
let oldTowerLv = role.towerLv;
if(toLv <= oldTowerLv) return resResult(STATUS.TOWER_CANNOT_SKIP);
let dicTower = gameData.tower.get(oldTowerLv);
if(!dicTower.canSkip) {
return resResult(STATUS.TOWER_CANNOT_SKIP);
}
// 检查战力是否足够
let towerRec = await TowerRecordModel.getRecordByLv(roleId, oldTowerLv);
let heroes = await HeroModel.findByRole(roleId, [{ field: 'ce', sortBy: -1 }], 'hid ce job', true);
let newWarStar: WarStar[] = [], resultGoods: { towerLv: number, goods: { id: number, count: number }[] }[] = [], rewards: ItemInter[] = [];
for(let lv = oldTowerLv; lv < toLv; lv++) {
let dicTower = gameData.tower.get(lv);
let warArray = dicTower?.warArray||[];
let recommendCeSum = 0, heroesCeSum = 0;
for(let warId of warArray) {
if(!getTowerStatusByWarId(warId, towerRec?.warStatus)) {
let dicWar = gameData.war.get(warId);
recommendCeSum += dicWar.recommendedPower;
heroesCeSum += getTowerHeroCe(warId, heroes, towerRec.heroes);
newWarStar.push({ id: warId, warType: dicWar.warType, star: 0, stars: [] })
}
}
if(!vipCanSkipTower(recommendCeSum, heroesCeSum, role.vipStartTime)) {
return resResult(STATUS.TOWER_SKIP_POWER_NOT_ENOUGH)
}
resultGoods.push({ towerLv: lv, goods: dicTower.reward });
rewards.push(...dicTower.reward);
}
// 更新towerRecord
let warStatus: WarStatus[] = getWarStatusByLv(toLv);
await TowerRecordModel.skipTower(roleId, role.towerLv, toLv, warStatus);
await checkAndStartHungUp(roleId, roleName, role.towerLv);
// 更新玩家表
role = await RoleModel.setTowerLv(roleId, toLv, newWarStar);
await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.TOWER_BATTLE_END);
pushTowerMsg(roleId, roleName, serverId, MSG_SOURCE.TOWER_SUC, role.towerLv - 1);
let data = await getTowerStatus(role);
// 更新redis
let r = new Rank(REDIS_KEY.TOWER_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, role.towerLv - 1, role.towerUpTime.getTime(), role);
await checkTaskInSkipTower(serverId, roleId, sid, role.towerLv);
await checkPopUpCondition(serverId, roleId, POP_UP_SHOP_CONDITION_TYPE.TOWER, { oldLv: oldTowerLv - 1, newLv: role.towerLv - 1 })
return resResult(STATUS.SUCCESS, { ...data, resultGoods });
}
/**
* 获取节点奖励
* @param session
*/
async receiveBox(msg: { id: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { id } = msg; // id为0表示一键领取
let role = await RoleModel.findByRoleId(roleId, 'towerLv towerReceived');
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let { towerLv, towerReceived = [] } = role;
let rewards: RewardInter[] = [], newReceived: number[] = [];
if(id == 0) {
for(let [ id, dicTowerGift ] of gameData.towerGift) {
if(towerLv > dicTowerGift.towerLv && towerReceived.indexOf(id) == -1) {
rewards.push(...dicTowerGift.reward);
newReceived.push(id);
}
}
if(newReceived.length <= 0) return resResult(STATUS.TOWER_BOX_NO_RECEIVE);
} else {
let dicTowerGift = gameData.towerGift.get(id);
if(!dicTowerGift) return resResult(STATUS.WRONG_PARMS);
if(towerLv <= dicTowerGift.towerLv) {
return resResult(STATUS.TOWER_LV_NOT_ENOUGH);
}
if(towerReceived.indexOf(id) != -1) {
return resResult(STATUS.TOWER_BOX_HAS_RECEIVED);
}
rewards.push(...dicTowerGift.reward);
newReceived.push(id);
}
role = await RoleModel.receiveTowerBox(roleId, newReceived);
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.RECEIVE_TOWER_BOX);
return resResult(STATUS.SUCCESS, { goods, receivedBox: newReceived });
}
}
import { STATUS } from './../../../consts/statusCode';
import { HANG_UP_CONSTS, ITEM_CHANGE_REASON, MSG_SOURCE, POP_UP_SHOP_CONDITION_TYPE, REDIS_KEY } from './../../../consts';
import { TaskHero, TowerTaskRecModel, TowerTaskRecType } from './../../../db/TowerTaskRec';
import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
import { HangUpRecordModel } from './../../../db/HangUpRecord';
import { RoleModel } from './../../../db/Role';
import { TowerRecordModel, WarStatus } from './../../../db/TowerRecord';
import { Application, BackendSession } from 'pinus';
import { resResult, genCode, shouldRefresh } from '@pubUtils/util';
import { calcuHangUpReward, refreshTasks, treatTask, getRemainTime, getTowerStatus, getHungupRewards, getTasks, checkTaskRewards, getTowerTaskCostGold, getManyHangSpdUpCostGold, getTaskStatus, checkForbiddenChar, checkAndStartHungUp, createNewTowerRecord, getTowerRecByLv, getTowerStatusByWarId, getTowerHeroCe, getWarStatusByLv } from '../../../services/battleService';
import { addItems, getGoldObject, handleCost } from '../../../services/role/rewardService';
import { checkBattleHeroes } from '../../../services/normalBattleService';
import { gameData } from '@pubUtils/data';
import * as dicParam from '@pubUtils/dicParam';
import { HeroModel } from '@db/Hero';
import { vipCanSkipTower } from '../../../services/activity/monthlyTicketService';
import { pushTowerMsg } from '../../../services/sysChatService';
import { WarStar } from '@domain/dbGeneral';
import { ItemInter, RewardInter } from '@pubUtils/interface';
import { combineItems } from '../../../services/role/util';
import { checkTaskInSkipTower } from '../../../services/task/taskService';
import { Rank } from '../../../services/rankService';
import { checkPopUpCondition } from '../../../services/activity/popUpShopService';
import { isHeroHidden } from '../../../services/dataService';
export default function(app: Application) {
return new TowerBattleHandler(app);
}
export class TowerBattleHandler {
constructor(private app: Application) {
}
/**
* 获取天梯当前挑战状态
* @param session
*/
async getStatus(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'roleId serverId towerLv towerReceived');
let data = await getTowerStatus(role);
return resResult(STATUS.SUCCESS, data);
}
/**
* 重置天梯当前层的挑战记录
* @param towerLv 要重置的天梯层数
* @param session
*/
async resetLv(msg: {towerLv: number}, session: BackendSession) {
let roleId = session.get('roleId');
let { towerLv } = await RoleModel.findByRoleId(roleId);
if (msg.towerLv !== towerLv) {
return resResult(STATUS.TOWER_RESET_ERR);
}
const record = await TowerRecordModel.resetRecordByLv(roleId, towerLv);
if (!record) {
return resResult(STATUS.TOWER_NOT_FOUND);
}
return resResult(STATUS.SUCCESS, {
roleId: record.roleId,
curLv: record.lv,
heroes: record.heroes,
warStatus: record.warStatus,
speedUpCnt: record.speedUpCnt,
speedUpTime: record.speedUpTime,
hangUpTime: record.hangUpTime,
passed: record.passed
});
}
/**
* 查询当前挂机可得奖励
* @param msg
* @param session
* @returns
*/
async checkHangUpRewards(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let result = await getHungupRewards(roleId);
if(!result) {
return resResult(STATUS.TOWER_HANG_UP_NOT_START);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* 领取当前挂机可得奖励
* @param msg
* @param session
* @returns
*/
async recHangUpRewards(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let role = await RoleModel.findByRoleId(roleId);
const result = await calcuHangUpReward(role);
if(!result) {
return resResult(STATUS.TOWER_HANG_UP_NOT_START);
}
let { timeReward, endLv, endTime, deltaTime, needReceiveGoods } = result;
const goods = await addItems(roleId, roleName, sid, timeReward, ITEM_CHANGE_REASON.TOWER_HUNG_UP_REWARD);
await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime, needReceiveGoods);
return resResult(STATUS.SUCCESS, { endTime, hangUpPassTime: Math.floor((deltaTime%HANG_UP_CONSTS.UNIT_TIME)/1000), goods });
}
/**
* 加速挂机
* @param {{speedUpCnt: number}} msg 加速次数
* @param session
* @returns
*/
async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { speedUpCnt } = msg;
const curTime = new Date();
let role = await RoleModel.findByRoleId(roleId);
let { hangUpSpdUpCnt, gold, lastSpdUpTime } = role;
if (shouldRefresh(lastSpdUpTime, curTime)) {
hangUpSpdUpCnt = 0;
}
if (speedUpCnt + hangUpSpdUpCnt > dicParam.TOWER_BOOST.TOWER_BOOSTTIME) {
return resResult(STATUS.TOWER_NOT_ENOUGH_HANG_UP_TIME)
}
const calResult = await calcuHangUpReward(role, true, msg.speedUpCnt, curTime);
if(!calResult) {
return resResult(STATUS.TOWER_HANG_UP_FAILED);
}
let { timeReward, endLv, deltaTime, needReceiveGoods } = calResult;
const costGold = getManyHangSpdUpCostGold(hangUpSpdUpCnt, msg.speedUpCnt);
if(costGold > gold) {
return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
}
await handleCost(roleId, sid, [getGoldObject(costGold)], ITEM_CHANGE_REASON.TOWER_HUNG_UP_SDP_UP)
const spdUpResult = await RoleModel.hangUpSpdUp(roleId, msg.speedUpCnt, curTime);
if (!spdUpResult) {
return resResult(STATUS.TOWER_HANG_UP_FAILED);
}
const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, msg.speedUpCnt, endLv, needReceiveGoods);
const goods = await addItems(roleId, roleName, sid, timeReward, ITEM_CHANGE_REASON.TOWER_HUNG_UP_REWARD);
let nextCostGold = getManyHangSpdUpCostGold(spdUpResult.hangUpSpdUpCnt, 1);
return resResult(STATUS.SUCCESS, { goods, hangUpSpdUpCnt: dicParam.TOWER_BOOST.TOWER_BOOSTTIME - spdUpResult.hangUpSpdUpCnt, nextCostGold, hangUpPassTime: Math.floor(deltaTime/1000), rewardLv: endLv, costGold });
}
async getTasks(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let result = await getTasks(roleId);
return resResult(STATUS.SUCCESS, result);
}
async refreshTasks(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let curTime = new Date();
let { towerLv, towerTaskRefTime, towerTaskReCnt=0 } = await RoleModel.findByRoleId(roleId);
if(towerTaskReCnt >= dicParam.TOWER_SEARCH.TOWER_SEARCH_REFRESHRULE) { // 付费刷新次数
return resResult(STATUS.TOWER_REF_CNT_NOT_ENOUGH);
}
let costGold = getTowerTaskCostGold(towerTaskReCnt, towerTaskRefTime);
let {gold} = await RoleModel.findByRoleId(roleId);
if(costGold > gold) {
return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
}
// 只刷掉当前面板上没有做派遣的任务
let batchCode = genCode(8);
let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
for(let task of curTasks) {
if(task) batchCode = task.batchCode;
}
curTasks = await refreshTasks(towerLv, batchCode, roleId, roleName, curTasks);
let newRole = await RoleModel.increaseTowerRefCnt(roleId, 1);
let refRemainTime = getRemainTime(curTime);
let nextCostGold = getTowerTaskCostGold(newRole.towerTaskReCnt, newRole.towerTaskRefTime);
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), costGold, nextCostGold, refRemainTime, towerTaskReCnt: newRole.towerTaskReCnt });
}
async sendTaskHero(msg: {batchCode: string, tasks: {taskCode: string, heroes: number[]}[]}, session: BackendSession) {
let roleId = session.get('roleId');
let batchCode = msg.batchCode;
const curTime = new Date();
let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前一批的任务
if (!curTasks || curTasks.length == 0) {
return resResult(STATUS.TOWER_TASK_NOT_FOUND);
}
let usedHeroes: number[] = [], tasks: {taskCode:string, heroes: TaskHero[], completeTime: number}[] = [];
const tasksCode: string[] = [];
const taskMap = new Map<string, any>()
curTasks.forEach(task => {
let getStatusResult = getTaskStatus(task.status, task.completeTime, curTime);
if(getStatusResult.status == 1) {
for(let { seqId } of task.heroes) {
usedHeroes.push(seqId);
}
}
tasksCode.push(task.taskCode);
taskMap.set(task.taskCode, task);
batchCode = task.batchCode;
});
for (let { taskCode, heroes: seqIds } of msg.tasks) {
let curTask = taskMap.get(taskCode); // 数据库中,这个任务的数据
if(!curTask) {
return resResult(STATUS.TOWER_TASK_MISSING)
}
let dicTask = gameData.towerTask.get(curTask.taskId);
if (seqIds.length !== dicTask.actorNeeded) { // 武将数,从策划表中读取
return resResult(STATUS.TOWER_TASK_MAX_HERO);
}
let { isOK, heroes, hids } = await checkBattleHeroes(roleId, seqIds);
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
if(isHeroHidden(...hids)) return resResult(STATUS.HERO_IS_HIDDEN);
if (tasksCode.indexOf(taskCode) === -1) {
return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);
}
if (usedHeroes.length > 0) { // 是否在其他任务重使用了武将
let used = !!seqIds.find(seqId => usedHeroes.indexOf(seqId) !== -1);
if (used) {
return resResult(STATUS.TOWER_TASK_HERO_HAS_USED);
}
}
let taskHeroes = heroes.map(hero => {
return new TaskHero(hero);
});
tasks.push({ taskCode, heroes: taskHeroes, completeTime: dicTask.completeTime})
}
const recs = await TowerTaskRecModel.sendHeroes(roleId, batchCode, tasks, curTime,);
if (!recs || recs.length === 0) {
return resResult(STATUS.TOWER_TASK_SEND_ERR);
}
let role = await RoleModel.increaseTowerCnt(roleId, tasks.length)
let refRemainTime = getRemainTime(curTime);
curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
let costGold = getTowerTaskCostGold(role.towerTaskReCnt, role.towerTaskRefTime);
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), refRemainTime, nextCostGold: costGold });
}
async settleTask(msg: {batchCode: string, taskCode: string}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
const { batchCode, taskCode } = msg;
let allFlag = !taskCode;
const curTime = new Date();
let tasks: TowerTaskRecType[] = [];
if(allFlag) {
tasks = await TowerTaskRecModel.getCurTasks(roleId);
} else {
let task = await TowerTaskRecModel.getTaskByCode(roleId, taskCode);
if(task) tasks.push(task);
}
if (!tasks || tasks.length == 0) {
return resResult(STATUS.TOWER_TASK_NOT_FOUND);
}
const checkResult = checkTaskRewards(batchCode, tasks);
if (!checkResult) {
return resResult(STATUS.TOWER_TASK_CANNOT_RECEIVE);
}
const { compTasks, rewards } = checkResult;
if(compTasks.length <= 0) return resResult(STATUS.TOWER_TASK_CANNOT_RECEIVE)
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.TOWER_TASK_REWARD);
await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
let refRemainTime = getRemainTime(curTime);
let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
let role = await RoleModel.findByRoleId(roleId);
let costGold = getTowerTaskCostGold(role.towerTaskReCnt, role.towerTaskRefTime);
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), goods, refRemainTime, nextCostGold: costGold });
}
async skipTower(msg: { toLv: number }, session: BackendSession) {
const { toLv } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let sid = session.get('sid');
let role = await RoleModel.findByRoleId(roleId);
let oldTowerLv = role.towerLv;
if(toLv <= oldTowerLv) return resResult(STATUS.TOWER_CANNOT_SKIP);
let dicTower = gameData.tower.get(oldTowerLv);
if(!dicTower.canSkip) {
return resResult(STATUS.TOWER_CANNOT_SKIP);
}
// 检查战力是否足够
let towerRec = await TowerRecordModel.getRecordByLv(roleId, oldTowerLv);
let heroes = await HeroModel.findByRole(roleId, [{ field: 'ce', sortBy: -1 }], 'hid ce job', true);
let newWarStar: WarStar[] = [], resultGoods: { towerLv: number, goods: { id: number, count: number }[] }[] = [], rewards: ItemInter[] = [];
for(let lv = oldTowerLv; lv < toLv; lv++) {
let dicTower = gameData.tower.get(lv);
let warArray = dicTower?.warArray||[];
let recommendCeSum = 0, heroesCeSum = 0;
for(let warId of warArray) {
if(!getTowerStatusByWarId(warId, towerRec?.warStatus)) {
let dicWar = gameData.war.get(warId);
recommendCeSum += dicWar.recommendedPower;
heroesCeSum += getTowerHeroCe(warId, heroes, towerRec.heroes);
newWarStar.push({ id: warId, warType: dicWar.warType, star: 0, stars: [] })
}
}
if(!vipCanSkipTower(recommendCeSum, heroesCeSum, role.vipStartTime)) {
return resResult(STATUS.TOWER_SKIP_POWER_NOT_ENOUGH)
}
resultGoods.push({ towerLv: lv, goods: dicTower.reward });
rewards.push(...dicTower.reward);
}
// 更新towerRecord
let warStatus: WarStatus[] = getWarStatusByLv(toLv);
await TowerRecordModel.skipTower(roleId, role.towerLv, toLv, warStatus);
await checkAndStartHungUp(roleId, roleName, role.towerLv);
// 更新玩家表
role = await RoleModel.setTowerLv(roleId, toLv, newWarStar);
await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.TOWER_BATTLE_END);
pushTowerMsg(roleId, roleName, serverId, MSG_SOURCE.TOWER_SUC, role.towerLv - 1);
let data = await getTowerStatus(role);
// 更新redis
let r = new Rank(REDIS_KEY.TOWER_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, role.towerLv - 1, role.towerUpTime.getTime(), role);
await checkTaskInSkipTower(serverId, roleId, sid, role.towerLv);
await checkPopUpCondition(serverId, roleId, POP_UP_SHOP_CONDITION_TYPE.TOWER, { oldLv: oldTowerLv - 1, newLv: role.towerLv - 1 })
return resResult(STATUS.SUCCESS, { ...data, resultGoods });
}
/**
* 获取节点奖励
* @param session
*/
async receiveBox(msg: { id: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { id } = msg; // id为0表示一键领取
let role = await RoleModel.findByRoleId(roleId, 'towerLv towerReceived');
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let { towerLv, towerReceived = [] } = role;
let rewards: RewardInter[] = [], newReceived: number[] = [];
if(id == 0) {
for(let [ id, dicTowerGift ] of gameData.towerGift) {
if(towerLv > dicTowerGift.towerLv && towerReceived.indexOf(id) == -1) {
rewards.push(...dicTowerGift.reward);
newReceived.push(id);
}
}
if(newReceived.length <= 0) return resResult(STATUS.TOWER_BOX_NO_RECEIVE);
} else {
let dicTowerGift = gameData.towerGift.get(id);
if(!dicTowerGift) return resResult(STATUS.WRONG_PARMS);
if(towerLv <= dicTowerGift.towerLv) {
return resResult(STATUS.TOWER_LV_NOT_ENOUGH);
}
if(towerReceived.indexOf(id) != -1) {
return resResult(STATUS.TOWER_BOX_HAS_RECEIVED);
}
rewards.push(...dicTowerGift.reward);
newReceived.push(id);
}
role = await RoleModel.receiveTowerBox(roleId, newReceived);
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.RECEIVE_TOWER_BOX);
return resResult(STATUS.SUCCESS, { goods, receivedBox: newReceived });
}
}

View File

@@ -1,218 +1,219 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { PVPConfigModel, PVPConfigType } from '../../../db/PvpConfig';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { setApiIsClose } from '../../../services/chatService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { setServerGroup } from '../../../services/serverService';
import { savePvpSeasonMemory } from '../../../services/log/memoryLogService';
import { setKvToMemory } from '../../../services/pushService';
import { getPvpTime } from '../../../services/pvpService';
import { taflush } from '../../../services/sdkService';
import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
import { errlogger } from '../../../util/logger';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new BattleRemote(app);
}
export class BattleRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
/**
* Add user into chat channel.
*
* @param {String} uid unique id for user
* @param {String} sid server id
* @param {boolean} flag channel parameter
*
*/
public async add(uid: string, sid: string, serverId: number, flag: boolean) {
let name = `server-${serverId}`;
console.log('BattleRemote add: ', name, flag);
let channel = this.channelService.getChannel(name, flag);
if (!!channel && !this.get(name, false).includes(uid)) {
if (!!channel) {
channel.add(uid, sid);
}
}
return this.get(name, flag);
}
/**
* Get user from chat channel.
*
* @param {Object} opts parameters for request
* @param {String} name channel name
* @param {boolean} flag channel parameter
* @return {Array} users uids in channel
*
*/
private get(name: string, flag: boolean) {
let users: string[] = [];
let channel = this.channelService.getChannel(name, flag);
if (!!channel) {
users = channel.getMembers();
}
for (let i = 0; i < users.length; i++) {
users[i] = users[i].split('*')[0];
}
return users;
}
/**
* Kick user out chat channel.
*
* @param {String} uid unique id for user
* @param {String} sid server id
*
*/
public async kick(uid: string, sid: string, serverId: number) {
let name = `server-${serverId}`;
let channel = this.channelService.getChannel(name, false);
// leave channel
if (!!channel) {
channel.leave(uid, sid);
}
}
/**
* 重载json资源
*/
public reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSettleSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSettleSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async getPvpTime() {
try {
return getPvpTime();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public savePvpSeasonMemory() {
try {
return savePvpSeasonMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { PVPConfigModel, PVPConfigType } from '@db/PvpConfig';
import { gameData, reloadResources } from '@pubUtils/data';
import { setApiIsClose } from '../../../services/chatService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { setServerGroup } from '../../../services/serverService';
import { savePvpSeasonMemory } from '../../../services/log/memoryLogService';
import { setKvToMemory } from '../../../services/pushService';
import { getPvpTime } from '../../../services/pvpService';
import { taflush } from '../../../services/sdkService';
import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
import { errlogger } from '../../../util/logger';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new BattleRemote(app);
}
export class BattleRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
/**
* Add user into chat channel.
*
* @param {String} uid unique id for user
* @param {String} sid server id
* @param {boolean} flag channel parameter
*
*/
public async add(uid: string, sid: string, serverId: number, flag: boolean) {
let name = `server-${serverId}`;
console.log('BattleRemote add: ', name, flag);
let channel = this.channelService.getChannel(name, flag);
if (!!channel && !this.get(name, false).includes(uid)) {
if (!!channel) {
channel.add(uid, sid);
}
}
return this.get(name, flag);
}
/**
* Get user from chat channel.
*
* @param {Object} opts parameters for request
* @param {String} name channel name
* @param {boolean} flag channel parameter
* @return {Array} users uids in channel
*
*/
private get(name: string, flag: boolean) {
let users: string[] = [];
let channel = this.channelService.getChannel(name, flag);
if (!!channel) {
users = channel.getMembers();
}
for (let i = 0; i < users.length; i++) {
users[i] = users[i].split('*')[0];
}
return users;
}
/**
* Kick user out chat channel.
*
* @param {String} uid unique id for user
* @param {String} sid server id
*
*/
public async kick(uid: string, sid: string, serverId: number) {
let name = `server-${serverId}`;
let channel = this.channelService.getChannel(name, false);
// leave channel
if (!!channel) {
channel.leave(uid, sid);
}
}
/**
* 重载json资源
*/
public reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSettleSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSettleSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async getPvpTime() {
try {
return getPvpTime();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public savePvpSeasonMemory() {
try {
return savePvpSeasonMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,229 +1,230 @@
import { CHANNEL_PREFIX, MSG_SOURCE, getChannelType } from './../../../consts/constModules/chatConst';
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { DEFAULT_MSG_PER_PAGE, SDK_PUSH_MSG_TYPE, SDK_PUSH_TARGET_TYPE, STATUS, TASK_TYPE } from '../../../consts';
import { createAccuseData, createGroupMsg, createPrivateMsg, getPrivateMessages, pushGroupMsgToRoom, pushMsgToRole, updatePrivateMsgReadInfo, recentPrivateChatInfos, recentWorldMsgs, recentSysMsgs, recentGuildMsgs, updatePrivateMsgIsTop, delPrivateMsg, recentServerGroupMsgs, recentLeagueMsgs } from '../../../services/chatService';
import { getSimpleRoleInfo } from '../../../services/roleService';
import { checkTask } from '../../../services/task/taskService';
import { RoleModel } from '../../../db/Role';
import { getFriendRelationType } from '../../../services/friendService';
import { GVGLeagueModel } from '../../../db/GVGLeague';
import { getAllGroupOfServer } from '../../../services/serverService';
import { getGuildCodeString } from '../../../services/gvg/gvgRecService';
import { GroupMessageType } from '../../../db/GroupMessage';
import { pushMsg37 } from '../../../services/sdkService';
import { gameData } from '../../../pubUtils/data';
import { pushClientMsg } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new ChatHandler(app);
}
export class ChatHandler {
constructor(private app: Application) {
}
/**
* @description 群聊发送接口
* @param {{ channel: string, type: number, content: string, targetRoleId: string, targetMsgCode: string }} msg
* @param {BackendSession} session
* @memberof ChatHandler
*/
async sendGroupMessage(msg: { channel: string, type: number, content: string, targetRoleId: string, targetMsgCode: string }, session: BackendSession) {
const { channel, type, content, targetRoleId, targetMsgCode } = msg;
if (channel === CHANNEL_PREFIX.SYS) return resResult(STATUS.SYS_CHANNEL_AUTH_NOT_ENOUGH);
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let channelIds: (string|number)[] = [], otherInfo = '';
if (channel === CHANNEL_PREFIX.WORLD) channelIds.push(serverId);
if (channel === CHANNEL_PREFIX.GUILD) channelIds.push(guildCode);
if (channel === CHANNEL_PREFIX.GVG) {
let groupIds = await getAllGroupOfServer(serverId);
groupIds.forEach(groupId => channelIds.push(groupId));
otherInfo = genCode(10);
}
if (channel == CHANNEL_PREFIX.LEAGUE) {
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_NOT_JOIN_LEAGUE);
channelIds.push(myLeague.leagueCode);
otherInfo = getGuildCodeString(myLeague);
}
let msgData: GroupMessageType;
for(let channelId of channelIds) {
msgData = await createGroupMsg(roleId, roleName, channel, `${channelId}`, type, MSG_SOURCE.ROLE_SEND_TEXT, content, targetRoleId, targetMsgCode, otherInfo);
if (!msgData) return resResult(STATUS.WRONG_PARMS);
await pushGroupMsgToRoom(msgData);
}
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.CHAT, { chatType: getChannelType(channel) });
return resResult(STATUS.SUCCESS, msgData);
}
/**
* @description 私聊发送接口
* @param {{ type: number, content: string, targetRoleId: string, targetMsgCode: string }} msg
* @param {BackendSession} session
* @memberof ChatHandler
*/
async sendPrivateMessage(msg: { type: number, content: string, targetRoleId: string, targetMsgCode: string }, session: BackendSession) {
const { type, content, targetRoleId, targetMsgCode } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const roleName = session.get('roleName');
const sid = session.get('sid');
let relation = await getFriendRelationType(roleId, targetRoleId);
const msgData = await createPrivateMsg(roleId, roleName, type, MSG_SOURCE.ROLE_SEND_TEXT, content, targetRoleId, targetMsgCode, relation);
await pushMsgToRole(msgData);
if (!msgData) return resResult(STATUS.WRONG_PARMS);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.CHAT, { chatType: getChannelType('private') });
return resResult(STATUS.SUCCESS, msgData);
}
/**
* @description 获取初始聊天消息,数据和登录时返回的一致
* @param {{}} msg
* @memberof ChatHandler
*/
async getInitMessage(msg: {}, session: BackendSession) {
}
/**
* @description 获取最近私聊对象列表
* @param {{}} msg
* @param session
*/
async getRecentPrivateChats(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const recentPrivateChats = await recentPrivateChatInfos(roleId, roleName) || [];
return resResult(STATUS.SUCCESS, {
recentPrivateChats
});
}
/**
* @description 获取群组聊天记录
* @param {{}} msg
* @param session
*/
async getGroupMessages(msg: {}, session: BackendSession) {
const serverId: number = session.get('serverId');
const guildCode: string = session.get('guildCode');
const worldMsgs = await recentWorldMsgs(serverId);
const sysMsgs = await recentSysMsgs(serverId);
const guildMsgs = await recentGuildMsgs(guildCode);
const gvgMsgs = await recentServerGroupMsgs(serverId);
const leagueMsgs = await recentLeagueMsgs(guildCode);
return resResult(STATUS.SUCCESS, { worldMsgs, sysMsgs, guildMsgs, gvgMsgs, leagueMsgs })
}
/**
* @description 获取私聊历史消息
* @param {{targetRoleId: string, fromSeqId: number, count: number}} msg 聊天对象;聊天消息的顺序 id不传为从最新开始count 为消息条数
* @memberof ChatHandler
*/
async getPrivateMessage(msg: { targetRoleId: string, fromSeqId: number, count: number }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId, fromSeqId = Infinity, count = DEFAULT_MSG_PER_PAGE } = msg;
const msgs = await getPrivateMessages(roleId, targetRoleId, fromSeqId, count);
const targetRoleInfo = await getSimpleRoleInfo(targetRoleId);
return resResult(STATUS.SUCCESS, { targetRoleId, msgs, targetRoleInfo });
}
/**
* @description 查看私聊,主要用于更新最后查看时间和未读消息数
* @param {{ targetRoleId: string }} msg
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async readPrivateMessage(msg: { targetRoleId: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId } = msg;
const result = await updatePrivateMsgReadInfo(roleId, targetRoleId);
if (!result) {
return resResult(STATUS.UPDATE_PRIVATE_MSG_READ_TIME_ERR);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 设置置顶
* @param {{ targetRoleId: string, isTop: boolean }} msg
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async setPrivateMessageTop(msg: { targetRoleId: string, isTop: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId, isTop } = msg;
const result = await updatePrivateMsgIsTop(roleId, targetRoleId, isTop);
if (!result) {
return resResult(STATUS.SET_PRIVATE_MSG_TOP_ERR);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 删除私聊
* @param {{ targetRoleId: string }} msg
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async delPrivateMessage(msg: { targetRoleId: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId } = msg;
const result = await delPrivateMsg(roleId, targetRoleId);
if (!result) {
return resResult(STATUS.DEL_PRIVATE_MSG_ERR);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 举报玩家的消息
* @param {{targetRoleId: string, targetMsgCode: string; reason: number}} msg 被举报玩家的 Id被举报的消息编号举报原因
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async accuse(msg: { targetRoleId: string, targetMsgCode: string; reason: number }, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const { targetRoleId, targetMsgCode, reason } = msg;
let targetRole = await RoleModel.findByRoleId(targetRoleId);
if(!targetRoleId) return resResult(STATUS.ROLE_NOT_FOUND);
const accuseRec = await createAccuseData(roleId, roleName, targetRoleId, targetRole.roleName, targetMsgCode, reason);
if (!accuseRec) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, accuseRec);
}
// 客户端推送消息
async debugPushMessage(msg: { uid: number }, session: BackendSession) {
let dic = gameData.dicPushMessage.get(SDK_PUSH_MSG_TYPE.GUILD_ACTIVITY_START);
if(!dic) return resResult(STATUS.WRONG_PARMS);
let result = await pushMsg37(Date.now().toString(), dic, SDK_PUSH_TARGET_TYPE.SINGLE, `${msg.uid}`);
// await pushClientMsg(SDK_PUSH_MSG_TYPE.AFK_ATTENTION);
return resResult(STATUS.SUCCESS, result);
}
}
import { CHANNEL_PREFIX, MSG_SOURCE, getChannelType } from './../../../consts/constModules/chatConst';
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '@pubUtils/util';
import { DEFAULT_MSG_PER_PAGE, SDK_PUSH_MSG_TYPE, SDK_PUSH_TARGET_TYPE, STATUS, TASK_TYPE } from '../../../consts';
import { createAccuseData, createGroupMsg, createPrivateMsg, getPrivateMessages, pushGroupMsgToRoom, pushMsgToRole, updatePrivateMsgReadInfo, recentPrivateChatInfos, recentWorldMsgs, recentSysMsgs, recentGuildMsgs, updatePrivateMsgIsTop, delPrivateMsg, recentServerGroupMsgs, recentLeagueMsgs } from '../../../services/chatService';
import { getSimpleRoleInfo } from '../../../services/roleService';
import { checkTask } from '../../../services/task/taskService';
import { RoleModel } from '@db/Role';
import { getFriendRelationType } from '../../../services/friendService';
import { GVGLeagueModel } from '@db/GVGLeague';
import { getAllGroupOfServer } from '../../../services/serverService';
import { getGuildCodeString } from '../../../services/gvg/gvgRecService';
import { GroupMessageType } from '@db/GroupMessage';
import { pushMsg37 } from '../../../services/sdkService';
import { gameData } from '@pubUtils/data';
import { pushClientMsg } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new ChatHandler(app);
}
export class ChatHandler {
constructor(private app: Application) {
}
/**
* @description 群聊发送接口
* @param {{ channel: string, type: number, content: string, targetRoleId: string, targetMsgCode: string }} msg
* @param {BackendSession} session
* @memberof ChatHandler
*/
async sendGroupMessage(msg: { channel: string, type: number, content: string, targetRoleId: string, targetMsgCode: string }, session: BackendSession) {
const { channel, type, content, targetRoleId, targetMsgCode } = msg;
if (channel === CHANNEL_PREFIX.SYS) return resResult(STATUS.SYS_CHANNEL_AUTH_NOT_ENOUGH);
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let channelIds: (string|number)[] = [], otherInfo = '';
if (channel === CHANNEL_PREFIX.WORLD) channelIds.push(serverId);
if (channel === CHANNEL_PREFIX.GUILD) channelIds.push(guildCode);
if (channel === CHANNEL_PREFIX.GVG) {
let groupIds = await getAllGroupOfServer(serverId);
groupIds.forEach(groupId => channelIds.push(groupId));
otherInfo = genCode(10);
}
if (channel == CHANNEL_PREFIX.LEAGUE) {
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_NOT_JOIN_LEAGUE);
channelIds.push(myLeague.leagueCode);
otherInfo = getGuildCodeString(myLeague);
}
let msgData: GroupMessageType;
for(let channelId of channelIds) {
msgData = await createGroupMsg(roleId, roleName, channel, `${channelId}`, type, MSG_SOURCE.ROLE_SEND_TEXT, content, targetRoleId, targetMsgCode, otherInfo);
if (!msgData) return resResult(STATUS.WRONG_PARMS);
await pushGroupMsgToRoom(msgData);
}
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.CHAT, { chatType: getChannelType(channel) });
return resResult(STATUS.SUCCESS, msgData);
}
/**
* @description 私聊发送接口
* @param {{ type: number, content: string, targetRoleId: string, targetMsgCode: string }} msg
* @param {BackendSession} session
* @memberof ChatHandler
*/
async sendPrivateMessage(msg: { type: number, content: string, targetRoleId: string, targetMsgCode: string }, session: BackendSession) {
const { type, content, targetRoleId, targetMsgCode } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const roleName = session.get('roleName');
const sid = session.get('sid');
let relation = await getFriendRelationType(roleId, targetRoleId);
const msgData = await createPrivateMsg(roleId, roleName, type, MSG_SOURCE.ROLE_SEND_TEXT, content, targetRoleId, targetMsgCode, relation);
await pushMsgToRole(msgData);
if (!msgData) return resResult(STATUS.WRONG_PARMS);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.CHAT, { chatType: getChannelType('private') });
return resResult(STATUS.SUCCESS, msgData);
}
/**
* @description 获取初始聊天消息,数据和登录时返回的一致
* @param {{}} msg
* @memberof ChatHandler
*/
async getInitMessage(msg: {}, session: BackendSession) {
}
/**
* @description 获取最近私聊对象列表
* @param {{}} msg
* @param session
*/
async getRecentPrivateChats(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const recentPrivateChats = await recentPrivateChatInfos(roleId, roleName) || [];
return resResult(STATUS.SUCCESS, {
recentPrivateChats
});
}
/**
* @description 获取群组聊天记录
* @param {{}} msg
* @param session
*/
async getGroupMessages(msg: {}, session: BackendSession) {
const serverId: number = session.get('serverId');
const guildCode: string = session.get('guildCode');
const worldMsgs = await recentWorldMsgs(serverId);
const sysMsgs = await recentSysMsgs(serverId);
const guildMsgs = await recentGuildMsgs(guildCode);
const gvgMsgs = await recentServerGroupMsgs(serverId);
const leagueMsgs = await recentLeagueMsgs(guildCode);
return resResult(STATUS.SUCCESS, { worldMsgs, sysMsgs, guildMsgs, gvgMsgs, leagueMsgs })
}
/**
* @description 获取私聊历史消息
* @param {{targetRoleId: string, fromSeqId: number, count: number}} msg 聊天对象;聊天消息的顺序 id不传为从最新开始count 为消息条数
* @memberof ChatHandler
*/
async getPrivateMessage(msg: { targetRoleId: string, fromSeqId: number, count: number }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId, fromSeqId = Infinity, count = DEFAULT_MSG_PER_PAGE } = msg;
const msgs = await getPrivateMessages(roleId, targetRoleId, fromSeqId, count);
const targetRoleInfo = await getSimpleRoleInfo(targetRoleId);
return resResult(STATUS.SUCCESS, { targetRoleId, msgs, targetRoleInfo });
}
/**
* @description 查看私聊,主要用于更新最后查看时间和未读消息数
* @param {{ targetRoleId: string }} msg
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async readPrivateMessage(msg: { targetRoleId: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId } = msg;
const result = await updatePrivateMsgReadInfo(roleId, targetRoleId);
if (!result) {
return resResult(STATUS.UPDATE_PRIVATE_MSG_READ_TIME_ERR);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 设置置顶
* @param {{ targetRoleId: string, isTop: boolean }} msg
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async setPrivateMessageTop(msg: { targetRoleId: string, isTop: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId, isTop } = msg;
const result = await updatePrivateMsgIsTop(roleId, targetRoleId, isTop);
if (!result) {
return resResult(STATUS.SET_PRIVATE_MSG_TOP_ERR);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 删除私聊
* @param {{ targetRoleId: string }} msg
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async delPrivateMessage(msg: { targetRoleId: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { targetRoleId } = msg;
const result = await delPrivateMsg(roleId, targetRoleId);
if (!result) {
return resResult(STATUS.DEL_PRIVATE_MSG_ERR);
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 举报玩家的消息
* @param {{targetRoleId: string, targetMsgCode: string; reason: number}} msg 被举报玩家的 Id被举报的消息编号举报原因
* @param {BackendSession} session
* @returns
* @memberof ChatHandler
*/
async accuse(msg: { targetRoleId: string, targetMsgCode: string; reason: number }, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const { targetRoleId, targetMsgCode, reason } = msg;
let targetRole = await RoleModel.findByRoleId(targetRoleId);
if(!targetRoleId) return resResult(STATUS.ROLE_NOT_FOUND);
const accuseRec = await createAccuseData(roleId, roleName, targetRoleId, targetRole.roleName, targetMsgCode, reason);
if (!accuseRec) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, accuseRec);
}
// 客户端推送消息
async debugPushMessage(msg: { uid: number }, session: BackendSession) {
let dic = gameData.dicPushMessage.get(SDK_PUSH_MSG_TYPE.GUILD_ACTIVITY_START);
if(!dic) return resResult(STATUS.WRONG_PARMS);
let result = await pushMsg37(Date.now().toString(), dic, SDK_PUSH_TARGET_TYPE.SINGLE, `${msg.uid}`);
// await pushClientMsg(SDK_PUSH_MSG_TYPE.AFK_ATTENTION);
return resResult(STATUS.SUCCESS, result);
}
}

View File

@@ -1,211 +1,212 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { _checkFilterWords, taflush } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { errlogger } from '../../../util/logger';
import { addUserToChannel, sendMessageToChannel, sendMessgeToChannelByBatch, setKvToMemory } from '../../../services/pushService';
import { setApiIsClose } from '../../../services/chatService';
import { setServerGroup } from '../../../services/serverService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ChatRemote(app);
}
// rpc 定义挪到单独的定义文件(user.rpc.define.ts)。解决ts-node 有可能找不到定义的问题。
// 你也可以用其它方法解决,或者没有遇到过这个问题的话,定义还是可以放在这里。
// UserRpc的命名空间自动合并
// declare global {
// interface UserRpc {
// chat: {
// chatRemote: RemoterClass<FrontendSession, ChatRemote>;
// };
// }
// }
export class ChatRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
// getTire();
}
private channelService: ChannelService;
/**
* @description 添加用户到频道
* @param {string} channelName 频道名
* @param {string} roleId 要添加的用户名
* @param {string} sid 用户连接的前端服务器名
* @memberof ChatRemote
*/
public async addChannel(channelName: string, roleId: string, sid: string) {
try {
let channel = this.channelService.getChannel(channelName, true);
if (!channel) return;
addUserToChannel(channel, roleId, sid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* @description 从频道中删除用户
* @param {string} channelName
* @param {string} roleId
* @param {string} sid
* @memberof ChatRemote
*/
public async leaveChannel(channelName: string, roleId: string, sid: string) {
try {
let channel = this.channelService.getChannel(channelName, false);
// leave channel
if (!channel) return;
channel.leave(roleId, sid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 向频道推送消息
* @param roomId 房间号
* @param path 推送地址
* @param data 推送数据
* @returns
*/
public async pushMessage(roomId: string, path: string, data: any, isBatch = false) {
try {
let channel = this.channelService.getChannel(roomId, false);
if (!channel) return;
if(isBatch) { // 分批推送
sendMessgeToChannelByBatch(channel, path, data);
} else {
sendMessageToChannel(channel, path, data);
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async deleteChannel(roomId: string) {
try {
let channel = this.channelService.getChannel(roomId, false);
if (!channel) return;
channel.destroy();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async checkFilterWords(word: string) {
try {
return await _checkFilterWords(word);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '@pubUtils/data';
import { _checkFilterWords, taflush } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { errlogger } from '../../../util/logger';
import { addUserToChannel, sendMessageToChannel, sendMessgeToChannelByBatch, setKvToMemory } from '../../../services/pushService';
import { setApiIsClose } from '../../../services/chatService';
import { setServerGroup } from '../../../services/serverService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ChatRemote(app);
}
// rpc 定义挪到单独的定义文件(user.rpc.define.ts)。解决ts-node 有可能找不到定义的问题。
// 你也可以用其它方法解决,或者没有遇到过这个问题的话,定义还是可以放在这里。
// UserRpc的命名空间自动合并
// declare global {
// interface UserRpc {
// chat: {
// chatRemote: RemoterClass<FrontendSession, ChatRemote>;
// };
// }
// }
export class ChatRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
// getTire();
}
private channelService: ChannelService;
/**
* @description 添加用户到频道
* @param {string} channelName 频道名
* @param {string} roleId 要添加的用户名
* @param {string} sid 用户连接的前端服务器名
* @memberof ChatRemote
*/
public async addChannel(channelName: string, roleId: string, sid: string) {
try {
let channel = this.channelService.getChannel(channelName, true);
if (!channel) return;
addUserToChannel(channel, roleId, sid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* @description 从频道中删除用户
* @param {string} channelName
* @param {string} roleId
* @param {string} sid
* @memberof ChatRemote
*/
public async leaveChannel(channelName: string, roleId: string, sid: string) {
try {
let channel = this.channelService.getChannel(channelName, false);
// leave channel
if (!channel) return;
channel.leave(roleId, sid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 向频道推送消息
* @param roomId 房间号
* @param path 推送地址
* @param data 推送数据
* @returns
*/
public async pushMessage(roomId: string, path: string, data: any, isBatch = false) {
try {
let channel = this.channelService.getChannel(roomId, false);
if (!channel) return;
if(isBatch) { // 分批推送
sendMessgeToChannelByBatch(channel, path, data);
} else {
sendMessageToChannel(channel, path, data);
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async deleteChannel(roomId: string) {
try {
let channel = this.channelService.getChannel(roomId, false);
if (!channel) return;
channel.destroy();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async checkFilterWords(word: string) {
try {
return await _checkFilterWords(word);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,145 +1,146 @@
import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, pinus, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { handleComBtlProgress, _addToSearchingTeams } from '../../../services/battle/comBattleService';
import { MemComBtlTeam } from '../../../domain/battleField/ComBattleTeamField';
import { errlogger } from '../../../util/logger';
import { saveComBattleMemory } from '../../../services/log/memoryLogService';
import { setApiIsClose } from '../../../services/chatService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import { setKvToMemory } from '../../../services/pushService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { gameData, reloadResources } from '../../../pubUtils/data';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ComBattleRemote(app);
}
export class ComBattleRemote {
bossHp = 10000;
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
public async checkMyTeam(roleId: string ) {
try {
let teamMap: Map<string, MemComBtlTeam> = this.app.get('teamMap');
let hasMyTeam = false;
for(let [,team] of teamMap) {
if(team.roleIds.indexOf(roleId) > -1) {
hasMyTeam = true; break;
}
}
return hasMyTeam
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async addToSearchingTeams(teamCode: string, roleId: string, sid: string) {
try {
await _addToSearchingTeams(teamCode, roleId, sid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public saveComBattleMemory() {
try {
return saveComBattleMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, pinus, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { handleComBtlProgress, _addToSearchingTeams } from '../../../services/battle/comBattleService';
import { MemComBtlTeam } from '@domain/battleField/ComBattleTeamField';
import { errlogger } from '../../../util/logger';
import { saveComBattleMemory } from '../../../services/log/memoryLogService';
import { setApiIsClose } from '../../../services/chatService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import { setKvToMemory } from '../../../services/pushService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { gameData, reloadResources } from '@pubUtils/data';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ComBattleRemote(app);
}
export class ComBattleRemote {
bossHp = 10000;
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
public async checkMyTeam(roleId: string ) {
try {
let teamMap: Map<string, MemComBtlTeam> = this.app.get('teamMap');
let hasMyTeam = false;
for(let [,team] of teamMap) {
if(team.roleIds.indexOf(roleId) > -1) {
hasMyTeam = true; break;
}
}
return hasMyTeam
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async addToSearchingTeams(teamCode: string, roleId: string, sid: string) {
try {
await _addToSearchingTeams(teamCode, roleId, sid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public saveComBattleMemory() {
try {
return saveComBattleMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,21 +1,21 @@
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback, pinus, FrontendSession} from "pinus";
// import { checkEvent } from '../../../services/eventSercive';
import { refresh } from '../../../services/refreshService';
import { checkPrivateChat, checkGuildChat, checkOtherChat, checkRoleName, checkGuildName } from "../../../services/sdkService";
import { resResult, genCode } from "../../../pubUtils/util";
import { checkWhiteList, MsgEncrypt } from "../../../pubUtils/sysUtil";
import { BLOCK_TYPE, CHANNEL_PREFIX, MSG_TYPE, PUSH_ROUTE, STATUS } from "../../../consts";
import { nowSeconds } from "../../../pubUtils/timeUtil";
import { getServerMainten } from "../../../services/gmService";
import { errlogger, infologger } from "../../../util/logger";
import { gameData } from "../../../pubUtils/data";
import { sendMessageToUser } from "../../../services/pushService";
import { isCheckWord, isSkipEncode } from "../../../pubUtils/sdkUtil";
import { isDevelopEnv } from "../../../services/utilService";
import { refresh } from "@pubUtils/refreshService";
import { checkPrivateChat, checkGuildChat, checkOtherChat, checkRoleName, checkGuildName } from "@pubUtils/sdkService";
import { resResult, genCode } from "@pubUtils/util";
import { checkWhiteList, MsgEncrypt } from "@pubUtils/sysUtil";
import { BLOCK_TYPE, CHANNEL_PREFIX, MSG_TYPE, PUSH_ROUTE, STATUS } from "@consts";
import { nowSeconds } from "@pubUtils/timeUtil";
import { getServerMainten } from "@pubUtils/gmService";
import { errlogger, infologger } from "@pubUtils/logger";
import { gameData } from "@pubUtils/data";
import { sendMessageToUser } from "@pubUtils/pushService";
import { isCheckWord, isSkipEncode } from "@pubUtils/sdkUtil";
import { isDevelopEnv } from "@pubUtils/utilService";
import { isNumber } from "underscore";
import { getServerCreateTime, redisClient } from "../../../services/redisService";
import { checkRouteParam } from "../../../services/checkParam";
import { isApiClose } from "../../../services/chatService";
import { getServerCreateTime, redisClient } from "@pubUtils/redisService";
import { checkRouteParam } from "@pubUtils/checkParam";
import { isApiClose } from "@pubUtils/chatService";
export function globalFilter(app: Application) {
return new Filter(app);
@@ -29,13 +29,12 @@ class Filter {
this.app = app;
}
public async before (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
public async before (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const roleId: string = session.get('roleId');
const uid: number = session.get('userid');
const ip: string = session.get('ip');
// console.log('*********** global before ip', ip)
const version: string = session.get('version');
const isNewUser: boolean = session.get('isNewUser');
let guildCode = session.get('guildCode');
@@ -46,172 +45,293 @@ class Filter {
if(!this.checkPassEncrypt(routeRecord.route)) {
msg = this.decryptMsg(msg, session);
if(!msg) return next(new Error('globalFilter'), resResult(STATUS.WRONG_PARMS, { route: routeRecord.route }));
if(!this.checkTimeStamp(msg)) return next(new Error('globalFilter'), resResult(STATUS.TIMESTAMP_ERR, { route: routeRecord.route }));
if(!this.checkDuplicateAccess(msg)) return next(new Error('globalFilter'), resResult(STATUS.DUPLICATE_ACCESS, { route: routeRecord.route }))
}
msg = this.setMsg(msg, { logCode });
// 访问频率控制
if(!this.checkFrequency(routeRecord.route, msg, roleId)) {
return next(new Error('globalFilter'), resResult(STATUS.ACCESS_BUSY, { route: routeRecord.route }));
}
if(!this.checkFunction(routeRecord.route, msg)) {
return next(new Error('globalFilter'), resResult(STATUS.FUNCTION_CLOSE, { route: routeRecord.route }));
// @ts-ignore
if(!this.checkTimeStamp(msg)) return next(new Error('globalFilter'), resResult(STATUS.TIMESTAMP_ERR, { route: routeRecord.route }));
}
if(!checkRouteParam(routeRecord.route, msg)) {
return next(new Error('globalFilter'), resResult(STATUS.WRONG_PARMS, { route: routeRecord.route }));
// @ts-ignore
if (isApiClose(routeRecord.route)) {
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.API_CLOSE, { route: routeRecord.route }));
}
// 玩家屏蔽
if(blockType == BLOCK_TYPE.BLOCK) return next(new Error('globalFilter'), resResult(STATUS.BLOCKED, { route: routeRecord.route }));
if(blockType == BLOCK_TYPE.BAN && this.checkBanRoute(routeRecord.route)) {
return next(new Error('globalFilter'), resResult(STATUS.BANNED, { route: routeRecord.route }));
}
session.push('teamCode', () => {});
if(isCheckWord(isDevelopEnv())) {
let hasBlockWords = await this.checkHasBlockWord(routeRecord.route, msg, roleId, serverId, guildCode);
if(hasBlockWords) return next(new Error('globalFilter'), resResult(STATUS.BLOCK_WORDS, { route: routeRecord.route }));
}
if(routeRecord.route == 'guild.guildHandler.createGuild') {
let guildCode = genCode(6);
msg.guildCode = guildCode;
}
if(routeRecord.route != 'connector.entryHandler.enter' && await this.checkMainten(serverId, sid, ip, uid, isNewUser)) {
sendMessageToUser(roleId, PUSH_ROUTE.SERVER_MAINTENANCE, resResult(STATUS.SERVER_MAINTENANCE), sid);
if(await this.checkMainten(serverId, sid, ip, uid, isNewUser)) {
const mainten = getServerMainten(serverId);
return next(new Error('globalFilter'), resResult(STATUS.SERVER_MAINTENANCE, { route: routeRecord.route, curVersion: version, minVersion: mainten.version }));
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.SERVER_MAINTAIN, {
route: routeRecord.route,
startTime: mainten.startTime,
endTime: mainten.endTime
}));
}
next(null);
};
public async after (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
//刷新
await refresh(session);
infologger.debug('global after', msg && msg.logCode, routeRecord.route, msg && JSON.stringify(msg), resp && JSON.stringify(resp), session && session.get('roleId'));
if(!this.checkPassEncrypt(routeRecord.route)) {
let data = this.encryptMsg(resp, session);
if(!data) return next(new Error('response data err'));
resp = this.setResp(resp, data);
}
next(null);
};
// 检查调用频率
private checkFrequency (route: string, msg: any, roleId: string) {
let protect = gameData.serverConst.PROTECT_API.find(cur => {
if(cur.route == route) {
let paramOK = true;
for(let key in cur.param) {
if(msg[key] != cur.param[key]) {
paramOK = false; break;
}
// @ts-ignore
if(!isDevelopEnv(this.app.get('env'))) {
if(!this.checkPassEncrypt(routeRecord.route)) {
if(!this.checkSign(routeRecord.route, msg, session)) {
infologger.error('checkSign false', routeRecord.route, msg, session.uid);
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.SIGN_ERROR, { route: routeRecord.route }));
}
if(paramOK) return true;
}
return false;
});
if(!protect) {
return true;
}
let keyOfRouteWithUser = `${protect.id}_${roleId}`;
if(this.accessTime && this.accessTime.has(keyOfRouteWithUser)) {
console.log(this.accessTime.get(keyOfRouteWithUser) - Date.now());
if(Date.now() - this.accessTime.get(keyOfRouteWithUser) < protect.interval) {
errlogger.info(`${keyOfRouteWithUser} 间隔时间小于${protect.interval}ms${Date.now() - this.accessTime.get(keyOfRouteWithUser)}`);
return false;
}
}
if(!this.accessTime) this.accessTime = new Map<string, number>();
this.accessTime.set(keyOfRouteWithUser, Date.now());
return true;
}
// 检查该接口是否关闭
private checkFunction (route: string, msg: any) {
if(isApiClose()) {
let isClose = gameData.serverConst.CLOSE_APIS.find(cur => {
if(cur.route == route) {
if(cur.param == null) return true;
for(let key in cur.param) {
if(cur.param[key] == true && msg[key] != undefined) return true;
if(cur.param[key] && msg[key] == cur.param[key]) return true;
}
}
return false;
});
return !isClose
if(roleId) {
// @ts-ignore
if(blockType && blockType === BLOCK_TYPE.ROLE) {
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.ROLE_BLOCKED, { route: routeRecord.route }));
}
}
return true;
}
// 这个接口是否需要加密解密
private checkPassEncrypt (route: string) {
return isSkipEncode(isDevelopEnv()) || route.startsWith('gm.') || route == 'connector.entryHandler.gmEnter' || route == 'gate.gateHandler.queryEntry';
}
// 解密接口
private decryptMsg (msg: any, session: FrontendOrBackendSession) {
let msgEncrypt = new MsgEncrypt({ encodeK: msg?.k, encodeV: msg?.v });
let { aesKey, aesIV } = msgEncrypt.getKv();
msg = this.setMsg(msg, msgEncrypt.decryptMsg(msg?.data));
if(!msg) return false;
session.set('k', aesKey);
session.set('v', aesIV);
session.push('k', () => {});
session.push('v', () => {});
return msg
}
// 解密接口
private encryptMsg (resp: any, session: FrontendOrBackendSession) {
let msgEncrypt = new MsgEncrypt({ k: session.get('k'), v: session.get('v')});
let data = msgEncrypt.encryptMsg(resp);
return data;
if(await this.checkDuplicateAccess(msg)) {
infologger.error('checkDuplicateAccess false', routeRecord.route, msg);
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.DUPLICATE_ACCESS, { route: routeRecord.route }));
}
if(routeRecord.route.indexOf('Handler.') != -1) {
if (!checkRouteParam(msg, routeRecord.route)) {
infologger.error('checkRouteParam false', routeRecord.route, msg);
return next(new Error('globalFilter'), resResult(STATUS.WRONG_PARMS, { route: routeRecord.route }));
}
}
if(msg.body) {
msg = msg.body;
}
if(!this.checkBlackList(roleId, serverId)) {
infologger.error('checkBlackList true', roleId, serverId);
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.IN_BLACK_LIST, { route: routeRecord.route }));
}
if(await this.checkHasBlockWord(routeRecord.route, msg, roleId, serverId, guildCode)) {
infologger.error('checkHasBlockWord true', roleId, serverId);
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.HAS_BLOCK_WORD, { route: routeRecord.route }));
}
if(routeRecord.route.indexOf('battle.') != -1) {
// @ts-ignore
if(!this.checkVersion(routeRecord.route, version)) {
// @ts-ignore
return next(new Error('globalFilter'), resResult(STATUS.VERSION_TOO_LOW, { route: routeRecord.route, version: version }));
}
}
const beginTime = Date.now();
this.accessTime.set(`${roleId}_${routeRecord.route}`, beginTime);
// @ts-ignore
next();
}
// 传入的msg的修改
private setMsg (msg:any, targetObj: any) {
if(!msg || !targetObj || typeof targetObj != 'object') {
return false;
}
delete msg.k;
delete msg.v;
if(typeof msg.data == 'string') delete msg.data;
for(let key in targetObj) {
if(targetObj.hasOwnProperty(key)) {
msg[key] = targetObj[key];
}
private checkVersion(route: string, version: string) {
if(!version) return true;
// @ts-ignore
const minVersion = gameData.serverConst.MIN_VERSION[route];
if(!minVersion) return true;
return version >= minVersion;
}
private decryptMsg(msg: any, session: FrontendOrBackendSession) {
if (!session) return msg;
const publicKey = session.get('publicKey');
const encode = session.get('encode');
// @ts-ignore
if(!encode || encode != MsgEncrypt.RSA) return msg;
if(!publicKey) return msg;
try {
// @ts-ignore
const decryptMsg = pinus.crypto.decrypt(Buffer.from(publicKey, 'base64'), Buffer.from(msg, 'base64'));
msg = JSON.parse(decryptMsg.toString());
} catch (e) {
errlogger.error('decryptMsg error', e);
return null;
}
return msg;
}
// 传出的resp的修改
private setResp(resp: any, data: string) {
for(let key in resp) {
if(resp.hasOwnProperty(key)) {
delete resp[key];
}
}
resp.data = data;
return resp;
private checkSign(route: string, msg: any, session: FrontendOrBackendSession) {
if (!session) return false;
const sign = msg['sign'];
const token = session.get('token');
if (!sign || !token) return false;
const md5 = require('crypto').createHash('md5');
const str = route + JSON.stringify(msg) + token;
const signVal = md5.update(str).digest('hex');
return sign === signVal;
}
// 禁言的接口
private checkBanRoute (route: string) {
return [
private checkPassEncrypt(route: string) {
// @ts-ignore
if(!gameData.serverConst.NOT_CHECK_SIGN_ROUTES) return false;
// @ts-ignore
return gameData.serverConst.NOT_CHECK_SIGN_ROUTES.indexOf(route) != -1;
}
private checkBlackList(roleId: string, serverId: number) {
if(!roleId) return true;
const blackRoleMap = this.app.get('blackRoleMap') || new Map();
const roleList = blackRoleMap.get(serverId);
if(!roleList) return true;
// @ts-ignore
if(roleList.indexOf(roleId) != -1) {
return false;
}
return true;
}
private checkRoleFrom(route: string, session: FrontendOrBackendSession) {
const needRoutes = [
'role.roleHandler.rename',
'role.roleHandler.setHead',
'role.roleHandler.setSign',
];
if(needRoutes.indexOf(route) == -1) return true;
return session.get('roleId') === session.get('createRoleId');
}
private checkNoRepeatRoute(route: string, session: FrontendOrBackendSession) {
if(!session) return true;
const noRepeatRoutes = [
'role.roleHandler.createRole',
'gate.gateHandler.login',
'connector.entryHandler.enter',
];
if(noRepeatRoutes.indexOf(route) == -1) return true;
if(session.get('hasEnter')) {
return false;
}
session.set('hasEnter', true);
return true;
}
private checkChat(route: string, session: FrontendOrBackendSession, msg: any) {
if(route.indexOf('chat.') == -1) return true;
// @ts-ignore
if(session.get('blockType') == BLOCK_TYPE.CHAT) {
return false;
}
const needCheckRoutes = [
'chat.chatHandler.sendPrivateMessage',
'chat.chatHandler.sendGroupMessage',
'battle.comBattleHandler.sendTeamMsg',
'battle.barrageHandler.sendBarrage',
];
if(needCheckRoutes.indexOf(route) == -1) return true;
// @ts-ignore
const sendLimit = gameData.serverConst.SEND_CHAT_LIMIT;
const roleId = session.get('roleId');
getServerCreateTime(session.get('serverId')).then((now: number) => {
const lastTime = this.accessTime.get(`${roleId}_${route}`) || 0;
if(now - lastTime < sendLimit) {
return false;
}
});
return true;
}
private isNoCheckRoute(route: string) {
return [
'gate.gateHandler.login',
'connector.entryHandler.enter',
'role.roleHandler.initRole',
'role.roleHandler.createRole',
'chat.chatHandler.getInitData',
'chat.chatHandler.getChatList',
'chat.chatHandler.getPrivateChatList',
'battle.barrageHandler.getBarrages',
'activity.activityHandler.getActivityList',
'activity.activityHandler.getServerTime',
'role.roleHandler.getRoleInitInfo',
'role.roleHandler.getRoleOtherInfo',
'gate.gateHandler.getServerList',
'gate.gateHandler.getServerList1',
'gate.gateHandler.getServerTime',
'gm.gmHandler.getServerList',
'gm.gmHandler.getServerList1',
'gm.gmHandler.getServerTime',
'role.roleHandler.getOtherRoleInfo',
'battle.normalBattleHandler.getChapterInfo',
'battle.normalBattleHandler.getChapterStarReward',
'battle.normalBattleHandler.getBoxReward',
'battle.pvpHandler.getPvpInfo',
'battle.pvpHandler.getRankList',
'battle.ladderHandler.getLadderInfo',
'battle.ladderHandler.getLadderRankList',
'battle.ladderHandler.getSeasonReward',
'role.roleHandler.getRechargeList',
'role.roleHandler.getVipInfo',
'role.roleHandler.getMonthCard',
'activity.signInHandler.getSignInInfo',
'activity.dailyGiftsHandler.getInfo',
'activity.dailyMealHandler.getInfo',
'activity.dailyRMBGiftsHandler.getInfo',
'activity.growthFundHandler.getInfo',
'activity.monthlyFundHandler.getInfo',
'activity.sevenDaysHandler.getInfo',
'activity.firstGiftHandler.getInfo',
'activity.rechargeMoneyHandler.getInfo',
'activity.rebateHandler.getInfo',
'activity.thirtyDaysHandler.getInfo',
'activity.timeLimitRankHandler.getRankList',
'activity.timeLimitRankHandler.getMyRankInfo',
'guild.guildHandler.getGuildList',
'guild.guildHandler.getGuildDetail',
'guild.guildHandler.getGuildMemberList',
'guild.guildHandler.getApplyList',
'guild.guildHandler.getGuildLog',
'guild.guildHandler.searchGuild',
'guild.guildTrainHandler.getTrainInfo',
'guild.guildTrainHandler.getDonateLog',
'guild.guildRefineHandler.getRefineLog',
'guild.guildBossHandler.getGuildBossDetail',
'guild.guildBossHandler.getRankList',
'guild.gvgHandler.getGVGInfo',
'guild.gvgBattleHandler.getSeasonReward',
'guild.gvgBattleHandler.getRankList',
'guild.gvgBattleHandler.getMyRankInfo',
'guild.wishPoolHandler.getWishPoolInfo',
'activity.popUpShopHandler.getPopUpShopInfo',
'activity.yuanbaoShopHandler.getYuanbaoShopInfo',
'activity.refreshShopHandler.getRefreshShopInfo',
'activity.selfServiceShopActivityHandler.getSelfServiceShopInfo',
'activity.forgeHandler.getForgeInfo',
'activity.limitPackageHandler.getLimitPackageInfo',
'battle.towerBattleHandler.getTowerInfo',
'battle.towerBattleHandler.getTowerRankList',
'battle.towerBattleHandler.getMyTowerRankInfo',
'battle.expeditionBattleHandler.getExpeditionInfo',
'battle.expeditionBattleHandler.getExpeditionRankList',
'battle.dungeonBattleHandler.getDungeonInfo',
'battle.friendBattleHandler.getFriendBattleInfo',
'battle.friendBattleHandler.getFriendBattleRecord',
'battle.rougeHandler.getRougeInfo',
'battle.rougeHandler.getRougeRecord',
'activity.weeklyFundHandler.getInfo',
'activity.monthlyTicketHandler.getInfo',
'activity.newHeroGachaHandler.getNewHeroGachaInfo',
'activity.newHeroGKHandler.getNewHeroGKInfo',
'activity.newHeroGiftsHandler.getNewHeroGiftsInfo',
'activity.groupShopHandler.getGroupShopInfo',
'activity.luckyHandler.getLuckyInfo',
'activity.luckyTurntableHandler.getLuckyTurntableInfo',
'activity.treasureHuntHandler.getTreasureHuntInfo',
'activity.bindPhoneHandler.getPhoneState',
'activity.midAutumnHandler.getMidAutumnInfo',
'activity.dragonBoatHandler.getDragonBoatInfo',
'activity.qixiHandler.getQixiInfo',
'activity.chongyangHandler.getChongyangInfo',
'activity.novemberHandler.getNovemberInfo',
'activity.entertainHandler.getEntertainInfo',
'activity.miniGameHandler.getMiniGameInfo',
'activity.activityMonopolyHandler.getActivityMonopolyInfo',
'activity.vipRechargeMoneyHandler.getVipRechargeMoneyInfo',
'activity.refreshTaskHandler.getRefreshTaskInfo',
'battle.barrageHandler.sendBarrage',
'guild.guildHandler.sendMail',
'guild.guildHandler.setGuildInfo',
'guild.gvgManageHandler.sendMail',
@@ -220,59 +340,58 @@ class Filter {
'guild.gvgBattleHandler.setNotice',
].indexOf(route) != -1
}
// 检查聊天屏蔽词
private async checkHasBlockWord (route: string, msg: any, roleId: string, serverId: number, guildCode: string) {
private async checkHasBlockWord (route: string, msg: any, roleId: string, serverId: number, guildCode: string) {
let hasBlockWords = false;
switch(route) {
case 'chat.chatHandler.sendPrivateMessage':
{
let result = await checkPrivateChat(roleId, msg.targetRoleId, msg.type == MSG_TYPE.IMG? "表情": msg.content);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'chat.chatHandler.sendGroupMessage':
{
if(msg.channel == CHANNEL_PREFIX.GUILD) {
let result = await checkGuildChat(roleId, guildCode, msg.type == MSG_TYPE.IMG? "表情": msg.content);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
} else {
let result = await checkOtherChat(roleId, msg.channel, msg.type == MSG_TYPE.IMG? "表情": msg.content);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
}
case 'battle.comBattleHandler.sendTeamMsg':
{
let result = await checkOtherChat(roleId, CHANNEL_PREFIX.TEAM, msg.content);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'battle.barrageHandler.sendBarrage':
{
let result = await checkOtherChat(roleId, CHANNEL_PREFIX.WORLD, msg.content);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'guild.guildHandler.sendMail':
{
let result = await checkGuildChat(roleId, guildCode, msg.info);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'role.roleHandler.rename':
case 'role.roleHandler.initRole':
{
let result = await checkRoleName(roleId, msg.roleName);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'guild.guildHandler.createGuild':
case 'guild.guildHandler.setGuildInfo':
{
let result = await checkGuildName(guildCode, serverId, msg.name, msg.notice);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'guild.gvgManageHandler.createLeague':
@@ -280,32 +399,31 @@ class Filter {
case 'guild.gvgBattleHandler.setNotice':
{
let result = await checkGuildName(guildCode, serverId, msg.name, msg.notice);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
case 'guild.gvgManageHandler.sendMail':
case 'guild.gvgManageHandler.recruit':
{
let result = await checkGuildChat(roleId, guildCode, msg.content);
if(!result) hasBlockWords = true;
if(!result) hasBlockWords = true;
break;
}
}
return hasBlockWords;
}
// 检查是否维护中
private async checkMainten(serverId: number, sid: string, ip: string, uid: number, isNewUser: boolean) {
if(!sid) return false;
const mainten = getServerMainten(serverId);
if(!mainten) return false // 该服务器维护
if(!mainten) return false
if(mainten.startTime > nowSeconds() || mainten.endTime < nowSeconds()) return false;
let isWhiteList = await checkWhiteList(this.app.get('env'), ip, uid);
if(isWhiteList) return false;
if(isNewUser) return false;
return true
}
@@ -328,4 +446,4 @@ class Filter {
await redis.expireAsync(`cs: ${cs}`, gameData.serverConst.ACCESS_CODE_EXPIRE_TIME/1000);
return true;
}
}
}

View File

@@ -1,423 +1,424 @@
import { STATUS } from './../../../consts/statusCode';
import { RoleModel, RoleType } from './../../../db/Role';
import { UserModel, UserType } from '../../../db/User';
import { GMUserModel } from '../../../db/GMUser';
import { Application, HandlerService, pinus, } from 'pinus';
import { FrontendSession } from 'pinus';
import { HeroModel } from './../../../db/Hero';
import { compareVersion, genCode, generateStr, resResult } from '../../../pubUtils/util';
import { COM_BTL_QUALITY, HERO_SELECT, DEBUG_MAGIC_WORD, REDIS_KEY, TASK_TYPE, ENTERY_ROLE_PICK, COUNTER, DEFAULT_LV, TA_USERSET_TYPE, LOG_TYPE, JEWEL_SELECT, ITEM_SELECT, SKIN_SELECT, PUSH_ROUTE } from '../../../consts';
// import { loginRefresh } from '../../../services/playerEventService';
import { nowSeconds, getZeroPoint } from '../../../pubUtils/timeUtil';
import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin, getOnlineRoleByUserCode } from '../../../services/redisService';
import { addRoleToGuildChannel, addRoleToSysChannel, addRoleToWorldChannel, leaveGroupShopChannel, leaveGuildAuctionChannel, leaveGuildChannel, leaveGVGAreaChannel, leaveGVGAreaTeamChannel, leaveGVGCityTeamChannel, leaveSysChannel, leaveWorldAuctionChannel, leaveWorldChannel } from '../../../services/chatService';
import { reportOneOnline, savePlayTime } from '../../../services/authenticateService';
import { checkTaskInEntry, } from '../../../services/task/taskService';
import { pushData, kickUser, getModuleData, assignServer, leaveServer } from '../../../services/connectorService';
// import { setComBtlOnUserLeave } from '../../../services/comBattleService';
import Counter from '../../../db/Counter';
import { getExpByLv } from '../../../pubUtils/data';
import { reportCreateRoleEventToTa, reportTAEvent, reportTAUserSet } from '../../../services/sdkService';
import { saveLoginAndOutLog } from '../../../pubUtils/logUtil';
import { sendMessageToAllWithSuc, sendMessageToUserWithSuc } from '../../../services/pushService';
import { checkIsNewUser, getIpLocation } from '../../../services/roleService';
import { leaveRaceActivityToRemote } from '../../../services/guildActivity/guildActivityService';
import { leaveCity } from '../../../services/gvg/gvgBattleService';
import { autoCreateServerWhenRoleInit } from '../../../services/serverService';
import { getHiddenData } from '../../../services/memoryCache/hiddenData';
import { ServerlistModel } from '../../../db/Serverlist';
import { checkWhiteList } from '../../../pubUtils/sysUtil';
import { getAp } from '../../../services/actionPointService';
import { RegionModel } from '../../../db/Region';
export default function (app: Application) {
new HandlerService(app, {});
return new EntryHandler(app);
}
export class EntryHandler {
constructor(private app: Application) {
}
/**
* New client entry chat server.
*
* @param {Object} msg request message
* @param {Object} session current session object
*/
async enter(msg: { token: string, serverId: number, version: string }, session: FrontendSession) {
// console.log('****** entry before', Date.now());
let self = this;
let serverId = msg.serverId;
let curRegion = await RegionModel.findRegionByEnv(pinus.app.get('env'));
const versionFlag = compareVersion(msg.version, curRegion?.minVersion);
if (!curRegion || versionFlag < 0) {
//版本号太低
return resResult(STATUS.VERSION_ERR, { version: curRegion.minVersion });
}
let user = await UserModel.findUserByToken(msg.token);
if (!user) {
console.log('user token not found');
return resResult(STATUS.TOKEN_ERR);
}
let ip = this.getIp(session);
let isWhiteList = await checkWhiteList(pinus.app.get('env'), ip, user.uid);
let ipLocation = await getIpLocation(ip);
let role = await RoleModel.findByUidAndSetTime(user.uid, serverId, ip, ipLocation, null, true);
if (!role) {
return resResult(STATUS.ROLE_NOT_FOUND);
}
let onlineRoleId = isWhiteList? role.roleId: await getOnlineRoleByUserCode(user.userCode);
if (!!onlineRoleId) { // 多地登陆踢下线
let connect = await getRoleOnlineInfo(onlineRoleId);
if (connect.sid = self.app.getServerId()) {
await kickUser(self.app, onlineRoleId);
} else {
await self.app.rpc.connector.connectorRemote.remoteLogin.toServer(connect.sid, onlineRoleId);
}
}
let server = await ServerlistModel.findByServerId(serverId);
if(!server) return resResult(STATUS.SERVER_NOT_FOUND);
if(!isWhiteList) { // 白名单
if(server.openTime > nowSeconds()) {
return resResult(STATUS.SERVER_IS_NOT_OPEN);
}
if(server.maintenance && server.maintenance.isOpen && server.maintenance.startTime <= nowSeconds() && server.maintenance.endTime >= nowSeconds()) {
let isNewUser = await checkIsNewUser(msg.version, server.maintenance.version, user.uid, server.latestServerUniqId);
console.log('#### isNewUser', isNewUser)
if(isNewUser && server.id == server.latestServerUniqId) {
user['isNewUser'] = true;
} else {
return resResult(STATUS.SERVER_MAINTENANCE, { curVersion: msg.version, minVersion: server.maintenance.version })
}
}
}
let serverName = this.app.getServerId();
await roleLogin(role.roleId, user.userCode, serverName, role.createTime, role.serverId, role.lv, role.topLineupCe); // 保存在线用户
await this.addSession(user, role, msg.version, session);
await reportCreateRoleEventToTa(role, ip);
saveLoginAndOutLog(LOG_TYPE.LOGIN, session);
addRoleToSysChannel(role.roleId, self.app.get('serverId'), role.serverId);
addRoleToWorldChannel(role.roleId, self.app.get('serverId'), role.serverId);
reportOneOnline(role.roleId, user.userCode, self.app.get('serverId'), true, user);
// 任务
checkTaskInEntry(serverId, role.roleId, self.app.get('serverId'), role);
if (role.hasGuild) {
addRoleToGuildChannel(role.roleId, self.app.get('serverId'), role.guildCode);
}
let todayZeroPoint = getZeroPoint();
if(role.needCount) autoCreateServerWhenRoleInit(serverId);
// console.log('****** entry after', Date.now());
return resResult(STATUS.SUCCESS, { roleId: role.roleId, todayZeroPoint });
}
async getData(msg: { }, session: FrontendSession) {
let ip = session.get('ip');
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId, '-_id', true, true);
// 推送数据
pushData(role.hasInit, role, session);
let todayZeroPoint = getZeroPoint();
return resResult(STATUS.SUCCESS, { todayZeroPoint });
}
private getIp(session: FrontendSession) {
return session.remoteAddress.ip.replace('::ffff:', '');
}
async addSession(user: UserType, role: RoleType, version: string, session: FrontendSession) {
const self = this;
let ip = this.getIp(session);
console.log('####### addSession', user['isNewUser']||false)
await session.abind(role.roleId);
session.set('userid', role.userInfo.uid);
session.set('roleId', role.roleId);
session.set('loginTime', nowSeconds());
session.set('roleName', role.roleName);
session.set('eventStatus', role.eventStatus);
session.set('blockType', role.blockType);
session.set('sid', self.app.get('serverId'));
session.set('serverId', role.serverId);
session.set('guildCode', role.guildCode);
session.set('ip', ip);
session.set('vipStartTime', role.vipStartTime||0);
session.set('channel', user.channelInfo?.platformAppid||'pc');
session.set('isNewUser', user['isNewUser']||false);
session.set('version', version);
session.set('quitTime', role.quitTime ? (role.quitTime * 1000) : Date.now())
session.push('userid', () => { });
session.push('sid', () => { });
session.push('roleId', () => { });
session.push('roleName', () => { });
session.push('eventStatus', () => { });
session.push('serverId', () => { });
session.push('loginTime', () => { });
session.push('guildCode', () => { });
session.push('blockType', () => { });
session.push('ip', () => { });
session.push('vipStartTime', () => { });
session.push('channel', () => { });
session.push('version', () => { });
session.push('isNewUser', () => { });
session.push('quitTime', () => { })
assignServer(role.roleId, session);
// console.log('#####', role.serverId, role.guildCode)
// console.log(role.guildCode)
// session.push('rid', function (err) {
// if (err) {
// console.error('set rid for session service failed! error is : %j', err.stack);
// }
// });
session.on('closed', this.onUserLeave.bind(this));
}
/**
* 每天5点时的刷新数据.
*
* @param {Object} msg request message
* @param {Object} session current session object
*/
async refresh(msg: {}, session: FrontendSession) {
let self = this;
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleIdAndSetTime(roleId, '-_id', true);
if (!role) {
return resResult(STATUS.ROLE_NOT_FOUND);
}
let { serverId } = role;
// 任务
checkTaskInEntry(serverId, role.roleId, self.app.get('serverId'), role);
// 推送数据
pushData(role.hasInit, role, session, 'refresh');
let todayZeroPoint = getZeroPoint();
return resResult(STATUS.SUCCESS, { todayZeroPoint });
}
async getHiddenData(msg: { }, session: FrontendSession) {
let data = getHiddenData();
return resResult(STATUS.SUCCESS, data);
}
async comeBack(msg: { version: string }, session: FrontendSession) {
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
/**
* User log out handler
*
* @param {Object} app current application
* @param {Object} session current session object
*
*/
async onUserLeave(session: FrontendSession, reason: string) {
if (!session || !session.uid) {
return;
}
let roleId = session.get('roleId');
let sid = session.get('sid');
let serverId = session.get('serverId');
let loginTime = session.get('loginTime');
const guildCode = session.get('guildCode');
const teamCode: string = session.get('teamCode');
roleLeave(roleId).then(function (roleInfo) {
if (roleInfo.isOnline) {
savePlayTime(roleInfo.userCode);
}
});
leaveRaceActivityToRemote(serverId, guildCode, roleId);
reportTAUserSet(TA_USERSET_TYPE.ADD, roleId, { total_play_time: nowSeconds() - loginTime });
rmRoleFromQueue(roleId, sid); // 删除redis中寻宝的匹配记录
let channelService = this.app.get('channelService');
let channel = channelService.getChannel(roleId, true);
channel.leave(roleId, sid);
try {
await leaveSysChannel(roleId, sid, serverId);
await leaveWorldChannel(roleId, sid, serverId);
await leaveGuildChannel(roleId, sid, guildCode);
await leaveGuildAuctionChannel(roleId, sid, guildCode);
await leaveWorldAuctionChannel(roleId, sid, serverId);
await leaveGroupShopChannel(roleId, sid);
await leaveGVGAreaChannel(roleId, sid);
await leaveGVGAreaTeamChannel(roleId, sid);
await leaveGVGCityTeamChannel(roleId, sid);
await leaveCity(true, roleId, serverId, guildCode);
} catch(e) {
console.error(e.stack);
}
RoleModel.updateRoleInfo(roleId, { quitTime: nowSeconds() });
// if(teamCode) { // 如果有寻宝中的队伍,那么等于战败
// setComBtlOnUserLeave(roleId, teamCode)
// }
saveLoginAndOutLog(LOG_TYPE.LOGINOUT, session);
leaveServer(session);
}
/**
* New client entry chat server.
*
* @param {Object} msg request message
* @param {Object} session current session object
*/
async gmEnter(msg: { token: string }, session: FrontendSession) {
let self = this;
let user = await GMUserModel.getGmAccountByToken(msg.token);
if (!user) {
console.log('user token not found');
return resResult(STATUS.TOKEN_ERR);
}
if(!user.isEnable) {
return resResult(STATUS.GM_NO_AUTHORITY_GET);
}
// console.log(self.app.get('serverId'));
await session.abind(user.username);
session.set('uid', user.uid);
session.set('roleId', user.username);
session.set('roleName', user.name);
session.set('groupId', user.groupId);
session.set('eventStatus', 0);
session.set('sid', self.app.get('serverId'));
session.push('uid', () => { });
session.push('sid', () => { });
session.push('roleId', () => { });
session.push('roleName', () => { });
session.push('groupId', () => { });
session.push('eventStatus', () => { });
// session.push('rid', function (err) {
// if (err) {
// console.error('set rid for session service failed! error is : %j', err.stack);
// }
// });
session.on('closed', this.onGmUserLeave.bind(this));
sendMessageToUserWithSuc(user.username, 'onGMENTER', {}, self.app.get('serverId'))
// put user into channel
return resResult(STATUS.SUCCESS, {
env: this.app.get('env')
});
}
/**
* User log out handler
*
* @param {Object} app current application
* @param {Object} session current session object
*
*/
async onGmUserLeave(session: FrontendSession, reason: string) {
if (!session || !session.uid) {
return;
}
}
/**
* ! 仅用于测试
* @description 测试接口,用于查询和返回 token
* @param {{ tel: string, magicWord: string }} msg 要查询的手机号;需要验证的密码
* @param {FrontendSession} session
* @returns
* @memberof EntryHandler
*/
async debugQueryToken(msg: { tel: string, magicWord: string }, session: FrontendSession) {
const { tel, magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const token = await UserModel.findTokenByTel(tel);
return resResult(STATUS.SUCCESS, { token });
}
/**
* ! 仅用于测试
* @description 测试接口,用于查询和返回 token
* @param {{ seqId: string, magicWord: string }} msg 要查询的手机号;需要验证的密码
* @param {FrontendSession} session
* @returns
* @memberof EntryHandler
*/
async debugQueryTokenById(msg: { uid: number, magicWord: string }, session: FrontendSession) {
const { uid, magicWord } = msg;
console.log('debugQueryTokenById msg:', msg);
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const user = await UserModel.findTokenByUid(uid);
console.log('debugQueryTokenById got user:', user);
return resResult(STATUS.SUCCESS, { user });
}
async debugGetRole(msg: { magicWord: string, type: string }, session: FrontendSession) {
const { magicWord, type = 'role' } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId, '-_id', true, true);
let module = await getModuleData(type, { role, session });
return resResult(STATUS.SUCCESS, { role: module });
}
async debugQueryTokenByTel(msg: { tel: string, magicWord: string, serverId: number }, session: FrontendSession) {
const { tel, magicWord, serverId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let token = await UserModel.findTokenByTel(tel);
if(!token) {
// 用户注册登录
token = generateStr(256);
let {user} = await UserModel.createOrUpdate(false, tel, token, 'pc', ' ', pinus.app.get('env'), '', '');
const roleId = genCode(10);
const code = genCode(6);
const seqId = await Counter.getNewCounter(COUNTER.ROLE) || -1;
await RoleModel.createRole(user.uid, serverId, { roleId, code, roleName: roleId, seqId, lv: DEFAULT_LV, exp: (getExpByLv(DEFAULT_LV - 1) || { sum: 0 }).sum || 0 }, '');
}
console.log('debugQueryTokenByTel got user:', token);
return resResult(STATUS.SUCCESS, { user: token });
}
async debugPushRefToOnlineUsers(msg: { magicWord: string, todayZeroPoint: number }, session: FrontendSession) {
const { magicWord, todayZeroPoint } = msg;
console.log('debugQueryTokenById msg:', msg);
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
await sendMessageToAllWithSuc(PUSH_ROUTE.REFRESH_TIME, { todayZeroPoint });
return resResult(STATUS.SUCCESS);
}
}
import { STATUS } from './../../../consts/statusCode';
import { RoleModel, RoleType } from './../../../db/Role';
import { UserModel, UserType } from '@db/User';
import { GMUserModel } from '@db/GMUser';
import { Application, HandlerService, pinus, } from 'pinus';
import { FrontendSession } from 'pinus';
import { HeroModel } from './../../../db/Hero';
import { compareVersion, genCode, generateStr, resResult } from '@pubUtils/util';
import { COM_BTL_QUALITY, HERO_SELECT, DEBUG_MAGIC_WORD, REDIS_KEY, TASK_TYPE, ENTERY_ROLE_PICK, COUNTER, DEFAULT_LV, TA_USERSET_TYPE, LOG_TYPE, JEWEL_SELECT, ITEM_SELECT, SKIN_SELECT, PUSH_ROUTE } from '../../../consts';
// import { loginRefresh } from '../../../services/playerEventService';
import { nowSeconds, getZeroPoint } from '@pubUtils/timeUtil';
import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin, getOnlineRoleByUserCode } from '../../../services/redisService';
import { addRoleToGuildChannel, addRoleToSysChannel, addRoleToWorldChannel, leaveGroupShopChannel, leaveGuildAuctionChannel, leaveGuildChannel, leaveGVGAreaChannel, leaveGVGAreaTeamChannel, leaveGVGCityTeamChannel, leaveSysChannel, leaveWorldAuctionChannel, leaveWorldChannel } from '../../../services/chatService';
import { reportOneOnline, savePlayTime } from '../../../services/authenticateService';
import { checkTaskInEntry, } from '../../../services/task/taskService';
import { pushData, kickUser, getModuleData, assignServer, leaveServer } from '../../../services/connectorService';
// import { setComBtlOnUserLeave } from '../../../services/comBattleService';
import Counter from '@db/Counter';
import { getExpByLv } from '@pubUtils/data';
import { reportCreateRoleEventToTa, reportTAEvent, reportTAUserSet } from '../../../services/sdkService';
import { saveLoginAndOutLog } from '@pubUtils/logUtil';
import { sendMessageToAllWithSuc, sendMessageToUserWithSuc } from '../../../services/pushService';
import { checkIsNewUser, getIpLocation } from '../../../services/roleService';
import { leaveRaceActivityToRemote } from '../../../services/guildActivity/guildActivityService';
import { leaveCity } from '../../../services/gvg/gvgBattleService';
import { autoCreateServerWhenRoleInit } from '../../../services/serverService';
import { getHiddenData } from '../../../services/memoryCache/hiddenData';
import { ServerlistModel } from '@db/Serverlist';
import { checkWhiteList } from '@pubUtils/sysUtil';
import { getAp } from '../../../services/actionPointService';
import { RegionModel } from '@db/Region';
export default function (app: Application) {
new HandlerService(app, {});
return new EntryHandler(app);
}
export class EntryHandler {
constructor(private app: Application) {
}
/**
* New client entry chat server.
*
* @param {Object} msg request message
* @param {Object} session current session object
*/
async enter(msg: { token: string, serverId: number, version: string }, session: FrontendSession) {
// console.log('****** entry before', Date.now());
let self = this;
let serverId = msg.serverId;
let curRegion = await RegionModel.findRegionByEnv(pinus.app.get('env'));
const versionFlag = compareVersion(msg.version, curRegion?.minVersion);
if (!curRegion || versionFlag < 0) {
//版本号太低
return resResult(STATUS.VERSION_ERR, { version: curRegion.minVersion });
}
let user = await UserModel.findUserByToken(msg.token);
if (!user) {
console.log('user token not found');
return resResult(STATUS.TOKEN_ERR);
}
let ip = this.getIp(session);
let isWhiteList = await checkWhiteList(pinus.app.get('env'), ip, user.uid);
let ipLocation = await getIpLocation(ip);
let role = await RoleModel.findByUidAndSetTime(user.uid, serverId, ip, ipLocation, null, true);
if (!role) {
return resResult(STATUS.ROLE_NOT_FOUND);
}
let onlineRoleId = isWhiteList? role.roleId: await getOnlineRoleByUserCode(user.userCode);
if (!!onlineRoleId) { // 多地登陆踢下线
let connect = await getRoleOnlineInfo(onlineRoleId);
if (connect.sid = self.app.getServerId()) {
await kickUser(self.app, onlineRoleId);
} else {
await self.app.rpc.connector.connectorRemote.remoteLogin.toServer(connect.sid, onlineRoleId);
}
}
let server = await ServerlistModel.findByServerId(serverId);
if(!server) return resResult(STATUS.SERVER_NOT_FOUND);
if(!isWhiteList) { // 白名单
if(server.openTime > nowSeconds()) {
return resResult(STATUS.SERVER_IS_NOT_OPEN);
}
if(server.maintenance && server.maintenance.isOpen && server.maintenance.startTime <= nowSeconds() && server.maintenance.endTime >= nowSeconds()) {
let isNewUser = await checkIsNewUser(msg.version, server.maintenance.version, user.uid, server.latestServerUniqId);
console.log('#### isNewUser', isNewUser)
if(isNewUser && server.id == server.latestServerUniqId) {
user['isNewUser'] = true;
} else {
return resResult(STATUS.SERVER_MAINTENANCE, { curVersion: msg.version, minVersion: server.maintenance.version })
}
}
}
let serverName = this.app.getServerId();
await roleLogin(role.roleId, user.userCode, serverName, role.createTime, role.serverId, role.lv, role.topLineupCe); // 保存在线用户
await this.addSession(user, role, msg.version, session);
await reportCreateRoleEventToTa(role, ip);
saveLoginAndOutLog(LOG_TYPE.LOGIN, session);
addRoleToSysChannel(role.roleId, self.app.get('serverId'), role.serverId);
addRoleToWorldChannel(role.roleId, self.app.get('serverId'), role.serverId);
reportOneOnline(role.roleId, user.userCode, self.app.get('serverId'), true, user);
// 任务
checkTaskInEntry(serverId, role.roleId, self.app.get('serverId'), role);
if (role.hasGuild) {
addRoleToGuildChannel(role.roleId, self.app.get('serverId'), role.guildCode);
}
let todayZeroPoint = getZeroPoint();
if(role.needCount) autoCreateServerWhenRoleInit(serverId);
// console.log('****** entry after', Date.now());
return resResult(STATUS.SUCCESS, { roleId: role.roleId, todayZeroPoint });
}
async getData(msg: { }, session: FrontendSession) {
let ip = session.get('ip');
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId, '-_id', true, true);
// 推送数据
pushData(role.hasInit, role, session);
let todayZeroPoint = getZeroPoint();
return resResult(STATUS.SUCCESS, { todayZeroPoint });
}
private getIp(session: FrontendSession) {
return session.remoteAddress.ip.replace('::ffff:', '');
}
async addSession(user: UserType, role: RoleType, version: string, session: FrontendSession) {
const self = this;
let ip = this.getIp(session);
console.log('####### addSession', user['isNewUser']||false)
await session.abind(role.roleId);
session.set('userid', role.userInfo.uid);
session.set('roleId', role.roleId);
session.set('loginTime', nowSeconds());
session.set('roleName', role.roleName);
session.set('eventStatus', role.eventStatus);
session.set('blockType', role.blockType);
session.set('sid', self.app.get('serverId'));
session.set('serverId', role.serverId);
session.set('guildCode', role.guildCode);
session.set('ip', ip);
session.set('vipStartTime', role.vipStartTime||0);
session.set('channel', user.channelInfo?.platformAppid||'pc');
session.set('isNewUser', user['isNewUser']||false);
session.set('version', version);
session.set('quitTime', role.quitTime ? (role.quitTime * 1000) : Date.now())
session.push('userid', () => { });
session.push('sid', () => { });
session.push('roleId', () => { });
session.push('roleName', () => { });
session.push('eventStatus', () => { });
session.push('serverId', () => { });
session.push('loginTime', () => { });
session.push('guildCode', () => { });
session.push('blockType', () => { });
session.push('ip', () => { });
session.push('vipStartTime', () => { });
session.push('channel', () => { });
session.push('version', () => { });
session.push('isNewUser', () => { });
session.push('quitTime', () => { })
assignServer(role.roleId, session);
// console.log('#####', role.serverId, role.guildCode)
// console.log(role.guildCode)
// session.push('rid', function (err) {
// if (err) {
// console.error('set rid for session service failed! error is : %j', err.stack);
// }
// });
session.on('closed', this.onUserLeave.bind(this));
}
/**
* 每天5点时的刷新数据.
*
* @param {Object} msg request message
* @param {Object} session current session object
*/
async refresh(msg: {}, session: FrontendSession) {
let self = this;
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleIdAndSetTime(roleId, '-_id', true);
if (!role) {
return resResult(STATUS.ROLE_NOT_FOUND);
}
let { serverId } = role;
// 任务
checkTaskInEntry(serverId, role.roleId, self.app.get('serverId'), role);
// 推送数据
pushData(role.hasInit, role, session, 'refresh');
let todayZeroPoint = getZeroPoint();
return resResult(STATUS.SUCCESS, { todayZeroPoint });
}
async getHiddenData(msg: { }, session: FrontendSession) {
let data = getHiddenData();
return resResult(STATUS.SUCCESS, data);
}
async comeBack(msg: { version: string }, session: FrontendSession) {
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
/**
* User log out handler
*
* @param {Object} app current application
* @param {Object} session current session object
*
*/
async onUserLeave(session: FrontendSession, reason: string) {
if (!session || !session.uid) {
return;
}
let roleId = session.get('roleId');
let sid = session.get('sid');
let serverId = session.get('serverId');
let loginTime = session.get('loginTime');
const guildCode = session.get('guildCode');
const teamCode: string = session.get('teamCode');
roleLeave(roleId).then(function (roleInfo) {
if (roleInfo.isOnline) {
savePlayTime(roleInfo.userCode);
}
});
leaveRaceActivityToRemote(serverId, guildCode, roleId);
reportTAUserSet(TA_USERSET_TYPE.ADD, roleId, { total_play_time: nowSeconds() - loginTime });
rmRoleFromQueue(roleId, sid); // 删除redis中寻宝的匹配记录
let channelService = this.app.get('channelService');
let channel = channelService.getChannel(roleId, true);
channel.leave(roleId, sid);
try {
await leaveSysChannel(roleId, sid, serverId);
await leaveWorldChannel(roleId, sid, serverId);
await leaveGuildChannel(roleId, sid, guildCode);
await leaveGuildAuctionChannel(roleId, sid, guildCode);
await leaveWorldAuctionChannel(roleId, sid, serverId);
await leaveGroupShopChannel(roleId, sid);
await leaveGVGAreaChannel(roleId, sid);
await leaveGVGAreaTeamChannel(roleId, sid);
await leaveGVGCityTeamChannel(roleId, sid);
await leaveCity(true, roleId, serverId, guildCode);
} catch(e) {
console.error(e.stack);
}
RoleModel.updateRoleInfo(roleId, { quitTime: nowSeconds() });
// if(teamCode) { // 如果有寻宝中的队伍,那么等于战败
// setComBtlOnUserLeave(roleId, teamCode)
// }
saveLoginAndOutLog(LOG_TYPE.LOGINOUT, session);
leaveServer(session);
}
/**
* New client entry chat server.
*
* @param {Object} msg request message
* @param {Object} session current session object
*/
async gmEnter(msg: { token: string }, session: FrontendSession) {
let self = this;
let user = await GMUserModel.getGmAccountByToken(msg.token);
if (!user) {
console.log('user token not found');
return resResult(STATUS.TOKEN_ERR);
}
if(!user.isEnable) {
return resResult(STATUS.GM_NO_AUTHORITY_GET);
}
// console.log(self.app.get('serverId'));
await session.abind(user.username);
session.set('uid', user.uid);
session.set('roleId', user.username);
session.set('roleName', user.name);
session.set('groupId', user.groupId);
session.set('eventStatus', 0);
session.set('sid', self.app.get('serverId'));
session.push('uid', () => { });
session.push('sid', () => { });
session.push('roleId', () => { });
session.push('roleName', () => { });
session.push('groupId', () => { });
session.push('eventStatus', () => { });
// session.push('rid', function (err) {
// if (err) {
// console.error('set rid for session service failed! error is : %j', err.stack);
// }
// });
session.on('closed', this.onGmUserLeave.bind(this));
sendMessageToUserWithSuc(user.username, 'onGMENTER', {}, self.app.get('serverId'))
// put user into channel
return resResult(STATUS.SUCCESS, {
env: this.app.get('env')
});
}
/**
* User log out handler
*
* @param {Object} app current application
* @param {Object} session current session object
*
*/
async onGmUserLeave(session: FrontendSession, reason: string) {
if (!session || !session.uid) {
return;
}
}
/**
* ! 仅用于测试
* @description 测试接口,用于查询和返回 token
* @param {{ tel: string, magicWord: string }} msg 要查询的手机号;需要验证的密码
* @param {FrontendSession} session
* @returns
* @memberof EntryHandler
*/
async debugQueryToken(msg: { tel: string, magicWord: string }, session: FrontendSession) {
const { tel, magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const token = await UserModel.findTokenByTel(tel);
return resResult(STATUS.SUCCESS, { token });
}
/**
* ! 仅用于测试
* @description 测试接口,用于查询和返回 token
* @param {{ seqId: string, magicWord: string }} msg 要查询的手机号;需要验证的密码
* @param {FrontendSession} session
* @returns
* @memberof EntryHandler
*/
async debugQueryTokenById(msg: { uid: number, magicWord: string }, session: FrontendSession) {
const { uid, magicWord } = msg;
console.log('debugQueryTokenById msg:', msg);
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const user = await UserModel.findTokenByUid(uid);
console.log('debugQueryTokenById got user:', user);
return resResult(STATUS.SUCCESS, { user });
}
async debugGetRole(msg: { magicWord: string, type: string }, session: FrontendSession) {
const { magicWord, type = 'role' } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let role = await RoleModel.findByRoleId(roleId, '-_id', true, true);
let module = await getModuleData(type, { role, session });
return resResult(STATUS.SUCCESS, { role: module });
}
async debugQueryTokenByTel(msg: { tel: string, magicWord: string, serverId: number }, session: FrontendSession) {
const { tel, magicWord, serverId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let token = await UserModel.findTokenByTel(tel);
if(!token) {
// 用户注册登录
token = generateStr(256);
let {user} = await UserModel.createOrUpdate(false, tel, token, 'pc', ' ', pinus.app.get('env'), '', '');
const roleId = genCode(10);
const code = genCode(6);
const seqId = await Counter.getNewCounter(COUNTER.ROLE) || -1;
await RoleModel.createRole(user.uid, serverId, { roleId, code, roleName: roleId, seqId, lv: DEFAULT_LV, exp: (getExpByLv(DEFAULT_LV - 1) || { sum: 0 }).sum || 0 }, '');
}
console.log('debugQueryTokenByTel got user:', token);
return resResult(STATUS.SUCCESS, { user: token });
}
async debugPushRefToOnlineUsers(msg: { magicWord: string, todayZeroPoint: number }, session: FrontendSession) {
const { magicWord, todayZeroPoint } = msg;
console.log('debugQueryTokenById msg:', msg);
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
await sendMessageToAllWithSuc(PUSH_ROUTE.REFRESH_TIME, { todayZeroPoint });
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,240 +1,241 @@
import { Application, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { UserGuildType } from '../../../db/UserGuild';
import { incServerNum, kickUser } from '../../../services/connectorService';
import { PVPConfigModel, PVPConfigType } from '../../../db/PvpConfig';
import { setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivity/guildActivityService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { errlogger } from '../../../util/logger';
import { setWeek } from '../../../pubUtils/timeUtil';
import { savePvpSeasonMemory } from '../../../services/log/memoryLogService';
import { setApiIsClose } from '../../../services/chatService';
import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
import { setKvToMemory } from '../../../services/pushService';
import { setServerGroup } from '../../../services/serverService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ConnectorRemote(app);
}
export class ConnectorRemote {
constructor(private app: Application) {
this.app = app;
}
public async remoteLogin(uid: string, message?: any) {
try {
await kickUser(this.app, uid, message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setOtherUserGuildSession(params: { roleId: string, userGuild: UserGuildType}[]) {
try {
let sessionService = this.app.get('sessionService');
for(let {roleId, userGuild} of params) {
let sessions = sessionService.getByUid(roleId);
if(!!sessions) {
sessions.forEach(session => {
if(userGuild && userGuild.status == 1) {
sessionService.aimportAll(session.id, { guildCode: userGuild?.guildCode, guildAuth: userGuild?.auth });
} else {
sessionService.aimportAll(session.id, { guildCode: '', guildAuth: 0 });
}
})
}
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setOtherUserSession(params: { roleId: string, roleName?: string, blockType?: number, vipStartTime?: number}[]) {
try {
let sessionService = this.app.get('sessionService');
for(let {roleId, roleName, blockType, vipStartTime} of params) {
let sessions = sessionService.getByUid(roleId);
if(!!sessions) {
sessions.forEach(session => {
if(roleName) sessionService.aimportAll(session.id, { roleName });
if(blockType) sessionService.aimportAll(session.id, { blockType });
if(vipStartTime) sessionService.aimportAll(session.id, { vipStartTime });
});
}
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSettleSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSettleSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的拍卖行时间
*/
async setDicAuctionTime(startTime: number, endActivity: number, startGuild: number, endGuild: number, startWorld: number, endWorld: number) {
try {
setDicAuctionTime(startTime, endActivity, startGuild, endGuild, startWorld, endWorld);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async setDay(week: number) {
try {
setWeek(week);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的军团活动开始时间&持续时间
* @param {number} aid 活动
* @param {number} startSeconds 从现在开始几秒后开启活动
* @param {number} endSeconds 从开始之后几秒后结束活动
*/
public async setDicGuildActivity(now: number, aid: number, startSeconds: number, endSeconds: number) {
try {
setDicGuildActivity(now, aid, startSeconds, endSeconds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async incServerNum(sid: string, inc: number) {
try {
incServerNum(sid, inc);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public savePvpSeasonMemory() {
try {
return savePvpSeasonMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '@pubUtils/data';
import { UserGuildType } from '@db/UserGuild';
import { incServerNum, kickUser } from '../../../services/connectorService';
import { PVPConfigModel, PVPConfigType } from '@db/PvpConfig';
import { setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivity/guildActivityService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { errlogger } from '../../../util/logger';
import { setWeek } from '@pubUtils/timeUtil';
import { savePvpSeasonMemory } from '../../../services/log/memoryLogService';
import { setApiIsClose } from '../../../services/chatService';
import { setPvpSeasonNum, setPvpSettleSeasonNum } from '../../../services/timeTaskService';
import { setKvToMemory } from '../../../services/pushService';
import { setServerGroup } from '../../../services/serverService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new ConnectorRemote(app);
}
export class ConnectorRemote {
constructor(private app: Application) {
this.app = app;
}
public async remoteLogin(uid: string, message?: any) {
try {
await kickUser(this.app, uid, message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setOtherUserGuildSession(params: { roleId: string, userGuild: UserGuildType}[]) {
try {
let sessionService = this.app.get('sessionService');
for(let {roleId, userGuild} of params) {
let sessions = sessionService.getByUid(roleId);
if(!!sessions) {
sessions.forEach(session => {
if(userGuild && userGuild.status == 1) {
sessionService.aimportAll(session.id, { guildCode: userGuild?.guildCode, guildAuth: userGuild?.auth });
} else {
sessionService.aimportAll(session.id, { guildCode: '', guildAuth: 0 });
}
})
}
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setOtherUserSession(params: { roleId: string, roleName?: string, blockType?: number, vipStartTime?: number}[]) {
try {
let sessionService = this.app.get('sessionService');
for(let {roleId, roleName, blockType, vipStartTime} of params) {
let sessions = sessionService.getByUid(roleId);
if(!!sessions) {
sessions.forEach(session => {
if(roleName) sessionService.aimportAll(session.id, { roleName });
if(blockType) sessionService.aimportAll(session.id, { blockType });
if(vipStartTime) sessionService.aimportAll(session.id, { vipStartTime });
});
}
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setPvpSettleSeasonNum(pvpConfig: PVPConfigType) {
try {
await setPvpSettleSeasonNum(pvpConfig);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的拍卖行时间
*/
async setDicAuctionTime(startTime: number, endActivity: number, startGuild: number, endGuild: number, startWorld: number, endWorld: number) {
try {
setDicAuctionTime(startTime, endActivity, startGuild, endGuild, startWorld, endWorld);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async setDay(week: number) {
try {
setWeek(week);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的军团活动开始时间&持续时间
* @param {number} aid 活动
* @param {number} startSeconds 从现在开始几秒后开启活动
* @param {number} endSeconds 从开始之后几秒后结束活动
*/
public async setDicGuildActivity(now: number, aid: number, startSeconds: number, endSeconds: number) {
try {
setDicGuildActivity(now, aid, startSeconds, endSeconds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async incServerNum(sid: string, inc: number) {
try {
incServerNum(sid, inc);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public savePvpSeasonMemory() {
try {
return savePvpSeasonMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,38 +1,39 @@
import { STATUS } from './../../../consts/statusCode';
import { dispatch } from '../../../pubUtils/dispatcher';
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { redisClient } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new GateHandler(app);
}
export class GateHandler {
constructor(private app: Application) {
}
/**
* Gate handler that dispatch user to connectors.
*
* @param {Object} msg message from client
* @param {Object} session
*
*/
async queryEntry(msg: { userCode: string }, session: BackendSession) {
let { userCode } = msg;
if (!userCode) {
return resResult(STATUS.WRONG_PARMS);
}
// get all connectors
let connectors = this.app.getServersByType('connector');
// console.log(connectors);
if (!connectors || connectors.length === 0) {
return resResult(STATUS.CONNECTOR_ERR);
}
// select connector
let res = await dispatch(redisClient(), userCode, connectors, 'connector');
return resResult(STATUS.SUCCESS, { host: res.clientHost, port: res.clientPort });
}
}
import { STATUS } from './../../../consts/statusCode';
import { dispatch } from '@pubUtils/dispatcher';
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { redisClient } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new GateHandler(app);
}
export class GateHandler {
constructor(private app: Application) {
}
/**
* Gate handler that dispatch user to connectors.
*
* @param {Object} msg message from client
* @param {Object} session
*
*/
async queryEntry(msg: { userCode: string }, session: BackendSession) {
let { userCode } = msg;
if (!userCode) {
return resResult(STATUS.WRONG_PARMS);
}
// get all connectors
let connectors = this.app.getServersByType('connector');
// console.log(connectors);
if (!connectors || connectors.length === 0) {
return resResult(STATUS.CONNECTOR_ERR);
}
// select connector
let res = await dispatch(redisClient(), userCode, connectors, 'connector');
return resResult(STATUS.SUCCESS, { host: res.clientHost, port: res.clientPort });
}
}

View File

@@ -1,16 +1,16 @@
import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, } from 'pinus';
export default function (app: Application) {
new HandlerService(app, {});
return new GateRemote(app);
}
export class GateRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
}
import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, } from 'pinus';
export default function (app: Application) {
new HandlerService(app, {});
return new GateRemote(app);
}
export class GateRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
}

View File

@@ -1,48 +1,49 @@
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback } from "pinus";
import { GM_API_TYPE, STATUS } from "../../../consts";
import { GMGroupModel } from "../../../db/GMGroup";
import { GMRecordModel } from "../../../db/GMRecord";
import { gameData } from "../../../pubUtils/data";
import { resResult } from "../../../pubUtils/util";
export function tokenFilter(app: Application) {
return new Filter(app);
}
var Filter = function(this: any, app: Application) {
this.app = app;
};
Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
const uid = session.get('uid');
const groupId = session.get('groupId');
let route = routeRecord.route;
// console.log('********uid', uid, route);
let dicApi = gameData.apiByUrl.get(route);
if(!dicApi) {
return next(new Error(), resResult(STATUS.GM_MISS_API));
}
let group = await GMGroupModel.getGroupById(groupId);
if(!group) {
return next(new Error(), resResult(STATUS.GM_NO_AUTHORITY_GET));
}
if(!group.apis.includes(0) && !group.apis.includes(dicApi.id)) {
return next(new Error(), resResult(STATUS.GM_NO_AUTHORITY_GET));
}
next(null);
};
Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
const uid = session.get('uid');
let route = routeRecord.route;
let dicApi = gameData.apiByUrl.get(route);
if(dicApi && dicApi.type != GM_API_TYPE.find) {
GMRecordModel.createRecord(uid, this.app.get('env'), route, JSON.stringify(msg||{}), JSON.stringify(resp||{}));
}
next(err);
};
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback } from "pinus";
import { GM_API_TYPE, STATUS } from "@consts";
import { GMGroupModel } from "@db/GMGroup";
import { GMRecordModel } from "@db/GMRecord";
import { gameData } from "@pubUtils/data";
import { resResult } from "@pubUtils/util";
export function tokenFilter(app: Application) {
return new Filter(app);
}
var Filter = function(this: any, app: Application) {
this.app = app;
};
Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
const uid = session.get('uid');
const groupId = session.get('groupId');
let route = routeRecord.route;
// console.log('********uid', uid, route);
let dicApi = gameData.apiByUrl.get(route);
if(!dicApi) {
return next(new Error(), resResult(STATUS.GM_MISS_API));
}
let group = await GMGroupModel.getGroupById(groupId);
if(!group) {
return next(new Error(), resResult(STATUS.GM_NO_AUTHORITY_GET));
}
if(!group.apis.includes(0) && !group.apis.includes(dicApi.id)) {
return next(new Error(), resResult(STATUS.GM_NO_AUTHORITY_GET));
}
next(null);
};
Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
const uid = session.get('uid');
let route = routeRecord.route;
let dicApi = gameData.apiByUrl.get(route);
if(dicApi && dicApi.type != GM_API_TYPE.find) {
GMRecordModel.createRecord(uid, this.app.get('env'), route, JSON.stringify(msg||{}), JSON.stringify(resp||{}));
}
next(err);
};

View File

@@ -1,357 +1,358 @@
import { Application, BackendSession, pinus } from 'pinus';
import { getRandSingleEelm, isTimestamp, resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { GMMailModel, GMMailType } from '../../../db/GMMail';
import { ACTIVITY_TYPE, GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE, MEMORY_LOG_TYPE, PUSH_ROUTE, SURVEY_SELECT } from '../../../consts';
import { ActivityModel } from '../../../db/Activity';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { ActivityGroupTypeModel } from '../../../db/ActivityGroupType';
import { getPastTime, getTimeFunM, nowSeconds } from '../../../pubUtils/timeUtil';
import moment = require('moment');
import { sendUngotDividend } from '../../../services/auctionService';
import { taflush } from '../../../services/sdkService';
import { ActivityInRemote } from '../../../domain/activityField/activityField';
import { pushCurrentTime } from '../../../services/auctionService';
import { SurveyModel, SurveyUpdate } from '../../../db/Survery';
import { compaireMailGoods, getSurvey } from '../../../services/gmService';
import { sendMessageToAllWithSuc } from '../../../services/pushService';
import { sendMailByContent, sendMailsByGmMail } from '../../../services/mailService';
import { saveMemory } from '../../../services/log/memoryLogService';
import { getGVGConfigFromRemote } from '../../../services/gvg/gvgService';
import { ServerGroupModel } from '../../../db/ServerGroup';
import { isNumber } from 'underscore';
import { group } from 'console';
import { GVGConfigModel } from '../../../db/GVGConfig';
import { ServerlistModel } from '../../../db/Serverlist';
import { getPvpTimeFromRemote } from '../../../services/pvpService';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmHandler(app);
}
export class GmHandler {
constructor(private app: Application) {
}
async sendSingleMail(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SINGLE, true);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
async sendSingleMailTxt(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SINGLE, false);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
async sendServerMail(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SERVER, true);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
async sendServerMailTxt(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SERVER, false);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
//对接gm后台下发邮件
async sendMail(gmmail: GMMailType, isPass: boolean, uid: number) {
let id = gmmail._id;
let { receivers, mailType, status, hasGoods, goods } = gmmail;
if(status != GM_MAIL_STATUS.CREATE) {
return resResult(STATUS.GM_MAIL_HAS_SENT);
}
if(isPass) {
let gmmailArr: GMMailType[] = [];
if(mailType == GM_MAIL_TYPE.SINGLE && hasGoods && (!goods || goods.length == 0)) {
for(let receiver of receivers) {
let index = gmmailArr.findIndex(gmmail => compaireMailGoods(gmmail, receiver));
if(index == -1) {
gmmailArr.push({...gmmail, receivers: [receiver], goods: receiver.rewards, hasGoods: receiver?receiver.rewards.length > 0: false });
} else {
gmmailArr[index].receivers.push(receiver);
}
}
} else {
gmmailArr.push(gmmail);
}
await sendMailsByGmMail(gmmailArr);
}
await GMMailModel.updateMailById(id, { status: isPass? GM_MAIL_STATUS.PASS: GM_MAIL_STATUS.NOT_PASS, viewAt: new Date(), viewBy: uid }, uid);
return resResult(STATUS.SUCCESS);
}
async reloadResource(msg: {}, session: BackendSession) {
try {
let activityServers = this.app.getServersByType('activity');
for (let { id } of activityServers) {
await this.app.rpc.activity.activityRemote.reloadResources.toServer(id);
}
let battleServers = this.app.getServersByType('battle');
for (let { id } of battleServers) {
await this.app.rpc.battle.battleRemote.reloadResources.toServer(id);
}
let comBattleServers = this.app.getServersByType('comBattle');
for (let { id } of comBattleServers) {
await this.app.rpc.comBattle.comBattleRemote.reloadResources.toServer(id);
}
let chatServers = this.app.getServersByType('chat');
for (let { id } of chatServers) {
await this.app.rpc.chat.chatRemote.reloadResources.toServer(id);
}
let connectServers = this.app.getServersByType('connector');
for (let { id } of connectServers) {
await this.app.rpc.connector.connectorRemote.reloadResources.toServer(id);
}
let guildServers = this.app.getServersByType('guild');
for (let { id } of guildServers) {
await this.app.rpc.guild.guildRemote.reloadResources.toServer(id);
}
let roleServers = this.app.getServersByType('role');
for (let { id } of roleServers) {
await this.app.rpc.role.roleRemote.reloadResources.toServer(id);
}
let systimerServers = this.app.getServersByType('systimer');
for (let { id } of systimerServers) {
await this.app.rpc.systimer.systimerRemote.reloadResources.toServer(id);
}
let orderServers = this.app.getServersByType('order');
for (let { id } of orderServers) {
await this.app.rpc.order.orderRemote.reloadResources.toServer(id);
}
return resResult(STATUS.SUCCESS, {
isOK: true
});
} catch (e) {
return resResult(STATUS.SUCCESS, {
isOK: false,
err: e.stack
});
}
}
async updateActivity(msg: { aids: number[] }, session: BackendSession) {
let { aids }= msg;
let activities = await ActivityModel.findActivityByIds(aids);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.updateActivities.toServer(server.id, activities.map(activity => new ActivityInRemote(activity)));
}
let timeLimitRanks = activities.filter(cur => cur.type == ACTIVITY_TYPE.TIME_LIMIT_RANK);
if(timeLimitRanks.length > 0) {
pinus.app.rpc.systimer.systimerRemote.updateTimeLimitRank.broadcast(timeLimitRanks);
}
let groupShops = activities.filter(cur => cur.type == ACTIVITY_TYPE.GROUP_SHOP);
if(groupShops.length > 0) {
pinus.app.rpc.systimer.systimerRemote.initSumSchedule.broadcast();
}
let signIns = activities.filter(cur => cur.type == ACTIVITY_TYPE.COMMON_SIGN_IN);
if(signIns.length > 0) {
pinus.app.rpc.systimer.systimerRemote.initVipSignInMailSchedule.broadcast();
}
return resResult(STATUS.SUCCESS, {
activity: activities
});
}
async deleteActivity(msg: { activityId: number}, session: BackendSession) {
const { activityId } = msg;
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.deleteActivities.toServer(server.id, [activityId]);
}
return resResult(STATUS.SUCCESS);
}
async updateActivityGroup(msg: { groupId: number, serverIds: number[], activityIds: number[] }, session: BackendSession) {
const uid = session.get('uid');
let { groupId, serverIds, activityIds } = msg;
pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.broadcast(groupId, activityIds);
pinus.app.rpc.activity.activityRemote.saveGroupToServer.broadcast([groupId], serverIds);
return resResult(STATUS.SUCCESS);
}
/**
* 开启军团活动到拍卖行debug
* @param msg
* @param session
*/
async setGuildActivityDebug(msg: { aid: number, day: number, startActivity: number, endActivity: number, startGuildAuction: number, endGuildAuction: number, startWorldAuction: number, endWorldAuction: number, startNextDay: number }, session: BackendSession) {
let { aid, day, startActivity = 0, endActivity = 0, startGuildAuction = 0, endGuildAuction = 0, startWorldAuction = 0, endWorldAuction = 0, startNextDay = 0 } = msg;
if(timer) {
clearTimeout(timer);
}
const uid = session.get('uid');
if(aid == undefined || day == undefined ) {
return resResult(STATUS.WRONG_PARMS);
}
if(aid == 0) {
day = new Date().getDay();
}
// 设置字典
let now = new Date();
let startTimes = await pinus.app.rpc.guild.guildActivityRemote.setDicGuildActivity.broadcast(now.getTime(), aid, startActivity, endActivity);
await pinus.app.rpc.systimer.systimerRemote.setDicGuildActivity.broadcast(now.getTime(), aid, startActivity, endActivity);
await pinus.app.rpc.connector.connectorRemote.setDicGuildActivity.broadcast(now.getTime(), aid, startActivity, endActivity);
await pinus.app.rpc.guild.guildActivityRemote.setDicAuctionTime.broadcast(startTimes[0], endActivity, startGuildAuction, endGuildAuction, startWorldAuction, endWorldAuction);
await pinus.app.rpc.connector.connectorRemote.setDicAuctionTime.broadcast(startTimes[0], endActivity, startGuildAuction, endGuildAuction, startWorldAuction, endWorldAuction);
await pinus.app.rpc.systimer.systimerRemote.setDicAuctionTime.broadcast(startTimes[0], endActivity, startGuildAuction, endGuildAuction, startWorldAuction, endWorldAuction);
await pinus.app.rpc.guild.guildActivityRemote.setDay.broadcast(day);
await pinus.app.rpc.systimer.systimerRemote.setDay.broadcast(day);
await pinus.app.rpc.connector.connectorRemote.setDay.broadcast(day);
await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(aid);
await pinus.app.rpc.guild.guildActivityRemote.clearActivityObj.broadcast();
// 开启定时器
await pinus.app.rpc.systimer.systimerRemote.setAuctionSchedule.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setGuildActivitySchedule.broadcast();
// 向客户端发送时间
let time = <number>getTimeFunM().getTimeWithWeek(day, 20, 0, 0) - startActivity * 1000;
pinus.app.rpc.guild.guildActivityRemote.setCurrentTime.broadcast(time);
await pushCurrentTime(time);
timer = setTimeout(async () => {
let time = <number>getTimeFunM().getAfterDayWithHour(0);
pinus.app.rpc.guild.guildActivityRemote.setCurrentTime.broadcast(time);
await pushCurrentTime(time);
let guilds = pinus.app.getServersByType('guild');
let guild = getRandSingleEelm(guilds);
await pinus.app.rpc.guild.guildActivityRemote.sendUngotDividend.toServer(guild.id);
}, startActivity * 1000 + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000 + endWorldAuction * 1000 + startNextDay * 1000)
return resResult(STATUS.SUCCESS, {
startActivity: startTimes[0],
endActivity: startTimes[0] + endActivity * 1000,
startGuildAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000,
endGuildAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000,
startWorldAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000,
endWorldAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000 + endWorldAuction * 1000,
startNextDay: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000 + endWorldAuction * 1000 + startNextDay * 1000,
});
}
async cancelGuildActivityDebug(msg: { }, session: BackendSession) {
// 设置字典
let now = new Date();
if(timer) {
clearTimeout(timer);
}
await pinus.app.rpc.guild.guildRemote.reloadResources.broadcast();
await pinus.app.rpc.systimer.systimerRemote.reloadResources.broadcast();
await pinus.app.rpc.guild.guildActivityRemote.setDay.broadcast(null);
await pinus.app.rpc.systimer.systimerRemote.setDay.broadcast(null);
await pinus.app.rpc.connector.connectorRemote.setDay.broadcast(null);
// 开启定时器
await pinus.app.rpc.systimer.systimerRemote.setAuctionSchedule.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setGuildActivitySchedule.broadcast();
await pinus.app.rpc.guild.guildActivityRemote.clearActivityObj.broadcast();
// 向客户端发送时间
pinus.app.rpc.guild.guildActivityRemote.setCurrentTime.broadcast(now.getTime());
await pushCurrentTime(now.getTime());
return resResult(STATUS.SUCCESS);
}
async taflus() {
taflush();
pinus.app.rpc.activity.activityRemote.taflush.broadcast();
pinus.app.rpc.battle.battleRemote.taflush.broadcast();
pinus.app.rpc.chat.chatRemote.taflush.broadcast();
pinus.app.rpc.connector.connectorRemote.taflush.broadcast();
pinus.app.rpc.guild.guildRemote.taflush.broadcast();
pinus.app.rpc.order.orderRemote.taflush.broadcast();
pinus.app.rpc.role.roleRemote.taflush.broadcast();
pinus.app.rpc.systimer.systimerRemote.taflush.broadcast();
return resResult(STATUS.SUCCESS);
}
async updateSurvey(msg: { code: string, surveyId: string, beginTim: number, endTime: number, isEnable: boolean, surveyLink: string, surveyName: string, roleIndex: number, goods: string, mailContent: string }, session: BackendSession) {
let update: SurveyUpdate = msg;
if(msg.goods) {
let reward = JSON.parse(msg.goods);
update.reward = reward;
}
let origin = await SurveyModel.findByCode(msg.code);
let result = await SurveyModel.updateSurvey(msg.code, update, SURVEY_SELECT.FIND);
if(!result) return resResult(STATUS.WRONG_PARMS);
if(origin && origin.isEnable != result.isEnable) {
await sendMessageToAllWithSuc(PUSH_ROUTE.UPDATE_SURVEY, { survey: result });
}
return resResult(STATUS.SUCCESS);
}
async deleteSurvey(msg: { code: string }, session: BackendSession) {
let { code } = msg;
await SurveyModel.deleteSurvey(code);
await sendMessageToAllWithSuc(PUSH_ROUTE.DELETE_SURVEY, { code });
return resResult(STATUS.SUCCESS);
}
async saveMemoryLog(msg: { memoryLogType: MEMORY_LOG_TYPE }, session: BackendSession) {
const { memoryLogType } = msg;
await saveMemory(memoryLogType);
return resResult(STATUS.SUCCESS);
}
async updateGVGServerGroup(msg: { serverId: number[], groupId: number }, session: BackendSession) {
const { serverId: serverIds, groupId } = msg;
if(!isNumber(groupId)) return resResult(STATUS.WRONG_PARMS);
for(let serverId of serverIds) {
if(!isNumber(serverId)) return resResult(STATUS.WRONG_PARMS);
}
let { scheduleTime } = await getGVGConfigFromRemote();
let { seasonNum, seasonEndTime } = await getPvpTimeFromRemote();
for(let serverId of serverIds) {
await ServerGroupModel.updateByServerId(serverId, groupId, scheduleTime, seasonNum == 0? getPastTime(): seasonEndTime);
}
try {
await pinus.app.rpc.guild.guildRemote.setServerGroup.broadcast();
await pinus.app.rpc.chat.chatRemote.setServerGroup.broadcast();
await pinus.app.rpc.connector.connectorRemote.setServerGroup.broadcast();
await pinus.app.rpc.gm.gmRemote.setServerGroup.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setServerGroup.broadcast();
await pinus.app.rpc.battle.battleRemote.setServerGroup.broadcast();
} catch(e) {
console.log('remote未初始完');
}
return resResult(STATUS.SUCCESS);
}
async updateGVGConfig(msg: { configId: number, teamTime: number, prepareTime: number, battleTime: number, scheduleTime: number }, session: BackendSession) {
const { configId, teamTime, prepareTime, battleTime, scheduleTime } = msg;
if(!isNumber(configId) || !isTimestamp(teamTime) || !isTimestamp(prepareTime) || !isTimestamp(battleTime) || !isTimestamp(scheduleTime)) {
return resResult(STATUS.WRONG_PARMS);
}
if(teamTime > prepareTime || prepareTime > battleTime || battleTime > scheduleTime) {
return resResult(STATUS.GM_GVG_TIME_ERR);
}
const config = await GVGConfigModel.updateConfig(configId, teamTime, prepareTime, battleTime, scheduleTime);
await pinus.app.rpc.guild.guildRemote.setGVGConfig.broadcast(config);
await pinus.app.rpc.systimer.systimerRemote.initGVGConfigSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, pinus } from 'pinus';
import { getRandSingleEelm, isTimestamp, resResult } from '@pubUtils/util';
import { STATUS } from '@consts/statusCode';
import { GMMailModel, GMMailType } from '@db/GMMail';
import { ACTIVITY_TYPE, GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE, MEMORY_LOG_TYPE, PUSH_ROUTE, SURVEY_SELECT } from '../../../consts';
import { ActivityModel } from '@db/Activity';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { ActivityGroupTypeModel } from '@db/ActivityGroupType';
import { getPastTime, getTimeFunM, nowSeconds } from '@pubUtils/timeUtil';
import moment = require('moment');
import { sendUngotDividend } from '../../../services/auctionService';
import { taflush } from '../../../services/sdkService';
import { ActivityInRemote } from '@domain/activityField/activityField';
import { pushCurrentTime } from '../../../services/auctionService';
import { SurveyModel, SurveyUpdate } from '@db/Survery';
import { compaireMailGoods, getSurvey } from '../../../services/gmService';
import { sendMessageToAllWithSuc } from '../../../services/pushService';
import { sendMailByContent, sendMailsByGmMail } from '../../../services/mailService';
import { saveMemory } from '../../../services/log/memoryLogService';
import { getGVGConfigFromRemote } from '../../../services/gvg/gvgService';
import { ServerGroupModel } from '@db/ServerGroup';
import { isNumber } from 'underscore';
import { group } from 'console';
import { GVGConfigModel } from '@db/GVGConfig';
import { ServerlistModel } from '@db/Serverlist';
import { getPvpTimeFromRemote } from '../../../services/pvpService';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmHandler(app);
}
export class GmHandler {
constructor(private app: Application) {
}
async sendSingleMail(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SINGLE, true);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
async sendSingleMailTxt(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SINGLE, false);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
async sendServerMail(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SERVER, true);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
async sendServerMailTxt(msg: { id: string, isPass: boolean }, session: BackendSession) {
const uid: number = session.get('uid')
let { id, isPass } = msg;
let gmmail = await GMMailModel.getGmMailByIdAndType(id, GM_MAIL_TYPE.SERVER, false);
if(!gmmail) return resResult(STATUS.GM_MAIL_NOT_FOUND);
return await this.sendMail(gmmail, isPass, uid);
}
//对接gm后台下发邮件
async sendMail(gmmail: GMMailType, isPass: boolean, uid: number) {
let id = gmmail._id;
let { receivers, mailType, status, hasGoods, goods } = gmmail;
if(status != GM_MAIL_STATUS.CREATE) {
return resResult(STATUS.GM_MAIL_HAS_SENT);
}
if(isPass) {
let gmmailArr: GMMailType[] = [];
if(mailType == GM_MAIL_TYPE.SINGLE && hasGoods && (!goods || goods.length == 0)) {
for(let receiver of receivers) {
let index = gmmailArr.findIndex(gmmail => compaireMailGoods(gmmail, receiver));
if(index == -1) {
gmmailArr.push({...gmmail, receivers: [receiver], goods: receiver.rewards, hasGoods: receiver?receiver.rewards.length > 0: false });
} else {
gmmailArr[index].receivers.push(receiver);
}
}
} else {
gmmailArr.push(gmmail);
}
await sendMailsByGmMail(gmmailArr);
}
await GMMailModel.updateMailById(id, { status: isPass? GM_MAIL_STATUS.PASS: GM_MAIL_STATUS.NOT_PASS, viewAt: new Date(), viewBy: uid }, uid);
return resResult(STATUS.SUCCESS);
}
async reloadResource(msg: {}, session: BackendSession) {
try {
let activityServers = this.app.getServersByType('activity');
for (let { id } of activityServers) {
await this.app.rpc.activity.activityRemote.reloadResources.toServer(id);
}
let battleServers = this.app.getServersByType('battle');
for (let { id } of battleServers) {
await this.app.rpc.battle.battleRemote.reloadResources.toServer(id);
}
let comBattleServers = this.app.getServersByType('comBattle');
for (let { id } of comBattleServers) {
await this.app.rpc.comBattle.comBattleRemote.reloadResources.toServer(id);
}
let chatServers = this.app.getServersByType('chat');
for (let { id } of chatServers) {
await this.app.rpc.chat.chatRemote.reloadResources.toServer(id);
}
let connectServers = this.app.getServersByType('connector');
for (let { id } of connectServers) {
await this.app.rpc.connector.connectorRemote.reloadResources.toServer(id);
}
let guildServers = this.app.getServersByType('guild');
for (let { id } of guildServers) {
await this.app.rpc.guild.guildRemote.reloadResources.toServer(id);
}
let roleServers = this.app.getServersByType('role');
for (let { id } of roleServers) {
await this.app.rpc.role.roleRemote.reloadResources.toServer(id);
}
let systimerServers = this.app.getServersByType('systimer');
for (let { id } of systimerServers) {
await this.app.rpc.systimer.systimerRemote.reloadResources.toServer(id);
}
let orderServers = this.app.getServersByType('order');
for (let { id } of orderServers) {
await this.app.rpc.order.orderRemote.reloadResources.toServer(id);
}
return resResult(STATUS.SUCCESS, {
isOK: true
});
} catch (e) {
return resResult(STATUS.SUCCESS, {
isOK: false,
err: e.stack
});
}
}
async updateActivity(msg: { aids: number[] }, session: BackendSession) {
let { aids }= msg;
let activities = await ActivityModel.findActivityByIds(aids);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.updateActivities.toServer(server.id, activities.map(activity => new ActivityInRemote(activity)));
}
let timeLimitRanks = activities.filter(cur => cur.type == ACTIVITY_TYPE.TIME_LIMIT_RANK);
if(timeLimitRanks.length > 0) {
pinus.app.rpc.systimer.systimerRemote.updateTimeLimitRank.broadcast(timeLimitRanks);
}
let groupShops = activities.filter(cur => cur.type == ACTIVITY_TYPE.GROUP_SHOP);
if(groupShops.length > 0) {
pinus.app.rpc.systimer.systimerRemote.initSumSchedule.broadcast();
}
let signIns = activities.filter(cur => cur.type == ACTIVITY_TYPE.COMMON_SIGN_IN);
if(signIns.length > 0) {
pinus.app.rpc.systimer.systimerRemote.initVipSignInMailSchedule.broadcast();
}
return resResult(STATUS.SUCCESS, {
activity: activities
});
}
async deleteActivity(msg: { activityId: number}, session: BackendSession) {
const { activityId } = msg;
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.deleteActivities.toServer(server.id, [activityId]);
}
return resResult(STATUS.SUCCESS);
}
async updateActivityGroup(msg: { groupId: number, serverIds: number[], activityIds: number[] }, session: BackendSession) {
const uid = session.get('uid');
let { groupId, serverIds, activityIds } = msg;
pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.broadcast(groupId, activityIds);
pinus.app.rpc.activity.activityRemote.saveGroupToServer.broadcast([groupId], serverIds);
return resResult(STATUS.SUCCESS);
}
/**
* 开启军团活动到拍卖行debug
* @param msg
* @param session
*/
async setGuildActivityDebug(msg: { aid: number, day: number, startActivity: number, endActivity: number, startGuildAuction: number, endGuildAuction: number, startWorldAuction: number, endWorldAuction: number, startNextDay: number }, session: BackendSession) {
let { aid, day, startActivity = 0, endActivity = 0, startGuildAuction = 0, endGuildAuction = 0, startWorldAuction = 0, endWorldAuction = 0, startNextDay = 0 } = msg;
if(timer) {
clearTimeout(timer);
}
const uid = session.get('uid');
if(aid == undefined || day == undefined ) {
return resResult(STATUS.WRONG_PARMS);
}
if(aid == 0) {
day = new Date().getDay();
}
// 设置字典
let now = new Date();
let startTimes = await pinus.app.rpc.guild.guildActivityRemote.setDicGuildActivity.broadcast(now.getTime(), aid, startActivity, endActivity);
await pinus.app.rpc.systimer.systimerRemote.setDicGuildActivity.broadcast(now.getTime(), aid, startActivity, endActivity);
await pinus.app.rpc.connector.connectorRemote.setDicGuildActivity.broadcast(now.getTime(), aid, startActivity, endActivity);
await pinus.app.rpc.guild.guildActivityRemote.setDicAuctionTime.broadcast(startTimes[0], endActivity, startGuildAuction, endGuildAuction, startWorldAuction, endWorldAuction);
await pinus.app.rpc.connector.connectorRemote.setDicAuctionTime.broadcast(startTimes[0], endActivity, startGuildAuction, endGuildAuction, startWorldAuction, endWorldAuction);
await pinus.app.rpc.systimer.systimerRemote.setDicAuctionTime.broadcast(startTimes[0], endActivity, startGuildAuction, endGuildAuction, startWorldAuction, endWorldAuction);
await pinus.app.rpc.guild.guildActivityRemote.setDay.broadcast(day);
await pinus.app.rpc.systimer.systimerRemote.setDay.broadcast(day);
await pinus.app.rpc.connector.connectorRemote.setDay.broadcast(day);
await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(aid);
await pinus.app.rpc.guild.guildActivityRemote.clearActivityObj.broadcast();
// 开启定时器
await pinus.app.rpc.systimer.systimerRemote.setAuctionSchedule.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setGuildActivitySchedule.broadcast();
// 向客户端发送时间
let time = <number>getTimeFunM().getTimeWithWeek(day, 20, 0, 0) - startActivity * 1000;
pinus.app.rpc.guild.guildActivityRemote.setCurrentTime.broadcast(time);
await pushCurrentTime(time);
timer = setTimeout(async () => {
let time = <number>getTimeFunM().getAfterDayWithHour(0);
pinus.app.rpc.guild.guildActivityRemote.setCurrentTime.broadcast(time);
await pushCurrentTime(time);
let guilds = pinus.app.getServersByType('guild');
let guild = getRandSingleEelm(guilds);
await pinus.app.rpc.guild.guildActivityRemote.sendUngotDividend.toServer(guild.id);
}, startActivity * 1000 + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000 + endWorldAuction * 1000 + startNextDay * 1000)
return resResult(STATUS.SUCCESS, {
startActivity: startTimes[0],
endActivity: startTimes[0] + endActivity * 1000,
startGuildAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000,
endGuildAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000,
startWorldAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000,
endWorldAuction: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000 + endWorldAuction * 1000,
startNextDay: startTimes[0] + endActivity * 1000 + startGuildAuction * 1000 + endGuildAuction * 1000 + startWorldAuction * 1000 + endWorldAuction * 1000 + startNextDay * 1000,
});
}
async cancelGuildActivityDebug(msg: { }, session: BackendSession) {
// 设置字典
let now = new Date();
if(timer) {
clearTimeout(timer);
}
await pinus.app.rpc.guild.guildRemote.reloadResources.broadcast();
await pinus.app.rpc.systimer.systimerRemote.reloadResources.broadcast();
await pinus.app.rpc.guild.guildActivityRemote.setDay.broadcast(null);
await pinus.app.rpc.systimer.systimerRemote.setDay.broadcast(null);
await pinus.app.rpc.connector.connectorRemote.setDay.broadcast(null);
// 开启定时器
await pinus.app.rpc.systimer.systimerRemote.setAuctionSchedule.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setGuildActivitySchedule.broadcast();
await pinus.app.rpc.guild.guildActivityRemote.clearActivityObj.broadcast();
// 向客户端发送时间
pinus.app.rpc.guild.guildActivityRemote.setCurrentTime.broadcast(now.getTime());
await pushCurrentTime(now.getTime());
return resResult(STATUS.SUCCESS);
}
async taflus() {
taflush();
pinus.app.rpc.activity.activityRemote.taflush.broadcast();
pinus.app.rpc.battle.battleRemote.taflush.broadcast();
pinus.app.rpc.chat.chatRemote.taflush.broadcast();
pinus.app.rpc.connector.connectorRemote.taflush.broadcast();
pinus.app.rpc.guild.guildRemote.taflush.broadcast();
pinus.app.rpc.order.orderRemote.taflush.broadcast();
pinus.app.rpc.role.roleRemote.taflush.broadcast();
pinus.app.rpc.systimer.systimerRemote.taflush.broadcast();
return resResult(STATUS.SUCCESS);
}
async updateSurvey(msg: { code: string, surveyId: string, beginTim: number, endTime: number, isEnable: boolean, surveyLink: string, surveyName: string, roleIndex: number, goods: string, mailContent: string }, session: BackendSession) {
let update: SurveyUpdate = msg;
if(msg.goods) {
let reward = JSON.parse(msg.goods);
update.reward = reward;
}
let origin = await SurveyModel.findByCode(msg.code);
let result = await SurveyModel.updateSurvey(msg.code, update, SURVEY_SELECT.FIND);
if(!result) return resResult(STATUS.WRONG_PARMS);
if(origin && origin.isEnable != result.isEnable) {
await sendMessageToAllWithSuc(PUSH_ROUTE.UPDATE_SURVEY, { survey: result });
}
return resResult(STATUS.SUCCESS);
}
async deleteSurvey(msg: { code: string }, session: BackendSession) {
let { code } = msg;
await SurveyModel.deleteSurvey(code);
await sendMessageToAllWithSuc(PUSH_ROUTE.DELETE_SURVEY, { code });
return resResult(STATUS.SUCCESS);
}
async saveMemoryLog(msg: { memoryLogType: MEMORY_LOG_TYPE }, session: BackendSession) {
const { memoryLogType } = msg;
await saveMemory(memoryLogType);
return resResult(STATUS.SUCCESS);
}
async updateGVGServerGroup(msg: { serverId: number[], groupId: number }, session: BackendSession) {
const { serverId: serverIds, groupId } = msg;
if(!isNumber(groupId)) return resResult(STATUS.WRONG_PARMS);
for(let serverId of serverIds) {
if(!isNumber(serverId)) return resResult(STATUS.WRONG_PARMS);
}
let { scheduleTime } = await getGVGConfigFromRemote();
let { seasonNum, seasonEndTime } = await getPvpTimeFromRemote();
for(let serverId of serverIds) {
await ServerGroupModel.updateByServerId(serverId, groupId, scheduleTime, seasonNum == 0? getPastTime(): seasonEndTime);
}
try {
await pinus.app.rpc.guild.guildRemote.setServerGroup.broadcast();
await pinus.app.rpc.chat.chatRemote.setServerGroup.broadcast();
await pinus.app.rpc.connector.connectorRemote.setServerGroup.broadcast();
await pinus.app.rpc.gm.gmRemote.setServerGroup.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setServerGroup.broadcast();
await pinus.app.rpc.battle.battleRemote.setServerGroup.broadcast();
} catch(e) {
console.log('remote未初始完');
}
return resResult(STATUS.SUCCESS);
}
async updateGVGConfig(msg: { configId: number, teamTime: number, prepareTime: number, battleTime: number, scheduleTime: number }, session: BackendSession) {
const { configId, teamTime, prepareTime, battleTime, scheduleTime } = msg;
if(!isNumber(configId) || !isTimestamp(teamTime) || !isTimestamp(prepareTime) || !isTimestamp(battleTime) || !isTimestamp(scheduleTime)) {
return resResult(STATUS.WRONG_PARMS);
}
if(teamTime > prepareTime || prepareTime > battleTime || battleTime > scheduleTime) {
return resResult(STATUS.GM_GVG_TIME_ERR);
}
const config = await GVGConfigModel.updateConfig(configId, teamTime, prepareTime, battleTime, scheduleTime);
await pinus.app.rpc.guild.guildRemote.setGVGConfig.broadcast(config);
await pinus.app.rpc.systimer.systimerRemote.initGVGConfigSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,182 +1,183 @@
import { Application, BackendSession, pinus } from 'pinus';
import { genCode, getRandSingleEelm, resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { ORDER_STATE, PAY_TYPE } from '../../../consts';
import _ = require('underscore');
import { dicRMB } from '../../../pubUtils/dictionary/DicRMB';
import { getActivityById } from '../../../services/activity/activityService';
import { UserOrderModel } from '../../../db/UserOrder';
import { settleOrder, settleOrderAli, settleOrderFromHandler, settleOrderWx } from '../../../services/orderService';
import { getActivityProducts, getParamStr } from '../../../services/gmService';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { Receiver } from '../../../db/GMMail';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { RoleModel } from '../../../db/Role';
export interface Cascader {
value: number|string;
label: number|string;
children?: Cascader[];
}
export default function (app: Application) {
return new GmOrderHandler(app);
}
export class GmOrderHandler {
constructor(private app: Application) {
}
async getActivitiesCanBuy(msg: { serverId: number }, session: BackendSession) {
const { serverId } = msg;
let groups = await ActivityGroupModel.findByServerId(serverId);
let result: Cascader[] = [];
for (let groupData of groups) {
let activities: Cascader[] = [];
for (let activityId of groupData.activities) {
let activityData = await getActivityById(activityId);
if(!activityData) continue;
let products = getActivityProducts(activityData);
if(products) {
let children = products.filter(cur => !!cur);
if(children.length > 0) {
activities.push({
value: activityData.activityId,
label: activityData.name,
children
});
}
}
}
if(activities.length > 0) {
result.push({
value: groupData.groupId,
label: groupData.groupName,
children: activities
});
}
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 虚拟充值
* @param {BackendSession} session
* @memberof orderHandler
*/
async applyOrder(msg: { serverId: number, activityId: (number|string)[], receiver: Receiver[] }, session: BackendSession) {
const { activityId: activityIds, receiver } = msg;
let activityId = <number>activityIds[1];
let productID = <string>activityIds[2];
let payType = PAY_TYPE.TEST
//如果有特殊情况activityId可为0
if (!productID || !_.isString(productID)) {
return resResult(STATUS.WRONG_PARMS);
}
//商品价格信息
let productInfo = dicRMB.get(productID)
if (!productInfo) {
console.log('productID', productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let price = productInfo.price;//价格
let productType = productInfo.type;//类型
let message = productInfo.message;//商品信息
let localOrderID = genCode(32);//本地订单号
let orderID = '';//平台订单号
let sdkOrderInfo = null;//客户端需要的平台订单信息
let activityData = await getActivityById(activityId);
if (!activityData) return resResult(STATUS.ACTIVITY_MISSING);
let results = [];
for(let { roleId, serverId } of receiver) {
let role = await RoleModel.findByRoleId(roleId);
if(!role && role.serverId != serverId) {
results.push(resResult(STATUS.ROLE_NOT_FOUND));
continue;
}
let paramStr = await getParamStr(activityData, productID, role);
let orderInfo = await UserOrderModel.applyOrder(serverId, roleId, productID, localOrderID, orderID, price, payType, activityId, paramStr, message, false, 0);
//订单成功
if(!orderInfo) {
results.push(resResult(STATUS.NO_ORDER));
continue;
}
let onlineUser = await getRoleOnlineInfo(roleId);
let result = await settleOrder(orderInfo, serverId, onlineUser?.sid);
orderInfo = await UserOrderModel.success(roleId, localOrderID, JSON.stringify(result));
console.log(`测试支付完成!!!!!!!!!!!!! serverId:${serverId}, productID:${productID}, productType:${productType}, roleId:${roleId}, localOrderID:${localOrderID}, payType:${payType}`)
results.push(resResult(STATUS.SUCCESS));
}
let findResultErrCode = results.find(cur => cur.code != 0);
if(!findResultErrCode) {
return resResult(STATUS.SUCCESS);
} else {
return findResultErrCode;
}
}
/**
* @description 补单
* @param {BackendSession} session
* @memberof orderHandler
*/
async reCallOrder(msg: { localOrderID: string }, session: BackendSession) {
let sid = session.get('sid');
const { localOrderID } = msg;
if (!localOrderID || !_.isString(localOrderID)) {
return resResult(STATUS.WRONG_PARMS);
}
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo) {
return resResult(STATUS.NO_ORDER);
}
if(orderInfo.state == ORDER_STATE.RESULT_SUCCESS) {
return resResult(STATUS.DUPLICATE_ORDER);
}
//商品价格信息
let productInfo = dicRMB.get(orderInfo.productID)
if (!productInfo) {
console.log(orderInfo.productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let order = await UserOrderModel.findOrder(localOrderID);
let result = await settleOrder(order, order.serverId, sid);
await UserOrderModel.saveOrderID(order.roleId, order.localOrderID, '', JSON.stringify(result));
orderInfo = await UserOrderModel.findOrder(localOrderID);
//订单成功
console.log('结算完成', localOrderID)
let res: any = {};
try {
res = orderInfo.rewardResult? JSON.parse(orderInfo.rewardResult): {};
} catch(e) {
console.log('order rewardResult', e);
}
if(res.code && res.code != 0) {
return resResult(STATUS.APPLY_ORDER_ERROR);
}
return resResult(STATUS.SUCCESS, {
...res,
price: orderInfo.price,
state: orderInfo.state,
localOrderID: orderInfo.localOrderID
});
}
}
import { Application, BackendSession, pinus } from 'pinus';
import { genCode, getRandSingleEelm, resResult } from '@pubUtils/util';
import { STATUS } from '@consts/statusCode';
import { ORDER_STATE, PAY_TYPE } from '../../../consts';
import _ = require('underscore');
import { dicRMB } from '@pubUtils/dictionary/DicRMB';
import { getActivityById } from '../../../services/activity/activityService';
import { UserOrderModel } from '@db/UserOrder';
import { settleOrder, settleOrderAli, settleOrderFromHandler, settleOrderWx } from '../../../services/orderService';
import { getActivityProducts, getParamStr } from '../../../services/gmService';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { Receiver } from '@db/GMMail';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { RoleModel } from '@db/Role';
export interface Cascader {
value: number|string;
label: number|string;
children?: Cascader[];
}
export default function (app: Application) {
return new GmOrderHandler(app);
}
export class GmOrderHandler {
constructor(private app: Application) {
}
async getActivitiesCanBuy(msg: { serverId: number }, session: BackendSession) {
const { serverId } = msg;
let groups = await ActivityGroupModel.findByServerId(serverId);
let result: Cascader[] = [];
for (let groupData of groups) {
let activities: Cascader[] = [];
for (let activityId of groupData.activities) {
let activityData = await getActivityById(activityId);
if(!activityData) continue;
let products = getActivityProducts(activityData);
if(products) {
let children = products.filter(cur => !!cur);
if(children.length > 0) {
activities.push({
value: activityData.activityId,
label: activityData.name,
children
});
}
}
}
if(activities.length > 0) {
result.push({
value: groupData.groupId,
label: groupData.groupName,
children: activities
});
}
}
return resResult(STATUS.SUCCESS, result);
}
/**
* @description 虚拟充值
* @param {BackendSession} session
* @memberof orderHandler
*/
async applyOrder(msg: { serverId: number, activityId: (number|string)[], receiver: Receiver[] }, session: BackendSession) {
const { activityId: activityIds, receiver } = msg;
let activityId = <number>activityIds[1];
let productID = <string>activityIds[2];
let payType = PAY_TYPE.TEST
//如果有特殊情况activityId可为0
if (!productID || !_.isString(productID)) {
return resResult(STATUS.WRONG_PARMS);
}
//商品价格信息
let productInfo = dicRMB.get(productID)
if (!productInfo) {
console.log('productID', productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let price = productInfo.price;//价格
let productType = productInfo.type;//类型
let message = productInfo.message;//商品信息
let localOrderID = genCode(32);//本地订单号
let orderID = '';//平台订单号
let sdkOrderInfo = null;//客户端需要的平台订单信息
let activityData = await getActivityById(activityId);
if (!activityData) return resResult(STATUS.ACTIVITY_MISSING);
let results = [];
for(let { roleId, serverId } of receiver) {
let role = await RoleModel.findByRoleId(roleId);
if(!role && role.serverId != serverId) {
results.push(resResult(STATUS.ROLE_NOT_FOUND));
continue;
}
let paramStr = await getParamStr(activityData, productID, role);
let orderInfo = await UserOrderModel.applyOrder(serverId, roleId, productID, localOrderID, orderID, price, payType, activityId, paramStr, message, false, 0);
//订单成功
if(!orderInfo) {
results.push(resResult(STATUS.NO_ORDER));
continue;
}
let onlineUser = await getRoleOnlineInfo(roleId);
let result = await settleOrder(orderInfo, serverId, onlineUser?.sid);
orderInfo = await UserOrderModel.success(roleId, localOrderID, JSON.stringify(result));
console.log(`测试支付完成!!!!!!!!!!!!! serverId:${serverId}, productID:${productID}, productType:${productType}, roleId:${roleId}, localOrderID:${localOrderID}, payType:${payType}`)
results.push(resResult(STATUS.SUCCESS));
}
let findResultErrCode = results.find(cur => cur.code != 0);
if(!findResultErrCode) {
return resResult(STATUS.SUCCESS);
} else {
return findResultErrCode;
}
}
/**
* @description 补单
* @param {BackendSession} session
* @memberof orderHandler
*/
async reCallOrder(msg: { localOrderID: string }, session: BackendSession) {
let sid = session.get('sid');
const { localOrderID } = msg;
if (!localOrderID || !_.isString(localOrderID)) {
return resResult(STATUS.WRONG_PARMS);
}
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo) {
return resResult(STATUS.NO_ORDER);
}
if(orderInfo.state == ORDER_STATE.RESULT_SUCCESS) {
return resResult(STATUS.DUPLICATE_ORDER);
}
//商品价格信息
let productInfo = dicRMB.get(orderInfo.productID)
if (!productInfo) {
console.log(orderInfo.productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let order = await UserOrderModel.findOrder(localOrderID);
let result = await settleOrder(order, order.serverId, sid);
await UserOrderModel.saveOrderID(order.roleId, order.localOrderID, '', JSON.stringify(result));
orderInfo = await UserOrderModel.findOrder(localOrderID);
//订单成功
console.log('结算完成', localOrderID)
let res: any = {};
try {
res = orderInfo.rewardResult? JSON.parse(orderInfo.rewardResult): {};
} catch(e) {
console.log('order rewardResult', e);
}
if(res.code && res.code != 0) {
return resResult(STATUS.APPLY_ORDER_ERROR);
}
return resResult(STATUS.SUCCESS, {
...res,
price: orderInfo.price,
state: orderInfo.state,
localOrderID: orderInfo.localOrderID
});
}
}

View File

@@ -1,437 +1,438 @@
import { Application, BackendSession, pinus } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { getRoleOnlineInfo, redisClient, updateUserInfo } from '../../../services/redisService';
import { addItems } from '../../../services/role/rewardService';
import { RewardInter } from '../../../pubUtils/interface';
import { gameData, getExpByLv, getHeroExpByLv, getHeroLvByExp, getLvByExp, getEquipByJobClassAndEPlace } from '../../../pubUtils/data';
import { RoleModel, RoleType, WarStar } from '../../../db/Role';
import { BLOCK_TYPE, DEFAULT_HEROES, GUILD_AUTH, GUILD_DISMISS_WAY, GUILD_JOB, GUILD_MASTER_CHANGE_WAY, GUILD_STATUS, GUILD_STRUCTURE, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, MAIL_TYPE, MEMORY_LOG_TYPE, PUSH_ROUTE, REDIS_KEY, TA_EVENT, WAR_TYPE } from '../../../consts';
import { GuildFormParam, SetHeroParam } from '../../../domain/backEndField/params';
import { GuildModel, GuildUpdateParam } from '../../../db/Guild';
import { Rank } from '../../../services/rankService';
import { UserGuildModel } from '../../../db/UserGuild';
import { UserGuildApplyModel } from '../../../db/UserGuildApply';
import { reportTAEvent } from '../../../services/sdkService';
import { sendMailByContent } from '../../../services/mailService';
import { GuildLeader } from '../../../domain/rank';
import { HeroModel } from '../../../db/Hero';
import { SkinModel } from '../../../db/Skin';
import { PvpDefenseModel } from '../../../db/PvpDefense';
import { createHeroes } from '../../../services/role/createHero';
import { calculateCeWithHero, calculateCeWithRole } from '../../../services/playerCeService';
import { pushChangeGuildLeader, pushGuildDismiss, pushGuildInfoUpdate } from '../../../services/guildService';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
import { RScriptRecordModel } from '../../../db/RScriptRecord';
import { DicWar } from '../../../pubUtils/dictionary/DicWar';
import { SchoolModel } from '../../../db/School';
import { JewelModel } from '../../../db/Jewel';
import { RoleCeModel } from '../../../db/RoleCe';
import { setTrainLv } from '../../../services/gmService';
import { ArtifactModel } from '../../../db/Artifact';
import { roleLeave } from '../../../services/redisService';
import { KeyName } from '../../../domain/rank';
import { LadderMatchModel } from '../../../db/LadderMatch';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmRoleHandler(app);
}
export class GmRoleHandler {
constructor(private app: Application) {
}
async addItems(msg: { roleId: string, roleName: string, serverId: number, values: { reward: RewardInter[], heroes: number[], lv: number, expInc: number, fixedIpLocation: string }}, session: BackendSession) {
let { roleId, roleName, serverId, values } = msg;
let { reward, heroes, lv, expInc = 0, fixedIpLocation } = values;
let connect = await getRoleOnlineInfo(roleId);
let sid = connect.isOnline?connect.sid: null;
if(reward &&reward.length > 0) {
await addItems(roleId, roleName, sid, values.reward, ITEM_CHANGE_REASON.DEBUG);
}
if(heroes && heroes.length > 0) {
await createHeroes(roleId, roleName, sid, serverId, heroes.map(hid => { return { hid, count: 1 }}))
}
if(lv && lv > 0) {
let exp = getExpByLv(lv - 1)?.sum||0;
exp += expInc;
let newLv = getLvByExp(exp);
let role = await RoleModel.updateRoleInfo(roleId, { lv: newLv, exp })
let r = new Rank(REDIS_KEY.USER_LV, { serverId: serverId });
await r.setRankWithRoleInfo(roleId, newLv, Date.now(), role);
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PLAYER_EXP_CHANGE, {
isLvUp: false, lv: newLv, exp
}, sid);
}
if(fixedIpLocation != undefined) {
await RoleModel.updateRoleInfo(roleId, { fixedIpLocation })
}
return resResult(STATUS.SUCCESS);
}
async handleBlock(msg: { roleId: string, blockType: BLOCK_TYPE, blockReason: string }, session: BackendSession) {
let { roleId, blockType, blockReason } = msg;
if(roleId == undefined || blockType == undefined || blockReason == undefined) return resResult(STATUS.WRONG_PARMS);
let role = await RoleModel.updateRoleInfo(roleId, { blockType, blockReason });
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let { isOnline, sid } = await getRoleOnlineInfo(roleId);
if(isOnline) {
await this.app.rpc.connector.connectorRemote.setOtherUserSession.toServer(sid,[{ roleId, blockType }]);
if(blockType == BLOCK_TYPE.BLOCK) { // 踢走
await this.app.rpc.connector.connectorRemote.remoteLogin.toServer(sid, roleId, STATUS.BLOCKED);
await roleLeave(roleId);
}
}
return resResult(STATUS.SUCCESS);
}
async setHero(msg: { roleId: string, hid: number, param: SetHeroParam }, session: BackendSession) {
let { roleId, hid } = msg;
let param = new SetHeroParam(msg.param);
if(!param.checkParams()) return resResult(STATUS.WRONG_PARMS);
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if(!hero) return resResult(STATUS.HERO_NOT_FIND);
let { sid } = await getRoleOnlineInfo(roleId);
if(param.lv && param.lv > 0) {
let exp = getHeroExpByLv(param.lv - 1)||0;
exp += (param.expInc||0);
let newLv = getHeroLvByExp(exp);
param.lv = newLv;
param['exp'] = exp;
}
await calculateCeWithHero(HERO_SYSTEM_TYPE.INIT, roleId, hero.serverId, sid, hid, {...hero, ...param});
// if(param.job > 0) {
// await calculateCe(HERO_SYSTEM_TYPE.STAGEUP, roleId, hero.serverId, sid, param, {}, { hid });
// hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.STAGEUP, sid, roleId, hero, { job: param.job, jobStage: 0 });
// }
// if (hero.star != param.star) {
// await calAllHeroCe(HERO_SYSTEM_TYPE.STAR, sid, roleId, {}, [hid, 1]); // 升星可能影响到百家学院全局加成
// }
return resResult(STATUS.SUCCESS);
}
/**
* 升级英雄装备至限制内的最高级
*
* @param {{ roleId: string, hid: number }} msg
* @param {BackendSession} session
* @return {*}
* @memberof GmRoleHandler
*/
async upgradeHeroEPlace(msg: { roleId: string, hid: number }, session: BackendSession) {
let { roleId, hid } = msg;
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
/*
* 通过
* dic_zyz_equipQuality.json
* dic_zyz_equipStar.json
* dic_zyz_equipStrength.json
* dic_zyz_artifactQuality.json
* 配置文件得出:
* maxLevel: 100
* maxQuality: 5 (金)
* maxStar: 12
*
* 限制:
* 装备等级不能超过hero等级
* maxQuality限制等级最大值: 金 最大lv 100
*
* 装备信息:
* dic_zyz_equip.json
*/
const MAX_STAR = 12;
const MAX_QUALITY = 5;
// EPLACE_ID 分别代表4个部位
const EPLACE_IDS = [1, 2, 3, 4];
// 装备升级、升星、升品(注意升级限制)
// 装备未满 - 补全 - 并升至满级
let doNotGetEPlaceIds = new Set(EPLACE_IDS);
hero.ePlace.forEach((ePlaceItem) => {
doNotGetEPlaceIds.delete(ePlaceItem.id);
// 该装备已拥有 - 升级、品、星
// 升级 - 最大等级100
ePlaceItem.lv = hero.lv; // 英雄等级肯定小于MAX_LV
// 升品 - 金
ePlaceItem.quality = MAX_QUALITY;
ePlaceItem.qualityStage = 0;
// 生星 - 最高12
ePlaceItem.star = MAX_STAR;
ePlaceItem.starStage = 0;
});
// 装备补全
let dicHero = gameData.hero.get(hero.skinId);
doNotGetEPlaceIds.forEach((ePlaceId) => {
let dicEquip = getEquipByJobClassAndEPlace(dicHero?.jobClass, ePlaceId);
if (dicEquip) {
hero.ePlace.push({
lv: hero.lv,
quality: MAX_QUALITY,
qualityStage: 0,
star: MAX_STAR,
starStage: 0,
jewel: 0,
id: ePlaceId,
equipId: dicEquip.id,
stones: [
{
id: 1,
stone: 0
},
{
id: 2,
stone: 0
},
{
id: 3,
stone: 0
}
]
})
}
})
// 更新装备信息
await HeroModel.updateHeroInfo(roleId, hid, { ePlace: hero.ePlace });
// 获取战力重算需要的数据
let role = await RoleModel.findByRoleId(roleId);
let schools = await SchoolModel.findByRoleId(roleId);
let jewels = await JewelModel.findbyRole(roleId);
let heroes = await HeroModel.findByRole(roleId);
let skins = await SkinModel.findbyRole(roleId);
let artifacts = await ArtifactModel.findbyRole(roleId);
// 所有战力重算
await calculateCeWithRole(HERO_SYSTEM_TYPE.RE_CAL, roleId, role.serverId, null, {}, { role, schools, jewels, heroes, skins, artifacts });
// 获取更新装备的英雄
hero = await HeroModel.findByHidAndRole(hid, roleId);
// 返回强化升星升品后的hero数据
return resResult(STATUS.SUCCESS, { curHero: hero });
}
async deleteHero(msg: { roleId: string, hid: number }, session: BackendSession) {
let { roleId, hid } = msg;
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
await HeroModel.deleteHero(roleId, hid);
await SkinModel.deleteByHero(roleId, hid);
let role = await RoleModel.findByRoleId(roleId);
await PvpDefenseModel.deleteHero(roleId, hid);
await RoleCeModel.deleteHero(roleId, hid);
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup.filter(cur => cur.hid != hid), topLineupCe: role.topLineupCe - hero.ce, ce: role.ce - hero.ce });
await JewelModel.updateMany({ hid }, { $set: { hid: 0}});
return resResult(STATUS.SUCCESS);
}
async updateGuild(msg: GuildFormParam, session: BackendSession ) {
const uid = session.get('uid');
let params = new GuildFormParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let guild = await GuildModel.findByCode(params.code, null, '+members');
let structure = guild.structure||[];
let updateParams: GuildUpdateParam = { code: params.code };
if(params.name && guild.name != params.name) updateParams.name = params.name;
if(params.fund != undefined && guild.fund != params.fund) updateParams.fund = params.fund;
if(params.notice && guild.notice != params.notice) updateParams.notice = params.notice;
if(params.lv && guild.lv != params.lv) updateParams.lv = params.lv;
for(let id = GUILD_STRUCTURE.START; id < GUILD_STRUCTURE.END; id ++) {
let curStructure = structure.find(cur => cur.id == id);
let lv = params.lv;
switch(id) {
case GUILD_STRUCTURE.ARMY_CENTER:
lv = params.lv; break;
case GUILD_STRUCTURE.EQUIP_PRODUCE:
lv = params.equipProduce; break;
case GUILD_STRUCTURE.BOSS:
lv = params.boss; break;
case GUILD_STRUCTURE.TRAIN:
lv = params.train; break;
case GUILD_STRUCTURE.DONATE:
lv = params.donate; break;
case GUILD_STRUCTURE.WISH_POOL:
lv = params.wishPool; break;
case GUILD_STRUCTURE.STORE:
lv = params.store; break;
}
if(curStructure) {
curStructure.lv = lv;
} else {
structure.push({ id, lv });
}
}
updateParams.structure = structure;
await pushGuildInfoUpdate(params.code, updateParams);
// 设置玩家名
if(updateParams.name != undefined || updateParams.lv != undefined) {
let arr = [];
if(updateParams.name != undefined) {
arr.push({ field: 'name', value: updateParams.name });
for(let roleId of guild.members) {
await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'guildName', value: updateParams.name }]);
}
}
if(updateParams.lv != undefined) arr.push({ field: 'lv', value: updateParams.lv });
await updateUserInfo(REDIS_KEY.GUILD_INFO, params.code, arr);
}
if (updateParams.lv != undefined) {
let r = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId: guild.serverId });
await r.setRankWithGuildInfo2(guild.code, updateParams.lv, guild.activeWeekly, guild.lvUpdateTime, guild);
}
guild = await GuildModel.updateInfo(params.code, updateParams);
if(params.trainLv) {
await setTrainLv(params.code, params.trainLv);
}
return resResult(STATUS.SUCCESS);
}
async dismissGuild(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let guild = await GuildModel.findByCode(code, null, '+serverId');
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
let serverId = guild.serverId;
guild = await GuildModel.dismiss(code, serverId);
if (!guild) return resResult(STATUS.GUILD_DELETE_ERROR);
await UserGuildModel.dismiss(code);
const { members } = guild;
await RoleModel.dissmissGuild(members);
await UserGuildApplyModel.deleteApplyByGuild(code);
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast(members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
// 删除channel
await pushGuildDismiss(code);
let r = new Rank(REDIS_KEY.GUILD_ACTIVE_RANK, { serverId });
await r.removeFromRank({ guildCode: code });
let r2 = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId });
await r2.removeFromRank({ guildCode: code });
let leader = <RoleType>guild.leader;
reportTAEvent(leader.roleId, TA_EVENT.GUILD_DISMISS, { name: guild.name, way: GUILD_DISMISS_WAY.BACKEND });
return resResult(STATUS.SUCCESS, { code, status: guild.status });
}
async setGuildLeader(msg: { code: string, roleId: string }, session: BackendSession) {
const { code, roleId } = msg;
let guild = await GuildModel.findByCode(code, null, '+serverId');
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let userGuild = await UserGuildModel.getMyGuild(roleId);
if(!userGuild || userGuild.guildCode != code) return resResult(STATUS.GUILD_KICK_ERROR);
if(userGuild.auth == GUILD_AUTH.LEADER) return resResult(STATUS.GUILD_USER_IS_LEADER);
let leader = <RoleType>guild.leader;
// 交换
let oldLeaderUserGuild = await UserGuildModel.updateInfo(leader.roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: leader.roleId, userGuild: oldLeaderUserGuild }]); // 更新session
let newLeaderUserGuild = await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.DAJIANGJUN }, {}, 'auth'); // 最高功勋人升
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: roleId, userGuild: newLeaderUserGuild }]); // 更新session
let managerCntInc = userGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
guild = await GuildModel.updateInfo(code, { leader: role._id }, { managerCnt: managerCntInc }, 'managerCnt name'); // 如果有转让团长设置leader
// 添加动态
await pushChangeGuildLeader(code, guild.managerCnt, role, leader.roleId);
await sendMailByContent(MAIL_TYPE.GUILD_BE_IMPEACH, leader.roleId, { params: [guild.name] });
await sendMailByContent(MAIL_TYPE.GUILD_BE_SET_LEADER, roleId, { params: [guild.name] });
await updateUserInfo(REDIS_KEY.GUILD_INFO, code, [{ field: 'leader', value: new GuildLeader(role) }]);
reportTAEvent(roleId, TA_EVENT.GUILD_MASTER_CHANGE, { way: GUILD_MASTER_CHANGE_WAY.BACKEND, change_id_after: roleId })
return resResult(STATUS.SUCCESS, { code });
}
async skipEpilogue(msg: { roleId: string, roleName: string }, session: BackendSession) {
const { roleId, roleName } = msg;
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
if(role.hasInit) return resResult(STATUS.ROLE_HAS_INIT);
let checkName = await RoleModel.checkName(roleName, role.serverId);
if (checkName) return resResult(STATUS.NAME_HAS_USED);
let warStars: WarStar[] = [];
let insertParams: DicWar[] = [];
let exp = 0;
for(let i = 101; i <= 103; i++) {
let dicWar = gameData.war.get(i);
insertParams.push(dicWar);
warStars.push({ id: dicWar.war_id, warType: dicWar.warType, star: 0, stars: [] });
exp += dicWar.kingExp;
}
let lv = getLvByExp(exp);
await RScriptRecordModel.deleteByWarType(roleId, WAR_TYPE.NORMAL);
await RScriptRecordModel.insertScripts(roleId, insertParams);
let onlineUser = await getRoleOnlineInfo(roleId);
await createHeroes(roleId, roleName, onlineUser?.sid, role.serverId, DEFAULT_HEROES.map(hid => ({hid, count: 1})), { roleName, hasInit: true, title: role.title, teraphs: role.teraphs, lv, exp, warStar: warStars });
return resResult(STATUS.SUCCESS);
}
async reCalCe(msg: { roleId: string }, session: BackendSession) {
const { roleId } = msg;
let role = await RoleModel.findByRoleId(roleId);
let schools = await SchoolModel.findByRoleId(roleId);
let jewels = await JewelModel.findbyRole(roleId);
let heroes = await HeroModel.findByRole(roleId);
let skins = await SkinModel.findbyRole(roleId);
let artifacts = await ArtifactModel.findbyRole(roleId);
await calculateCeWithRole(HERO_SYSTEM_TYPE.RE_CAL, roleId, role.serverId, null, {}, { role, schools, jewels, heroes, skins, artifacts });
return resResult(STATUS.SUCCESS);
}
async clearRank(msg: { roleId: string }, session: BackendSession) {
let { roleId } = msg;
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.WRONG_PARMS);
if(role.blockType != 2) return resResult(STATUS.GM_CANNOT_CLEAR_RANK)
let { serverId } = role;
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOWER_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.LADDER, { serverId }).getName(), roleId);
await LadderMatchModel.updateByRoleId(roleId, { rank: 0 });
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOP_LINEUP_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOP_HERO_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.HERO_NUM_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.SUM_CE_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.USER_LV, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.MAIN_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.MAIN_ELITE_RANK, { serverId }).getName(), roleId);
let keys = await redisClient().keysAsync(REDIS_KEY.PVP_RANK);
for(let key of keys) await redisClient().zremAsync(key, roleId);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, pinus } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '@consts/statusCode';
import { getRoleOnlineInfo, redisClient, updateUserInfo } from '../../../services/redisService';
import { addItems } from '../../../services/role/rewardService';
import { RewardInter } from '@pubUtils/interface';
import { gameData, getExpByLv, getHeroExpByLv, getHeroLvByExp, getLvByExp, getEquipByJobClassAndEPlace } from '@pubUtils/data';
import { RoleModel, RoleType, WarStar } from '@db/Role';
import { BLOCK_TYPE, DEFAULT_HEROES, GUILD_AUTH, GUILD_DISMISS_WAY, GUILD_JOB, GUILD_MASTER_CHANGE_WAY, GUILD_STATUS, GUILD_STRUCTURE, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, MAIL_TYPE, MEMORY_LOG_TYPE, PUSH_ROUTE, REDIS_KEY, TA_EVENT, WAR_TYPE } from '../../../consts';
import { GuildFormParam, SetHeroParam } from '@domain/backEndField/params';
import { GuildModel, GuildUpdateParam } from '@db/Guild';
import { Rank } from '../../../services/rankService';
import { UserGuildModel } from '@db/UserGuild';
import { UserGuildApplyModel } from '@db/UserGuildApply';
import { reportTAEvent } from '../../../services/sdkService';
import { sendMailByContent } from '../../../services/mailService';
import { GuildLeader } from '@domain/rank';
import { HeroModel } from '@db/Hero';
import { SkinModel } from '@db/Skin';
import { PvpDefenseModel } from '@db/PvpDefense';
import { createHeroes } from '../../../services/role/createHero';
import { calculateCeWithHero, calculateCeWithRole } from '../../../services/playerCeService';
import { pushChangeGuildLeader, pushGuildDismiss, pushGuildInfoUpdate } from '../../../services/guildService';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
import { RScriptRecordModel } from '@db/RScriptRecord';
import { DicWar } from '@pubUtils/dictionary/DicWar';
import { SchoolModel } from '@db/School';
import { JewelModel } from '@db/Jewel';
import { RoleCeModel } from '@db/RoleCe';
import { setTrainLv } from '../../../services/gmService';
import { ArtifactModel } from '@db/Artifact';
import { roleLeave } from '../../../services/redisService';
import { KeyName } from '@domain/rank';
import { LadderMatchModel } from '@db/LadderMatch';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmRoleHandler(app);
}
export class GmRoleHandler {
constructor(private app: Application) {
}
async addItems(msg: { roleId: string, roleName: string, serverId: number, values: { reward: RewardInter[], heroes: number[], lv: number, expInc: number, fixedIpLocation: string }}, session: BackendSession) {
let { roleId, roleName, serverId, values } = msg;
let { reward, heroes, lv, expInc = 0, fixedIpLocation } = values;
let connect = await getRoleOnlineInfo(roleId);
let sid = connect.isOnline?connect.sid: null;
if(reward &&reward.length > 0) {
await addItems(roleId, roleName, sid, values.reward, ITEM_CHANGE_REASON.DEBUG);
}
if(heroes && heroes.length > 0) {
await createHeroes(roleId, roleName, sid, serverId, heroes.map(hid => { return { hid, count: 1 }}))
}
if(lv && lv > 0) {
let exp = getExpByLv(lv - 1)?.sum||0;
exp += expInc;
let newLv = getLvByExp(exp);
let role = await RoleModel.updateRoleInfo(roleId, { lv: newLv, exp })
let r = new Rank(REDIS_KEY.USER_LV, { serverId: serverId });
await r.setRankWithRoleInfo(roleId, newLv, Date.now(), role);
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PLAYER_EXP_CHANGE, {
isLvUp: false, lv: newLv, exp
}, sid);
}
if(fixedIpLocation != undefined) {
await RoleModel.updateRoleInfo(roleId, { fixedIpLocation })
}
return resResult(STATUS.SUCCESS);
}
async handleBlock(msg: { roleId: string, blockType: BLOCK_TYPE, blockReason: string }, session: BackendSession) {
let { roleId, blockType, blockReason } = msg;
if(roleId == undefined || blockType == undefined || blockReason == undefined) return resResult(STATUS.WRONG_PARMS);
let role = await RoleModel.updateRoleInfo(roleId, { blockType, blockReason });
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let { isOnline, sid } = await getRoleOnlineInfo(roleId);
if(isOnline) {
await this.app.rpc.connector.connectorRemote.setOtherUserSession.toServer(sid,[{ roleId, blockType }]);
if(blockType == BLOCK_TYPE.BLOCK) { // 踢走
await this.app.rpc.connector.connectorRemote.remoteLogin.toServer(sid, roleId, STATUS.BLOCKED);
await roleLeave(roleId);
}
}
return resResult(STATUS.SUCCESS);
}
async setHero(msg: { roleId: string, hid: number, param: SetHeroParam }, session: BackendSession) {
let { roleId, hid } = msg;
let param = new SetHeroParam(msg.param);
if(!param.checkParams()) return resResult(STATUS.WRONG_PARMS);
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if(!hero) return resResult(STATUS.HERO_NOT_FIND);
let { sid } = await getRoleOnlineInfo(roleId);
if(param.lv && param.lv > 0) {
let exp = getHeroExpByLv(param.lv - 1)||0;
exp += (param.expInc||0);
let newLv = getHeroLvByExp(exp);
param.lv = newLv;
param['exp'] = exp;
}
await calculateCeWithHero(HERO_SYSTEM_TYPE.INIT, roleId, hero.serverId, sid, hid, {...hero, ...param});
// if(param.job > 0) {
// await calculateCe(HERO_SYSTEM_TYPE.STAGEUP, roleId, hero.serverId, sid, param, {}, { hid });
// hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.STAGEUP, sid, roleId, hero, { job: param.job, jobStage: 0 });
// }
// if (hero.star != param.star) {
// await calAllHeroCe(HERO_SYSTEM_TYPE.STAR, sid, roleId, {}, [hid, 1]); // 升星可能影响到百家学院全局加成
// }
return resResult(STATUS.SUCCESS);
}
/**
* 升级英雄装备至限制内的最高级
*
* @param {{ roleId: string, hid: number }} msg
* @param {BackendSession} session
* @return {*}
* @memberof GmRoleHandler
*/
async upgradeHeroEPlace(msg: { roleId: string, hid: number }, session: BackendSession) {
let { roleId, hid } = msg;
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
/*
* 通过
* dic_zyz_equipQuality.json
* dic_zyz_equipStar.json
* dic_zyz_equipStrength.json
* dic_zyz_artifactQuality.json
* 配置文件得出:
* maxLevel: 100
* maxQuality: 5 (金)
* maxStar: 12
*
* 限制:
* 装备等级不能超过hero等级
* maxQuality限制等级最大值: 金 最大lv 100
*
* 装备信息:
* dic_zyz_equip.json
*/
const MAX_STAR = 12;
const MAX_QUALITY = 5;
// EPLACE_ID 分别代表4个部位
const EPLACE_IDS = [1, 2, 3, 4];
// 装备升级、升星、升品(注意升级限制)
// 装备未满 - 补全 - 并升至满级
let doNotGetEPlaceIds = new Set(EPLACE_IDS);
hero.ePlace.forEach((ePlaceItem) => {
doNotGetEPlaceIds.delete(ePlaceItem.id);
// 该装备已拥有 - 升级、品、星
// 升级 - 最大等级100
ePlaceItem.lv = hero.lv; // 英雄等级肯定小于MAX_LV
// 升品 - 金
ePlaceItem.quality = MAX_QUALITY;
ePlaceItem.qualityStage = 0;
// 生星 - 最高12
ePlaceItem.star = MAX_STAR;
ePlaceItem.starStage = 0;
});
// 装备补全
let dicHero = gameData.hero.get(hero.skinId);
doNotGetEPlaceIds.forEach((ePlaceId) => {
let dicEquip = getEquipByJobClassAndEPlace(dicHero?.jobClass, ePlaceId);
if (dicEquip) {
hero.ePlace.push({
lv: hero.lv,
quality: MAX_QUALITY,
qualityStage: 0,
star: MAX_STAR,
starStage: 0,
jewel: 0,
id: ePlaceId,
equipId: dicEquip.id,
stones: [
{
id: 1,
stone: 0
},
{
id: 2,
stone: 0
},
{
id: 3,
stone: 0
}
]
})
}
})
// 更新装备信息
await HeroModel.updateHeroInfo(roleId, hid, { ePlace: hero.ePlace });
// 获取战力重算需要的数据
let role = await RoleModel.findByRoleId(roleId);
let schools = await SchoolModel.findByRoleId(roleId);
let jewels = await JewelModel.findbyRole(roleId);
let heroes = await HeroModel.findByRole(roleId);
let skins = await SkinModel.findbyRole(roleId);
let artifacts = await ArtifactModel.findbyRole(roleId);
// 所有战力重算
await calculateCeWithRole(HERO_SYSTEM_TYPE.RE_CAL, roleId, role.serverId, null, {}, { role, schools, jewels, heroes, skins, artifacts });
// 获取更新装备的英雄
hero = await HeroModel.findByHidAndRole(hid, roleId);
// 返回强化升星升品后的hero数据
return resResult(STATUS.SUCCESS, { curHero: hero });
}
async deleteHero(msg: { roleId: string, hid: number }, session: BackendSession) {
let { roleId, hid } = msg;
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
await HeroModel.deleteHero(roleId, hid);
await SkinModel.deleteByHero(roleId, hid);
let role = await RoleModel.findByRoleId(roleId);
await PvpDefenseModel.deleteHero(roleId, hid);
await RoleCeModel.deleteHero(roleId, hid);
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup.filter(cur => cur.hid != hid), topLineupCe: role.topLineupCe - hero.ce, ce: role.ce - hero.ce });
await JewelModel.updateMany({ hid }, { $set: { hid: 0}});
return resResult(STATUS.SUCCESS);
}
async updateGuild(msg: GuildFormParam, session: BackendSession ) {
const uid = session.get('uid');
let params = new GuildFormParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let guild = await GuildModel.findByCode(params.code, null, '+members');
let structure = guild.structure||[];
let updateParams: GuildUpdateParam = { code: params.code };
if(params.name && guild.name != params.name) updateParams.name = params.name;
if(params.fund != undefined && guild.fund != params.fund) updateParams.fund = params.fund;
if(params.notice && guild.notice != params.notice) updateParams.notice = params.notice;
if(params.lv && guild.lv != params.lv) updateParams.lv = params.lv;
for(let id = GUILD_STRUCTURE.START; id < GUILD_STRUCTURE.END; id ++) {
let curStructure = structure.find(cur => cur.id == id);
let lv = params.lv;
switch(id) {
case GUILD_STRUCTURE.ARMY_CENTER:
lv = params.lv; break;
case GUILD_STRUCTURE.EQUIP_PRODUCE:
lv = params.equipProduce; break;
case GUILD_STRUCTURE.BOSS:
lv = params.boss; break;
case GUILD_STRUCTURE.TRAIN:
lv = params.train; break;
case GUILD_STRUCTURE.DONATE:
lv = params.donate; break;
case GUILD_STRUCTURE.WISH_POOL:
lv = params.wishPool; break;
case GUILD_STRUCTURE.STORE:
lv = params.store; break;
}
if(curStructure) {
curStructure.lv = lv;
} else {
structure.push({ id, lv });
}
}
updateParams.structure = structure;
await pushGuildInfoUpdate(params.code, updateParams);
// 设置玩家名
if(updateParams.name != undefined || updateParams.lv != undefined) {
let arr = [];
if(updateParams.name != undefined) {
arr.push({ field: 'name', value: updateParams.name });
for(let roleId of guild.members) {
await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'guildName', value: updateParams.name }]);
}
}
if(updateParams.lv != undefined) arr.push({ field: 'lv', value: updateParams.lv });
await updateUserInfo(REDIS_KEY.GUILD_INFO, params.code, arr);
}
if (updateParams.lv != undefined) {
let r = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId: guild.serverId });
await r.setRankWithGuildInfo2(guild.code, updateParams.lv, guild.activeWeekly, guild.lvUpdateTime, guild);
}
guild = await GuildModel.updateInfo(params.code, updateParams);
if(params.trainLv) {
await setTrainLv(params.code, params.trainLv);
}
return resResult(STATUS.SUCCESS);
}
async dismissGuild(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let guild = await GuildModel.findByCode(code, null, '+serverId');
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
let serverId = guild.serverId;
guild = await GuildModel.dismiss(code, serverId);
if (!guild) return resResult(STATUS.GUILD_DELETE_ERROR);
await UserGuildModel.dismiss(code);
const { members } = guild;
await RoleModel.dissmissGuild(members);
await UserGuildApplyModel.deleteApplyByGuild(code);
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast(members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
// 删除channel
await pushGuildDismiss(code);
let r = new Rank(REDIS_KEY.GUILD_ACTIVE_RANK, { serverId });
await r.removeFromRank({ guildCode: code });
let r2 = new Rank(REDIS_KEY.GUILD_LV_RANK, { serverId });
await r2.removeFromRank({ guildCode: code });
let leader = <RoleType>guild.leader;
reportTAEvent(leader.roleId, TA_EVENT.GUILD_DISMISS, { name: guild.name, way: GUILD_DISMISS_WAY.BACKEND });
return resResult(STATUS.SUCCESS, { code, status: guild.status });
}
async setGuildLeader(msg: { code: string, roleId: string }, session: BackendSession) {
const { code, roleId } = msg;
let guild = await GuildModel.findByCode(code, null, '+serverId');
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
if(guild.status == GUILD_STATUS.DISMISSED) return resResult(STATUS.GUILD_DELETE_ERROR);
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
let userGuild = await UserGuildModel.getMyGuild(roleId);
if(!userGuild || userGuild.guildCode != code) return resResult(STATUS.GUILD_KICK_ERROR);
if(userGuild.auth == GUILD_AUTH.LEADER) return resResult(STATUS.GUILD_USER_IS_LEADER);
let leader = <RoleType>guild.leader;
// 交换
let oldLeaderUserGuild = await UserGuildModel.updateInfo(leader.roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: leader.roleId, userGuild: oldLeaderUserGuild }]); // 更新session
let newLeaderUserGuild = await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.DAJIANGJUN }, {}, 'auth'); // 最高功勋人升
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast([{ roleId: roleId, userGuild: newLeaderUserGuild }]); // 更新session
let managerCntInc = userGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
guild = await GuildModel.updateInfo(code, { leader: role._id }, { managerCnt: managerCntInc }, 'managerCnt name'); // 如果有转让团长设置leader
// 添加动态
await pushChangeGuildLeader(code, guild.managerCnt, role, leader.roleId);
await sendMailByContent(MAIL_TYPE.GUILD_BE_IMPEACH, leader.roleId, { params: [guild.name] });
await sendMailByContent(MAIL_TYPE.GUILD_BE_SET_LEADER, roleId, { params: [guild.name] });
await updateUserInfo(REDIS_KEY.GUILD_INFO, code, [{ field: 'leader', value: new GuildLeader(role) }]);
reportTAEvent(roleId, TA_EVENT.GUILD_MASTER_CHANGE, { way: GUILD_MASTER_CHANGE_WAY.BACKEND, change_id_after: roleId })
return resResult(STATUS.SUCCESS, { code });
}
async skipEpilogue(msg: { roleId: string, roleName: string }, session: BackendSession) {
const { roleId, roleName } = msg;
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
if(role.hasInit) return resResult(STATUS.ROLE_HAS_INIT);
let checkName = await RoleModel.checkName(roleName, role.serverId);
if (checkName) return resResult(STATUS.NAME_HAS_USED);
let warStars: WarStar[] = [];
let insertParams: DicWar[] = [];
let exp = 0;
for(let i = 101; i <= 103; i++) {
let dicWar = gameData.war.get(i);
insertParams.push(dicWar);
warStars.push({ id: dicWar.war_id, warType: dicWar.warType, star: 0, stars: [] });
exp += dicWar.kingExp;
}
let lv = getLvByExp(exp);
await RScriptRecordModel.deleteByWarType(roleId, WAR_TYPE.NORMAL);
await RScriptRecordModel.insertScripts(roleId, insertParams);
let onlineUser = await getRoleOnlineInfo(roleId);
await createHeroes(roleId, roleName, onlineUser?.sid, role.serverId, DEFAULT_HEROES.map(hid => ({hid, count: 1})), { roleName, hasInit: true, title: role.title, teraphs: role.teraphs, lv, exp, warStar: warStars });
return resResult(STATUS.SUCCESS);
}
async reCalCe(msg: { roleId: string }, session: BackendSession) {
const { roleId } = msg;
let role = await RoleModel.findByRoleId(roleId);
let schools = await SchoolModel.findByRoleId(roleId);
let jewels = await JewelModel.findbyRole(roleId);
let heroes = await HeroModel.findByRole(roleId);
let skins = await SkinModel.findbyRole(roleId);
let artifacts = await ArtifactModel.findbyRole(roleId);
await calculateCeWithRole(HERO_SYSTEM_TYPE.RE_CAL, roleId, role.serverId, null, {}, { role, schools, jewels, heroes, skins, artifacts });
return resResult(STATUS.SUCCESS);
}
async clearRank(msg: { roleId: string }, session: BackendSession) {
let { roleId } = msg;
let role = await RoleModel.findByRoleId(roleId);
if(!role) return resResult(STATUS.WRONG_PARMS);
if(role.blockType != 2) return resResult(STATUS.GM_CANNOT_CLEAR_RANK)
let { serverId } = role;
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOWER_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.LADDER, { serverId }).getName(), roleId);
await LadderMatchModel.updateByRoleId(roleId, { rank: 0 });
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOP_LINEUP_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.TOP_HERO_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.HERO_NUM_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.SUM_CE_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.USER_LV, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.MAIN_RANK, { serverId }).getName(), roleId);
await redisClient().zremAsync(new KeyName(REDIS_KEY.MAIN_ELITE_RANK, { serverId }).getName(), roleId);
let keys = await redisClient().keysAsync(REDIS_KEY.PVP_RANK);
for(let key of keys) await redisClient().zremAsync(key, roleId);
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,271 +1,272 @@
import { Application, BackendSession, pinus } from 'pinus';
import { genCode, getRandSingleEelm, isTimestamp, resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { UpdateHiddenDataParam, CreatePvpConfigParam, CreateServerParam, UpdateRegionParams, CreateServersParam } from '../../../domain/backEndField/params';
import { RegionModel, RegionType } from '../../../db/Region';
import { getDicServerName } from '../../../pubUtils/data';
import { Maintenance, ServerlistModel, ServerlistUpdate } from '../../../db/Serverlist';
import { nowSeconds, getFutureTime, getPastTime } from '../../../pubUtils/timeUtil';
import { calHiddenData } from '../../../services/gmService';
import { isNumber } from 'util';
import { MarqueeModel } from '../../../db/Marquee';
import { setApiIsCloseToRemote } from '../../../services/chatService';
import { PVPConfigModel } from '../../../db/PvpConfig';
import { HiddenDataByIdModel, HiddenDataByIdModelTypeParam } from '../../../db/HiddenDataById';
import { isDevelopEnv } from '../../../services/utilService';
import { redisClient } from "../../../services/redisService";
import { REDIS_KEY } from "../../../consts";
import { createNewServer } from '../../../services/serverService';
export default function (app: Application) {
return new GmHandler(app);
}
export class GmHandler {
constructor(private app: Application) {
}
// 保存大区配置
async saveRegionConf(msg: UpdateRegionParams, session: BackendSession) {
let params = new UpdateRegionParams(msg);
let uid = session.get('uid');
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let region: RegionType;
if(params.id == 'new') {
let update = params.getUpdateParam();
region = await RegionModel.createNewRegion(update, uid);
} else {
let oldRegion = await RegionModel.findRegionById(params.id);
if(!oldRegion) return resResult(STATUS.WRONG_PARMS);
let update = params.getUpdateParam(oldRegion);
region = await RegionModel.updateRegion(params.id, update, uid);
}
return resResult(STATUS.SUCCESS);
}
// 手动开服
async createNewServer(msg: CreateServersParam, session: BackendSession) {
if(isNumber(msg.openTime)) return resResult(STATUS.WRONG_PARMS, '请刷新后使用新后台页面');
let params = new CreateServersParam(msg);
let uid = session.get('uid');
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
console.log('*******', params);
let curRegion = await RegionModel.findRegionByEnv(params.env);
console.log('******* curRegion', curRegion);
if(!curRegion) return resResult(STATUS.WRONG_PARMS);
msg.openTime.sort()
let { latestServer = 0, env } = curRegion;
for(let openTime of msg.openTime) {
let dic = getDicServerName(env, latestServer + 1);
if(!dic) return resResult(STATUS.DIC_DATA_NOT_FOUND);
await createNewServer(curRegion, latestServer + 1, new CreateServerParam({...params, openTime}), uid);
latestServer++;
}
return resResult(STATUS.SUCCESS);
}
// 开始维护
async startMaintenance(msg: { id: number, startTime: number, endTime: number, hasNotify: boolean, version: string }, session: BackendSession) {
const { id, startTime, endTime, hasNotify, version } = msg;
if(!id || !isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
if(endTime < nowSeconds()) return resResult(STATUS.WRONG_PARMS, '结束时间不能比现在早');
const uid = session.get('uid');
let server = await ServerlistModel.findByServerId(id);
if(server && server.maintenance) {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(server.maintenance.batchCode, [server.id]);
}
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true, version }
server = await ServerlistModel.updateByServerId(id, { maintenance: newMaintenance });
await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast([server]);
return resResult(STATUS.SUCCESS,);
}
// 大区一起维护
async startRegionMaintenance(msg: { startTime: number, endTime: number, hasNotify: boolean, version: string }, session: BackendSession) {
const { startTime, endTime, hasNotify, version } = msg;
if(!isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
if(endTime < nowSeconds()) return resResult(STATUS.WRONG_PARMS, '结束时间不能比现在早');
const uid = session.get('uid');
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true, version }
let servers = await ServerlistModel.findByEnv(this.app.get('env'));
let serverIdsOfBatchCode = new Map<string, number[]>();
let serverIds: number[] = [];
for(let server of servers) {
if(server.maintenance) {
let { batchCode } = server.maintenance;
if(!serverIdsOfBatchCode.has(batchCode)) {
serverIdsOfBatchCode.set(batchCode, []);
}
serverIdsOfBatchCode.get(batchCode).push(server.id);
}
serverIds.push(server.id);
}
for(let [ batchCode, serverIds ] of serverIdsOfBatchCode) {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(batchCode, serverIds);
}
await ServerlistModel.updateByServerIds(serverIds, { maintenance: newMaintenance });
servers = await ServerlistModel.findByEnv(this.app.get('env'));
await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast(servers.map(server => ({...server, maintenance: newMaintenance })));
return resResult(STATUS.SUCCESS,);
}
// 提前结束维护
async stopMaintenance(msg: { id: number }, session: BackendSession) {
const { id } = msg;
const uid = session.get('uid');
let server = await ServerlistModel.findByServerId(id);
let maintenance = server.maintenance;
if(maintenance) {
// 更新serverlist上的status
await ServerlistModel.updateByServerId(server.id, { 'maintenance.isOpen': false } as ServerlistUpdate);
// console.log('&&&', server, server.id)
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(maintenance.batchCode, [server.id]);
}
return resResult(STATUS.SUCCESS,);
}
// 大区一起结束维护
async stopRegionMaintenance(msg: {}, session: BackendSession) {
const { } = msg;
const uid = session.get('uid');
let servers = await ServerlistModel.findByEnv(this.app.get('env'));
let serverIdsOfBatchCode = new Map<string, number[]>();
let serverIds: number[] = [];
for(let server of servers) {
if(server.maintenance) {
let { batchCode } = server.maintenance;
if(!serverIdsOfBatchCode.has(batchCode)) {
serverIdsOfBatchCode.set(batchCode, []);
}
serverIdsOfBatchCode.get(batchCode).push(server.id);
serverIds.push(server.id);
}
}
for(let [ batchCode, serverIds ] of serverIdsOfBatchCode) {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(batchCode, serverIds);
}
// 更新serverlist上的status
await ServerlistModel.updateByServerIds(serverIds, { 'maintenance.isOpen': false } as ServerlistUpdate);
return resResult(STATUS.SUCCESS,);
}
async sendMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let marquee = await MarqueeModel.findByCode(code);
if(!marquee) return resResult(STATUS.DB_DATA_NOT_FOUND);
await MarqueeModel.updateData(code, { isEnable: true });
let result = await this.app.rpc.systimer.systimerRemote.setMarquee.broadcast(marquee);
if (!result) return resResult(STATUS.GM_MARQUEE_ERR);
return resResult(STATUS.SUCCESS);
}
async cancelMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
await MarqueeModel.updateData(code, { isEnable: false });
let result = await this.app.rpc.systimer.systimerRemote.cancelMarquee.broadcast(code);
if (!result) return resResult(STATUS.GM_MARQUEE_CANCEL_ERR);
return resResult(STATUS.SUCCESS);
}
async setApiIsClose(msg: { isCloseApi: boolean }, session: BackendSession) {
const { isCloseApi } = msg;
let region = await RegionModel.findRegionByEnv(pinus.app.get('env'));
if(!region) return resResult(STATUS.SERVER_NOT_FOUND);
region = await RegionModel.updateRegion(region.id, { isCloseApi });
setApiIsCloseToRemote(region.isCloseApi);
return resResult(STATUS.SUCCESS);
}
async savePvpConfig(msg: CreatePvpConfigParam, session: BackendSession) {
let params = new CreatePvpConfigParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
if(params.seasonStartTime >= params.seasonEndTime) return resResult(STATUS.WRONG_PARMS, null, '开始时间不可晚于结束时间');
if(params.seasonEndTime >= params.seasonRewardTime) return resResult(STATUS.WRONG_PARMS, null, '结束时间不可晚于奖励时间');
if(await PVPConfigModel.checkTime(params.seasonNum, params.seasonStartTime, params.seasonRewardTime)) {
return resResult(STATUS.WRONG_PARMS, null, '不可与其他赛季时间重叠');
}
let uid = session.get('uid');
await PVPConfigModel.createPVPConfig(params.seasonNum, params.getUpdateParam(), uid);
pinus.app.rpc.systimer.systimerRemote.setPvpSeasonSchedule.broadcast(true);
return resResult(STATUS.SUCCESS);
}
async initHiddenData(msg: {pubArr: number[], hideArr: number[], type: number}, session: BackendSession) {
let { pubArr = [], hideArr = [], type } = msg;
let uid = session.get('uid');
let datas = await HiddenDataByIdModel.findExistData(type);
let existIds = datas.map(cur => cur.id);
let insertParam: HiddenDataByIdModelTypeParam[] = [];
for(let id of pubArr) {
if(existIds.indexOf(id) == -1) {
insertParam.push({ type, id, publishTime: getPastTime(), createdBy: uid, updatedBy: uid });
}
}
for(let id of hideArr) {
if(existIds.indexOf(id) == -1) {
insertParam.push({ type, id, publishTime: getFutureTime(), createdBy: uid, updatedBy: uid });
}
}
await HiddenDataByIdModel.createDatas(insertParam);
await calHiddenData(uid);
await pinus.app.rpc.systimer.systimerRemote.gmSetHiddenDataSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
async saveHiddenData(msg: UpdateHiddenDataParam, session: BackendSession) {
let params = new UpdateHiddenDataParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let uid = session.get('uid');
let heroes: number[] = [], goods: number[] = [];
for(let {type, id} of params.arr) {
if(type == 1) heroes.push(id);
if(type == 2) goods.push(id);
}
if(!isDevelopEnv()) {
if(!await HiddenDataByIdModel.checkById(1, heroes, params.publishTime) || !await HiddenDataByIdModel.checkById(2, goods, params.publishTime)) {
return resResult(STATUS.GM_OLD_REF_TIME_ERR);
}
}
for(let {type, id} of params.arr) {
await HiddenDataByIdModel.updateData(type, id, params.publishTime, uid);
}
await calHiddenData(uid);
await pinus.app.rpc.systimer.systimerRemote.gmSetHiddenDataSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
async setServerOpenTime(msg: { serverId: number, serverOpenTime: number }, session: BackendSession) {
let { serverId, serverOpenTime } = msg;
if(!isTimestamp(serverOpenTime)) return resResult(STATUS.WRONG_PARMS);
let server = await ServerlistModel.findByServerId(serverId);
if(!server) return resResult(STATUS.WRONG_PARMS);
let region = await RegionModel.findRegionById(server.regionId);
if(!region) return resResult(STATUS.WRONG_PARMS);
server = await ServerlistModel.updateByServerId(serverId, { openTime: serverOpenTime });
if(server.id == region.latestServerUniqId) {
region = await RegionModel.updateRegion(server.regionId, { latestServerOpenTime: server.openTime })
}
await redisClient().hsetAsync(REDIS_KEY.SERVER_OPEN_TIME, `${server.id}`, `${server.openTime}`);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, pinus } from 'pinus';
import { genCode, getRandSingleEelm, isTimestamp, resResult } from '@pubUtils/util';
import { STATUS } from '@consts/statusCode';
import { UpdateHiddenDataParam, CreatePvpConfigParam, CreateServerParam, UpdateRegionParams, CreateServersParam } from '@domain/backEndField/params';
import { RegionModel, RegionType } from '@db/Region';
import { getDicServerName } from '@pubUtils/data';
import { Maintenance, ServerlistModel, ServerlistUpdate } from '@db/Serverlist';
import { nowSeconds, getFutureTime, getPastTime } from '@pubUtils/timeUtil';
import { calHiddenData } from '../../../services/gmService';
import { isNumber } from 'util';
import { MarqueeModel } from '@db/Marquee';
import { setApiIsCloseToRemote } from '../../../services/chatService';
import { PVPConfigModel } from '@db/PvpConfig';
import { HiddenDataByIdModel, HiddenDataByIdModelTypeParam } from '@db/HiddenDataById';
import { isDevelopEnv } from '../../../services/utilService';
import { redisClient } from "../../../services/redisService";
import { REDIS_KEY } from "../../../consts";
import { createNewServer } from '../../../services/serverService';
export default function (app: Application) {
return new GmHandler(app);
}
export class GmHandler {
constructor(private app: Application) {
}
// 保存大区配置
async saveRegionConf(msg: UpdateRegionParams, session: BackendSession) {
let params = new UpdateRegionParams(msg);
let uid = session.get('uid');
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let region: RegionType;
if(params.id == 'new') {
let update = params.getUpdateParam();
region = await RegionModel.createNewRegion(update, uid);
} else {
let oldRegion = await RegionModel.findRegionById(params.id);
if(!oldRegion) return resResult(STATUS.WRONG_PARMS);
let update = params.getUpdateParam(oldRegion);
region = await RegionModel.updateRegion(params.id, update, uid);
}
return resResult(STATUS.SUCCESS);
}
// 手动开服
async createNewServer(msg: CreateServersParam, session: BackendSession) {
if(isNumber(msg.openTime)) return resResult(STATUS.WRONG_PARMS, '请刷新后使用新后台页面');
let params = new CreateServersParam(msg);
let uid = session.get('uid');
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
console.log('*******', params);
let curRegion = await RegionModel.findRegionByEnv(params.env);
console.log('******* curRegion', curRegion);
if(!curRegion) return resResult(STATUS.WRONG_PARMS);
msg.openTime.sort()
let { latestServer = 0, env } = curRegion;
for(let openTime of msg.openTime) {
let dic = getDicServerName(env, latestServer + 1);
if(!dic) return resResult(STATUS.DIC_DATA_NOT_FOUND);
await createNewServer(curRegion, latestServer + 1, new CreateServerParam({...params, openTime}), uid);
latestServer++;
}
return resResult(STATUS.SUCCESS);
}
// 开始维护
async startMaintenance(msg: { id: number, startTime: number, endTime: number, hasNotify: boolean, version: string }, session: BackendSession) {
const { id, startTime, endTime, hasNotify, version } = msg;
if(!id || !isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
if(endTime < nowSeconds()) return resResult(STATUS.WRONG_PARMS, '结束时间不能比现在早');
const uid = session.get('uid');
let server = await ServerlistModel.findByServerId(id);
if(server && server.maintenance) {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(server.maintenance.batchCode, [server.id]);
}
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true, version }
server = await ServerlistModel.updateByServerId(id, { maintenance: newMaintenance });
await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast([server]);
return resResult(STATUS.SUCCESS,);
}
// 大区一起维护
async startRegionMaintenance(msg: { startTime: number, endTime: number, hasNotify: boolean, version: string }, session: BackendSession) {
const { startTime, endTime, hasNotify, version } = msg;
if(!isNumber(startTime) || !isNumber(endTime)) return resResult(STATUS.WRONG_PARMS);
if(endTime < nowSeconds()) return resResult(STATUS.WRONG_PARMS, '结束时间不能比现在早');
const uid = session.get('uid');
let newMaintenance: Maintenance = { batchCode: genCode(10), startTime, endTime, hasNotify, isOpen: true, version }
let servers = await ServerlistModel.findByEnv(this.app.get('env'));
let serverIdsOfBatchCode = new Map<string, number[]>();
let serverIds: number[] = [];
for(let server of servers) {
if(server.maintenance) {
let { batchCode } = server.maintenance;
if(!serverIdsOfBatchCode.has(batchCode)) {
serverIdsOfBatchCode.set(batchCode, []);
}
serverIdsOfBatchCode.get(batchCode).push(server.id);
}
serverIds.push(server.id);
}
for(let [ batchCode, serverIds ] of serverIdsOfBatchCode) {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(batchCode, serverIds);
}
await ServerlistModel.updateByServerIds(serverIds, { maintenance: newMaintenance });
servers = await ServerlistModel.findByEnv(this.app.get('env'));
await pinus.app.rpc.systimer.systimerRemote.initMaintenance.broadcast(servers.map(server => ({...server, maintenance: newMaintenance })));
return resResult(STATUS.SUCCESS,);
}
// 提前结束维护
async stopMaintenance(msg: { id: number }, session: BackendSession) {
const { id } = msg;
const uid = session.get('uid');
let server = await ServerlistModel.findByServerId(id);
let maintenance = server.maintenance;
if(maintenance) {
// 更新serverlist上的status
await ServerlistModel.updateByServerId(server.id, { 'maintenance.isOpen': false } as ServerlistUpdate);
// console.log('&&&', server, server.id)
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(maintenance.batchCode, [server.id]);
}
return resResult(STATUS.SUCCESS,);
}
// 大区一起结束维护
async stopRegionMaintenance(msg: {}, session: BackendSession) {
const { } = msg;
const uid = session.get('uid');
let servers = await ServerlistModel.findByEnv(this.app.get('env'));
let serverIdsOfBatchCode = new Map<string, number[]>();
let serverIds: number[] = [];
for(let server of servers) {
if(server.maintenance) {
let { batchCode } = server.maintenance;
if(!serverIdsOfBatchCode.has(batchCode)) {
serverIdsOfBatchCode.set(batchCode, []);
}
serverIdsOfBatchCode.get(batchCode).push(server.id);
serverIds.push(server.id);
}
}
for(let [ batchCode, serverIds ] of serverIdsOfBatchCode) {
await pinus.app.rpc.systimer.systimerRemote.stopMaintenance.broadcast(batchCode, serverIds);
}
// 更新serverlist上的status
await ServerlistModel.updateByServerIds(serverIds, { 'maintenance.isOpen': false } as ServerlistUpdate);
return resResult(STATUS.SUCCESS,);
}
async sendMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let marquee = await MarqueeModel.findByCode(code);
if(!marquee) return resResult(STATUS.DB_DATA_NOT_FOUND);
await MarqueeModel.updateData(code, { isEnable: true });
let result = await this.app.rpc.systimer.systimerRemote.setMarquee.broadcast(marquee);
if (!result) return resResult(STATUS.GM_MARQUEE_ERR);
return resResult(STATUS.SUCCESS);
}
async cancelMarquee(msg: { code: string }, session: BackendSession) {
const { code } = msg;
await MarqueeModel.updateData(code, { isEnable: false });
let result = await this.app.rpc.systimer.systimerRemote.cancelMarquee.broadcast(code);
if (!result) return resResult(STATUS.GM_MARQUEE_CANCEL_ERR);
return resResult(STATUS.SUCCESS);
}
async setApiIsClose(msg: { isCloseApi: boolean }, session: BackendSession) {
const { isCloseApi } = msg;
let region = await RegionModel.findRegionByEnv(pinus.app.get('env'));
if(!region) return resResult(STATUS.SERVER_NOT_FOUND);
region = await RegionModel.updateRegion(region.id, { isCloseApi });
setApiIsCloseToRemote(region.isCloseApi);
return resResult(STATUS.SUCCESS);
}
async savePvpConfig(msg: CreatePvpConfigParam, session: BackendSession) {
let params = new CreatePvpConfigParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
if(params.seasonStartTime >= params.seasonEndTime) return resResult(STATUS.WRONG_PARMS, null, '开始时间不可晚于结束时间');
if(params.seasonEndTime >= params.seasonRewardTime) return resResult(STATUS.WRONG_PARMS, null, '结束时间不可晚于奖励时间');
if(await PVPConfigModel.checkTime(params.seasonNum, params.seasonStartTime, params.seasonRewardTime)) {
return resResult(STATUS.WRONG_PARMS, null, '不可与其他赛季时间重叠');
}
let uid = session.get('uid');
await PVPConfigModel.createPVPConfig(params.seasonNum, params.getUpdateParam(), uid);
pinus.app.rpc.systimer.systimerRemote.setPvpSeasonSchedule.broadcast(true);
return resResult(STATUS.SUCCESS);
}
async initHiddenData(msg: {pubArr: number[], hideArr: number[], type: number}, session: BackendSession) {
let { pubArr = [], hideArr = [], type } = msg;
let uid = session.get('uid');
let datas = await HiddenDataByIdModel.findExistData(type);
let existIds = datas.map(cur => cur.id);
let insertParam: HiddenDataByIdModelTypeParam[] = [];
for(let id of pubArr) {
if(existIds.indexOf(id) == -1) {
insertParam.push({ type, id, publishTime: getPastTime(), createdBy: uid, updatedBy: uid });
}
}
for(let id of hideArr) {
if(existIds.indexOf(id) == -1) {
insertParam.push({ type, id, publishTime: getFutureTime(), createdBy: uid, updatedBy: uid });
}
}
await HiddenDataByIdModel.createDatas(insertParam);
await calHiddenData(uid);
await pinus.app.rpc.systimer.systimerRemote.gmSetHiddenDataSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
async saveHiddenData(msg: UpdateHiddenDataParam, session: BackendSession) {
let params = new UpdateHiddenDataParam(msg);
if(!params.checkParams()) return resResult(STATUS.WRONG_PARMS);
let uid = session.get('uid');
let heroes: number[] = [], goods: number[] = [];
for(let {type, id} of params.arr) {
if(type == 1) heroes.push(id);
if(type == 2) goods.push(id);
}
if(!isDevelopEnv()) {
if(!await HiddenDataByIdModel.checkById(1, heroes, params.publishTime) || !await HiddenDataByIdModel.checkById(2, goods, params.publishTime)) {
return resResult(STATUS.GM_OLD_REF_TIME_ERR);
}
}
for(let {type, id} of params.arr) {
await HiddenDataByIdModel.updateData(type, id, params.publishTime, uid);
}
await calHiddenData(uid);
await pinus.app.rpc.systimer.systimerRemote.gmSetHiddenDataSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
async setServerOpenTime(msg: { serverId: number, serverOpenTime: number }, session: BackendSession) {
let { serverId, serverOpenTime } = msg;
if(!isTimestamp(serverOpenTime)) return resResult(STATUS.WRONG_PARMS);
let server = await ServerlistModel.findByServerId(serverId);
if(!server) return resResult(STATUS.WRONG_PARMS);
let region = await RegionModel.findRegionById(server.regionId);
if(!region) return resResult(STATUS.WRONG_PARMS);
server = await ServerlistModel.updateByServerId(serverId, { openTime: serverOpenTime });
if(server.id == region.latestServerUniqId) {
region = await RegionModel.updateRegion(server.regionId, { latestServerOpenTime: server.openTime })
}
await redisClient().hsetAsync(REDIS_KEY.SERVER_OPEN_TIME, `${server.id}`, `${server.openTime}`);
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,85 +1,86 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { setServerGroup } from '../../../services/serverService';
import { errlogger } from '../../../util/logger';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import { gameData, reloadResources } from '../../../pubUtils/data';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new GMRemote(app);
}
// rpc 定义挪到单独的定义文件(user.rpc.define.ts)。解决ts-node 有可能找不到定义的问题。
// 你也可以用其它方法解决,或者没有遇到过这个问题的话,定义还是可以放在这里。
// UserRpc的命名空间自动合并
// declare global {
// interface UserRpc {
// chat: {
// GMRemote: RemoterClass<FrontendSession, GMRemote>;
// };
// }
// }
export class GMRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
await setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { setServerGroup } from '../../../services/serverService';
import { errlogger } from '../../../util/logger';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import { gameData, reloadResources } from '@pubUtils/data';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new GMRemote(app);
}
// rpc 定义挪到单独的定义文件(user.rpc.define.ts)。解决ts-node 有可能找不到定义的问题。
// 你也可以用其它方法解决,或者没有遇到过这个问题的话,定义还是可以放在这里。
// UserRpc的命名空间自动合并
// declare global {
// interface UserRpc {
// chat: {
// GMRemote: RemoterClass<FrontendSession, GMRemote>;
// };
// }
// }
export class GMRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
await setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,68 +1,69 @@
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { GUILD_AUTH_CHECK_TYPE, GUILD_OPERATE, GUILD_ROUTE_TO_OPERATE, STATUS } from "../../../consts";
import { UserGuildModel, UserGuildType } from "../../../db/UserGuild";
import { checkAuth, setUserGuildSession } from "../../../services/guildService";
export function guildAuthFilter(app: Application) {
return new Filter(app);
}
var Filter = function(this: any, app: Application) {
this.app = app;
};
Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
const roleId: string = session.get('roleId');
let guildCode: string = session.get('guildCode');
let guildAuth: number = session.get('guildAuth');
// console.log('********guildAuth', guildAuth);
const { code, roleId: hisRoleId } = msg;
let route = routeRecord.route;
if(GUILD_ROUTE_TO_OPERATE.has(route)) {
let myUserGuild: UserGuildType;
let hisUserGuild: UserGuildType;
if(!guildAuth) {
myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
if(myUserGuild) {
guildCode = myUserGuild.guildCode;
guildAuth = myUserGuild.auth;
}
setUserGuildSession(session, myUserGuild);
}
let arr = GUILD_ROUTE_TO_OPERATE.get(route);
for(let { operate, type } of arr) {
if( type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF) {
myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
} else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF_IF_EXIST) {
if(!!guildCode) {
myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
}
} else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_OTHERS) {
hisUserGuild = await UserGuildModel.getMyGuild(hisRoleId, 'auth guildCode job');
const checkResult = await checkAuth(operate, code||guildCode, hisUserGuild?.auth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
} else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION) {
const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
}
}
msg.myUserGuild = myUserGuild;
msg.hisUserGuild = hisUserGuild;
}
next(null);
};
Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
next(err);
};
import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback } from "pinus";
import { resResult } from "@pubUtils/util";
import { GUILD_AUTH_CHECK_TYPE, GUILD_OPERATE, GUILD_ROUTE_TO_OPERATE, STATUS } from "@consts";
import { UserGuildModel, UserGuildType } from "@db/UserGuild";
import { checkAuth, setUserGuildSession } from "@pubUtils/guildService";
export function guildAuthFilter(app: Application) {
return new Filter(app);
}
var Filter = function(this: any, app: Application) {
this.app = app;
};
Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
const roleId: string = session.get('roleId');
let guildCode: string = session.get('guildCode');
let guildAuth: number = session.get('guildAuth');
// console.log('********guildAuth', guildAuth);
const { code, roleId: hisRoleId } = msg;
let route = routeRecord.route;
if(GUILD_ROUTE_TO_OPERATE.has(route)) {
let myUserGuild: UserGuildType;
let hisUserGuild: UserGuildType;
if(!guildAuth) {
myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
if(myUserGuild) {
guildCode = myUserGuild.guildCode;
guildAuth = myUserGuild.auth;
}
setUserGuildSession(session, myUserGuild);
}
let arr = GUILD_ROUTE_TO_OPERATE.get(route);
for(let { operate, type } of arr) {
if( type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF) {
myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
} else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF_IF_EXIST) {
if(!!guildCode) {
myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
}
} else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_OTHERS) {
hisUserGuild = await UserGuildModel.getMyGuild(hisRoleId, 'auth guildCode job');
const checkResult = await checkAuth(operate, code||guildCode, hisUserGuild?.auth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
} else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION) {
const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
}
}
msg.myUserGuild = myUserGuild;
msg.hisUserGuild = hisUserGuild;
}
next(null);
};
Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
next(err);
};

View File

@@ -1,399 +1,400 @@
import { DividendModel, DividendType } from './../../../db/Dividend';
import { Application, BackendSession, ChannelService, HandlerService, pinus, } from "pinus";
import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS, CHANNEL_PREFIX, MAIL_TYPE, ITEM_CHANGE_REASON, TA_EVENT, ROLE_RECEIVE_STATUS, PUSH_ROUTE, AUCTION_BID_EXTEND_TIME } from "../../../consts";
import { LotModel, LotParam } from "../../../db/Lot";
import { ItemReward } from "../../../domain/dbGeneral";
import { genCode, resResult } from "../../../pubUtils/util";
import { auctionStage, calculateDividend, genAuction, sendUngotDividend, startGuildAuction, startWorldAuction, stopAuction, todayGuildBegin, getBasePrice, debugAuctionLots, officialAuctionLots, auctionBidStatus, getMaxPrice, guildBidStatus, getAuction, pushAuctionOver, pushAuctionUpdate, processDividendFormat, processSingleDividendFormat, tomorrowGuildBegin, processLotsFormat, processSingleLotFormat, getAuctionRewardByPoolId, getLotStatus, extendLotTime } from "../../../services/auctionService";
import { addItems, getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getSimpleRoleInfo } from '../../../services/roleService';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { lockData } from '../../../services/redLockService';
import { GuildModel } from '../../../db/Guild';
import { RoleModel, RoleType } from '../../../db/Role';
import { openGuildRefine } from '../../../services/guildRefineService';
import { unlockTrain } from '../../../services/guildTrainService';
import { UserGuildModel } from '../../../db/UserGuild';
import { UserGuildApplyModel } from '../../../db/UserGuildApply';
import * as dicParam from '../../../pubUtils/dicParam';
import { gameData } from '../../../pubUtils/data';
import { sendMailByContent } from '../../../services/mailService';
import { reportTAEvent } from '../../../services/sdkService';
import { sendMessageToGuildWithSuc, sendMessageToServerWithSuc } from '../../../services/pushService';
import { LOTS_KEEP_TO_WORLD_CNT } from '../../../consts';
export default function (app: Application) {
new HandlerService(app, {});
return new AuctionHandler(app);
}
export class AuctionHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
async getAuction(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
const guildCode = session.get('guildCode');
let result = await getAuction(guildCode, session, magicWord);
return resResult(STATUS.SUCCESS, result);
}
async leaveAuction(msg: {}, session: BackendSession) {
return resResult(STATUS.SUCCESS);
}
async offer(msg: { code: string, max: boolean, auctionStage: number, magicWord: string }, session: BackendSession) {
const { code, max, auctionStage, magicWord } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const ip = session.get('ip');
let res: any = await lockData(serverId, DATA_NAME.AUCTION_LOT, '');// 加锁
try {
if (!!res.err) {
return resResult(STATUS.REDLOCK_ERR);
}
const lot = await LotModel.findLot(code);
if (!lot) {
res.releaseCallback();
return resResult(STATUS.GUILD_LOT_NOT_FOUND);
}
if (lot.status === LOT_STATUS.SOLD || lot.status === LOT_STATUS.MAX) {
res.releaseCallback();
return resResult(STATUS.GUILD_LOT_HAS_SOLD);
}
if (auctionStage === AUCTION_STAGE.GUILD && lot.guildCode !== guildCode) {
res.releaseCallback();
return resResult(STATUS.AUCTION_GUILD_MEMBER_ONLY);
}
let { curBuyer, curPrice, prePrice, maxPrice, gid, count, bidRoles, watchingRoles, seq, begin, auctionStage: lotAuctionStage } = lot;
if (auctionStage != lotAuctionStage) {
res.releaseCallback();
return resResult(STATUS.AUCITON_STAGE_ERR);
}
if (curBuyer === roleId && !max) {
res.releaseCallback();
return resResult(STATUS.LOT_OFFER_SERIAL);
}
let newPrice = Math.floor(curPrice * dicParam.GUILD_AUCTION.AUCTION_PRICE_RISE);
let maxFlag = max;
if (maxFlag) {
curPrice = maxPrice;
}
if (curPrice >= maxPrice) {
curPrice = maxPrice;
newPrice = maxPrice;
maxFlag = true;
}
if(newPrice > maxPrice) {
newPrice = maxPrice;
}
const costRes = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: curPrice }], ITEM_CHANGE_REASON.AUCTION_OFFER);
if (!costRes) {
res.releaseCallback();
return resResult(STATUS.ROLE_COIN_NOT_ENOUGH);
}
bidRoles.push({ roleId, price: newPrice, time: new Date() });
let lotStatus = await getLotStatus(auctionStage, max, maxFlag)
let update: LotParam = { code, curBuyer: roleId, curPrice: newPrice, auctionStage, prePrice: curPrice, bidRoles, status: lotStatus, watchingRoles: Array.from(new Set([...watchingRoles, roleId])), seq: 0 };
if(lotStatus == LOT_STATUS.BIDDING) update.end = new Date(Date.now() + AUCTION_BID_EXTEND_TIME * 1000);
const newLot = await LotModel.updateLot(update);
if(!newLot) {
// 如果拍卖行状态不对那回退handleCost
if (curBuyer && prePrice > 0) {
await sendMailByContent(MAIL_TYPE.AUCTION_OVER, roleId, { goods: [getGoldObject(curPrice)] });
}
res.releaseCallback();
return resResult(STATUS.GUILD_LOT_HAS_SOLD);
} else {
if (curBuyer && prePrice > 0) {
await sendMailByContent(MAIL_TYPE.AUCTION_OVER, curBuyer, { goods: [getGoldObject(prePrice)] });
}
if (maxFlag) {
newPrice = maxPrice;
await sendMailByContent(MAIL_TYPE.AUTION_REWARD, roleId, { goods: [{ id: gid, count }] });
let dicGoods = gameData.goods.get(gid);
reportTAEvent(roleId, TA_EVENT.AUCTION_ITEM_GET, { item_name: dicGoods?.name, item_count: count, deel_price: newPrice }, ip);
}
}
await extendLotTime(newLot);
if(seq <= LOTS_KEEP_TO_WORLD_CNT && seq > 0) await LotModel.updateOne({ begin, gid, count, status: LOT_STATUS.DEFAULT, serverId, seq: { $gt: LOTS_KEEP_TO_WORLD_CNT } }, { $set: { seq }});
await pushAuctionOver(newLot); // 推送竞价超过标志
res.releaseCallback();
const incPrice = curPrice - prePrice > 0? prePrice: 0;
let newDividend: DividendType = null;
if (auctionStage === AUCTION_STAGE.GUILD) {
const dividend = await DividendModel.updateLot(code, gid, curPrice, incPrice, max);
newDividend = await calculateDividend(dividend);
await sendMessageToGuildWithSuc(guildCode, PUSH_ROUTE.DIVIDEND_UPDATE, { dividends: processDividendFormat([newDividend]) })
}
let newLotResult = processSingleLotFormat(newLot);
return resResult(STATUS.SUCCESS, { lot: newLotResult, dividend: processSingleDividendFormat(newDividend) });
} catch (e) {
console.log('offer got err:', e);
res.releaseCallback();
return resResult(STATUS.INTERNAL_ERR);
}
}
async watchLot(msg: { code: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { code } = msg;
const lot = await LotModel.watchLot(code, roleId);
if (!lot) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { lot: processSingleLotFormat(lot) });
}
async unWatchLot(msg: { code: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { code } = msg;
const lot = await LotModel.unWatchLot(code, roleId);
if (!lot) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { lot: processSingleLotFormat(lot) });
}
async checkDividend(msg: {}, session: BackendSession) {
const begin = await todayGuildBegin();
const tomorrowBegin = await tomorrowGuildBegin();
const guildCode = session.get('guildCode');
if(guildCode) {
const dividends = await DividendModel.findGuildDividendsByBegin(guildCode, [begin, tomorrowBegin]);
return resResult(STATUS.SUCCESS, { dividends: processDividendFormat(dividends) });
} else {
let roleId = session.get('roleId');
const dividends = await DividendModel.findDividendByRoleAndBegin(roleId, [begin, tomorrowBegin]);
return resResult(STATUS.SUCCESS, { dividends: processDividendFormat(dividends) });
}
}
async getDividend(msg: { code: string }, session: BackendSession) {
const roleId = session.get('roleId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const { code } = msg;
const dividendData = await DividendModel.findReadyDividend(code);
if (!dividendData) return resResult(STATUS.DIVIDEND_NOT_READY);
const { dividends } = dividendData;
const dividend = dividends.find(item => { return item.roleId === roleId });
if (!dividend || dividend.status == ROLE_RECEIVE_STATUS.YES) return resResult(STATUS.DIVIDEND_GUILD_PLAYER_ONLY);
let goods = await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: dividend.total }], ITEM_CHANGE_REASON.AUCTION_DIVIDEND);
await DividendModel.updateReceiveStatus(dividendData.code, roleId);
dividend.status = ROLE_RECEIVE_STATUS.YES;
return resResult(STATUS.SUCCESS, { dividend, goods });
}
async myWatching(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const begin = await todayGuildBegin();
const lots = await LotModel.watchingLotsByBegin(serverId, roleId, begin);
const stage = await auctionStage();
let newLots = await processLotsFormat(lots);
return resResult(STATUS.SUCCESS, { lots: stage === AUCTION_STAGE.END ? [] : newLots });
}
async offerRecs(msg: { count: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const lotsData = await LotModel.recentBidLots(serverId, roleId, msg.count);
const bidRecs = lotsData.map(lot => {
const bidRec = lot.bidRoles.find(role => { return role.roleId === roleId });
const { gid } = lot;
return { ...bidRec, gid, status: auctionBidStatus(roleId, lot) };
}).sort((a,b) => b.time.getTime() - a.time.getTime());
return resResult(STATUS.SUCCESS, { bidRecs });
}
async guildLotRecs(msg: { count: number }, session: BackendSession) {
const guildCode = session.get('guildCode');
const dividends = await DividendModel.findDividendsByGuild(guildCode, msg.count);
let lotsData = [];
dividends.forEach(dividend => {
const lots = dividend.lots.map(lot => {
return { ...lot, sourceType: dividend.sourceType, dividendStatus: dividend.status };
})
lotsData = [...lotsData, ...lots];
});
const lotRecs = lotsData.map(lot => {
const { gid, count, price: lotPrice } = lot;
// const price = lotPrice === 0 ? getBasePrice(gid, count) : lotPrice;
const sold = guildBidStatus(lot);
return { ...lot, price: lotPrice, sold };
}).sort((a,b) => b.time.getTime() - a.time.getTime());;
return resResult(STATUS.SUCCESS, { lotRecs });
}
// ! 测试接口
async debugSetDividendStatus(msg: { magicWord: string, sourceType: number, status: number }, session: BackendSession) {
const { magicWord, sourceType, status } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const guildCode: string = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND)
const dividend = await DividendModel.updateDividendStatus(guildCode, sourceType, status);
return resResult(STATUS.SUCCESS, { dividend });
}
// ! 测试接口
async debugSetLotStage(msg: { magicWord: string, code: string, auctionStage: number }, session: BackendSession) {
const { magicWord, code, auctionStage } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const lot = await LotModel.updateLotStage(code, auctionStage);
return resResult(STATUS.SUCCESS, { lot });
}
// ! 测试接口
async debugAddLots(msg: { magicWord: string, sourceType: number, sourceCode: string, poolId: number }, session: BackendSession) {
const { magicWord, sourceType, sourceCode, poolId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let guildCode: string = session.get('guildCode');
const serverId: number = session.get('serverId');
if (!guildCode) {//创建公会
const roleId = session.get('roleId');
const role: RoleType = await RoleModel.findByRoleId(roleId);
// 创建公会
const name = '测试公会'
const icon = 1
const notice = '测试公会'
const guild = await GuildModel.createGuild({ guildCode: genCode(6), name, icon, notice }, role, serverId);
if (!guild) return resResult(STATUS.GUILD_CREATE_ERROR);
guild.leader = <RoleType>guild.leader;
//创建科技树
await openGuildRefine(guild.code);
await unlockTrain(guild.code, 1);
const userGuild = await UserGuildModel.createUserGuild(guild.code, role, true);
if (!userGuild) return resResult(STATUS.GUILD_CREATE_ERROR);
await RoleModel.joinGuild(roleId, guild.code, guild.name, true);
await UserGuildApplyModel.deleteApply(roleId); // 删除玩家所有对其他公会的申请
guildCode = guild.code;
session.set('guildCode', guildCode);
session.push('guildCode', () => {});
}
let rewards = getAuctionRewardByPoolId(poolId);
if(!rewards) return resResult(STATUS.WRONG_PARMS);
const result = await genAuction(guildCode, sourceType, magicWord, serverId, rewards);
if (!result) {
return resResult(STATUS.WRONG_PARMS);
}
return resResult(STATUS.SUCCESS, result);
}
// ! 测试接口
async debugScheduleStartGuild(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await startGuildAuction();
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
// ! 测试接口
async debugScheduleStartWorld(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await startWorldAuction();
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
// ! 测试接口
async debugScheduleStopAuction(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await stopAuction();
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
// ! 测试接口
async debugScheduleSendUngotDividend(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await sendUngotDividend(true);
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
async debugSetPlayTime(msg: { magicWord: string, time: string }, session: BackendSession) {
const { magicWord, time } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let serverId = session.get('serverId');
await sendMessageToServerWithSuc(serverId, PUSH_ROUTE.PUSH_CURRENT_TIME, { time: new Date(time).getTime() });
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
/**
* 领取分红之前,修改分红数据信息,确保领取分红接口能正常跑通
* debugSetDividendStatus 和 debugSetDividendStatusV2 区别
* debugSetDividendStatus: 修改 DividendModel.status
* debugSetDividendStatus: 修改 DividendModel.status 和 DividendModel.dividends.status
*
* @param {{ magicWord: string, sourceType: number, status: number }} msg
* @param {BackendSession} session
* @return {*}
* @memberof AuctionHandler
*/
async debugSetDividendStatusV2(msg: { magicWord: string, sourceType: number, status: number }, session: BackendSession) {
const { magicWord, sourceType, status } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const guildCode: string = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND)
let dividend = await DividendModel.updateDividendStatus(guildCode, sourceType, status);
dividend.dividends.forEach(item => {
item.status = ROLE_RECEIVE_STATUS.NO
});
dividend = await DividendModel.updateDividend(dividend.code, { dividends: dividend.dividends })
return resResult(STATUS.SUCCESS, { dividend });
}
}
import { DividendModel, DividendType } from './../../../db/Dividend';
import { Application, BackendSession, ChannelService, HandlerService, pinus, } from "pinus";
import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS, CHANNEL_PREFIX, MAIL_TYPE, ITEM_CHANGE_REASON, TA_EVENT, ROLE_RECEIVE_STATUS, PUSH_ROUTE, AUCTION_BID_EXTEND_TIME } from "../../../consts";
import { LotModel, LotParam } from "@db/Lot";
import { ItemReward } from "@domain/dbGeneral";
import { genCode, resResult } from "@pubUtils/util";
import { auctionStage, calculateDividend, genAuction, sendUngotDividend, startGuildAuction, startWorldAuction, stopAuction, todayGuildBegin, getBasePrice, debugAuctionLots, officialAuctionLots, auctionBidStatus, getMaxPrice, guildBidStatus, getAuction, pushAuctionOver, pushAuctionUpdate, processDividendFormat, processSingleDividendFormat, tomorrowGuildBegin, processLotsFormat, processSingleLotFormat, getAuctionRewardByPoolId, getLotStatus, extendLotTime } from "../../../services/auctionService";
import { addItems, getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getSimpleRoleInfo } from '../../../services/roleService';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { lockData } from '../../../services/redLockService';
import { GuildModel } from '@db/Guild';
import { RoleModel, RoleType } from '@db/Role';
import { openGuildRefine } from '../../../services/guildRefineService';
import { unlockTrain } from '../../../services/guildTrainService';
import { UserGuildModel } from '@db/UserGuild';
import { UserGuildApplyModel } from '@db/UserGuildApply';
import * as dicParam from '@pubUtils/dicParam';
import { gameData } from '@pubUtils/data';
import { sendMailByContent } from '../../../services/mailService';
import { reportTAEvent } from '../../../services/sdkService';
import { sendMessageToGuildWithSuc, sendMessageToServerWithSuc } from '../../../services/pushService';
import { LOTS_KEEP_TO_WORLD_CNT } from '../../../consts';
export default function (app: Application) {
new HandlerService(app, {});
return new AuctionHandler(app);
}
export class AuctionHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
async getAuction(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
const guildCode = session.get('guildCode');
let result = await getAuction(guildCode, session, magicWord);
return resResult(STATUS.SUCCESS, result);
}
async leaveAuction(msg: {}, session: BackendSession) {
return resResult(STATUS.SUCCESS);
}
async offer(msg: { code: string, max: boolean, auctionStage: number, magicWord: string }, session: BackendSession) {
const { code, max, auctionStage, magicWord } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const ip = session.get('ip');
let res: any = await lockData(serverId, DATA_NAME.AUCTION_LOT, '');// 加锁
try {
if (!!res.err) {
return resResult(STATUS.REDLOCK_ERR);
}
const lot = await LotModel.findLot(code);
if (!lot) {
res.releaseCallback();
return resResult(STATUS.GUILD_LOT_NOT_FOUND);
}
if (lot.status === LOT_STATUS.SOLD || lot.status === LOT_STATUS.MAX) {
res.releaseCallback();
return resResult(STATUS.GUILD_LOT_HAS_SOLD);
}
if (auctionStage === AUCTION_STAGE.GUILD && lot.guildCode !== guildCode) {
res.releaseCallback();
return resResult(STATUS.AUCTION_GUILD_MEMBER_ONLY);
}
let { curBuyer, curPrice, prePrice, maxPrice, gid, count, bidRoles, watchingRoles, seq, begin, auctionStage: lotAuctionStage } = lot;
if (auctionStage != lotAuctionStage) {
res.releaseCallback();
return resResult(STATUS.AUCITON_STAGE_ERR);
}
if (curBuyer === roleId && !max) {
res.releaseCallback();
return resResult(STATUS.LOT_OFFER_SERIAL);
}
let newPrice = Math.floor(curPrice * dicParam.GUILD_AUCTION.AUCTION_PRICE_RISE);
let maxFlag = max;
if (maxFlag) {
curPrice = maxPrice;
}
if (curPrice >= maxPrice) {
curPrice = maxPrice;
newPrice = maxPrice;
maxFlag = true;
}
if(newPrice > maxPrice) {
newPrice = maxPrice;
}
const costRes = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: curPrice }], ITEM_CHANGE_REASON.AUCTION_OFFER);
if (!costRes) {
res.releaseCallback();
return resResult(STATUS.ROLE_COIN_NOT_ENOUGH);
}
bidRoles.push({ roleId, price: newPrice, time: new Date() });
let lotStatus = await getLotStatus(auctionStage, max, maxFlag)
let update: LotParam = { code, curBuyer: roleId, curPrice: newPrice, auctionStage, prePrice: curPrice, bidRoles, status: lotStatus, watchingRoles: Array.from(new Set([...watchingRoles, roleId])), seq: 0 };
if(lotStatus == LOT_STATUS.BIDDING) update.end = new Date(Date.now() + AUCTION_BID_EXTEND_TIME * 1000);
const newLot = await LotModel.updateLot(update);
if(!newLot) {
// 如果拍卖行状态不对那回退handleCost
if (curBuyer && prePrice > 0) {
await sendMailByContent(MAIL_TYPE.AUCTION_OVER, roleId, { goods: [getGoldObject(curPrice)] });
}
res.releaseCallback();
return resResult(STATUS.GUILD_LOT_HAS_SOLD);
} else {
if (curBuyer && prePrice > 0) {
await sendMailByContent(MAIL_TYPE.AUCTION_OVER, curBuyer, { goods: [getGoldObject(prePrice)] });
}
if (maxFlag) {
newPrice = maxPrice;
await sendMailByContent(MAIL_TYPE.AUTION_REWARD, roleId, { goods: [{ id: gid, count }] });
let dicGoods = gameData.goods.get(gid);
reportTAEvent(roleId, TA_EVENT.AUCTION_ITEM_GET, { item_name: dicGoods?.name, item_count: count, deel_price: newPrice }, ip);
}
}
await extendLotTime(newLot);
if(seq <= LOTS_KEEP_TO_WORLD_CNT && seq > 0) await LotModel.updateOne({ begin, gid, count, status: LOT_STATUS.DEFAULT, serverId, seq: { $gt: LOTS_KEEP_TO_WORLD_CNT } }, { $set: { seq }});
await pushAuctionOver(newLot); // 推送竞价超过标志
res.releaseCallback();
const incPrice = curPrice - prePrice > 0? prePrice: 0;
let newDividend: DividendType = null;
if (auctionStage === AUCTION_STAGE.GUILD) {
const dividend = await DividendModel.updateLot(code, gid, curPrice, incPrice, max);
newDividend = await calculateDividend(dividend);
await sendMessageToGuildWithSuc(guildCode, PUSH_ROUTE.DIVIDEND_UPDATE, { dividends: processDividendFormat([newDividend]) })
}
let newLotResult = processSingleLotFormat(newLot);
return resResult(STATUS.SUCCESS, { lot: newLotResult, dividend: processSingleDividendFormat(newDividend) });
} catch (e) {
console.log('offer got err:', e);
res.releaseCallback();
return resResult(STATUS.INTERNAL_ERR);
}
}
async watchLot(msg: { code: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { code } = msg;
const lot = await LotModel.watchLot(code, roleId);
if (!lot) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { lot: processSingleLotFormat(lot) });
}
async unWatchLot(msg: { code: string }, session: BackendSession) {
const roleId = session.get('roleId');
const { code } = msg;
const lot = await LotModel.unWatchLot(code, roleId);
if (!lot) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { lot: processSingleLotFormat(lot) });
}
async checkDividend(msg: {}, session: BackendSession) {
const begin = await todayGuildBegin();
const tomorrowBegin = await tomorrowGuildBegin();
const guildCode = session.get('guildCode');
if(guildCode) {
const dividends = await DividendModel.findGuildDividendsByBegin(guildCode, [begin, tomorrowBegin]);
return resResult(STATUS.SUCCESS, { dividends: processDividendFormat(dividends) });
} else {
let roleId = session.get('roleId');
const dividends = await DividendModel.findDividendByRoleAndBegin(roleId, [begin, tomorrowBegin]);
return resResult(STATUS.SUCCESS, { dividends: processDividendFormat(dividends) });
}
}
async getDividend(msg: { code: string }, session: BackendSession) {
const roleId = session.get('roleId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const { code } = msg;
const dividendData = await DividendModel.findReadyDividend(code);
if (!dividendData) return resResult(STATUS.DIVIDEND_NOT_READY);
const { dividends } = dividendData;
const dividend = dividends.find(item => { return item.roleId === roleId });
if (!dividend || dividend.status == ROLE_RECEIVE_STATUS.YES) return resResult(STATUS.DIVIDEND_GUILD_PLAYER_ONLY);
let goods = await addItems(roleId, roleName, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: dividend.total }], ITEM_CHANGE_REASON.AUCTION_DIVIDEND);
await DividendModel.updateReceiveStatus(dividendData.code, roleId);
dividend.status = ROLE_RECEIVE_STATUS.YES;
return resResult(STATUS.SUCCESS, { dividend, goods });
}
async myWatching(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const begin = await todayGuildBegin();
const lots = await LotModel.watchingLotsByBegin(serverId, roleId, begin);
const stage = await auctionStage();
let newLots = await processLotsFormat(lots);
return resResult(STATUS.SUCCESS, { lots: stage === AUCTION_STAGE.END ? [] : newLots });
}
async offerRecs(msg: { count: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const lotsData = await LotModel.recentBidLots(serverId, roleId, msg.count);
const bidRecs = lotsData.map(lot => {
const bidRec = lot.bidRoles.find(role => { return role.roleId === roleId });
const { gid } = lot;
return { ...bidRec, gid, status: auctionBidStatus(roleId, lot) };
}).sort((a,b) => b.time.getTime() - a.time.getTime());
return resResult(STATUS.SUCCESS, { bidRecs });
}
async guildLotRecs(msg: { count: number }, session: BackendSession) {
const guildCode = session.get('guildCode');
const dividends = await DividendModel.findDividendsByGuild(guildCode, msg.count);
let lotsData = [];
dividends.forEach(dividend => {
const lots = dividend.lots.map(lot => {
return { ...lot, sourceType: dividend.sourceType, dividendStatus: dividend.status };
})
lotsData = [...lotsData, ...lots];
});
const lotRecs = lotsData.map(lot => {
const { gid, count, price: lotPrice } = lot;
// const price = lotPrice === 0 ? getBasePrice(gid, count) : lotPrice;
const sold = guildBidStatus(lot);
return { ...lot, price: lotPrice, sold };
}).sort((a,b) => b.time.getTime() - a.time.getTime());;
return resResult(STATUS.SUCCESS, { lotRecs });
}
// ! 测试接口
async debugSetDividendStatus(msg: { magicWord: string, sourceType: number, status: number }, session: BackendSession) {
const { magicWord, sourceType, status } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const guildCode: string = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND)
const dividend = await DividendModel.updateDividendStatus(guildCode, sourceType, status);
return resResult(STATUS.SUCCESS, { dividend });
}
// ! 测试接口
async debugSetLotStage(msg: { magicWord: string, code: string, auctionStage: number }, session: BackendSession) {
const { magicWord, code, auctionStage } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const lot = await LotModel.updateLotStage(code, auctionStage);
return resResult(STATUS.SUCCESS, { lot });
}
// ! 测试接口
async debugAddLots(msg: { magicWord: string, sourceType: number, sourceCode: string, poolId: number }, session: BackendSession) {
const { magicWord, sourceType, sourceCode, poolId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let guildCode: string = session.get('guildCode');
const serverId: number = session.get('serverId');
if (!guildCode) {//创建公会
const roleId = session.get('roleId');
const role: RoleType = await RoleModel.findByRoleId(roleId);
// 创建公会
const name = '测试公会'
const icon = 1
const notice = '测试公会'
const guild = await GuildModel.createGuild({ guildCode: genCode(6), name, icon, notice }, role, serverId);
if (!guild) return resResult(STATUS.GUILD_CREATE_ERROR);
guild.leader = <RoleType>guild.leader;
//创建科技树
await openGuildRefine(guild.code);
await unlockTrain(guild.code, 1);
const userGuild = await UserGuildModel.createUserGuild(guild.code, role, true);
if (!userGuild) return resResult(STATUS.GUILD_CREATE_ERROR);
await RoleModel.joinGuild(roleId, guild.code, guild.name, true);
await UserGuildApplyModel.deleteApply(roleId); // 删除玩家所有对其他公会的申请
guildCode = guild.code;
session.set('guildCode', guildCode);
session.push('guildCode', () => {});
}
let rewards = getAuctionRewardByPoolId(poolId);
if(!rewards) return resResult(STATUS.WRONG_PARMS);
const result = await genAuction(guildCode, sourceType, magicWord, serverId, rewards);
if (!result) {
return resResult(STATUS.WRONG_PARMS);
}
return resResult(STATUS.SUCCESS, result);
}
// ! 测试接口
async debugScheduleStartGuild(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await startGuildAuction();
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
// ! 测试接口
async debugScheduleStartWorld(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await startWorldAuction();
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
// ! 测试接口
async debugScheduleStopAuction(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await stopAuction();
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
// ! 测试接口
async debugScheduleSendUngotDividend(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const result = await sendUngotDividend(true);
if (result === true) {
return resResult(STATUS.SUCCESS);
}
return resResult(STATUS.INTERNAL_ERR);
}
async debugSetPlayTime(msg: { magicWord: string, time: string }, session: BackendSession) {
const { magicWord, time } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let serverId = session.get('serverId');
await sendMessageToServerWithSuc(serverId, PUSH_ROUTE.PUSH_CURRENT_TIME, { time: new Date(time).getTime() });
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
/**
* 领取分红之前,修改分红数据信息,确保领取分红接口能正常跑通
* debugSetDividendStatus 和 debugSetDividendStatusV2 区别
* debugSetDividendStatus: 修改 DividendModel.status
* debugSetDividendStatus: 修改 DividendModel.status 和 DividendModel.dividends.status
*
* @param {{ magicWord: string, sourceType: number, status: number }} msg
* @param {BackendSession} session
* @return {*}
* @memberof AuctionHandler
*/
async debugSetDividendStatusV2(msg: { magicWord: string, sourceType: number, status: number }, session: BackendSession) {
const { magicWord, sourceType, status } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const guildCode: string = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND)
let dividend = await DividendModel.updateDividendStatus(guildCode, sourceType, status);
dividend.dividends.forEach(item => {
item.status = ROLE_RECEIVE_STATUS.NO
});
dividend = await DividendModel.updateDividend(dividend.code, { dividends: dividend.dividends })
return resResult(STATUS.SUCCESS, { dividend });
}
}

View File

@@ -1,425 +1,426 @@
import { Application, ChannelService, BackendSession, pinus, HandlerService, } from "pinus";
import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { genCode, resResult } from "../../../pubUtils/util";
import { getGuildActivityStatus, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex, sendCityGuildRankToUser } from "../../../services/guildActivity/guildActivityService";
import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
import { gameData } from "../../../pubUtils/data";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
import { leaveCityChannel, addRoleToCityChannel } from "../../../services/chatService";
import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { nowSeconds, getTimeFun } from "../../../pubUtils/timeUtil";
import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
import { getGoldObject, handleCost } from "../../../services/role/rewardService";
import { Rank } from "../../../services/rankService";
import { checkTask } from "../../../services/task/taskService";
import { guildInter } from "../../../pubUtils/interface";
import { dispatch } from "../../../pubUtils/dispatcher";
import { ServerRecordModel } from "../../../db/ServerRecords";
import { sendMessageToCityWithSuc } from "../../../services/pushService";
import { isDebugTime } from "../../../pubUtils/sdkUtil";
import { GuildActivityCityDeclareModel } from "../../../db/GuildActivityCityDeclare";
import { GuildModel } from "../../../db/Guild";
import { getHistoryCity, redisClient, setHistoryCity } from "../../../services/redisService";
import { HeroModel } from "../../../db/Hero";
import { getCityActivityObj } from "../../../services/memoryCache/guildActivityData";
export default function (app: Application) {
new HandlerService(app, {});
return new CityActivityHandler(app);
}
export class CityActivityHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
private aid = GUILD_ACTIVITY_TYPE.CITY_ACTIVITY; // 诸侯混战id
// 进入诸侯混战
async getCityActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let obj = getCityActivityObj();
if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
await autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
}
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cities = getCities(guildCode, dbCities);
let guildActivityRec = await GuildActivityRecordModel.findByGuild(guildCode, this.aid, index);
let ranks = await getCityActivityRank(guildCode, serverId, guildActivityRec?.challengeCityId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
...statusResult,
cities,
...ranks
});
}
// 获取单个城池状态
async getCityStatus(msg: { cityId: number }, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let sid = session.get('sid');
const { cityId } = msg;
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicCity = gameData.cityActivity.get(cityId);
if (!dicCity) return resResult(STATUS.CITY_NOT_FOUND);
let obj = getCityActivityObj();
let {gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId);
let guildActivityRec = await GuildActivityRecordModel.findByGuild(guildCode, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let myGuildActivityRec = await UserGuildActivityRecModel.findByRoleId(roleId, guildActivityRec.code);
let challengeTime = 0;
if (myGuildActivityRec) {
challengeTime = myGuildActivityRec.challengeTime;
}
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
if (cityStatus == CITY_STATUS.DECLARED) {
obj.pushGuild(guildCode, serverId, cityId);
}
let historyCity = await getHistoryCity(roleId);
if (historyCity) {
await leaveCityChannel(roleId, sid, serverId, `${historyCity}`);
}
await addRoleToCityChannel(roleId, sid, serverId, cityId);
await setHistoryCity(roleId, cityId);
let ranks = await getCityActivityRank(guildCode, serverId, cityId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
cityId,
...statusResult,
cityStatus,
gateHp, maxHp,
challengeTime,
...ranks
});
}
// 宣战
async declareCity(msg: { cityId: number }, session: BackendSession) {
const roleId = session.get('roleId');
// const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let { cityId } = msg;
let dicCity = gameData.cityActivity.get(cityId);
if (dicCity.preCity.length > 0) return resResult(STATUS.CAN_NOT_DECLARE);
let declareIndex = getDeclareIndex();
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if (!!checkResult) return resResult(STATUS.HAS_DECLARED);
await GuildActivityCityModel.getCity(serverId, cityId, declareIndex);
let declareResult = await declareCity(serverId, roleId, guildCode, cityId, false, declareIndex);
if(!declareResult) return resResult(STATUS.HAS_DECLARED);
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cities = getCities(guildCode, dbCities);
return resResult(STATUS.SUCCESS, { cities });
}
// 开始挑战
async checkBattle(msg: guildInter & { cityId: number, heroes: number[] }, session: BackendSession) {
let { cityId, heroes, myUserGuild: userGuild } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if (!checkResult) return resResult(STATUS.HAS_NOT_DECLARED);
let obj = getCityActivityObj();
const dicCity = gameData.cityActivity.get(cityId);
if (!dicCity) return resResult(STATUS.CITY_NOT_FOUND);
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
if (gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index, [], cityId);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
if (myGuildActivityRec.challengeTime > nowSeconds()) {
return resResult(STATUS.CHALLENGE_TIME_NOT_REACH);
}
myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
let { code } = myGuildActivityRec;
// 更新公会参与的玩家
obj.pushMembers(guildCode, roleId, userGuild.job, myGuildActivityRec.code);
// 返回当前军团总军功
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ACTIVITY, { aid: this.aid });
return resResult(STATUS.SUCCESS, {
code,
cityId,
cityStatus,
...statusResult,
gateHp, maxHp,
guildScore,
myScore: 0
});
}
async resetChallengeTime(msg: {}, session: BackendSession) {
if(1==1) return resResult(STATUS.FUNCTION_CLOSE);
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let guildActivityRec = await GuildActivityRecordModel.findByGuild(guildCode, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
let goldObj = getGoldObject(GUILDACTIVITY.CITYACTIVITY_CD_COST);
const costRes = await handleCost(roleId, sid, [goldObj], ITEM_CHANGE_REASON.CITY_ACT_RESET_CHALLENGE_TIME);
if (!costRes) {
return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
}
myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(myGuildActivityRec.code, { challengeTime: 0 });
return resResult(STATUS.SUCCESS, {
challengeTime: myGuildActivityRec.challengeTime
});
}
// 上报城门受到伤害
async hitGate(msg: { cityId: number, code: string, damage: number, hid: number, round: number, timegap: number, roundTime: number }, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let { cityId, code, damage, hid, round, timegap = 0, roundTime = 0 } = msg;
let obj = getCityActivityObj();
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
if (gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
let member = obj.getMember(guildCode, roleId);
if(!member) return resResult(STATUS.NOT_CHECK_BATTLE);
if(!member.startActionTime || member.startActionTime == 0) {
member.startActionTime = nowSeconds();
}
if ((roundTime > 0 && roundTime < 500) || (timegap - (nowSeconds() - member.startActionTime) > 5)) { // 前后端误差超过5秒拦截
return resResult(STATUS.SUCCESS, {
isError: true,
timegap: nowSeconds() - member.startActionTime
});
}
let hero = await HeroModel.findBySeqIdAndRole(hid, roleId);
if(!hero && (damage/maxHp > 0.01)) damage = 0;
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) {
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
isError: false,
timegap: nowSeconds() - member.startActionTime,
})
}
let challengeTime = nowSeconds() + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
if(isDebugTime()) {
let guilds = pinus.app.getServersByType('guild');
let guild = await dispatch(redisClient(), roleId, guilds, 'guild');
let currentTime = await pinus.app.rpc.guild.guildActivityRemote.getCurrentTime.toServer(guild.id);
challengeTime = Math.floor(currentTime/1000) + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
}
let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage }, challengeTime);
if (!pushResult) return resResult(STATUS.WRONG_PARMS);
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
// 更新redis数据
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.setRankWithRoleInfo(roleId, damage, obj.getTimeGap(), null, true);
await myR.setExpire(nextWeek);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.setRankWithGuildInfo(guildCode, damage, obj.getTimeGap(), null, true);
await r.setExpire(nextWeek);
({gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId, -1 * damage));
if (gateHp <= 0) {
// 推送 停止活动并结算奖励
await sendSingleCityActEndMsg(cityId, serverId);
}
// 推送 城门血量
await sendMessageToCityWithSuc(serverId, cityId, PUSH_ROUTE.GUILD_CITY_ACT_HP, { cityId, gateHp, maxHp });
await sendCityGuildRankToUser(serverId, cityId, guildCode, roleId);
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
guildScore,
myScore,
gateHp,
isError: false,
timegap: nowSeconds() - member.startActionTime,
})
}
// 结束挑战
async battleEnd(msg: { cityId: number, code: string, isSuccess: boolean }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { cityId, code, isSuccess } = msg;
let obj = getCityActivityObj();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicCity = gameData.cityActivity.get(cityId);
if (!dicCity) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let challengeTime = nowSeconds() + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
if(isDebugTime()) {
let guilds = pinus.app.getServersByType('guild');
let guild = await dispatch(redisClient(), roleId, guilds, 'guild');
let currentTime = await pinus.app.rpc.guild.guildActivityRemote.getCurrentTime.toServer(guild.id);
challengeTime = Math.floor(currentTime/1000) + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
}
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true, cityId, challengeTime });
if (!myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
// 返回当前军团总军功
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.getMyScore({ roleId });
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
return resResult(STATUS.SUCCESS, {
isSuccess,
code,
...statusResult,
guildScore,
myScore,
gateHp,
maxHp,
challengeTime: myGuildActivityRec.challengeTime
});
}
async debugTestAutoDeclare(msg: { }, session: BackendSession) {
let serverId = session.get('serverId');
let roleId = session.get('roleId');
let guildCode = session.get('guildCode');
let declareIndex = getDeclareIndex();
for(let i = 0; i < 1000; i++) {
autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
}
return resResult(STATUS.SUCCESS)
}
private interval: NodeJS.Timer;
async debugStartHitGate(msg: { param: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { param = 1000 } = msg;
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(this.interval) {
clearInterval(this.interval);
}
let fun = async () => {
for(let [cityId] of gameData.cityActivity) {
let guilds = pinus.app.getServersByType('guild');
let guild = await dispatch(redisClient(), `${cityId}`, guilds, 'guild');
await pinus.app.rpc.guild.guildActivityRemote.debugSendGateHp.toServer(guild.id, serverId, cityId);
}
await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.broadcast(this.aid);
};
await fun();
this.interval = setInterval(fun, param)
return resResult(STATUS.SUCCESS)
}
async debugStopHitGate(msg: { magicWord: string }, session: BackendSession) {
if(this.interval) {
clearInterval(this.interval);
}
return resResult(STATUS.SUCCESS);
}
}
import { Application, ChannelService, BackendSession, pinus, HandlerService, } from "pinus";
import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { genCode, resResult } from "@pubUtils/util";
import { getGuildActivityStatus, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex, sendCityGuildRankToUser } from "../../../services/guildActivity/guildActivityService";
import { GuildActivityCityModel } from "@db/GuildActivityCity";
import { gameData } from "@pubUtils/data";
import { UserGuildActivityRecModel } from "@db/UserGuildActivityRec";
import { leaveCityChannel, addRoleToCityChannel } from "../../../services/chatService";
import { GuildActivityRecordModel } from "@db/GuildActivityRec";
import { nowSeconds, getTimeFun } from "@pubUtils/timeUtil";
import { GUILDACTIVITY } from "@pubUtils/dicParam";
import { getGoldObject, handleCost } from "../../../services/role/rewardService";
import { Rank } from "../../../services/rankService";
import { checkTask } from "../../../services/task/taskService";
import { guildInter } from "@pubUtils/interface";
import { dispatch } from "@pubUtils/dispatcher";
import { ServerRecordModel } from "@db/ServerRecords";
import { sendMessageToCityWithSuc } from "../../../services/pushService";
import { isDebugTime } from "@pubUtils/sdkUtil";
import { GuildActivityCityDeclareModel } from "@db/GuildActivityCityDeclare";
import { GuildModel } from "@db/Guild";
import { getHistoryCity, redisClient, setHistoryCity } from "../../../services/redisService";
import { HeroModel } from "@db/Hero";
import { getCityActivityObj } from "../../../services/memoryCache/guildActivityData";
export default function (app: Application) {
new HandlerService(app, {});
return new CityActivityHandler(app);
}
export class CityActivityHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
private aid = GUILD_ACTIVITY_TYPE.CITY_ACTIVITY; // 诸侯混战id
// 进入诸侯混战
async getCityActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let obj = getCityActivityObj();
if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
await autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
}
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cities = getCities(guildCode, dbCities);
let guildActivityRec = await GuildActivityRecordModel.findByGuild(guildCode, this.aid, index);
let ranks = await getCityActivityRank(guildCode, serverId, guildActivityRec?.challengeCityId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
...statusResult,
cities,
...ranks
});
}
// 获取单个城池状态
async getCityStatus(msg: { cityId: number }, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let sid = session.get('sid');
const { cityId } = msg;
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicCity = gameData.cityActivity.get(cityId);
if (!dicCity) return resResult(STATUS.CITY_NOT_FOUND);
let obj = getCityActivityObj();
let {gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId);
let guildActivityRec = await GuildActivityRecordModel.findByGuild(guildCode, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let myGuildActivityRec = await UserGuildActivityRecModel.findByRoleId(roleId, guildActivityRec.code);
let challengeTime = 0;
if (myGuildActivityRec) {
challengeTime = myGuildActivityRec.challengeTime;
}
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
if (cityStatus == CITY_STATUS.DECLARED) {
obj.pushGuild(guildCode, serverId, cityId);
}
let historyCity = await getHistoryCity(roleId);
if (historyCity) {
await leaveCityChannel(roleId, sid, serverId, `${historyCity}`);
}
await addRoleToCityChannel(roleId, sid, serverId, cityId);
await setHistoryCity(roleId, cityId);
let ranks = await getCityActivityRank(guildCode, serverId, cityId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
cityId,
...statusResult,
cityStatus,
gateHp, maxHp,
challengeTime,
...ranks
});
}
// 宣战
async declareCity(msg: { cityId: number }, session: BackendSession) {
const roleId = session.get('roleId');
// const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let { cityId } = msg;
let dicCity = gameData.cityActivity.get(cityId);
if (dicCity.preCity.length > 0) return resResult(STATUS.CAN_NOT_DECLARE);
let declareIndex = getDeclareIndex();
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if (!!checkResult) return resResult(STATUS.HAS_DECLARED);
await GuildActivityCityModel.getCity(serverId, cityId, declareIndex);
let declareResult = await declareCity(serverId, roleId, guildCode, cityId, false, declareIndex);
if(!declareResult) return resResult(STATUS.HAS_DECLARED);
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cities = getCities(guildCode, dbCities);
return resResult(STATUS.SUCCESS, { cities });
}
// 开始挑战
async checkBattle(msg: guildInter & { cityId: number, heroes: number[] }, session: BackendSession) {
let { cityId, heroes, myUserGuild: userGuild } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if (!checkResult) return resResult(STATUS.HAS_NOT_DECLARED);
let obj = getCityActivityObj();
const dicCity = gameData.cityActivity.get(cityId);
if (!dicCity) return resResult(STATUS.CITY_NOT_FOUND);
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
if (gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index, [], cityId);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
if (myGuildActivityRec.challengeTime > nowSeconds()) {
return resResult(STATUS.CHALLENGE_TIME_NOT_REACH);
}
myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
let { code } = myGuildActivityRec;
// 更新公会参与的玩家
obj.pushMembers(guildCode, roleId, userGuild.job, myGuildActivityRec.code);
// 返回当前军团总军功
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ACTIVITY, { aid: this.aid });
return resResult(STATUS.SUCCESS, {
code,
cityId,
cityStatus,
...statusResult,
gateHp, maxHp,
guildScore,
myScore: 0
});
}
async resetChallengeTime(msg: {}, session: BackendSession) {
if(1==1) return resResult(STATUS.FUNCTION_CLOSE);
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let guildActivityRec = await GuildActivityRecordModel.findByGuild(guildCode, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
let goldObj = getGoldObject(GUILDACTIVITY.CITYACTIVITY_CD_COST);
const costRes = await handleCost(roleId, sid, [goldObj], ITEM_CHANGE_REASON.CITY_ACT_RESET_CHALLENGE_TIME);
if (!costRes) {
return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
}
myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(myGuildActivityRec.code, { challengeTime: 0 });
return resResult(STATUS.SUCCESS, {
challengeTime: myGuildActivityRec.challengeTime
});
}
// 上报城门受到伤害
async hitGate(msg: { cityId: number, code: string, damage: number, hid: number, round: number, timegap: number, roundTime: number }, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let { cityId, code, damage, hid, round, timegap = 0, roundTime = 0 } = msg;
let obj = getCityActivityObj();
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
if (gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);
let member = obj.getMember(guildCode, roleId);
if(!member) return resResult(STATUS.NOT_CHECK_BATTLE);
if(!member.startActionTime || member.startActionTime == 0) {
member.startActionTime = nowSeconds();
}
if ((roundTime > 0 && roundTime < 500) || (timegap - (nowSeconds() - member.startActionTime) > 5)) { // 前后端误差超过5秒拦截
return resResult(STATUS.SUCCESS, {
isError: true,
timegap: nowSeconds() - member.startActionTime
});
}
let hero = await HeroModel.findBySeqIdAndRole(hid, roleId);
if(!hero && (damage/maxHp > 0.01)) damage = 0;
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) {
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
isError: false,
timegap: nowSeconds() - member.startActionTime,
})
}
let challengeTime = nowSeconds() + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
if(isDebugTime()) {
let guilds = pinus.app.getServersByType('guild');
let guild = await dispatch(redisClient(), roleId, guilds, 'guild');
let currentTime = await pinus.app.rpc.guild.guildActivityRemote.getCurrentTime.toServer(guild.id);
challengeTime = Math.floor(currentTime/1000) + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
}
let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage }, challengeTime);
if (!pushResult) return resResult(STATUS.WRONG_PARMS);
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
// 更新redis数据
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.setRankWithRoleInfo(roleId, damage, obj.getTimeGap(), null, true);
await myR.setExpire(nextWeek);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.setRankWithGuildInfo(guildCode, damage, obj.getTimeGap(), null, true);
await r.setExpire(nextWeek);
({gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId, -1 * damage));
if (gateHp <= 0) {
// 推送 停止活动并结算奖励
await sendSingleCityActEndMsg(cityId, serverId);
}
// 推送 城门血量
await sendMessageToCityWithSuc(serverId, cityId, PUSH_ROUTE.GUILD_CITY_ACT_HP, { cityId, gateHp, maxHp });
await sendCityGuildRankToUser(serverId, cityId, guildCode, roleId);
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
guildScore,
myScore,
gateHp,
isError: false,
timegap: nowSeconds() - member.startActionTime,
})
}
// 结束挑战
async battleEnd(msg: { cityId: number, code: string, isSuccess: boolean }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { cityId, code, isSuccess } = msg;
let obj = getCityActivityObj();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicCity = gameData.cityActivity.get(cityId);
if (!dicCity) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let challengeTime = nowSeconds() + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
if(isDebugTime()) {
let guilds = pinus.app.getServersByType('guild');
let guild = await dispatch(redisClient(), roleId, guilds, 'guild');
let currentTime = await pinus.app.rpc.guild.guildActivityRemote.getCurrentTime.toServer(guild.id);
challengeTime = Math.floor(currentTime/1000) + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
}
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true, cityId, challengeTime });
if (!myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
// 返回当前军团总军功
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.getMyScore({ roleId });
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
return resResult(STATUS.SUCCESS, {
isSuccess,
code,
...statusResult,
guildScore,
myScore,
gateHp,
maxHp,
challengeTime: myGuildActivityRec.challengeTime
});
}
async debugTestAutoDeclare(msg: { }, session: BackendSession) {
let serverId = session.get('serverId');
let roleId = session.get('roleId');
let guildCode = session.get('guildCode');
let declareIndex = getDeclareIndex();
for(let i = 0; i < 1000; i++) {
autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
}
return resResult(STATUS.SUCCESS)
}
private interval: NodeJS.Timer;
async debugStartHitGate(msg: { param: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { param = 1000 } = msg;
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(this.interval) {
clearInterval(this.interval);
}
let fun = async () => {
for(let [cityId] of gameData.cityActivity) {
let guilds = pinus.app.getServersByType('guild');
let guild = await dispatch(redisClient(), `${cityId}`, guilds, 'guild');
await pinus.app.rpc.guild.guildActivityRemote.debugSendGateHp.toServer(guild.id, serverId, cityId);
}
await pinus.app.rpc.guild.guildActivityRemote.sendRankToGuilds.broadcast(this.aid);
};
await fun();
this.interval = setInterval(fun, param)
return resResult(STATUS.SUCCESS)
}
async debugStopHitGate(msg: { magicWord: string }, session: BackendSession) {
if(this.interval) {
clearInterval(this.interval);
}
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,157 +1,158 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { UserGuildModel } from '../../../db/UserGuild';
import { resResult } from '../../../pubUtils/util';
import { DATA_NAME, ITEM_CHANGE_REASON, STATUS, TASK_TYPE } from '../../../consts';
import { DonationModel } from '../../../db/Donation';
import { getZeroPoint, nowSeconds } from '../../../pubUtils/timeUtil';
import { getArmyDonateBaseByLv, getArmyDonateBoxBaseById, getArmyDonateBoxBaseByLvAndIndex } from '../../../pubUtils/data';
import { GuildModel } from '../../../db/Guild';
import { handleCost, addItems } from '../../../services/role/rewardService';
import { CHAT_SERVER, GUILD_POINT_WAYS } from '../../../consts';
import { addFund, donate, getDonation, getGuildFundByRefTime } from '../../../services/donateService';
import { getUserGuildWithRefActive } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { addActive } from '../../../services/guildService'
import { checkTask, checkTaskInDonate } from '../../../services/task/taskService';
import { guildInter } from '../../../pubUtils/interface';
import { lockData } from '../../../services/redLockService';
import { getVipDonateConsume } from '../../../services/activity/monthlyTicketService';
import { changeReceiveBoxIdByLvAndIndex } from '../../../services/donateService';
export default function (app: Application) {
new HandlerService(app, {});
return new DonationHandler(app);
}
export class DonationHandler {
constructor(private app: Application) {
}
/**
* 捐献所的等级,捐献的次数,战报,捐献达到的基金,领取宝箱记录
* @param msg
* @param session
*/
async getDonation(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild) return resResult(STATUS.WRONG_PARMS);
let guild = await GuildModel.findGuild(userGuild.guildCode, serverId, 'structure lv');
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
const { guildCode: code, donateCnt, receiveBoxs } = userGuild;
let { donateFund, reports, donationLv } = await getDonation(code, guild);
// 根据donationLv, 和index, 转化成对应的箱子id
let haveGotBoxIds: number[] = changeReceiveBoxIdByLvAndIndex(receiveBoxs, donationLv);
return resResult(STATUS.SUCCESS, { receiveBoxs: haveGotBoxIds, donateFund, reports, donateCnt: donateCnt || 0, donationLv });
}
/**
* 捐献
* @param msg
* @param session
*/
async donate(msg: guildInter & { id: number }, session: BackendSession) {
const { id } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = parseInt(session.get('serverId'));
const sid: string = session.get('sid');
const guildCode: string = session.get('guildCode');
let res: any = await lockData(serverId, DATA_NAME.DONATE, guildCode);// 锁定资金的增加
try {
if (!!res.err) {
return resResult(STATUS.REDLOCK_ERR);
}
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
const { guildCode: code, donateCnt: resdonateCnt } = userGuild;
let guild = await GuildModel.findGuild(code, serverId, 'structure lv');
if(!guild) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
if (resdonateCnt >= ARMY.ARMY_DONATE_TIMES) {
res.releaseCallback();
return resResult(STATUS.GUILD_DONATE_TIMES_NOT_ENOUGH);
}
let { donationLv } = await getGuildFundByRefTime(code, getZeroPoint());
let { donateReward } = getArmyDonateBaseByLv(donationLv);
let { rewardGood, rewardFund, cosume } = donateReward.get(id);
let consumeResult = getVipDonateConsume(cosume, session.get('vipStartTime'));
let result = await handleCost(roleId, sid, consumeResult, ITEM_CHANGE_REASON.DONATE);
if (!result) {
res.releaseCallback();
return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
let { donateCnt } = await UserGuildModel.donateFund(roleId, 1);
let { donateFund, reports } = await donate(code, rewardFund, id, roleName, donationLv);
let goods = [];
if (!!rewardGood)
goods = await addItems(roleId, roleName, sid, [rewardGood], ITEM_CHANGE_REASON.DONATE);
//增加基金
await addFund(code, serverId, rewardFund);
await checkTaskInDonate(serverId, roleId, sid, cosume);
await addActive(roleId, serverId, GUILD_POINT_WAYS.DONATE, id);
res.releaseCallback();
return resResult(STATUS.SUCCESS, { donateFund, reports, donateCnt, simpleGoods: goods });
} catch (e) {
res.releaseCallback();
throw e;
}
}
/**
* 领取宝箱
* @param msg
* @param session
*/
async receiveBox(msg: guildInter & { id: number }, session: BackendSession) {
const { id, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, receiveBoxs: resReceiveBoxs } = userGuild;
let guild = await GuildModel.findGuild(code, serverId, 'structure lv');
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
// 领取限制: 一天内相同index的箱子不允许重复领取
// 当前要领取的箱子index
const {index: curBoxIndex} = getArmyDonateBoxBaseById(id);
for (let haveGotId of resReceiveBoxs) {
// 已领取箱子index
let {index: haveGotIndex} = getArmyDonateBoxBaseById(haveGotId);
if (haveGotIndex === curBoxIndex) {
return resResult(STATUS.GUILD_DONATE_BOXS_IS_GOT);
}
}
let { boxRewards, fund, level } = getArmyDonateBoxBaseById(id);
let { donateFund, donationLv } = await getDonation(code, guild);
if( donationLv < level) return resResult(STATUS.GUILD_DONATE_LV_NOT_ENOUGH)
if (donateFund < fund)
return resResult(STATUS.GUILD_DONATE_BOXS_NOT_GOT);
resReceiveBoxs.push(id);
let { receiveBoxs } = await UserGuildModel.updateInfo(roleId, { receiveBoxs: resReceiveBoxs }, {}, 'receiveBoxs');
let goods = await addItems(roleId, roleName, sid, boxRewards, ITEM_CHANGE_REASON.DONATE_BOX);
// 根据donationLv, 和index, 转化成对应的箱子id
let haveGotBoxIds: number[] = changeReceiveBoxIdByLvAndIndex(receiveBoxs, donationLv);
return resResult(STATUS.SUCCESS, { receiveBoxs: haveGotBoxIds, goods });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { UserGuildModel } from '@db/UserGuild';
import { resResult } from '@pubUtils/util';
import { DATA_NAME, ITEM_CHANGE_REASON, STATUS, TASK_TYPE } from '../../../consts';
import { DonationModel } from '@db/Donation';
import { getZeroPoint, nowSeconds } from '@pubUtils/timeUtil';
import { getArmyDonateBaseByLv, getArmyDonateBoxBaseById, getArmyDonateBoxBaseByLvAndIndex } from '@pubUtils/data';
import { GuildModel } from '@db/Guild';
import { handleCost, addItems } from '../../../services/role/rewardService';
import { CHAT_SERVER, GUILD_POINT_WAYS } from '../../../consts';
import { addFund, donate, getDonation, getGuildFundByRefTime } from '../../../services/donateService';
import { getUserGuildWithRefActive } from '../../../services/guildService';
import { ARMY } from '@pubUtils/dicParam';
import { addActive } from '../../../services/guildService'
import { checkTask, checkTaskInDonate } from '../../../services/task/taskService';
import { guildInter } from '@pubUtils/interface';
import { lockData } from '../../../services/redLockService';
import { getVipDonateConsume } from '../../../services/activity/monthlyTicketService';
import { changeReceiveBoxIdByLvAndIndex } from '../../../services/donateService';
export default function (app: Application) {
new HandlerService(app, {});
return new DonationHandler(app);
}
export class DonationHandler {
constructor(private app: Application) {
}
/**
* 捐献所的等级,捐献的次数,战报,捐献达到的基金,领取宝箱记录
* @param msg
* @param session
*/
async getDonation(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild) return resResult(STATUS.WRONG_PARMS);
let guild = await GuildModel.findGuild(userGuild.guildCode, serverId, 'structure lv');
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
const { guildCode: code, donateCnt, receiveBoxs } = userGuild;
let { donateFund, reports, donationLv } = await getDonation(code, guild);
// 根据donationLv, 和index, 转化成对应的箱子id
let haveGotBoxIds: number[] = changeReceiveBoxIdByLvAndIndex(receiveBoxs, donationLv);
return resResult(STATUS.SUCCESS, { receiveBoxs: haveGotBoxIds, donateFund, reports, donateCnt: donateCnt || 0, donationLv });
}
/**
* 捐献
* @param msg
* @param session
*/
async donate(msg: guildInter & { id: number }, session: BackendSession) {
const { id } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = parseInt(session.get('serverId'));
const sid: string = session.get('sid');
const guildCode: string = session.get('guildCode');
let res: any = await lockData(serverId, DATA_NAME.DONATE, guildCode);// 锁定资金的增加
try {
if (!!res.err) {
return resResult(STATUS.REDLOCK_ERR);
}
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
const { guildCode: code, donateCnt: resdonateCnt } = userGuild;
let guild = await GuildModel.findGuild(code, serverId, 'structure lv');
if(!guild) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
if (resdonateCnt >= ARMY.ARMY_DONATE_TIMES) {
res.releaseCallback();
return resResult(STATUS.GUILD_DONATE_TIMES_NOT_ENOUGH);
}
let { donationLv } = await getGuildFundByRefTime(code, getZeroPoint());
let { donateReward } = getArmyDonateBaseByLv(donationLv);
let { rewardGood, rewardFund, cosume } = donateReward.get(id);
let consumeResult = getVipDonateConsume(cosume, session.get('vipStartTime'));
let result = await handleCost(roleId, sid, consumeResult, ITEM_CHANGE_REASON.DONATE);
if (!result) {
res.releaseCallback();
return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
let { donateCnt } = await UserGuildModel.donateFund(roleId, 1);
let { donateFund, reports } = await donate(code, rewardFund, id, roleName, donationLv);
let goods = [];
if (!!rewardGood)
goods = await addItems(roleId, roleName, sid, [rewardGood], ITEM_CHANGE_REASON.DONATE);
//增加基金
await addFund(code, serverId, rewardFund);
await checkTaskInDonate(serverId, roleId, sid, cosume);
await addActive(roleId, serverId, GUILD_POINT_WAYS.DONATE, id);
res.releaseCallback();
return resResult(STATUS.SUCCESS, { donateFund, reports, donateCnt, simpleGoods: goods });
} catch (e) {
res.releaseCallback();
throw e;
}
}
/**
* 领取宝箱
* @param msg
* @param session
*/
async receiveBox(msg: guildInter & { id: number }, session: BackendSession) {
const { id, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, receiveBoxs: resReceiveBoxs } = userGuild;
let guild = await GuildModel.findGuild(code, serverId, 'structure lv');
if(!guild) {
return resResult(STATUS.WRONG_PARMS);
}
// 领取限制: 一天内相同index的箱子不允许重复领取
// 当前要领取的箱子index
const {index: curBoxIndex} = getArmyDonateBoxBaseById(id);
for (let haveGotId of resReceiveBoxs) {
// 已领取箱子index
let {index: haveGotIndex} = getArmyDonateBoxBaseById(haveGotId);
if (haveGotIndex === curBoxIndex) {
return resResult(STATUS.GUILD_DONATE_BOXS_IS_GOT);
}
}
let { boxRewards, fund, level } = getArmyDonateBoxBaseById(id);
let { donateFund, donationLv } = await getDonation(code, guild);
if( donationLv < level) return resResult(STATUS.GUILD_DONATE_LV_NOT_ENOUGH)
if (donateFund < fund)
return resResult(STATUS.GUILD_DONATE_BOXS_NOT_GOT);
resReceiveBoxs.push(id);
let { receiveBoxs } = await UserGuildModel.updateInfo(roleId, { receiveBoxs: resReceiveBoxs }, {}, 'receiveBoxs');
let goods = await addItems(roleId, roleName, sid, boxRewards, ITEM_CHANGE_REASON.DONATE_BOX);
// 根据donationLv, 和index, 转化成对应的箱子id
let haveGotBoxIds: number[] = changeReceiveBoxIdByLvAndIndex(receiveBoxs, donationLv);
return resResult(STATUS.SUCCESS, { receiveBoxs: haveGotBoxIds, goods });
}
}

View File

@@ -1,332 +1,333 @@
import { Application, BackendSession, ChannelService, pinus, HandlerService, } from "pinus";
import { getGuildActivityStatus, getRecordScore, participants, getGateActivityRank, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
import { resResult } from "../../../pubUtils/util";
import { STATUS, GUILD_ACTIVITY_TYPE, GUILD_POINT_WAYS, ENEMIES_TYPE, GET_POINT_WAYS, TASK_TYPE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { delGuildActivityRank } from "../../../services/redisService";
import { REDIS_KEY } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
import { Rank } from "../../../services/rankService";
import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
import { checkTask } from "../../../services/task/taskService";
import { guildInter } from "../../../pubUtils/interface";
import { ServerRecordModel } from "../../../db/ServerRecords";
import { getGateActivityObj } from "../../../services/memoryCache/guildActivityData";
export default function (app: Application) {
new HandlerService(app, {});
return new GateActivityHandler(app);
}
export class GateActivityHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
private aid = GUILD_ACTIVITY_TYPE.GATE_ACTIVITY; // 蛮夷入侵id
// 进入蛮夷入侵界面
async getGateActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let index = getGAIndexInPinus(this.aid);
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
let { challengeCnt } = myGuildActivityRec;
let ranks = await getGateActivityRank(guildCode, serverId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
...statusResult,
challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - challengeCnt,
...ranks
});
}
// 开启挑战
async checkBattle(msg: guildInter & { heroes: number[] }, session: BackendSession) {
let { heroes, myUserGuild: userGuild } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let obj = getGateActivityObj();
let index = getGAIndexInPinus(this.aid);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
if (myGuildActivityRec.challengeCnt > 0) {
return resResult(STATUS.CHALLENGE_CNT_NOT_ENOUGH);
}
myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
let { code, challengeCnt } = myGuildActivityRec;
// 更新公会参与的玩家
obj.pushMembers(guildCode, serverId, roleId, userGuild.job, code);
// 返回当前军团总军功
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ACTIVITY, { aid: this.aid });
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
guildScore: guildScore || 0,
myScore: 0,
challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - challengeCnt,
});
}
// 上报玩家获得军功
async action(msg: { code: string, round: number, record: { round: number, dataId: number }[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, round, record } = msg;
let obj = getGateActivityObj();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) {
return resResult(STATUS.SUCCESS, {
code,
...statusResult
})
}
// 计算record内得分
let memberRecord = obj.getMemberRecord(code, roleId);
let scoreResult = getRecordScore(this.aid, round, record, memberRecord);
if (!scoreResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let { score, newRecords, memberRecord: newMemberRecord } = scoreResult;
obj.setMemberRecord(code, newMemberRecord);
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
// console.log('####### nextWeek', nextWeek)
let index = getGAIndexInPinus(this.aid);
// 更新redis数据
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.setRankWithRoleInfo(roleId, score, obj.getTimeGap(), null, true);
await myR.setExpire(nextWeek);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let guildScore = await r.setRankWithGuildInfo(guildCode, score, obj.getTimeGap(), null, true);
await r.setExpire(nextWeek);
// 更新数据库
let rec = await UserGuildActivityRecModel.pushRecord(code, newRecords, round);
return resResult(STATUS.SUCCESS, {
code: rec.code,
...statusResult,
guildScore: guildScore || 0,
myScore: myScore || 0
});
}
// 结束挑战
async battleEnd(msg: { code: string, isSuccess: boolean, gateHp: number }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, isSuccess, gateHp } = msg;
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true, gateHp });
if (!myGuildActivityRec) return resResult(STATUS.INTERNAL_ERR);
// 功劳簿计算
let { record, round } = myGuildActivityRec;
let enemyCnt = 0, littleBossCnt = 0, bossCnt = 0;
for (let { enemyType, round: r } of record) {
if (enemyType == ENEMIES_TYPE.ENEMY || enemyType == ENEMIES_TYPE.ELITE_ENEMY) {
enemyCnt++;
} else if (enemyType == ENEMIES_TYPE.LITTLE_BOSS) {
littleBossCnt++;
} else if (enemyType == ENEMIES_TYPE.BOSS) {
bossCnt++;
}
}
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
if (isSuccess && statusResult.status == GUILD_ACTIVITY_STATUS.START) {
let obj = getGateActivityObj();
let score = gameData.gateActivityPoint.get(GET_POINT_WAYS.DEFENSE_SUCCESS);
if(score > 0) {
await myR.setRankWithRoleInfo(roleId, score, obj.getTimeGap(), null, true);
await r.setRankWithGuildInfo(guildCode, score, obj.getTimeGap(), null, true);
}
}
// 返回当前军团总军功
let guildScore = await r.getMyScore({ guildCode });
let myScore = await myR.getMyScore({ roleId });
let info = {
round,
enemyCnt, littleBossCnt, bossCnt,
isSuccess
}
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
guildScore,
myScore,
info
})
}
// ! 测试接口
async debugGetPrivate(msg: {}, session: BackendSession) {
let guildCode = session.get('guildCode');
// console.log(guildCode);
let serverId = session.get('serverId');
let res = getGateActivityObj().getObj(guildCode, serverId);
return resResult(STATUS.SUCCESS, res)
}
// ! 测试接口
async test(msg: { sourceType: number, sourceCode: string }, session: BackendSession) {
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
// await GuildActivityCityModel.declare(serverId, 1, guildCode);
let { sourceType, sourceCode } = msg;
let result = await participants(guildCode, sourceType, sourceCode);
return result;
// let result = await setMedianCe();
// return resResult(STATUS.SUCCESS, {result});
}
// ! 测试接口
async debugIncChallengeCnt(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let today = getZeroPointD();
await UserGuildActivityRecModel.updateMany(
{ roleId, createdAt: { $gte: today } }, { $set: { challengeCnt: -100 } }, { new: true }).lean();
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
async debugStartActivity(msg: { aid: number }, session: BackendSession) {
let { aid } = msg;
let dic = gameData.guildActivity.get(aid);
if (!dic) return resResult(STATUS.WRONG_PARMS);
let result = await pinus.app.rpc.systimer.systimerRemote.guildActivityStart.toServer('systimer-server-1', dic);
if (!result) {
return resResult(STATUS.GUILD_ACTIVITY_IS_OPEN)
}
// !! 注意,这条函数会改变内存中的字典表,仅用于测试中使用
let now = new Date();
let guildServers = pinus.app.getServersByType('guild');
for (let server of guildServers) {
pinus.app.rpc.guild.guildActivityRemote.updateGuildActivityData.toServer(server.id, aid, true);
}
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
async debugSetDay(msg: { week: number }, session: BackendSession) {
await pinus.app.rpc.guild.guildActivityRemote.setDay.broadcast(msg.week);
await pinus.app.rpc.systimer.systimerRemote.setDay.broadcast(msg.week);
await pinus.app.rpc.connector.connectorRemote.setDay.broadcast(msg.week);
if (msg.week <= 2) {
await GuildActivityCityModel.deleteMany({});
}
await delGuildActivityRank(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
await delGuildActivityRank(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
await delGuildActivityRank(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
async debugEndActivity(msg: { aid: number }, session: BackendSession) {
let { aid } = msg;
if (aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
await pinus.app.rpc.systimer.systimerRemote.gateActivityEnd.toServer('systimer-server-1');
} else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
await pinus.app.rpc.systimer.systimerRemote.cityActivityEnd.toServer('systimer-server-1');
} else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
await pinus.app.rpc.systimer.systimerRemote.raceActivityEnd.toServer('systimer-server-1');
} else {
return resResult(STATUS.WRONG_PARMS)
}
// !! 注意,这条函数会改变内存中的字典表,仅用于测试中使用
let now = new Date();
let guildServers = pinus.app.getServersByType('guild');
for (let server of guildServers) {
pinus.app.rpc.guild.guildActivityRemote.updateGuildActivityData.toServer(server.id, aid, false);
}
return resResult(STATUS.SUCCESS);
}
async debugDelRedis(msg: { aid: number }, session: BackendSession) {
let { aid } = msg;
await delGuildActivityRank(aid);
}
// ! 测试接口 将自己添加进活动roleId里
async debugAddParticipants(msg: { aid: number }, session: BackendSession) {
let roleId = session.get('roleId');
let guildCode = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
let serverId = session.get('serverId');
let { aid } = msg;
let index = getGAIndexInPinus(aid);
await GuildActivityRecordModel.getRecord(guildCode, serverId, aid, index);
let userGuild = await UserGuildModel.getMyGuild(roleId);
let result = await GuildActivityRecordModel.updateInfo(guildCode, aid, index, { memberCnt: 1, members: [{ roleId, job: userGuild.job, code: '' }], auctionType: aid + 1 });
return resResult(STATUS.SUCCESS, {
sourceType: result.auctionType,
sourceCode: result.code
});
}
}
import { Application, BackendSession, ChannelService, pinus, HandlerService, } from "pinus";
import { getGuildActivityStatus, getRecordScore, participants, getGateActivityRank, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
import { resResult } from "@pubUtils/util";
import { STATUS, GUILD_ACTIVITY_TYPE, GUILD_POINT_WAYS, ENEMIES_TYPE, GET_POINT_WAYS, TASK_TYPE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { UserGuildActivityRecModel } from "@db/UserGuildActivityRec";
import { GUILDACTIVITY } from "@pubUtils/dicParam";
import { GuildActivityRecordModel } from "@db/GuildActivityRec";
import { delGuildActivityRank } from "../../../services/redisService";
import { REDIS_KEY } from "../../../consts";
import { gameData } from "@pubUtils/data";
import { UserGuildModel } from "@db/UserGuild";
import { GuildActivityCityModel } from "@db/GuildActivityCity";
import { Rank } from "../../../services/rankService";
import { getTimeFun, getZeroPointD } from "@pubUtils/timeUtil";
import { checkTask } from "../../../services/task/taskService";
import { guildInter } from "@pubUtils/interface";
import { ServerRecordModel } from "@db/ServerRecords";
import { getGateActivityObj } from "../../../services/memoryCache/guildActivityData";
export default function (app: Application) {
new HandlerService(app, {});
return new GateActivityHandler(app);
}
export class GateActivityHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
private aid = GUILD_ACTIVITY_TYPE.GATE_ACTIVITY; // 蛮夷入侵id
// 进入蛮夷入侵界面
async getGateActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let index = getGAIndexInPinus(this.aid);
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
let { challengeCnt } = myGuildActivityRec;
let ranks = await getGateActivityRank(guildCode, serverId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
...statusResult,
challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - challengeCnt,
...ranks
});
}
// 开启挑战
async checkBattle(msg: guildInter & { heroes: number[] }, session: BackendSession) {
let { heroes, myUserGuild: userGuild } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let obj = getGateActivityObj();
let index = getGAIndexInPinus(this.aid);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
if (myGuildActivityRec.challengeCnt > 0) {
return resResult(STATUS.CHALLENGE_CNT_NOT_ENOUGH);
}
myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
let { code, challengeCnt } = myGuildActivityRec;
// 更新公会参与的玩家
obj.pushMembers(guildCode, serverId, roleId, userGuild.job, code);
// 返回当前军团总军功
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ACTIVITY, { aid: this.aid });
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
guildScore: guildScore || 0,
myScore: 0,
challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - challengeCnt,
});
}
// 上报玩家获得军功
async action(msg: { code: string, round: number, record: { round: number, dataId: number }[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, round, record } = msg;
let obj = getGateActivityObj();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) {
return resResult(STATUS.SUCCESS, {
code,
...statusResult
})
}
// 计算record内得分
let memberRecord = obj.getMemberRecord(code, roleId);
let scoreResult = getRecordScore(this.aid, round, record, memberRecord);
if (!scoreResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let { score, newRecords, memberRecord: newMemberRecord } = scoreResult;
obj.setMemberRecord(code, newMemberRecord);
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
// console.log('####### nextWeek', nextWeek)
let index = getGAIndexInPinus(this.aid);
// 更新redis数据
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.setRankWithRoleInfo(roleId, score, obj.getTimeGap(), null, true);
await myR.setExpire(nextWeek);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let guildScore = await r.setRankWithGuildInfo(guildCode, score, obj.getTimeGap(), null, true);
await r.setExpire(nextWeek);
// 更新数据库
let rec = await UserGuildActivityRecModel.pushRecord(code, newRecords, round);
return resResult(STATUS.SUCCESS, {
code: rec.code,
...statusResult,
guildScore: guildScore || 0,
myScore: myScore || 0
});
}
// 结束挑战
async battleEnd(msg: { code: string, isSuccess: boolean, gateHp: number }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, isSuccess, gateHp } = msg;
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true, gateHp });
if (!myGuildActivityRec) return resResult(STATUS.INTERNAL_ERR);
// 功劳簿计算
let { record, round } = myGuildActivityRec;
let enemyCnt = 0, littleBossCnt = 0, bossCnt = 0;
for (let { enemyType, round: r } of record) {
if (enemyType == ENEMIES_TYPE.ENEMY || enemyType == ENEMIES_TYPE.ELITE_ENEMY) {
enemyCnt++;
} else if (enemyType == ENEMIES_TYPE.LITTLE_BOSS) {
littleBossCnt++;
} else if (enemyType == ENEMIES_TYPE.BOSS) {
bossCnt++;
}
}
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
if (isSuccess && statusResult.status == GUILD_ACTIVITY_STATUS.START) {
let obj = getGateActivityObj();
let score = gameData.gateActivityPoint.get(GET_POINT_WAYS.DEFENSE_SUCCESS);
if(score > 0) {
await myR.setRankWithRoleInfo(roleId, score, obj.getTimeGap(), null, true);
await r.setRankWithGuildInfo(guildCode, score, obj.getTimeGap(), null, true);
}
}
// 返回当前军团总军功
let guildScore = await r.getMyScore({ guildCode });
let myScore = await myR.getMyScore({ roleId });
let info = {
round,
enemyCnt, littleBossCnt, bossCnt,
isSuccess
}
return resResult(STATUS.SUCCESS, {
code,
...statusResult,
guildScore,
myScore,
info
})
}
// ! 测试接口
async debugGetPrivate(msg: {}, session: BackendSession) {
let guildCode = session.get('guildCode');
// console.log(guildCode);
let serverId = session.get('serverId');
let res = getGateActivityObj().getObj(guildCode, serverId);
return resResult(STATUS.SUCCESS, res)
}
// ! 测试接口
async test(msg: { sourceType: number, sourceCode: string }, session: BackendSession) {
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
// await GuildActivityCityModel.declare(serverId, 1, guildCode);
let { sourceType, sourceCode } = msg;
let result = await participants(guildCode, sourceType, sourceCode);
return result;
// let result = await setMedianCe();
// return resResult(STATUS.SUCCESS, {result});
}
// ! 测试接口
async debugIncChallengeCnt(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let today = getZeroPointD();
await UserGuildActivityRecModel.updateMany(
{ roleId, createdAt: { $gte: today } }, { $set: { challengeCnt: -100 } }, { new: true }).lean();
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
async debugStartActivity(msg: { aid: number }, session: BackendSession) {
let { aid } = msg;
let dic = gameData.guildActivity.get(aid);
if (!dic) return resResult(STATUS.WRONG_PARMS);
let result = await pinus.app.rpc.systimer.systimerRemote.guildActivityStart.toServer('systimer-server-1', dic);
if (!result) {
return resResult(STATUS.GUILD_ACTIVITY_IS_OPEN)
}
// !! 注意,这条函数会改变内存中的字典表,仅用于测试中使用
let now = new Date();
let guildServers = pinus.app.getServersByType('guild');
for (let server of guildServers) {
pinus.app.rpc.guild.guildActivityRemote.updateGuildActivityData.toServer(server.id, aid, true);
}
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
async debugSetDay(msg: { week: number }, session: BackendSession) {
await pinus.app.rpc.guild.guildActivityRemote.setDay.broadcast(msg.week);
await pinus.app.rpc.systimer.systimerRemote.setDay.broadcast(msg.week);
await pinus.app.rpc.connector.connectorRemote.setDay.broadcast(msg.week);
if (msg.week <= 2) {
await GuildActivityCityModel.deleteMany({});
}
await delGuildActivityRank(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
await delGuildActivityRank(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
await delGuildActivityRank(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
return resResult(STATUS.SUCCESS);
}
// ! 测试接口
async debugEndActivity(msg: { aid: number }, session: BackendSession) {
let { aid } = msg;
if (aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
await pinus.app.rpc.systimer.systimerRemote.gateActivityEnd.toServer('systimer-server-1');
} else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
await pinus.app.rpc.systimer.systimerRemote.cityActivityEnd.toServer('systimer-server-1');
} else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
await pinus.app.rpc.systimer.systimerRemote.raceActivityEnd.toServer('systimer-server-1');
} else {
return resResult(STATUS.WRONG_PARMS)
}
// !! 注意,这条函数会改变内存中的字典表,仅用于测试中使用
let now = new Date();
let guildServers = pinus.app.getServersByType('guild');
for (let server of guildServers) {
pinus.app.rpc.guild.guildActivityRemote.updateGuildActivityData.toServer(server.id, aid, false);
}
return resResult(STATUS.SUCCESS);
}
async debugDelRedis(msg: { aid: number }, session: BackendSession) {
let { aid } = msg;
await delGuildActivityRank(aid);
}
// ! 测试接口 将自己添加进活动roleId里
async debugAddParticipants(msg: { aid: number }, session: BackendSession) {
let roleId = session.get('roleId');
let guildCode = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
let serverId = session.get('serverId');
let { aid } = msg;
let index = getGAIndexInPinus(aid);
await GuildActivityRecordModel.getRecord(guildCode, serverId, aid, index);
let userGuild = await UserGuildModel.getMyGuild(roleId);
let result = await GuildActivityRecordModel.updateInfo(guildCode, aid, index, { memberCnt: 1, members: [{ roleId, job: userGuild.job, code: '' }], auctionType: aid + 1 });
return resResult(STATUS.SUCCESS, {
sourceType: result.auctionType,
sourceCode: result.code
});
}
}

View File

@@ -1,298 +1,299 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
import { AUCTION_SOURCE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, MAIL_TYPE, PUSH_ROUTE, STATUS, TASK_TYPE, WAR_TYPE } from '../../../consts';
import { BossInstanceModel } from '../../../db/BossInstance';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { nowSeconds, getZeroPoint, getSeconds } from '../../../pubUtils/timeUtil';
import { getBossInstanceInfo, checkBossBattleMemberExists, pushBossHpMessage, addBossInstance, refreshUserGuildOfBoss, refreshGuildOfBoss, getBossHp, getBossInstanceInfoByData, pushBossStatus, zoomOutDamage, zoomInDamage } from '../../../services/guildBossService';
import { findWhere } from 'underscore'
import { GUILD_STRUCTURE, GUILD_BOSS_STATUS, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
import { DATA_NAME } from '../../../consts/dataName';
import { UserGuildModel } from '../../../db/UserGuild';
import { addActive, addBossWarExtendActive } from '../../../services/guildService';
import { GuildModel } from '../../../db/Guild';
import { gameData, getBossByLv } from '../../../pubUtils/data';
import { lockData } from '../../../services/redLockService';
import { pushGuildBossSucMsg, getGuildChannelSid } from '../../../services/chatService';
import { checkTask } from '../../../services/task/taskService';
import { guildInter, pvpEndParamInter } from '../../../pubUtils/interface';
import { addItems, getGoldObject, handleCost } from '../../../services/role/rewardService';
import * as dicParam from '../../../pubUtils/dicParam';
import { RoleModel } from '../../../db/Role';
import { sendMailToGuildByContent } from '../../../services/mailService';
import { genAuction, getAuctionRewardByPoolId } from '../../../services/auctionService';
import { sendMessageToGuildWithSuc } from '../../../services/pushService';
import { getBattleRecordParam } from '../../../services/normalBattleService';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildHandler(app);
}
export class GuildHandler {
constructor(private app: Application) {
}
// 获得boss关卡
async getBossInstance(msg: guildInter & {}, session: BackendSession) {
let { myUserGuild: userGuild } = msg;
let result = await getBossInstanceInfo(userGuild);
return resResult(STATUS.SUCCESS, result);
}
//开启演武场
async openBossInstance(msg: guildInter & {}, session: BackendSession) {
const serverId: number = parseInt(session.get('serverId'));
const { myUserGuild: userGuild } = msg;
const { guildCode: code } = userGuild;
let res: any = await lockData(serverId, DATA_NAME.BOSS_SCRIPT, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
const guild = await GuildModel.findByCode(code, serverId, 'code lv structure refOpenBossTime openBossCnt');
if (!guild) {
res.releaseCallback();
return resResult(STATUS.GUILD_NOT_FOUND);
}
const { structure } = guild;
const curStructure = structure.find(cur => cur.id == GUILD_STRUCTURE.BOSS);
if (!curStructure) {
res.releaseCallback();
return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
}
let bossBase = getBossByLv(curStructure.lv);
let dicBossBaseWar = getRandSingleEelm(bossBase.wars);
// let bossHp = Math.ceil(medianCe * bossBase.ratio);
let { ratio, bossHp } = await getBossHp(serverId, code, dicBossBaseWar, bossBase.bossLevel);
let resGuild = await GuildModel.costFund(code, bossBase.opencost);
if (!resGuild) {
res.releaseCallback();
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
}
let bossInstance = await BossInstanceModel.findBossInstance(code);
if (!!bossInstance && bossInstance.status == GUILD_BOSS_STATUS.OPEN) {
res.releaseCallback();
return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
}
// 每天开启一次
let { leaderOpenCnt } = await refreshGuildOfBoss(guild);
if(leaderOpenCnt >= dicParam.GUILD_BOSS.GUILD_BOSS_OPEN_COUNT) {
res.releaseCallback();
return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
}
await refreshGuildOfBoss(guild, 1);
bossInstance = await BossInstanceModel.openBossInstance(code, bossHp, ratio, dicBossBaseWar.warId, bossBase.bossLevel);
res.releaseCallback();
let result = await getBossInstanceInfoByData(bossInstance, userGuild, guild);
await pushBossStatus(code, result);
return resResult(STATUS.SUCCESS, result);
}
async battleBoss(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { myUserGuild: userGuild } = msg;
const { guildCode } = userGuild;
let bossInstance = await BossInstanceModel.findBossInstance(guildCode);
if (!bossInstance)
return resResult(STATUS.GUILD_SCRIPT_NOT_OPENED);
if (bossInstance.bossHp <= 0)
return resResult(STATUS.GUILD_SCRIPT_IS_COMPLETE);
let { myChallengeCnt } = await refreshUserGuildOfBoss(userGuild, 0, 0);
if(myChallengeCnt >= dicParam.GUILD_BOSS.GUILD_BOSS_CHALLENGE_COUNT) {
return resResult(STATUS.GUILD_SCRIPT_IS_BATTLED);
}
let { code: bossCode, warId, ranks, bossHp, encourageCnt } = bossInstance;
const battleCode = genCode(8); // 关卡唯一值
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId: warId, warType: WAR_TYPE.BOSS,
status: 0,
record: { heroes: [], bossInstanceCode: bossCode, bossHp: zoomOutDamage(bossHp), encourageCnt },
}
}, true);
const serverId: number = parseInt(session.get('serverId'));
await addBossInstance(guildCode, serverId, roleId);
if (!findWhere(ranks, { roleId })) {
await BossInstanceModel.pushRanks(bossCode, { roleId, score: 0, time: nowSeconds(), job: userGuild.job });
} else {
await BossInstanceModel.updateRank(bossCode, roleId);
}
let { myChallengeCnt: newMyChallengeCnt } = await refreshUserGuildOfBoss(userGuild, 0, 1);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_BOSS);
await addActive(roleId, serverId, GUILD_POINT_WAYS.BOSS_WAR);//获得活跃值
return resResult(STATUS.SUCCESS, { battleCode, bossCode: bossInstance.code, myChallengeCnt: newMyChallengeCnt });
}
async getBossInstanceByBattleCode(msg: guildInter & { battleCode: string }, session: BackendSession) {
const { battleCode, myUserGuild: userGuild } = msg;
let result = {
status: 0,
bossInfo: null
};
let battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode);
if(battleRecord && battleRecord.record && battleRecord.record.bossInstanceCode) {
let bossInstance = await BossInstanceModel.findByCode(battleRecord.record.bossInstanceCode);
if(bossInstance) {
let info = await getBossInstanceInfoByData(bossInstance, userGuild);
result.status = bossInstance.status;
result.bossInfo = info.bossInfo && { ...info.bossInfo, encourageCnt: battleRecord.record.encourageCnt }
}
}
return resResult(STATUS.SUCCESS, result);
}
async action(msg: guildInter & { bossCode: string, damage: number, battleCode: string }, session: BackendSession) {
const { battleCode, damage, myUserGuild: userGuild, bossCode } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = parseInt(session.get('serverId'));
if(!userGuild) return resResult(STATUS.GUILD_NOT_FOUND);
const { guildCode } = userGuild;
let flag = await checkBossBattleMemberExists(guildCode, serverId, roleId, battleCode);
if (!flag) {
return resResult(STATUS.SUCCESS);
}
//记录伤害
let bossInstance = await BossInstanceModel.updateBossHp(bossCode, zoomInDamage(damage), roleId);
if(!bossInstance) { // 如果已经被扣成负的了
return resResult(STATUS.SUCCESS, { bossHp: 0 });
}
await BattleRecordModel.incBossDamage(battleCode, zoomInDamage(damage), bossInstance.bossHp);
if (bossInstance.bossHp <= 0) {//进入结算
let res:any = await lockData(serverId, DATA_NAME.BOSS_SCRIPT, guildCode);//加锁
if (!!res.err)
return resResult(STATUS.SUCCESS, { bossHp: 0 });
bossInstance = await BossInstanceModel.clearBoss(bossCode, bossInstance.bossHp, roleId);
if (!bossInstance) return resResult(STATUS.SUCCESS, { bossHp: 0 });
let { warId, bossLv } = bossInstance;//锁定关卡信息
await pushBossHpMessage(guildCode, serverId, 0, true);
// 击杀奖励&伤害奖励
let dicBossBase = gameData.bossBaseByBossLv.get(bossLv);
let dicWar = gameData.war.get(warId);
await sendMailToGuildByContent(MAIL_TYPE.GUILD_BOSS_REWARD, guildCode, {
params: [`${dicWar.gk_name?.split('&')[1]}`], goods: dicBossBase.killReward
});
// 加入拍卖行
if(dicBossBase) {
let rewards = getAuctionRewardByPoolId(dicBossBase.rewards);
await genAuction(guildCode, AUCTION_SOURCE.BOSS, bossCode, serverId, rewards);
}
let result = await getBossInstanceInfoByData(bossInstance, userGuild);
await pushBossStatus(guildCode, result);
pushGuildBossSucMsg(roleId, roleName, guildCode, bossInstance);
await addBossWarExtendActive(bossCode, serverId)
res.releaseCallback();//解锁
return resResult(STATUS.SUCCESS, { bossHp: 0 });
} else {
pushBossHpMessage(guildCode, serverId, bossInstance.bossHp);
return resResult(STATUS.SUCCESS, { bossHp: bossInstance.bossHp });
}
}
async battleBossEnd(msg: guildInter & { bossCode: string, battleCode: string, damageRecords: pvpEndParamInter[], round: number }, session: BackendSession) {
const { battleCode, myUserGuild: userGuild, bossCode, damageRecords, round } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
let bossInstance = await BossInstanceModel.findByCode(bossCode);
if(!bossInstance) return resResult(STATUS.WRONG_PARMS);
let battleRecord = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: 1, ...getBattleRecordParam(damageRecords, round) }//战斗结束统一设置成1
}, true);
let { bossDamage = 0 } = battleRecord.record; // 伤害奖励
let dicBossBase = gameData.bossBaseByBossLv.get(bossInstance.bossLv);
let { basicReward, damageRewardTotal } = dicBossBase;
let damageReward = damageRewardTotal.map(cur => {
return { id: cur.id, count: Math.ceil(cur.count * bossDamage / bossInstance.bossTotalHp )}
})
let reward = [...basicReward, ...damageReward];
let battleGoods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BOSS_BATTLE_END);
let result = await getBossInstanceInfoByData(bossInstance, userGuild);
return resResult(STATUS.SUCCESS, { ...result, battleGoods, createdAt: getSeconds(battleRecord.createdAt) });
}
async encourage(msg: guildInter & { count: number }, session: BackendSession) {
const { count, myUserGuild: userGuild } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let bossInstance = await BossInstanceModel.findBossInstance(userGuild.guildCode);
if(!bossInstance) return resResult(STATUS.GUILD_SCRIPT_NOT_OPENED);
let { myEncourageCnt } = await refreshUserGuildOfBoss(userGuild);
let freeCount = dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_FREECOUNT - myEncourageCnt > 0? dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_FREECOUNT - myEncourageCnt: 0;
let costGold = (count - freeCount) * dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_COST;
if(costGold < 0) costGold = 0;
let { gold } = await RoleModel.findByRoleId(roleId, 'gold');
if(gold < costGold) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
let { code, bossLv } = bossInstance;
let dicBossBase = gameData.bossBaseByBossLv.get(bossLv);
bossInstance = await BossInstanceModel.encourage(code, count, dicBossBase.encourageSum); // 军团次数
if(!bossInstance) return resResult(STATUS.GUILD_SCRIPT_ENCOURGE_NOT_ENOUGH);
let consume = getGoldObject(costGold);
let costResult = await handleCost(roleId, sid, [consume], ITEM_CHANGE_REASON.GUILD_BOSS_ENCOURAGE);
if(!costResult) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
let { myEncourageCnt: myEncourageCntResult } = await refreshUserGuildOfBoss(userGuild, count);
let result = {
encourageCnt: bossInstance.encourageCnt,
encourageMax: dicBossBase.encourageSum,
myEncourageCnt: myEncourageCntResult
}
await sendMessageToGuildWithSuc(userGuild.guildCode, PUSH_ROUTE.GUILD_BOSS_ENCOURAGE, result);
return resResult(STATUS.SUCCESS, result);
}
async debugAddBattleTimes(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const roleId: string = session.get('roleId');
await UserGuildModel.updateInfo(roleId, { bossChallengeCnt: 0 }, {});
return resResult(STATUS.SUCCESS);
}
async debugAddOpenTimes(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const guildCode: string = session.get('guildCode');
await GuildModel.updateInfo(guildCode, { openBossCnt: 0 }, {});
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { resResult, genCode, getRandSingleEelm } from '@pubUtils/util';
import { AUCTION_SOURCE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, MAIL_TYPE, PUSH_ROUTE, STATUS, TASK_TYPE, WAR_TYPE } from '../../../consts';
import { BossInstanceModel } from '@db/BossInstance';
import { BattleRecordModel } from '@db/BattleRecord';
import { nowSeconds, getZeroPoint, getSeconds } from '@pubUtils/timeUtil';
import { getBossInstanceInfo, checkBossBattleMemberExists, pushBossHpMessage, addBossInstance, refreshUserGuildOfBoss, refreshGuildOfBoss, getBossHp, getBossInstanceInfoByData, pushBossStatus, zoomOutDamage, zoomInDamage } from '../../../services/guildBossService';
import { findWhere } from 'underscore'
import { GUILD_STRUCTURE, GUILD_BOSS_STATUS, GUILD_POINT_WAYS } from '@consts/constModules/guildConst';
import { DATA_NAME } from '@consts/dataName';
import { UserGuildModel } from '@db/UserGuild';
import { addActive, addBossWarExtendActive } from '../../../services/guildService';
import { GuildModel } from '@db/Guild';
import { gameData, getBossByLv } from '@pubUtils/data';
import { lockData } from '../../../services/redLockService';
import { pushGuildBossSucMsg, getGuildChannelSid } from '../../../services/chatService';
import { checkTask } from '../../../services/task/taskService';
import { guildInter, pvpEndParamInter } from '@pubUtils/interface';
import { addItems, getGoldObject, handleCost } from '../../../services/role/rewardService';
import * as dicParam from '@pubUtils/dicParam';
import { RoleModel } from '@db/Role';
import { sendMailToGuildByContent } from '../../../services/mailService';
import { genAuction, getAuctionRewardByPoolId } from '../../../services/auctionService';
import { sendMessageToGuildWithSuc } from '../../../services/pushService';
import { getBattleRecordParam } from '../../../services/normalBattleService';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildHandler(app);
}
export class GuildHandler {
constructor(private app: Application) {
}
// 获得boss关卡
async getBossInstance(msg: guildInter & {}, session: BackendSession) {
let { myUserGuild: userGuild } = msg;
let result = await getBossInstanceInfo(userGuild);
return resResult(STATUS.SUCCESS, result);
}
//开启演武场
async openBossInstance(msg: guildInter & {}, session: BackendSession) {
const serverId: number = parseInt(session.get('serverId'));
const { myUserGuild: userGuild } = msg;
const { guildCode: code } = userGuild;
let res: any = await lockData(serverId, DATA_NAME.BOSS_SCRIPT, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
const guild = await GuildModel.findByCode(code, serverId, 'code lv structure refOpenBossTime openBossCnt');
if (!guild) {
res.releaseCallback();
return resResult(STATUS.GUILD_NOT_FOUND);
}
const { structure } = guild;
const curStructure = structure.find(cur => cur.id == GUILD_STRUCTURE.BOSS);
if (!curStructure) {
res.releaseCallback();
return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
}
let bossBase = getBossByLv(curStructure.lv);
let dicBossBaseWar = getRandSingleEelm(bossBase.wars);
// let bossHp = Math.ceil(medianCe * bossBase.ratio);
let { ratio, bossHp } = await getBossHp(serverId, code, dicBossBaseWar, bossBase.bossLevel);
let resGuild = await GuildModel.costFund(code, bossBase.opencost);
if (!resGuild) {
res.releaseCallback();
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
}
let bossInstance = await BossInstanceModel.findBossInstance(code);
if (!!bossInstance && bossInstance.status == GUILD_BOSS_STATUS.OPEN) {
res.releaseCallback();
return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
}
// 每天开启一次
let { leaderOpenCnt } = await refreshGuildOfBoss(guild);
if(leaderOpenCnt >= dicParam.GUILD_BOSS.GUILD_BOSS_OPEN_COUNT) {
res.releaseCallback();
return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
}
await refreshGuildOfBoss(guild, 1);
bossInstance = await BossInstanceModel.openBossInstance(code, bossHp, ratio, dicBossBaseWar.warId, bossBase.bossLevel);
res.releaseCallback();
let result = await getBossInstanceInfoByData(bossInstance, userGuild, guild);
await pushBossStatus(code, result);
return resResult(STATUS.SUCCESS, result);
}
async battleBoss(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { myUserGuild: userGuild } = msg;
const { guildCode } = userGuild;
let bossInstance = await BossInstanceModel.findBossInstance(guildCode);
if (!bossInstance)
return resResult(STATUS.GUILD_SCRIPT_NOT_OPENED);
if (bossInstance.bossHp <= 0)
return resResult(STATUS.GUILD_SCRIPT_IS_COMPLETE);
let { myChallengeCnt } = await refreshUserGuildOfBoss(userGuild, 0, 0);
if(myChallengeCnt >= dicParam.GUILD_BOSS.GUILD_BOSS_CHALLENGE_COUNT) {
return resResult(STATUS.GUILD_SCRIPT_IS_BATTLED);
}
let { code: bossCode, warId, ranks, bossHp, encourageCnt } = bossInstance;
const battleCode = genCode(8); // 关卡唯一值
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId: warId, warType: WAR_TYPE.BOSS,
status: 0,
record: { heroes: [], bossInstanceCode: bossCode, bossHp: zoomOutDamage(bossHp), encourageCnt },
}
}, true);
const serverId: number = parseInt(session.get('serverId'));
await addBossInstance(guildCode, serverId, roleId);
if (!findWhere(ranks, { roleId })) {
await BossInstanceModel.pushRanks(bossCode, { roleId, score: 0, time: nowSeconds(), job: userGuild.job });
} else {
await BossInstanceModel.updateRank(bossCode, roleId);
}
let { myChallengeCnt: newMyChallengeCnt } = await refreshUserGuildOfBoss(userGuild, 0, 1);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_BOSS);
await addActive(roleId, serverId, GUILD_POINT_WAYS.BOSS_WAR);//获得活跃值
return resResult(STATUS.SUCCESS, { battleCode, bossCode: bossInstance.code, myChallengeCnt: newMyChallengeCnt });
}
async getBossInstanceByBattleCode(msg: guildInter & { battleCode: string }, session: BackendSession) {
const { battleCode, myUserGuild: userGuild } = msg;
let result = {
status: 0,
bossInfo: null
};
let battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode);
if(battleRecord && battleRecord.record && battleRecord.record.bossInstanceCode) {
let bossInstance = await BossInstanceModel.findByCode(battleRecord.record.bossInstanceCode);
if(bossInstance) {
let info = await getBossInstanceInfoByData(bossInstance, userGuild);
result.status = bossInstance.status;
result.bossInfo = info.bossInfo && { ...info.bossInfo, encourageCnt: battleRecord.record.encourageCnt }
}
}
return resResult(STATUS.SUCCESS, result);
}
async action(msg: guildInter & { bossCode: string, damage: number, battleCode: string }, session: BackendSession) {
const { battleCode, damage, myUserGuild: userGuild, bossCode } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = parseInt(session.get('serverId'));
if(!userGuild) return resResult(STATUS.GUILD_NOT_FOUND);
const { guildCode } = userGuild;
let flag = await checkBossBattleMemberExists(guildCode, serverId, roleId, battleCode);
if (!flag) {
return resResult(STATUS.SUCCESS);
}
//记录伤害
let bossInstance = await BossInstanceModel.updateBossHp(bossCode, zoomInDamage(damage), roleId);
if(!bossInstance) { // 如果已经被扣成负的了
return resResult(STATUS.SUCCESS, { bossHp: 0 });
}
await BattleRecordModel.incBossDamage(battleCode, zoomInDamage(damage), bossInstance.bossHp);
if (bossInstance.bossHp <= 0) {//进入结算
let res:any = await lockData(serverId, DATA_NAME.BOSS_SCRIPT, guildCode);//加锁
if (!!res.err)
return resResult(STATUS.SUCCESS, { bossHp: 0 });
bossInstance = await BossInstanceModel.clearBoss(bossCode, bossInstance.bossHp, roleId);
if (!bossInstance) return resResult(STATUS.SUCCESS, { bossHp: 0 });
let { warId, bossLv } = bossInstance;//锁定关卡信息
await pushBossHpMessage(guildCode, serverId, 0, true);
// 击杀奖励&伤害奖励
let dicBossBase = gameData.bossBaseByBossLv.get(bossLv);
let dicWar = gameData.war.get(warId);
await sendMailToGuildByContent(MAIL_TYPE.GUILD_BOSS_REWARD, guildCode, {
params: [`${dicWar.gk_name?.split('&')[1]}`], goods: dicBossBase.killReward
});
// 加入拍卖行
if(dicBossBase) {
let rewards = getAuctionRewardByPoolId(dicBossBase.rewards);
await genAuction(guildCode, AUCTION_SOURCE.BOSS, bossCode, serverId, rewards);
}
let result = await getBossInstanceInfoByData(bossInstance, userGuild);
await pushBossStatus(guildCode, result);
pushGuildBossSucMsg(roleId, roleName, guildCode, bossInstance);
await addBossWarExtendActive(bossCode, serverId)
res.releaseCallback();//解锁
return resResult(STATUS.SUCCESS, { bossHp: 0 });
} else {
pushBossHpMessage(guildCode, serverId, bossInstance.bossHp);
return resResult(STATUS.SUCCESS, { bossHp: bossInstance.bossHp });
}
}
async battleBossEnd(msg: guildInter & { bossCode: string, battleCode: string, damageRecords: pvpEndParamInter[], round: number }, session: BackendSession) {
const { battleCode, myUserGuild: userGuild, bossCode, damageRecords, round } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
let bossInstance = await BossInstanceModel.findByCode(bossCode);
if(!bossInstance) return resResult(STATUS.WRONG_PARMS);
let battleRecord = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: 1, ...getBattleRecordParam(damageRecords, round) }//战斗结束统一设置成1
}, true);
let { bossDamage = 0 } = battleRecord.record; // 伤害奖励
let dicBossBase = gameData.bossBaseByBossLv.get(bossInstance.bossLv);
let { basicReward, damageRewardTotal } = dicBossBase;
let damageReward = damageRewardTotal.map(cur => {
return { id: cur.id, count: Math.ceil(cur.count * bossDamage / bossInstance.bossTotalHp )}
})
let reward = [...basicReward, ...damageReward];
let battleGoods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BOSS_BATTLE_END);
let result = await getBossInstanceInfoByData(bossInstance, userGuild);
return resResult(STATUS.SUCCESS, { ...result, battleGoods, createdAt: getSeconds(battleRecord.createdAt) });
}
async encourage(msg: guildInter & { count: number }, session: BackendSession) {
const { count, myUserGuild: userGuild } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let bossInstance = await BossInstanceModel.findBossInstance(userGuild.guildCode);
if(!bossInstance) return resResult(STATUS.GUILD_SCRIPT_NOT_OPENED);
let { myEncourageCnt } = await refreshUserGuildOfBoss(userGuild);
let freeCount = dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_FREECOUNT - myEncourageCnt > 0? dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_FREECOUNT - myEncourageCnt: 0;
let costGold = (count - freeCount) * dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_COST;
if(costGold < 0) costGold = 0;
let { gold } = await RoleModel.findByRoleId(roleId, 'gold');
if(gold < costGold) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
let { code, bossLv } = bossInstance;
let dicBossBase = gameData.bossBaseByBossLv.get(bossLv);
bossInstance = await BossInstanceModel.encourage(code, count, dicBossBase.encourageSum); // 军团次数
if(!bossInstance) return resResult(STATUS.GUILD_SCRIPT_ENCOURGE_NOT_ENOUGH);
let consume = getGoldObject(costGold);
let costResult = await handleCost(roleId, sid, [consume], ITEM_CHANGE_REASON.GUILD_BOSS_ENCOURAGE);
if(!costResult) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
let { myEncourageCnt: myEncourageCntResult } = await refreshUserGuildOfBoss(userGuild, count);
let result = {
encourageCnt: bossInstance.encourageCnt,
encourageMax: dicBossBase.encourageSum,
myEncourageCnt: myEncourageCntResult
}
await sendMessageToGuildWithSuc(userGuild.guildCode, PUSH_ROUTE.GUILD_BOSS_ENCOURAGE, result);
return resResult(STATUS.SUCCESS, result);
}
async debugAddBattleTimes(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const roleId: string = session.get('roleId');
await UserGuildModel.updateInfo(roleId, { bossChallengeCnt: 0 }, {});
return resResult(STATUS.SUCCESS);
}
async debugAddOpenTimes(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const guildCode: string = session.get('guildCode');
await GuildModel.updateInfo(guildCode, { openBossCnt: 0 }, {});
return resResult(STATUS.SUCCESS);
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,202 +1,203 @@
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { UserGuildModel } from '../../../db/UserGuild';
import { resResult } from '../../../pubUtils/util';
import { STATUS, GUILD_OPERATE, TASK_TYPE, ITEM_CHANGE_REASON, ITID, CONSUME_TYPE } from '../../../consts';
import { GuildRefineModel } from '../../../db/GuildRefine';
import { gameData, getArmyDevelopConsumeById, getGoodById } from '../../../pubUtils/data';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { handleCost, addItems } from '../../../services/role/rewardService';
import { GuildModel } from '../../../db/Guild';
import { findIndex, findWhere } from 'underscore';
import { lockData } from '../../../services/redLockService';
import { ARMY } from '../../../pubUtils/dicParam';
import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
import { checkEquipProduceStructureLv, openGuildRefine, refreshRefinCnt } from '../../../services/guildRefineService';
import { DATA_NAME } from '../../../consts/dataName';
import { checkTask } from '../../../services/task/taskService';
import { guildInter } from '../../../pubUtils/interface';
import { DicArmyDevelopConsume } from '../../../pubUtils/dictionary/DicArmyDevelopConsume';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildRefineHandler(app);
}
export class GuildRefineHandler {
constructor(private app: Application) {
}
/**
* 获得科技树信息
* @param msg
* @param session
*/
async getRefine(msg: guildInter & {}, session: BackendSession) {
const { myUserGuild: userGuild } = msg;
const { guildCode: code } = userGuild;
let guildRefine = await GuildRefineModel.getRefine(code);
if (!guildRefine) {
guildRefine = await openGuildRefine(code);
}
let { refineCnt } = refreshRefinCnt(userGuild);
return resResult(STATUS.SUCCESS, { scienceTrees: guildRefine.scienceTrees, refineCnt });
}
/**
* 炼器
* @param msg
* @param session
*/
async refine(msg: guildInter & { id: number, count: number }, session: BackendSession) {
let { id, count, myUserGuild: userGuild } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
let dicGoods = gameData.goods.get(id);
if(!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicItid = ITID.get(dicGoods.itid);
if(!dicItid || dicItid.type != CONSUME_TYPE.DRAWING) return resResult(STATUS.GUILD_CANNOT_REFINE_THIS);
let { guildCode: code } = userGuild;
let guildRefine = await GuildRefineModel.getRefine(code);
if(!guildRefine) return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);
let { scienceTrees } = guildRefine;
let dicDevelopConsume: DicArmyDevelopConsume;
for(let scienceTree of scienceTrees) {
if(scienceTree.endTime && scienceTree.endTime >= nowSeconds()) continue; // 没有炼完
let _dicDevelopConsume = getArmyDevelopConsumeById(scienceTree.id);
if(_dicDevelopConsume.quality != dicGoods.quality) continue; // 品质错误
if(!dicDevelopConsume || dicDevelopConsume.qualityLevel < _dicDevelopConsume.qualityLevel) { // 选择等级最高的
dicDevelopConsume = _dicDevelopConsume;
}
}
if(!dicDevelopConsume) return resResult(STATUS.GUILD_CANNOT_REFINE_THIS);
let { refineCnt, refRefineTime } = refreshRefinCnt(userGuild);
let curQualityCnt = refineCnt.find(cur => cur.quality == dicGoods.quality);
let myCnt = curQualityCnt?.count||0;
if(myCnt + count > dicDevelopConsume.max) return resResult(STATUS.GUILD_REFINE_CNT_MAX);
if(!curQualityCnt) {
refineCnt.push({ quality: dicGoods.quality, count });
} else {
curQualityCnt.count += count;
}
let result = await handleCost(roleId, sid, dicDevelopConsume.honourConsume.map(cur=> ({...cur, count: cur.count * count })), ITEM_CHANGE_REASON.REFINE_EQUIP);
if (!result)
return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
await UserGuildModel.updateInfo(roleId, { refineCnt, refRefineTime }, {});
let goods = await addItems(roleId, roleName, sid, [{ id, count }], ITEM_CHANGE_REASON.REFINE_EQUIP);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_REFINE, { quality: dicGoods.quality, count });
return resResult(STATUS.SUCCESS, { goods, refineCnt });
}
/**
* 点亮科技树
* @param msg
* @param session
*/
async lightUpTree(msg: guildInter & guildInter & { id: number }, session: BackendSession) {
let { id } = msg;
const serverId: number = session.get('serverId');
const { myUserGuild: userGuild } = msg
const { guildCode: code } = userGuild;
let { structure } = await GuildModel.findByCode(code, serverId);
let dicDevelopConsume = getArmyDevelopConsumeById(id);
if (!dicDevelopConsume) return resResult(STATUS.WRONG_PARMS);
let res: any = await lockData(serverId, DATA_NAME.GUILD_REFINE, code);//加锁
if (!!res.err) return resResult(STATUS.REDLOCK_ERR);
if(!checkEquipProduceStructureLv(structure, id)) {
res.releaseCallback();
return resResult(STATUS.GUILD_EQUIP_PRODUCE_LV_NOT_ENOUGH);
}
let guildRefine = await GuildRefineModel.getRefine(code);
let nowTime = nowSeconds();
for (let scienceTree of guildRefine.scienceTrees) {
if (scienceTree.id == id) {//检查是否点亮过
res.releaseCallback();
return resResult(STATUS.GUILD_LIGHT_UP_THE_SCIENCETREE);
}
if (scienceTree.endTime > nowTime) {
res.releaseCallback();
return resResult(STATUS.GUILD_SCIENCETREE_IS_RUNNING);//检查是否有在进行的科技研发,若在研发,不允许研发其他科技树
}
}
for (let prePosition of dicDevelopConsume.prePositions) {
let preScieceTree = guildRefine.scienceTrees.find(cur => cur.id == prePosition);
if (!preScieceTree || preScieceTree.endTime > nowTime) {
res.releaseCallback();
return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);//前置科技树未点亮
}
}
//点亮消耗
const costResult = await GuildModel.costFund(code, dicDevelopConsume.fundConsume);
if (!costResult) {
res.releaseCallback();
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
}
let scienceTree = { id, endTime: nowTime + dicDevelopConsume.timeConsume, assistRoleIds: [] }
let { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
res.releaseCallback();
return resResult(STATUS.SUCCESS, { scienceTrees });
}
/**
* 协助点亮科技树
* @param msg
* @param session
*/
async assistRefine(msg: guildInter & { id: number }, session: BackendSession) {
let { id, myUserGuild: userGuild } = msg;
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { guildCode: code } = userGuild;
let res: any = await lockData(serverId, DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildRefine = await GuildRefineModel.getRefine(code);
let index = findIndex(guildRefine.scienceTrees, { id });
if (index == -1) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
let scienceTree = guildRefine.scienceTrees[index];
if (scienceTree.assistRoleIds.indexOf(roleId) != -1) {
res.releaseCallback();
return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE); //玩家已经协助过
}
if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) {
res.releaseCallback();
return resResult(STATUS.GUILD_REACH_MAX_ASSIST_COUNT); //协助的人数已经达到最大
}
let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_DEVELOPMENT_SPEEDCOST }], ITEM_CHANGE_REASON.ASSIST_REFINE);
if (!result) {
res.releaseCallback();
return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
scienceTree.assistRoleIds.push(roleId);
scienceTree.endTime = scienceTree.endTime - ARMY.ARMY_DEVELOPMENT_SPEED * 60;
let { scienceTrees } = await GuildRefineModel.updateRefine(code, { scienceTrees: guildRefine.scienceTrees })
res.releaseCallback();
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ASSIST_REFINE);
return resResult(STATUS.SUCCESS, { scienceTrees });
}
}
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { UserGuildModel } from '@db/UserGuild';
import { resResult } from '@pubUtils/util';
import { STATUS, GUILD_OPERATE, TASK_TYPE, ITEM_CHANGE_REASON, ITID, CONSUME_TYPE } from '../../../consts';
import { GuildRefineModel } from '@db/GuildRefine';
import { gameData, getArmyDevelopConsumeById, getGoodById } from '@pubUtils/data';
import { nowSeconds } from '@pubUtils/timeUtil';
import { handleCost, addItems } from '../../../services/role/rewardService';
import { GuildModel } from '@db/Guild';
import { findIndex, findWhere } from 'underscore';
import { lockData } from '../../../services/redLockService';
import { ARMY } from '@pubUtils/dicParam';
import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '@consts/constModules/itemConst';
import { checkEquipProduceStructureLv, openGuildRefine, refreshRefinCnt } from '../../../services/guildRefineService';
import { DATA_NAME } from '@consts/dataName';
import { checkTask } from '../../../services/task/taskService';
import { guildInter } from '@pubUtils/interface';
import { DicArmyDevelopConsume } from '@pubUtils/dictionary/DicArmyDevelopConsume';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildRefineHandler(app);
}
export class GuildRefineHandler {
constructor(private app: Application) {
}
/**
* 获得科技树信息
* @param msg
* @param session
*/
async getRefine(msg: guildInter & {}, session: BackendSession) {
const { myUserGuild: userGuild } = msg;
const { guildCode: code } = userGuild;
let guildRefine = await GuildRefineModel.getRefine(code);
if (!guildRefine) {
guildRefine = await openGuildRefine(code);
}
let { refineCnt } = refreshRefinCnt(userGuild);
return resResult(STATUS.SUCCESS, { scienceTrees: guildRefine.scienceTrees, refineCnt });
}
/**
* 炼器
* @param msg
* @param session
*/
async refine(msg: guildInter & { id: number, count: number }, session: BackendSession) {
let { id, count, myUserGuild: userGuild } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
let dicGoods = gameData.goods.get(id);
if(!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicItid = ITID.get(dicGoods.itid);
if(!dicItid || dicItid.type != CONSUME_TYPE.DRAWING) return resResult(STATUS.GUILD_CANNOT_REFINE_THIS);
let { guildCode: code } = userGuild;
let guildRefine = await GuildRefineModel.getRefine(code);
if(!guildRefine) return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);
let { scienceTrees } = guildRefine;
let dicDevelopConsume: DicArmyDevelopConsume;
for(let scienceTree of scienceTrees) {
if(scienceTree.endTime && scienceTree.endTime >= nowSeconds()) continue; // 没有炼完
let _dicDevelopConsume = getArmyDevelopConsumeById(scienceTree.id);
if(_dicDevelopConsume.quality != dicGoods.quality) continue; // 品质错误
if(!dicDevelopConsume || dicDevelopConsume.qualityLevel < _dicDevelopConsume.qualityLevel) { // 选择等级最高的
dicDevelopConsume = _dicDevelopConsume;
}
}
if(!dicDevelopConsume) return resResult(STATUS.GUILD_CANNOT_REFINE_THIS);
let { refineCnt, refRefineTime } = refreshRefinCnt(userGuild);
let curQualityCnt = refineCnt.find(cur => cur.quality == dicGoods.quality);
let myCnt = curQualityCnt?.count||0;
if(myCnt + count > dicDevelopConsume.max) return resResult(STATUS.GUILD_REFINE_CNT_MAX);
if(!curQualityCnt) {
refineCnt.push({ quality: dicGoods.quality, count });
} else {
curQualityCnt.count += count;
}
let result = await handleCost(roleId, sid, dicDevelopConsume.honourConsume.map(cur=> ({...cur, count: cur.count * count })), ITEM_CHANGE_REASON.REFINE_EQUIP);
if (!result)
return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
await UserGuildModel.updateInfo(roleId, { refineCnt, refRefineTime }, {});
let goods = await addItems(roleId, roleName, sid, [{ id, count }], ITEM_CHANGE_REASON.REFINE_EQUIP);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_REFINE, { quality: dicGoods.quality, count });
return resResult(STATUS.SUCCESS, { goods, refineCnt });
}
/**
* 点亮科技树
* @param msg
* @param session
*/
async lightUpTree(msg: guildInter & guildInter & { id: number }, session: BackendSession) {
let { id } = msg;
const serverId: number = session.get('serverId');
const { myUserGuild: userGuild } = msg
const { guildCode: code } = userGuild;
let { structure } = await GuildModel.findByCode(code, serverId);
let dicDevelopConsume = getArmyDevelopConsumeById(id);
if (!dicDevelopConsume) return resResult(STATUS.WRONG_PARMS);
let res: any = await lockData(serverId, DATA_NAME.GUILD_REFINE, code);//加锁
if (!!res.err) return resResult(STATUS.REDLOCK_ERR);
if(!checkEquipProduceStructureLv(structure, id)) {
res.releaseCallback();
return resResult(STATUS.GUILD_EQUIP_PRODUCE_LV_NOT_ENOUGH);
}
let guildRefine = await GuildRefineModel.getRefine(code);
let nowTime = nowSeconds();
for (let scienceTree of guildRefine.scienceTrees) {
if (scienceTree.id == id) {//检查是否点亮过
res.releaseCallback();
return resResult(STATUS.GUILD_LIGHT_UP_THE_SCIENCETREE);
}
if (scienceTree.endTime > nowTime) {
res.releaseCallback();
return resResult(STATUS.GUILD_SCIENCETREE_IS_RUNNING);//检查是否有在进行的科技研发,若在研发,不允许研发其他科技树
}
}
for (let prePosition of dicDevelopConsume.prePositions) {
let preScieceTree = guildRefine.scienceTrees.find(cur => cur.id == prePosition);
if (!preScieceTree || preScieceTree.endTime > nowTime) {
res.releaseCallback();
return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);//前置科技树未点亮
}
}
//点亮消耗
const costResult = await GuildModel.costFund(code, dicDevelopConsume.fundConsume);
if (!costResult) {
res.releaseCallback();
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
}
let scienceTree = { id, endTime: nowTime + dicDevelopConsume.timeConsume, assistRoleIds: [] }
let { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
res.releaseCallback();
return resResult(STATUS.SUCCESS, { scienceTrees });
}
/**
* 协助点亮科技树
* @param msg
* @param session
*/
async assistRefine(msg: guildInter & { id: number }, session: BackendSession) {
let { id, myUserGuild: userGuild } = msg;
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { guildCode: code } = userGuild;
let res: any = await lockData(serverId, DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildRefine = await GuildRefineModel.getRefine(code);
let index = findIndex(guildRefine.scienceTrees, { id });
if (index == -1) {
res.releaseCallback();
return resResult(STATUS.WRONG_PARMS);
}
let scienceTree = guildRefine.scienceTrees[index];
if (scienceTree.assistRoleIds.indexOf(roleId) != -1) {
res.releaseCallback();
return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE); //玩家已经协助过
}
if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) {
res.releaseCallback();
return resResult(STATUS.GUILD_REACH_MAX_ASSIST_COUNT); //协助的人数已经达到最大
}
let result = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: ARMY.ARMY_DEVELOPMENT_SPEEDCOST }], ITEM_CHANGE_REASON.ASSIST_REFINE);
if (!result) {
res.releaseCallback();
return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
scienceTree.assistRoleIds.push(roleId);
scienceTree.endTime = scienceTree.endTime - ARMY.ARMY_DEVELOPMENT_SPEED * 60;
let { scienceTrees } = await GuildRefineModel.updateRefine(code, { scienceTrees: guildRefine.scienceTrees })
res.releaseCallback();
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ASSIST_REFINE);
return resResult(STATUS.SUCCESS, { scienceTrees });
}
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,269 +1,270 @@
import { Application, ChannelService, BackendSession, HandlerService, pinus, } from "pinus";
import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, REDIS_KEY, TASK_TYPE, PUSH_ROUTE, DEBUG_MAGIC_WORD } from "../../../consts";
import { genCode, resResult } from "../../../pubUtils/util";
import { getGuildActivityStatus, getWoodenHorseList, getGAIndexInPinus, getJoinIndex, leaveRaceActivity } from "../../../services/guildActivity/guildActivityService";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
import { Rank } from "../../../services/rankService";
import { checkTask } from "../../../services/task/taskService";
import { ServerRecordModel } from "../../../db/ServerRecords";
import { sendMessageToGuildWithSuc } from "../../../services/pushService";
import { RaceActivityRankParam } from "../../../domain/battleField/guildActivity";
import { GuildRankInfo } from "../../../domain/rank";
import { dispatch } from "../../../pubUtils/dispatcher";
import { redisClient } from "../../../services/redisService";
import { getRaceActivityObj } from "../../../services/memoryCache/guildActivityData";
export default function (app: Application) {
new HandlerService(app, {});
return new RaceActivityHandler(app);
}
export class RaceActivityHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
private aid = GUILD_ACTIVITY_TYPE.RACE_ACTIVITY; // 蛮夷入侵id
// 进入粮草先行界面
async getRaceActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let obj = getRaceActivityObj();
let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let events = obj.getEvents(guildCode, woodenHorse.distance);
let ranks: { myGuildRank?: RaceActivityRankParam, guildRank?: RaceActivityRankParam[] } = {};
let hasJoin = await obj.updateMemberSid(guildCode, serverId, roleId, sid);
if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
ranks = await obj.getRanks(serverId, guildCode);
} else {
let index = getGAIndexInPinus(this.aid);
let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId, index });
r.setGenerFieldsFun(function (param: GuildRankInfo) {
let { rank, code, name, num, num1, num2 } = param;
return { rank, code, name, num, time: Math.floor(num1/1000), durability: num2 };
});
let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
ranks = { guildRank, myGuildRank }
}
return resResult(STATUS.SUCCESS, {
...statusResult,
hasJoin: !!hasJoin,
code: hasJoin?.code||'',
woodenHorse,
...ranks,
events
});
}
// 离开粮草先行界面
async leavePage(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
await leaveRaceActivity(serverId, guildCode, roleId);
return resResult(STATUS.SUCCESS);
}
// 加入木马
async join(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let joinIndex = getJoinIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let obj = getRaceActivityObj();
let hasJoin = !!obj.getMember(guildCode, roleId);
if (hasJoin) {
return resResult(STATUS.RACE_HAS_JOIN);
}
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, joinIndex, obj.getEvents(guildCode, 0));
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
let myGuild = await UserGuildModel.getMyGuild(roleId, 'job');
let woodenHorse = await obj.joinWoodenHorse(guildCode, roleId, roleName, serverId, sid, myGuild.job, myGuildActivityRec.code);
if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
await GuildActivityRecordModel.join(guildCode, this.aid, joinIndex, { roleId, roleName, job: myGuild.job, code: myGuildActivityRec.code });
let events = obj.getEvents(guildCode, woodenHorse.distance);
await sendMessageToGuildWithSuc(guildCode, PUSH_ROUTE.GUILD_RACE_JOIN, { timestamp: Date.now(), woodenHorse });
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ACTIVITY, { aid: this.aid });
return resResult(STATUS.SUCCESS, {
code: myGuildActivityRec.code,
...statusResult,
hasJoin,
woodenHorse,
events
});
}
// 打开竞赛页面
async getRace(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// if (statusResult.status != GUILD_ACTIVITY_STATUS.START) {
// return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
// }
let obj = getRaceActivityObj();
let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let events = obj.getEvents(guildCode, woodenHorse.distance);
let hasJoin = !!obj.getMember(guildCode, roleId);
let items = obj.getItem(roleId);
let woodenHorseList = await getWoodenHorseList(guildCode, serverId);
return resResult(STATUS.SUCCESS, {
...statusResult,
hasJoin,
woodenHorseList,
events,
items
});
}
// 使用道具
async useItem(msg: { id: number, count: number, toGuild: string }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let guildCode = session.get('guildCode');
let sid = session.get('sid');
let joinIndex = getJoinIndex();
let { id, count, toGuild } = msg;
let obj = getRaceActivityObj();
let woodenHorse = obj.getWoodenHorse(toGuild, serverId);
if (!woodenHorse) return resResult(STATUS.WRONG_PARMS);
let event = await obj.useItem(serverId, roleId, sid, guildCode, toGuild, id, count);
if (!event) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
await GuildActivityRecordModel.pushEvent(guildCode, this.aid, joinIndex, event);
return resResult(STATUS.SUCCESS, {
timestamp: Date.now(),
events: obj.getEvents(guildCode, 0)
});
}
// 结束挑战
async battleEnd(msg: { code: string, isSuccess: boolean }, session: BackendSession) {
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, isSuccess } = msg;
let joinIndex = getJoinIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, joinIndex);
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true });
if (!guildActivityRec || !myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
let hasShow = !!myGuildActivityRec.hasShow;
if(!hasShow) {
await UserGuildActivityRecModel.updateInfo(code, { hasShow: true });
}
// 返回当前军团总军功
let obj = getRaceActivityObj();
let myGuildRank = 0;
let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
if(woodenHorse) {
let { myGuildRank: rank, guildRank } = await obj.getRanks(serverId, guildCode);
// console.log('#', JSON.stringify(guildRank))
myGuildRank = rank?.rank||0;
if(woodenHorse) {
// console.log('########', woodenHorse.time - woodenHorse.allStartTime, rank.sortTime);
woodenHorse = woodenHorse.getTreatTime();
}
} else {
woodenHorse = guildActivityRec.woodenHorse;
myGuildRank = guildActivityRec.rank;
}
return resResult(STATUS.SUCCESS, {
timestamp: Date.now(),
hasShow,
woodenHorse,
myGuildRank
})
}
// 加入木马
async debugAddHorse(msg: { magicWord: string, isMyGuild: number, memberCnt: number, itemInterval: number }, session: BackendSession) {
const { magicWord, isMyGuild, memberCnt, itemInterval } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const serverId = session.get('serverId');
let guildCode = session.get('guildCode');
if(!isMyGuild) {
guildCode = genCode(8);
}
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guild = pinus.app.getServersByType('guild');
let sid = await dispatch(redisClient(), `${serverId}`, guild, 'guild');
pinus.app.rpc.guild.guildActivityRemote.debugAddHorse.toServer(sid.id, serverId, guildCode, memberCnt, itemInterval)
return resResult(STATUS.SUCCESS);
}
}
import { Application, ChannelService, BackendSession, HandlerService, pinus, } from "pinus";
import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, REDIS_KEY, TASK_TYPE, PUSH_ROUTE, DEBUG_MAGIC_WORD } from "../../../consts";
import { genCode, resResult } from "@pubUtils/util";
import { getGuildActivityStatus, getWoodenHorseList, getGAIndexInPinus, getJoinIndex, leaveRaceActivity } from "../../../services/guildActivity/guildActivityService";
import { UserGuildModel } from "@db/UserGuild";
import { GuildActivityRecordModel } from "@db/GuildActivityRec";
import { UserGuildActivityRecModel } from "@db/UserGuildActivityRec";
import { Rank } from "../../../services/rankService";
import { checkTask } from "../../../services/task/taskService";
import { ServerRecordModel } from "@db/ServerRecords";
import { sendMessageToGuildWithSuc } from "../../../services/pushService";
import { RaceActivityRankParam } from "@domain/battleField/guildActivity";
import { GuildRankInfo } from "@domain/rank";
import { dispatch } from "@pubUtils/dispatcher";
import { redisClient } from "../../../services/redisService";
import { getRaceActivityObj } from "../../../services/memoryCache/guildActivityData";
export default function (app: Application) {
new HandlerService(app, {});
return new RaceActivityHandler(app);
}
export class RaceActivityHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
private aid = GUILD_ACTIVITY_TYPE.RACE_ACTIVITY; // 蛮夷入侵id
// 进入粮草先行界面
async getRaceActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let obj = getRaceActivityObj();
let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let events = obj.getEvents(guildCode, woodenHorse.distance);
let ranks: { myGuildRank?: RaceActivityRankParam, guildRank?: RaceActivityRankParam[] } = {};
let hasJoin = await obj.updateMemberSid(guildCode, serverId, roleId, sid);
if(obj.getStatus() == GUILD_ACTIVITY_STATUS.START) {
ranks = await obj.getRanks(serverId, guildCode);
} else {
let index = getGAIndexInPinus(this.aid);
let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId, index });
r.setGenerFieldsFun(function (param: GuildRankInfo) {
let { rank, code, name, num, num1, num2 } = param;
return { rank, code, name, num, time: Math.floor(num1/1000), durability: num2 };
});
let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
ranks = { guildRank, myGuildRank }
}
return resResult(STATUS.SUCCESS, {
...statusResult,
hasJoin: !!hasJoin,
code: hasJoin?.code||'',
woodenHorse,
...ranks,
events
});
}
// 离开粮草先行界面
async leavePage(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
await leaveRaceActivity(serverId, guildCode, roleId);
return resResult(STATUS.SUCCESS);
}
// 加入木马
async join(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let joinIndex = getJoinIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let obj = getRaceActivityObj();
let hasJoin = !!obj.getMember(guildCode, roleId);
if (hasJoin) {
return resResult(STATUS.RACE_HAS_JOIN);
}
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, joinIndex, obj.getEvents(guildCode, 0));
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
let myGuild = await UserGuildModel.getMyGuild(roleId, 'job');
let woodenHorse = await obj.joinWoodenHorse(guildCode, roleId, roleName, serverId, sid, myGuild.job, myGuildActivityRec.code);
if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
await GuildActivityRecordModel.join(guildCode, this.aid, joinIndex, { roleId, roleName, job: myGuild.job, code: myGuildActivityRec.code });
let events = obj.getEvents(guildCode, woodenHorse.distance);
await sendMessageToGuildWithSuc(guildCode, PUSH_ROUTE.GUILD_RACE_JOIN, { timestamp: Date.now(), woodenHorse });
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
// 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.GUILD_ACTIVITY, { aid: this.aid });
return resResult(STATUS.SUCCESS, {
code: myGuildActivityRec.code,
...statusResult,
hasJoin,
woodenHorse,
events
});
}
// 打开竞赛页面
async getRace(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// if (statusResult.status != GUILD_ACTIVITY_STATUS.START) {
// return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
// }
let obj = getRaceActivityObj();
let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
if (!woodenHorse) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let events = obj.getEvents(guildCode, woodenHorse.distance);
let hasJoin = !!obj.getMember(guildCode, roleId);
let items = obj.getItem(roleId);
let woodenHorseList = await getWoodenHorseList(guildCode, serverId);
return resResult(STATUS.SUCCESS, {
...statusResult,
hasJoin,
woodenHorseList,
events,
items
});
}
// 使用道具
async useItem(msg: { id: number, count: number, toGuild: string }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let guildCode = session.get('guildCode');
let sid = session.get('sid');
let joinIndex = getJoinIndex();
let { id, count, toGuild } = msg;
let obj = getRaceActivityObj();
let woodenHorse = obj.getWoodenHorse(toGuild, serverId);
if (!woodenHorse) return resResult(STATUS.WRONG_PARMS);
let event = await obj.useItem(serverId, roleId, sid, guildCode, toGuild, id, count);
if (!event) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
await GuildActivityRecordModel.pushEvent(guildCode, this.aid, joinIndex, event);
return resResult(STATUS.SUCCESS, {
timestamp: Date.now(),
events: obj.getEvents(guildCode, 0)
});
}
// 结束挑战
async battleEnd(msg: { code: string, isSuccess: boolean }, session: BackendSession) {
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, isSuccess } = msg;
let joinIndex = getJoinIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, joinIndex);
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true });
if (!guildActivityRec || !myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
let hasShow = !!myGuildActivityRec.hasShow;
if(!hasShow) {
await UserGuildActivityRecModel.updateInfo(code, { hasShow: true });
}
// 返回当前军团总军功
let obj = getRaceActivityObj();
let myGuildRank = 0;
let woodenHorse = await obj.getWoodenHorse(guildCode, serverId);
if(woodenHorse) {
let { myGuildRank: rank, guildRank } = await obj.getRanks(serverId, guildCode);
// console.log('#', JSON.stringify(guildRank))
myGuildRank = rank?.rank||0;
if(woodenHorse) {
// console.log('########', woodenHorse.time - woodenHorse.allStartTime, rank.sortTime);
woodenHorse = woodenHorse.getTreatTime();
}
} else {
woodenHorse = guildActivityRec.woodenHorse;
myGuildRank = guildActivityRec.rank;
}
return resResult(STATUS.SUCCESS, {
timestamp: Date.now(),
hasShow,
woodenHorse,
myGuildRank
})
}
// 加入木马
async debugAddHorse(msg: { magicWord: string, isMyGuild: number, memberCnt: number, itemInterval: number }, session: BackendSession) {
const { magicWord, isMyGuild, memberCnt, itemInterval } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const serverId = session.get('serverId');
let guildCode = session.get('guildCode');
if(!isMyGuild) {
guildCode = genCode(8);
}
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
if(statusResult.status != GUILD_ACTIVITY_STATUS.START) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guild = pinus.app.getServersByType('guild');
let sid = await dispatch(redisClient(), `${serverId}`, guild, 'guild');
pinus.app.rpc.guild.guildActivityRemote.debugAddHorse.toServer(sid.id, serverId, guildCode, memberCnt, itemInterval)
return resResult(STATUS.SUCCESS);
}
}

View File

@@ -1,172 +1,173 @@
import { Application, BackendSession } from 'pinus';
import { UserGuildModel } from '../../../db/UserGuild';
import { GuildModel } from '../../../db/Guild';
import { WishPoolReportModel } from '../../../db/WishPoolReport';
import { resResult, genCode } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, PUSH_ROUTE, STATUS } from '../../../consts';
import { gameData, getGoodById, getWishPoolReward } from '../../../pubUtils/data';
import { addItems, checkGoods, checkHeroEquips, checkHeroes, getHonourObject, handleCost } from '../../../services/role/rewardService';
import { ITID, CONSUME_TYPE } from '../../../consts/constModules/itemConst';
import { GUILD_POINT_WAYS, GUILD_STRUCTURE, WISH_POOL_TYPE } from '../../../consts/constModules/guildConst';
import { getWishPool, getUserGuildWithRefActive, addActive, canWishToday } from '../../../services/guildService';
import { findIndex, findWhere } from 'underscore';
import { RoleModel } from '../../../db/Role';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { ARMY } from '../../../pubUtils/dicParam';
import { guildInter } from '../../../pubUtils/interface';
import { getSeconds, getZeroPoint, nowSeconds, isToday } from '../../../pubUtils/timeUtil';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
import { isGoodsHidden } from '../../../services/dataService';
export default function(app: Application) {
return new WishPoolHandler(app);
}
export class WishPoolHandler {
constructor(private app: Application) {
}
async getWishPool(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
let res = await getWishPool(userGuild);
return resResult(STATUS.SUCCESS, res);
}
// 许愿
async wishGoods(msg: guildInter & {goodId: number, type: number}, session: BackendSession) {
const { goodId, type, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
if(isGoodsHidden(goodId)) return resResult(STATUS.ITEM_IS_HIDDEN);
let dicGoods = getGoodById(goodId)
if (!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicItid = ITID.get(dicGoods.itid);
if (dicItid.type != CONSUME_TYPE.SOUL || type != WISH_POOL_TYPE.SOUL)
return resResult(STATUS.GUILD_WISH_POOL_CAN_NOT_WISH);
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild) return resResult(STATUS.WRONG_PARMS);
// 退出A军团 和 新入B军团 在同一天, 且在A军团已经许过愿那么此时不允许许愿
if (!await canWishToday(roleId)) {
return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
}
const { guildCode: code, wishGoods, receivedWishPool } = userGuild;
let { lv } = await GuildModel.findGuild(code, serverId, 'lv');
let len = wishGoods.filter(cur => cur.type == type).length;
if(receivedWishPool.indexOf(type) != -1) {
return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
}
if (len >= ARMY.ARMY_WISH_TIMES) //今日已经许愿过
return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
let dicStructure = gameData.centerBase.get(lv);
let count = 0;
if (type == WISH_POOL_TYPE.SOUL) {
let wishGoodsHero = dicStructure.wishgoodsHero.find(cur => cur.quality == dicGoods.quality);
if (!wishGoodsHero) return resResult(STATUS.NOT_WISH_THE_QUALITY_GOODS);
count = wishGoodsHero.count;
}
const id = genCode(6);
let { wishGoods: resWishGoods } = await UserGuildModel.pushAndUpdate(roleId, {}, { wishGoods: { type, goodId, count, receiveCnt: 0, drawCnt: 0, id, donateNames:[]} }, 'wishGoods');
return resResult(STATUS.SUCCESS, { wishGoods: resWishGoods, receivedWishPool });
}
// 捐赠
async donateGoods(msg: guildInter & {wishRoleId: string, id: string}, session: BackendSession) {
let { wishRoleId, id, myUserGuild } = msg;
const dntRoleId: string = session.get('roleId');
const dntRoleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
if (wishRoleId == dntRoleId)
return resResult(STATUS.WRONG_PARMS);
let role = await RoleModel.findByRoleId(wishRoleId);
if (!role)
return resResult(STATUS.WRONG_PARMS);//没有玩家
let wishUserGuild = await getUserGuildWithRefActive(wishRoleId, ' wishDntCnt wishGoods guildCode');
if (!wishUserGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, wishGoods } = wishUserGuild;
let dntRoleGuild = await getUserGuildWithRefActive(dntRoleId);
if (!dntRoleGuild)
return resResult(STATUS.WRONG_PARMS);
if (dntRoleGuild.guildCode != code)
return resResult(STATUS.WRONG_PARMS);
if (dntRoleGuild.wishDntCnt >= ARMY.ARMY_WISH_HELP)
return resResult(STATUS.HAS_REACH_WISH_DONATE_COUNT_LIMIT);
let wishGood = findWhere(wishGoods, { id });
if (!wishGood)
return resResult(STATUS.WRONG_PARMS);//没有该许愿
if (wishGood.receiveCnt >= wishGood.count)
return resResult(STATUS.HAS_RECEIVE_WISH_GOOD);//已经收到
if(isGoodsHidden(wishGood.goodId)) return resResult(STATUS.ITEM_IS_HIDDEN);
let dicWishReward = getWishPoolReward(wishGood.goodId);
if(!dicWishReward) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let costResult = await handleCost(dntRoleId, sid, [{ id: wishGood.goodId, count: 1 }], ITEM_CHANGE_REASON.WISH_POOL_DONATE);
if(!costResult) return resResult(STATUS.GUILD_DONATE_CAN_NOT_SEND);
let { wishDntCnt } = await UserGuildModel.donateGoods(dntRoleId, 1, 'wishDntCnt');
let { wishGoods: resWishGoods } = await UserGuildModel.donateUpdate(wishRoleId, dntRoleName, id, 'wishGoods');
let hisOnlineInfo = await getRoleOnlineInfo(wishRoleId);
if(hisOnlineInfo.isOnline && hisOnlineInfo.sid) {
sendMessageToUserWithSuc(wishRoleId, PUSH_ROUTE.WISH_GOODS_RECEIVE, { wishGoods: resWishGoods }, hisOnlineInfo.sid);
}
await WishPoolReportModel.addReport(code, wishRoleId, role.roleName , dntRoleId, dntRoleName, wishGood.goodId, 1);
let goods = await addItems(dntRoleId, dntRoleName, sid, [getHonourObject(dicWishReward.honourReward)], ITEM_CHANGE_REASON.WISH_POOL_DONATE);
await addActive(dntRoleId, serverId, GUILD_POINT_WAYS.WISH_POOL);
return resResult(STATUS.SUCCESS, { wishDntCnt, goods, updateWishGoods: resWishGoods.map(({type, goodId, count, receiveCnt, drawCnt, id})=>{
return { type, goodId, count, receiveCnt, drawCnt, id, roleId: wishRoleId };
})
});
}
async receiveGoods(msg: guildInter & { id: string }, session: BackendSession) {
let { id, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { wishGoods, receivedWishPool } = userGuild;
let index = findIndex(wishGoods, { id });
if (index == -1)
return resResult(STATUS.WRONG_PARMS);
let { drawCnt, goodId } = wishGoods[index];
if (drawCnt <= 0)
return resResult(STATUS.WRONG_PARMS);
wishGoods[index].drawCnt = 0;
if(receivedWishPool.indexOf(wishGoods[index].type) == -1) receivedWishPool.push(wishGoods[index].type);
let result = await UserGuildModel.updateInfo(roleId, { wishGoods, receivedWishPool }, {});
if (!result)
resResult(STATUS.INTERNAL_ERR);
let goods = await addItems(roleId, roleName, sid, [{ id : goodId, count: drawCnt }], ITEM_CHANGE_REASON.WISH_POOL_RECEIVE);
return resResult(STATUS.SUCCESS, { goods, wishGoods, receivedWishPool });
}
async getReports(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const { myUserGuild } = msg;
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
const reports = await WishPoolReportModel.getReportsByTime(code, 1);//获得今天的捐赠日报
return resResult(STATUS.SUCCESS, { reports });
}
}
import { Application, BackendSession } from 'pinus';
import { UserGuildModel } from '@db/UserGuild';
import { GuildModel } from '@db/Guild';
import { WishPoolReportModel } from '@db/WishPoolReport';
import { resResult, genCode } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, PUSH_ROUTE, STATUS } from '../../../consts';
import { gameData, getGoodById, getWishPoolReward } from '@pubUtils/data';
import { addItems, checkGoods, checkHeroEquips, checkHeroes, getHonourObject, handleCost } from '../../../services/role/rewardService';
import { ITID, CONSUME_TYPE } from '@consts/constModules/itemConst';
import { GUILD_POINT_WAYS, GUILD_STRUCTURE, WISH_POOL_TYPE } from '@consts/constModules/guildConst';
import { getWishPool, getUserGuildWithRefActive, addActive, canWishToday } from '../../../services/guildService';
import { findIndex, findWhere } from 'underscore';
import { RoleModel } from '@db/Role';
import { getRoleOnlineInfo } from '../../../services/redisService';
import { ARMY } from '@pubUtils/dicParam';
import { guildInter } from '@pubUtils/interface';
import { getSeconds, getZeroPoint, nowSeconds, isToday } from '@pubUtils/timeUtil';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
import { isGoodsHidden } from '../../../services/dataService';
export default function(app: Application) {
return new WishPoolHandler(app);
}
export class WishPoolHandler {
constructor(private app: Application) {
}
async getWishPool(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
let res = await getWishPool(userGuild);
return resResult(STATUS.SUCCESS, res);
}
// 许愿
async wishGoods(msg: guildInter & {goodId: number, type: number}, session: BackendSession) {
const { goodId, type, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
if(isGoodsHidden(goodId)) return resResult(STATUS.ITEM_IS_HIDDEN);
let dicGoods = getGoodById(goodId)
if (!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicItid = ITID.get(dicGoods.itid);
if (dicItid.type != CONSUME_TYPE.SOUL || type != WISH_POOL_TYPE.SOUL)
return resResult(STATUS.GUILD_WISH_POOL_CAN_NOT_WISH);
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild) return resResult(STATUS.WRONG_PARMS);
// 退出A军团 和 新入B军团 在同一天, 且在A军团已经许过愿那么此时不允许许愿
if (!await canWishToday(roleId)) {
return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
}
const { guildCode: code, wishGoods, receivedWishPool } = userGuild;
let { lv } = await GuildModel.findGuild(code, serverId, 'lv');
let len = wishGoods.filter(cur => cur.type == type).length;
if(receivedWishPool.indexOf(type) != -1) {
return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
}
if (len >= ARMY.ARMY_WISH_TIMES) //今日已经许愿过
return resResult(STATUS.HAS_REACH_WISH_COUNT_LIMIT);
let dicStructure = gameData.centerBase.get(lv);
let count = 0;
if (type == WISH_POOL_TYPE.SOUL) {
let wishGoodsHero = dicStructure.wishgoodsHero.find(cur => cur.quality == dicGoods.quality);
if (!wishGoodsHero) return resResult(STATUS.NOT_WISH_THE_QUALITY_GOODS);
count = wishGoodsHero.count;
}
const id = genCode(6);
let { wishGoods: resWishGoods } = await UserGuildModel.pushAndUpdate(roleId, {}, { wishGoods: { type, goodId, count, receiveCnt: 0, drawCnt: 0, id, donateNames:[]} }, 'wishGoods');
return resResult(STATUS.SUCCESS, { wishGoods: resWishGoods, receivedWishPool });
}
// 捐赠
async donateGoods(msg: guildInter & {wishRoleId: string, id: string}, session: BackendSession) {
let { wishRoleId, id, myUserGuild } = msg;
const dntRoleId: string = session.get('roleId');
const dntRoleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
if (wishRoleId == dntRoleId)
return resResult(STATUS.WRONG_PARMS);
let role = await RoleModel.findByRoleId(wishRoleId);
if (!role)
return resResult(STATUS.WRONG_PARMS);//没有玩家
let wishUserGuild = await getUserGuildWithRefActive(wishRoleId, ' wishDntCnt wishGoods guildCode');
if (!wishUserGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, wishGoods } = wishUserGuild;
let dntRoleGuild = await getUserGuildWithRefActive(dntRoleId);
if (!dntRoleGuild)
return resResult(STATUS.WRONG_PARMS);
if (dntRoleGuild.guildCode != code)
return resResult(STATUS.WRONG_PARMS);
if (dntRoleGuild.wishDntCnt >= ARMY.ARMY_WISH_HELP)
return resResult(STATUS.HAS_REACH_WISH_DONATE_COUNT_LIMIT);
let wishGood = findWhere(wishGoods, { id });
if (!wishGood)
return resResult(STATUS.WRONG_PARMS);//没有该许愿
if (wishGood.receiveCnt >= wishGood.count)
return resResult(STATUS.HAS_RECEIVE_WISH_GOOD);//已经收到
if(isGoodsHidden(wishGood.goodId)) return resResult(STATUS.ITEM_IS_HIDDEN);
let dicWishReward = getWishPoolReward(wishGood.goodId);
if(!dicWishReward) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let costResult = await handleCost(dntRoleId, sid, [{ id: wishGood.goodId, count: 1 }], ITEM_CHANGE_REASON.WISH_POOL_DONATE);
if(!costResult) return resResult(STATUS.GUILD_DONATE_CAN_NOT_SEND);
let { wishDntCnt } = await UserGuildModel.donateGoods(dntRoleId, 1, 'wishDntCnt');
let { wishGoods: resWishGoods } = await UserGuildModel.donateUpdate(wishRoleId, dntRoleName, id, 'wishGoods');
let hisOnlineInfo = await getRoleOnlineInfo(wishRoleId);
if(hisOnlineInfo.isOnline && hisOnlineInfo.sid) {
sendMessageToUserWithSuc(wishRoleId, PUSH_ROUTE.WISH_GOODS_RECEIVE, { wishGoods: resWishGoods }, hisOnlineInfo.sid);
}
await WishPoolReportModel.addReport(code, wishRoleId, role.roleName , dntRoleId, dntRoleName, wishGood.goodId, 1);
let goods = await addItems(dntRoleId, dntRoleName, sid, [getHonourObject(dicWishReward.honourReward)], ITEM_CHANGE_REASON.WISH_POOL_DONATE);
await addActive(dntRoleId, serverId, GUILD_POINT_WAYS.WISH_POOL);
return resResult(STATUS.SUCCESS, { wishDntCnt, goods, updateWishGoods: resWishGoods.map(({type, goodId, count, receiveCnt, drawCnt, id})=>{
return { type, goodId, count, receiveCnt, drawCnt, id, roleId: wishRoleId };
})
});
}
async receiveGoods(msg: guildInter & { id: string }, session: BackendSession) {
let { id, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { wishGoods, receivedWishPool } = userGuild;
let index = findIndex(wishGoods, { id });
if (index == -1)
return resResult(STATUS.WRONG_PARMS);
let { drawCnt, goodId } = wishGoods[index];
if (drawCnt <= 0)
return resResult(STATUS.WRONG_PARMS);
wishGoods[index].drawCnt = 0;
if(receivedWishPool.indexOf(wishGoods[index].type) == -1) receivedWishPool.push(wishGoods[index].type);
let result = await UserGuildModel.updateInfo(roleId, { wishGoods, receivedWishPool }, {});
if (!result)
resResult(STATUS.INTERNAL_ERR);
let goods = await addItems(roleId, roleName, sid, [{ id : goodId, count: drawCnt }], ITEM_CHANGE_REASON.WISH_POOL_RECEIVE);
return resResult(STATUS.SUCCESS, { goods, wishGoods, receivedWishPool });
}
async getReports(msg: guildInter & {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const { myUserGuild } = msg;
let userGuild = await getUserGuildWithRefActive(roleId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
const reports = await WishPoolReportModel.getReportsByTime(code, 1);//获得今天的捐赠日报
return resResult(STATUS.SUCCESS, { reports });
}
}

View File

@@ -1,241 +1,242 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, setGuildActivityIndexInPinus, guildActivityStart, debugSendGateHp, debugAddHorse, leaveRaceActivity, leaveRaceWhenQuitGuild, leaveRaceWhenDismiss } from '../../../services/guildActivity/guildActivityService';
import { gameData } from '../../../pubUtils/data';
import { setWeek } from '../../../pubUtils/timeUtil';
import { sendUngotDividend } from '../../../services/auctionService';
import { errlogger } from '../../../util/logger';
import { GUILD_ACTIVITY_TYPE } from '../../../consts';
import { saveGuildActivityIndexMemory } from '../../../services/log/memoryLogService';
import { clearActivityObj } from '../../../services/memoryCache/guildActivityData';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildActivityRemote(app);
}
export class GuildActivityRemote {
constructor(private app: Application) {
this.app = app;
}
private currentTime: number = Date.now();
private setTime: number = Date.now();
private isAuctionPopUp: boolean = false;
/**
* 从systimer服分发到guild各个服发送排行榜数据
*/
public async sendRankToGuilds(aid: number) {
try {
await sendAllGuildRanks(aid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 发送结束活动消息
*/
public async guildActivityEnd(aid: number) {
try {
await settleGuildActivityReward(aid);
this.isAuctionPopUp = true;
setTimeout(() => { // 军团活动结束的15分钟内就不会再弹出了
this.isAuctionPopUp = false;
}, 15 * 60 * 1000);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 计算粮草先行木马状态并发送
*/
public async calWoodenHorseAndSend(serverId: number) {
try {
await calWoodenHorseAndSend(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 诸侯混战和蛮夷入侵开始
*/
async guildActivityStart(aid: number) {
try {
await guildActivityStart(aid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 发送粮草先行活动开始通知
*/
async raceActivityStart(serverId: number) {
try {
await sendRaceStartMsg(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* !! 注意,这条函数会改变内存中的字典表,影响甚大,请考虑清楚后使用
*/
async updateGuildActivityData(aid: number, isStart: boolean) {
try {
let guildActivity = gameData.guildActivity;
let cur = guildActivity.get(aid);
if (isStart) {
let now = new Date();
cur.startMinute = now.getMinutes();
cur.startTime = now.getHours();
cur.startSeconds = now.getSeconds();
} else {
let now = new Date(Date.now() - cur.duringTime * 1000);
cur.startMinute = now.getMinutes();
cur.startTime = now.getHours();
cur.startSeconds = now.getSeconds();
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的军团活动开始时间&持续时间
* @param {number} aid 活动
* @param {number} startSeconds 从现在开始几秒后开启活动
* @param {number} endSeconds 从开始之后几秒后结束活动
*/
async setDicGuildActivity(now: number, aid: number, startSeconds: number, endSeconds: number) {
try {
return setDicGuildActivity(now, aid, startSeconds, endSeconds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的拍卖行时间
*/
async setDicAuctionTime(startTime: number, endActivity: number, startGuild: number, endGuild: number, startWorld: number, endWorld: number) {
try {
setDicAuctionTime(startTime, endActivity, startGuild, endGuild, startWorld, endWorld);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* !! 注意,这条函数会改变内存时间,影响甚大,请考虑清楚后使用
*/
async setDay(week: number) {
try {
setWeek(week);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
setCurrentTime(time: number) {
try {
this.currentTime = time;
this.setTime = Date.now();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
getCurrentTime() {
try {
return Date.now() - this.setTime + this.currentTime;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async sendUngotDividend() {
try {
await sendUngotDividend();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getAuctionPopUpShow() {
try {
return this.isAuctionPopUp;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async clearActivityObj() {
try {
clearActivityObj();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async setGuildActivityIndex(aid: number, index: number) {
try {
setGuildActivityIndexInPinus(aid, index);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async debugSendGateHp(serverId: number, cityId: number) {
try {
await debugSendGateHp(serverId, cityId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async debugAddHorse(serverId: number, guildCode: string, memberCnt: number, itemInterval: number) {
try {
await debugAddHorse(serverId, guildCode, memberCnt, itemInterval);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public saveGuildActivityIndexMemory() {
try {
return saveGuildActivityIndexMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public leaveRaceActivity(serverId: number, guildCode: string, roleId: string) {
try {
return leaveRaceActivity(serverId, guildCode, roleId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public leaveRaceWhenQuitGuild(serverId: number, guildCode: string, roleId: string) {
try {
return leaveRaceWhenQuitGuild(serverId, guildCode, roleId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public leaveRaceWhenDismiss(guildCode: string, serverId: number) {
try {
return leaveRaceWhenDismiss(guildCode, serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, setGuildActivityIndexInPinus, guildActivityStart, debugSendGateHp, debugAddHorse, leaveRaceActivity, leaveRaceWhenQuitGuild, leaveRaceWhenDismiss } from '../../../services/guildActivity/guildActivityService';
import { gameData } from '@pubUtils/data';
import { setWeek } from '@pubUtils/timeUtil';
import { sendUngotDividend } from '../../../services/auctionService';
import { errlogger } from '../../../util/logger';
import { GUILD_ACTIVITY_TYPE } from '../../../consts';
import { saveGuildActivityIndexMemory } from '../../../services/log/memoryLogService';
import { clearActivityObj } from '../../../services/memoryCache/guildActivityData';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildActivityRemote(app);
}
export class GuildActivityRemote {
constructor(private app: Application) {
this.app = app;
}
private currentTime: number = Date.now();
private setTime: number = Date.now();
private isAuctionPopUp: boolean = false;
/**
* 从systimer服分发到guild各个服发送排行榜数据
*/
public async sendRankToGuilds(aid: number) {
try {
await sendAllGuildRanks(aid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 发送结束活动消息
*/
public async guildActivityEnd(aid: number) {
try {
await settleGuildActivityReward(aid);
this.isAuctionPopUp = true;
setTimeout(() => { // 军团活动结束的15分钟内就不会再弹出了
this.isAuctionPopUp = false;
}, 15 * 60 * 1000);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 计算粮草先行木马状态并发送
*/
public async calWoodenHorseAndSend(serverId: number) {
try {
await calWoodenHorseAndSend(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 诸侯混战和蛮夷入侵开始
*/
async guildActivityStart(aid: number) {
try {
await guildActivityStart(aid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 发送粮草先行活动开始通知
*/
async raceActivityStart(serverId: number) {
try {
await sendRaceStartMsg(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* !! 注意,这条函数会改变内存中的字典表,影响甚大,请考虑清楚后使用
*/
async updateGuildActivityData(aid: number, isStart: boolean) {
try {
let guildActivity = gameData.guildActivity;
let cur = guildActivity.get(aid);
if (isStart) {
let now = new Date();
cur.startMinute = now.getMinutes();
cur.startTime = now.getHours();
cur.startSeconds = now.getSeconds();
} else {
let now = new Date(Date.now() - cur.duringTime * 1000);
cur.startMinute = now.getMinutes();
cur.startTime = now.getHours();
cur.startSeconds = now.getSeconds();
}
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的军团活动开始时间&持续时间
* @param {number} aid 活动
* @param {number} startSeconds 从现在开始几秒后开启活动
* @param {number} endSeconds 从开始之后几秒后结束活动
*/
async setDicGuildActivity(now: number, aid: number, startSeconds: number, endSeconds: number) {
try {
return setDicGuildActivity(now, aid, startSeconds, endSeconds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* 改变字典表中的拍卖行时间
*/
async setDicAuctionTime(startTime: number, endActivity: number, startGuild: number, endGuild: number, startWorld: number, endWorld: number) {
try {
setDicAuctionTime(startTime, endActivity, startGuild, endGuild, startWorld, endWorld);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
/**
* !! 注意,这条函数会改变内存时间,影响甚大,请考虑清楚后使用
*/
async setDay(week: number) {
try {
setWeek(week);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
setCurrentTime(time: number) {
try {
this.currentTime = time;
this.setTime = Date.now();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
getCurrentTime() {
try {
return Date.now() - this.setTime + this.currentTime;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async sendUngotDividend() {
try {
await sendUngotDividend();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getAuctionPopUpShow() {
try {
return this.isAuctionPopUp;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async clearActivityObj() {
try {
clearActivityObj();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async setGuildActivityIndex(aid: number, index: number) {
try {
setGuildActivityIndexInPinus(aid, index);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async debugSendGateHp(serverId: number, cityId: number) {
try {
await debugSendGateHp(serverId, cityId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async debugAddHorse(serverId: number, guildCode: string, memberCnt: number, itemInterval: number) {
try {
await debugAddHorse(serverId, guildCode, memberCnt, itemInterval);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public saveGuildActivityIndexMemory() {
try {
return saveGuildActivityIndexMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public leaveRaceActivity(serverId: number, guildCode: string, roleId: string) {
try {
return leaveRaceActivity(serverId, guildCode, roleId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public leaveRaceWhenQuitGuild(serverId: number, guildCode: string, roleId: string) {
try {
return leaveRaceWhenQuitGuild(serverId, guildCode, roleId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public leaveRaceWhenDismiss(guildCode: string, serverId: number) {
try {
return leaveRaceWhenDismiss(guildCode, serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,240 +1,241 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { taflush, treatGuildName } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { errlogger } from '../../../util/logger';
import { setApiIsClose } from '../../../services/chatService';
import { setKvToMemory } from '../../../services/pushService';
import { getGVGConfig, setGVGConfig } from '../../../services/gvg/gvgService';
import { GVGConfigType } from '../../../db/GVGConfig';
import { catapultHurt, gvgBattleEnd, gvgBattleSeconds, gvgBattleStart, initCatapult, leaveCityMem } from '../../../services/gvg/gvgBattleService';
import { clearBattleMemory } from '../../../services/memoryCache/gvgBattleData';
import { updateLeagueNameMem, updateTeamRoleInfoMem } from '../../../services/gvg/gvgTeamService';
import { resetPeriodTime, setPeriodTime } from '../../../services/gvg/gvgFightService';
import { setServerGroup } from '../../../services/serverService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildRemote(app);
}
export class GuildRemote {
constructor(private app: Application) {
this.app = app;
}
/**
* 重载json资源
*/
public reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async treatGuildName(content: string) {
try {
await treatGuildName(content);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGVGConfig(config: GVGConfigType) {
try {
await setGVGConfig(config);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async getGVGConfig() {
try {
return getGVGConfig();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async gvgBattleStart() {
try {
return await gvgBattleStart();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async initCatapult(cityId: number, groupKey: string, leagueCode: string, leagueName: string) {
try {
return await initCatapult(cityId, groupKey, leagueCode, leagueName);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async catapultHurt() {
try {
return await catapultHurt();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async gvgBattleSeconds() {
try {
return await gvgBattleSeconds();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async gvgBattleEnd() {
try {
return await gvgBattleEnd();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async clearBattleMemory() {
try {
return clearBattleMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async leaveCityMem(groupKey: string, roleId: string) {
try {
return leaveCityMem(groupKey, roleId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async updateLeagueNameMem(serverId: number, leagueCode: string, leagueName: string) {
try {
return updateLeagueNameMem(serverId, leagueCode, leagueName);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async updateTeamRoleInfoMem(serverId: number, roleId: string, info: { roleName?: string, lv?: number }) {
try {
return updateTeamRoleInfoMem(serverId, roleId, info);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setPeriodTime(startFightTime: number, endFightTime: number) {
try {
return setPeriodTime(startFightTime, endFightTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public resetPeriodTime() {
try {
return resetPeriodTime();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '@pubUtils/data';
import { taflush, treatGuildName } from '../../../services/sdkService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { errlogger } from '../../../util/logger';
import { setApiIsClose } from '../../../services/chatService';
import { setKvToMemory } from '../../../services/pushService';
import { getGVGConfig, setGVGConfig } from '../../../services/gvg/gvgService';
import { GVGConfigType } from '@db/GVGConfig';
import { catapultHurt, gvgBattleEnd, gvgBattleSeconds, gvgBattleStart, initCatapult, leaveCityMem } from '../../../services/gvg/gvgBattleService';
import { clearBattleMemory } from '../../../services/memoryCache/gvgBattleData';
import { updateLeagueNameMem, updateTeamRoleInfoMem } from '../../../services/gvg/gvgTeamService';
import { resetPeriodTime, setPeriodTime } from '../../../services/gvg/gvgFightService';
import { setServerGroup } from '../../../services/serverService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new GuildRemote(app);
}
export class GuildRemote {
constructor(private app: Application) {
this.app = app;
}
/**
* 重载json资源
*/
public reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async treatGuildName(content: string) {
try {
await treatGuildName(content);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGVGConfig(config: GVGConfigType) {
try {
await setGVGConfig(config);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async getGVGConfig() {
try {
return getGVGConfig();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setServerGroup() {
try {
return setServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async gvgBattleStart() {
try {
return await gvgBattleStart();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async initCatapult(cityId: number, groupKey: string, leagueCode: string, leagueName: string) {
try {
return await initCatapult(cityId, groupKey, leagueCode, leagueName);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async catapultHurt() {
try {
return await catapultHurt();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async gvgBattleSeconds() {
try {
return await gvgBattleSeconds();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async gvgBattleEnd() {
try {
return await gvgBattleEnd();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async clearBattleMemory() {
try {
return clearBattleMemory();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async leaveCityMem(groupKey: string, roleId: string) {
try {
return leaveCityMem(groupKey, roleId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async updateLeagueNameMem(serverId: number, leagueCode: string, leagueName: string) {
try {
return updateLeagueNameMem(serverId, leagueCode, leagueName);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async updateTeamRoleInfoMem(serverId: number, roleId: string, info: { roleName?: string, lv?: number }) {
try {
return updateTeamRoleInfoMem(serverId, roleId, info);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setPeriodTime(startFightTime: number, endFightTime: number) {
try {
return setPeriodTime(startFightTime, endFightTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public resetPeriodTime() {
try {
return resetPeriodTime();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

View File

@@ -1,315 +1,316 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { ACTIVITY_TYPE, CURRENCY, DEBUG_MAGIC_WORD, DEBUG_PRICE, ITEM_CHANGE_REASON, ORDER_STATE, PAY_TYPE, STATUS, TASK_TYPE, TA_EVENT } from '../../../consts';
import { dicRMB } from '../../../pubUtils/dictionary/DicRMB';
import { UserOrderModel } from '../../../db/UserOrder';
import _ = require('underscore');
import { applyOrderWX } from '../../../services/pay/weixinPay';
import { applyOrderALI } from '../../../services/pay/aliPay';
import { applyOrder37 } from '../../../services/pay/37Pay';
import { checkOrderCanBuy, settleOrder, settleOrderAli, settleOrderFromHandler, settleOrderWx } from '../../../services/orderService';
import { getActivityById } from '../../../services/activity/activityService';
import { reportTAEvent } from '../../../services/sdkService';
import { canPay, isDebugPay } from '../../../pubUtils/sdkUtil';
import { isDevelopEnv } from '../../../services/utilService';
import { checkVoucherId, getVoucherCoinObject, getVoucherObject, handleCost } from '../../../services/role/rewardService';
import { CheckMeterial } from '../../../services/role/checkMaterial';
export default function (app: Application) {
new HandlerService(app, {});
return new orderHandler(app);
}
export class orderHandler {
constructor(private app: Application) {
}
/************************订单****************************/
/**
* @description 获取订单号
* @param {{productID:string, payType:number ,activityId: number, paramStr: string }} msg
* @param {BackendSession} session
* @memberof orderHandler
*/
async applyOrder(msg: { productID: string, payType: number, activityId: number, paramStr: string, useVoucher: number }, session: BackendSession) {
const { productID, payType, activityId, paramStr, useVoucher } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const ip = session.get('ip');
//如果有特殊情况activityId可为0
if (!productID || !_.isString(productID) || !_.isNumber(payType)) {
return resResult(STATUS.WRONG_PARMS);
}
if(!canPay()) {
return resResult(STATUS.PAY_NOT_OPEN)
}
//商品价格信息
let productInfo = dicRMB.get(productID)
if (!productInfo) {
console.log('productID', productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let price = productInfo.price;//价格
let productType = productInfo.type;//类型
let message = productInfo.message;//商品信息
let localOrderID = genCode(32);//本地订单号
let orderID = '';//平台订单号
let sdkOrderInfo = null;//客户端需要的平台订单信息
if(useVoucher) {
if(!checkVoucherId(useVoucher)) return resResult(STATUS.WRONG_PARMS);
let check = new CheckMeterial(roleId);
let isEnough = await check.decrease([{ id: useVoucher, count: price}]);
if (!isEnough) return resResult(STATUS.VOUCHER_NOT_ENOUGH);
} else {
switch (payType) {
case PAY_TYPE.THREE_SEVEN:
case PAY_TYPE.THREE_SEVEN_IOS:
{
let pay37Order = await applyOrder37(localOrderID, roleId, productInfo);
if (pay37Order.code == -1) {
console.log('37下单失败')
return pay37Order.resData;
}
sdkOrderInfo = pay37Order.data;
orderID = ''
break;
}
case PAY_TYPE.WX:
{
let weixinOrder = await applyOrderWX(localOrderID, price * 100, message);
if (weixinOrder.code == -1) {
console.log('微信下单失败')
return resResult(STATUS.APPLY_ORDER_ERROR);
}
sdkOrderInfo = weixinOrder.data;
orderID = weixinOrder.data.prepayid;//微信订单号
break;
}
case PAY_TYPE.ALI:
{
let aliOrder = await applyOrderALI(localOrderID, price, message);
if (aliOrder.code == -1) {
console.log('支付宝下单失败')
return resResult(STATUS.APPLY_ORDER_ERROR);
}
sdkOrderInfo = aliOrder.data;
orderID = aliOrder.data;//支付宝订单
break;
}
case PAY_TYPE.TEST:
{
if(!isDevelopEnv()) {
return resResult(STATUS.NO_PAY_TYPE);
}
break;
}
case PAY_TYPE.APPLE:
{
break;
}
default:
console.log('未知支付类型');
return resResult(STATUS.NO_PAY_TYPE);
}
}
if(activityId > 0) {
let activityData = await getActivityById(activityId);
let check = await checkOrderCanBuy(roleId, serverId, activityData, productID, paramStr);
if(!check) return resResult(STATUS.ORDER_CANNOT_BUY)
}
await UserOrderModel.applyOrder(serverId, roleId, productID, localOrderID, orderID, price, payType, activityId, paramStr, message, !!useVoucher, useVoucher);
reportTAEvent(roleId, TA_EVENT.RECHARGE, {
pay_id: localOrderID, chargeId: productID, pay_name: message, pay_amount: price, pay_channel: payType
}, ip)
if(isDebugPay()) {
productInfo = {...productInfo, price: DEBUG_PRICE}
}
return resResult(STATUS.SUCCESS, { orderInfo: sdkOrderInfo, productInfo: {
productID: productInfo.channelProductID,
message: productInfo.message,
price: productInfo.price,
}, localOrderID });
}
/**
* @description 查询订单,结算奖励
* @param {{ localOrderID: string}} msg
* @param {BackendSession} session
* @memberof firstGiftHandler
*/
async checkOrder(msg: { localOrderID: string }, session: BackendSession) {
const { localOrderID } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
if (!localOrderID || !_.isString(localOrderID)) {
return resResult(STATUS.WRONG_PARMS);
}
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo) {
return resResult(STATUS.NO_ORDER);
}
//商品价格信息
let productInfo = dicRMB.get(orderInfo.productID)
if (!productInfo) {
console.log(orderInfo.productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
if(orderInfo.useVoucher) {
let voucherId = orderInfo.voucherId;
let voucher = [{ id: voucherId, count: productInfo.price }];
if(orderInfo.state != ORDER_STATE.APPLY) {
return resResult(STATUS.DUPLICATE_ORDER);
}
if(orderInfo.roleId != roleId) {
console.log('订单玩家错误');
return resResult(STATUS.ORDER_STATUS_ERROR);
}
let result = await handleCost(roleId, sid, voucher, ITEM_CHANGE_REASON.USE_VOUCHER);
if(!result) return resResult(STATUS.VOUCHER_NOT_ENOUGH);
let res = await settleOrderFromHandler(localOrderID, roleId, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
} else {
switch (orderInfo.payType) {
case PAY_TYPE.TEST:
{
let res = await settleOrderFromHandler(localOrderID, roleId, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
break;
}
case PAY_TYPE.THREE_SEVEN:
case PAY_TYPE.THREE_SEVEN_IOS:
case PAY_TYPE.APPLE:
{
break;
}
case PAY_TYPE.WX:
{
let res = await settleOrderWx(orderInfo, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
break;
}
case PAY_TYPE.ALI:
{
let res = await settleOrderAli(orderInfo, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
break;
}
default:
console.log('未知支付类型');
return resResult(STATUS.NO_PAY_TYPE);
}
}
//订单成功
console.log('结算完成', localOrderID)
let res: any = {};
try {
res = orderInfo.rewardResult? JSON.parse(orderInfo.rewardResult): {};
} catch(e) {
console.log('order rewardResult', e);
}
if(res.code && res.code != 0) {
return resResult(STATUS.APPLY_ORDER_ERROR);
}
return resResult(STATUS.SUCCESS, {
...res,
price: orderInfo.price,
state: orderInfo.state,
localOrderID: orderInfo.localOrderID
});
}
/**
* @description 支付测试
* @param {{productID:string, magicWord:string, paramStr: string }} msg
* @param {BackendSession} session
* @memberof orderHandler
*/
async debugOrder(msg: { productID: string, magicWord: string, paramStr: string, activityId: number }, session: BackendSession) {
const { magicWord, productID, paramStr, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD || !activityId) {
return resResult(STATUS.WRONG_PARMS);
}
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let payType = PAY_TYPE.TEST
//如果有特殊情况activityId可为0
if (!productID || !_.isString(productID)) {
return resResult(STATUS.WRONG_PARMS);
}
//商品价格信息
let productInfo = dicRMB.get(productID)
if (!productInfo) {
console.log('productID', productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let price = productInfo.price;//价格
let productType = productInfo.type;//类型
let message = productInfo.message;//商品信息
let localOrderID = genCode(32);//本地订单号
let orderID = '';//平台订单号
let sdkOrderInfo = null;//客户端需要的平台订单信息
// let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
// let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(activityGroupId, productType, -1);
// if (activityArray.length === 0) {
// return resResult(STATUS.ACTIVITY_MISSING);
// }
let activityData = await getActivityById(activityId);
if (!activityData) return resResult(STATUS.ACTIVITY_MISSING);
let check = await checkOrderCanBuy(roleId, serverId, activityData, productID, paramStr);
if(!check) return resResult(STATUS.ORDER_CANNOT_BUY)
let orderInfo = await UserOrderModel.applyOrder(serverId, roleId, productID, localOrderID, orderID, price, payType, activityId, paramStr, message, false, 0);
//订单成功
if(!orderInfo) {
return resResult(STATUS.NO_ORDER);
}
let result = await settleOrder(orderInfo, serverId, sid);
orderInfo = await UserOrderModel.success(roleId, localOrderID, JSON.stringify(result));
console.log(`测试支付完成!!!!!!!!!!!!! serverId:${serverId}, productID:${productID}, productType:${productType}, roleId:${roleId}, localOrderID:${localOrderID}, payType:${payType}`)
return resResult(STATUS.SUCCESS, {...result, localOrderID});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '@pubUtils/util';
import { ACTIVITY_TYPE, CURRENCY, DEBUG_MAGIC_WORD, DEBUG_PRICE, ITEM_CHANGE_REASON, ORDER_STATE, PAY_TYPE, STATUS, TASK_TYPE, TA_EVENT } from '../../../consts';
import { dicRMB } from '@pubUtils/dictionary/DicRMB';
import { UserOrderModel } from '@db/UserOrder';
import _ = require('underscore');
import { applyOrderWX } from '../../../services/pay/weixinPay';
import { applyOrderALI } from '../../../services/pay/aliPay';
import { applyOrder37 } from '../../../services/pay/37Pay';
import { checkOrderCanBuy, settleOrder, settleOrderAli, settleOrderFromHandler, settleOrderWx } from '../../../services/orderService';
import { getActivityById } from '../../../services/activity/activityService';
import { reportTAEvent } from '../../../services/sdkService';
import { canPay, isDebugPay } from '@pubUtils/sdkUtil';
import { isDevelopEnv } from '../../../services/utilService';
import { checkVoucherId, getVoucherCoinObject, getVoucherObject, handleCost } from '../../../services/role/rewardService';
import { CheckMeterial } from '../../../services/role/checkMaterial';
export default function (app: Application) {
new HandlerService(app, {});
return new orderHandler(app);
}
export class orderHandler {
constructor(private app: Application) {
}
/************************订单****************************/
/**
* @description 获取订单号
* @param {{productID:string, payType:number ,activityId: number, paramStr: string }} msg
* @param {BackendSession} session
* @memberof orderHandler
*/
async applyOrder(msg: { productID: string, payType: number, activityId: number, paramStr: string, useVoucher: number }, session: BackendSession) {
const { productID, payType, activityId, paramStr, useVoucher } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const ip = session.get('ip');
//如果有特殊情况activityId可为0
if (!productID || !_.isString(productID) || !_.isNumber(payType)) {
return resResult(STATUS.WRONG_PARMS);
}
if(!canPay()) {
return resResult(STATUS.PAY_NOT_OPEN)
}
//商品价格信息
let productInfo = dicRMB.get(productID)
if (!productInfo) {
console.log('productID', productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let price = productInfo.price;//价格
let productType = productInfo.type;//类型
let message = productInfo.message;//商品信息
let localOrderID = genCode(32);//本地订单号
let orderID = '';//平台订单号
let sdkOrderInfo = null;//客户端需要的平台订单信息
if(useVoucher) {
if(!checkVoucherId(useVoucher)) return resResult(STATUS.WRONG_PARMS);
let check = new CheckMeterial(roleId);
let isEnough = await check.decrease([{ id: useVoucher, count: price}]);
if (!isEnough) return resResult(STATUS.VOUCHER_NOT_ENOUGH);
} else {
switch (payType) {
case PAY_TYPE.THREE_SEVEN:
case PAY_TYPE.THREE_SEVEN_IOS:
{
let pay37Order = await applyOrder37(localOrderID, roleId, productInfo);
if (pay37Order.code == -1) {
console.log('37下单失败')
return pay37Order.resData;
}
sdkOrderInfo = pay37Order.data;
orderID = ''
break;
}
case PAY_TYPE.WX:
{
let weixinOrder = await applyOrderWX(localOrderID, price * 100, message);
if (weixinOrder.code == -1) {
console.log('微信下单失败')
return resResult(STATUS.APPLY_ORDER_ERROR);
}
sdkOrderInfo = weixinOrder.data;
orderID = weixinOrder.data.prepayid;//微信订单号
break;
}
case PAY_TYPE.ALI:
{
let aliOrder = await applyOrderALI(localOrderID, price, message);
if (aliOrder.code == -1) {
console.log('支付宝下单失败')
return resResult(STATUS.APPLY_ORDER_ERROR);
}
sdkOrderInfo = aliOrder.data;
orderID = aliOrder.data;//支付宝订单
break;
}
case PAY_TYPE.TEST:
{
if(!isDevelopEnv()) {
return resResult(STATUS.NO_PAY_TYPE);
}
break;
}
case PAY_TYPE.APPLE:
{
break;
}
default:
console.log('未知支付类型');
return resResult(STATUS.NO_PAY_TYPE);
}
}
if(activityId > 0) {
let activityData = await getActivityById(activityId);
let check = await checkOrderCanBuy(roleId, serverId, activityData, productID, paramStr);
if(!check) return resResult(STATUS.ORDER_CANNOT_BUY)
}
await UserOrderModel.applyOrder(serverId, roleId, productID, localOrderID, orderID, price, payType, activityId, paramStr, message, !!useVoucher, useVoucher);
reportTAEvent(roleId, TA_EVENT.RECHARGE, {
pay_id: localOrderID, chargeId: productID, pay_name: message, pay_amount: price, pay_channel: payType
}, ip)
if(isDebugPay()) {
productInfo = {...productInfo, price: DEBUG_PRICE}
}
return resResult(STATUS.SUCCESS, { orderInfo: sdkOrderInfo, productInfo: {
productID: productInfo.channelProductID,
message: productInfo.message,
price: productInfo.price,
}, localOrderID });
}
/**
* @description 查询订单,结算奖励
* @param {{ localOrderID: string}} msg
* @param {BackendSession} session
* @memberof firstGiftHandler
*/
async checkOrder(msg: { localOrderID: string }, session: BackendSession) {
const { localOrderID } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
if (!localOrderID || !_.isString(localOrderID)) {
return resResult(STATUS.WRONG_PARMS);
}
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo) {
return resResult(STATUS.NO_ORDER);
}
//商品价格信息
let productInfo = dicRMB.get(orderInfo.productID)
if (!productInfo) {
console.log(orderInfo.productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
if(orderInfo.useVoucher) {
let voucherId = orderInfo.voucherId;
let voucher = [{ id: voucherId, count: productInfo.price }];
if(orderInfo.state != ORDER_STATE.APPLY) {
return resResult(STATUS.DUPLICATE_ORDER);
}
if(orderInfo.roleId != roleId) {
console.log('订单玩家错误');
return resResult(STATUS.ORDER_STATUS_ERROR);
}
let result = await handleCost(roleId, sid, voucher, ITEM_CHANGE_REASON.USE_VOUCHER);
if(!result) return resResult(STATUS.VOUCHER_NOT_ENOUGH);
let res = await settleOrderFromHandler(localOrderID, roleId, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
} else {
switch (orderInfo.payType) {
case PAY_TYPE.TEST:
{
let res = await settleOrderFromHandler(localOrderID, roleId, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
break;
}
case PAY_TYPE.THREE_SEVEN:
case PAY_TYPE.THREE_SEVEN_IOS:
case PAY_TYPE.APPLE:
{
break;
}
case PAY_TYPE.WX:
{
let res = await settleOrderWx(orderInfo, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
break;
}
case PAY_TYPE.ALI:
{
let res = await settleOrderAli(orderInfo, serverId, sid);
if(res.code != 0) {
return resResult(res);
}
orderInfo = await UserOrderModel.findOrder(localOrderID);
break;
}
default:
console.log('未知支付类型');
return resResult(STATUS.NO_PAY_TYPE);
}
}
//订单成功
console.log('结算完成', localOrderID)
let res: any = {};
try {
res = orderInfo.rewardResult? JSON.parse(orderInfo.rewardResult): {};
} catch(e) {
console.log('order rewardResult', e);
}
if(res.code && res.code != 0) {
return resResult(STATUS.APPLY_ORDER_ERROR);
}
return resResult(STATUS.SUCCESS, {
...res,
price: orderInfo.price,
state: orderInfo.state,
localOrderID: orderInfo.localOrderID
});
}
/**
* @description 支付测试
* @param {{productID:string, magicWord:string, paramStr: string }} msg
* @param {BackendSession} session
* @memberof orderHandler
*/
async debugOrder(msg: { productID: string, magicWord: string, paramStr: string, activityId: number }, session: BackendSession) {
const { magicWord, productID, paramStr, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD || !activityId) {
return resResult(STATUS.WRONG_PARMS);
}
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let payType = PAY_TYPE.TEST
//如果有特殊情况activityId可为0
if (!productID || !_.isString(productID)) {
return resResult(STATUS.WRONG_PARMS);
}
//商品价格信息
let productInfo = dicRMB.get(productID)
if (!productInfo) {
console.log('productID', productID)
return resResult(STATUS.NO_PRODUCT_ID);
}
let price = productInfo.price;//价格
let productType = productInfo.type;//类型
let message = productInfo.message;//商品信息
let localOrderID = genCode(32);//本地订单号
let orderID = '';//平台订单号
let sdkOrderInfo = null;//客户端需要的平台订单信息
// let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
// let activityArray: ActivityModelType[] = await ActivityModel.findActivityByType(activityGroupId, productType, -1);
// if (activityArray.length === 0) {
// return resResult(STATUS.ACTIVITY_MISSING);
// }
let activityData = await getActivityById(activityId);
if (!activityData) return resResult(STATUS.ACTIVITY_MISSING);
let check = await checkOrderCanBuy(roleId, serverId, activityData, productID, paramStr);
if(!check) return resResult(STATUS.ORDER_CANNOT_BUY)
let orderInfo = await UserOrderModel.applyOrder(serverId, roleId, productID, localOrderID, orderID, price, payType, activityId, paramStr, message, false, 0);
//订单成功
if(!orderInfo) {
return resResult(STATUS.NO_ORDER);
}
let result = await settleOrder(orderInfo, serverId, sid);
orderInfo = await UserOrderModel.success(roleId, localOrderID, JSON.stringify(result));
console.log(`测试支付完成!!!!!!!!!!!!! serverId:${serverId}, productID:${productID}, productType:${productType}, roleId:${roleId}, localOrderID:${localOrderID}, payType:${payType}`)
return resResult(STATUS.SUCCESS, {...result, localOrderID});
}
}

View File

@@ -1,133 +1,134 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '../../../pubUtils/data';
import { refundOrderFromRedisPub, settleOrderFromRedisPub } from '../../../services/orderService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { errlogger } from '../../../util/logger';
import { setApiIsClose } from '../../../services/chatService';
import { setKvToMemory } from '../../../services/pushService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '../../../pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new OrderRemote(app);
}
export class OrderRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async settleOrderFromRedisPub(message: string) {
try {
await settleOrderFromRedisPub(message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async refundOrderFromRedisPub(message: string) {
try {
await refundOrderFromRedisPub(message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}
import { Application, ChannelService, HandlerService, } from 'pinus';
import { gameData, reloadResources } from '@pubUtils/data';
import { refundOrderFromRedisPub, settleOrderFromRedisPub } from '../../../services/orderService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { errlogger } from '../../../util/logger';
import { setApiIsClose } from '../../../services/chatService';
import { setKvToMemory } from '../../../services/pushService';
import { setHiddenData } from '../../../services/memoryCache/hiddenData';
import * as dicParam from '@pubUtils/dicParam';
export default function (app: Application) {
new HandlerService(app, {});
return new OrderRemote(app);
}
export class OrderRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
}
private channelService: ChannelService;
/**
* 重载json资源
*/
public async reloadResources(type?: string) {
try {
reloadResources(type);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setDicParam(field1: string, field2: string, value: string|number) {
try {
if(dicParam[field1] && dicParam[field1][field2]) dicParam[field1][field2] = value;
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGameDataToApp() {
try {
this.app.set('gameData', gameData);
this.app.set('dicParam', dicParam);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async settleOrderFromRedisPub(message: string) {
try {
await settleOrderFromRedisPub(message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async refundOrderFromRedisPub(message: string) {
try {
await refundOrderFromRedisPub(message);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public setServerMainten(serverIds: number[], startTime: number, endTime: number, version: string) {
try {
setServerMainten(serverIds, startTime, endTime, version);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public stopServerMainten(serverIds: number[]) {
try {
stopServerMainten(serverIds);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getServerMainten(serverId: number) {
try {
return getServerMainten(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public taflush() {
try {
return taflush();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setApiIsClose(isClose: boolean) {
try {
setApiIsClose(isClose);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setHiddenData(heroes: number[], goods: number[], refTime: number) {
try {
setHiddenData(heroes, goods, refTime);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setKvToMemory(originK: string, originV: string, aesKey: string, aesIV: string, now: number) {
try {
setKvToMemory(originK, originV, aesKey, aesIV, now);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async fun() {
try {
console.log('预留一个函数,用于之后线上维护时需要使用');
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

Some files were not shown because too many files have changed in this diff Show More