全局：加载json方法全部改为最新

game-server/app/servers/activity/handler/gachaHandler.ts

@@ -1,15 +1,15 @@
 import { Application, BackendSession } from "pinus";
-import { resResult, getRandomWithWeight, getRandEelm, shouldRefresh } from "../../../pubUtils/util";
+import { resResult, getRandEelmWithWeight, shouldRefresh, getRandSingleEelm } from "../../../pubUtils/util";
 import { STATUS, GACHA_ID, HERO_QUALITY_TYPE, TASK_TYPE, REFRESH_HOUR } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { GachaListReturn, GachaResult, GachaData } from "../../../domain/activityField/gachaField";
 import { UserGachaModel } from "../../../db/UserGacha";
 import { refreshGacha, getFloorResult, getResultFromContentId } from "../../../services/gachaService";
 import { RoleModel } from "../../../db/Role";
-import { HeroModel, HeroUpdate } from "../../../db/Hero";
+import { HeroModel } from "../../../db/Hero";
 import { RewardInter } from "../../../pubUtils/interface";
 import { handleCost, createHeroes, addItems } from "../../../services/rewardService";
-import { getAfterDateByDay, getTodayZeroDate, getZeroDate } from "../../../pubUtils/timeUtil";
+import { getAfterDateByDay, getTodayZeroDate } from "../../../pubUtils/timeUtil";
 import { UserGachaRecModel } from "../../../db/UserGachaRec";
 import { ActivityModel } from "../../../db/Activity";
 import { checkTask } from "../../../services/taskService";
@@ -17,7 +17,6 @@ import { RECRUIT } from "../../../pubUtils/dicParam";
 import { getAllHeroByQuality } from "../../../services/gachaService";
 import { transPiece } from "../../../pubUtils/itemUtils";
 import { CreateHeroParam } from "../../../domain/roleField/hero";
-import roleHandler from "../../role/handler/roleHandler";
 
 export default function (app: Application) {
     return new GachaHandler(app);
@@ -82,7 +81,7 @@ export class GachaHandler {
         let items: RewardInter[] = [], heroInfo: CreateHeroParam[] = [], resultList: GachaResult[] = [];
         for (let i = 0; i < count; i++) {
             // 按照一般概率抽出
-            let { dic: { id: base } } = getRandomWithWeight(dicGacha.percent);
+            let { dic: { id: base } } = getRandEelmWithWeight(dicGacha.percent);
             let contentId = getFloorResult(gachaId, base, floor);
             if (contentId == false) return resResult(STATUS.DIC_DATA_NOT_FOUND);
             let result = getResultFromContentId(contentId, lv, hope);
@@ -184,7 +183,6 @@ export class GachaHandler {
 
         let userGacha = await UserGachaModel.findByRole(roleId, gachaId, 0);
         let { point, turntable, costPoint } = userGacha;
-        console.log('***drawTurnTable', point)
         if (point < RECRUIT.RECRUIT_BONUS_RECRUIT) return resResult(STATUS.GACHA_TURNTABLE_POINT_NOT_ENOUGH);
 
         let turntablePool: { quality: number, count: number }[] = [];
@@ -198,13 +196,13 @@ export class GachaHandler {
             turntable = []; turntablePool = gameData.gachaTurntable;
         }
 
-        let randTurntable = getRandEelm(turntablePool);
-        let { quality, count } = randTurntable[0];
+        let randTurntable = getRandSingleEelm(turntablePool);
+        let { quality, count } = randTurntable;
         // 根据品质查武将
         let pool = getAllHeroByQuality(quality);
 
-        let hero = getRandEelm(pool);
-        let contentId = gameData.gachaContentHero.get(hero[0]);
+        let hero = getRandSingleEelm(pool);
+        let contentId = gameData.gachaContentHero.get(hero);
 
         // 获得或者转成碎片
         let heroInfo: { hid: number, count: number }[] = [];

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

@@ -1,8 +1,8 @@
 import { DividendModel } from './../../../db/Dividend';
 import { Application, BackendSession, ChannelService } from "pinus";
-import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, OFFER_RATIO, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS, DIVIDEND_STATUS } from "../../../consts";
+import { AUCTION_STAGE, DEBUG_MAGIC_WORD, STATUS, OFFER_RATIO, CURRENCY_BY_TYPE, CURRENCY_TYPE, DATA_NAME, LOT_STATUS } from "../../../consts";
 import { LotModel } from "../../../db/Lot";
-import { ItemReward, LotRec } from "../../../domain/dbGeneral";
+import { ItemReward } from "../../../domain/dbGeneral";
 import { resResult } from "../../../pubUtils/util";
 import { auctionStage, calculateDividend, genAuction, sendUngotDividend, startGuildAuction, startWorldAuction, stopAuction, todayGuildBegin, getBasePrice, debugAuctionLots, officialAuctionLots, auctionBidStatus, getMaxPrice, guildBidStatus } from "../../../services/auctionService";
 import { addItems, handleCost } from '../../../services/rewardService';

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

@@ -7,14 +7,13 @@ import { difference } from 'underscore';
  * @Last Modified time: 2021-03-10 20:15:30
  */
 import { IT_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, COM_TEAM_STATUS, COM_BTL_CONST, CONSUME_TYPE, COM_BTL_QUALITY, MSG_SOURCE, QUALITY_TYPE, ROLE_SELECT, TASK_TYPE } from './../../../consts';
-import { getGoodById, getBlueprtComposeByQuality, getBluePrtByQuality, getWarById, getWarIdByBlueprtId } from '../../../pubUtils/gamedata';
 import Role, { RoleModel } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { Application, BackendSession } from 'pinus';
-import { resResult, getRandomByLen } from '../../../pubUtils/util';
-import { RoleStatus, ComBattleTeamModel, ComBattleTeamType } from '../../../db/ComBattleTeam';
-import { ItemModel } from '../../../db/Item';
-import { handleFixedReward, addItems, handleCost } from '../../../services/rewardService';
+import { resResult, getRandSingleEelm } from '../../../pubUtils/util';
+import { RoleStatus, ComBattleTeamModel, ComBattleTeamType, BossHp } from '../../../db/ComBattleTeam';
+import { ItemModel, ItemType } from '../../../db/Item';
+import { addItems, handleCost } from '../../../services/rewardService';
 import { checkRoleInQueue, rmRoleFromQueue, setTeamSearchReq } from '../../../services/redisService';
 import { getRandBlueprtId, clearComBtlTimer, getAssistTimesByQuality, getFrd, updateRobotHurtByTime, comBtlLvInvalid, clearRobotHurtTimer, setDismissTimer, dismissTeam, incEquipPrintDrop, randEquipPrintId, handleComBtlProgress, getComBattleFriendAdd, teammateInBlackList, blueprtIdValid, createComTeamData, hasEnoughBlueprt, addRoleToTeam, addRoleStToTeam, addValidSearchingRoles, validToJoin, addRobotsToTeam, addRobotsLater, teamIsFullToStart, oneTeamNotInBlack } from '../../../services/comBattleService';
 import { setAp } from '../../../services/actionPointService';
@@ -26,6 +25,7 @@ import { EXTERIOR } from '../../../pubUtils/dicParam';
 import { getTodayZeroDate } from '../../../pubUtils/timeUtil';
 import { FriendParams } from '../../../domain/roleField/friend';
 import { checkTask, checkTaskWithGoods } from '../../../services/taskService';
+import { gameData, getWarByBlueprtId } from '../../../pubUtils/data';
 
 export default function(app: Application) {
     return new ComBattleHandler(app);
@@ -126,7 +126,7 @@ export class ComBattleHandler {
             let blueprtId = getRandBlueprtId(qualityArr).pop();
             let comTeam: MemComBtlTeam = createComTeamData(teamCode, false, blueprtId, 'robot', 0)
 
-            let { quality } = getGoodById(blueprtId);
+            let { quality } = gameData.goods.get(blueprtId);
             let isFrd = await getFrd(roleId, quality);
             // 将玩家加入队伍
             addRoleToTeam(comTeam, roleInfo, false, isFrd);
@@ -179,7 +179,7 @@ export class ComBattleHandler {
         if (teamStatus.roleIds.indexOf(roleId) !== -1) return resResult(STATUS.COM_BATTLE_DUP_ENTER);
         let { lv = 1, head = EXTERIOR.EXTERIOR_FACE, topLineupCe = 0, frame = EXTERIOR.EXTERIOR_FACECASE, spine = EXTERIOR.EXTERIOR_APPEARANCE } = await Role.findByRoleId(roleId, null, true);
 
-        let { quality } = getGoodById(teamStatus.blueprtId);
+        let { quality } = gameData.goods.get(teamStatus.blueprtId);
         if (lv < COM_BTL_CONST.ENABLE_LV) {
             return resResult(STATUS.COM_BATTLE_LV_NOT_ENOUGH);
         } else if (comBtlLvInvalid(lv, teamStatus.lvRange)) {
@@ -346,7 +346,7 @@ export class ComBattleHandler {
         let channel = channelService.getChannel(teamCode, false);
         // 先推送离队消息，再将玩家从房间中移除
         channel.pushMessage('onLeaveTeam', resResult(STATUS.SUCCESS, {teamCode, roleId: roleIdToRm}));
-        let users = channel.getMembers();
+        let users: string[] = channel.getMembers();
         if (users.indexOf(roleIdToRm) !== -1) {
             channel.removeMember(roleIdToRm);
         }
@@ -455,7 +455,7 @@ export class ComBattleHandler {
             }
         }
         // 重置总血量，计算真实伤害
-        let actBossHurts = [];
+        let actBossHurts: {dataId: number, hurtHp: number}[] = [];
         let totalHurtHp = 0;
         teamStatus.bossHpArr.forEach(boss => {
             for (let bh of bossHurts) {
@@ -546,13 +546,9 @@ export class ComBattleHandler {
             }
         });
         if (roleSt.gotReward) return resResult(STATUS.COM_BATTLE_REWARDED);
-        let warInfo = getWarById(getWarIdByBlueprtId(blueprtId));
+        let warInfo = getWarByBlueprtId(blueprtId);
         if (!warInfo) return resResult(STATUS.BATTLE_MISS_INFO);
 
-        if(!warInfo.hasOwnProperty('cost')) {
-            warInfo['cost'] = 0;
-        }
-
         const now = Date.now(); // 当前时间戳
         let apJson = await setAp(now, roleId, sid, funcs, -1 * warInfo.cost); // 扣除体力
         if(!apJson) {
@@ -563,12 +559,12 @@ export class ComBattleHandler {
         if (dropResult) {
             const dropEquipId = randEquipPrintId(warInfo);
             if (dropEquipId) {
-                roleSt.fixReward = `${roleSt.fixReward}|${dropEquipId}&${1}`;
+                roleSt.fixReward.push({ id: dropEquipId, count: 1 });
             }
         }
 
         await ComBattleTeamModel.updateRewardSt(teamCode, roleId, true);
-        const goods = await handleFixedReward(roleId, roleName, sid, roleSt.fixReward, 1);
+        const goods = await addItems(roleId, roleName, sid, roleSt.fixReward);
         let actordata = await roleLevelup(roleId, warInfo.kingExp, session);// 主公升级经验
         // 任务
         await checkTaskWithGoods(roleId, sid, funcs, TASK_TYPE.COM_BATTLE_DROP, goods);
@@ -578,7 +574,7 @@ export class ComBattleHandler {
 
     async getComBtlStatus(msg: {teamCode: string}, session: BackendSession) {
         let { teamCode } = msg;
-        let roleStatus, status, bossHpArr, timeout;
+        let roleStatus: RoleStatus[], status: number, bossHpArr: BossHp[], timeout: boolean;
         let memTeam = this.teamMap.get(teamCode);
         if (memTeam) {
             ({ roleStatus, status, bossHpArr, timeout } = memTeam);
@@ -615,7 +611,7 @@ export class ComBattleHandler {
     async getBlueprtCount(msg: {ids: number[]}, session: BackendSession) {
         let roleId = session.get('roleId');
         let { ids } = msg;
-        let blueprts;
+        let blueprts: ItemType[];
         if (ids && ids.length) {
             blueprts = await ItemModel.findbyRoleAndIds(roleId, ids);
         } else {
@@ -650,7 +646,7 @@ export class ComBattleHandler {
     async getComBtlCnt(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let cntMap = await getAssistTimesByQuality(roleId);
-        let cnt = [];
+        let cnt: number[] = [];
         for (let i = 0; i < COM_BTL_QUALITY.length; ++i) {
             cnt[i] = cntMap.get(i + 1) || 0;
         }
@@ -749,7 +745,7 @@ export class ComBattleHandler {
         // 原材料检查
         let originalQuality: number, originalSum: number = 0;
         for(let {id, count} of original) {
-            const goodInfo = getGoodById(id);
+            const goodInfo = gameData.goods.get(id);
             if(!originalQuality) originalQuality = goodInfo.quality;
             if(originalQuality != goodInfo.quality) {
                 return resResult(STATUS.COM_BLUEPRT_QUALITY_ERROR);
@@ -760,7 +756,7 @@ export class ComBattleHandler {
             }
         }
 
-        const dicCompose = getBlueprtComposeByQuality(originalQuality);
+        const dicCompose = gameData.blurprtCompose.get(originalQuality);
         if(!dicCompose) {
             return resResult(STATUS.COM_BLUEPRT_QUALITY_CANNOT_COMPOSE);
         } 
@@ -777,12 +773,12 @@ export class ComBattleHandler {
         let costResult = await handleCost(roleId, sid, original);
         if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
-        const targetList = getBluePrtByQuality(dicCompose.targetQuality);
-        const target = getRandomByLen(targetList);
+        const targetList = gameData.blueprt.get(dicCompose.targetQuality);
+        const target = getRandSingleEelm(targetList);
         const reward = [{id: target, count: 1}];
         const goods = await addItems(roleId, roleName, sid, reward);
         if (dicCompose.targetQuality >= QUALITY_TYPE.ORANGE) {
-            const { name } = getGoodById(target);
+            const { name } = gameData.goods.get(target);
             pushNormalItemMsg(roleId, roleName, serverId, MSG_SOURCE.ORANGE_BLUEPRT_COMPOSE, target, name);
         }
         await checkTask(roleId, sid, funcs, TASK_TYPE.COM_BATTLE_BLUEPRT, 1, true, { quality: dicCompose.targetQuality });

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

@@ -1,6 +1,5 @@
 import { Application, BackendSession } from 'pinus';
 import { DailyRecordModel } from '../../../db/DailyRecord';
-import { getGamedata } from '../../../pubUtils/gamedata';
 import { GOLD_COST_RATIO } from '../../../consts';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult, calculateNum } from '../../../pubUtils/util';
@@ -8,6 +7,7 @@ import { RoleModel } from '../../../db/Role';
 import { getDailyNum } from '../../../services/dailyBattleService';
 import { handleCost } from '../../../services/rewardService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
+import { gameData } from '../../../pubUtils/data';
 
 export default function(app: Application) {
     return new DailyBattleHandler(app);
@@ -22,36 +22,34 @@ export class DailyBattleHandler {
         let roleId = session.get('roleId');
 
         let {warStar} = await RoleModel.findByRoleId(roleId); 
-        let dicDaily = getGamedata('dic_zyz_daily');
-        let dicDailyWar = getGamedata('dic_zyz_gk_daily');
+        let dicDaily = gameData.daily;
 
         let result = new Array();
         for(let {dailyType: type, name, timesPerDay, timesCanBuy } of dicDaily) {
             let refreshResult = await DailyRecordModel.refreshRecord(roleId, type);
-            let wars = new Array();
-            for(let {war_id, dailyType, cost, gk_name, previousGk } of dicDailyWar) {
-                if(dailyType == type) {
-                    let status = 0, star = 0;
-                    let curBattle = warStar.find(cur => cur.id == war_id);
-                    if(curBattle) {
-                        status = 2;
-                        star = curBattle.star;
-                    } else {
-                        if (previousGk) {
-                            let preBattleRecord = warStar.find(cur => cur.id == previousGk);
-                            if(preBattleRecord) {
-                                status = 1;
-                            } else {
-                                status = 0;
-                            }
-                        } else {
+            let wars: {battleId: number, cost: number, star: number, status: number, name: string}[] = new Array();
+            let dicDailyWar = gameData.dailyWarByType.get(type);
+            for(let {war_id, cost, gk_name, previousGk } of dicDailyWar) {
+                let status = 0, star = 0;
+                let curBattle = warStar.find(cur => cur.id == war_id);
+                if(curBattle) {
+                    status = 2;
+                    star = curBattle.star;
+                } else {
+                    if (previousGk) {
+                        let preBattleRecord = warStar.find(cur => cur.id == previousGk);
+                        if(preBattleRecord) {
                             status = 1;
+                        } else {
+                            status = 0;
                         }
+                    } else {
+                        status = 1;
                     }
-                    wars.push({
-                        battleId: war_id, cost, star, status, name: gk_name
-                    });
                 }
+                wars.push({
+                    battleId: war_id, cost, star, status, name: gk_name
+                });
             }
             let checkDailyResult = await getDailyNum(refreshResult, timesPerDay, timesCanBuy);
             result.push({
@@ -70,8 +68,7 @@ export class DailyBattleHandler {
         const roleId = session.get('roleId');
         const sid = session.get('sid');
 
-        const dicDaily = getGamedata('dic_zyz_daily');
-        const curDaily = dicDaily.find(cur => cur.dailyType == type);
+        const curDaily = gameData.daily.find(cur => cur.dailyType == type);
         if(!curDaily) return resResult(STATUS.DAILY_TYPE_NOT_FOUND);
         let { timesPerDay, timesCanBuy } = curDaily;
         let { buyCount = 0 } = await DailyRecordModel.refreshRecord(roleId, type);

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

@@ -3,7 +3,7 @@ import { EventRecordModel } from '../../../db/EventRecord';
 import { RoleModel } from '../../../db/Role';
 import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS, TASK_TYPE } from '../../../consts';
 import { checkEvent, checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz } from '../../../services/eventSercive';
-import { handleFixedReward, addItems } from '../../../services/rewardService';
+import { addItems } from '../../../services/rewardService';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { checkTask } from '../../../services/taskService';

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

@@ -1,5 +1,4 @@
 import { Application, BackendSession } from 'pinus';
-import { getGamedata, getWarById, hasExpeditionById } from '../../../pubUtils/gamedata';
 import { BattleRecordModel } from '../../../db/BattleRecord';
 import { ExpeditionRecordModel } from '../../../db/ExpeditionRecord';
 import { ExpeditionWarRecordModel } from '../../../db/ExpeditionWarRecord';
@@ -9,12 +8,13 @@ import { calculateSumCE, genCode } from '../../../pubUtils/util';
 import { getPointRewardStatus, getResetRemainCnt, findOrCreateEnemies } from '../../../services/expeditionService';
 import { EXPEDITION_CONST, EXPEDITION_WAR_RECORD_STATUS, LINEUP_NUM, TASK_TYPE } from '../../../consts';
 import { WarReward } from '../../../services/warRewardService';
-import { handleFixedReward } from '../../../services/rewardService';
+import { addItems } from '../../../services/rewardService';
 import { getAp, setAp } from '../../../services/actionPointService';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { checkBattleHeroes, roleLevelup } from '../../../services/normalBattleService';
 import { checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
+import { gameData } from '../../../pubUtils/data';
 
 export default function(app: Application) {
     return new ExpeditionBattleHandler(app);
@@ -127,7 +127,7 @@ export class ExpeditionBattleHandler {
         let { battleId, enemyFrom, enemies, battleStatus, ce: curCe } = curExpeditionWarRecord;
         let nextCe = 0; // 下一关战力
         
-        if(hasExpeditionById(expeditionId + 1)) {
+        if(gameData.expedition.has(expeditionId + 1)) {
             let nextExpeditionWarRecord = await findOrCreateEnemies(roleId, myCe, expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.HIDE);
             if(nextExpeditionWarRecord) nextCe = nextExpeditionWarRecord.ce;    
         }
@@ -150,7 +150,7 @@ export class ExpeditionBattleHandler {
         const { expeditionCode, expeditionId, battleId, heroes: seqIds = [] } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
-        let warInfo = getWarById(battleId);
+        let warInfo = gameData.war.get(battleId);
         if(!warInfo) {
             return resResult(STATUS.BATTLE_MISS_INFO);
         }
@@ -214,13 +214,10 @@ export class ExpeditionBattleHandler {
         let sid = session.get('sid');
         let funcs: number[] = session.get('funcs');
 
-        let warInfo = getWarById(battleId);
+        let warInfo = gameData.war.get(battleId);
         if(!warInfo) {
             return resResult(STATUS.BATTLE_MISS_INFO);
         }
-        if(!warInfo.hasOwnProperty('cost')) {
-            warInfo['cost'] = 0;
-        }
 
         const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode);
         if(!BattleRecord || BattleRecord.status != 0) {
@@ -297,8 +294,8 @@ export class ExpeditionBattleHandler {
 
         let role = await RoleModel.findByRoleId(roleId);
         let {expeditionPoint} = role;
-        let dicExpeditionPoint = getGamedata('dic_expedition_point');
-        let curDicExpeditionPoint = dicExpeditionPoint.find(cur => cur.point == point);
+        let dicExpeditionPoint = gameData.expeditionPoint;
+        let curDicExpeditionPoint = dicExpeditionPoint.get(point);
         if(!curDicExpeditionPoint) {
             return resResult(STATUS.EXPEDITION_MISS_POINT_INFO);
         }
@@ -318,12 +315,12 @@ export class ExpeditionBattleHandler {
         // 标记状态
         let {rewards: resultRewards} = await ExpeditionPointModel.updatePointStatus(roleId, point, curDicExpeditionPoint.reward);
         let hasReceivedAll = true, maxPoint = 0;
-        for(let dic of dicExpeditionPoint) {
-            let curReward = resultRewards.find(cur => cur.point == dic.point);
+        for(let [ point ] of dicExpeditionPoint) {
+            let curReward = resultRewards.find(cur => cur.point == point);
             if(!curReward || !curReward.received) {
                 hasReceivedAll = false;
             }
-            if(dic.point > maxPoint) maxPoint = dic.point;
+            if(point > maxPoint) maxPoint = point;
         }
         if(hasReceivedAll) { // 全部领取了，刷新
             await ExpeditionPointModel.completeStatus(roleId);
@@ -334,7 +331,7 @@ export class ExpeditionBattleHandler {
         // 任务
         await checkTask(roleId, sid, funcs, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1, true, { point });
 
-        let goods = await handleFixedReward(roleId, roleName, sid, curDicExpeditionPoint.reward, 1);
+        let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward);
 
         return resResult(STATUS.SUCCESS, {
             costPoint: hasReceivedAll?maxPoint: 0,

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

@@ -1,5 +1,5 @@
 import { Application, BackendSession } from 'pinus';
-import { resResult, genCode, getRandomByLen } from '../../../pubUtils/util';
+import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
 import { STATUS, TASK_TYPE, AUCTION_SOURCE } from '../../../consts';
 import { BossInstanceModel } from '../../../db/BossInstance';
 import { BattleRecordModel } from '../../../db/BattleRecord';
@@ -91,7 +91,7 @@ export class GuildHandler {
             return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
         }
         let bossBase = getBossByLv(curStructure.lv);
-        let { bossHp, warId } = getRandomByLen(bossBase.wars);
+        let { bossHp, warId } = getRandSingleEelm(bossBase.wars);
         let resGuild = await GuildModel.costFund(code, bossBase.opencost);
         if (!resGuild) {
             res.releaseCallback();

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

@@ -1,11 +1,11 @@
-import { Application, BackendSession, pinus } from 'pinus';
-import { resResult, genCode, getRandomByLen } from '../../../pubUtils/util';
+import { Application, BackendSession } from 'pinus';
+import { resResult, genCode, getRandSingleEelm } from '../../../pubUtils/util';
 import { STATUS, TASK_TYPE } from '../../../consts';
 import { GuildTrainModel } from '../../../db/GuildTrain';
 import { BattleRecordModel } from '../../../db/BattleRecord';
 import { nowSeconds, getHourPoint, getCurHourPoint } from '../../../pubUtils/timeUtil';
-import { getUserGuild, getGuildTrainInfo, unlockTrain, resetTrain, getGuildTrainRewards } from '../../../services/guildTrainService';
-import { findIndex, findWhere, indexBy } from 'underscore'
+import { getUserGuild, getGuildTrainInfo, unlockTrain, getGuildTrainRewards } from '../../../services/guildTrainService';
+import { findIndex, findWhere } from 'underscore'
 import { lockData } from '../../../services/redLockService';
 import { REFRESH_HOUR, GUILD_REPORT_NUM, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
 import { UserGuildModel } from '../../../db/UserGuild';
@@ -319,7 +319,7 @@ export class GuildTrainHandler {
             res.releaseCallback();//解锁
             return resResult(STATUS.GUILD_TRAIN_BOX_IS_GOT);
         }
-        let good = getRandomByLen(heroRewards);
+        let good = getRandSingleEelm(heroRewards);
         good.count = Math.floor((100 + shilianRewardRatio) * good.count / 100);
         let goods = await addItems(roleId, roleName, sid, [good]);
 

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

@@ -1,7 +1,6 @@
 import { Application, BackendSession } from 'pinus';
 import { BattleRecordModel } from '../../../db/BattleRecord';
 import { BattleSweepRecordModel } from '../../../db/BattleSweepRecord';
-import { getWarById,  } from '../../../pubUtils/gamedata';
 import { genCode } from '../../../pubUtils/util';
 import { WAR_TYPE, EVENT_STATUS, FUNC_OPT_TYPE, MSG_SOURCE, REDIS_KEY, TASK_TYPE } from '../../../consts';
 import { checkDaily, checkDailyAndIncrease } from '../../../services/dailyBattleService';
@@ -35,14 +34,10 @@ export class NormalBattleHandler {
         const { battleId, heroes: seqIds = [] } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
-        let warInfo = getWarById(battleId);
+        let warInfo = gameData.war.get(battleId);
         if(!warInfo) {
             return resResult(STATUS.BATTLE_MISS_INFO);
         }
-        if(!warInfo.hasOwnProperty('cost')) {
-            warInfo['cost'] = 0;
-        }
-
         let apJson = await getAp(Date.now(), roleId);
         let {ap} = apJson;
         if(ap < warInfo.cost) {
@@ -289,7 +284,7 @@ export class NormalBattleHandler {
         let roleName = session.get('roleName');
         let sid = session.get('sid');
         let funcs: number[] = session.get('funcs');
-        let warInfo = getWarById(battleId);
+        let warInfo = gameData.war.get(battleId);
         if(!warInfo) {
             return resResult(STATUS.BATTLE_MISS_INFO);
         }
@@ -301,9 +296,6 @@ export class NormalBattleHandler {
         }
 
         // 扣体力
-        if(!warInfo.hasOwnProperty('cost')) {
-            warInfo['cost'] = 0;
-        }
         const now = Date.now(); // 当前时间戳
         let apJson = await setAp(now, roleId, sid, funcs, -1 * warInfo.cost * count); // 扣除体力
         if(!apJson) {
@@ -359,7 +351,7 @@ export class NormalBattleHandler {
 
         const { battleId, type, script } = msg;
         let roleId = session.get('roleId');
-        let warInfo = getWarById(battleId);
+        let warInfo = gameData.war.get(battleId);
         let result = await RScriptRecordModel.setScript(roleId, battleId, warInfo.warType, type, script);
         if(result) {
             if(!result.scriptBefore) result.scriptBefore = '';

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

@@ -6,13 +6,14 @@ import { HangUpRecordModel } from './../../../db/HangUpRecord';
 import { RoleModel } from './../../../db/Role';
 import { TowerRecordModel } from './../../../db/TowerRecord';
 import { Application, BackendSession } from 'pinus';
-import { getTaskById, getTowerDataByLv } from '../../../pubUtils/gamedata';
-import { decodeArrayStr, resResult, shouldRefresh, calculateNum, getRefTime, genCode } from '../../../pubUtils/util';
-import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime, getTasksReward, getTaskStatus, getDoingOrWaitingTasks } from '../../../services/battleService';
-import { handleFixedReward, addItems, handleCost } from '../../../services/rewardService';
+import { resResult, shouldRefresh, calculateNum, genCode } from '../../../pubUtils/util';
+import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime, getDoingOrWaitingTasks } from '../../../services/battleService';
+import { addItems, handleCost } from '../../../services/rewardService';
 import { checkBattleHeroes } from '../../../services/normalBattleService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
 import { Rank } from '../../../services/rankService';
+import { gameData } from '../../../pubUtils/data';
+import { ItemInter } from '../../../pubUtils/interface';
 
 export default function(app: Application) {
     return new TowerBattleHandler(app);
@@ -39,10 +40,10 @@ export class TowerBattleHandler {
         }
         let towerRec = await TowerRecordModel.getRecordByLv(roleId, towerLv);
         if (!towerRec) {
-            const towerInfo = getTowerDataByLv(towerLv);
+            const towerInfo = gameData.tower.get(towerLv);
             const { warArray } = towerInfo;
-            const sts = decodeArrayStr(warArray, '&').map(id => {
-                return {warId: parseInt(id), status: false};
+            const sts = warArray.map(id => {
+                return {warId: id, status: false};
             });
             towerRec = await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
             // return { code: 201, data: '天梯记录异常' };
@@ -237,7 +238,7 @@ export class TowerBattleHandler {
             if(!curTask) {
                 return resResult(STATUS.TOWER_TASK_MISSING)
             }
-            let taskInfo = getTaskById(curTask.taskId);
+            let taskInfo = gameData.towerTask.get(curTask.taskId);
             if (task.heroes.length !== taskInfo.actorNeeded) { // 武将数，从策划表中读取
                 return resResult(STATUS.TOWER_TASK_MAX_HERO);
             }
@@ -279,26 +280,27 @@ export class TowerBattleHandler {
         if (!curTasks || curTasks.length == 0) {
             return resResult(STATUS.TOWER_TASK_NOT_FOUND);
         }
-        const compTasks = [];
-        let goods = [];
+        const compTasks: string[] = [];
+        let rewards: ItemInter[] = [];
         for (let task of curTasks) {
             if (task.batchCode !== msg.batchCode) {
                 return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
             }
             if ((allFlag || task.taskCode === msg.taskCode) && task.status === 1) {
-                let {completeTime, reward, termsForAdd, additionalReward} = getTaskById(task.taskId);
+                let {completeTime, reward, termsForAdd, additionalReward} = gameData.towerTask.get(task.taskId);
                 if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
                     compTasks.push(task.taskCode);
-                    const rewardGoods = await handleFixedReward(roleId, roleName, sid, reward, 1);
-                    goods = goods.concat(rewardGoods);
+                    rewards = rewards.concat(reward);
                     if(termsForAdd) {
                         const result = await checkTaskConditions(roleId, task.heroes, termsForAdd);
-                        const bonusGoods = await handleFixedReward(roleId, roleName, sid, result?additionalReward:'', 1);
-                        goods = goods.concat(bonusGoods);
+                        if(result) {
+                            rewards = rewards.concat(additionalReward)
+                        }
                     }
                 }
             }
         }
+        let goods = addItems(roleId, roleName, sid, rewards);
         await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
         await TowerTaskRecModel.showTask(roleId, msg.batchCode, compTasks.length);
         let refRemainTime = getRemainTime(curTime);

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

@@ -1,7 +1,7 @@
 import { Application, BackendSession, ChannelService } from 'pinus';
 import { handleCost, addItems, unlockFigure, createHero } from '../../../services/rewardService';
 import { calPlayerCeAndSave, calAllHeroCe } from '../../../services/playerCeService';
-import { resResult, returnHeroCeRatio, deepCopy } from '../../../pubUtils/util';
+import { resResult, deepCopy } from '../../../pubUtils/util';
 import { STATUS } from '../../../consts/statusCode';
 import { HeroModel, Connect } from '../../../db/Hero';
 import { CURRENCY_BY_TYPE, CURRENCY_TYPE, CONSUME_TYPE, HERO_GROW_MAX, HERO_SYSTEM_TYPE, ABI_STAGE, DEBUG_MAGIC_WORD, HERO_INITIAL_QUALITY, REDIS_KEY, TASK_TYPE } from '../../../consts';
@@ -14,8 +14,6 @@ import { pushComposeOrangeHero, pushHeroQualityUpMsg, pushHeroStarMax, pushHeroW
 import { calculatetopLineup } from '../../../pubUtils/playerCe';
 import { PvpDefenseModel } from '../../../db/PvpDefense';
 import { Attribute } from '../../../domain/roleField/attribute';
-import { nowSeconds } from '../../../pubUtils/timeUtil';
-import { Rank } from '../../../services/rankService';
 import { checkTaskWithHero, checkTask } from '../../../services/taskService';
 
 export default function (app: Application) {
@@ -26,8 +24,6 @@ export class HeroHandler {
     constructor(private app: Application) {
     }
 
-    private channelService: ChannelService = this.app.get('channelService');
-
     public async test(msg: {}, session: BackendSession) {
         let roles = await RoleModel.find({}).lean();
         for (let role of roles) {

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

@@ -1,5 +1,5 @@
 import { STATUS } from '../../../consts/statusCode';
-import Role, { RoleModel } from './../../../db/Role';
+import { RoleModel } from './../../../db/Role';
 import { HeroModel } from '../../../db/Hero';
 import { resResult, decodeIdCntArrayStr, parseGoodStr } from '../../../pubUtils/util';
 import { Application, BackendSession, pinus } from 'pinus';
@@ -19,7 +19,6 @@ import { updateUserInfo } from '../../../services/redisService';
 import { checkTaskWithHero, checkTask, checkTaskWithArgs } from '../../../services/taskService';
 import { accomplishTask } from '../../../pubUtils/taskUtil';
 import { getGoldObject, getCoinObject } from '../../../pubUtils/itemUtils';
-import { getWarById } from '../../../pubUtils/gamedata';
 import { RScriptRecordModel } from '../../../db/RScriptRecord';
 
 export default function (app: Application) {
@@ -60,7 +59,7 @@ export class RoleHandler {
         role = await RoleModel.updateRoleInfo(roleId, { hasInit: true, roleName })
 
         let battleId = SCRIPT.SCRIPT_BATTLE_ID;
-        let warInfo = getWarById(battleId);
+        let warInfo = gameData.war.get(battleId);
         await RScriptRecordModel.setScript(roleId, battleId, warInfo.warType, 2, SCRIPT.SCRIPT_NAME);
 
         return resResult(STATUS.SUCCESS, {

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

@@ -1,5 +1,5 @@
 import { Application, BackendSession, pinus } from "pinus";
-import { resResult, parseGoodStr, getRandEelm } from "../../../pubUtils/util";
+import { resResult, parseGoodStr, getRandSingleEelm } from "../../../pubUtils/util";
 import { STATUS, TASK_FUN_TYPE } from "../../../consts";
 import { gameData } from "../../../pubUtils/data";
 import { UserTaskRecModel } from "../../../db/UserTaskRec";
@@ -7,7 +7,7 @@ import { addItems } from "../../../services/rewardService";
 import { UserTaskModel } from "../../../db/UserTask";
 import { getCurWeekDate, nowSeconds } from "../../../pubUtils/timeUtil";
 import { DicDailyTask, DicAchievement, DicMainTask } from "../../../pubUtils/dictionary/DicTask";
-import { getMainTask, refDailyTaskBox, removeHistoryTask, getDailyTask, getCurTask, checkTask } from "../../../services/taskService";
+import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask } from "../../../services/taskService";
 import { TASK } from "../../../pubUtils/dicParam";
 
 export default function(app: Application) {
@@ -194,7 +194,7 @@ export class ShopHandler {
         for(let [_id, task] of gameData.tasks.get(type)) {
             tasks.push(task);
         }
-        let task = getRandEelm(tasks, 1)[0];
+        let task = getRandSingleEelm(tasks);
         await checkTask(roleId, sid, [1,2,3,4,5], task.taskType, task.condition, false, { isDebug: true });
         return resResult(STATUS.SUCCESS, {
             task

game-server/app/services/battleService.ts

@@ -5,27 +5,26 @@ import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY, TASK_TYPE } from './../con
 import { BattleRecordModel } from './../db/BattleRecord';
 import { TowerRecordModel } from './../db/TowerRecord';
 import { RoleModel } from './../db/Role';
-import { getHeroInfoById, getJobInfoById, getTowerDataByLv, getTaskById, getGamedata, getWarJsons } from "../pubUtils/gamedata"
-import { decodeArrayStr, shouldRefresh, resResult, decodeStr, cal, getRandomWithWeight, getRefTime, decodeStrSingle, genCode } from '../pubUtils/util';
+import { shouldRefresh, resResult, cal, getRandEelmWithWeight, getRefTime } from '../pubUtils/util';
 import { STATUS } from '../consts/statusCode';
 import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
 import { TowerTaskRecModel } from '../db/TowerTaskRec';
 import { cloneDeep } from 'lodash';
 import { Rank } from './rankService';
 import { checkTask } from './taskService';
-import { getRandExpedition } from '../pubUtils/data';
+import { getRandExpedition, gameData } from '../pubUtils/data';
+import { ItemInter, RewardInter } from '../pubUtils/interface';
 
 export async function checkTowerWar(roleId: string, battleId: number, heroes: Array<number>) {
-    const battleIdStr = `${battleId}`;
     let { towerLv } = await RoleModel.findByRoleId(roleId);
-    const towerInfo = getTowerDataByLv(towerLv);
+    const towerInfo = gameData.tower.get(towerLv);
     if (!towerInfo) {
         console.error(`天梯层数异常，lv ${towerLv} by ${roleId}`);
         return { status: -1, resResult: resResult(STATUS.TOWER_INFO_NOT_FOUND) };
     }
-    const warIds = decodeArrayStr(towerInfo.warArray, '&') || [];
+    const warIds = towerInfo.warArray;
 
-    if (warIds.indexOf(battleIdStr) === -1) {
+    if (warIds.indexOf(battleId) === -1) {
         return { status: -1, resResult: resResult(STATUS.TOWER_WRONG_BATTLE_ID) };
     }
 
@@ -70,24 +69,24 @@ export async function towerBattleEnd(sid: string, funcs: number[], roleId: strin
             }
         })
         let newRec = await TowerRecordModel.updateRecord(roleId, towerLv, battleCode, battleId, heroes, inc);
-        let towerReward = null;
+        let towerReward: RewardInter[] = null;
         if (inc === 1) {
             let role = await RoleModel.towerLvUp(roleId);
             // 更新redis
             let r = new Rank(REDIS_KEY.TOWER_RANK, { serverId });
             await r.setRankWithRoleInfo(roleId, towerLv + 1, role.towerUpTime.getTime(), role);
 
-            const nextTowerInfo = getTowerDataByLv(towerLv + 1);
+            const nextTowerInfo = gameData.tower.get(towerLv + 1);
             if (nextTowerInfo) {
                 const { warArray } = nextTowerInfo;
-                const sts = decodeArrayStr(warArray, '&').map(id => {
-                    return {warId: parseInt(id), status: false};
+                const sts = warArray.map(id => {
+                    return {warId: id, status: false};
                 });
 
                 await TowerRecordModel.createRecord({roleId, lv: towerLv + 1, warStatus: sts});
 
             }
-            const { reward } = getTowerDataByLv(towerLv);
+            const { reward } = gameData.tower.get(towerLv);
             if (reward) towerReward = reward;
             if (towerLv + 1 == HANG_UP_CONSTS.ENABLE_LV) {
                 await startHangUp(roleId, roleName);
@@ -129,10 +128,10 @@ export async function calcuHangUpReward(roleId: string, speedUp = false, speedUp
         return {status: -1, resResult: resResult(STATUS.TOWER_HANG_UP_NOT_START)}
     }
 
-    let towerInfo = getTowerDataByLv(towerLv - 1); // towerLv 是当前层，奖励计算按照已经通过的层，即上一层
+    let towerInfo = gameData.tower.get(towerLv - 1); // towerLv 是当前层，奖励计算按照已经通过的层，即上一层
     let timeReward = []; // 奖励
     let needReceiveGoods = []; // 由于小数，未能领取的奖励
-    let baseReward = decodeStr('decimalReward', towerInfo.rewardOfcollect);
+    let baseReward = towerInfo.rewardOfcollect;
 
     let { startTime } = await HangUpRecordModel.getCurRec(roleId);
     let endTime = curTime; // 挂机结束时间，现在到开始时间，经历了10的倍数的时间
@@ -217,7 +216,7 @@ async function checkCond(roleId: string, heroes, type: number, param: number, cn
         case 2:
             for(let seqId of heroes) {
                 let {hid} = await HeroModel.findBySeqIdAndRole(seqId, roleId);
-                const hInfo = getHeroInfoById(hid);
+                const hInfo = gameData.hero.get(hid);
                 if (hInfo.camp === param) {
                     heroCnt++;
                 }
@@ -226,8 +225,8 @@ async function checkCond(roleId: string, heroes, type: number, param: number, cn
         case 3:
             for(let seqId of heroes) {
                 let {hid} = await HeroModel.findBySeqIdAndRole(seqId, roleId);
-                const hInfo = getHeroInfoById(hid);
-                if (getJobInfoById(hInfo.jobid).job_class === param) {
+                const hInfo = gameData.hero.get(hid);
+                if (gameData.job.get(hInfo.jobid).job_class === param) {
                     heroCnt++;
                 }
             }
@@ -241,12 +240,11 @@ async function checkCond(roleId: string, heroes, type: number, param: number, cn
     return false;
 }
 
-export async function checkTaskConditions(roleId: string, heroes: Array<number>, conditionsStr: string) {
-    let condition = decodeStr('towerTaskCondition', conditionsStr);
+export async function checkTaskConditions(roleId: string, heroes: number[], condition: { type: number, param: number, count: number }[]) {
 
     let res = true;
-    for (let {type, param, cnt} of condition) {
-        const checkRes = await checkCond(roleId, heroes, type, param, cnt);
+    for (let {type, param, count} of condition) {
+        const checkRes = await checkCond(roleId, heroes, type, param, count);
         if (!checkRes) {
             res = false;
             break;
@@ -264,10 +262,9 @@ export async function checkTaskConditions(roleId: string, heroes: Array<number>,
  */
 export async function createCurTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, hideNum: number, showNum: number, rids: Array<number>) {
     let randomList = [];
-    let dicTask = getGamedata('dic_zyz_search');
-    for(let task of dicTask) {
-        let {suitFloor} = task;
-        let {min, max} = decodeStrSingle('suitLevelSingle', suitFloor); 
+    let dicTask = gameData.towerTask;
+    for(let [ _id, task] of dicTask) {
+        let {suitFloor: {min, max} } = task;
         let flag = max?(towerLv >= min && towerLv <= max): (towerLv >= min);
         if(flag) {
             randomList.push(task);
@@ -279,7 +276,7 @@ export async function createCurTasks(towerLv: number, batchCode: string, roleId:
         let taskIds = [];
         for(let i = 0; i < num; i++) {
             let list = randomList.filter(cur => !rids.includes(cur.taskId));
-            let {dic: tmp} = getRandomWithWeight(list);
+            let {dic: tmp} = getRandEelmWithWeight(list);
             if(tmp) {
                 taskIds.push(tmp.taskId);
                 rids.push(tmp.taskId)
@@ -339,14 +336,16 @@ export function getTaskStatus(status: number, completeTime: Date, curTime: Date)
 
 export async function getTasksReward(roleId: string, curTime: Date) {
     let oldTasks = await TowerTaskRecModel.getCurTasks(roleId);
-    let goods = [];
+    let goods: ItemInter[] = [];
     for(let task of oldTasks) {
-        let {completeTime, reward, termsForAdd, additionalReward} = getTaskById(task.taskId);
+        let {completeTime, reward, termsForAdd, additionalReward} = gameData.towerTask.get(task.taskId);
         if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
-            goods = goods.concat(decodeStr('fixReward', reward));
+            goods = goods.concat(reward);
             if(termsForAdd) {
                 const result = checkTaskConditions(roleId, task.heroes, termsForAdd);
-                goods = goods.concat(decodeStr('fixReward', result?additionalReward:''));
+                if(result) {
+                    goods = goods.concat(additionalReward);
+                }
             }
         }
     }
@@ -365,7 +364,7 @@ export function getRandRobot(cnt = 1, withAttr = false) {
     let robots = [];
     for (let info of setInfo) {
         if (!info || !info.warId) continue;
-        const warInfo = getWarJsons(info.warId).json;
+        const warInfo = gameData.warJson.get(info.warId);
         if (!warInfo || !warInfo.length) continue;
 
         let heroes = [];

game-server/app/services/comBattleService.ts

@@ -7,10 +7,9 @@ import { RoleModel, RoleType } from './../db/Role';
 import { EquipPrintDropType, EquipPrintDropModel } from './../db/EquipPrintDrop';
 import { FriendPointModel } from './../db/FriendPoint';
 import { STATUS } from './../consts/statusCode';
-import { COM_TEAM_STATUS, CURRENCY_BY_TYPE, CURRENCY_TYPE, FRIEND_DROP_TYPE, COM_BTL_CONST, FRIEND_DROP_MAX } from './../consts';
+import { COM_TEAM_STATUS, FRIEND_DROP_TYPE, COM_BTL_CONST, FRIEND_DROP_MAX } from './../consts';
 import { RoleStatus, ComBattleTeamModel, ComBattleTeamType } from './../db/ComBattleTeam';
-import { getBluePrtByQuality, getComBtlSetByQuality, getRewardByBlueprtId, getWarById, getWarIdByBlueprtId, comBtlRangeInfo, getGoodById, comBtlRangeByLv, getBossHpByBlueprtId } from "../pubUtils/gamedata";
-import { getRandEelm, getRandValue, resResult, ratioReward, getRandValueByMinMax, getRandomWithWeight, decodeStr, getRobotInfo } from "../pubUtils/util";
+import { getRandEelm, getRandValue, resResult, ratioReward, getRandValueByMinMax, getRandEelmWithWeight, getRobotInfo } from "../pubUtils/util";
 import { getRandRobot, transBossHpArr } from "./battleService";
 import { difference, omit } from 'underscore';
 import { Channel, ChannelService } from 'pinus';
@@ -22,6 +21,9 @@ import { getTeamSearchByQuality, rmRoleFromQueue } from './redisService';
 import { addUserToChannel } from './roleService';
 import { ChannelUser } from '../domain/ChannelUser';
 import { checkTaskInComBattleEnd } from './taskService';
+import { getRewardByBlueprtId, gameData, comBtlRangeByLv, getBossHpByBlueprtId } from '../pubUtils/data';
+import { getFriendPointObject } from '../pubUtils/itemUtils';
+import { DicWar } from '../pubUtils/dictionary/DicWar';
 
 /**
  * 在给定的品质列表中随机返回一定数量的藏宝图Id
@@ -30,9 +32,9 @@ import { checkTaskInComBattleEnd } from './taskService';
  */
 export function getRandBlueprtId(qualityArr: number[], cnt = 1) {
     if (!qualityArr || !qualityArr.length) return null;
-    let blueprtIdArr = [];
+    let blueprtIdArr: number[] = [];
     for (let q of qualityArr) {
-        blueprtIdArr = blueprtIdArr.concat(getBluePrtByQuality(q));
+        blueprtIdArr = blueprtIdArr.concat(gameData.blueprt.get(q));
     }
     if (blueprtIdArr.length === 0) return null;
     const res = getRandEelm(blueprtIdArr, cnt);
@@ -124,7 +126,7 @@ export async function checkComBattleDrop(roleId: string, battleCode: string) {
     let fixReward = getRewardByBlueprtId(team.blueprtId);
     if (!roleSt.isCap) {
         if (roleSt.isFrd) {
-            fixReward = '&';
+            fixReward = [];
         } else {
             fixReward = ratioReward(fixReward, COM_BTL_CONST.ASSIST_REWARD_RATIO);
         }
@@ -149,23 +151,22 @@ export function setComBtlTimer(teamCode: string, timer: NodeJS.Timer, timerMap:
 }
 
 export async function getRealReward(blueprtId: number, roleSt: RoleStatus) {
-    let warInfo = getWarById(getWarIdByBlueprtId(blueprtId));
-    let fixRewardStr = warInfo['fixReward'];
+    let fixReward = getRewardByBlueprtId(blueprtId);
     if (!roleSt.isCap) {
         if (roleSt.isFrd) {
             let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleSt.roleId, FRIEND_DROP_TYPE.COM_BATTLE);
             if (!frdPointRec || frdPointRec.cnt <= FRIEND_DROP_MAX.COM_BTL - COM_BTL_CONST.FRDCNT_DROP) {
-                fixRewardStr = `${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.FRIEND_POINT)}&${COM_BTL_CONST.FRDCNT_DROP}`;
+                fixReward = [getFriendPointObject(COM_BTL_CONST.FRDCNT_DROP)];
             } else if (frdPointRec.cnt < FRIEND_DROP_MAX.COM_BTL) {
-                fixRewardStr = `${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.FRIEND_POINT)}&${COM_BTL_CONST.FRDCNT_DROP - frdPointRec.cnt}`;
+                fixReward = [getFriendPointObject(COM_BTL_CONST.FRDCNT_DROP - frdPointRec.cnt)];
             } else {
-                fixRewardStr = '&';
+                fixReward = [];
             }
         } else {
-            fixRewardStr = ratioReward(fixRewardStr, COM_BTL_CONST.ASSIST_REWARD_RATIO);
+            fixReward = ratioReward(fixReward, COM_BTL_CONST.ASSIST_REWARD_RATIO);
         }
     }
-    return fixRewardStr;
+    return fixReward;
 }
 
 export async function getAssistTimesByQuality(roleId: string, qualityArr?: number[]) {
@@ -189,7 +190,7 @@ export async function getFrd(roleId: string, quality: number) {
     let isFrd = false;
     let assistTimes = await getAssistTimesByQuality(roleId, [quality]);
     let assistTime = assistTimes.get(quality);
-    let { assistanceTime } = getComBtlSetByQuality(quality);
+    let { assistanceTime } = gameData.xunbao.get(quality);
     if (assistTime >= assistanceTime) isFrd = true;
     return isFrd;
 }
@@ -232,7 +233,7 @@ function updateRobotKilled(bossHp: number, roleSt: RoleStatus) {
     }
 }
 
-export async function handleComBtlProgress(teamStatus, robotHurtTimer: Map<string, NodeJS.Timer>, teamMap: Map<string, any>, channel: Channel) {
+export async function handleComBtlProgress(teamStatus: MemComBtlTeam, robotHurtTimer: Map<string, NodeJS.Timer>, teamMap: Map<string, MemComBtlTeam>, channel: Channel) {
     const { teamCode, roleIds, capId, quality } = teamStatus;
     // 判断战斗是否结束
     let battleSt = checkComBattleResult(teamStatus);
@@ -272,7 +273,7 @@ export async function handleComBtlProgress(teamStatus, robotHurtTimer: Map<strin
  * @param {*} teamStatus 要更新的队伍信息
  * @param {RoleStatus} roleSt 要更新的玩家信息
  */
-export function updateRobotHurt(teamStatus, roleSt: RoleStatus, channel: Channel) {
+export function updateRobotHurt(teamStatus: MemComBtlTeam, roleSt: RoleStatus, channel: Channel) {
     // 机器人的伤害为：boss 血量的一定比例，平均到一定回合数内，再平均到每个敌军，上下浮动一定比例
     let eachHurtHp = robotEachHurt(teamStatus.bossHp, teamStatus.bossHpArr.length);
     let robotTotalHurt = 0;
@@ -305,7 +306,7 @@ export function updateRobotHurt(teamStatus, roleSt: RoleStatus, channel: Channel
  * @param {Channel} channel
  * @param {Map<string, NodeJS.Timer>} robotHurtTimer
  */
-export function updateRobotHurtByTime(teamStatus, roleSt: RoleStatus, interval: number, channel: Channel, robotHurtTimer: Map<string, NodeJS.Timer>, teamMap: Map<string, any>) {
+export function updateRobotHurtByTime(teamStatus: MemComBtlTeam, roleSt: RoleStatus, interval: number, channel: Channel, robotHurtTimer: Map<string, NodeJS.Timer>, teamMap: Map<string, MemComBtlTeam>) {
     const timerKey = `${teamStatus.teamCode}_${roleSt.roleId}`;
     const robotTimer = setInterval(() => {
         const robotTotalHurt = teamStatus.bossHp * COM_BTL_CONST.ROBOT_HURT_RATIO;
@@ -344,13 +345,13 @@ export function clearRobotHurtTimer(teamStatus, robotHurtTimer: Map<string, Node
  * @returns
  */
 export function comBtlLvInvalid(lv: number, lvRange: number) {
-    const lvs = comBtlRangeInfo(lvRange);
+    const lvs = gameData.comBtlLvRange.get(lvRange);
     if (!lvs) return true;
     const minLv = lvs[0];
     return lv < minLv;
 }
 
-export async function dismissTeam(teamStatus, teamMap: Map<string, any>, roleId: string, teamDisTimer: Map<string, NodeJS.Timer>, channel) {
+export async function dismissTeam(teamStatus: MemComBtlTeam, teamMap: Map<string, MemComBtlTeam>, roleId: string, teamDisTimer: Map<string, NodeJS.Timer>, channel) {
     const { teamCode } = teamStatus;
     if (!teamStatus || !teamStatus.roleIds || teamStatus.roleIds.indexOf(roleId) === -1) return resResult(STATUS.COM_BATTLE_TEAM_INVALID);
     if (teamStatus.status !== COM_TEAM_STATUS.DEFAULT) return resResult(STATUS.COM_BATTLE_DISSMISS_ERR);
@@ -368,7 +369,7 @@ export async function dismissTeam(teamStatus, teamMap: Map<string, any>, roleId:
     return resResult(STATUS.SUCCESS);
 }
 
-export function setDismissTimer(teamStatus, teamMap: Map<string, any>, roleId: string, teamDisTimer: Map<string, NodeJS.Timer>, channel) {
+export function setDismissTimer(teamStatus: MemComBtlTeam, teamMap: Map<string, MemComBtlTeam>, roleId: string, teamDisTimer: Map<string, NodeJS.Timer>, channel) {
     if (teamIsFullToStart(teamStatus)) {
         clearComBtlTimer(teamStatus.teamCode, teamDisTimer);
         let timer = setTimeout(async () => {
@@ -428,12 +429,11 @@ export async function incEquipPrintDrop(roleSt: RoleStatus) {
     return { dropResult, dropRec };
 }
 
-export function randEquipPrintId(warInfo) {
-    if (!warInfo || !warInfo['jackpotReward']) {
+export function randEquipPrintId(warInfo: DicWar) {
+    if (!warInfo || !warInfo.jackpotReward) {
         return null;
     }
-    let jackpotReward: { id: number, weight: number}[] = decodeStr('possibility', warInfo['jackpotReward']);
-    const result = getRandomWithWeight(jackpotReward);
+    const result = getRandEelmWithWeight(warInfo.jackpotReward);
     if (!result || !result.dic || !result.dic.id) {
         return null;
     }
@@ -521,7 +521,7 @@ export async function teammateInBlackList(roleId: string, roleIds: string[]) {
 }
 
 export function blueprtIdValid(id: number) {
-    const goodData = getGoodById(id);
+    const goodData = gameData.goods.get(id);
     return goodData && goodData.itid === IT_TYPE.BLUEPRT && COM_BTL_QUALITY.indexOf(goodData.quality) !== -1;
 }
 
@@ -540,7 +540,7 @@ export function blueprtIdValid(id: number) {
  * @returns
  */
 export function createComTeamData(teamCode: string, pub: boolean, blueprtId: number, capId: string, ceLimit: number) {
-    const { lvLimited, quality } = getGoodById(blueprtId);
+    const { lvLimited, quality } = gameData.goods.get(blueprtId);
     const lvRange = comBtlRangeByLv(lvLimited);
     const { bossHpSum, bossHpArr } = getBossHpByBlueprtId(blueprtId);
     const curRnd = 0;
@@ -605,7 +605,7 @@ export function addRoleStToTeam(comTeam: MemComBtlTeam, roleSt: RoleStatus) {
  * @returns
  */
 export async function addValidSearchingRoles(comTeam: MemComBtlTeam, channelService: ChannelService) {
-    const { quality, lvLimited } = getGoodById(comTeam.blueprtId);
+    const { quality, lvLimited } = gameData.goods.get(comTeam.blueprtId);
     let teammates = await getTeamSearchByQuality(quality, comBtlRangeByLv(lvLimited));
     if (teammates && teammates.length) {
         for (let teammate of teammates) {
@@ -650,7 +650,7 @@ export function teamIsFullToStart(comTeam: MemComBtlTeam) {
  * @param {number} roleLv 真实玩家等级，用来做机器人等级基准
  * @param {number} [count=1]
  */
-export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, roleCe: number, roleLv: number, teamMap: Map<string, any>, teamDisTimer: Map<string, NodeJS.Timer>, channel: Channel, count = 1) {
+export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, roleCe: number, roleLv: number, teamMap: Map<string, MemComBtlTeam>, teamDisTimer: Map<string, NodeJS.Timer>, channel: Channel, count = 1) {
     const { teamCode } = comTeam;
     const { robotStArr, robotIdArr } = getRandComBtlRobots(roleCe, comTeam.ceLimit, roleLv, count);
     for (let st of robotStArr) {
@@ -666,11 +666,11 @@ export async function addRobotsToTeam(comTeam: MemComBtlTeam, roleId: string, ro
  * @export
  * @param {MemComBtlTeam} comTeam
  * @param {RoleType} roleInfo
- * @param {Map<string, any>} teamMap
+ * @param {Map<string, MemComBtlTeam>} teamMap
  * @param {Map<string, NodeJS.Timer>} teamDisTimer
  * @param {Channel} channel
  */
-export async function addRobotsLater(comTeam: MemComBtlTeam, roleInfo: RoleType, teamMap: Map<string, any>, teamDisTimer: Map<string, NodeJS.Timer>, channel: Channel) {
+export async function addRobotsLater(comTeam: MemComBtlTeam, roleInfo: RoleType, teamMap: Map<string, MemComBtlTeam>, teamDisTimer: Map<string, NodeJS.Timer>, channel: Channel) {
     const teamStatus = comTeam;
     const { teamCode } = teamStatus;
     const { roleId, lv } = roleInfo;

game-server/app/services/dailyBattleService.ts

@@ -3,20 +3,18 @@
  */
 
 import DailyRecord, { DailyRecordModel } from '../db/DailyRecord';
-import { getGamedata } from '../pubUtils/gamedata';
 import { resResult } from '../pubUtils/util';
 import { STATUS } from '../consts/statusCode';
 import { RoleModel } from '../db/Role';
+import { gameData } from '../pubUtils/data';
 
 // 检查每日本次数checkBattle使用
 export async function checkDaily(roleId: string, battleId: number, inc: number) {
-    let dicDaily = getGamedata('dic_zyz_daily');
-    let dicDailyWar = getGamedata('dic_zyz_gk_daily');
-    let dailyWar = dicDailyWar.find(cur => cur.war_id == battleId);
+    let dailyWar = gameData.war.get(battleId);
     if(!dailyWar) return { status: -1, resResult: resResult(STATUS.DAILY_WAR_NOT_FOUND) };
     let type = dailyWar.dailyType;
 
-    let curDaily = dicDaily.find(cur => cur.dailyType == type);
+    let curDaily = gameData.daily.find(cur => cur.dailyType == type);
     if(!curDaily) return { status: -1, resResult: resResult(STATUS.DAILY_TYPE_NOT_FOUND) };
     let dailyRecord = await DailyRecordModel.refreshRecord(roleId, type);
     let { count = 0, buyCount = 0 } = dailyRecord;
@@ -36,13 +34,11 @@ export async function checkDaily(roleId: string, battleId: number, inc: number)
  */
 
 export async function checkDailyAndIncrease(roleId: string, battleId: number, inc: number, isRef: boolean) {
-    let dicDaily = getGamedata('dic_zyz_daily');
-    let dicDailyWar = getGamedata('dic_zyz_gk_daily');
-    let dailyWar = dicDailyWar.find(cur => cur.war_id == battleId);
+    let dailyWar = gameData.war.get(battleId);
     if(!dailyWar) return { status: -1, resResult: resResult(STATUS.DAILY_WAR_NOT_FOUND) };
     let type = dailyWar.dailyType;
 
-    let curDaily = dicDaily.find(cur => cur.dailyType == type);
+    let curDaily = gameData.daily.find(cur => cur.dailyType == type);
     if(!curDaily) return { status: -1, resResult: resResult(STATUS.DAILY_TYPE_NOT_FOUND) };
 
     let dailyRecord: any;
@@ -63,8 +59,7 @@ export async function checkDailyAndIncrease(roleId: string, battleId: number, in
 export async function getDailyNum(dailyRecord: DailyRecord, timesPerDay?: number, timesCanBuy?: number) {
     let {roleId, type, count = 0, buyCount = 0} = dailyRecord;
     if(!timesPerDay || !timesCanBuy) {
-        const dicDaily = getGamedata('dic_zyz_daily');
-        const curDaily = dicDaily.find(cur => cur.dailyType == type);
+        const curDaily = gameData.daily.find(cur => cur.dailyType == type);
         timesPerDay = curDaily.timesPerDay;
         timesCanBuy = curDaily.timesCanBuy;
     }

game-server/app/services/eventSercive.ts

@@ -1,12 +1,12 @@
 import { FrontendOrBackendSession, pinus } from 'pinus';
-import { getGamedata } from '../pubUtils/gamedata';
 import EventRecord, { EventRecordModel } from '../db/EventRecord';
 import { RoleModel } from '../db/Role';
-import { genCode, decodeStrSingle, decodeStr, getRandomWithWeight, resResult } from '../pubUtils/util';
+import { genCode, getRandEelmWithWeight, resResult, getRandSingleEelm } from '../pubUtils/util';
 import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_TYPE, EVENT_RANDOM_TYPE_ONE_OPEN, EVENT_QUIZ_NUM, EVENT_ANSWER_STATUS, FUNCS_ID } from '../consts';
 import { EVENT_REFRESH_NUM } from '../consts';
 import { STATUS } from '../consts/statusCode';
 import { gameData } from '../pubUtils/data';
+import { DicQuestion } from '../pubUtils/dictionary/DicQuestion';
 
 /**
  * 从检查接口调用，检查是否有这么个战斗，顺便保存一下battleCode
@@ -235,7 +235,7 @@ export async function refreshEvent(num: number, roleId: string, roleName: string
         let randomList = dicEvent;
         let curPoint = new Array<number>();
         for(let i = 0; i < num; i++) {
-            let {dic} = getRandomWithWeight(randomList);
+            let {dic} = getRandEelmWithWeight(randomList);
             // 临时处理，不出现相同的关卡id
             for(let x = 0; x < 1000; x++) {
                 let hasEvent = event.find(cur => {
@@ -243,7 +243,7 @@ export async function refreshEvent(num: number, roleId: string, roleName: string
                 let hasPreEvent = preEvents.find(cur => {
                     return cur.type == EVENT_TYPE.BATTLE && cur.battleId == dic.warId});
                 if(!hasEvent && !hasPreEvent) break;
-                dic = getRandomWithWeight(randomList).dic;
+                dic = getRandEelmWithWeight(randomList).dic;
             }
 
             // if(!dic) break;
@@ -377,14 +377,16 @@ export function checkQuizParam(param: Array<number>, database?:  Array<{id: numb
  * @param num 题目数量
  */
 function randomQuestion(num: number) {
-    let questions = getGamedata('Questions');
+    let questions = new Array<DicQuestion>();
+    gameData.question.forEach(cur => {
+        questions.push(cur);
+    });
     let rid:Array<number> = [], result = [];
     while(num > 0) {
-        let index = Math.floor(Math.random() * questions.length);
-        let {id, question, a1, a2, a3, a4, correct} = questions[index];
+        let dicQuestion = getRandSingleEelm(questions);
+        let {id, question, answer, correct} = dicQuestion;
         if(rid.includes(id)) continue;
         rid.push(id);
-        let answer = [a1, a2, a3, a4].filter(cur => cur);
         result.push({id, question, answer, correct});
         num--;
     }
@@ -398,8 +400,7 @@ function randomQuestion(num: number) {
  * @param answer 
  */
 export function checkQuiz(id: number, answer: number) {
-    let questions = getGamedata('Questions');
-    let result = questions[id - 1];
+    let result = gameData.question.get(id);
 
     return {
         isCorrect: !!result && result.correct == answer,

game-server/app/services/expeditionService.ts

@@ -3,10 +3,8 @@ import { ExpeditionPointModel } from '../db/ExpeditionPoint';
 import Role, { RoleModel, RoleType } from '../db/Role';
 import { PvpDefenseModel } from '../db/PvpDefense';
 
-import { getWarJsons, getGamedata } from '../pubUtils/gamedata';
-import { decodeStr, shouldRefresh } from '../pubUtils/util';
-import { EXPEDITION_CONST, HERO_CE_RATIO } from '../consts';
-import { getAtrrNameById} from '../consts';
+import { shouldRefresh } from '../pubUtils/util';
+import { EXPEDITION_CONST } from '../consts';
 import { ExpeditionWarRecordModel } from '../db/ExpeditionWarRecord';
 import { HeroType } from '../db/Hero';
 import { gameData } from '../pubUtils/data';
@@ -80,7 +78,7 @@ export async function findOrCreateEnemies(roleId: string, myCe: number, expediti
  * @param enemyObj 返回的敌军数据
  */
 export async function matchPlayers(roleId: string, scale: number, range: number, myCe: number, warJsonIndex:any, enemyObj: {enemyFrom: number, enemyId: string, enemies: Array<any>, ce: number }) {
-    let {json: dicWarJson } = getWarJsons(warJsonIndex);
+    let dicWarJson = gameData.warJson.get(warJsonIndex);
 
     let min = myCe * scale * (1 - range/100);
     let max = myCe * scale * (1 + range/100);
@@ -183,12 +181,13 @@ export async function getPointRewardStatus(roleId: string, role?: Role) {
         role = await RoleModel.findByRoleId(roleId);
     }
     let {expeditionPoint = 0} = role;
-    let dicExpeditionPoint = getGamedata('dic_expedition_point');
+    let dicExpeditionPoint = gameData.expeditionPoint;
+    let rewards: { point: number, received: boolean }[] = [];
+    for(let [point] of dicExpeditionPoint) {
+        rewards.push({ point, received: false })
+    }
     let pointRewards = {
-        expeditionPoint,
-        rewards: dicExpeditionPoint.map(cur => {
-            return { point: cur.point, received: false }
-        })
+        expeditionPoint, rewards
     };
     let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
     if(pointStatusInDatabase) {

game-server/app/services/gachaService.ts

@@ -2,7 +2,7 @@ import { GachaData, Floor, GachaResult, Hope } from "../domain/activityField/gac
 import { ActivityModel } from "../db/Activity";
 import { DicGacha } from "../pubUtils/dictionary/DicGacha";
 import { UserGachaType, UserGachaModel } from "../db/UserGacha";
-import { shouldRefresh, getRandEelm, getRandomWithWeight } from "../pubUtils/util";
+import { shouldRefresh, getRandEelm, getRandEelmWithWeight } from "../pubUtils/util";
 import { REFRESH_HOUR, GACHA_TO_FLOOR, GACHA_FLOOR_TYPE, GACHA_CONTENT_TYPE, HERO_QUALITY_TYPE, GACHA_OCCUPY_HID, IT_TYPE, ITID, CONSUME_TYPE, SPECIAL_ATTR } from "../consts";
 import { getNextDayByGap, getTodayZeroDate } from "../pubUtils/timeUtil";
 import { gameData, getDicGachaFloor } from "../pubUtils/data";
@@ -200,7 +200,7 @@ function getPoolByHope(hope: Hope[], qualtiy: number) {
         let list = gameData.gachaHope.map(cur => {
             return {...cur, hasGet: hopeMap.get(cur.id)?.hasGet||false};
         })
-        let { dic: { id, hasGet } } = getRandomWithWeight(list);
+        let { dic: { id, hasGet } } = getRandEelmWithWeight(list);
         if(id == 0 || hasGet) {
             return getAllHeroByQuality(qualtiy).filter(cur => !hasGetHope.includes(cur) );
         } else {

game-server/app/services/guildTrainService.ts

@@ -9,7 +9,7 @@ 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 { resResult, getRandSingleEelm } from '../pubUtils/util';
 import { STATUS } from '../consts/statusCode';
 import { GuildTrainReportModel } from '../db/GuildTrainReport';
 import { DATA_NAME } from '../consts/dataName';
@@ -131,14 +131,16 @@ export async function resetTrain(code: string, serverId: number) {
     let { shilianRewardRatio } = getTrainBaseByLv(GUILD_STRUCTURE.TRAIN);
     //结算未领取的宝箱奖励发送到邮件中
     userGuildList.forEach(async function ({roleId, trainRewards}) {
-        let goods = [];
+        let goods: { id: number, count: number }[] = [];
         guildTrains.forEach(guildTrain=>{
             guildTrain.trainInstances.forEach(({ trainBoxs })=>{
                 if (!findWhere(trainBoxs, {roleId})) {
                     let { heroRewards } = getArmyTrainJuDian(guildTrain.trainId);
-                    let good = getRandomByLen(heroRewards);
-                    good.count = Math.floor((100 + shilianRewardRatio) * good.count/100);
-                    goods.push(good);
+                    let good = getRandSingleEelm(heroRewards);
+                    goods.push({
+                        id: good.id,
+                        count: Math.floor((100 + shilianRewardRatio) * good.count/100)
+                    });
                 }
             })
         });

game-server/app/services/normalBattleService.ts

@@ -38,7 +38,7 @@ export async function roleLevelup(roleId: string, kingExp: number, session: Back
         await accomplishTask(roleId, TASK_TYPE.ROLE_LV, newLv);
 
     }
-    let actordata = [];
+    let actordata: {lv: number, exp: number, getExp: number, mostExp: number}[] = [];
     for (let i = lv; i <= newLv; i++) {
         let lvObj = getExpByLv(i);
 

game-server/app/services/pvpService.ts

@@ -4,7 +4,7 @@ import { RoleType } from '../db/Role';
 import { PVP_HERO_POS, REDIS_KEY, PVP_CONST } from '../consts';
 import { setPvpDefResult } from '../services/timeTaskService';
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
-import { getRandomIndexByLen, genCode, shouldRefresh, reduceCe, getChineseName } from '../pubUtils/util';
+import { getRandSingleIndex, genCode, shouldRefresh, reduceCe, getChineseName } from '../pubUtils/util';
 import { oppPlayersInter, pvpEndParamInter } from '../pubUtils/interface';
 import { gameData, getPLvByScore } from "../pubUtils/data";
 import { PVP } from '../pubUtils/dicParam';
@@ -186,13 +186,13 @@ async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJs
     });
     if(range.length <= 0) return false;
 
-    let index = getRandomIndexByLen(range.length);
+    let index = getRandSingleIndex(range.length);
     let result = range[index]; // 本次匹配结果 pvpdefense
     if(!result) return false;
     if(result.roleId == roleId) {
         range.splice(index, 1);
         if(range.length <= 0) return false;
-        index = getRandomIndexByLen(range.length);
+        index = getRandSingleIndex(range.length);
         result = range[index];
     }
     let pvpHistoryOpp = await generPlayerOppHis(result, mapWarJson, roleId, pos);
@@ -258,7 +258,7 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
     let range = gameData.pvpWar;
     if(range.length <= 0) return false;
 
-    let index = getRandomIndexByLen(range.length);
+    let index = getRandSingleIndex(range.length);
     let result = range[index];
     if(!result) return false;
 

game-server/app/services/redisService.ts

@@ -5,7 +5,7 @@ import { GameModel } from "../db/Game";
 import { promisifyAll } from 'bluebird';
 import { pinus } from 'pinus';
 import { GuildRankParam, GuildLeader, RankParam, LineupParam } from '../domain/rank';
-import { comBtlRanges } from '../pubUtils/gamedata';
+import { comBtlRanges } from '../pubUtils/data';
 import { setRankRedisFromDb } from './rankService';
 /**
  * 在服务重新启动时，将信息存入redis

game-server/app/services/rewardService.ts

@@ -1,7 +1,6 @@
 import { ITID, CONSUME_TYPE, getCurNameById, ITEM_TABLE, HERO_SYSTEM_TYPE, CURRENCY_BY_TYPE, FIGURE_UNLOCK_CONDITION, REDIS_KEY } from './../consts';
 import { EquipModel } from './../db/Equip';
-import { resResult, parseGoodStr } from '../pubUtils/util';
-import { getGoodById } from '../pubUtils/gamedata';
+import { resResult } from '../pubUtils/util';
 import { RoleModel, RoleType } from '../db/Role';
 import { setAp } from './actionPointService';
 import { calAllHeroCe, pushCalPlayerCe, pushCalAllHeroCe } from './playerCeService';
@@ -9,24 +8,15 @@ import { ItemModel } from '../db/Item';
 import { STATUS } from '../consts/statusCode';
 import { pinus } from 'pinus';
 import { addEquips, addBags, addSkins, addFigure, unlockFigure as pubUnlockFigure, createHeroes as pubCreateHeroes, transPiece } from '../pubUtils/itemUtils';
-import { EquipInter, ItemInter, BagInter, RewardInter } from '../pubUtils/interface';
+import { EquipInter, ItemInter, BagInter } from '../pubUtils/interface';
 import { gameData } from '../pubUtils/data';
 import { uniq, indexOf, findIndex } from 'underscore';
-import { HeroModel, HeroUpdate, HeroType } from '../db/Hero';
+import { HeroModel, HeroType } from '../db/Hero';
 import { Figure } from '../domain/dbGeneral';
 import { Rank } from './rankService';
 import { pushTaskUpdate } from './taskService';
 import { CreateHeroParam } from '../domain/roleField/hero';
 
-export async function handleFixedReward(roleId: string, roleName: string, sid: string, rewardStr: string, multi: number) {
-    let reward = parseGoodStr(rewardStr);
-    let rewards = [];
-    for (let obj of reward)
-        rewards.push({ ...obj, count: Math.ceil(obj.count * multi) });
-    const result = await addItems(roleId, roleName, sid, reward);
-    return result;
-}
-
 export async function handleCost(roleId: string, sid: string, goods: Array<ItemInter>) {
     let currencysMap: any = {};
     let equips: Array<number> = [];
@@ -75,7 +65,7 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
 function sortConsumes(goods: Array<ItemInter>, bags: Array<ItemInter>, currencysMap: any, equips: Array<number>) {
     for (let good of goods) {
         if(good.count == 0) continue;
-        let goodInfo = getGoodById(good.id);
+        let goodInfo = gameData.goods.get(good.id);
         let { type, table } = ITID.get(goodInfo.itid);
 
         if (table == ITEM_TABLE.EQUIP) {
@@ -256,7 +246,7 @@ export async function checkGoods(roleId: string, goodIds: Array<number>) {
     let hids: Array<number> = [];
     goodIds = uniq(goodIds);
     for (let goodId of goodIds) {
-        let goodInfo = getGoodById(goodId);
+        let goodInfo = gameData.goods.get(goodId);
         if (!!goodInfo) {
             let { table } = ITID.get(goodInfo.itid);
             if (table == ITEM_TABLE.EQUIP) {

game-server/app/services/roleService.ts

@@ -1,8 +1,7 @@
 import { ChannelUser } from './../domain/ChannelUser';
 import { Channel } from 'pinus';
-import { getRandNum, getRandomArr } from '../pubUtils/util';
+import { getRandValueByMinMax, getRandEelm } from '../pubUtils/util';
 import { TERAPH_RANDOM } from "../consts";
-import { indexOf } from 'underscore';
 import { DicTeraph } from '../pubUtils/dictionary/DicTeraph';
 import { Teraph, RoleModel } from '../db/Role';
 import { ROLE_SELECT } from '../consts';
@@ -22,9 +21,9 @@ export function checkTeraphMaterialEnough(count: number, attrs:number[], teraphI
             if (!attrs.length) {
                 break;
             }
-            let num = getRandNum(TERAPH_RANDOM.MIN, TERAPH_RANDOM.MAX); // 强化时随机增加 2-4 属性
-            let arr: number[] = getRandomArr(attrs, num); // 随机出的属性id
-            let critical = getRandNum(0, 100);//属性暴击率
+            let num = getRandValueByMinMax(TERAPH_RANDOM.MIN, TERAPH_RANDOM.MAX); // 强化时随机增加 2-4 属性
+            let arr = getRandEelm(attrs, num); // 随机出的属性id
+            let critical = getRandValueByMinMax(0, 100);//属性暴击率
             let criEffect = 1; // 暴击效果
             if (critical <= teraphInfo.criRate) 
                 criEffect = teraphInfo.criEffect;
@@ -42,18 +41,18 @@ export function checkTeraphMaterialEnough(count: number, attrs:number[], teraphI
             times++;
         }
     } else if (count == 10){
-        let criticalArrTimes = getRandomArr(TERAPH_STRENGTHEN, 2);//10次中随机2次发生暴击
+        let criticalArrTimes = getRandEelm(TERAPH_STRENGTHEN, 2);//10次中随机2次发生暴击
         for (let item of TERAPH_STRENGTHEN) {
             if (!attrs.length) {
                 break;
             }
             let criEffect = 1;
-            let index = indexOf(criticalArrTimes, {item});
+            let index = criticalArrTimes.indexOf(item)
             if (index > 0) {
                 criEffect = teraphInfo.criEffect;//本次是暴击 item 在 criticalArrTimes 中
             }
-            let num = getRandNum(TERAPH_RANDOM.MIN, TERAPH_RANDOM.MAX);
-            let arr: number[] = getRandomArr(attrs, num);
+            let num = getRandValueByMinMax(TERAPH_RANDOM.MIN, TERAPH_RANDOM.MAX);
+            let arr: number[] = getRandEelm(attrs, num);
             for (let attrId of arr) {
                 let val = teraph.attr.get(attrId); // 已有的强化值
                 val += teraphInfo.mainAttrUp.get(attrId) * criEffect;

game-server/app/services/timeTaskService.ts

@@ -5,7 +5,7 @@ import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
 import { PVP } from '../pubUtils/dicParam';
 import { nowSeconds, getTodayZeroPoint, getAge } from '../pubUtils/timeUtil';
 import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards, getResultMaxRank, getTodayGuildActivity } from '../pubUtils/data';
-import { deepCopy, getRandomArr, resResult } from '../pubUtils/util';
+import { deepCopy, resResult, getRandSingleEelm } from '../pubUtils/util';
 import { getLvByScore } from './pvpService';
 import { getAllOnlineRoles, getAllServers, initSingleRank, delGuildActivityRank } from './redisService';
 import { MAIL_TYPE, REDIS_KEY, ADULT_AGE, GUEST_MAX_TIME, ADDICTION_PREVENTION_CODE, GUILD_ACTIVITY_STATUS, GUILD_ACTIVITY_TYPE, TASK_TYPE } from '../consts';
@@ -223,13 +223,12 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
 export async function resetPvpWarId() {
     // console.log('resetPvpWarId');
     let systemConfig = await SystemConfigModel.findSystemConfig();
-    let warIds = deepCopy(getPvpGkWarIds());
+    let warIds: number[] = deepCopy(getPvpGkWarIds());
     let index = indexOf(warIds, systemConfig.warId);
     if (index != -1) {
         warIds.splice(index, 1);
     }
-    let res = getRandomArr(warIds, 1);
-    let warId = res[0];
+    let warId = getRandSingleEelm(warIds);
     return await SystemConfigModel.updateSystemConfig({ warId });
 }
 /**

game-server/app/services/warRewardService.ts

@@ -4,13 +4,14 @@
  */
 
 import { BattleDropModel } from '../db/BattleDrop';
-import { getWarById, getBluePrtByQuality, getGamedata } from '../pubUtils/gamedata';
-import { decodeStr, getRefTime, getRandomWithWeight, getRandomByLen } from '../pubUtils/util';
+import { getRefTime, getRandEelmWithWeight, getRandSingleEelm } from '../pubUtils/util';
 import { BATTLE_REWARD_TYPE, BLUEPRT_CONST } from '../consts';
 import { addItems } from './rewardService';
 import { BattleBlueprtDropModel } from '../db/BattleBlueprtDrop'
 import { RoleModel } from '../db/Role';
 import { gameData } from '../pubUtils/data';
+import { DicWar } from '../pubUtils/dictionary/DicWar';
+import { RewardInter } from '../pubUtils/interface';
 
 export class WarReward {
     private roleId: string;
@@ -18,12 +19,12 @@ export class WarReward {
     private sid: string;
     private battleId: number;
     private condition: Map<number, boolean>;
-    private warInfo: any;
+    private warInfo: DicWar;
     private isSuccess: boolean;
     private rewards: Array<{type: number, id: number, count: number, times: number}>;
-    private fixReward: string;
-    private conditionReward: string;
-    private randomReward: string;
+    private fixReward: Array<{id: number, count: number}>;
+    private conditionReward: Array<{id: number, count: number, condition: number}>;
+    private randomReward: Array<{id: number, count: number, frequency: number}>;
     private costAp: number;
 
     constructor(roleId: string, roleName: string, sid: string, battleId: number, isSuccess: boolean) {
@@ -32,12 +33,12 @@ export class WarReward {
         this.sid = sid;
         this.battleId = battleId;
         this.condition = new Map();
-        this.warInfo = getWarById(battleId);
+        this.warInfo = gameData.war.get(battleId);
 
-        let {fixReward = '', conditionReward = '', RandomReward = ''} = this.warInfo;
+        let { fixReward, conditionReward, randomReward } = this.warInfo;
         this.fixReward = fixReward;
         this.conditionReward = conditionReward;
-        this.randomReward = RandomReward;
+        this.randomReward = randomReward;
 
         this.isSuccess = isSuccess;
         this.costAp = this.warInfo.cost;
@@ -47,55 +48,38 @@ export class WarReward {
         this.condition.set(id, isOk);
     }
 
-    public setFixReward(reward: string) {
-        let str = this.fixReward;
-        let last = str.substr(str.length-1, 1);
-        if(last == '&') str = str.substr(0, str.length - 1);
-        if(str.length) {
-            this.fixReward = str + '|' + reward;
-        } else {
-            this.fixReward = str + reward;
+    public setFixReward(reward: RewardInter[]) {
+        for(let r of reward) {
+            this.fixReward.push(r);
         }
     }
 
-    public resetFixReward(reward: string) {
+    public resetFixReward(reward: RewardInter[]) {
         this.fixReward = reward;
     }
 
-    public setConditionReward(reward: string) {
-        let str = this.conditionReward;
-        let last = str.substr(str.length-1, 1);
-        if(last == '&') str = str.substr(0, str.length - 1);
-        if(str.length) {
-            this.conditionReward = str + '|' + reward;
-        } else {
-            this.conditionReward = str + reward;
+    public setConditionReward(reward: {id: number, count: number, condition: number}[]) {
+        for(let r of reward) {
+            this.conditionReward.push(r);
         }
     }
 
-    public setRandomReward(reward: string) {
-        let str = this.randomReward;
-        let last = str.substr(str.length-1, 1);
-        if(last == '&') str = str.substr(0, str.length - 1);
-        if(str.length) {
-            this.randomReward = str + '|' + reward;
-        } else {
-            this.randomReward = str + reward;
+    public setRandomReward(reward: {id: number, count: number, frequency: number}[]) {
+        for(let r of reward) {
+            this.randomReward.push(r);
         }
     }
 
-    private handleFixReward(num: number, fixReward: string) {
-        let reward = decodeStr('fixReward', fixReward);
+    private handleFixReward(num: number, fixReward: RewardInter[]) {
         for(let i = 0; i < num; i++) {
-            for(let obj of reward) {
+            for(let obj of fixReward) {
                 this.rewards.push({type: BATTLE_REWARD_TYPE.FIX_REWARD, times: i +1, ...obj, count: obj.count });
             }
         }
     }
-    private handleConditionReward(num: number, conditionReward: string) {
-        let reward = decodeStr('conditionReward', conditionReward);
+    private handleConditionReward(num: number, conditionReward: {id: number, count: number, condition: number}[]) {
         for(let i = 0; i < num; i++) {
-            for(let obj of reward) {
+            for(let obj of conditionReward) {
                 if(this.condition.get(obj.condition)) {
                     this.rewards.push({type: BATTLE_REWARD_TYPE.CONDITION_REWARD, times: i +1, ...obj, count: obj.count});
                 }
@@ -103,34 +87,33 @@ export class WarReward {
         }
     }
 
-    private async handleRandomReward(num: number, randomReward: string) {
+    private async handleRandomReward(num: number, randomReward: {id: number, count: number, frequency: number}[]) {
 
-            let reward = decodeStr('randomReward', randomReward);
-            for(let obj of reward) {
-                let { id, frequency } = obj;
-                let dropHistory = await BattleDropModel.findByGid(this.roleId, this.battleId, id);
-                let { getNum = 0, allNum = 0, getSum = 0, allSum = 0 } = dropHistory;
-                for(let i = 0; i < num; i ++) {
-                    let flag = false; // 是否可以获得
-                    if(allNum >= frequency) {
-                        allNum = 0; getNum = 0;
-                    }
-                    allNum++; allSum++;
-                    if(getNum == 0) {
-                        let r = Math.random();
-                        if(r <= 1/frequency*allNum || (allNum >= frequency) ) {
-                            flag = true; // 独立概率随机
-                        }
-                    }
-                    if(flag) {
-                        getNum ++; getSum++;
-                        this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, times: i +1, ...obj});
+        for(let obj of randomReward) {
+            let { id, frequency } = obj;
+            let dropHistory = await BattleDropModel.findByGid(this.roleId, this.battleId, id);
+            let { getNum = 0, allNum = 0, getSum = 0, allSum = 0 } = dropHistory;
+            for(let i = 0; i < num; i ++) {
+                let flag = false; // 是否可以获得
+                if(allNum >= frequency) {
+                    allNum = 0; getNum = 0;
+                }
+                allNum++; allSum++;
+                if(getNum == 0) {
+                    let r = Math.random();
+                    if(r <= 1/frequency*allNum || (allNum >= frequency) ) {
+                        flag = true; // 独立概率随机
                     }
                 }
-                await BattleDropModel.updateByGid(this.roleId, this.battleId, id, {
-                    getNum, allNum, getSum, allSum
-                });
+                if(flag) {
+                    getNum ++; getSum++;
+                    this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, times: i +1, ...obj});
+                }
             }
+            await BattleDropModel.updateByGid(this.roleId, this.battleId, id, {
+                getNum, allNum, getSum, allSum
+            });
+        }
     }
 
     private async handlerBlueprtReward(num: number) {
@@ -175,10 +158,10 @@ export class WarReward {
         const result = dicPossibility.find(cur => {return cur.min <= lv && cur.max >= lv});
 
         if(result) {
-            const {dic: {id}} = getRandomWithWeight(result.possibility);
+            const {dic: {id}} = getRandEelmWithWeight(result.possibility);
             
-            const blueprtList = getBluePrtByQuality(id);
-            const gid = getRandomByLen(blueprtList);
+            const blueprtList = gameData.blueprt.get(id);
+            const gid = getRandSingleEelm(blueprtList);
             return {id: gid, count:1}
         } else {
             return null
@@ -190,7 +173,7 @@ export class WarReward {
         // let warType = this.warInfo.warType;
         
         if(this.isSuccess) { // 成功了才给固定奖励
-            // console.log(this.fixReward)
+            console.log(this.fixReward)
             if(this.fixReward) this.handleFixReward(num, this.fixReward);
             if(this.conditionReward) this.handleConditionReward(num, this.conditionReward);
             if(this.randomReward) await this.handleRandomReward(num, this.randomReward);