军团bug和备注

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

@@ -6,7 +6,7 @@ import { BattleRecordModel } from '../../../db/BattleRecord';
 import { nowSeconds, getTodayZeroPoint } from '../../../pubUtils/timeUtil';
 import { getBossInstanceInfo, bossResult, checkMemberExists, pushBossHpMessage, getBossInstanceWhenEnd, addBossInstance } from '../../../services/guildBossService';
 import { findWhere } from 'underscore'
-import { GUILD_STRUCTURE, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
+import { GUILD_STRUCTURE, GUILD_BOSS_STATUS, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
 import { DATA_NAME } from '../../../consts/dataName';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { GUILD_OPERATE } from '../../../consts';
@@ -14,7 +14,6 @@ import { checkAuth, addActive } from '../../../services/guildService';
 import { GuildModel } from '../../../db/Guild';
 import { getBossByLv } from '../../../pubUtils/data';
 import { lockData } from '../../../services/redLockService';
-import { handleCost } from '../../../services/rewardService';
 
 export default function (app: Application) {
     return new GuildHandler(app);
@@ -51,10 +50,9 @@ export class GuildHandler {
         const { guildCode: code } = userGuild;
         let bossInstance = await BossInstanceModel.findBossInstance(code);
         if (!bossInstance) {
-            return resResult(STATUS.SUCCESS, {status: 1});//1：等待团长开启，2：今日已开启，且boss通关，3：开启中
+            return resResult(STATUS.SUCCESS, {status: GUILD_BOSS_STATUS.WAIT_OPEN});//等待团长开启
         }
         let result = await getBossInstanceInfo(bossInstance, roleId);
-
         return resResult(STATUS.SUCCESS, result);
     }
     
@@ -75,22 +73,27 @@ export class GuildHandler {
             return resResult(STATUS.REDLOCK_ERR); 
         let bossInstance = await BossInstanceModel.findBossInstance(code);
         if (!!bossInstance && ( bossInstance.bossHp > 0 || bossInstance.startTime >= getTodayZeroPoint() )) {
+            res.releaseCallback();
             return resResult(STATUS.GUILD_SCRIPT_IS_OPENED_TODAY);
         }
         const guild = await GuildModel.findByCode(code, serverId, 'lv structure');
         if(!guild) {
+            res.releaseCallback();
             return resResult(STATUS.GUILD_NOT_FOUND);
         }
         const { structure } = guild;
         const curStructure = structure.find(cur => cur.id == GUILD_STRUCTURE.BOSS);
         if(!curStructure) {
+            res.releaseCallback();
             return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
         }
         let bossBase = getBossByLv(curStructure.lv);
         let { bossHp, warId } = getRandomByLen(bossBase.wars);
         let resGuild = await GuildModel.costFund(code, bossBase.opencost);
-        if (!resGuild) 
+        if (!resGuild) {
+            res.releaseCallback();
             return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
+        }
         await BossInstanceModel.openBossInstance(code, bossHp, warId, bossBase.bossLevel);
         res.releaseCallback();
         let result = {warId, ranks: [], myRank: {}, bossHp, status: 3, bossLv: bossBase.bossLevel, isBattled: false};
@@ -145,7 +148,7 @@ export class GuildHandler {
         }
         //记录伤害
         let bossInstance = await BossInstanceModel.updateBossHp(code, damage, roleId);
-        if (!bossInstance) {//进入结算
+        if (!bossInstance|| bossInstance.bossHp == 0) {//进入结算
             let flag = await bossResult(code, serverId, DATA_NAME.BOSS_SCRIPT, roleId, damage);
             if (!flag) {
                 return resResult(STATUS.WRONG_PARMS);

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

@@ -87,20 +87,28 @@ 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) 
+            if (scienceTree.endTime > nowTime) {
+                res.releaseCallback();
                 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) 
+            if (!scienceTree||scienceTree.endTime > nowTime) {
+                res.releaseCallback();
                 return resResult(STATUS.GUILD_PERSITION_TREE_NOT_LIGHT);
+            }
         }
         const costResult = await GuildModel.costFund(code, developConsume.fundConsume);
-        if(!costResult) 
+        if(!costResult) {
+            res.releaseCallback();
             return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
+        }
         let scienceTree = { id, endTime: nowTime + developConsume.timeConsume, assistRoleIds: []}
         let { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
         res.releaseCallback();
@@ -122,16 +130,24 @@ export class GuildRefineHandler {
         let guildRefine = await GuildRefineModel.getRefine(code);
         
         let index = findIndex(guildRefine.scienceTrees, { id });
-        if (index == -1) 
+        if (index == -1) {
+            res.releaseCallback();
             return resResult(STATUS.WRONG_PARMS);
+        }
         let scienceTree = guildRefine.scienceTrees[index];
-        if (scienceTree.assistRoleIds.indexOf(roleId) != -1) 
+        if (scienceTree.assistRoleIds.indexOf(roleId) != -1) {
+            res.releaseCallback();
             return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE); 
-        if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) 
+        }
+        if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) {
+            res.releaseCallback();
             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) 
+        if (!result) {
+            res.releaseCallback();
             return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);   
+        }
         scienceTree.assistRoleIds.push(roleId);
         scienceTree.endTime = scienceTree.endTime - ARMY.ARMY_DEVELOPMENT_SPEED * 60;
         let { scienceTrees } = await GuildRefineModel.updateRefine(code, { scienceTrees: guildRefine.scienceTrees })

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

@@ -180,18 +180,24 @@ export class GuildTrainHandler {
             return resResult(STATUS.GUILD_TRAIN_SCRIPT_NOT_OPENED);
         }
         let trainInstance = findWhere(guildTrain.trainInstances, { hid });
-        if (!trainInstance) 
+        if (!trainInstance) {
+            res.releaseCallback();//解锁
             return resResult(STATUS.WRONG_PARMS); 
+        }
 
         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) * (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 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 = [];
@@ -266,14 +272,20 @@ export class GuildTrainHandler {
             return resResult(STATUS.GUILD_TRAIN_SCRIPT_NOT_OPENED);
         }
         let trainInstance = findWhere(guildTrain.trainInstances, { hid });
-        if (trainInstance.endTime < nowSeconds())
+        if (trainInstance.endTime < nowSeconds()) {
+            res.releaseCallback();//解锁
             return resResult(STATUS.GUILD_TRAIN_BOX_IS_OVER_TIME);
+        }
         let trainBox = findWhere(trainInstance.trainBoxs, { index })
-        if (!!trainBox) 
+        if (!!trainBox) {
+            res.releaseCallback();//解锁
             return resResult(STATUS.GUILD_TRAIN_BOX_INDEX_IS_GOT);
+        }
         trainBox = findWhere(trainInstance.trainBoxs, { roleId })
-        if (!!trainBox) 
+        if (!!trainBox) {
+            res.releaseCallback();//解锁
             return resResult(STATUS.GUILD_TRAIN_BOX_IS_GOT);
+        }
         let good = getRandomByLen(heroRewards);
         good.count = Math.floor((100 + shilianRewardRatio) * good.count/100);
         let goods = await addItems(roleId, roleName, sid, [good]);
@@ -282,8 +294,7 @@ export class GuildTrainHandler {
         res.releaseCallback();//解锁
        
         if (!resGuildTrain) {
-            let result:any = getGuildTrainRewards(guildTrain);
+            return resResult(STATUS.GUILD_GET_TRAIN_BOX_FAIL);
-            return resResult(STATUS.GUILD_GET_TRAIN_BOX_FAIL, result);
         }
         let result:any = getGuildTrainRewards(resGuildTrain);
 

game-server/app/services/guildBossService.ts

@@ -12,43 +12,46 @@ import { getArmyBossRank } from '../pubUtils/data';
 import { getMailContent } from '../services/mailService';
 import { pushMail } from '../pubUtils/interface';
 import { MAIL_TYPE } from '../consts';
+import { GUILD_BOSS_STATUS } from '../consts/constModules/guildConst';
 /**
  * 
  * @param bossInstance 
  * @param roleId 
  */
 export async function getBossInstanceInfo(bossInstance: BossInstanceType, roleId:string) {
-    let { warId, ranks,  bossHp, bossLv, winWarId, winTime, roleIdRecords, guildCode } = bossInstance;
+    let { warId, ranks,  bossHp, bossLv, winWarId, winTime, roleIdRecords, guildCode, startTime, winBossLv } = bossInstance;
     ranks.sort(function(a, b) {
         return b.score - a.score + a.time - b.time;
     });
     let result:any = {};
-    //1：等待团长开启，2：今日已开启，且boss通关，3：开启中
+    if (!!winWarId && winTime > getTodayZeroPoint() && roleIdRecords.indexOf(roleId) == -1) {
-    if ( bossInstance.bossHp <= 0 ) {
+        //今日通关过，且首次点开boss界面，提示某某boss已通关
-        if (!!winWarId && winTime > getTodayZeroPoint() && roleIdRecords.indexOf(roleId) == -1) {
+        result = { showParam: { winWarId, winBossLv } };
-            result = { winWarId };
+        await BossInstanceModel.recordRoleIdWhenCheck(guildCode, roleId);
-            await BossInstanceModel.recordRoleIdWhenCheck(guildCode, roleId);
+    }
-        }
+    if ( bossHp <= 0 ) { 
-        if (bossInstance.startTime < getTodayZeroPoint()) {
+        result = { warId };
-            result.status = 1;
+        if (startTime < getTodayZeroPoint()) {
+            //今日未开启过boss，等待开启
+            result.status = GUILD_BOSS_STATUS.WAIT_OPEN;
             return result;
         } else {
-            result.status = 2;
+            //今日已开启，且boss通关
+            result.status = GUILD_BOSS_STATUS.OPENED;
             return result;
         }
     }
     let isBattled = false;
     let myRank = {};
-    
     let lastRanks = ranks.map(({roleId: battleRoleId, score, time}, index) => {
         if (roleId == battleRoleId) {
-            myRank = {roleId, score, rankLv: index + 1};
+            myRank = { roleId, score, rankLv: index + 1 };
             if (time >= getTodayZeroPoint())
                 isBattled = true;
         }
         return {roleId, score, rankLv: index + 1};
     });
-    return {warId, ranks: lastRanks, myRank, bossHp, status: 3, isBattled, bossLv};
+    return { warId, ranks: lastRanks, myRank, bossHp, status: GUILD_BOSS_STATUS.OPEN, isBattled, bossLv };
 }
 /**
  * 战斗结束返回
@@ -57,16 +60,16 @@ export async function getBossInstanceInfo(bossInstance: BossInstanceType, roleId
  * @param battleNum 
  */
 export async function getBossInstanceWhenEnd(bossInstance: BossInstanceType, roleId:string, battleNum:number) {
-    let { warId, ranks, bossHp, winWarId, guildCode, recordRanks, winNum, bossLv } = bossInstance;
+    let { warId, ranks, bossHp, winWarId, guildCode, recordRanks, winNum, bossLv, winBossLv } = bossInstance;
     let pushRanks;
     let result:any = {};
     if (battleNum == winNum) {
         pushRanks = deepCopy(recordRanks);
-        result = {warId: winWarId, bossHp: 0, bossLv, status: 3};
+        result = {warId: winWarId, bossHp: 0, bossLv: winBossLv, status:  GUILD_BOSS_STATUS.OPEN};
         await BossInstanceModel.recordRoleIdWhenCheck(guildCode, roleId);
     } else {
         pushRanks = deepCopy(ranks);
-        result = {warId, bossHp, bossLv, status: 3};
+        result = {warId, bossHp, bossLv, status:  GUILD_BOSS_STATUS.OPEN};
     }
     pushRanks.sort(function(a, b) {
         return b.score - a.score + a.time - b.time;
@@ -99,7 +102,7 @@ export async function bossResult(code: string, serverId: number, dataName: strin
     let res:any = await lockData(serverId, dataName, code);//加锁
     if (!!res.err) 
         return true;
-    let {winSettled, ranks, num, warId, bossHp} = await BossInstanceModel.findBossInstance(code);//锁定关卡信息
+    let {winSettled, ranks, num, warId, bossHp, bossLv} = await BossInstanceModel.findBossInstance(code);//锁定关卡信息
     if (winSettled) {
         res.releaseCallback();//解锁
         await BossInstanceModel.recordRoleIdWhenCheck(code, roleId);
@@ -115,7 +118,7 @@ export async function bossResult(code: string, serverId: number, dataName: strin
         res.releaseCallback();//解锁
         return true;
     }
-    let { recordRanks } = await BossInstanceModel.updateBossInstance(code, { bossHp: 0, winSettled: true, ranks,  recordRanks: ranks, winNum: num, winWarId: warId, roleIdRecords:[roleId]}, );
+    let { recordRanks } = await BossInstanceModel.updateBossInstance(code, { bossHp: 0, winSettled: true, ranks,  recordRanks: ranks, winNum: num, winWarId: warId, winBossLv: bossLv, roleIdRecords:[roleId]}, );
     await pushBossHpMessage(code, serverId, 0, true);
     res.releaseCallback();//数据修改解锁
     recordRanks.sort(function(a, b) {
@@ -180,7 +183,7 @@ export async function checkMemberExists(code: string, serverId:number, roleId: s
         if(!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId) {
             return false;
         } 
-        addBossInstance(code, serverId, roleId);
+        await addBossInstance(code, serverId, roleId);
         flag = true;
     }
     return flag;

shared/consts/constModules/guildConst.ts

@@ -118,6 +118,12 @@ export enum GUILD_REC_TYPE {
     IMPEACH = 11,             // 弹劾 roleName roleName
 }
 
+//1：等待团长开启，2：今日已开启，且boss通关，3：开启中
+export enum GUILD_BOSS_STATUS {
+    WAIT_OPEN = 1,
+    OPENED = 2,
+    OPEN = 3,//开启中
+}
 
 export const GUILD_REPORT_NUM = 40;
 export const REFRESH_HOUR = 5;

shared/consts/dataName.ts

@@ -1,7 +1,7 @@
 export enum DATA_NAME {
     BOSS_SCRIPT = 'BossInstance',
-    TRAIN = 'BossInstance',
+    TRAIN = 'TrainInstance',
-    TRAIN_BOX = 'BossInstanceBox',
+    TRAIN_BOX = 'TrainInstanceBox',
     GUILD = 'Guild',
     GUILD_REFINE = 'GuildRefine',
     GUILD_ASSIST_REFINE = 'GuildAssistRefine',

shared/db/BossInstance.ts

@@ -32,22 +32,25 @@ export default class BossInstance extends BaseModel {
     startTime: number;
     
     @prop({ required: true, default: 0})
-    num: number;
+    num: number; //重置次数
 
     @prop({ required: true, default:[], type: String, _id: false})
     roleIdRecords: Array<string>; //记录提示过胜利boss关的玩家
 
     @prop({ required: true })
-    winWarId: number; //记录上一次通关的关卡
+    winWarId: number; //记录上一次通关的关卡，boss被压制成功后，首次点开boss界面会提示文字，boss已被压制
+
+    @prop({ required: true })
+    winBossLv: number; //记录上一次通关的boss等级
 
     @prop({ required: true })
     winTime: number; //记录上一次通关的时间
 
     @prop({ required: true, default: 0})
-    winNum: number;
+    winNum: number; //记录上一次重置次数
 
     @prop({ required: true, type: Rank, default:[]})
-    recordRanks:Array<Rank>;
+    recordRanks:Array<Rank>;//上一场排名信息
 
     @prop({ required: true, default: false })
     winSettled: boolean; //胜利是否结算过

shared/resource/jsons/dic_army_structureOpen.json

@@ -0,0 +1,51 @@
+[
+    {
+        "id": 1,
+        "structureId": 1,
+        "openLv": 1,
+        "name": "中军大帐",
+        "info": "&"
+    },
+    {
+        "id": 2,
+        "structureId": 2,
+        "openLv": 2,
+        "name": "炼器堂",
+        "info": "中军大帐2级时开启"
+    },
+    {
+        "id": 3,
+        "structureId": 3,
+        "openLv": 2,
+        "name": "演武台",
+        "info": "中军大帐2级时开启"
+    },
+    {
+        "id": 4,
+        "structureId": 4,
+        "openLv": 2,
+        "name": "练兵场",
+        "info": "中军大帐2级时开启"
+    },
+    {
+        "id": 5,
+        "structureId": 5,
+        "openLv": 1,
+        "name": "许愿池",
+        "info": "中军大帐1级时开启"
+    },
+    {
+        "id": 6,
+        "structureId": 6,
+        "openLv": 1,
+        "name": "商店",
+        "info": "中军大帐1级时开启"
+    },
+    {
+        "id": 7,
+        "structureId": 7,
+        "openLv": 1,
+        "name": "捐献所",
+        "info": "中军大帐1级时开启"
+    }
+]

shared/resource/jsons/dic_zyz_playerRecord.json

@@ -0,0 +1,20 @@
+[
+    {
+        "id": 1,
+        "titleString": "主线",
+        "param": "main",
+        "content": "%d-%d"
+    },
+    {
+        "id": 2,
+        "titleString": "天梯",
+        "param": "tower",
+        "content": "第%d层"
+    },
+    {
+        "id": 3,
+        "titleString": "PVP",
+        "param": "pvp",
+        "content": "第%d名"
+    }
+]