240 lines
12 KiB
TypeScript
240 lines
12 KiB
TypeScript
import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
|
|
import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
|
|
import { STATUS, TASK_TYPE } from '../../../consts';
|
|
import { BossInstanceModel } from '../../../db/BossInstance';
|
|
import { BattleRecordModel } from '../../../db/BattleRecord';
|
|
import { nowSeconds, getZeroPoint } from '../../../pubUtils/timeUtil';
|
|
import { getBossInstanceInfo, checkBossResult, checkBossBattleMemberExists, pushBossHpMessage, addBossInstance, refreshUserGuildOfBoss, refreshGuildOfBoss } 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 } 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/taskService';
|
|
import { guildInter } from '../../../pubUtils/interface';
|
|
import { addItems, handleCost } from '../../../services/rewardService';
|
|
import * as dicParam from '../../../pubUtils/dicParam';
|
|
import { getGoldObject } from '../../../pubUtils/itemUtils';
|
|
import { RoleModel } from '../../../db/Role';
|
|
|
|
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) {
|
|
const roleId: string = session.get('roleId');
|
|
let { myUserGuild: userGuild } = msg;
|
|
const { guildCode: code } = userGuild;
|
|
let result = await getBossInstanceInfo(code, roleId, 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, 'lv structure');
|
|
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 { bossHp, warId } = getRandSingleEelm(bossBase.wars);
|
|
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);
|
|
}
|
|
leaderOpenCnt = (await refreshGuildOfBoss(guild, 1)).leaderOpenCnt;
|
|
let { myChallengeCnt } = await refreshUserGuildOfBoss(userGuild);
|
|
|
|
await BossInstanceModel.openBossInstance(code, bossHp, warId, bossBase.bossLevel);
|
|
res.releaseCallback();
|
|
let result = { warId, ranks: [], myRank: {}, bossHp, status: 3, bossLv: bossBase.bossLevel, leaderOpenCnt };
|
|
|
|
let chatSid = await getGuildChannelSid(code);
|
|
pinus.app.rpc.chat.guildRemote.pushBossOpen.toServer(chatSid, code, warId, bossHp, result.status);
|
|
|
|
return resResult(STATUS.SUCCESS, {...result, leaderOpenCnt, myChallengeCnt});
|
|
}
|
|
|
|
async battleBoss(msg: guildInter & {}, session: BackendSession) {
|
|
const roleId: string = session.get('roleId');
|
|
const roleName: string = session.get('roleName');
|
|
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 myRank = findWhere(bossInstance.ranks, { roleId });
|
|
if (!!myRank && myRank.time > getZeroPoint())
|
|
return resResult(STATUS.GUILD_SCRIPT_IS_BATTLED);
|
|
|
|
let { code: bossCode, warId, ranks, bossHp } = bossInstance;
|
|
const battleCode = genCode(8); // 关卡唯一值
|
|
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
|
|
$set: {
|
|
roleId, roleName, battleId: warId,
|
|
status: 0,
|
|
record: { heroes: [], bossInstanceCode: bossCode, bossHp: bossHp },
|
|
}
|
|
}, 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 } = await refreshUserGuildOfBoss(userGuild, 0, 1);
|
|
return resResult(STATUS.SUCCESS, { battleCode, bossCode: bossInstance.code, myChallengeCnt });
|
|
}
|
|
|
|
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'));
|
|
const { guildCode } = userGuild;
|
|
let flag = await checkBossBattleMemberExists(guildCode, serverId, roleId, battleCode);
|
|
if (!flag) {
|
|
return resResult(STATUS.REDLOCK_ERR);
|
|
}
|
|
//记录伤害
|
|
let bossInstance = await BossInstanceModel.updateBossHp(bossCode, damage, roleId);
|
|
await BattleRecordModel.incBossDamage(battleCode, damage, bossInstance?.bossHp);
|
|
if (!bossInstance || bossInstance.bossHp == 0) {//进入结算
|
|
let flag = await checkBossResult(bossCode, guildCode, serverId, DATA_NAME.BOSS_SCRIPT, roleId, damage);
|
|
if (!flag) {
|
|
return resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
pushGuildBossSucMsg(roleId, roleName, guildCode, bossInstance);
|
|
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 }, session: BackendSession) {
|
|
const { battleCode, myUserGuild: userGuild, bossCode } = msg;
|
|
const roleId = session.get('roleId');
|
|
const roleName = session.get('roleName');
|
|
const sid = session.get('sid');
|
|
|
|
const serverId: number = parseInt(session.get('serverId'));
|
|
const { guildCode } = userGuild;
|
|
let bossInstance = await BossInstanceModel.findByCode(bossCode);
|
|
if(!bossInstance) return resResult(STATUS.WRONG_PARMS);
|
|
|
|
let battleRecord = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
|
|
$set: { status: 1 }//战斗结束统一设置成1
|
|
}, true);
|
|
|
|
let { bossDamage } = battleRecord.record; // 伤害奖励
|
|
let dicBossBase = gameData.bossBaseByBossLv.get(bossInstance.bossLv);
|
|
let reward = dicBossBase.damageReward.map(({id, count}) => {
|
|
return { id, count: Math.floor(count * bossDamage * dicBossBase.ratio / 1000 ) }
|
|
});
|
|
let battleGoods = await addItems(roleId, roleName, sid, reward);
|
|
|
|
await addActive(roleId, serverId, GUILD_POINT_WAYS.BOSS_WAR);//获得活跃值
|
|
// 任务
|
|
await checkTask(roleId, sid, TASK_TYPE.GUILD_BOSS, 1, true, {});
|
|
|
|
let result = await getBossInstanceInfo(guildCode, roleId, userGuild);
|
|
|
|
return resResult(STATUS.SUCCESS, { ...result, battleGoods });
|
|
}
|
|
|
|
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');
|
|
if(!count || count < 0) return resResult(STATUS.WRONG_PARMS);
|
|
|
|
let bossInstance = await BossInstanceModel.findBossInstance(userGuild.guildCode);
|
|
if(!bossInstance) return resResult(STATUS.GUILD_SCRIPT_NOT_OPENED);
|
|
|
|
let { myEncourageCnt } = await refreshUserGuildOfBoss(userGuild);
|
|
let costGold = (myEncourageCnt + count - dicParam.GUILD_BOSS.GUILD_BOSS_ENCOURAGE_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]);
|
|
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
|
|
}
|
|
let chatSid = await getGuildChannelSid(code);
|
|
pinus.app.rpc.chat.guildRemote.pushEncourage.toServer(chatSid, code, result);
|
|
return resResult(STATUS.SUCCESS, result);
|
|
|
|
}
|
|
|
|
async debugAddBattleTimes(msg: {}, session: BackendSession) {
|
|
const roleId: string = session.get('roleId');
|
|
let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
|
|
if (!userGuild)
|
|
return resResult(STATUS.WRONG_PARMS);
|
|
const { guildCode: code } = userGuild;
|
|
let { ranks } = await BossInstanceModel.findBossInstance(code);
|
|
for (let i = 0; i < ranks.length; i++) {
|
|
let rank = ranks[i];
|
|
if (rank.roleId == roleId) {
|
|
rank.time = 0;
|
|
break;
|
|
}
|
|
}
|
|
let { ranks: resRanks } = await BossInstanceModel.updateBossInstance(code, { ranks });
|
|
return resResult(STATUS.SUCCESS, { ranks: resRanks });
|
|
}
|
|
} |