xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
luying
2021-05-06 20:25:05 +08:00
parent 2ef00e8179
commit 0315269387
36 changed files with 401 additions and 920 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
game-server/app/servers/activity/handler/gachaHandler.ts
View File

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

4
game-server/app/servers/battle/handler/auctionHandler.ts
View File

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

44
game-server/app/servers/battle/handler/comBattleHandler.ts
View File

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

47
game-server/app/servers/battle/handler/dailyBattleHandler.ts
View File

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

2
game-server/app/servers/battle/handler/eventBattleHandler.ts
View File

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

25
game-server/app/servers/battle/handler/expeditionBattleHandler.ts
View File

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

4
game-server/app/servers/battle/handler/guildBossHandler.ts
View File

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

10
game-server/app/servers/battle/handler/guildTrainHandler.ts
View File

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

14
game-server/app/servers/battle/handler/normalBattleHandler.ts
View File

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

32
game-server/app/servers/battle/handler/towerBattleHandler.ts
View File

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

6
game-server/app/servers/role/handler/heroHandler.ts
View File

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

5
game-server/app/servers/role/handler/roleHandler.ts
View File

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

6
game-server/app/servers/role/handler/taskHandler.ts
View File

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

61
game-server/app/services/battleService.ts
View File

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

60
game-server/app/services/comBattleService.ts
View File

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

17
game-server/app/services/dailyBattleService.ts
View File

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

21
game-server/app/services/eventSercive.ts
View File

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

19
game-server/app/services/expeditionService.ts
View File

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

4
game-server/app/services/gachaService.ts
View File

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

12
game-server/app/services/guildTrainService.ts
View File

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

2
game-server/app/services/normalBattleService.ts
View File

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

8
game-server/app/services/pvpService.ts
View File

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

2
game-server/app/services/redisService.ts
View File

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

20
game-server/app/services/rewardService.ts
View File

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

17
game-server/app/services/roleService.ts
View File

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

7
game-server/app/services/timeTaskService.ts
View File

@@ -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 });
}
/**

119
game-server/app/services/warRewardService.ts
View File

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

20
gm-server/app/service/Utils.ts
View File

@@ -1,7 +1,6 @@
import { Service } from 'egg';
import { addSkins, addBags, addEquips } from '@pubUtils/itemUtils';
import * as pubUtils from '@pubUtils/util';
import * as pubGamedata from '@pubUtils/gamedata'
import { BagInter, EquipInter } from '@pubUtils/interface';
const csprng = require('csprng');
@@ -22,25 +21,6 @@ export default class Utils extends Service {
return pubUtils.genCode(len)
}
public getGamedata(key: string) {
return pubGamedata.getGamedata(key);
}
public getHeroById(hid: number) {
return pubGamedata.getHeroInfoById(hid);
}
public getWarById(warid: number) {
return pubGamedata.getWarById(warid);
}
public getGoodById(gid: number) {
return pubGamedata.getGoodById(gid);
}
public getExpByLv(lv: number) {
return pubGamedata.getExpByLv(lv);
}
public resResult(status: {code: number, simStr: string}, data?, customMsg?: string) {
return pubUtils.resResult(status, data, customMsg);
}

8
gm-server/app/service/users.ts
View File

@@ -23,7 +23,7 @@ import Counter from '@db/Counter';
import { STATUS, HERO_SYSTEM_TYPE } from '@consts';
import { ITID, COUNTER } from '@consts';
import { ItemModel } from '@db/Item';
import { gameData, getHeroExpByLv } from '@pubUtils/data';
import { gameData, getHeroExpByLv, getExpByLv } from '@pubUtils/data';
import { calPlayerCeAndSave, calculatetopLineup, calEquipSeids } from '@pubUtils/playerCe';
import { SchoolModel } from '@db/School';
import { Attribute } from '@domain/roleField/attribute';
@@ -250,7 +250,7 @@ export default class GMUsers extends Service {
for(let hid of hids) {
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if(hero) continue;
let dicHero = ctx.service.utils.getHeroById(hid);
let dicHero = gameData.hero.get(hid);
if(!dicHero) continue;
const heroInfo = {
roleId, roleName: role.roleName, hid, serverId: role.serverId,
@@ -389,7 +389,7 @@ export default class GMUsers extends Service {
let lv = parseInt(_lv);
if(isNaN(lv)) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
for(let roleId of uids) {
let exp = ctx.service.utils.getExpByLv(lv - 1);
let exp = getExpByLv(lv - 1);
await RoleModel.levelup(roleId, lv, exp?exp.sum:0);
}
@@ -438,7 +438,7 @@ export default class GMUsers extends Service {
let { attr: roleAttrs } = role;
let dicHero = ctx.service.utils.getHeroById(hid);
let dicHero = gameData.hero.get(hid);
let attribute = new Attribute();
attribute.setByDbData(roleAttrs, heroAttrs);

5
shared/db/ComBattleTeam.ts
View File

@@ -1,6 +1,7 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { EXTERIOR } from '../pubUtils/dicParam';
import { ItemReward } from '../domain/dbGeneral';
export class RoleStatus {
@prop({ required: true })
@@ -48,8 +49,8 @@ export class RoleStatus {
@prop({ required: true, default: false })
gotReward: boolean;
// 固定奖励
@prop({ required: true, default: '&' })
fixReward: string;
@prop({ required: true, default: [], type: ItemReward })
fixReward: ItemReward[];
// 好友间伤害加成
@prop({ required: true, default: 0 })
frdRatio: number = 0;

17
shared/db/ExpeditionPoint.ts
View File

@@ -1,6 +1,17 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { ItemReward } from '../domain/dbGeneral';
class Reward {
@prop({ required: true })
point: number;
@prop({ required: true, type: ItemReward, default: [] })
reward: ItemReward[];
@prop({ required: true })
received: boolean;
@prop({ required: true })
recTime: Date;
}
/**
* 远征记录
*/
@@ -14,15 +25,15 @@ export default class ExpeditionPoint extends BaseModel {
pointCost: number; // 消耗点数
@prop({ required: true, default: false })
completed: boolean; // 本轮奖励是否完成
@prop({ required: true, default: [] })
rewards: Array<{point: number, reward: string, received:boolean, recTime: Date}>; // 领取记录
@prop({ required: true, type: Reward, default: [] })
rewards: Reward[]; // 领取记录
public static async getExpeditionPoint(roleId: string, lean = true) {
const result: ExpeditionPointType = await ExpeditionPointModel.findOne({ roleId, completed: false }).lean(lean);
return result;
}
public static async updatePointStatus(roleId: string, point: number, reward: string, lean = true) {
public static async updatePointStatus(roleId: string, point: number, reward: ItemReward[], lean = true) {
const result: ExpeditionPointType = await ExpeditionPointModel.findOneAndUpdate(
{ roleId, completed: false },
{ $set: { pointCost: point }, $push: {rewards:{point, reward, received: true, recTime: new Date()}}},

2
shared/domain/battleField/ComBattleTeamField.ts
View File

@@ -1,2 +1,2 @@
import { ComBattleTeamParam } from './../../db/ComBattleTeam';
export type MemComBtlTeam = ComBattleTeamParam & { bossCurHp: number; curRnd: number };
export type MemComBtlTeam = ComBattleTeamParam & { bossCurHp: number; curRnd: number; bossHp: number };

50
shared/pubUtils/data.ts
View File

@@ -15,10 +15,10 @@ import { dicQuestion } from "./dictionary/DicQuestion";
import { dicSe } from "./dictionary/DicSe";
import { dicTower } from "./dictionary/DicTower";
import { dicTowerTask } from "./dictionary/DicTowerTask";
import { dicWar, dicWarPvp } from "./dictionary/DicWar";
import { dicWar, dicWarPvp, dicDailyWarByType } from "./dictionary/DicWar";
import { dicWarJson } from "./dictionary/DicWarJson";
import { dicXunbao } from "./dictionary/DicXunbao";
import { SPECIAL_ATTR } from "../consts";
import { SPECIAL_ATTR, COM_BTL_LV_RANGE } from "../consts";
import { dicFashions } from "./dictionary/DicFashions";
import { friendShips, friendShipHidAandIds } from "./dictionary/DicFriendShip";
import { maxFriendShipLv, dicFriendShipLevelMap } from "./dictionary/DicFriendShipLevel";
@@ -107,6 +107,7 @@ export const gameData = {
towerTask: dicTowerTask,
war: dicWar,
warJson: dicWarJson,
dailyWarByType: dicDailyWarByType,
xunbao: dicXunbao,
btlBossHpSum: new Map<number, number>(),
btlBossHp: new Map<number, Array<{ dataId: number, hp: number, actorId: number }>>(),
@@ -193,7 +194,8 @@ export const gameData = {
gachaHope: getGachaHopePercent(),
gachaTurntable: getGachaTurntablePercent(),
heroTransPiece: getHeroTransPiece(),
giftPackage: dicGiftPackage
giftPackage: dicGiftPackage,
comBtlLvRange: parseComBtlLvRange()
};
// 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -301,6 +303,48 @@ export function getWarIdByBlueprtId(blueprtId: number) {
return warId;
}
export function getBossHpByBlueprtId(blueprtId: number) {
let { dispatchJsonId } = getWarByBlueprtId(blueprtId);
let bossHpInfo = getBossHpByWarId(dispatchJsonId);
return bossHpInfo;
}
export function getWarByBlueprtId(blueprtId: number) {
let warId = getWarIdByBlueprtId(blueprtId);
return gameData.war.get(warId);
}
export function getRewardByBlueprtId(blueprtId: number) {
let { fixReward } = getWarByBlueprtId(blueprtId);
return fixReward;
}
function parseComBtlLvRange() {
let map = new Map<number, Array<number>>()
const lvRange = COM_BTL_LV_RANGE;
lvRange.forEach(range => {
const lvs = [];
for (let lv = range.minLv; lv <= range.maxLv; lv++) {
lvs.push(lv);
}
map.set(range.id, lvs);
});
return map
}
export function comBtlRangeByLv(lv: number) {
for (let [k, v] of gameData.comBtlLvRange) {
if (v.indexOf(lv) !== -1) {
return k;
}
}
}
export function comBtlRanges() {
return Array.from(gameData.comBtlLvRange.keys());
}
export function getHeroStarByQuality(quality: number, star: number) {
return gameData.heroStar.get(`${quality}_${star}`);
}

24
shared/pubUtils/dictionary/DicWar.ts
View File

@@ -28,10 +28,15 @@ export interface DicWar {
readonly dailyType: number;
// 显示章节名
readonly detailUIBg: string[];
// 寻宝匹配json
readonly dispatchJsonId: number;
// 寻宝奖励
readonly jackpotReward: Array<{id: number, weight: number}>;
}
export const dicWar = new Map<number, DicWar>();
export const dicWarPvp = new Array<DicWar>();
export const dicDailyWarByType = new Map<number, DicWar[]>();
for(let filename of WAR_RELATE_TABLES) {
const str = readJsonFile(filename);
@@ -42,10 +47,16 @@ for(let filename of WAR_RELATE_TABLES) {
o.conditionReward = parseConditionReward(o.conditionReward);
o.parseRandomReward = parseRandomReward(o.parseRandomReward);
o.detailUIBg = parseDetailUIBg(o.detailUIBg);
o.jackpotReward = parseJackpotReward(o.jackpotReward);
dicWar.set(o.war_id, o);
if(o.warType == WAR_TYPE.PVP) {
dicWarPvp.push(o);
} else if (o.warType == WAR_TYPE.DAILY) {
if(!dicDailyWarByType.has(o.dailyType)) {
dicDailyWarByType.set(o.dailyType, []);
}
dicDailyWarByType.get(o.dailyType).push(o);
}
});
}
@@ -94,4 +105,17 @@ function parseDetailUIBg(str: string = '') {
if(!str) return result;
let decodeArr = decodeArrayStr(str, '_');
return decodeArr;
}
function parseJackpotReward(str: string = '') {
let result = new Array<{id: number, weight: number}>();
if(!str) return result;
let decodeArr = decodeArrayListStr(str);
for(let [id, weight] of decodeArr) {
if(isNaN(parseInt(id)) || isNaN(parseInt(weight))) {
throw new Error('data table format wrong');
}
result.push({id: parseInt(id), weight: parseInt(weight)});
}
return result
}

416
shared/pubUtils/gamedata.ts
View File

@@ -1,416 +0,0 @@
import fs = require('fs');
import path = require('path');
import { ABI_TYPE, COM_BTL_LV_RANGE } from '../consts';
import { decodeIdCntArrayStr } from './util';
import { IT_TYPE } from '../consts';
let gamedata = {};
const wars = ['dic_zyz_gk_main', 'dic_zyz_gk_mainElite', 'dic_zyz_gk_daily', 'dic_zyz_gk_event', 'dic_zyz_gk_tower', 'dic_zyz_gk_expedition', 'dic_zyz_gk_dungeon','dic_zyz_gk_dungeonElite', 'dic_zyz_gk_Treasure','dic_zyz_gk_branch']; // 关卡相关的表
const allWarInfos = new Map<number, any>();
const towerInfos = new Map<number, any>();
const towerTaskInfos = new Map<number, any>();
const heroInfos = new Map<number, any>();
const jobInfos = new Map<number, any>();
const jobClassMaxGrades = new Map<number, {grade:number, jobid:number}>();
const jobClassAndgrades = new Map<string, {jobid:number, unlockLevel:number}>();
const levelInfos = new Map<number, {sum: number, cur: number}>();
const heroLevelInfo = new Map<number, number>();
const expeditionInfo = new Map<number, any> ();
const comBtlInfo = new Map<number, {quality: number, name: string, assistanceTime: number}>();
const btlBossHpSum = new Map<number, number>();
const btlBossHp = new Map<number, Array<{dataId: number, hp: number, actorId: number}>>();
const blueprtToWar = new Map<number, number>();
const goodInfo = new Map<number, any>();
const blueprt = new Map<number, Array<number>>();
const blueprtCompose = new Map<number, any>();
const fiendShips = new Map<string, any>();
const comBtlLvRange = new Map<number, Array<number>>();
function parseWarData() {
let result = null;
for (let filename of wars) {
let warInfo = gamedata['jsons'][filename]||[];
for(let war of warInfo) {
if(war.war_id) {
allWarInfos.set(war.war_id, war);
}
}
}
return result;
}
function parseTowerData() {
const towerFile = 'dic_zyz_tower';
const towerData = gamedata['jsons'][towerFile] || [];
towerData.forEach(elem => {
if (elem.towerFloor) {
towerInfos.set(elem.towerFloor, elem);
}
});
}
function parseTowerTaskData() {
const towerTaskFile = 'dic_zyz_search';
const towerTaskData = gamedata['jsons'][towerTaskFile] || [];
towerTaskData.forEach(elem => {
if (elem && elem.taskId) {
towerTaskInfos.set(elem.taskId, elem);
}
});
}
function parseHeroData() {
const heroFile = 'dic_zyz_hero';
const heroesData = gamedata['jsons'][heroFile] || [];
heroesData.forEach(elem => {
if (elem && elem.heroId) {
elem.baseAbilityArr = new Array<number>();
elem.baseAbilityUpArr = new Array<number>();
elem.baseAbilityArr[ABI_TYPE.ABI_HP] = elem.hp||0;
elem.baseAbilityArr[ABI_TYPE.ABI_ATK] = elem.atk||0;
elem.baseAbilityArr[ABI_TYPE.ABI_MATK] = elem.matk||0;
elem.baseAbilityArr[ABI_TYPE.ABI_DEF] = elem.def||0;
elem.baseAbilityArr[ABI_TYPE.ABI_MDEF] = elem.mdef||0;
elem.baseAbilityArr[ABI_TYPE.ABI_AGI] = elem.agi||0;
elem.baseAbilityArr[ABI_TYPE.ABI_LUK] = elem.luk||0;
elem.baseAbilityArr[ABI_TYPE.ABI_SPEED] = elem.speed||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_HP] = elem.hp_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_ATK] = elem.atk_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_MATK] = elem.matk_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_DEF] = elem.def_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_MDEF] = elem.mdef_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_AGI] = elem.agi_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_LUK] = elem.luk_up||0;
elem.baseAbilityUpArr[ABI_TYPE.ABI_SPEED] = elem.speed_up||0;
heroInfos.set(elem.heroId, elem);
}
});
}
function parseJobData() {
const jobFile = 'dic_zyz_job';
const jobsData = gamedata['jsons'][jobFile] || [];
jobsData.forEach(elem => {
if (elem && elem.jobid) {
elem.seids = elem.seid.split('&');
delete elem.seid;
jobInfos.set(elem.jobid, elem);
let jobClass = jobClassMaxGrades.get(elem.job_class);
if (!!jobClass && jobClass.grade < elem.grade) {
jobClassMaxGrades.set(elem.job_class, {grade: elem.grade,jobid: elem.jobid});
}
jobClassAndgrades.set(elem.job_class+'_'+elem.grade,{unlockLevel:elem.unlockLevel, jobid:elem.jobid});
}
});
}
function parseLevelInfo() {
const jobFile = 'dic_zyz_kingexp';
const levelData = gamedata['jsons'][jobFile] || [];
let exp = 0;
levelData.forEach(elem => {
if (elem && elem.level) {
exp += elem.exp;
levelInfos.set(elem.level, { sum: exp, cur: elem.exp });
}
});
}
function parseHeroLevelInfo() {
const jobFile = 'dic_zyz_charexp';
const levelData = gamedata['jsons'][jobFile] || [];
let exp = 0;
levelData.forEach(elem => {
if (elem && elem.level) {
exp += elem.exp;
heroLevelInfo.set(elem.level, exp);
}
});
}
function parseExpedition() {
const file = 'dic_expedition';
const data = gamedata['jsons'][file] || [];
data.forEach(elem => {
if (elem && elem.id) {
expeditionInfo.set(elem.id, elem);
}
});
}
function parseComBtlData() {
const file = 'dic_zyz_xunbao';
const data = gamedata['jsons'][file] || [];
data.forEach(elem => {
if (elem && elem.quality) {
comBtlInfo.set(elem.quality, elem);
}
});
}
function parseComBtlLvRange() {
const lvRange = COM_BTL_LV_RANGE;
lvRange.forEach(range => {
const lvs = [];
for (let lv = range.minLv; lv <= range.maxLv; lv++) {
lvs.push(lv);
}
comBtlLvRange.set(range.id, lvs);
});
}
function parseGood() {
const file = 'dic_goods';
const data = gamedata['jsons'][file] || [];
data.forEach(elem => {
if (elem && elem.good_id) {
goodInfo.set(elem.good_id, elem);
if(elem.itid == IT_TYPE.BLUEPRT) {
let arr = blueprt.get(elem.quality)||new Array();
arr.push(elem.good_id);
blueprt.set(elem.quality, arr);
}
}
});
}
function parseBlueprtCompose() {
const file = 'dic_blueprt_compose';
const data = gamedata['jsons'][file] || [];
data.forEach(elem => {
if (elem && elem.quality) {
blueprtCompose.set(elem.quality, elem);
}
});
}
function parseFiendShipLevels() {
const file = 'dic_zyz_friend_ship_level';
const data = gamedata['jsons'][file] || [];
data.sort(function(a, b) {
return a.level - b.level;
});
}
function initData (folder: string) {
if(!gamedata.hasOwnProperty(folder)) {
gamedata[folder] = {};
}
fs.readdirSync(__dirname + '/../resource/' + folder)
.filter(function(file) {
return (file.indexOf(".") !== 0) && (file !== "index.js");
})
//筛选有文件名且不是index进行遍历
.forEach(function(file) {
var name = file.split('.')[0];
try {
gamedata[folder][name] = JSON.parse(
fs.readFileSync(path.resolve(__dirname, "../resource/" + folder + "/" + file)).toString('utf8').replace(/^\uFEFF/, '')
);
} catch(e) {
console.error(e);
console.error('【文件错误】：' + file);
gamedata[folder][name] = [];
}
});
}
function parseData() {
parseWarData();
parseTowerData();
parseTowerTaskData();
parseHeroData();
parseJobData();
parseLevelInfo();
parseHeroLevelInfo();
parseExpedition();
parseComBtlData();
parseComBtlLvRange();
parseGood();
parseBlueprtCompose();
parseFiendShipLevels();
}
initData('jsons'); // 加载一般json
initData('warJsons'); // 加载出兵表
parseData();
export function getGamedata(key) {
return gamedata['jsons'][key];
}
// 获取出兵表
export function getWarJsons(key: any) {
key = key + '';
let arr = key.split('&');
let index = Math.floor(Math.random() * arr.length);
key = arr[index];
return {
json: gamedata['warJsons'][key],
fileName: key
}
}
export function getWarById(warid: number) {
return allWarInfos.get(warid);
}
export function getTowerDataByLv(lv: number) {
return towerInfos.get(lv);
}
export function getGoodById(gid) {
return goodInfo.get(gid);
}
export function getBluePrtByQuality(quality: number) {
return blueprt.get(quality)|| new Array<number>();
}
export function getTaskById(tid: number) {
const taskInfo = towerTaskInfos.get(tid);
return taskInfo;
}
export function getHeroInfoById(hid: number) {
const heroInfo = heroInfos.get(hid);
return heroInfo;
}
export function getJobInfoById(jid: number) {
const jobInfo = jobInfos.get(jid);
return jobInfo;
}
export function getMaxGradeByjobClass(jobClass: number) {
const job = jobClassMaxGrades.get(jobClass);
return job?.jobid;
}
export function getLvByExp(exp: number) {
let curLv = 0;
let entries = levelInfos.entries();
for (let [lv, {sum}] of entries) {
curLv = lv;
if(exp < sum) break;
}
return curLv;
}
export function getExpByLv(lv: number) {
return levelInfos.get(lv);
}
export function getHeroLvByExp(exp: number) {
let curLv = 0;
let entries = heroLevelInfo.entries();
for (let [lv, sum] of entries) {
curLv = lv;
if(exp < sum) break;
}
return curLv;
}
export function getHeroExpByLv(lv: number) {
return heroLevelInfo.get(lv);
}
export function getExpeditionById(id: number) {
return expeditionInfo.get(id);
}
export function getComBtlSetByQuality(quality: number) {
return comBtlInfo.get(quality);
}
export function comBtlRangeInfo(range: number) {
return comBtlLvRange.get(range);
}
export function comBtlRangeByLv(lv: number) {
for (let [k, v] of comBtlLvRange) {
if (v.indexOf(lv) !== -1) {
return k;
}
}
}
export function comBtlRanges() {
return Array.from(comBtlLvRange.keys());
}
export function getBossHpByWarId(warId: number) {
let bossHpSum = btlBossHpSum.get(warId) || 0;
let bossHpArr = btlBossHp.get(warId) || [];
if (!bossHpSum || !bossHpArr) {
const warInfo = getWarJsons(warId).json;
if (warInfo && warInfo.length) {
warInfo.forEach(hero => {
let { attribute, dataId, relation, actorId } = hero;
if (relation === 2) {
let attriData = decodeIdCntArrayStr(attribute, 1);
const hp = attriData.get('1');
if (hp > 0) {
bossHpArr.push({dataId, hp, actorId});
bossHpSum += hp;
}
}
})
btlBossHp.set(warId, bossHpArr);
btlBossHpSum.set(warId, bossHpSum);
}
}
return { bossHpSum, bossHpArr };
}
export function getWarIdByBlueprtId(blueprtId: number) {
let warId = blueprtToWar.get(blueprtId);
if (!warId) {
const { specialAttr } = getGoodById(blueprtId);
const attrData = decodeIdCntArrayStr(specialAttr, 1);
warId = attrData.get('1');
blueprtToWar.set(blueprtId, warId);
}
return warId;
}
export function getBossHpByBlueprtId(blueprtId: number) {
let warId = getWarIdByBlueprtId(blueprtId);
let { dispatchJsonId } = getWarById(warId);
let bossHpInfo = getBossHpByWarId(dispatchJsonId);
return bossHpInfo;
}
export function getRewardByBlueprtId(blueprtId: number) {
let warId = getWarIdByBlueprtId(blueprtId);
let { fixReward } = getWarById(warId);
return fixReward;
}
export function hasExpeditionById(id: number) {
return expeditionInfo.has(id);
}
export function getBlueprtComposeByQuality(quality: number) {
return blueprtCompose.get(quality);
}
export function getFriendShipById(shipId: number, level: number) {
return fiendShips.get(shipId +'_' + level);
}
export function getJobByGradeAndClass(jobClass: number, grade: number) {
return jobClassAndgrades.get(jobClass +'_' + grade);
}

193
shared/pubUtils/util.ts
View File

@@ -65,103 +65,6 @@ export function generateNum(len: number) {
return code;
}
export function decodeStr(type, str, splitForm = '|') {
if (str == '&' || !str) {
return []
} else {
return str.split(splitForm).map(cur => {
return decodeStrSingle(type, cur);
});
};
}
export function decodeStrSingle(type, str) { //单层，返回对象而不是数组
let last = str.substr(str.length - 1, 1);
if (last == '&') str = str.substr(0, str.length - 1);
if (str == '&' || !str) {
return {}
} else {
let arr = str.split('&');
let result: any;
switch (type) {
case 'fixReward': {
let [id, count] = arr;
if (isNaN(id) || isNaN(count)) throw new Error('data table format wrong');
result = { id: parseInt(id), count: parseInt(count) };
break;
}
case 'conditionReward': {
let [id, count, condition] = arr;
if (isNaN(id) || isNaN(count)) throw new Error('data table format wrong');
result = { id: parseInt(id), count: parseInt(count), condition: parseInt(condition) };
break;
}
case 'randomReward': {
let [id, count, frequency] = arr;
if (isNaN(id) || isNaN(count)) throw new Error('data table format wrong');
result = { id: parseInt(id), count: parseInt(count), frequency: parseInt(frequency) };
break;
}
case 'suitLevel': {
let [min, max] = arr;
if (isNaN(min) || isNaN(max)) throw new Error('data table format wrong');
result = { min: parseInt(min), max: parseInt(max) };
break;
}
case 'suitLevelSingle': {
let [min, max] = arr;
if (max) {
if (isNaN(min) || isNaN(max)) throw new Error('data table format wrong');
result = { min: parseInt(min), max: parseInt(max) };
break;
} else {
if (isNaN(min)) throw new Error('data table format wrong');
result = { min: parseInt(min) };
break;
}
}
case 'attribute': {
let [id, value] = arr;
if (isNaN(id) || isNaN(value)) throw new Error('data table format wrong');
result = { id: parseInt(id), value: parseInt(value) };
break;
}
case 'point': {
let [x] = arr;
if (isNaN(x)) throw new Error('data table format wrong');
result = x;
break;
}
case 'decimalReward': {
let [id, count] = arr;
if (isNaN(id) || isNaN(count)) throw new Error('data table format wrong');
result = { id: parseInt(id), count: parseFloat(count) };
break;
}
case 'towerTaskCondition': {
let [type, param, cnt] = arr;
if (isNaN(type) || isNaN(param) || isNaN(cnt)) throw new Error('data table format wrong');
result = { type: parseInt(type), param: parseInt(param), cnt: parseInt(cnt) };
break;
}
case 'possibility': {
let [id, weight] = arr;
if (isNaN(id) || isNaN(weight)) throw new Error('data table format wrong');
result = { id: parseInt(id), weight: parseInt(weight) };
break;
}
case 'cost': {
let [id, count] = arr;
if (isNaN(id) || isNaN(count)) throw new Error('data table format wrong');
result = { id: parseInt(id), count: parseInt(count) };
break;
}
}
return result;
};
}
/**
* 将 | 分隔的字符串解析为数组，如：a|b|c 解析为[a, b, c]
* @param str 要解析的字符串
@@ -211,32 +114,6 @@ export async function calculateSumCE(roleId: string, type: number, param: { num?
return sum;
}
export function getRandomByLen(arr: Array<any>): any {
let len = arr.length;
return arr[Math.floor(Math.random() * len)]
}
export function getRandomIndexByLen(len: number) {
return Math.floor(Math.random() * len);
}
export function getRandomWithWeight<T extends { weight: number }>(randomList: T[]): { dic: T, index: number } {
let len = randomList.reduce((pre, cur) => {
return pre + cur.weight || 1;
}, 0);
let index = Math.floor(Math.random() * len);
let result = { dic: null, index: -1 };
for (let i = 0; i < randomList.length; i++) {
let { weight = 0 } = randomList[i];
if (index < weight) {
result.dic = randomList[i];
result.index = i;
break;
}
index -= weight;
}
return result
}
/**
* 传入两个时间，返回按照时间差计算，第二个时间比第一个晚几天
* @param preTime 之前的时间
@@ -329,6 +206,45 @@ export function getRandEelm<T>(source: Array<T> = [], cnt = 1): Array<T> {
return source.filter((_item, idx) => idxs.has(idx));
}
/**
* 从一个数组中随机返回1元素
* @param source
*/
export function getRandSingleEelm<T>(source: Array<T>): T {
let len = source.length;
return source[Math.floor(Math.random() * len)]
}
/**
* 随机数组中一个index
* @param len
*/
export function getRandSingleIndex(len: number) {
return Math.floor(Math.random() * len);
}
/**
* 从一个数组根据权重随机一个元素
* @param randomList
*/
export function getRandEelmWithWeight<T extends { weight: number }>(randomList: T[]): { dic: T, index: number } {
let len = randomList.reduce((pre, cur) => {
return pre + cur.weight || 1;
}, 0);
let index = Math.floor(Math.random() * len);
let result = { dic: null, index: -1 };
for (let i = 0; i < randomList.length; i++) {
let { weight = 0 } = randomList[i];
if (index < weight) {
result.dic = randomList[i];
result.index = i;
break;
}
index -= weight;
}
return result
}
/**
* 不改变原数组长度，将内部元素打乱
* @param source
@@ -360,7 +276,6 @@ export function getRandValueByMinMax(min: number, max: number, decimal = 2): num
}
export function resResult(status: { code: number, simStr: string }, data = null, customMsg = '') {
const { code, simStr } = status;
if (code !== STATUS.SUCCESS.code) {
@@ -452,13 +367,10 @@ export function calculateNum(ratio: { A: number, B: number }, params: { num: num
}
}
export function ratioReward(rewardStr: string, ratio: number): string {
let rewards = decodeIdCntArrayStr(rewardStr, ratio);
let res = '';
for (let [k, v] of rewards) {
res += `${k}&${v}|`;
}
return res.substring(0, res.length - 1);
export function ratioReward(reward: {id: number, count: number}[], ratio: number): {id: number, count: number}[] {
return reward.map(cur => {
return {id: cur.id, count: cur.count * ratio}
});
}
export function getItems(str: string) {
@@ -606,25 +518,6 @@ export function reduceCe(ce: number = 0) {
return Math.floor(ce / HERO_CE_RATIO / HERO_CE_RATIO)
}
export function getRandNum(min, max) {
let randNum = min + Math.floor(Math.random() * (max - min + 1));
return randNum;
}
export function getRandomArr(allarr, ranNum) {
let arr = deepCopy(allarr);
var result = [];
if (arr.length <= ranNum) {
result = result.concat(arr);
return result;
}
for (var i = 0; i < ranNum; i++) {
var ran = Math.floor(Math.random() * arr.length);
result.push(arr.splice(ran, 1)[0]);
};
return result;
}
// 获取全部属性
export function getAllAttrStage() {