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

装备：清理旧代码

Browse Source
This commit is contained in:
luying
2022-02-18 17:53:10 +08:00
parent e29326856c
commit 3d6fab2ae6
33 changed files with 169 additions and 1472 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
shared/pubUtils/dictionary/DicBlueprtCompose.ts
View File

@@ -1,29 +0,0 @@
// 藏宝图合成表
import { readFileAndParse, parseGoodStr } from '../util'
import { FILENAME } from '../../consts'
import { RewardInter } from '../interface';
export interface DicBlueprtCompose {
// 品质
readonly quality: number;
// 消耗的寻宝币数量
readonly coinNum: RewardInter[];
// 消耗的藏宝图的数量
readonly blueprtNum: number;
// 目标品质
readonly targetQuality: number;
}
export const dicBlueprtCompose = new Map<number, DicBlueprtCompose>();
export function loadBlueprtCompose() {
dicBlueprtCompose.clear();
let arr = readFileAndParse(FILENAME.DIC_BLUEPRT_COMPOSE);
arr.forEach(o => {
o.coinNum = parseGoodStr(o.coinNum);
dicBlueprtCompose.set(o.quality, o);
});
arr = undefined;
}

38
shared/pubUtils/dictionary/DicBlueprtPossibility.ts
View File

@@ -1,38 +0,0 @@
// 藏宝图掉落率
import { decodeArrayListStr, readFileAndParse } from '../util'
import { FILENAME } from '../../consts'
export interface DicBlueprtPossibility {
// 君主等级下限
readonly min: number;
// 君主等级上限
readonly max: number;
// 掉落概率
readonly possibility: Array<{id: number, weight: number}>;
}
export const dicBlueprtPossibility = new Array<DicBlueprtPossibility>();
export function loadBlueprtPossibility() {
dicBlueprtPossibility.splice(0, dicBlueprtPossibility.length);
let arr = readFileAndParse(FILENAME.DIC_BLUEPRT_POSSIBILITY);
arr.forEach(o => {
o.possibility = parsePossibility(o.possibility);
dicBlueprtPossibility.push(o);
});
}
function parsePossibility(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
}

28
shared/pubUtils/dictionary/DicFuncSwitch.ts
View File

@@ -1,28 +0,0 @@
// 开启功能表
import { readFileAndParse } from '../util';
import { FILENAME } from '../../consts';
export interface DicFuncSwitch {
// 功能id
readonly id: number;
// 描述
readonly desc: string;
// 条件
readonly conditionType: number;
// 参数
readonly param: number;
// 客户端指令
readonly script: string;
}
export const dicFuncSwitch = new Map<number, DicFuncSwitch>();
export function loadFuncSwitch() {
dicFuncSwitch.clear();
let arr = readFileAndParse(FILENAME.DIC_FUNC_SWITCH);
arr.forEach(o => {
dicFuncSwitch.set(o.id, o);
});
arr = undefined;
}

133
shared/pubUtils/dictionary/DicGoods.ts
View File

@@ -1,69 +1,31 @@
// 物品表
import { decodeArrayListStr, readFileAndParse, parseGoodStr, parseNumberList, decodeArrayStr } from '../util'
import { FILENAME, IT_TYPE, ABI_TYPE } from '../../consts'
import { decodeArrayListStr, readFileAndParse, parseGoodStr, } from '../util'
import { FILENAME, } from '../../consts'
import { RewardInter } from '../interface';
const _ = require('lodash');
import { findWhere } from 'underscore';
export interface SpecialMaterial {
readonly ids: number[];
readonly count: number;
}
export interface DicGoods {
// 物品id
readonly good_id: number;
// 物品名
readonly name: string;
// 等级限制
readonly lvLimited: number;
// 星级
readonly equipLvl: number;
// 职业限制
readonly jobLimited: number[];
// 武将限制
readonly charLimited: number[];
// 合成装备需要的碎片数
readonly pieces: number;
// 对应的碎片id
readonly pieceId: number;
// 合成材料
readonly composeMaterial: Array<RewardInter>;
// 特殊材料
readonly specialMaterial: SpecialMaterial;
// 分解所得
readonly decomposeItem: Array<RewardInter>;
// 物品品质
readonly quality: number;
// 洞数
readonly hole: number;
// 随机属性范围
readonly randomEffect: Array<number>;
// 类型id
readonly itid: number;
// 物品类型
readonly goodType: number;
// 分解所得
readonly decomposeItem: Array<RewardInter>;
// 将魂对应武将id
readonly hid: number;
// 属性
readonly goodsAbility: Map<number, number>;
// 强化属性
readonly goodsAbilityUp: Map<number, number>;
// 套装id
readonly suitId: number;
// 特殊属性
readonly specialAttr: Map<number, number>;
// 属性外加的值，经验，好感
readonly value: number;
readonly count?: number;
readonly nextJewelId?: number;
readonly specialCount?: number;
readonly nextSpecialId?: number;
// 对应的装备id
readonly equipId?: number;
// 解锁条件
readonly condition: { id: number, type: number, params: number[] }[];
// 时间限制
@@ -78,35 +40,17 @@ type KeysEnum<T> = { [P in keyof Required<T>]: true };
const DicGoodsKeys: KeysEnum<DicGoods> = {
good_id: true,
name: true,
lvLimited: true,
pieces: true,
composeMaterial: true,
specialMaterial: true,
decomposeItem: true,
quality: true,
hole: true,
randomEffect: true,
itid: true,
goodType: true,
hid: true,
goodsAbility: true,
goodsAbilityUp: true,
suitId: true,
specialAttr: true,
value: true,
pieceId: true,
count: true,
nextJewelId: true,
specialCount: true,
nextSpecialId: true,
equipId: true,
condition: true,
timeLimit: true,
image_id: true,
gift: true,
jobLimited: true,
charLimited: true,
equipLvl: true
}
export const dicGoods = new Map<number, DicGoods>();
export const figureCondition = new Map<number, { params: number[], id: number, gid: number }[]>(); // type => {params, id, gid}
@@ -118,19 +62,8 @@ export function loadGoods() {
let arr = readFileAndParse(FILENAME.DIC_GOODS);
arr.forEach(o => {
o.goodsAbility = parseAbility(o);
o.goodsAbilityUp = parseAbilityUp(o);
o.composeMaterial = parseGoodStr(o.composeMaterial);
o.decomposeItem = parseGoodStr(o.decomposeItem);
o.specialAttr = parseSpecialAttr(o.specialAttr);
o.specialMaterial = parseSpecialMaterial(o.specialMaterial);
o.randomEffect = parseNumberList(o.randomEffect);
o.timeLimit = o.timelimit;
if (o.goodType == IT_TYPE.EQUIP_PIECE) {
let good = findWhere(arr, { pieceId: o.good_id });
if (!!good)
o.equipId = good.good_id;
}
let condition = parseConditionStr(o.condition);
for (let { id, type, params } of condition) {
let mapArr = figureCondition.get(type) || new Array<{ params: number[], id: number, gid: number }>();
@@ -138,68 +71,12 @@ export function loadGoods() {
figureCondition.set(type, mapArr);
}
o.condition = condition;
o.jobLimited = parseNumberList(o.jobLimited);
o.charLimited = parseNumberList(o.charLimited);
dicGoods.set(o.good_id, _.pick(o, Object.keys(DicGoodsKeys)));
});
arr = undefined;
}
function parseSpecialAttr(str: string) {
let specialAttr = new Map<number, number>();
if (str) {
let decodeArr = decodeArrayListStr(str);
for (let [type, count] of decodeArr) {
if (isNaN(parseInt(type)) || isNaN(parseInt(count))) {
throw new Error('data table format wrong');
}
specialAttr.set(parseInt(type), parseInt(count));
}
}
return specialAttr;
}
function parseAbility(json) {
let map = new Map<number, number>();
map.set(ABI_TYPE.ABI_HP, json.hp || 0);
map.set(ABI_TYPE.ABI_ATK, json.atk || 0);
map.set(ABI_TYPE.ABI_DEF, json.def || 0);
map.set(ABI_TYPE.ABI_MDEF, json.mdef || 0);
map.set(ABI_TYPE.ABI_DAMAGE_INCREASE, json.damageIncrease || 0);
map.set(ABI_TYPE.ABI_DAMAGE_DECREASE, json.damageDecrease || 0);
map.set(ABI_TYPE.ABI_PHYSICAL_DAMAGE_DECREASE, json.atkDecrease || 0);
map.set(ABI_TYPE.ABI_MAGIC_DAMAGE_DECREASE, json.matkDecrease || 0);
return map
}
function parseAbilityUp(json) {
let map = new Map<number, number>();
map.set(ABI_TYPE.ABI_HP, json.hp_up || 0);
map.set(ABI_TYPE.ABI_ATK, json.atk_up || 0);
map.set(ABI_TYPE.ABI_DEF, json.def_up || 0);
map.set(ABI_TYPE.ABI_MDEF, json.mdef_up || 0);
map.set(ABI_TYPE.ABI_DAMAGE_INCREASE, json.damageIncrease_up || 0);
map.set(ABI_TYPE.ABI_DAMAGE_DECREASE, json.damageDecrease_up || 0);
return map
}
function parseSpecialMaterial(str: string) {
let specialAttr = { ids: new Array<number>(), count: 0 }
if (!str) return specialAttr;
let decodeArr = decodeArrayStr(str);
if (decodeArr.length >= 2) {
let ids = parseNumberList(decodeArr[0]);
let count = parseInt(decodeArr[1]);
if (isNaN(count)) return specialAttr;
specialAttr.ids = ids;
specialAttr.count = count;
}
return specialAttr;
}
// 解析物品 {"type": number, "param": number} 格式
export function parseConditionStr(str: string) {
let result = new Array<{ id: number, type: number, params: number[] }>();

4
shared/pubUtils/dictionary/DicGuildWishReward.ts
View File

@@ -8,8 +8,6 @@ export interface DicGuildWishReward {
readonly id: number;
// itid
readonly itid: number;
// 装备星级
readonly starLevel: number;
// 品质
readonly quality: number;
// 功勋奖励
@@ -24,7 +22,7 @@ export function loadGuildWishReward() {
arr.forEach(o => {
if(o.starLevel == '&') o.starLevel = 0;
dicGuildWishReward.set(`${o.itid}_${o.starLevel}_${o.quality}`, o);
dicGuildWishReward.set(`${o.itid}_${o.quality}`, o);
});
arr = undefined;
}

5
shared/pubUtils/dictionary/DicHero.ts
View File

@@ -37,17 +37,12 @@ export interface DicHero {
type KeysEnum<T> = { [P in keyof Required<T>]: true };
const DicHeroKeys: KeysEnum<DicHero> = {heroId: true, name: true, quality: true, camp: true, jobClass: true, jobid: true, skill: true, pieceId: true, initialStars: true, pieceCount: true, baseAbilityArr: true, baseAbilityUpArr: true, initialSkin: true, recruit: true, face_id: true};
export const dicMyHeroes = new Array<number>();
export const dicHero = new Map<number, DicHero>();
export function loadHero() {
dicMyHeroes.splice(0, dicMyHeroes.length);
dicHero.clear();
let arr = readFileAndParse(FILENAME.DIC_HERO);
arr.forEach(o => {
if(o.heroId > 0 && o.heroId <= 300) {
dicMyHeroes.push(o.heroId);
}
o.baseAbilityArr = parseBaseAbilityArr(o);
o.baseAbilityUpArr = parseBaseAbilityUpArr(o);
o.recruit = parseInt(o.recruit) == 1;

27
shared/pubUtils/dictionary/DicHeroEquip.ts
View File

@@ -1,27 +0,0 @@
// 藏宝图合成表
import { readFileAndParse, parseNumberList } from '../util'
import { FILENAME } from '../../consts'
const _ = require('lodash');
export interface DicHeroEquip {
readonly itId: number;
readonly classId: Array<number>;
}
type KeysEnum<T> = { [P in keyof Required<T>]: true };
const DicHeroEquipKeys: KeysEnum<DicHeroEquip> = {
itId: true,
classId: true
}
export const dicHeroEquip = new Map<number, DicHeroEquip>();
export function loadHeroEquip() {
dicHeroEquip.clear();
let arr = readFileAndParse(FILENAME.DIC_HERO_EQUIP);
arr.forEach(o => {
o.classId = parseNumberList(o.classId);
dicHeroEquip.set(o.itId, _.pick(o, Object.keys(DicHeroEquipKeys)));
});
arr = undefined;
}

27
shared/pubUtils/dictionary/DicQuenchConsume.ts
View File

@@ -1,27 +0,0 @@
import { readFileAndParse, parseGoodStr } from '../util'
import { FILENAME } from '../../consts'
import { RewardInter } from '../interface';
export interface DicQuenchConsume {
// id
readonly id: number;
// 等级
readonly equipLvl: number;
// 品质
readonly quality: number;
// 淬火一次的消耗
readonly unitConsume: RewardInter[];
}
export const dicQuenchConsume = new Map<string, RewardInter[]>(); // equipLvl&quality => dic
export function loadQuenchConsume() {
dicQuenchConsume.clear();
let arr = readFileAndParse(FILENAME.DIC_QUENCH_CONSUME);
arr.forEach(o => {
o.unitConsume = parseGoodStr(o.unitconsume);
dicQuenchConsume.set(`${o.equipLvl}_${o.quality}`, o.unitConsume);
});
arr = undefined;
}

63
shared/pubUtils/dictionary/DicQuenchQuality.ts
View File

@@ -1,63 +0,0 @@
import { readFileAndParse } from '../util'
import { FILENAME } from '../../consts'
export interface DicQuenchQuality {
// id
readonly id: number;
// 装备品质
readonly quality: number;
// 品相
readonly grade: number;
// 单属性最小值
readonly singleRatioMin: number;
// 单属性最大值
readonly singleRatioMax: number;
// 初始是否可以随机出
readonly initialAvailable: number;
// 暴击率
readonly critProbability: number;
// 暴击效果
readonly critEffect: number;
}
export const dicQuenchRangeByQualityAndGrade = new Map<string, { min: number, max: number, randMin: number, randMax: number }>();
export const dicQuenchRangeByQuality = new Map<number, { min: number, max: number, randMin: number, randMax: number }>(); // quality => {}
export const dicQuenchByQuality = new Map<number, Map<number, DicQuenchQuality>>(); // quality => grade => dic
export function loadQuenchQuality() {
dicQuenchByQuality.clear();
dicQuenchRangeByQuality.clear();
dicQuenchRangeByQualityAndGrade.clear();
let arr = readFileAndParse(FILENAME.DIC_QUENCH_QUALITY);
arr.forEach(o => {
if(o.initialAvailable == 1) {
}
if(!dicQuenchRangeByQuality.has(o.quality)) {
dicQuenchRangeByQuality.set(o.quality, { min: o.singleRatioMin, max: o.singleRatioMax, randMin: o.singleRatioMin, randMax: o.singleRatioMax });
} else {
if(o.singleRatioMin < dicQuenchRangeByQuality.get(o.quality).min) {
dicQuenchRangeByQuality.get(o.quality).min = o.singleRatioMin;
}
if(o.singleRatioMax > dicQuenchRangeByQuality.get(o.quality).max) {
dicQuenchRangeByQuality.get(o.quality).max = o.singleRatioMax;
}
if(o.singleRatioMin < dicQuenchRangeByQuality.get(o.quality).randMin && o.initialAvailable == 1) {
dicQuenchRangeByQuality.get(o.quality).randMin = o.singleRatioMin;
}
if(o.singleRatioMax > dicQuenchRangeByQuality.get(o.quality).randMax && o.initialAvailable == 1) {
dicQuenchRangeByQuality.get(o.quality).randMax = o.singleRatioMax;
}
}
dicQuenchRangeByQualityAndGrade.set(`${o.quality}_${o.grade}`, { min: o.singleRatioMin, max: o.singleRatioMax, randMin: o.singleRatioMin, randMax: o.singleRatioMax });
if(!dicQuenchByQuality.has(o.quality)) {
dicQuenchByQuality.set(o.quality, new Map<number, DicQuenchQuality>());
}
dicQuenchByQuality.get(o.quality).set(o.grade, o);
});
arr = undefined;
}

34
shared/pubUtils/dictionary/DicRefine.ts
View File

@@ -1,34 +0,0 @@
// 武将特技表
import { readFileAndParse, parseGoodStr } from '../util'
import { FILENAME } from '../../consts'
import { RewardInter } from '../interface';
export interface DicRefine {
// 精炼id
readonly id: number;
// 精炼等级
readonly level: number;
// 精炼次数
readonly count: number;
// 等级限制
readonly levelLimited: number;
// 提高属性百分比
readonly upPercent: number;
// 材料
readonly consume: Array<RewardInter>;
}
export const dicRefine = new Map<number, DicRefine>();
export function loadRefine() {
dicRefine.clear();
let arr = readFileAndParse(FILENAME.DIC_REFINE);
arr.forEach(o => {
o.consume = parseGoodStr(o.consume)
dicRefine.set(o.id, o);
});
arr = undefined;
}

22
shared/pubUtils/dictionary/DicStrengthenCost.ts
View File

@@ -1,22 +0,0 @@
// 强化消耗表
import {readFileAndParse} from '../util'
import { FILENAME } from '../../consts'
export interface DicStrengthenCost {
// 等级
readonly level: number;
// 消耗铜钱
readonly costCoin: number;
}
export const dicStrengthenCost = new Map<number, number>();
export function loadStrengthenCost() {
dicStrengthenCost.clear();
let arr = readFileAndParse(FILENAME.DIC_STRENGTHEN_COST);
arr.forEach(o => {
dicStrengthenCost.set(o.level, o.costCoin);
});
arr = undefined;
}

50
shared/pubUtils/dictionary/DicSuit.ts
View File

@@ -1,50 +0,0 @@
// 套装表
import { decodeArrayListStr, readFileAndParse, parseNumberList } from '../util'
import { FILENAME } from '../../consts';
export interface DicSuit {
// 套装id
readonly id: number;
// 套装类型，相同suitType效果可跨级用
readonly suitType: number;
// 星级，相同suitType starLevel较高的套装可覆盖较低的效果
readonly starLevel: number;
// 包含关卡
readonly name: string;
// 总件数
readonly totalCount: number;
// 套装效果
readonly effect: Array<{ count: number, seid: number }>;
readonly tireInfo: Array<number>;
}
export const dicSuit = new Map<number, DicSuit>();
export const dicSuitByTypeAndLv = new Map<string, DicSuit>();
export function loadSuit() {
dicSuit.clear();
dicSuitByTypeAndLv.clear();
let arr = readFileAndParse(FILENAME.DIC_SUIT);
arr.forEach(o => {
o.effect = parseSuitEffect(o.effect);
o.tireInfo = parseNumberList(o.tireInfo);
dicSuit.set(o.id, o);
dicSuitByTypeAndLv.set(`${o.suitType}_${o.starLevel}`, o);
});
arr = undefined;
}
function parseSuitEffect(str: string) {
let result = new Array<{ count: number, seid: number }>();
if (!str) return result;
let decodeArr = decodeArrayListStr(str);
for (let [count, seid] of decodeArr) {
if (isNaN(parseInt(count)) || isNaN(parseFloat(seid))) {
throw new Error('data table format wrong');
}
result.push({ count: parseInt(count), seid: parseFloat(seid) });
}
return result
}