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

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);
-    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();//解锁
+    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);
-  
 }

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