炼器堂

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

@@ -9,10 +9,11 @@ import { findWhere, random } from 'underscore'
 import { GUILD_DATA_NAME, GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { GUILD_OPERATE } from '../../../consts';
-import { checkAuth } from '../../../services/guildService';
+import { checkAuth, addActive } from '../../../services/guildService';
 import { GuildModel } from '../../../db/Guild';
 import { getBossByLv } from '../../../pubUtils/data';
 import { lockData } from '../../../services/redLockService';
+
 export default function (app: Application) {
     return new GuildHandler(app);
 }
@@ -69,6 +70,7 @@ export class GuildHandler {
         if (!resGuild) 
             return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
         await BossInstanceModel.openBossInstance(code, bossHp, warId);
+        res.releaseCallback();
         let result = {warId, ranks: [], myRank: {}, bossHp, type: 3, isBattled: false};
         return resResult(STATUS.SUCCESS, result);
     }
@@ -140,6 +142,7 @@ export class GuildHandler {
     async battleBossEnd(msg: { battleCode: string }, session: BackendSession) {
         const { battleCode } = msg;
         const roleId = session.get('roleId');
+        const serverId: number = parseInt(session.get('serverId'));
         let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
         if (!userGuild) 
             return resResult(STATUS.WRONG_PARMS); 
@@ -153,7 +156,7 @@ export class GuildHandler {
         }, true);
         let bossInstance = await BossInstanceModel.findBossInstance(code);
         let result = await getBossInstanceWhenEnd(bossInstance, roleId, battleRecord.record.recordNum);
-
+        await addActive(roleId, serverId, 3, 1);
         return resResult(STATUS.SUCCESS, result);
     }
 

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

@@ -16,6 +16,8 @@ import { GuildRecModel } from '../../../db/GuildRec';
 import { sendMail } from '../../../services/mailService';
 import { existsRank, initSingleRankWithServer, getRank, setRank, redisUserInfoUpdate, redisUserInfoAdd, removeFromRank, getMyRank } from '../../../services/redisService';
 
+import { openGuildRefine } from '../../../services/guildRefineService'; 
+import { unlockTrain } from '../../../services/guildTrainService';
 export default function (app: Application) {
     return new GuildHandler(app);
 }
@@ -55,7 +57,9 @@ export class GuildHandler {
         guild.guildCe = reduceCe(guild.guildCe);
         guild.leader = <RoleType>guild.leader;
         guild.leader.ce = reduceCe(guild.leader.ce);
-
+        //创建科技树
+        await openGuildRefine(guild.code);
+        await unlockTrain(guild.code, 1);
         const userGuild = await UserGuildModel.createUserGuild(guild.code, role, true);
         if(!userGuild) return resResult(STATUS.GUILD_CREATE_ERROR);
 

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

@@ -0,0 +1,138 @@
+import { Application, BackendSession, pinus } from 'pinus';
+import { UserGuildModel } from '../../../db/UserGuild';
+import { resResult } from '../../../pubUtils/util';
+import { STATUS, GUILD_OPERATE } from '../../../consts';
+import { GuildRefineModel } from '../../../db/GuildRefine';
+import { getArmyDevelopConsumeById, getGoodById } from '../../../pubUtils/data';
+import { EquipModel } from '../../../db/Equip';
+import { nowSeconds } from '../../../pubUtils/timeUtil';
+import { handleCost, addItems } from '../../../services/rewardService';
+import { GuildModel } from '../../../db/Guild';
+import { findIndex, findWhere } from 'underscore';
+import { lockData } from '../../../services/redLockService';
+import { GUILD_DATA_NAME, GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
+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';
+export default function (app: Application) {
+    return new GuildRefineHandler(app);
+}
+
+export class GuildRefineHandler {
+    constructor(private app: Application) {
+
+    }
+
+    async getRefine(msg: {}, session: BackendSession) {
+        const roleId = session.get('roleId');
+        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
+        if (!userGuild) 
+            return resResult(STATUS.WRONG_PARMS); 
+        const { guildCode: code } = userGuild;
+        let guildRefine = await GuildRefineModel.getRefine(code);
+        if (!guildRefine) {
+            guildRefine = await openGuildRefine(code);
+        }
+        return resResult(STATUS.SUCCESS, { scienceTrees: guildRefine.scienceTrees }); 
+    }   
+
+    async refineEquip(msg: {eid: number}, session: BackendSession) {
+        let { eid } = msg;
+        const roleId: string = session.get('roleId');
+        const sid: string = session.get('sid');
+        const roleName: string = session.get('roleName');
+        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
+        if (!userGuild) 
+            return resResult(STATUS.WRONG_PARMS); 
+        let { guildCode: code } = userGuild;
+        let equpInfo = getGoodById(eid);
+        let { scienceTrees } = await GuildRefineModel.getRefine(code);
+        let findDevelopConsume;
+        for (let scienceTree of scienceTrees) {
+            if (scienceTree.endTime < nowSeconds()) {
+                let developConsume = getArmyDevelopConsumeById(scienceTree.id);
+                if (developConsume.quality && developConsume.levelMax >= equpInfo.lvLimited && equpInfo.lvLimited <= developConsume.levelMin) {
+                    findDevelopConsume = developConsume;
+                    break;
+                }
+            }
+        }
+        if (!findDevelopConsume) 
+            return resResult(STATUS.GUILD_NOT_REFINE_THE_EQUIP);
+      
+        let result = await handleCost(roleId, sid, findDevelopConsume.honourConsume);
+        if(!result) 
+            return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+        let goods = await addItems(roleId, roleName, sid, [{id: eid, count: 1}]);
+        return resResult(STATUS.SUCCESS, { goods }); 
+    }   
+
+    async lightUpTree(msg: {id: number}, session: BackendSession) {
+        let { id } = msg;
+        const roleId: string = session.get('roleId');
+        const serverId: number = session.get('serverId');
+        let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
+        if (!userGuild) 
+            return resResult(STATUS.WRONG_PARMS); 
+        const checkMyResult = await checkAuth(GUILD_OPERATE.EQUIP_PRODUCE, roleId, null, userGuild);
+        if(!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
+        const { guildCode: code } = userGuild;
+        let developConsume = getArmyDevelopConsumeById(id);
+        if (!developConsume)
+            return resResult(STATUS.WRONG_PARMS); 
+        let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_REFINE, code);//加锁
+        if (!!res.err) 
+            return resResult(STATUS.REDLOCK_ERR); 
+        let guildRefine = await GuildRefineModel.getRefine(code);
+        for (let scienceTree of  guildRefine.scienceTrees) {
+            if (scienceTree.id == id) 
+                return resResult(STATUS.GUILD_LIGHT_UP_THE_SCIENCETREE);
+            
+            if (scienceTree.endTime > nowSeconds()) 
+                return resResult(STATUS.GUILD_SCIENCETREE_IS_RUNNING);
+        }
+        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 { scienceTrees } = await GuildRefineModel.pushRefine(code, scienceTree);
+        res.releaseCallback();
+        return resResult(STATUS.SUCCESS, { scienceTrees }); 
+    }
+
+    async assistRefine(msg: {id: number}, session: BackendSession) {
+        let { id } = msg;
+        const roleId: string = session.get('roleId');
+        const serverId: number = session.get('serverId');
+        const sid: string = session.get('sid');
+
+        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
+        if (!userGuild) 
+            return resResult(STATUS.WRONG_PARMS); 
+        const { guildCode: code } = userGuild;
+        let res:any = await lockData(serverId, GUILD_DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
+        if (!!res.err) 
+            return resResult(STATUS.REDLOCK_ERR); 
+        let guildRefine = await GuildRefineModel.getRefine(code);
+        
+        let index = findIndex(guildRefine.scienceTrees, { id });
+        if (index == -1) 
+            return resResult(STATUS.WRONG_PARMS);
+        let scienceTree = guildRefine.scienceTrees[index];
+        if (scienceTree.assistRoleIds.indexOf(roleId) != -1) 
+            return resResult(STATUS.GUILD_IS_ASSISTED_SCIENCETREE); 
+        if (scienceTree.assistRoleIds.length >= ARMY.ARMY_DEVELOPMENT_SPEEDTMES) 
+            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) 
+            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 })
+        res.releaseCallback();
+        return resResult(STATUS.SUCCESS, { scienceTrees }); 
+    }
+}

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

@@ -1,23 +0,0 @@
-import { Application, BackendSession, pinus } from 'pinus';
-import { UserGuildModel } from '../../../db/UserGuild';
-import { resResult } from '../../../pubUtils/util';
-import { STATUS } from '../../../consts';
-
-export default function (app: Application) {
-    return new GuildRefinerHandler(app);
-}
-
-export class GuildRefinerHandler {
-    constructor(private app: Application) {
-
-    }
-
-    async refineEquip(msg: {eId: number}, session: BackendSession) {
-        const roleId = session.get('roleId');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild) 
-            return resResult(STATUS.WRONG_PARMS); 
-        
-        
-    }   
-}

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

@@ -4,7 +4,7 @@ import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB } from '../../../consts';
 import { GuildTrainModel } from '../../../db/GuildTrain';
 import { BattleRecordModel } from '../../../db/BattleRecord';
 import { nowSeconds, getHourPoint, getCurHourPoint } from '../../../pubUtils/timeUtil';
-import { getUserGuild, getGuildTrainInfo, lockTrain, resetTrain, getGuildTrainRewards} from '../../../services/guildTrainService';
+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';
@@ -14,6 +14,7 @@ import { getArmyTrainJuDian, getTrainSoloReward, getTrainBaseByLv } from '../../
 import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
 import { handleCost, addItems } from '../../../services/rewardService';
 import { ARMY } from '../../../pubUtils/dicParam';
+import { addActive } from '../../../services/guildService';
 export default function (app: Application) {
     return new GuildTrainHandler(app);
 }
@@ -38,7 +39,7 @@ export class GuildTrainHandler {
         }
         let guildTrains = await GuildTrainModel.findGuildTrainByTrainIds(code, trainIds);
         if (!guildTrains || !findWhere(guildTrains, {trainId})) {
-            let guildTrain = await lockTrain(code, trainId);
+            let guildTrain = await unlockTrain(code, trainId);
             if (!guildTrains) {
                 guildTrains.push(guildTrain);
             }
@@ -98,13 +99,14 @@ export class GuildTrainHandler {
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         const battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
-        // if(!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId || battleRecord.record.guildCode != code) {
+        // if (!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId || battleRecord.record.guildCode != code) {
         //     return resResult(STATUS.WRONG_PARMS);
         // } 
         let time = Math.floor(battleRecord.createdAt.getTime()/1000);
         // if (userGuild.trainCount - 1 < 0) {
         //     return resResult(STATUS.WRONG_PARMS);
         // } 
+        
         if (time < getCurHourPoint(REFRESH_HOUR) && nowSeconds() > getCurHourPoint(REFRESH_HOUR)) {
             return resResult(STATUS.GUILD_TRAIN_IS_RESETED);//关卡已经重置
         }
@@ -168,14 +170,14 @@ export class GuildTrainHandler {
                 let progress = instance.progress;
                 resGuildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
                 if (needLockNext) { //
-                    let nextResGuildTrain = await lockTrain(code, trainId + 1);
+                    let nextResGuildTrain = await unlockTrain(code, trainId + 1);
                     trainIds.push(nextResGuildTrain.trainId);
                     guildTrains.push(nextResGuildTrain);
                 }
                 res.releaseCallback();//解锁
             } else {
                 let progress = trainInstance.progress + addScore;
-                resGuildTrain =  await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
+                resGuildTrain = await GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
                 res.releaseCallback();//解锁
             }
         } else {
@@ -194,6 +196,7 @@ export class GuildTrainHandler {
         let { trainCount, trainRewards } = userGuild;
         let result:any = getGuildTrainInfo(guildTrains, roleId, trainCount, trainRewards, trainIds);
         result.battleGoods = goods;
+        await addActive(roleId, serverId, 2, 1);
         return resResult(STATUS.SUCCESS, result);
     }
    

game-server/app/servers/connector/handler/entryHandler.ts

@@ -95,6 +95,7 @@ export class EntryHandler {
         role['ce'] = reduceCe(role.ce);
         role['topFiveCe'] = reduceCe(role.topFiveCe);
 
+
         return resResult(STATUS.SUCCESS, { role });
     }
 

game-server/app/services/funcSwitchService.ts

@@ -4,6 +4,7 @@ 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';
 // 开启功能
 export async function switchOnFunc(roleId: string, type: number, param: number, session: (BackendSession|FrontendSession)) {
 
@@ -33,4 +34,5 @@ export async function switchOnFunc(roleId: string, type: number, param: number,
 
 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);
 }

game-server/app/services/guildBossService.ts

@@ -8,6 +8,7 @@ import { pinus } from 'pinus';
 import { STATUS } from '../consts/statusCode';
 import { deepCopy, resResult } from '../pubUtils/util';
 import { BattleRecordModel } from '../db/BattleRecord';
+import { getArmyBossRank } from '../pubUtils/data';
 /**
  * 
  * @param bossInstance 
@@ -122,7 +123,9 @@ export async function bossResult(code: string, serverId: number, dataName: strin
     recordRanks.forEach(async function({roleId, score}, index){
         let rankLv = index + 1;
         const doc = new MailModel();
-        let goods;
+        let goods = getArmyBossRankReward(rankLv);
+        if (!goods || !goods.length)
+            return;
         const mail = Object.assign(doc.toJSON(), {roleId, goods, sendName: '系统', mailId: 1, sendTime: nowSeconds(), content:'恭喜玩家获得演武台第' + rankLv +'名 奖励如下：'});
         mails.push(mail);
         let key = 'login_roleId_' + roleId; 
@@ -138,6 +141,15 @@ export async function bossResult(code: string, serverId: number, dataName: strin
     return true;
 }
 
+export function getArmyBossRankReward(rankLv: number) {
+    let armybossRankReward = getArmyBossRank();
+    for (let item of armybossRankReward) {
+        if (item.rankMin <= rankLv && (rankLv <= item.rankMax || item.rankMax == -1)) {
+            return item.reward;
+        }
+    }
+}
+ 
 export async function addBossInstance(code: string, serverId:number, roleId: string) {
     let loginKey = 'login_roleId_' + roleId; 
     let sid = await getRedis(loginKey);

game-server/app/services/guildRefineService.ts

@@ -0,0 +1,30 @@
+import { UserGuildModel } from '../db/UserGuild';
+import { getArmyTrainJuDian, getArmyDevelopConsume } from '../pubUtils/data';
+import { nowSeconds, getHourPoint } from '../pubUtils/timeUtil';
+import { GUILD_REPORT_NUM, GUILD_DATA_NAME, REFRESH_HOUR } from '../consts/constModules/guildConst';
+import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain';
+import { GuildModel } from '../db/Guild';
+import { findWhere } from 'underscore';
+import { ARMY } from '../pubUtils/dicParam';
+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 { ScienceTree, GuildRefineModel } from '../db/GuildRefine';
+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
+            scienceTree.assistRoleIds = [];
+            scienceTrees.push(scienceTree);
+        }
+    });
+    let guildRefine = await GuildRefineModel.createScienceTree(code, scienceTrees);
+    return guildRefine;
+}

game-server/app/services/guildTrainService.ts

@@ -6,11 +6,11 @@ import { GuildTrainType, GuildTrainModel, TrainInstance } from '../db/GuildTrain
 import { GuildModel } from '../db/Guild';
 import { findWhere } from 'underscore';
 import { ARMY } from '../pubUtils/dicParam';
-import { lockData } from '../services/redLockService';
+import { lockData } from './redLockService';
 import { pinus } from 'pinus';
 import { MailModel, MailType } from '../db/Mail';
 import { getRandomByLen, resResult } from '../pubUtils/util';
-import { getRedis } from '../services/redisService';
+import { getRedis } from './redisService';
 import { STATUS } from '../consts/statusCode';
 export async function getUserGuild(roleId: string, serverId: number) {
     let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards');
@@ -109,7 +109,7 @@ export  function getGuildTrainInfo (guildTrains: Array<GuildTrainType>, roleId:
     return { guildTrain, trainCount, trainRewards};
 }
 
-export async function lockTrain(code: string, trainId: number) {
+export async function unlockTrain(code: string, trainId: number) {
     let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
     if (!!guildTrain) {
         return;
@@ -180,6 +180,13 @@ export async function resetTrain(code: string, serverId: number) {
     pinus.app.channelService.pushMessageByUids('onGuildTainReset', resResult(STATUS.SUCCESS, {}), uids);
     await MailModel.addMails(mails);
     await GuildTrainModel.resetGuildTrain(code);
-    await lockTrain(code, 1);
+    await unlockTrain(code, 1);
     await UserGuildModel.resetTrainUserGuild(code);
 }
+
+export async function checkesetTrain(roleId: string, serverId: number) {
+    let userGuild = await UserGuildModel.getMyGuild(roleId,'guildCode');
+    if (!userGuild)
+        return;
+    await resetTrain(userGuild.guildCode, serverId);
+}

shared/consts/constModules/guildConst.ts

@@ -121,7 +121,9 @@ export enum GUILD_DATA_NAME {
     BOSS_SCRIPT = 'BossInstance',
     TRAIN = 'BossInstance',
     TRAIN_BOX = 'BossInstanceBox',
-    GUILD = 'Guild'
+    GUILD = 'Guild',
+    GUILD_REFINE = 'GuildRefine',
+    GUILD_ASSIST_REFINE = 'GuildAssistRefine',
 }
 
 export const GUILD_REPORT_NUM = 40;

shared/consts/constModules/sysConst.ts

@@ -320,8 +320,9 @@ export const FILENAME = {
   DIC_MAIL: 'dic_email_army',
   DIC_ARMY_TRAIN_JU_DIAN: 'dic_army_trainJuDian',
   DIC_ARMY_TRAIN_SOLO_REWARD: 'dic_army_trainSoloReward',
-  DIC_ARMY_ACTIVE_POINT_WAYS: 'dic_army_activePointWays'
+  DIC_ARMY_ACTIVE_POINT_WAYS: 'dic_army_activePointWays',
-
+  DIC_ARMY_DEVELOPMENTCONSUME: 'dic_army_developmentConsume',
+  DIC_ARMY_BOSS_RANK_REWARD: 'dic_army_bossrankReward'
 }
 
 export const WAR_RELATE_TABLES = [

shared/consts/statusCode.ts

@@ -226,8 +226,12 @@ export const STATUS = {
     GUILD_GET_TRAIN_REWARD_FAIL: {code: 30913, simStr: '宝箱领取失败'},
     GUILD_TRAIN_LEVEL_IS_COMPLETE: {code: 30913, simStr: '试炼已经进阶'},
     GUILD_BUY_TRAIN_COUNT_REACH_MAX: { code: 30913, simStr: '训练场购买挑战次数以达到上线' },
-    GUILD_TRAIN_IS_RESETED: { code: 30913, simStr: '训练场购买挑战次数以达到上线' },
+    GUILD_TRAIN_IS_RESETED: { code: 30913, simStr: '军团训练场已经重置' },
-
+    GUILD_NOT_REFINE_THE_EQUIP: { code: 30913, simStr: '军团不能研发次装备' },
+    GUILD_LIGHT_UP_THE_SCIENCETREE: { code: 20920, simStr: '军团已经点亮此科技' },
+    GUILD_SCIENCETREE_IS_RUNNING: { code: 20920, simStr: '军团正在进行研发，不能点亮' },
+    GUILD_IS_ASSISTED_SCIENCETREE: { code: 20920, simStr: '玩家已经协助过该科技树' },
+    GUILD_REACH_MAX_ASSIST_COUNT: { code: 20920, simStr: '已经达到协助的最大次数' },
     // 社交相关状态 40000 - 49999
     // 运营模块相关状态 50000 - 59999
     // GM后台相关状态 60000 - 69999

shared/db/BossInstance.ts

@@ -11,13 +11,6 @@ class Rank {
     time: number;
 }
 
-class LastRecord {
-    @prop({ required: true, default: 0 })
-    warId: number;
-    @prop({ required: true})
-    roleIds: Array<string>;
-}
-
 @index({ guildCode: 1 })
 export default class BossInstance extends BaseModel {
     @prop({ required: true })
@@ -38,7 +31,7 @@ export default class BossInstance extends BaseModel {
     @prop({ required: true, default: 0})
     num: number;
 
-    @prop({ required: true, default:[]})
+    @prop({ required: true, default:[], type: String, _id: false})
     roleIdRecords: Array<string>; //记录提示过胜利boss关的玩家
 
     @prop({ required: true })

shared/db/ComBattleTeam.ts

@@ -87,7 +87,7 @@ export default class ComBattleTeam extends BaseModel {
     @prop({ required: true })
     teamCode: string;
 
-    @prop({ required: true, type: String, default: [] })
+    @prop({ required: true, type: String, default: [], _id: false })
     roleIds: Array<string>
 
     // 队伍是否开放加入

shared/db/GuildRefine.ts

@@ -1,18 +1,18 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
 
-class ScienceTree {
+export class ScienceTree {
     @prop({ required: true })
     id: number;		
     @prop({ required: true })
-    time: number;
+    endTime: number;
-    @prop({ required: true })
+    @prop({ required: true, default: [], type: String, _id: false})
-    assistCount: number;	
+    assistRoleIds: Array<string>;	
 }
 
 @index({ guildCode: 1 })
 
-export default class GuildRefiner extends BaseModel {
+export default class GuildRefine extends BaseModel {
     @prop({ required: true })
     guildCode: string;					
 
@@ -20,13 +20,27 @@ export default class GuildRefiner extends BaseModel {
     scienceTrees: ScienceTree[];       
 
     public static async createScienceTree(guildCode: string, scienceTrees: ScienceTree[], lean = true) {
-        const result = await GuildRefinerModel.findOneAndUpdate({ guildCode }, {$set: {scienceTrees}}, {new: true, upsert: true}).lean(lean);
+        const result = await GuildRefineModel.findOneAndUpdate({ guildCode }, {$set: {scienceTrees}}, {new: true, upsert: true}).lean(lean);
         return result;
     }
 
+    public static async getRefine(guildCode: string, lean = true) {
+        const result = await GuildRefineModel.findOne({ guildCode }).lean(lean);
+        return result;
+    }
     
+    public static async pushRefine(guildCode: string, scienceTree: ScienceTree,lean = true) {
+        const result = await GuildRefineModel.findOneAndUpdate({ guildCode,  'scienceTrees.$.id':{$ne:scienceTree.id}}, {$push: {scienceTrees: scienceTree}}, { new: true }).lean(lean);
+        return result;
+    }
+
+    public static async updateRefine(guildCode: string, update: GuildRefineTypeParam, lean = true) {
+        const result = await GuildRefineModel.findOneAndUpdate({ guildCode}, {$set: update}, { new: true }).lean(lean);
+        return result;
+    }
 }
 
-export const GuildRefinerModel = getModelForClass(GuildRefiner);
+export const GuildRefineModel = getModelForClass(GuildRefine)
+export interface GuildRefineType extends Pick<DocumentType<GuildRefine>, keyof GuildRefine> { };
 
-export interface GuildRefinerType extends Pick<DocumentType<GuildRefiner>, keyof GuildRefiner>{}
+export type GuildRefineTypeParam = Partial<GuildRefineType>; // 将所有字段变成可选项

shared/pubUtils/data.ts

@@ -53,7 +53,8 @@ import { dicMail } from "./dictionary/DicMail";
 import { dicArmyTrainJuDian } from './dictionary/DicArmyTrainJuDian';
 import { dicTrainSoloReward } from './dictionary/DicTrainSoloReward';
 import { RewardInter } from "./interface";
-
+import { dicArmyDevelopConsume } from '../pubUtils/dictionary/DicArmyDevelopConsume';
+import { dicArmyBossRank } from '../pubUtils/dictionary/DicArmyBossRank';
 export const gameData = {
     blurprtCompose: dicBlueprtCompose,
     blueprtPossibility: dicBlueprtPossibility,
@@ -128,7 +129,9 @@ export const gameData = {
     armyTrainJuDian: dicArmyTrainJuDian,
     trainSoloReward: dicTrainSoloReward,
     mail: dicMail,
-    guildActiveWays: dicGuildActiveWays
+    guildActiveWays: dicGuildActiveWays,
+    armyDevelopConsume: dicArmyDevelopConsume,
+    armyBossRank: dicArmyBossRank
 };
 
 // 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -370,3 +373,15 @@ export function getGuildActiveByIdAndType(id: number, type: number) {
     if(!dicWay) return 0;
     return dicWay.activePoint.get(type.toString());
 }
+export function getArmyDevelopConsumeById(id: number) {
+    let result = gameData.armyDevelopConsume.get(id);
+    return result;
+}
+
+export function getArmyDevelopConsume() {
+    return gameData.armyDevelopConsume;
+}
+
+export function getArmyBossRank() {
+    return gameData.armyBossRank;
+}

shared/pubUtils/dictionary/DicArmyBossRank.ts

@@ -0,0 +1,29 @@
+import { readJsonFile, parseGoodStr } from '../util'
+import { FILENAME } from '../../consts'
+type KeysEnum<T> = { [P in keyof Required<T>]: true };
+import { RewardInter } from '../interface';
+const _ = require('lodash');
+
+export interface DicArmyBossRank {
+    readonly id: number;
+    readonly rankMin: number;
+    readonly rankMax: number;
+    readonly reward: Array<RewardInter>;
+}
+
+const DicArmyBossRankKeys: KeysEnum<DicArmyBossRank> = {
+    id: true,
+    rankMin: true,
+    rankMax: true,
+    reward: true,
+};
+
+const str = readJsonFile(FILENAME.DIC_ARMY_BOSS_RANK_REWARD);
+let arr = JSON.parse(str);
+
+export const dicArmyBossRank = new Array<DicArmyBossRank>();
+arr.forEach(o => {
+    o.reward = parseGoodStr(o.reward);
+    dicArmyBossRank.push(_.pick(o, Object.keys(DicArmyBossRankKeys)));
+});
+arr = undefined;

shared/pubUtils/dictionary/DicArmyDevelopConsume.ts

@@ -0,0 +1,43 @@
+import { readJsonFile, parseGoodStr } from '../util'
+import { FILENAME } from '../../consts'
+type KeysEnum<T> = { [P in keyof Required<T>]: true };
+import { RewardInter } from '../interface';
+const _ = require('lodash');
+
+export interface DicArmyDevelopConsume {
+
+    readonly id: number;
+    // 目标品质
+    readonly quality: number;
+    readonly levelMin: number;
+    readonly levelMax: number;
+    readonly prePositions: Array<number>;
+    readonly honourConsume: Array<RewardInter>;
+    readonly fundConsume: number;
+    readonly timeConsume: number;
+}
+
+const DicArmyDevelopConsumeKeys: KeysEnum<DicArmyDevelopConsume> = {
+    id: true,
+    quality: true,
+    levelMin: true,
+    levelMax: true,
+    prePositions: true,
+    honourConsume: true,
+    fundConsume: true,
+    timeConsume: true
+};
+
+const str = readJsonFile(FILENAME.DIC_ARMY_DEVELOPMENTCONSUME);
+let arr = JSON.parse(str);
+
+export const dicArmyDevelopConsume = new Map<number, DicArmyDevelopConsume>();
+arr.forEach(o => {
+    o.honourConsume = parseGoodStr(o.honourConsume);
+    o.prePositions = o.preposition.split('&').map(element => {
+        return parseInt(element);
+    });
+
+    dicArmyDevelopConsume.set(o.id,_.pick(o, Object.keys(DicArmyDevelopConsumeKeys)));
+});
+arr = undefined;