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

炼器堂，练兵场，事件开启，redlock注释

Browse Source
This commit is contained in:
mamengke01
2021-02-24 15:13:46 +08:00
parent dd995e67eb
commit 0e933d1ec4
14 changed files with 157 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
game-server/app/servers/battle/handler/guildRefineHandler.ts
View File

@@ -23,7 +23,11 @@ export class GuildRefineHandler {
constructor(private app: Application) {
}
/**
* 获得科技树信息
* @param msg
* @param session
*/
async getRefine(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
@@ -36,7 +40,11 @@ export class GuildRefineHandler {
}
return resResult(STATUS.SUCCESS, { scienceTrees: guildRefine.scienceTrees });
}
/**
* 炼器
* @param msg
* @param session
*/
async refineEquip(msg: {pid: number}, session: BackendSession) {
let { pid } = msg;
const roleId: string = session.get('roleId');
@@ -50,6 +58,7 @@ export class GuildRefineHandler {
let { scienceTrees } = await GuildRefineModel.getRefine(code);
let findDevelopConsume;
//判断是否可以炼该兵器
for (let scienceTree of scienceTrees) {
if (scienceTree.endTime < nowSeconds()) {
let developConsume = getArmyDevelopConsumeById(scienceTree.id);
@@ -67,7 +76,11 @@ export class GuildRefineHandler {
let goods = await addItems(roleId, roleName, sid, [{id: pid, count: 1}]);
return resResult(STATUS.SUCCESS, { goods });
}
/**
* 点亮科技树
* @param msg
* @param session
*/
async lightUpTree(msg: {id: number}, session: BackendSession) {
let { id } = msg;
const roleId: string = session.get('roleId');
@@ -87,23 +100,25 @@ export class GuildRefineHandler {
let guildRefine = await GuildRefineModel.getRefine(code);
let nowTime = nowSeconds();
for (let scienceTree of guildRefine.scienceTrees) {
if (scienceTree.id == id) {
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);
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) {
res.releaseCallback();
return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);
return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);//前置科技树未点亮
}
}
//点亮消耗
const costResult = await GuildModel.costFund(code, developConsume.fundConsume);
if(!costResult) {
res.releaseCallback();
@@ -114,7 +129,11 @@ export class GuildRefineHandler {
res.releaseCallback();
return resResult(STATUS.SUCCESS, { scienceTrees });
}
/**
* 协助点亮科技树
* @param msg
* @param session
*/
async assistRefine(msg: {id: number}, session: BackendSession) {
let { id } = msg;
const roleId: string = session.get('roleId');
@@ -137,11 +156,11 @@ export class GuildRefineHandler {
let scienceTree = guildRefine.scienceTrees[index];
if (scienceTree.assistRoleIds.indexOf(roleId) != -1) {
res.releaseCallback();
return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE);
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);
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}]);
if (!result) {

59
game-server/app/servers/battle/handler/guildTrainHandler.ts
View File

@@ -64,7 +64,7 @@ export class GuildTrainHandler {
trainReports.map(({ reports: resReports, trainId: resTrainId})=>{
if (resTrainId != trainId) {
let lenNum = resReports.length;
resReports = resReports.splice(lenNum - GUILD_REPORT_NUM - 1, GUILD_REPORT_NUM);
resReports = resReports.splice(lenNum - GUILD_REPORT_NUM - 1, GUILD_REPORT_NUM);//获得上场的战报的信息与本次战报合并
}
reports.push(...resReports);
});
@@ -79,7 +79,7 @@ export class GuildTrainHandler {
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { guildCode: code } = userGuild;
let guildTrains = await GuildTrainModel.findGuildTrain(code);
let guildTrains = await GuildTrainModel.findGuildTrain(code);//获得未失效的宝箱奖励
let resTrainBoxs = [];
guildTrains.forEach(({trainInstances, trainId}) =>{
let { trainInstances: instances } = getArmyTrainJuDian(trainId);
@@ -101,7 +101,11 @@ export class GuildTrainHandler {
})
return resResult(STATUS.SUCCESS, {trainBoxRewards: resTrainBoxs});
}
/**
* 挑战练兵副本
* @param msg
* @param session
*/
async trainBattleStart(msg: { hid: number, trainId: number, difficulty: number }, session: BackendSession) {
const { hid, difficulty, trainId } = msg;
const roleId = session.get('roleId');
@@ -139,7 +143,11 @@ export class GuildTrainHandler {
}, true);
return resResult(STATUS.SUCCESS, { battleCode });
}
/**
* 战斗结算
* @param msg
* @param session
*/
async trainBattleEnd(msg: { battleCode: string, isSuccess: boolean}, session: BackendSession) {
const { battleCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
@@ -160,14 +168,14 @@ export class GuildTrainHandler {
}
if (time < getCurHourPoint(REFRESH_HOUR) && nowSeconds() > getCurHourPoint(REFRESH_HOUR)) {
return resResult(STATUS.GUILD_TRAIN_IS_RESETED);//关卡已经重置
return resResult(STATUS.GUILD_TRAIN_IS_RESETED);//重置前进入战斗，重置后回调该接口
}
if (time > getHourPoint(REFRESH_HOUR)) {
userGuild = await UserGuildModel.updateInfo(roleId, {}, { trainCount: -1 });
userGuild = await UserGuildModel.updateInfo(roleId, {}, { trainCount: -1 });//扣除一次挑战次数
}
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess?1:2 }
}, true);
}, true);//设置战斗状态
let trainId = battleRecord.record.trainId;
let hid = battleRecord.record.hid;
@@ -187,31 +195,32 @@ export class GuildTrainHandler {
let { trainInstances, soloRewardRatio } = getArmyTrainJuDian(trainId);
let instance = findWhere(trainInstances, { hid });
if (!instance) {
if (!instance) {//校验是否存在该关卡
res.releaseCallback();//解锁
return resResult(STATUS.WRONG_PARMS);
}
let trainSoloReward = getTrainSoloReward(battleRecord.record.difficulty);
if (!trainSoloReward) {
if (!trainSoloReward) {//获得个人奖励信息
res.releaseCallback();//解锁
return resResult(STATUS.WRONG_PARMS);
}
let addScore = Math.floor((isSuccess?trainSoloReward.winScore:trainSoloReward.failScore));
let addScore = Math.floor((isSuccess?trainSoloReward.winScore:trainSoloReward.failScore));//个人获得积分，也是压制进度
//个人功勋奖励
let goods = await addItems(roleId, roleName, sid, [{id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.HONOUR), count: (isSuccess?trainSoloReward.failHonour:trainSoloReward.failHonour) * (soloRewardRatio + 100 ) / 100}]);
//是否压制
let { isComplete, ranks } = guildTrain;
let reports = [];
let index = findIndex(ranks, {roleId});
if (index !== -1) {
ranks[index].score += addScore;
ranks[index].score += addScore;//更新原有的排名信息
} else {
ranks.push({score: addScore, roleId});
ranks.push({score: addScore, roleId});//新增排名
}
let needLockNext = false;
let report = {roleName, trainId, hid, score: addScore, time: nowSeconds(), type: isSuccess?2:1, difficulty: battleRecord.record.difficulty};//1表示普通战报， 2表示系统战报即：被成功压制
let report = {roleName, trainId, hid, score: addScore, time: nowSeconds(), type: isSuccess?2:1, difficulty: battleRecord.record.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})=>{
@@ -225,28 +234,35 @@ export class GuildTrainHandler {
}
let progress = instance.progress;
guildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, isComplete);
if (needLockNext) { //
if (needLockNext) {
//type 1：失败， 2：成功，3：表示系统战报即：被成功压制
reports.push({ type: 3, time:nowSeconds(), score: addScore, roleName, trainId, hid, difficulty: battleRecord.record.difficulty });
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);
await GuildTrainReportModel.pushGuildTrainReports(code, trainId, reports);//增加战报
let { trainCount, trainRewards } = userGuild;
let result:any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);
let result:any = getGuildTrainInfo(guildTrain, roleId, trainCount, trainRewards);//战斗后更新练兵场信息
result.battleGoods = goods;
await addActive(roleId, serverId, GUILD_POINT_WAYS.TRAIN);
return resResult(STATUS.SUCCESS, result);
}
/**
* 领取练兵场宝箱 hid：副本id，index:领取位置
* @param msg
* @param session
*/
async getTrainInstanceBox(msg: { trainId: number , hid: number, index: number}, session: BackendSession) {
let { trainId, hid, index } = msg;
const roleId: string = session.get('roleId');
@@ -273,6 +289,7 @@ export class GuildTrainHandler {
}
let trainInstance = findWhere(guildTrain.trainInstances, { hid });
if (trainInstance.endTime < nowSeconds()) {
//宝箱失效
res.releaseCallback();//解锁
return resResult(STATUS.GUILD_TRAIN_BOX_IS_OVER_TIME);
}
@@ -301,7 +318,11 @@ export class GuildTrainHandler {
result.goods = goods;
return resResult(STATUS.SUCCESS, result);
}
/**
* 领取练兵试炼等级奖励
* @param msg
* @param session
*/
async getTrainLvUpRewards(msg: {trainId: number }, session: BackendSession) {
let { trainId } = msg;
const roleId: string = session.get('roleId');

4
game-server/app/servers/role/handler/mailHandler.ts
View File

@@ -107,9 +107,9 @@ export class MailHandler {
let mailRewards = await MailModel.findRewardsMails(roleId);
let { mailGoods: goods, mailIds, groupMailIds} = await this.app.rpc.gm.gmRemote.getUseMails.toServer('gm-server-1', serverId, groupMailRewards, mailRewards);
mailGoods = goods;
if (!!groupMailIds.length)
if (!!groupMailIds.length) //领取群体邮件
mails = await GroupMailModel.updateMailStatus(groupMailIds, MAIL_STATUS.RECEIVED, roleId);
if (!!mailIds.length)
if (!!mailIds.length) //领取单个邮件
mails = await MailModel.updateMailStatus(mailIds, MAIL_STATUS.RECEIVED);
}
let resGoods = [];

15
game-server/app/services/funcSwitchService.ts
View File

@@ -1,10 +1,9 @@
import { BackendSession, FrontendSession, pinus } from "pinus";
import { getGamedata } from "../pubUtils/gamedata";
import { RoleModel } from "../db/Role";
import { resResult } from "../pubUtils/util";
import { STATUS, FUNC_OPT_TYPE } from "../consts";
import { eventOnPlayerLvUp } from '../services/playerEventService';
import { checkesetTrain } from '../services/guildTrainService';
import { checkResetTrain } from '../services/guildTrainService';
import { getUserGuildWithRefActive } from '../services/guildService';
// 开启功能
export async function switchOnFunc(roleId: string, type: number, param: number, session: (BackendSession|FrontendSession)) {
@@ -14,10 +13,10 @@ export async function switchOnFunc(roleId: string, type: number, param: number,
let addFuncs = new Array<number>();
switch (type) {
case FUNC_OPT_TYPE.LEVEL_UP:
case FUNC_OPT_TYPE.LEVEL_UP://等级提升，触发事件
await eventOnPlayerLvUp(roleId, param, addFuncs, dataFuncs);
break;
case FUNC_OPT_TYPE.BATTLE_END:
case FUNC_OPT_TYPE.BATTLE_END://战斗结束，触发事件
//开启奇遇
break;
}
@@ -32,9 +31,13 @@ export async function switchOnFunc(roleId: string, type: number, param: number,
return recs;
}
}
/**
* 登录检查刷新
* @param role
* @param session
*/
export async function chackFunOpenWhenLogin(role: any, session: BackendSession|FrontendSession) {
await switchOnFunc(role.roleId, FUNC_OPT_TYPE.LEVEL_UP, role.lv, session);
await checkesetTrain(role.roleId, role.serverId);
await checkResetTrain(role.roleId, role.serverId);
await getUserGuildWithRefActive(role.roleId, '', true)
}

5
game-server/app/services/guildRefineService.ts
View File

@@ -1,10 +1,15 @@
import { getArmyDevelopConsume } from '../pubUtils/data';
import { ScienceTree, GuildRefineModel } from '../db/GuildRefine';
/**
* 开启符合条件的科技树
* @param code
*/
export async function openGuildRefine(code: string) {
let developConsumes = getArmyDevelopConsume();
let scienceTrees = new Array<ScienceTree>();
developConsumes.forEach(developConsume=>{
if (developConsume.fundConsume == 0 && developConsume.timeConsume == 0) {
//无前置条件，无研发时间的科技树直接可以点亮
let scienceTree = new ScienceTree();
scienceTree.id = developConsume.id;
scienceTree.endTime = 0

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

@@ -1,7 +1,7 @@
import { UserGuildModel } from '../db/UserGuild';
import { getArmyTrainJuDian, getTrainBaseByLv } from '../pubUtils/data';
import { nowSeconds, getHourPoint } from '../pubUtils/timeUtil';
import { GUILD_REPORT_NUM, REFRESH_HOUR, GUILD_STRUCTURE } from '../consts/constModules/guildConst';
import { REFRESH_HOUR, GUILD_STRUCTURE } from '../consts/constModules/guildConst';
import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain';
import { GuildModel } from '../db/Guild';
import { findWhere } from 'underscore';
@@ -10,20 +10,23 @@ import { lockData } from './redLockService';
import { pinus } from 'pinus';
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';
import { DATA_NAME } from '../consts/dataName';
import { getMailContent } from './mailService';
import { MAIL_TYPE } from '../consts';
/**
* 获得userGuild，并检查，是否需要每日重置购买挑战次数和今日挑战次数，已经检查是否需要每周重置练兵场
* @param roleId
* @param serverId
*/
export async function getUserGuild(roleId: string, serverId: number) {
let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards guildCode buyTrainCount');
if (!userGuild)
return;
let { trainCount, trainTime, buyTrainCount, guildCode} = userGuild;
await resetTrain(guildCode, serverId);
if (trainTime < getHourPoint(REFRESH_HOUR)) {
await resetTrain(guildCode, serverId);//检查重置练兵场
if (trainTime < getHourPoint(REFRESH_HOUR)) {//重置挑战次数和购买次数
trainCount = ARMY.ARMY_TRAIN_BUYTIMES;
buyTrainCount = 0;
userGuild = await UserGuildModel.updateInfo(roleId, {trainCount, trainTime: nowSeconds(), buyTrainCount}, {});
@@ -32,25 +35,10 @@ export async function getUserGuild(roleId: string, serverId: number) {
return userGuild;
}
export async function recordUserGuild(roleId: string, code: string) {
let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards');
if (!userGuild||userGuild.guildCode != code)
return;
let { trainCount, trainTime} = userGuild;
if (trainTime < getHourPoint(REFRESH_HOUR)) {
trainCount = 0;
}
userGuild = await UserGuildModel.updateInfo(roleId, {trainCount, trainTime: nowSeconds()}, {});
return userGuild;
}
export function getGuildTrain (guildTrains, trainCount:number, trainRewards: Array<number>) {
let list = guildTrains.map(({trainId, isComplete})=>{
return ({trainId, isComplete, });
});
return { list, trainCount, trainRewards};
}
/**
* 获得未失效的试炼宝箱奖励
* @param guildTrain
*/
export function getGuildTrainRewards (guildTrain) {
let { trainInstances: instances } = getArmyTrainJuDian(guildTrain.trainId);
let trainBoxs = guildTrain.trainInstances.map(({hid, trainBoxs, endTime})=>{
@@ -62,7 +50,13 @@ export function getGuildTrainRewards (guildTrain) {
})
return { trainBoxs };
}
/**
* 获得练兵场封装信息 练兵场关卡进度，排行榜，挑战次数，和练兵场升级奖励
* @param guildTrain
* @param roleId
* @param trainCount
* @param trainRewards
*/
export function getGuildTrainInfo (guildTrain: GuildTrainType, roleId: string, trainCount:number, trainRewards: Array<number>) {
let { trainId, isComplete, trainInstances, ranks } = guildTrain;
@@ -87,7 +81,11 @@ export function getGuildTrainInfo (guildTrain: GuildTrainType, roleId: string,
return { guildTrain: resGuildTrain, trainCount, trainRewards};
}
/**
* 解锁试炼trainId
* @param code
* @param trainId
*/
export async function unlockTrain(code: string, trainId: number) {
let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
if (!!guildTrain) {
@@ -110,7 +108,11 @@ export async function unlockTrain(code: string, trainId: number) {
return guildTrain;
}
/**
* 重置练兵场
* @param code
* @param serverId
*/
export async function resetTrain(code: string, serverId: number) {
let res:any = await lockData(serverId, DATA_NAME.GUILD, code);//加锁
if (!!res.err)
@@ -118,17 +120,16 @@ export async function resetTrain(code: string, serverId: number) {
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();//解锁
if (!guild) {//不满足重置条件，结束并解锁
return;
}
res.releaseCallback();//解锁
const userGuildList = await UserGuildModel.getListByGuild(code, 'trainRewards', {});
const guildTrains = await GuildTrainModel.getGuildTrainBoxs(code);
let mails = new Array<MailType>();
let pushMessage = [];
let { shilianRewardRatio } = getTrainBaseByLv(GUILD_STRUCTURE.TRAIN);
//结算未领取的宝箱奖励发送到邮件中
userGuildList.forEach(async function ({roleId, trainRewards}) {
let goods = [];
guildTrains.forEach(guildTrain=>{
@@ -155,14 +156,18 @@ export async function resetTrain(code: string, serverId: number) {
await MailModel.addMails(mails);
pushMessage.forEach(({route, data, uids })=>{
pinus.app.channelService.pushMessageByUids(route, resResult(STATUS.SUCCESS, { mails:data }), uids);
pinus.app.channelService.pushMessageByUids('onGuildTainReset', resResult(STATUS.SUCCESS, {}), uids);
pinus.app.channelService.pushMessageByUids('onGuildTainReset', resResult(STATUS.SUCCESS, {}), uids);//通知在线玩家练兵场重置，
});
await GuildTrainModel.resetGuildTrain(code);
await unlockTrain(code, 1);
await UserGuildModel.resetTrainUserGuild(code);
await GuildTrainModel.resetGuildTrain(code);//将开启的练兵场锁定
await unlockTrain(code, 1);//开启练兵场1级
await UserGuildModel.resetTrainUserGuild(code);//重置玩家的挑战次数和购买挑战次数
}
export async function checkesetTrain(roleId: string, serverId: number) {
/**
* 检查并重置试炼
* @param roleId
* @param serverId
*/
export async function checkResetTrain(roleId: string, serverId: number) {
let userGuild = await UserGuildModel.getMyGuild(roleId,'guildCode');
if (!userGuild)
return;
@@ -177,5 +182,4 @@ export async function checkesetTrain(roleId: string, serverId: number) {
*/
export async function removeTrainRank(guildCode: string, roleId: string, trainId: number) {
await GuildTrainModel.removeTrainRank(guildCode, roleId, trainId);
}

8
game-server/app/services/playerEventService.ts
View File

@@ -3,7 +3,13 @@ import { checkPvp, findPvpDefByRoleId } from '../services/pvpService'
import { getFuncsSwitch } from '../pubUtils/data';
import { FUNCS_ID, FUNC_OPT_TYPE } from '../consts/constModules/sysConst';
import { RoleModel } from '../db/Role';
/**
* 等级提升触发事件
* @param roleId
* @param lv
* @param addFuncs
* @param dataFuncs
*/
export async function eventOnPlayerLvUp(roleId: string, lv: number, addFuncs: Array<number>, dataFuncs: Array<number>) {
if (!dataFuncs.includes(FUNCS_ID.PVP)) {//开启pvp

13
game-server/app/services/redlockCacheService.ts
View File

@@ -9,18 +9,23 @@ interface UserCache {
var userCacheMap = new Map<string, UserCache>();
export function init() {
scheduleJob("0/5 * * * * *", clearDirtyData, {name:'clearDirtyData'});
scheduleJob("0/5 * * * * *", clearDirtyData, {name:'clearDirtyData'});//每个5秒钟，释放redis锁
}
/**
* 释放锁
*/
export function clearDirtyData() {
userCacheMap.forEach(function(userCache, key) {
if(nowSeconds() > userCache.time + 10){
console.log('show lock =' + JSON.stringify(userCache.lock));
userCacheMap.delete(key);
releaseLock(key);
}
})
}
/**
* 根据key解锁
* @param lockKey
*/
export function releaseLock(lockKey: string) {
var userCache = userCacheMap.get(lockKey);
if (!!userCache && userCache.lock){

2
shared/consts/statusCode.ts
View File

@@ -177,7 +177,7 @@ export const STATUS = {
GUILD_LIGHT_UP_THE_SCIENCETREE: { code: 20964, simStr: '军团已经点亮此科技' },
GUILD_SCIENCETREE_IS_RUNNING: { code: 20965, simStr: '军团正在进行研发，不能点亮' },
GUILD_IS_ASSISTED_SCIENCETREE: { code: 20966, simStr: '玩家已经协助过该科技树' },
GUILD_REACH_MAX_ASSIST_COUNT: { code: 20967, simStr: '已经达到协助的最大次数' },
GUILD_REACH_MAX_ASSIST_COUNT: { code: 20967, simStr: '协助的人数已经达到最大' },
GUILD_TRAIN_IS_NOT_COMPLETE: { code: 20968, simStr: '军团该训练场没有完成' },
GUILD_TRAIN_QUALITY_REWARD_IS_GOT: { code: 20969, simStr: '军团训练进阶奖励已经领取' },
GUILD_PERSITION_TREE_NOT_LIGHT: { code: 20970, simStr: '军团前置科技树未研发' },

5
shared/db/GMMail.ts
View File

@@ -3,14 +3,15 @@ import { getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { nowSeconds } from '../pubUtils/timeUtil';
class RewardInter {
@prop({ required: true })
id: number;
@prop({ required: true })
count: number;
}
class SendRole {
@prop({ required: true })
roleId: string;
@prop({ required: true })
status: number;
}
export default class GMMail extends BaseModel {

2
shared/db/GroupMail.ts
View File

@@ -5,7 +5,9 @@ import { MAIL_STATUS, MAIL_TYPE } from '../consts/constModules/mailConst';
import { findWhere } from 'underscore';
const { ObjectId } = mongoose.Types;
class RewardInter {
@prop({ required: true })
id: number;
@prop({ required: true })
count: number;
}
class SendRole {

8
shared/db/Guild.ts
View File

@@ -212,7 +212,13 @@ export default class Guild extends BaseModel {
const result = await GuildModel.findOneAndUpdate({ members: { $elemMatch: { $eq: roleId } }, status: GUILD_STATUS.RUNNING}, {$inc: {guildCe: inc}}, {new: true}).lean({getters: true});
return result;
}
/**
* 每周一，5点刷新,若满足刷新条件，则重置试炼等级并返回
* @param code
* @param serverId
* @param trainLv
* @param lean
*/
public static async resetGuildTrain(code: string, serverId: number, trainLv: number, lean = true) {
const time = getCurWeekTime(1, 5);//每周一，5点刷新
const result = await GuildModel.findOneAndUpdate({ code, status: GUILD_STATUS.RUNNING, serverId, resetTrainTime:{$ne:time}},{$set: {trainId: 1, resetTrainTime: time, trainLv}}, {new: true}).lean(lean);

2
shared/db/GuildTrainReport.ts
View File

@@ -15,7 +15,7 @@ class Report {
@prop({ required: true })
difficulty: number;
@prop({ required: true })
type: number;//1表示普通战报， 2表示系统战报即：被成功压制
type: number;//1：失败， 2：成功，3：表示系统战报即：被成功压制
}
@index({guildCode: 1, trainId: 1})

2
shared/db/Mail.ts
View File

@@ -34,7 +34,7 @@ export default class Mail extends BaseModel {
status: number;
@prop({ required: true })
mailTemType: number; //1:表示模板邮件，2：表示系统邮件
mailTemType: number; //1:表示从gm下发的邮件，2：表示系统邮件
@prop({ required: true })
sendName: string;