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