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

✨ feat(军团): 练兵场添加扫荡

Browse Source
This commit is contained in:
luying
2023-06-17 16:57:12 +08:00
parent 5e28f4447d
commit be09636e85
7 changed files with 158 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
game-server/app/servers/guild/handler/guildTrainHandler.ts
View File

@@ -255,7 +255,7 @@ export class GuildTrainHandler {
await GuildTrainReportModel.pushGuildTrainReports(code, trainId, reports);//增加战报
let { trainCount, trainRewards } = userGuild;
let result: any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);//战斗后更新练兵场信息
let result: any = await getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);//战斗后更新练兵场信息
result.battleGoods = goods;
result.createdAt = time;
await addActive(roleId, serverId, GUILD_POINT_WAYS.TRAIN);
@@ -270,6 +270,119 @@ export class GuildTrainHandler {
throw e;
}
}
/**
* 练兵场扫荡
* @param msg
* @param session
*/
async trainBattleSweep(msg: guildInter & { hid: number, difficulty: number, trainId: number, battleId: number }, session: BackendSession) {
const { hid, difficulty, trainId, battleId, myUserGuild } = msg;
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
if (userGuild.trainCount - 1 < 0) {
return resResult(STATUS.WRONG_PARMS);
}
let hasPassed = await BattleRecordModel.getBattleRecordByIdAndStatus(roleId, battleId, 1);
if(!hasPassed) return resResult(STATUS.GUILD_TRAIN_CANNOT_SWEEP);
let { trainLv } = await GuildModel.findGuild(code, serverId, 'trainLv');
let maxTrainId = gameData.lastGuildTrainIdOfLv.get(trainLv);
let res: any = await lockData(serverId, DATA_NAME.TRAIN, code + '_' + trainId);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
if (!guildTrain) {
res.releaseCallback();//解锁
return resResult(STATUS.GUILD_TRAIN_SCRIPT_NOT_OPENED);
}
let trainInstance = findWhere(guildTrain.trainInstances, { hid });
if (!trainInstance) {
res.releaseCallback();//解锁
return resResult(STATUS.WRONG_PARMS);
}
let { trainInstances } = getArmyTrainJuDian(trainId);
let dicWar = gameData.war.get(battleId);
if(!dicWar) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let instance = findWhere(trainInstances, { hid });
if (!instance) {//校验是否存在该关卡
res.releaseCallback();//解锁
return resResult(STATUS.WRONG_PARMS);
}
userGuild = await UserGuildModel.updateInfo(roleId, {}, { trainCount: -1 });//扣除一次挑战次数
let score = dicWar.winReward.get(TRAIN_REWARD_TYPE.SCORE);
let item = dicWar.winReward.get(TRAIN_REWARD_TYPE.ITEM);
let addScore = Math.floor(<number>score);//个人获得积分，也是压制进度
//个人功勋奖励
let goods = await addItems(roleId, roleName, sid, <RewardInter[]>item, ITEM_CHANGE_REASON.TRAIN_BATTLE_END);
let { isComplete, ranks } = guildTrain;
let reports = [];
let needLockNext = false;
let report = { roleName, trainId, hid, score: addScore, time: nowSeconds(), type: 2, difficulty };//type 1：失败， 2：成功，3：表示系统战报即：被成功压制
reports.push(report);
if (trainInstance.progress < instance.progress) {
if (trainInstance.progress + addScore >= instance.progress) {
//压制成功
if (!isComplete) {
isComplete = true;
guildTrain.trainInstances.forEach(({ hid: otherHid, progress }) => {
if (hid != otherHid && progress != instance.progress) {
isComplete = false;
}
});
if (isComplete) { //解锁下一关
needLockNext = true;
}
}
let progress = instance.progress;
guildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, isComplete);
//type 1：失败， 2：成功，3：表示系统战报即：被成功压制
reports.push({ type: 3, time: nowSeconds(), score: addScore, roleName, trainId, hid, difficulty });
pushGuildTrainSucMsg(roleId, roleName, code, hid);
if (needLockNext && maxTrainId > trainId) {
guildTrain = await unlockTrain(code, trainId + 1);
}
res.releaseCallback();//解锁
} else {
//压制失败，更新排行榜进度等信息
let progress = trainInstance.progress + addScore;
guildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, isComplete);
res.releaseCallback();//解锁
}
} else {
// //玩家结算前已经完成进度，修改玩家的排名
// guildTrain = await GuildTrainModel.updateGuildTrain(code, trainId, { ranks });
res.releaseCallback();//解锁
}
await GuildTrainReportModel.pushGuildTrainReports(code, trainId, reports);//增加战报
let { trainCount, trainRewards } = userGuild;
let result: any = await getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);//战斗后更新练兵场信息
result.goods = goods;
await addActive(roleId, serverId, GUILD_POINT_WAYS.TRAIN);
// 任务
await checkTaskInGuildTrain(serverId, roleId, sid, battleId, true, isComplete);
return resResult(STATUS.SUCCESS, result);
}
/**
* 领取练兵场宝箱 hid：副本id，index:领取位置
* @param msg

6
game-server/app/services/checkParam.ts
View File

@@ -1260,6 +1260,12 @@ export function checkRouteParam(route: string, msg: any) {
if(!checkBoolean(isSuccess)) return false;
break;
}
case "guild.guildTrainHandler.trainBattleSweep":
{
let { hid, difficulty, trainId, battleId } = msg;
if(!checkNaturalNumbers(hid, difficulty, trainId, battleId)) return false;
break;
}
case "guild.guildTrainHandler.getTrainInstanceBox":
{
let { trainId, hid, index } = msg;

45
game-server/app/services/guildTrainService.ts
View File

@@ -1,7 +1,7 @@
import { UserGuildModel, UserGuildType } from '../db/UserGuild';
import { getArmyTrainJuDian, getGuildTrainGkInfo, getTrainBaseByLv } from '../pubUtils/data';
import { nowSeconds, getZeroPoint, isToday, getSeconds } from '../pubUtils/timeUtil';
import { GUILD_STRUCTURE, PUSH_ROUTE, SHOP_REFRESH_TYPE } from '../consts';
import { nowSeconds, getZeroPoint, isToday, getSeconds, getZeroPointD } from '../pubUtils/timeUtil';
import { GUILD_STRUCTURE, PUSH_ROUTE, SHOP_REFRESH_TYPE, WAR_TYPE } from '../consts';
import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain';
import { GuildModel, GuildType } from '../db/Guild';
import { findWhere } from 'underscore';
@@ -18,6 +18,7 @@ import { MAIL_TYPE } from '../consts';
import { getGuildChannelSid } from './chatChannelService';
import { sendMessageToGuildWithSuc } from './pushService';
import { gameData } from '../pubUtils/data';
import { BattleRecordModel } from '../db/BattleRecord';
/**
* 获得userGuild，并检查，是否需要每日重置购买挑战次数和今日挑战次数，已经检查是否需要每周重置练兵场
* @param roleId
@@ -125,25 +126,29 @@ export function getGuildTrainRewards (guildTrain) {
* @param trainCount
* @param trainRewards
*/
export function getGuildTrainInfo (guildTrain: GuildTrainType, roleId: string, trainCount:number, trainRewards: Array<number>) {
export async function getGuildTrainInfo (guildTrain: GuildTrainType, roleId: string, trainCount:number, trainRewards: Array<number>) {
let { trainId, isComplete, trainInstances, ranks } = guildTrain;
// ranks.sort(function(a, b) {
// return b.score - a.score;
// });
// let myRank = {};
// let resRanks = ranks.map(({roleId: rankRoleId, score}, index)=>{
// if (roleId == rankRoleId)
// myRank = {roleId: rankRoleId, score, rankLv: index+1};
// return {roleId: rankRoleId, score, rankLv: index+1};
// });
let { trainInstances: instances, trainLv } = getArmyTrainJuDian(trainId);
let { trainInstances: dicInstances, trainLv } = getArmyTrainJuDian(trainId);
let battleIds: number[] = [];
for(let { hid } of dicInstances) {
let trainInfo = getGuildTrainGkInfo(trainId, hid);
if(trainInfo) battleIds.push(...trainInfo.difficulty);
}
let battleRecords = await BattleRecordModel.findByBattleIds(roleId, battleIds, 1);
let resTrainInstances = trainInstances.map(({hid, progress, endTime})=>{
let instance = findWhere(instances, { hid });
let isComplete = false;
if ( progress >= instance.progress)
isComplete = true;
return {hid, progress, endTime, isComplete};
let dicInstance = dicInstances.find(cur => cur.hid == hid);
if(!dicInstance) return { hid, progress, endTime, isComplete: false, passedDifficult: [] }
let trainInfo = getGuildTrainGkInfo(trainId, hid);
let passedDifficult = trainInfo.difficulty.filter(warId => {
let battleRecord = battleRecords.find(record => record.battleId == warId);
return !!battleRecord;
})
let isComplete = progress >= dicInstance.progress;
return {hid, progress, endTime, isComplete, passedDifficult };
});
let resGuildTrain = {trainId, isComplete, trainInstances: resTrainInstances, myRank: 0, ranks: [] };
@@ -285,7 +290,7 @@ export async function getGuildTrainInstance(roleId: string, guild: GuildType, us
let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
if (!guildTrain) return null
let { trainCount, trainRewards, buyTrainCount } = userGuild;
let result: any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);
let result: any = await getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);
result.buyTrainCount = buyTrainCount || 0;
result.trainLv = trainLv;
return result;

1
shared/consts/constModules/guildConst.ts
View File

@@ -138,6 +138,7 @@ export const GUILD_ROUTE_OPERATE = [
{ route: 'guild.guildTrainHandler.getTrainBoxs', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
{ route: 'guild.guildTrainHandler.trainBattleStart', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
{ route: 'guild.guildTrainHandler.trainBattleEnd', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
{ route: 'guild.guildTrainHandler.trainBattleSweep', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
{ route: 'guild.guildTrainHandler.getTrainInstanceBox', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
{ route: 'guild.guildTrainHandler.getTrainLvUpRewards', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
{ route: 'guild.guildTrainHandler.purchaseTrainCount', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },

1
shared/consts/statusCode.ts
View File

@@ -262,6 +262,7 @@ export const STATUS = {
GUILD_SCRIPT_ENCOURGE_NOT_ENOUGH: { code: 20974, simStr: '鼓舞次数达到上限' },
GUILD_CANNOT_INVITE: { code: 20975, simStr: '该玩家已经加入军团或该玩家不同服' },
GUILD_REFINE_CNT_MAX: { code: 20976, simStr: '兑换此图纸品质达到上限' },
GUILD_TRAIN_CANNOT_SWEEP: { code: 20977, simStr: '练兵场未通过无法扫荡' },
GUILD_LOT_NOT_FOUND: { code: 21001, simStr: '拍品未找到' },
LOT_OFFER_SERIAL: { code: 21002, simStr: '不能连续出价' },

5
shared/db/BattleRecord.ts
View File

@@ -111,6 +111,11 @@ export default class BattleRecord extends BaseModel {
let result: BattleRecordType[] = await BattleRecordModel.find({ roleId, warType, status, createdAt: { $gte: beginTime, $lt: endTime } }).lean();
return result;
}
public static async findByBattleIds(roleId: string, battleIds: number[], status: number) {
let result: BattleRecordType[] = await BattleRecordModel.find({ roleId, battleId: { $in: battleIds }, status }).lean();
return result;
}
}
export const BattleRecordModel = getModelForClass(BattleRecord);

10
shared/pubUtils/dictionary/DicGuildTrainInfo.ts
View File

@@ -1,4 +1,4 @@
import { readFileAndParse, parseGoodStr } from '../util'
import { readFileAndParse, parseGoodStr, parseNumberList } from '../util'
import { FILENAME } from '../../consts'
type KeysEnum<T> = { [P in keyof Required<T>]: true };
import { RewardInter } from '../interface';
@@ -12,7 +12,7 @@ export interface DicGuildTrainInfo {
readonly trainLv: number; // 试炼场等级
readonly heroId: number;
readonly heroRewards: RewardInter[]; // 翻牌子的奖励，随机其中一个
readonly difficulty: number[]; // 难度
}
const DicGuildTrainInfoKeys: KeysEnum<DicGuildTrainInfo> = {
@@ -20,7 +20,8 @@ const DicGuildTrainInfoKeys: KeysEnum<DicGuildTrainInfo> = {
trainId: true,
trainLv: true,
heroId: true,
heroRewards: true
heroRewards: true,
difficulty: true,
};
export const dicGuildTrainInfo = new Map<string, DicGuildTrainInfo>();
@@ -31,7 +32,8 @@ export function loadGuildTrainInfo() {
arr.forEach(o => {
o.heroId = o.heroid;
o.heroRewards = parseGoodStr(o.shilianReward); // TODO 这个改到
o.heroRewards = parseGoodStr(o.shilianReward);
o.difficulty = parseNumberList(o.war_id);
dicGuildTrainInfo.set(`${o.trainId}_${o.heroId}`,_.pick(o, Object.keys(DicGuildTrainInfoKeys)));
});