511 lines
14 KiB
TypeScript
511 lines
14 KiB
TypeScript
import * as fs from "fs";
|
|
import * as path from "path";
|
|
|
|
import * as camelCase from "camelcase";
|
|
|
|
export interface IGlyphProperties {
|
|
id: number;
|
|
spellId: number;
|
|
}
|
|
|
|
export interface IAchievement {
|
|
id: number;
|
|
faction: number;
|
|
titleLang0: string;
|
|
descriptionLang0: string;
|
|
category: number;
|
|
points: number;
|
|
flags: number;
|
|
iconId: number;
|
|
}
|
|
|
|
export interface IAchievementCategory {
|
|
id: number;
|
|
parent: number;
|
|
nameLang0: string;
|
|
}
|
|
|
|
export interface IItemDbc {
|
|
id: number;
|
|
classId: number;
|
|
subclassId: number;
|
|
displayInfoId: number;
|
|
inventoryType: number;
|
|
}
|
|
|
|
export interface IItemRetailDbc {
|
|
id: number;
|
|
inventoryType: number;
|
|
}
|
|
|
|
export interface IItemAppearanceDbc {
|
|
id: number;
|
|
itemDisplayInfoId: number;
|
|
}
|
|
|
|
export interface IItemModifiedAppearanceDbc {
|
|
id: number;
|
|
itemId: number;
|
|
itemAppearanceId: number;
|
|
}
|
|
|
|
export interface IItemDisplayInfoDbc {
|
|
id: number;
|
|
inventoryIcon0: number;
|
|
}
|
|
|
|
export interface IMountDbc {
|
|
id: number;
|
|
sourceSpellId: number;
|
|
}
|
|
|
|
export interface IMountXDisplayDbc {
|
|
id: number;
|
|
creatureDisplayInfoId: number;
|
|
mountId: number;
|
|
}
|
|
|
|
export interface ISkillDbc {
|
|
id: number;
|
|
categoryId: number;
|
|
skillCostId: number;
|
|
name: string;
|
|
spellIcon: number;
|
|
altVerb: string;
|
|
canLink: number;
|
|
}
|
|
|
|
export interface ISpellDbc {
|
|
id: number;
|
|
mechanic: number;
|
|
spellIconId: number;
|
|
}
|
|
|
|
export interface ISpellItemEnchantmentDbc {
|
|
id: number;
|
|
srcItemId: number;
|
|
}
|
|
|
|
export interface ISpellIcon {
|
|
id: number;
|
|
textureFilename: string;
|
|
}
|
|
|
|
export interface ITalent {
|
|
id: number;
|
|
tabId: number;
|
|
tierId: number;
|
|
columnIndex: number;
|
|
spellRank0: number;
|
|
spellRank1: number;
|
|
spellRank2: number;
|
|
spellRank3: number;
|
|
spellRank4: number;
|
|
prereqTalent0: number;
|
|
prereqRank0: number;
|
|
}
|
|
|
|
export interface ITalentTab {
|
|
id: number;
|
|
nameLang0: string;
|
|
spellIconId: number;
|
|
classMask: number;
|
|
}
|
|
|
|
export interface IFactionDbc {
|
|
id: number;
|
|
reputationId: number;
|
|
name: string;
|
|
}
|
|
|
|
export interface IAreas {
|
|
id: number;
|
|
zoneName: string;
|
|
mapId: number;
|
|
areaId: number;
|
|
}
|
|
|
|
interface IAsyncGeneratorWithArrayMethods<T> {
|
|
[Symbol.asyncIterator](): AsyncGenerator<T>;
|
|
toArray(): Promise<T[]>;
|
|
map<M>(fn: (t: T) => M): IAsyncGeneratorWithArrayMethods<M>;
|
|
filter(fn: (t: T) => boolean): IAsyncGeneratorWithArrayMethods<T>;
|
|
find(fn: (t: T) => boolean): Promise<T>;
|
|
}
|
|
|
|
class ArrayAsAsyncGenerator<T> implements IAsyncGeneratorWithArrayMethods<T> {
|
|
private data: T[];
|
|
|
|
public constructor(data: T[]) {
|
|
this.data = data;
|
|
}
|
|
|
|
async toArray(): Promise<T[]> {
|
|
return this.data;
|
|
}
|
|
|
|
async *[Symbol.asyncIterator](): AsyncGenerator<T> {
|
|
for (const x of this.data) {
|
|
yield x;
|
|
}
|
|
}
|
|
|
|
public map<M>(fn: (t: T) => M): ArrayAsAsyncGenerator<M> {
|
|
return new ArrayAsAsyncGenerator<M>(this.data.map(fn));
|
|
}
|
|
|
|
filter(fn: (t: T) => boolean): ArrayAsAsyncGenerator<T> {
|
|
return new ArrayAsAsyncGenerator<T>(this.data.filter(fn));
|
|
}
|
|
|
|
async find(fn: (t: T) => boolean): Promise<T> {
|
|
return this.data.find(fn);
|
|
}
|
|
}
|
|
|
|
class AsyncGenWrapper<T> implements IAsyncGeneratorWithArrayMethods<T> {
|
|
private gen: AsyncGenerator<T>;
|
|
|
|
public constructor(gen: AsyncGenerator<T>) {
|
|
this.gen = gen;
|
|
}
|
|
|
|
public static from<T>(array: T[]): AsyncGenWrapper<T> {
|
|
return new AsyncGenWrapper<T>(
|
|
(async function* () {
|
|
for (const x of array) {
|
|
yield x;
|
|
}
|
|
})(),
|
|
);
|
|
}
|
|
|
|
public async *[Symbol.asyncIterator](): AsyncGenerator<T> {
|
|
for await (const x of this.gen) {
|
|
yield x;
|
|
}
|
|
}
|
|
|
|
public async toArray(): Promise<T[]> {
|
|
const values = [];
|
|
for await (const x of this) {
|
|
values.push(x);
|
|
}
|
|
return values;
|
|
}
|
|
|
|
private wrap<X>(g: (that: AsyncGenWrapper<T>) => AsyncGenerator<X>): AsyncGenWrapper<X> {
|
|
return new AsyncGenWrapper<X>(g(this));
|
|
}
|
|
|
|
public map<M>(fn: (t: T) => M): AsyncGenWrapper<M> {
|
|
return this.wrap(async function* (me) {
|
|
for await (const x of me) {
|
|
yield fn(x);
|
|
}
|
|
});
|
|
}
|
|
|
|
public filter(fn: (t: T) => boolean): AsyncGenWrapper<T> {
|
|
return this.wrap(async function* (me) {
|
|
for await (const x of me) {
|
|
if (fn(x)) {
|
|
yield x;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public async find(fn: (t: T) => boolean): Promise<T> {
|
|
for await (const x of this) {
|
|
if (fn(x)) {
|
|
return x;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class DbcReader<T> {
|
|
private filePath: string;
|
|
private fields: string[];
|
|
|
|
public constructor(filePath: string, keepFields: string[] = []) {
|
|
this.filePath = filePath;
|
|
this.fields = keepFields;
|
|
}
|
|
|
|
public async *read(): AsyncGenerator<T> {
|
|
const stream = fs.createReadStream(this.filePath);
|
|
const itr = this.parseCsv(stream);
|
|
const headerLine = await itr.next();
|
|
if (headerLine.done === true) {
|
|
return;
|
|
}
|
|
|
|
const headerCols = headerLine.value.map((header) => camelCase(header).replace(/[[\]]/g, ""));
|
|
|
|
for await (const arr of itr) {
|
|
const cols = arr.map((value) => {
|
|
if (value === "") {
|
|
return value;
|
|
}
|
|
return isNaN(+value) ? value : parseInt(value, 10);
|
|
});
|
|
const row = {};
|
|
headerCols.forEach((header, headerIdx) => {
|
|
if (this.fields.length === 0 || this.fields.includes(header)) {
|
|
row[header] = cols[headerIdx];
|
|
}
|
|
});
|
|
yield row as T;
|
|
}
|
|
}
|
|
|
|
private async *parseCsv(stream: fs.ReadStream): AsyncGenerator<string[]> {
|
|
// Adapted from https://stackoverflow.com/a/14991797
|
|
const arr = [];
|
|
let col = 0;
|
|
let quote = false; // 'true' means we're inside a quoted field
|
|
|
|
for await (const chunk of stream) {
|
|
const str = chunk.toString();
|
|
// Iterate over each character, keep track of current column (of the returned array)
|
|
for (let c = 0; c < str.length; ++c) {
|
|
const ch = str[c];
|
|
const nch = str[c + 1]; // Current character, next character
|
|
if (!(col in arr)) {
|
|
arr[col] = ""; // Create a new column (start with empty string) if necessary
|
|
}
|
|
|
|
// If the current character is a quotation mark, and we're inside a
|
|
// quoted field, and the next character is also a quotation mark,
|
|
// add a quotation mark to the current column and skip the next character
|
|
if (ch == '"' && quote && nch == '"') {
|
|
arr[col] += ch;
|
|
++c;
|
|
continue;
|
|
}
|
|
|
|
// If it's just one quotation mark, begin/end quoted field
|
|
if (ch == '"') {
|
|
quote = !quote;
|
|
continue;
|
|
}
|
|
|
|
// If it's a comma and we're not in a quoted field, move on to the next column
|
|
if (ch == "," && !quote) {
|
|
++col;
|
|
continue;
|
|
}
|
|
|
|
// If it's a newline (CRLF) and we're not in a quoted field, skip the next character
|
|
// and move on to the next row and move to column 0 of that new row
|
|
if (ch == "\r" && nch == "\n" && !quote) {
|
|
yield arr;
|
|
arr.length = 0; // Clear the row
|
|
col = 0;
|
|
++c;
|
|
continue;
|
|
}
|
|
|
|
// If it's a newline (LF or CR) and we're not in a quoted field,
|
|
// move on to the next row and move to column 0 of that new row
|
|
if (!quote && (ch == "\r" || ch == "\n")) {
|
|
yield arr;
|
|
arr.length = 0; // Clear the row
|
|
col = 0;
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, append the current character to the current column
|
|
arr[col] += ch;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const dir = path.join(process.cwd(), "data");
|
|
export const DbcFiles = {
|
|
achievement: path.join(dir, "Achievement_3.3.5_12340.csv"),
|
|
achievementCategory: path.join(dir, "AchievementCategory_3.3.5_12340.csv"),
|
|
areas: path.join(dir, "Areas.csv"),
|
|
faction: path.join(dir, "Factions.csv"),
|
|
glyphProperties: path.join(dir, "GlyphProperties_3.3.5_12340.csv"),
|
|
item: path.join(dir, "Item_3.3.5_12340.csv"),
|
|
itemRetail: path.join(dir, "Item_9.2.0_41462.csv"),
|
|
itemAppearance: path.join(dir, "ItemAppearance_9.2.0_41462.csv"),
|
|
itemModifiedAppearance: path.join(dir, "ItemModifiedAppearance_9.2.0_41462.csv"),
|
|
itemDisplayInfo: path.join(dir, "ItemDisplayInfo_3.3.5_12340.csv"),
|
|
mount: path.join(dir, "Mount_9.2.0_41462.csv"),
|
|
mountDisplay: path.join(dir, "MountXDisplay_9.2.0_41462.csv"),
|
|
skill: path.join(dir, "Skills.csv"),
|
|
spell: path.join(dir, "Spell_3.3.5_12340.csv"),
|
|
spellItemEnchantment: path.join(dir, "SpellItemEnchantment_3.3.5_12340.csv"),
|
|
spellIcon: path.join(dir, "SpellIcon_3.3.5_12340.csv"),
|
|
talent: path.join(dir, "Talent_3.3.5_12340.csv"),
|
|
talentTab: path.join(dir, "TalentTab_3.3.5_12340.csv"),
|
|
};
|
|
|
|
const dbcFields = {
|
|
achievement: ["id", "faction", "titleLang0", "descriptionLang0", "category", "points", "flags", "iconId"],
|
|
achievementCategory: ["id", "parent", "nameLang0"],
|
|
areas: ["id", "zoneName", "mapId", "areaId"],
|
|
glyphProperties: ["id", "spellId"],
|
|
item: ["id", "classId", "subclassId", "displayInfoId", "inventoryType"],
|
|
itemRetail: ["id", "inventoryType"],
|
|
itemAppearance: ["id", "itemDisplayInfoId"],
|
|
itemModifiedAppearance: ["id", "itemId", "itemAppearanceId"],
|
|
itemDisplayInfo: ["id", "inventoryIcon0"],
|
|
mount: ["id", "sourceSpellId"],
|
|
mountDisplay: ["id", "creatureDisplayInfoId", "mountId"],
|
|
skill: ["id", "name"],
|
|
spell: ["id", "mechanic", "spellIconId"],
|
|
spellItemEnchantment: ["id", "srcItemId"],
|
|
spellIcon: ["id", "textureFilename"],
|
|
talent: [
|
|
"id",
|
|
"tabId",
|
|
"tierId",
|
|
"columnIndex",
|
|
"spellRank0",
|
|
"spellRank1",
|
|
"spellRank2",
|
|
"spellRank3",
|
|
"spellRank4",
|
|
"prereqTalent0",
|
|
"prereqRank0",
|
|
],
|
|
talentTab: ["id", "nameLang0", "spellIconId", "classMask"],
|
|
faction: ["id", "reputationId", "name"],
|
|
};
|
|
|
|
export class DbcManager {
|
|
private _achievement: IAchievement[];
|
|
private _achievementCategory: IAchievementCategory[];
|
|
private _areas: IAreas[];
|
|
private _glyphProperties: IGlyphProperties[];
|
|
private _faction: IFactionDbc[];
|
|
private _item: IItemDbc[];
|
|
private _itemRetail: IItemRetailDbc[];
|
|
private _itemAppearance: IItemAppearanceDbc[];
|
|
private _itemModifiedAppearance: IItemModifiedAppearanceDbc[];
|
|
private _itemDisplayInfo: IItemDisplayInfoDbc[];
|
|
private _mount: IMountDbc[];
|
|
private _mountDisplay: IMountXDisplayDbc[];
|
|
private _skill: ISkillDbc[];
|
|
private _spell: ISpellDbc[];
|
|
private _spellItemEnchantment: ISpellItemEnchantmentDbc[];
|
|
private _spellIcon: ISpellIcon[];
|
|
private _talent: ITalent[];
|
|
private _talentTab: ITalentTab[];
|
|
|
|
public async loadAllFiles(): Promise<void> {
|
|
this._achievement = await this.read<IAchievement>(DbcFiles.achievement, dbcFields.achievement).toArray();
|
|
this._achievementCategory = await this.read<IAchievementCategory>(
|
|
DbcFiles.achievementCategory,
|
|
dbcFields.achievementCategory,
|
|
).toArray();
|
|
this._areas = await this.read<IAreas>(DbcFiles.areas).toArray();
|
|
this._glyphProperties = await this.read<IGlyphProperties>(DbcFiles.glyphProperties, dbcFields.glyphProperties).toArray();
|
|
this._item = await this.read<IItemDbc>(DbcFiles.item, dbcFields.item).toArray();
|
|
this._itemRetail = await this.read<IItemRetailDbc>(DbcFiles.itemRetail, dbcFields.itemRetail).toArray();
|
|
this._itemAppearance = await this.read<IItemAppearanceDbc>(DbcFiles.itemAppearance, dbcFields.itemAppearance).toArray();
|
|
this._itemModifiedAppearance = await this.read<IItemModifiedAppearanceDbc>(
|
|
DbcFiles.itemModifiedAppearance,
|
|
dbcFields.itemModifiedAppearance,
|
|
).toArray();
|
|
this._itemDisplayInfo = await this.read<IItemDisplayInfoDbc>(DbcFiles.itemDisplayInfo, dbcFields.itemDisplayInfo).toArray();
|
|
this._mount = await this.read<IMountDbc>(DbcFiles.mount, dbcFields.mount).toArray();
|
|
this._mountDisplay = await this.read<IMountXDisplayDbc>(DbcFiles.mountDisplay, dbcFields.mountDisplay).toArray();
|
|
this._skill = await this.read<ISkillDbc>(DbcFiles.skill).toArray();
|
|
this._spell = await this.read<ISpellDbc>(DbcFiles.spell, dbcFields.spell).toArray();
|
|
this._spellItemEnchantment = await this.read<ISpellItemEnchantmentDbc>(
|
|
DbcFiles.spellItemEnchantment,
|
|
dbcFields.spellItemEnchantment,
|
|
).toArray();
|
|
this._spellIcon = await this.read<ISpellIcon>(DbcFiles.spellIcon, dbcFields.spellIcon).toArray();
|
|
this._talent = await this.read<ITalent>(DbcFiles.talent, dbcFields.talent).toArray();
|
|
this._talentTab = await this.read<ITalentTab>(DbcFiles.talentTab, dbcFields.talentTab).toArray();
|
|
}
|
|
|
|
public achievement() {
|
|
return this.getLoadedDataOrRead(DbcFiles.achievement, this._achievement, dbcFields.achievement);
|
|
}
|
|
|
|
public achievementCategory() {
|
|
return this.getLoadedDataOrRead(DbcFiles.achievementCategory, this._achievementCategory, dbcFields.achievementCategory);
|
|
}
|
|
|
|
public areas() {
|
|
return this.getLoadedDataOrRead(DbcFiles.areas, this._areas);
|
|
}
|
|
|
|
public faction() {
|
|
return this.getLoadedDataOrRead(DbcFiles.faction, this._faction, dbcFields.faction);
|
|
}
|
|
|
|
public glyphProperties() {
|
|
return this.getLoadedDataOrRead(DbcFiles.glyphProperties, this._glyphProperties, dbcFields.glyphProperties);
|
|
}
|
|
|
|
public item() {
|
|
return this.getLoadedDataOrRead(DbcFiles.item, this._item, dbcFields.item);
|
|
}
|
|
|
|
public itemRetail() {
|
|
return this.getLoadedDataOrRead(DbcFiles.itemRetail, this._itemRetail, dbcFields.itemRetail);
|
|
}
|
|
|
|
public itemAppearance() {
|
|
return this.getLoadedDataOrRead(DbcFiles.itemAppearance, this._itemAppearance, dbcFields.itemAppearance);
|
|
}
|
|
|
|
public itemModifiedAppearance() {
|
|
return this.getLoadedDataOrRead(DbcFiles.itemModifiedAppearance, this._itemModifiedAppearance, dbcFields.itemModifiedAppearance);
|
|
}
|
|
|
|
public itemDisplayInfo() {
|
|
return this.getLoadedDataOrRead(DbcFiles.itemDisplayInfo, this._itemDisplayInfo, dbcFields.itemDisplayInfo);
|
|
}
|
|
|
|
public mount() {
|
|
return this.getLoadedDataOrRead(DbcFiles.mount, this._mount, dbcFields.mount);
|
|
}
|
|
|
|
public mountDisplay() {
|
|
return this.getLoadedDataOrRead(DbcFiles.mountDisplay, this._mountDisplay, dbcFields.mountDisplay);
|
|
}
|
|
|
|
public skill() {
|
|
return this.getLoadedDataOrRead(DbcFiles.skill, this._skill, dbcFields.skill);
|
|
}
|
|
|
|
public spell() {
|
|
return this.getLoadedDataOrRead(DbcFiles.spell, this._spell, dbcFields.spell);
|
|
}
|
|
|
|
public spellItemEnchantment() {
|
|
return this.getLoadedDataOrRead(DbcFiles.spellItemEnchantment, this._spellItemEnchantment, dbcFields.spellItemEnchantment);
|
|
}
|
|
|
|
public spellIcon() {
|
|
return this.getLoadedDataOrRead(DbcFiles.spellIcon, this._spellIcon, dbcFields.spellIcon);
|
|
}
|
|
|
|
public talent() {
|
|
return this.getLoadedDataOrRead(DbcFiles.talent, this._talent, dbcFields.talent);
|
|
}
|
|
|
|
public talentTab() {
|
|
return this.getLoadedDataOrRead(DbcFiles.talentTab, this._talentTab, dbcFields.talentTab);
|
|
}
|
|
|
|
private read<T>(file: string, keepFields: string[] = []): AsyncGenWrapper<T> {
|
|
const reader = new DbcReader<T>(file, keepFields);
|
|
return new AsyncGenWrapper(reader.read());
|
|
}
|
|
|
|
private getLoadedDataOrRead<T>(path: string, data: T[], keepFields: string[] = []): IAsyncGeneratorWithArrayMethods<T> {
|
|
return data === undefined ? this.read<T>(path, keepFields) : new ArrayAsAsyncGenerator(data);
|
|
}
|
|
}
|