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

game-server/app/servers/battle/handler/guildRefineHandler.ts

@@ -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) {

game-server/app/servers/battle/handler/guildTrainHandler.ts

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

game-server/app/servers/role/handler/mailHandler.ts

@@ -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 = [];

game-server/app/services/funcSwitchService.ts

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

game-server/app/services/guildRefineService.ts

@@ -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

game-server/app/services/guildTrainService.ts

@@ -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);
+    await resetTrain(guildCode, serverId);//检查重置练兵场
-    if (trainTime < getHourPoint(REFRESH_HOUR)) {
+    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)
+ * @param guildTrain 
-        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};
-}
-
 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();//解锁
-        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 GuildTrainModel.resetGuildTrain(code);//将开启的练兵场锁定
-    await unlockTrain(code, 1);
+    await unlockTrain(code, 1);//开启练兵场1级
-    await UserGuildModel.resetTrainUserGuild(code);
+    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);
-  
 }

game-server/app/services/playerEventService.ts

@@ -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

game-server/app/services/redlockCacheService.ts

@@ -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){

shared/consts/statusCode.ts

@@ -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: '军团前置科技树未研发' },

shared/db/GMMail.ts

@@ -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 {

shared/db/GroupMail.ts

@@ -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 {

shared/db/Guild.ts

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

shared/db/GuildTrainReport.ts

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

shared/db/Mail.ts

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