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

练兵接口调整，新增获得宝箱和战报

Browse Source
This commit is contained in:
mamengke01
2021-01-28 20:07:08 +08:00
parent a54e5d6d2b
commit 54dde229d3
11 changed files with 327 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-server/app/servers/battle/handler/donateHandler.ts
+59
View File
@@ -0,0 +1,59 @@
import { Application, BackendSession } from 'pinus';
import { UserGuildModel } from '../../../db/UserGuild';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { DonationModel } from '../../../db/Donation';
import { nowSeconds } from '../../../pubUtils/timeUtil';
export default function(app: Application) {
return new DonationHandler(app);
}
export class DonationHandler {
constructor(private app: Application) {
}
async getDonation(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
let userGuild = await UserGuildModel.getMyGuild(roleId,'donateCnt receiveBoxs guildCode');
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, donateCnt, receiveBoxs } = userGuild;
let { donateFund, reports } = await DonationModel.getDonation(code);
return resResult(STATUS.SUCCESS, { receiveBoxs, donateFund, reports, donateCnt });
}
async donate(msg: {id: number}, session: BackendSession) {
const { id } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
let userGuild = await UserGuildModel.getMyGuild(roleId,'donateCnt receiveBoxs guildCode');
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, donateCnt: resdonateCnt } = userGuild;
if (resdonateCnt <= 0)
return resResult(STATUS.SUCCESS);
let { donateCnt } = await UserGuildModel.donateFund(roleId, 1);
let fund;//捐献TODO
let report = {id, roleName, time: nowSeconds()};
let { donateFund, reports } = await DonationModel.donation(code, fund, report);
return resResult(STATUS.SUCCESS, { donateFund, reports, donateCnt });
}
async receiveBox(msg: {id: number}, session: BackendSession) {
const { id } = msg;
const roleId: string = session.get('roleId');
let userGuild = await UserGuildModel.getMyGuild(roleId,'donateCnt receiveBoxs guildCode');
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code, donateCnt: resdonateCnt, receiveBoxs: resReceiveBoxs } = userGuild;
if (resReceiveBoxs.indexOf(id) != -1)
return resResult(STATUS.SUCCESS);
if (resdonateCnt <= 0)
return resResult(STATUS.SUCCESS);
resReceiveBoxs.push(id);
let { receiveBoxs } = await UserGuildModel.updateInfo(roleId, {receiveBoxs: resReceiveBoxs}, {}, 'receiveBoxs');
return resResult(STATUS.SUCCESS, { receiveBoxs });
}
}
game-server/app/servers/battle/handler/guildBossHandler.ts
+1
View File
@@ -83,6 +83,7 @@ export class GuildHandler {
return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
}
let bossBase = getBossByLv(curStructure.lv);
//消耗TODO
let {bossHp, warId, bossLevel } = getRandomByLen(bossBase.wars);
let resGuild = await GuildModel.costFund(code, bossBase.consume)
if (!resGuild)
game-server/app/servers/battle/handler/guildRefineHandler.ts
+10 -3
View File
@@ -15,6 +15,7 @@ import { checkAuth } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
import { openGuildRefine } from '../../../services/guildRefineService';
import { now } from 'moment';
export default function (app: Application) {
return new GuildRefineHandler(app);
}
@@ -85,17 +86,23 @@ export class GuildRefineHandler {
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let guildRefine = await GuildRefineModel.getRefine(code);
for (let scienceTree of guildRefine.scienceTrees) {
let nowTime = nowSeconds();
for (let scienceTree of guildRefine.scienceTrees) {
if (scienceTree.id == id)
return resResult(STATUS.GUILD_LIGHT_UP_THE_SCIENCETREE);
if (scienceTree.endTime > nowSeconds())
if (scienceTree.endTime > nowTime)
return resResult(STATUS.GUILD_SCIENCETREE_IS_RUNNING);
}
for (let prePosition of developConsume.prePositions) {
let scienceTree = findWhere(guildRefine.scienceTrees, {id: prePosition});
if (!scienceTree||scienceTree.endTime > nowTime)
return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);
}
const costResult = await GuildModel.costFund(code, developConsume.fundConsume);
if(!costResult)
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
let scienceTree = { id, endTime: nowSeconds() + developConsume.timeConsume, assistRoleIds: []}
let scienceTree = { id, endTime: nowTime + developConsume.timeConsume, assistRoleIds: []}
let { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
res.releaseCallback();
return resResult(STATUS.SUCCESS, { scienceTrees });
game-server/app/servers/battle/handler/guildTrainHandler.ts
+74 -38
View File
@@ -7,7 +7,7 @@ import { nowSeconds, getHourPoint, getCurHourPoint } from '../../../pubUtils/tim
import { getUserGuild, getGuildTrainInfo, unlockTrain, resetTrain, getGuildTrainRewards} from '../../../services/guildTrainService';
import { findIndex, findWhere, indexBy } from 'underscore'
import { lockData } from '../../../services/redLockService';
import { GUILD_DATA_NAME, REFRESH_HOUR } from '../../../consts/constModules/guildConst';
import { GUILD_DATA_NAME, REFRESH_HOUR, GUILD_REPORT_NUM } from '../../../consts/constModules/guildConst';
import { UserGuildModel } from '../../../db/UserGuild';
import { GuildModel } from '../../../db/Guild';
import { getArmyTrainJuDian, getTrainSoloReward, getTrainBaseByLv } from '../../../pubUtils/data';
@@ -15,7 +15,7 @@ import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/it
import { handleCost, addItems } from '../../../services/rewardService';
import { ARMY } from '../../../pubUtils/dicParam';
import { addActive } from '../../../services/guildService';
import { GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
import { GuildTrainReportModel } from '../../../db/GuildTrainReport';
export default function (app: Application) {
return new GuildTrainHandler(app);
}
@@ -34,22 +34,70 @@ export class GuildTrainHandler {
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let { trainId } = await GuildModel.findGuild(code, serverId, 'trainId');
let trainIds = [trainId];
if (trainId - 1 > 0) {
trainIds.push(trainId - 1);
}
let guildTrains = await GuildTrainModel.findGuildTrainByTrainIds(code, trainIds);
if (!guildTrains || !findWhere(guildTrains, {trainId})) {
let guildTrain = await unlockTrain(code, trainId);
if (!guildTrains) {
guildTrains.push(guildTrain);
}
let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
if (!guildTrain ) {
guildTrain = await unlockTrain(code, trainId);
}
let { trainCount, trainRewards, buyTrainCount } = userGuild;
let result:any = getGuildTrainInfo(guildTrains, roleId, trainCount, trainRewards, [trainId]);
let result:any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);
result.buyTrainCount = buyTrainCount;
return resResult(STATUS.SUCCESS, result);
}
//获得试炼战报
async getTrainReports(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await getUserGuild(roleId, serverId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let trainIds = [];
let { trainId } = await GuildModel.findGuild(code, serverId, 'trainId');
trainIds.push(trainId);
if (trainId > 1)
trainIds.push(trainId - 1);
let trainReports = await GuildTrainReportModel.findGuildTrainByTrainIds(code, trainIds);
let reports = [];
trainReports.map(({ reports: resReports, trainId: resTrainId})=>{
if (resTrainId != trainId) {
let lenNum = resReports.length;
resReports = resReports.splice(lenNum - GUILD_REPORT_NUM - 1, GUILD_REPORT_NUM);
}
reports.push(...resReports);
});
return resResult(STATUS.SUCCESS, {reports});
}
//获得试炼宝箱
async getTrainBoxs(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = parseInt(session.get('serverId'));
let userGuild = await getUserGuild(roleId, serverId);
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let guildTrains = await GuildTrainModel.findGuildTrain(code);
let resTrainBoxs = [];
let { trainId: curTrainId } = await GuildModel.findGuild(code, serverId, 'trainId');
guildTrains.forEach(({trainInstances, trainId}) =>{
let { trainInstances: instances } = getArmyTrainJuDian(trainId);
let flag = false;
let boxRewards = []
trainInstances.map(({hid, progress, endTime, trainBoxs})=>{
let instance = findWhere(instances, { hid });
let isComplete = false;
if ( progress >= instance.progress)
isComplete = true;
if (endTime > nowSeconds())
flag = true;
boxRewards.push({hid, recordBoxs: trainBoxs, trainId, endTime, isComplete});
});
if (flag || trainId == curTrainId) {
resTrainBoxs.push(...boxRewards);
}
})
return resResult(STATUS.SUCCESS, {trainBoxs: resTrainBoxs});
}
async trainBattleStart(msg: { hid: number, trainId: number, difficulty: number }, session: BackendSession) {
const { hid, difficulty, trainId } = msg;
@@ -141,10 +189,9 @@ export class GuildTrainHandler {
return resResult(STATUS.WRONG_PARMS);
let addScore = Math.floor((isSuccess?trainSoloReward.winScore:trainSoloReward.failScore) * (soloRewardRatio + 100 ) / 100);
let goods = await addItems(roleId, roleName, sid, [{id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.HONOUR), count: isSuccess?trainSoloReward.failHonour:trainSoloReward.failHonour}]);
let guildTrains = [];
let trainIds = [];
//是否压制
let { isComplete, reports, ranks } = guildTrain;
let { isComplete, ranks } = guildTrain;
let reports = [];
let index = findIndex(ranks, {roleId});
if (index !== -1) {
ranks[index].score += addScore;
@@ -152,11 +199,10 @@ export class GuildTrainHandler {
ranks.push({score: addScore, roleId});
}
let needLockNext = false;
let resGuildTrain;
let report = {roleId, trainId, hid, score: addScore, time: nowSeconds(), isSuccessed: isSuccess, type: 1};//1表示普通战报， 2表示系统战报即：被成功压制
let report = {roleName, trainId, hid, score: addScore, time: nowSeconds(), isSuccessed: isSuccess, type: 1};//1表示普通战报， 2表示系统战报即：被成功压制
reports.push(report);
if (trainInstance.progress < instance.progress ) {
if (trainInstance.progress + addScore >= instance.progress) {
reports.push(...[{isSuccessed: true, type: 2, time:nowSeconds(), score: addScore, roleId, trainId, hid},report]);
if (!isComplete) {
isComplete = true;
guildTrain.trainInstances.forEach(({hid: otherHid, progress})=>{
@@ -169,33 +215,24 @@ export class GuildTrainHandler {
}
}
let progress = instance.progress;
resGuildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
guildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, isComplete);
if (needLockNext) { //
let nextResGuildTrain = await unlockTrain(code, trainId + 1);
trainIds.push(nextResGuildTrain.trainId);
guildTrains.push(nextResGuildTrain);
reports.push({ isSuccessed: true, type: 2, time:nowSeconds(), score: addScore, roleName, trainId, hid });
guildTrain = await unlockTrain(code, trainId + 1);
}
res.releaseCallback();//解锁
} else {
let progress = trainInstance.progress + addScore;
resGuildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
guildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, isComplete);
res.releaseCallback();//解锁
}
} else {
reports.push(report);
resGuildTrain = await GuildTrainModel.updateGuildTrain(code, trainId, {reports, ranks});
guildTrain = await GuildTrainModel.updateGuildTrain(code, trainId, { ranks});
res.releaseCallback();//解锁
}
if (!needLockNext) {
if (trainId - 1 > 0 ) {
let lastGuildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId - 1);
guildTrains.push(lastGuildTrain);
}
trainIds.push(resGuildTrain.trainId);
}
guildTrains.push(resGuildTrain);
await GuildTrainReportModel.pushGuildTrainReports(code, trainId, reports);
let { trainCount, trainRewards } = userGuild;
let result:any = getGuildTrainInfo(guildTrains, roleId, trainCount, trainRewards, trainIds);
let result:any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);
result.battleGoods = goods;
await addActive(roleId, serverId, 2, 1);
return resResult(STATUS.SUCCESS, result);
@@ -211,13 +248,12 @@ export class GuildTrainHandler {
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let { structure } = await GuildModel.findGuild(code, serverId, 'structure');
let stru = findWhere(structure, {id: 4});
let { trainLv } = await GuildModel.findGuild(code, serverId, 'structure');
let res:any = await lockData(serverId, GUILD_DATA_NAME.TRAIN_BOX, code + '_' + trainId);//加锁
if (!!res.err)
return resResult(STATUS.REDLOCK_ERR);
let { shilianRewardRatio } = getTrainBaseByLv(GUILD_STRUCTURE.TRAIN);
let { shilianRewardRatio } = getTrainBaseByLv(trainLv);
let { heroRewards, trainInstances } = getArmyTrainJuDian(trainId);
let { progress } = findWhere(trainInstances, {hid});
let guildTrain = await GuildTrainModel.findTrainInstanceBoxByIndex(code, roleId, trainId, hid, index, progress, nowSeconds());
game-server/app/services/guildTrainService.ts
+29 -50
View File
@@ -12,7 +12,7 @@ import { MailModel, MailType } from '../db/Mail';
import { getRandomByLen, resResult } from '../pubUtils/util';
import { getRedis } from './redisService';
import { STATUS } from '../consts/statusCode';
import { GuildTrainReportModel } from '../db/GuildTrainReport'
export async function getUserGuild(roleId: string, serverId: number) {
let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards guildCode');
if (!userGuild)
@@ -57,57 +57,32 @@ export function getGuildTrainRewards (guildTrain) {
isComplete = true;
return {hid, recordBoxs: trainBoxs, trainId: guildTrain.trainId, endTime, isComplete};
})
return { trainBoxs};
return { trainBoxs };
}
export function getGuildTrainInfo (guildTrains: Array<GuildTrainType>, roleId: string, trainCount:number, trainRewards: Array<number>, trainIds:Array<number>) {
let guildTrain;
guildTrains.map(({trainId, isComplete, trainInstances, ranks, reports})=>{
if (trainIds.indexOf(trainId) == -1) {
return;
}
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 } = getArmyTrainJuDian(trainId);
let resTrainBoxs = [];
let resTrainInstances = trainInstances.map(({hid, progress, endTime, trainBoxs})=>{
let instance = findWhere(instances, { hid });
let isComplete = false;
if ( progress >= instance.progress)
isComplete = true;
resTrainBoxs.push({hid, recordBoxs: trainBoxs, trainId, endTime, isComplete});
return {hid, progress, endTime, isComplete};
})
let lastGuildTrain = findWhere(guildTrains, { trainId: trainId - 1});
if (!!lastGuildTrain) {
let lenNum = lastGuildTrain.reports.length;
if (lenNum < GUILD_REPORT_NUM)
reports = [...lastGuildTrain.reports, ...reports];
else {
let trainReports = lastGuildTrain.reports.splice(lenNum - GUILD_REPORT_NUM - 1, GUILD_REPORT_NUM);
reports = [...trainReports, ...reports];
}
let flag = false;
let lastTrainBoxs = lastGuildTrain.trainInstances.map(({hid, endTime, trainBoxs}) => {
if (endTime < nowSeconds()) {
flag = true;
}
return {hid, recordBoxs: trainBoxs, trainId: lastGuildTrain.trainId, endTime, isComplete: true};
});
if (flag) {
resTrainBoxs.push(...lastTrainBoxs);
}
}
guildTrain = {trainId, isComplete, trainInstances: resTrainInstances, trainBoxs: resTrainBoxs, reports, myRank, ranks: resRanks};
export 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;
});
return { guildTrain, trainCount, trainRewards};
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 } = getArmyTrainJuDian(trainId);
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 resGuildTrain = {trainId, isComplete, trainInstances: resTrainInstances, myRank, ranks: resRanks};
return { guildTrain: resGuildTrain, trainCount, trainRewards};
}
export async function unlockTrain(code: string, trainId: number) {
@@ -127,6 +102,7 @@ export async function unlockTrain(code: string, trainId: number) {
return t;
});
guildTrain = await GuildTrainModel.openGuildTrain(code, trainId, instances);
await GuildTrainReportModel.resetGuildTrainReport(code, trainId);
await GuildModel.updateInfo(code, {trainId}, {});
return guildTrain;
@@ -136,7 +112,9 @@ export async function resetTrain(code: string, serverId: number) {
let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD, code);//加锁
if (!!res.err)
return;
let guild = await GuildModel.resetGuildTrain(code, serverId);
let { structure } = await GuildModel.findGuild(code, serverId, 'structure');
let { lv } = findWhere(structure, {id: GUILD_STRUCTURE.TRAIN});
let guild = await GuildModel.resetGuildTrain(code, serverId, lv);
if (!guild) {
res.releaseCallback();//解锁
return;
@@ -161,6 +139,7 @@ export async function resetTrain(code: string, serverId: number) {
}
})
});
for (let trainId = 1; trainId < guild.trainId; trainId++) {
let { jinjieReward } = getArmyTrainJuDian(trainId);
if (trainRewards.indexOf(trainId)) {