Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-05 15:28:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Code style consistency.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-07-02 17:00:24 +02:00
parent 3c398d6133
commit 37690ef1e6
45 changed files with 1352 additions and 1358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/data_formats/Vec3.ts Normal file
View File

@ -0,0 +1,22 @@
export class Vec3 {
x: number;
y: number;
z: number;
constructor(x: number, y: number, z: number) {
this.x = x;
this.y = y;
this.z = z;
}
add(v: Vec3): Vec3 {
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this;
}
clone() {
return new Vec3(this.x, this.y, this.z);
}
}

257
src/data_formats/parsing/geometry.ts
View File

@ -1,23 +1,12 @@
import {
BufferAttribute,
BufferGeometry,
DoubleSide,
Face3,
Geometry,
Mesh,
MeshBasicMaterial,
MeshLambertMaterial,
Object3D,
TriangleStripDrawMode,
Vector3
} from 'three';
import { Vec3, Section } from '../../domain';
import Logger from 'js-logger'; import Logger from 'js-logger';
import { BufferGeometry, DoubleSide, Face3, Float32BufferAttribute, Geometry, Mesh, MeshBasicMaterial, MeshLambertMaterial, Object3D, TriangleStripDrawMode, Uint16BufferAttribute, Vector3 } from 'three';
import { Section } from '../../domain';
import { Vec3 } from "../Vec3";
const logger = Logger.get('data_formats/parsing/geometry'); const logger = Logger.get('data_formats/parsing/geometry');
export function parseCRel(arrayBuffer: ArrayBuffer): Object3D { export function parse_c_rel(array_buffer: ArrayBuffer): Object3D {
const dv = new DataView(arrayBuffer); const dv = new DataView(array_buffer);
const object = new Object3D(); const object = new Object3D();
const materials = [ const materials = [
@ -43,7 +32,7 @@ export function parseCRel(arrayBuffer: ArrayBuffer): Object3D {
side: DoubleSide side: DoubleSide
}) })
]; ];
const wireframeMaterials = [ const wireframe_materials = [
// Wall // Wall
new MeshBasicMaterial({ new MeshBasicMaterial({
color: 0x90D0E0, color: 0x90D0E0,
@ -68,33 +57,33 @@ export function parseCRel(arrayBuffer: ArrayBuffer): Object3D {
}) })
]; ];
const mainBlockOffset = dv.getUint32(dv.byteLength - 16, true); const main_block_offset = dv.getUint32(dv.byteLength - 16, true);
const mainOffsetTableOffset = dv.getUint32(mainBlockOffset, true); const main_offset_table_offset = dv.getUint32(main_block_offset, true);
for ( for (
let i = mainOffsetTableOffset; let i = main_offset_table_offset;
i === mainOffsetTableOffset || dv.getUint32(i) !== 0; i === main_offset_table_offset || dv.getUint32(i) !== 0;
i += 24 i += 24
) { ) {
const blockGeometry = new Geometry(); const block_geometry = new Geometry();
const blockTrailerOffset = dv.getUint32(i, true); const block_trailer_offset = dv.getUint32(i, true);
const vertexCount = dv.getUint32(blockTrailerOffset, true); const vertex_count = dv.getUint32(block_trailer_offset, true);
const vertexTableOffset = dv.getUint32(blockTrailerOffset + 4, true); const vertex_table_offset = dv.getUint32(block_trailer_offset + 4, true);
const vertexTableEnd = vertexTableOffset + 12 * vertexCount; const vertex_table_end = vertex_table_offset + 12 * vertex_count;
const triangleCount = dv.getUint32(blockTrailerOffset + 8, true); const triangle_count = dv.getUint32(block_trailer_offset + 8, true);
const triangleTableOffset = dv.getUint32(blockTrailerOffset + 12, true); const triangle_table_offset = dv.getUint32(block_trailer_offset + 12, true);
const triangleTableEnd = triangleTableOffset + 36 * triangleCount; const triangle_table_end = triangle_table_offset + 36 * triangle_count;
for (let j = vertexTableOffset; j < vertexTableEnd; j += 12) { for (let j = vertex_table_offset; j < vertex_table_end; j += 12) {
const x = dv.getFloat32(j, true); const x = dv.getFloat32(j, true);
const y = dv.getFloat32(j + 4, true); const y = dv.getFloat32(j + 4, true);
const z = dv.getFloat32(j + 8, true); const z = dv.getFloat32(j + 8, true);
blockGeometry.vertices.push(new Vector3(x, y, z)); block_geometry.vertices.push(new Vector3(x, y, z));
} }
for (let j = triangleTableOffset; j < triangleTableEnd; j += 36) { for (let j = triangle_table_offset; j < triangle_table_end; j += 36) {
const v1 = dv.getUint16(j, true); const v1 = dv.getUint16(j, true);
const v2 = dv.getUint16(j + 2, true); const v2 = dv.getUint16(j + 2, true);
const v3 = dv.getUint16(j + 4, true); const v3 = dv.getUint16(j + 4, true);
@ -104,70 +93,68 @@ export function parseCRel(arrayBuffer: ArrayBuffer): Object3D {
dv.getFloat32(j + 12, true), dv.getFloat32(j + 12, true),
dv.getFloat32(j + 16, true) dv.getFloat32(j + 16, true)
); );
const isSectionTransition = flags & 0b1000000; const is_section_transition = flags & 0b1000000;
const isVegetation = flags & 0b10000; const is_vegetation = flags & 0b10000;
const isGround = flags & 0b1; const is_ground = flags & 0b1;
const colorIndex = isSectionTransition ? 3 : (isVegetation ? 2 : (isGround ? 1 : 0)); const color_index = is_section_transition ? 3 : (is_vegetation ? 2 : (is_ground ? 1 : 0));
blockGeometry.faces.push(new Face3(v1, v2, v3, n, undefined, colorIndex)); block_geometry.faces.push(new Face3(v1, v2, v3, n, undefined, color_index));
} }
const mesh = new Mesh(blockGeometry, materials); const mesh = new Mesh(block_geometry, materials);
mesh.renderOrder = 1; mesh.renderOrder = 1;
object.add(mesh); object.add(mesh);
const wireframeMesh = new Mesh(blockGeometry, wireframeMaterials); const wireframe_mesh = new Mesh(block_geometry, wireframe_materials);
wireframeMesh.renderOrder = 2; wireframe_mesh.renderOrder = 2;
object.add(wireframeMesh); object.add(wireframe_mesh);
} }
return object; return object;
} }
export function parseNRel( export function parse_n_rel(
arrayBuffer: ArrayBuffer array_buffer: ArrayBuffer
): { sections: Section[], object3d: Object3D } { ): { sections: Section[], object_3d: Object3D } {
const dv = new DataView(arrayBuffer); const dv = new DataView(array_buffer);
const sections = new Map(); const sections = new Map();
const object = new Object3D(); const object = new Object3D();
const mainBlockOffset = dv.getUint32(dv.byteLength - 16, true); const main_block_offset = dv.getUint32(dv.byteLength - 16, true);
const sectionCount = dv.getUint32(mainBlockOffset + 8, true); const section_count = dv.getUint32(main_block_offset + 8, true);
const sectionTableOffset = dv.getUint32(mainBlockOffset + 16, true); const section_table_offset = dv.getUint32(main_block_offset + 16, true);
// const textureNameOffset = dv.getUint32(mainBlockOffset + 20, true); // const texture_name_offset = dv.getUint32(main_block_offset + 20, true);
for ( for (
let i = sectionTableOffset; let i = section_table_offset;
i < sectionTableOffset + sectionCount * 52; i < section_table_offset + section_count * 52;
i += 52 i += 52
) { ) {
const sectionId = dv.getInt32(i, true); const section_id = dv.getInt32(i, true);
const sectionX = dv.getFloat32(i + 4, true); const section_x = dv.getFloat32(i + 4, true);
const sectionY = dv.getFloat32(i + 8, true); const section_y = dv.getFloat32(i + 8, true);
const sectionZ = dv.getFloat32(i + 12, true); const section_z = dv.getFloat32(i + 12, true);
const sectionRotation = dv.getInt32(i + 20, true) / 0xFFFF * 2 * Math.PI; const section_rotation = dv.getInt32(i + 20, true) / 0xFFFF * 2 * Math.PI;
const section = new Section( const section = new Section(
sectionId, section_id,
new Vec3(sectionX, sectionY, sectionZ), new Vec3(section_x, section_y, section_z),
sectionRotation section_rotation
); );
sections.set(sectionId, section); sections.set(section_id, section);
const indexListsList = []; const index_lists_list = [];
const positionListsList = []; const position_lists_list = [];
const normalListsList = []; const normal_lists_list = [];
const simpleGeometryOffsetTableOffset = dv.getUint32(i + 32, true); const simple_geometry_offset_table_offset = dv.getUint32(i + 32, true);
// const complexGeometryOffsetTableOffset = dv.getUint32(i + 36, true); // const complex_geometry_offset_table_offset = dv.getUint32(i + 36, true);
const simpleGeometryOffsetCount = dv.getUint32(i + 40, true); const simple_geometry_offset_count = dv.getUint32(i + 40, true);
// const complexGeometryOffsetCount = dv.getUint32(i + 44, true); // const complex_geometry_offset_count = dv.getUint32(i + 44, true);
// logger.log(`section id: ${sectionId}, section rotation: ${sectionRotation}, simple vertices: ${simpleGeometryOffsetCount}, complex vertices: ${complexGeometryOffsetCount}`);
for ( for (
let j = simpleGeometryOffsetTableOffset; let j = simple_geometry_offset_table_offset;
j < simpleGeometryOffsetTableOffset + simpleGeometryOffsetCount * 16; j < simple_geometry_offset_table_offset + simple_geometry_offset_count * 16;
j += 16 j += 16
) { ) {
let offset = dv.getUint32(j, true); let offset = dv.getUint32(j, true);
@ -177,41 +164,39 @@ export function parseNRel(
offset = dv.getUint32(offset, true); offset = dv.getUint32(offset, true);
} }
const geometryOffset = dv.getUint32(offset + 4, true); const geometry_offset = dv.getUint32(offset + 4, true);
if (geometryOffset > 0) { if (geometry_offset > 0) {
const vertexInfoTableOffset = dv.getUint32(geometryOffset + 4, true); const vertex_info_table_offset = dv.getUint32(geometry_offset + 4, true);
const vertexInfoCount = dv.getUint32(geometryOffset + 8, true); const vertex_info_count = dv.getUint32(geometry_offset + 8, true);
const triangleStripTableOffset = dv.getUint32(geometryOffset + 12, true); const triangle_strip_table_offset = dv.getUint32(geometry_offset + 12, true);
const triangleStripCount = dv.getUint32(geometryOffset + 16, true); const triangle_strip_count = dv.getUint32(geometry_offset + 16, true);
// const transparentObjectTableOffset = dv.getUint32(blockOffset + 20, true); // const transparent_object_table_offset = dv.getUint32(blockOffset + 20, true);
// const transparentObjectCount = dv.getUint32(blockOffset + 24, true); // const transparent_object_count = dv.getUint32(blockOffset + 24, true);
// logger.log(`block offset: ${blockOffset}, vertex info count: ${vertexInfoCount}, object table offset ${objectTableOffset}, object count: ${objectCount}, transparent object count: ${transparentObjectCount}`); const geom_index_lists = [];
const geomIndexLists = [];
for ( for (
let k = triangleStripTableOffset; let k = triangle_strip_table_offset;
k < triangleStripTableOffset + triangleStripCount * 20; k < triangle_strip_table_offset + triangle_strip_count * 20;
k += 20 k += 20
) { ) {
// const flagAndTextureIdOffset = dv.getUint32(k, true); // const flag_and_texture_id_offset = dv.getUint32(k, true);
// const dataType = dv.getUint32(k + 4, true); // const data_type = dv.getUint32(k + 4, true);
const triangleStripIndexTableOffset = dv.getUint32(k + 8, true); const triangle_strip_index_table_offset = dv.getUint32(k + 8, true);
const triangleStripIndexCount = dv.getUint32(k + 12, true); const triangle_strip_index_count = dv.getUint32(k + 12, true);
const triangleStripIndices = []; const triangle_strip_indices = [];
for ( for (
let l = triangleStripIndexTableOffset; let l = triangle_strip_index_table_offset;
l < triangleStripIndexTableOffset + triangleStripIndexCount * 2; l < triangle_strip_index_table_offset + triangle_strip_index_count * 2;
l += 2 l += 2
) { ) {
triangleStripIndices.push(dv.getUint16(l, true)); triangle_strip_indices.push(dv.getUint16(l, true));
} }
geomIndexLists.push(triangleStripIndices); geom_index_lists.push(triangle_strip_indices);
// TODO: Read texture info. // TODO: Read texture info.
} }
@ -219,66 +204,62 @@ export function parseNRel(
// TODO: Do the previous for the transparent index table. // TODO: Do the previous for the transparent index table.
// Assume vertexInfoCount == 1. TODO: Does that make sense? // Assume vertexInfoCount == 1. TODO: Does that make sense?
if (vertexInfoCount > 1) { if (vertex_info_count > 1) {
logger.warn(`Vertex info count of ${vertexInfoCount} was larger than expected.`); logger.warn(`Vertex info count of ${vertex_info_count} was larger than expected.`);
} }
// const vertexType = dv.getUint32(vertexInfoTableOffset, true); // const vertex_type = dv.getUint32(vertexInfoTableOffset, true);
const vertexTableOffset = dv.getUint32(vertexInfoTableOffset + 4, true); const vertex_table_offset = dv.getUint32(vertex_info_table_offset + 4, true);
const vertexSize = dv.getUint32(vertexInfoTableOffset + 8, true); const vertex_size = dv.getUint32(vertex_info_table_offset + 8, true);
const vertexCount = dv.getUint32(vertexInfoTableOffset + 12, true); const vertex_count = dv.getUint32(vertex_info_table_offset + 12, true);
// logger.log(`vertex type: ${vertexType}, vertex size: ${vertexSize}, vertex count: ${vertexCount}`); const geom_positions = [];
const geom_normals = [];
const geomPositions = [];
const geomNormals = [];
for ( for (
let k = vertexTableOffset; let k = vertex_table_offset;
k < vertexTableOffset + vertexCount * vertexSize; k < vertex_table_offset + vertex_count * vertex_size;
k += vertexSize k += vertex_size
) { ) {
let nX, nY, nZ; let n_x, n_y, n_z;
switch (vertexSize) { switch (vertex_size) {
case 16: case 16:
case 24: case 24:
// TODO: are these values sensible? // TODO: are these values sensible?
nX = 0; n_x = 0;
nY = 1; n_y = 1;
nZ = 0; n_z = 0;
break; break;
case 28: case 28:
case 36: case 36:
nX = dv.getFloat32(k + 12, true); n_x = dv.getFloat32(k + 12, true);
nY = dv.getFloat32(k + 16, true); n_y = dv.getFloat32(k + 16, true);
nZ = dv.getFloat32(k + 20, true); n_z = dv.getFloat32(k + 20, true);
// TODO: color, texture coords. // TODO: color, texture coords.
break; break;
default: default:
logger.error(`Unexpected vertex size of ${vertexSize}.`); logger.error(`Unexpected vertex size of ${vertex_size}.`);
continue; continue;
} }
const x = dv.getFloat32(k, true); const x = dv.getFloat32(k, true);
const y = dv.getFloat32(k + 4, true); const y = dv.getFloat32(k + 4, true);
const z = dv.getFloat32(k + 8, true); const z = dv.getFloat32(k + 8, true);
const rotatedX = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z; const rotated_x = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z;
const rotatedZ = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z; const rotated_z = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z;
geomPositions.push(sectionX + rotatedX); geom_positions.push(section_x + rotated_x);
geomPositions.push(sectionY + y); geom_positions.push(section_y + y);
geomPositions.push(sectionZ + rotatedZ); geom_positions.push(section_z + rotated_z);
geomNormals.push(nX); geom_normals.push(n_x);
geomNormals.push(nY); geom_normals.push(n_y);
geomNormals.push(nZ); geom_normals.push(n_z);
} }
indexListsList.push(geomIndexLists); index_lists_list.push(geom_index_lists);
positionListsList.push(geomPositions); position_lists_list.push(geom_positions);
normalListsList.push(geomNormals); normal_lists_list.push(geom_normals);
} else {
// logger.error(`Block offset at ${offset + 4} was ${blockOffset}.`);
} }
} }
@ -286,13 +267,13 @@ export function parseNRel(
// return v[0] === w[0] && v[1] === w[1] && v[2] === w[2]; // return v[0] === w[0] && v[1] === w[1] && v[2] === w[2];
// } // }
for (let i = 0; i < positionListsList.length; ++i) { for (let i = 0; i < position_lists_list.length; ++i) {
const positions = positionListsList[i]; const positions = position_lists_list[i];
const normals = normalListsList[i]; const normals = normal_lists_list[i];
const geomIndexLists = indexListsList[i]; const geom_index_lists = index_lists_list[i];
// const indices = []; // const indices = [];
geomIndexLists.forEach(objectIndices => { geom_index_lists.forEach(object_indices => {
// for (let j = 2; j < objectIndices.length; ++j) { // for (let j = 2; j < objectIndices.length; ++j) {
// const a = objectIndices[j - 2]; // const a = objectIndices[j - 2];
// const b = objectIndices[j - 1]; // const b = objectIndices[j - 1];
@ -318,11 +299,9 @@ export function parseNRel(
// } // }
const geometry = new BufferGeometry(); const geometry = new BufferGeometry();
geometry.addAttribute( geometry.addAttribute('position', new Float32BufferAttribute(positions, 3));
'position', new BufferAttribute(new Float32Array(positions), 3)); geometry.addAttribute('normal', new Float32BufferAttribute(normals, 3));
geometry.addAttribute( geometry.setIndex(new Uint16BufferAttribute(object_indices, 1));
'normal', new BufferAttribute(new Float32Array(normals), 3));
geometry.setIndex(new BufferAttribute(new Uint16Array(objectIndices), 1));
const mesh = new Mesh( const mesh = new Mesh(
geometry, geometry,
@ -372,6 +351,6 @@ export function parseNRel(
return { return {
sections: [...sections.values()].sort((a, b) => a.id - b.id), sections: [...sections.values()].sort((a, b) => a.id - b.id),
object3d: object object_3d: object
}; };
} }

208
src/data_formats/parsing/itempmt.ts
View File

@ -1,7 +1,7 @@
import { BufferCursor } from "../BufferCursor"; import { BufferCursor } from "../BufferCursor";
export type ItemPmt = { export type ItemPmt = {
statBoosts: PmtStatBoost[], stat_boosts: PmtStatBoost[],
armors: PmtArmor[], armors: PmtArmor[],
shields: PmtShield[], shields: PmtShield[],
units: PmtUnit[], units: PmtUnit[],
@ -10,63 +10,63 @@ export type ItemPmt = {
} }
export type PmtStatBoost = { export type PmtStatBoost = {
stat1: number, stat_1: number,
stat2: number, stat_2: number,
amount1: number, amount_1: number,
amount2: number, amount_2: number,
} }
export type PmtWeapon = { export type PmtWeapon = {
id: number, id: number,
type: number, type: number,
skin: number, skin: number,
teamPoints: number, team_points: number,
class: number, class: number,
reserved1: number, reserved_1: number,
minAtp: number, min_atp: number,
maxAtp: number, max_atp: number,
reqAtp: number, req_atp: number,
reqMst: number, req_mst: number,
reqAta: number, req_ata: number,
mst: number, mst: number,
maxGrind: number, max_grind: number,
photon: number, photon: number,
special: number, special: number,
ata: number, ata: number,
statBoost: number, stat_boost: number,
projectile: number, projectile: number,
photonTrail1X: number, photon_trail_1_x: number,
photonTrail1Y: number, photon_trail_1_y: number,
photonTrail2X: number, photon_trail_2_x: number,
photonTrail2Y: number, photon_trail_2_y: number,
photonType: number, photon_type: number,
unknown1: number[], unknown_1: number[],
techBoost: number, tech_boost: number,
comboType: number, combo_type: number,
} }
export type PmtArmor = { export type PmtArmor = {
id: number, id: number,
type: number, type: number,
skin: number, skin: number,
teamPoints: number, team_points: number,
dfp: number, dfp: number,
evp: number, evp: number,
blockParticle: number, block_particle: number,
blockEffect: number, block_effect: number,
class: number, class: number,
reserved1: number, reserved_1: number,
requiredLevel: number, required_level: number,
efr: number, efr: number,
eth: number, eth: number,
eic: number, eic: number,
edk: number, edk: number,
elt: number, elt: number,
dfpRange: number, dfp_range: number,
evpRange: number, evp_range: number,
statBoost: number, stat_boost: number,
techBoost: number, tech_boost: number,
unknown1: number, unknown_1: number,
} }
export type PmtShield = PmtArmor export type PmtShield = PmtArmor
@ -75,10 +75,10 @@ export type PmtUnit = {
id: number, id: number,
type: number, type: number,
skin: number, skin: number,
teamPoints: number, team_points: number,
stat: number, stat: number,
statAmount: number, stat_amount: number,
plusMinus: number, plus_minus: number,
reserved: number[] reserved: number[]
} }
@ -86,74 +86,74 @@ export type PmtTool = {
id: number, id: number,
type: number, type: number,
skin: number, skin: number,
teamPoints: number, team_points: number,
amount: number, amount: number,
tech: number, tech: number,
cost: number, cost: number,
itemFlag: number, item_flag: number,
reserved: number[], reserved: number[],
} }
export function parseItemPmt(cursor: BufferCursor): ItemPmt { export function parse_item_pmt(cursor: BufferCursor): ItemPmt {
cursor.seek_end(32); cursor.seek_end(32);
const mainTableOffset = cursor.u32(); const main_table_offset = cursor.u32();
const mainTableSize = cursor.u32(); const main_table_size = cursor.u32();
// const mainTableCount = cursor.u32(); // Should be 1. // const main_table_count = cursor.u32(); // Should be 1.
cursor.seek_start(mainTableOffset); cursor.seek_start(main_table_offset);
const compactTableOffsets = cursor.u16_array(mainTableSize); const compact_table_offsets = cursor.u16_array(main_table_size);
const tableOffsets: { offset: number, size: number }[] = []; const table_offsets: { offset: number, size: number }[] = [];
let expandedOffset: number = 0; let expanded_offset: number = 0;
for (const compactOffset of compactTableOffsets) { for (const compact_offset of compact_table_offsets) {
expandedOffset = expandedOffset + 4 * compactOffset; expanded_offset = expanded_offset + 4 * compact_offset;
cursor.seek_start(expandedOffset - 4); cursor.seek_start(expanded_offset - 4);
const size = cursor.u32(); const size = cursor.u32();
const offset = cursor.u32(); const offset = cursor.u32();
tableOffsets.push({ offset, size }); table_offsets.push({ offset, size });
} }
const itemPmt: ItemPmt = { const item_pmt: ItemPmt = {
// This size (65268) of this table seems wrong, so we pass in a hard-coded value. // This size (65268) of this table seems wrong, so we pass in a hard-coded value.
statBoosts: parseStatBoosts(cursor, tableOffsets[305].offset, 52), stat_boosts: parse_stat_boosts(cursor, table_offsets[305].offset, 52),
armors: parseArmors(cursor, tableOffsets[7].offset, tableOffsets[7].size), armors: parse_armors(cursor, table_offsets[7].offset, table_offsets[7].size),
shields: parseShields(cursor, tableOffsets[8].offset, tableOffsets[8].size), shields: parse_shields(cursor, table_offsets[8].offset, table_offsets[8].size),
units: parseUnits(cursor, tableOffsets[9].offset, tableOffsets[9].size), units: parse_units(cursor, table_offsets[9].offset, table_offsets[9].size),
tools: [], tools: [],
weapons: [], weapons: [],
}; };
for (let i = 11; i <= 37; i++) { for (let i = 11; i <= 37; i++) {
itemPmt.tools.push(parseTools(cursor, tableOffsets[i].offset, tableOffsets[i].size)); item_pmt.tools.push(parse_tools(cursor, table_offsets[i].offset, table_offsets[i].size));
} }
for (let i = 38; i <= 275; i++) { for (let i = 38; i <= 275; i++) {
itemPmt.weapons.push( item_pmt.weapons.push(
parseWeapons(cursor, tableOffsets[i].offset, tableOffsets[i].size) parse_weapons(cursor, table_offsets[i].offset, table_offsets[i].size)
); );
} }
return itemPmt; return item_pmt;
} }
function parseStatBoosts(cursor: BufferCursor, offset: number, size: number): PmtStatBoost[] { function parse_stat_boosts(cursor: BufferCursor, offset: number, size: number): PmtStatBoost[] {
cursor.seek_start(offset); cursor.seek_start(offset);
const statBoosts: PmtStatBoost[] = []; const stat_boosts: PmtStatBoost[] = [];
for (let i = 0; i < size; i++) { for (let i = 0; i < size; i++) {
statBoosts.push({ stat_boosts.push({
stat1: cursor.u8(), stat_1: cursor.u8(),
stat2: cursor.u8(), stat_2: cursor.u8(),
amount1: cursor.i16(), amount_1: cursor.i16(),
amount2: cursor.i16(), amount_2: cursor.i16(),
}); });
} }
return statBoosts; return stat_boosts;
} }
function parseWeapons(cursor: BufferCursor, offset: number, size: number): PmtWeapon[] { function parse_weapons(cursor: BufferCursor, offset: number, size: number): PmtWeapon[] {
cursor.seek_start(offset); cursor.seek_start(offset);
const weapons: PmtWeapon[] = []; const weapons: PmtWeapon[] = [];
@ -162,36 +162,36 @@ function parseWeapons(cursor: BufferCursor, offset: number, size: number): PmtWe
id: cursor.u32(), id: cursor.u32(),
type: cursor.i16(), type: cursor.i16(),
skin: cursor.i16(), skin: cursor.i16(),
teamPoints: cursor.i32(), team_points: cursor.i32(),
class: cursor.u8(), class: cursor.u8(),
reserved1: cursor.u8(), reserved_1: cursor.u8(),
minAtp: cursor.i16(), min_atp: cursor.i16(),
maxAtp: cursor.i16(), max_atp: cursor.i16(),
reqAtp: cursor.i16(), req_atp: cursor.i16(),
reqMst: cursor.i16(), req_mst: cursor.i16(),
reqAta: cursor.i16(), req_ata: cursor.i16(),
mst: cursor.i16(), mst: cursor.i16(),
maxGrind: cursor.u8(), max_grind: cursor.u8(),
photon: cursor.i8(), photon: cursor.i8(),
special: cursor.u8(), special: cursor.u8(),
ata: cursor.u8(), ata: cursor.u8(),
statBoost: cursor.u8(), stat_boost: cursor.u8(),
projectile: cursor.u8(), projectile: cursor.u8(),
photonTrail1X: cursor.i8(), photon_trail_1_x: cursor.i8(),
photonTrail1Y: cursor.i8(), photon_trail_1_y: cursor.i8(),
photonTrail2X: cursor.i8(), photon_trail_2_x: cursor.i8(),
photonTrail2Y: cursor.i8(), photon_trail_2_y: cursor.i8(),
photonType: cursor.i8(), photon_type: cursor.i8(),
unknown1: cursor.u8_array(5), unknown_1: cursor.u8_array(5),
techBoost: cursor.u8(), tech_boost: cursor.u8(),
comboType: cursor.u8(), combo_type: cursor.u8(),
}); });
} }
return weapons; return weapons;
} }
function parseArmors(cursor: BufferCursor, offset: number, size: number): PmtArmor[] { function parse_armors(cursor: BufferCursor, offset: number, size: number): PmtArmor[] {
cursor.seek_start(offset); cursor.seek_start(offset);
const armors: PmtArmor[] = []; const armors: PmtArmor[] = [];
@ -200,35 +200,35 @@ function parseArmors(cursor: BufferCursor, offset: number, size: number): PmtArm
id: cursor.u32(), id: cursor.u32(),
type: cursor.i16(), type: cursor.i16(),
skin: cursor.i16(), skin: cursor.i16(),
teamPoints: cursor.i32(), team_points: cursor.i32(),
dfp: cursor.i16(), dfp: cursor.i16(),
evp: cursor.i16(), evp: cursor.i16(),
blockParticle: cursor.u8(), block_particle: cursor.u8(),
blockEffect: cursor.u8(), block_effect: cursor.u8(),
class: cursor.u8(), class: cursor.u8(),
reserved1: cursor.u8(), reserved_1: cursor.u8(),
requiredLevel: cursor.u8(), required_level: cursor.u8(),
efr: cursor.u8(), efr: cursor.u8(),
eth: cursor.u8(), eth: cursor.u8(),
eic: cursor.u8(), eic: cursor.u8(),
edk: cursor.u8(), edk: cursor.u8(),
elt: cursor.u8(), elt: cursor.u8(),
dfpRange: cursor.u8(), dfp_range: cursor.u8(),
evpRange: cursor.u8(), evp_range: cursor.u8(),
statBoost: cursor.u8(), stat_boost: cursor.u8(),
techBoost: cursor.u8(), tech_boost: cursor.u8(),
unknown1: cursor.i16(), unknown_1: cursor.i16(),
}); });
} }
return armors; return armors;
} }
function parseShields(cursor: BufferCursor, offset: number, size: number): PmtShield[] { function parse_shields(cursor: BufferCursor, offset: number, size: number): PmtShield[] {
return parseArmors(cursor, offset, size); return parse_armors(cursor, offset, size);
} }
function parseUnits(cursor: BufferCursor, offset: number, size: number): PmtUnit[] { function parse_units(cursor: BufferCursor, offset: number, size: number): PmtUnit[] {
cursor.seek_start(offset); cursor.seek_start(offset);
const units: PmtUnit[] = []; const units: PmtUnit[] = [];
@ -237,10 +237,10 @@ function parseUnits(cursor: BufferCursor, offset: number, size: number): PmtUnit
id: cursor.u32(), id: cursor.u32(),
type: cursor.i16(), type: cursor.i16(),
skin: cursor.i16(), skin: cursor.i16(),
teamPoints: cursor.i32(), team_points: cursor.i32(),
stat: cursor.i16(), stat: cursor.i16(),
statAmount: cursor.i16(), stat_amount: cursor.i16(),
plusMinus: cursor.u8(), plus_minus: cursor.u8(),
reserved: cursor.u8_array(3), reserved: cursor.u8_array(3),
}); });
} }
@ -248,7 +248,7 @@ function parseUnits(cursor: BufferCursor, offset: number, size: number): PmtUnit
return units; return units;
} }
function parseTools(cursor: BufferCursor, offset: number, size: number): PmtTool[] { function parse_tools(cursor: BufferCursor, offset: number, size: number): PmtTool[] {
cursor.seek_start(offset); cursor.seek_start(offset);
const tools: PmtTool[] = []; const tools: PmtTool[] = [];
@ -257,11 +257,11 @@ function parseTools(cursor: BufferCursor, offset: number, size: number): PmtTool
id: cursor.u32(), id: cursor.u32(),
type: cursor.i16(), type: cursor.i16(),
skin: cursor.i16(), skin: cursor.i16(),
teamPoints: cursor.i32(), team_points: cursor.i32(),
amount: cursor.i16(), amount: cursor.i16(),
tech: cursor.i16(), tech: cursor.i16(),
cost: cursor.i32(), cost: cursor.i32(),
itemFlag: cursor.u8(), item_flag: cursor.u8(),
reserved: cursor.u8_array(3), reserved: cursor.u8_array(3),
}); });
} }

2
src/data_formats/parsing/ninja/index.ts
View File

@ -1,4 +1,4 @@
import { Vec3 } from '../../../domain'; import { Vec3 } from "../../Vec3";
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import { NjModel, parse_nj_model } from './nj'; import { NjModel, parse_nj_model } from './nj';
import { parse_xj_model, XjModel } from './xj'; import { parse_xj_model, XjModel } from './xj';

2
src/data_formats/parsing/ninja/motion.ts
View File

@ -1,5 +1,5 @@
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import { Vec3 } from '../../../domain'; import { Vec3 } from "../../Vec3";
const ANGLE_TO_RAD = 2 * Math.PI / 0xFFFF; const ANGLE_TO_RAD = 2 * Math.PI / 0xFFFF;

2
src/data_formats/parsing/ninja/nj.ts
View File

@ -1,6 +1,6 @@
import Logger from 'js-logger'; import Logger from 'js-logger';
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import { Vec3 } from '../../../domain'; import { Vec3 } from "../../Vec3";
import { NinjaVertex } from '../ninja'; import { NinjaVertex } from '../ninja';
const logger = Logger.get('data_formats/parsing/ninja/nj'); const logger = Logger.get('data_formats/parsing/ninja/nj');

2
src/data_formats/parsing/ninja/xj.ts
View File

@ -1,5 +1,5 @@
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import { Vec3 } from '../../../domain'; import { Vec3 } from "../../Vec3";
import { NinjaVertex } from '../ninja'; import { NinjaVertex } from '../ninja';
// TODO: // TODO:

18
src/data_formats/parsing/quest/bin.test.ts
View File

@ -1,23 +1,23 @@
import * as fs from 'fs'; import * as fs from 'fs';
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import * as prs from '../../compression/prs'; import * as prs from '../../compression/prs';
import { parseBin, writeBin } from './bin'; import { parse_bin, write_bin } from './bin';
/** /**
* Parse a file, convert the resulting structure to BIN again and check whether the end result is equal to the original. * Parse a file, convert the resulting structure to BIN again and check whether the end result is equal to the original.
*/ */
test('parseBin and writeBin', () => { test('parse_bin and write_bin', () => {
const origBuffer = fs.readFileSync('test/resources/quest118_e.bin').buffer; const orig_buffer = fs.readFileSync('test/resources/quest118_e.bin').buffer;
const origBin = prs.decompress(new BufferCursor(origBuffer, true)); const orig_bin = prs.decompress(new BufferCursor(orig_buffer, true));
const testBin = writeBin(parseBin(origBin)); const test_bin = write_bin(parse_bin(orig_bin));
origBin.seek_start(0); orig_bin.seek_start(0);
expect(testBin.size).toBe(origBin.size); expect(test_bin.size).toBe(orig_bin.size);
let match = true; let match = true;
while (origBin.bytes_left) { while (orig_bin.bytes_left) {
if (testBin.u8() !== origBin.u8()) { if (test_bin.u8() !== orig_bin.u8()) {
match = false; match = false;
break; break;
} }

98
src/data_formats/parsing/quest/bin.ts
View File

@ -4,59 +4,59 @@ import Logger from 'js-logger';
const logger = Logger.get('data_formats/parsing/quest/bin'); const logger = Logger.get('data_formats/parsing/quest/bin');
export interface BinFile { export interface BinFile {
questNumber: number; quest_id: number;
language: number; language: number;
questName: string; quest_name: string;
shortDescription: string; short_description: string;
longDescription: string; long_description: string;
functionOffsets: number[]; function_offsets: number[];
instructions: Instruction[]; instructions: Instruction[];
data: BufferCursor; data: BufferCursor;
} }
export function parseBin(cursor: BufferCursor, lenient: boolean = false): BinFile { export function parse_bin(cursor: BufferCursor, lenient: boolean = false): BinFile {
const objectCodeOffset = cursor.u32(); const object_code_offset = cursor.u32();
const functionOffsetTableOffset = cursor.u32(); // Relative offsets const function_offset_table_offset = cursor.u32(); // Relative offsets
const size = cursor.u32(); const size = cursor.u32();
cursor.seek(4); // Always seems to be 0xFFFFFFFF cursor.seek(4); // Always seems to be 0xFFFFFFFF
const questNumber = cursor.u32(); const quest_id = cursor.u32();
const language = cursor.u32(); const language = cursor.u32();
const questName = cursor.string_utf16(64, true, true); const quest_name = cursor.string_utf16(64, true, true);
const shortDescription = cursor.string_utf16(256, true, true); const short_description = cursor.string_utf16(256, true, true);
const longDescription = cursor.string_utf16(576, true, true); const long_description = cursor.string_utf16(576, true, true);
if (size !== cursor.size) { if (size !== cursor.size) {
logger.warn(`Value ${size} in bin size field does not match actual size ${cursor.size}.`); logger.warn(`Value ${size} in bin size field does not match actual size ${cursor.size}.`);
} }
const functionOffsetCount = Math.floor( const function_offset_count = Math.floor(
(cursor.size - functionOffsetTableOffset) / 4); (cursor.size - function_offset_table_offset) / 4);
cursor.seek_start(functionOffsetTableOffset); cursor.seek_start(function_offset_table_offset);
const functionOffsets = []; const function_offsets = [];
for (let i = 0; i < functionOffsetCount; ++i) { for (let i = 0; i < function_offset_count; ++i) {
functionOffsets.push(cursor.i32()); function_offsets.push(cursor.i32());
} }
const instructions = parseObjectCode( const instructions = parse_object_code(
cursor.seek_start(objectCodeOffset).take(functionOffsetTableOffset - objectCodeOffset), cursor.seek_start(object_code_offset).take(function_offset_table_offset - object_code_offset),
lenient lenient
); );
return { return {
questNumber, quest_id,
language, language,
questName, quest_name,
shortDescription, short_description,
longDescription, long_description,
functionOffsets, function_offsets,
instructions, instructions,
data: cursor.seek_start(0).take(cursor.size) data: cursor.seek_start(0).take(cursor.size)
}; };
} }
export function writeBin({ data }: { data: BufferCursor }): BufferCursor { export function write_bin({ data }: { data: BufferCursor }): BufferCursor {
return data.seek_start(0); return data.seek_start(0);
} }
@ -67,44 +67,44 @@ export interface Instruction {
size: number; size: number;
} }
function parseObjectCode(cursor: BufferCursor, lenient: boolean): Instruction[] { function parse_object_code(cursor: BufferCursor, lenient: boolean): Instruction[] {
const instructions = []; const instructions = [];
try { try {
while (cursor.bytes_left) { while (cursor.bytes_left) {
const mainOpcode = cursor.u8(); const main_opcode = cursor.u8();
let opcode; let opcode;
let opsize; let opsize;
let list; let list;
switch (mainOpcode) { switch (main_opcode) {
case 0xF8: case 0xF8:
opcode = cursor.u8(); opcode = cursor.u8();
opsize = 2; opsize = 2;
list = F8opcodeList; list = f8_opcode_list;
break; break;
case 0xF9: case 0xF9:
opcode = cursor.u8(); opcode = cursor.u8();
opsize = 2; opsize = 2;
list = F9opcodeList; list = f9_opcode_list;
break; break;
default: default:
opcode = mainOpcode; opcode = main_opcode;
opsize = 1; opsize = 1;
list = opcodeList; list = opcode_list;
break; break;
} }
let [, mnemonic, mask] = list[opcode]; let [, mnemonic, mask] = list[opcode];
if (mask == null) { if (mask == null) {
let fullOpcode = mainOpcode; let full_opcode = main_opcode;
if (mainOpcode === 0xF8 || mainOpcode === 0xF9) { if (main_opcode === 0xF8 || main_opcode === 0xF9) {
fullOpcode = (fullOpcode << 8) | opcode; full_opcode = (full_opcode << 8) | opcode;
} }
logger.warn(`Parameters unknown for opcode 0x${fullOpcode.toString(16).toUpperCase()}, assuming 0.`); logger.warn(`Parameters unknown for opcode 0x${full_opcode.toString(16).toUpperCase()}, assuming 0.`);
instructions.push({ instructions.push({
opcode, opcode,
@ -114,7 +114,7 @@ function parseObjectCode(cursor: BufferCursor, lenient: boolean): Instruction[]
}); });
} else { } else {
try { try {
const opargs = parseInstructionArguments(cursor, mask); const opargs = parse_instruction_arguments(cursor, mask);
instructions.push({ instructions.push({
opcode, opcode,
@ -143,13 +143,13 @@ function parseObjectCode(cursor: BufferCursor, lenient: boolean): Instruction[]
return instructions; return instructions;
} }
function parseInstructionArguments( function parse_instruction_arguments(
cursor: BufferCursor, cursor: BufferCursor,
mask: string mask: string
): { args: any[], size: number } { ): { args: any[], size: number } {
const oldPos = cursor.position; const old_pos = cursor.position;
const args = []; const args = [];
let argsSize: number; let args_size: number;
outer: outer:
for (let i = 0; i < mask.length; ++i) { for (let i = 0; i < mask.length; ++i) {
@ -208,13 +208,13 @@ function parseInstructionArguments(
// Variably sized data? // Variably sized data?
case 'j': case 'j':
case 'J': case 'J':
argsSize = 2 * cursor.u8(); args_size = 2 * cursor.u8();
cursor.seek(argsSize); cursor.seek(args_size);
break; break;
case 't': case 't':
case 'T': case 'T':
argsSize = cursor.u8(); args_size = cursor.u8();
cursor.seek(argsSize); cursor.seek(args_size);
break; break;
// Strings // Strings
@ -228,10 +228,10 @@ function parseInstructionArguments(
} }
} }
return { args, size: cursor.position - oldPos }; return { args, size: cursor.position - old_pos };
} }
const opcodeList: Array<[number, string, string | null]> = [ const opcode_list: Array<[number, string, string | null]> = [
[0x00, 'nop', ''], [0x00, 'nop', ''],
[0x01, 'ret', ''], [0x01, 'ret', ''],
[0x02, 'sync', ''], [0x02, 'sync', ''],
@ -512,7 +512,7 @@ const opcodeList: Array<[number, string, string | null]> = [
[0xFF, 'unknownFF', ''], [0xFF, 'unknownFF', ''],
]; ];
const F8opcodeList: Array<[number, string, string | null]> = [ const f8_opcode_list: Array<[number, string, string | null]> = [
[0x00, 'unknown', null], [0x00, 'unknown', null],
[0x01, 'set_chat_callback?', 'aRs'], [0x01, 'set_chat_callback?', 'aRs'],
[0x02, 'unknown', null], [0x02, 'unknown', null],
@ -771,7 +771,7 @@ const F8opcodeList: Array<[number, string, string | null]> = [
[0xFF, 'unknown', null], [0xFF, 'unknown', null],
]; ];
const F9opcodeList: Array<[number, string, string | null]> = [ const f9_opcode_list: Array<[number, string, string | null]> = [
[0x00, 'unknown', null], [0x00, 'unknown', null],
[0x01, 'dec2float', 'RR'], [0x01, 'dec2float', 'RR'],
[0x02, 'float2dec', 'RR'], [0x02, 'float2dec', 'RR'],

50
src/data_formats/parsing/quest/dat.test.ts
View File

@ -1,23 +1,23 @@
import * as fs from 'fs'; import * as fs from 'fs';
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import * as prs from '../../compression/prs'; import * as prs from '../../compression/prs';
import { parseDat, writeDat } from './dat'; import { parse_dat, write_dat } from './dat';
/** /**
* Parse a file, convert the resulting structure to DAT again and check whether the end result is equal to the original. * Parse a file, convert the resulting structure to DAT again and check whether the end result is equal to the original.
*/ */
test('parseDat and writeDat', () => { test('parse_dat and write_dat', () => {
const origBuffer = fs.readFileSync('test/resources/quest118_e.dat').buffer; const orig_buffer = fs.readFileSync('test/resources/quest118_e.dat').buffer;
const origDat = prs.decompress(new BufferCursor(origBuffer, true)); const orig_dat = prs.decompress(new BufferCursor(orig_buffer, true));
const testDat = writeDat(parseDat(origDat)); const test_dat = write_dat(parse_dat(orig_dat));
origDat.seek_start(0); orig_dat.seek_start(0);
expect(testDat.size).toBe(origDat.size); expect(test_dat.size).toBe(orig_dat.size);
let match = true; let match = true;
while (origDat.bytes_left) { while (orig_dat.bytes_left) {
if (testDat.u8() !== origDat.u8()) { if (test_dat.u8() !== orig_dat.u8()) {
match = false; match = false;
break; break;
} }
@ -30,29 +30,29 @@ test('parseDat and writeDat', () => {
* Parse a file, modify the resulting structure, convert it to DAT again and check whether the end result is equal to the original except for the bytes that should be changed. * Parse a file, modify the resulting structure, convert it to DAT again and check whether the end result is equal to the original except for the bytes that should be changed.
*/ */
test('parse, modify and write DAT', () => { test('parse, modify and write DAT', () => {
const origBuffer = fs.readFileSync('./test/resources/quest118_e.dat').buffer; const orig_buffer = fs.readFileSync('./test/resources/quest118_e.dat').buffer;
const origDat = prs.decompress(new BufferCursor(origBuffer, true)); const orig_dat = prs.decompress(new BufferCursor(orig_buffer, true));
const testParsed = parseDat(origDat); const test_parsed = parse_dat(orig_dat);
origDat.seek_start(0); orig_dat.seek_start(0);
testParsed.objs[9].position.x = 13; test_parsed.objs[9].position.x = 13;
testParsed.objs[9].position.y = 17; test_parsed.objs[9].position.y = 17;
testParsed.objs[9].position.z = 19; test_parsed.objs[9].position.z = 19;
const testDat = writeDat(testParsed); const test_dat = write_dat(test_parsed);
expect(testDat.size).toBe(origDat.size); expect(test_dat.size).toBe(orig_dat.size);
let match = true; let match = true;
while (origDat.bytes_left) { while (orig_dat.bytes_left) {
if (origDat.position === 16 + 9 * 68 + 16) { if (orig_dat.position === 16 + 9 * 68 + 16) {
origDat.seek(12); orig_dat.seek(12);
expect(testDat.f32()).toBe(13); expect(test_dat.f32()).toBe(13);
expect(testDat.f32()).toBe(17); expect(test_dat.f32()).toBe(17);
expect(testDat.f32()).toBe(19); expect(test_dat.f32()).toBe(19);
} else if (testDat.u8() !== origDat.u8()) { } else if (test_dat.u8() !== orig_dat.u8()) {
match = false; match = false;
break; break;
} }

202
src/data_formats/parsing/quest/dat.ts
View File

@ -1,110 +1,110 @@
import { groupBy } from 'lodash'; import { groupBy } from 'lodash';
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import Logger from 'js-logger'; import Logger from 'js-logger';
import { Vec3 } from '../../Vec3';
const logger = Logger.get('data_formats/parsing/quest/dat'); const logger = Logger.get('data_formats/parsing/quest/dat');
const OBJECT_SIZE = 68; const OBJECT_SIZE = 68;
const NPC_SIZE = 72; const NPC_SIZE = 72;
export interface DatFile { export type DatFile = {
objs: DatObject[]; objs: DatObject[],
npcs: DatNpc[]; npcs: DatNpc[],
unknowns: DatUnknown[]; unknowns: DatUnknown[],
} }
interface DatEntity { export type DatEntity = {
typeId: number; type_id: number,
sectionId: number; section_id: number,
position: { x: number, y: number, z: number }; position: Vec3,
rotation: { x: number, y: number, z: number }; rotation: Vec3,
areaId: number; area_id: number,
unknown: number[][]; unknown: number[][],
} }
export interface DatObject extends DatEntity { export type DatObject = DatEntity
export type DatNpc = DatEntity & {
flags: number,
skin: number,
} }
export interface DatNpc extends DatEntity { export type DatUnknown = {
flags: number; entity_type: number,
skin: number; total_size: number,
area_id: number,
entities_size: number,
data: number[],
} }
export interface DatUnknown { export function parse_dat(cursor: BufferCursor): DatFile {
entityType: number;
totalSize: number;
areaId: number;
entitiesSize: number;
data: number[];
}
export function parseDat(cursor: BufferCursor): DatFile {
const objs: DatObject[] = []; const objs: DatObject[] = [];
const npcs: DatNpc[] = []; const npcs: DatNpc[] = [];
const unknowns: DatUnknown[] = []; const unknowns: DatUnknown[] = [];
while (cursor.bytes_left) { while (cursor.bytes_left) {
const entityType = cursor.u32(); const entity_type = cursor.u32();
const totalSize = cursor.u32(); const total_size = cursor.u32();
const areaId = cursor.u32(); const area_id = cursor.u32();
const entitiesSize = cursor.u32(); const entities_size = cursor.u32();
if (entityType === 0) { if (entity_type === 0) {
break; break;
} else { } else {
if (entitiesSize !== totalSize - 16) { if (entities_size !== total_size - 16) {
throw Error(`Malformed DAT file. Expected an entities size of ${totalSize - 16}, got ${entitiesSize}.`); throw Error(`Malformed DAT file. Expected an entities size of ${total_size - 16}, got ${entities_size}.`);
} }
if (entityType === 1) { // Objects if (entity_type === 1) { // Objects
const objectCount = Math.floor(entitiesSize / OBJECT_SIZE); const object_count = Math.floor(entities_size / OBJECT_SIZE);
const startPosition = cursor.position; const start_position = cursor.position;
for (let i = 0; i < objectCount; ++i) { for (let i = 0; i < object_count; ++i) {
const typeId = cursor.u16(); const type_id = cursor.u16();
const unknown1 = cursor.u8_array(10); const unknown1 = cursor.u8_array(10);
const sectionId = cursor.u16(); const section_id = cursor.u16();
const unknown2 = cursor.u8_array(2); const unknown2 = cursor.u8_array(2);
const x = cursor.f32(); const x = cursor.f32();
const y = cursor.f32(); const y = cursor.f32();
const z = cursor.f32(); const z = cursor.f32();
const rotationX = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotation_x = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotationY = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotation_y = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotationZ = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotation_z = cursor.i32() / 0xFFFF * 2 * Math.PI;
// The next 3 floats seem to be scale values. // The next 3 floats seem to be scale values.
const unknown3 = cursor.u8_array(28); const unknown3 = cursor.u8_array(28);
objs.push({ objs.push({
typeId, type_id,
sectionId, section_id,
position: { x, y, z }, position: new Vec3(x, y, z),
rotation: { x: rotationX, y: rotationY, z: rotationZ }, rotation: new Vec3(rotation_x, rotation_y, rotation_z),
areaId, area_id,
unknown: [unknown1, unknown2, unknown3] unknown: [unknown1, unknown2, unknown3]
}); });
} }
const bytesRead = cursor.position - startPosition; const bytes_read = cursor.position - start_position;
if (bytesRead !== entitiesSize) { if (bytes_read !== entities_size) {
logger.warn(`Read ${bytesRead} bytes instead of expected ${entitiesSize} for entity type ${entityType} (Object).`); logger.warn(`Read ${bytes_read} bytes instead of expected ${entities_size} for entity type ${entity_type} (Object).`);
cursor.seek(entitiesSize - bytesRead); cursor.seek(entities_size - bytes_read);
} }
} else if (entityType === 2) { // NPCs } else if (entity_type === 2) { // NPCs
const npcCount = Math.floor(entitiesSize / NPC_SIZE); const npc_count = Math.floor(entities_size / NPC_SIZE);
const startPosition = cursor.position; const start_position = cursor.position;
for (let i = 0; i < npcCount; ++i) { for (let i = 0; i < npc_count; ++i) {
const typeId = cursor.u16(); const type_id = cursor.u16();
const unknown1 = cursor.u8_array(10); const unknown1 = cursor.u8_array(10);
const sectionId = cursor.u16(); const section_id = cursor.u16();
const unknown2 = cursor.u8_array(6); const unknown2 = cursor.u8_array(6);
const x = cursor.f32(); const x = cursor.f32();
const y = cursor.f32(); const y = cursor.f32();
const z = cursor.f32(); const z = cursor.f32();
const rotationX = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotation_x = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotationY = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotation_y = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotationZ = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotation_z = cursor.i32() / 0xFFFF * 2 * Math.PI;
const unknown3 = cursor.u8_array(4); const unknown3 = cursor.u8_array(4);
const flags = cursor.f32(); const flags = cursor.f32();
const unknown4 = cursor.u8_array(12); const unknown4 = cursor.u8_array(12);
@ -112,31 +112,31 @@ export function parseDat(cursor: BufferCursor): DatFile {
const unknown5 = cursor.u8_array(4); const unknown5 = cursor.u8_array(4);
npcs.push({ npcs.push({
typeId, type_id,
sectionId, section_id,
position: { x, y, z }, position: new Vec3(x, y, z),
rotation: { x: rotationX, y: rotationY, z: rotationZ }, rotation: new Vec3(rotation_x, rotation_y, rotation_z),
skin, skin,
areaId, area_id,
flags, flags,
unknown: [unknown1, unknown2, unknown3, unknown4, unknown5] unknown: [unknown1, unknown2, unknown3, unknown4, unknown5]
}); });
} }
const bytesRead = cursor.position - startPosition; const bytes_read = cursor.position - start_position;
if (bytesRead !== entitiesSize) { if (bytes_read !== entities_size) {
logger.warn(`Read ${bytesRead} bytes instead of expected ${entitiesSize} for entity type ${entityType} (NPC).`); logger.warn(`Read ${bytes_read} bytes instead of expected ${entities_size} for entity type ${entity_type} (NPC).`);
cursor.seek(entitiesSize - bytesRead); cursor.seek(entities_size - bytes_read);
} }
} else { } else {
// There are also waves (type 3) and unknown entity types 4 and 5. // There are also waves (type 3) and unknown entity types 4 and 5.
unknowns.push({ unknowns.push({
entityType, entity_type,
totalSize, total_size,
areaId, area_id,
entitiesSize, entities_size,
data: cursor.u8_array(entitiesSize) data: cursor.u8_array(entities_size)
}); });
} }
} }
@ -145,27 +145,29 @@ export function parseDat(cursor: BufferCursor): DatFile {
return { objs, npcs, unknowns }; return { objs, npcs, unknowns };
} }
export function writeDat({ objs, npcs, unknowns }: DatFile): BufferCursor { export function write_dat({ objs, npcs, unknowns }: DatFile): BufferCursor {
const cursor = new BufferCursor( const cursor = new BufferCursor(
objs.length * OBJECT_SIZE + npcs.length * NPC_SIZE + unknowns.length * 1000, true); objs.length * OBJECT_SIZE + npcs.length * NPC_SIZE + unknowns.length * 1000,
true
);
const groupedObjs = groupBy(objs, obj => obj.areaId); const grouped_objs = groupBy(objs, obj => obj.area_id);
const objAreaIds = Object.keys(groupedObjs) const obj_area_ids = Object.keys(grouped_objs)
.map(key => parseInt(key, 10)) .map(key => parseInt(key, 10))
.sort((a, b) => a - b); .sort((a, b) => a - b);
for (const areaId of objAreaIds) { for (const area_id of obj_area_ids) {
const areaObjs = groupedObjs[areaId]; const area_objs = grouped_objs[area_id];
const entitiesSize = areaObjs.length * OBJECT_SIZE; const entities_size = area_objs.length * OBJECT_SIZE;
cursor.write_u32(1); // Entity type cursor.write_u32(1); // Entity type
cursor.write_u32(entitiesSize + 16); cursor.write_u32(entities_size + 16);
cursor.write_u32(areaId); cursor.write_u32(area_id);
cursor.write_u32(entitiesSize); cursor.write_u32(entities_size);
for (const obj of areaObjs) { for (const obj of area_objs) {
cursor.write_u16(obj.typeId); cursor.write_u16(obj.type_id);
cursor.write_u8_array(obj.unknown[0]); cursor.write_u8_array(obj.unknown[0]);
cursor.write_u16(obj.sectionId); cursor.write_u16(obj.section_id);
cursor.write_u8_array(obj.unknown[1]); cursor.write_u8_array(obj.unknown[1]);
cursor.write_f32(obj.position.x); cursor.write_f32(obj.position.x);
cursor.write_f32(obj.position.y); cursor.write_f32(obj.position.y);
@ -177,23 +179,23 @@ export function writeDat({ objs, npcs, unknowns }: DatFile): BufferCursor {
} }
} }
const groupedNpcs = groupBy(npcs, npc => npc.areaId); const grouped_npcs = groupBy(npcs, npc => npc.area_id);
const npcAreaIds = Object.keys(groupedNpcs) const npc_area_ids = Object.keys(grouped_npcs)
.map(key => parseInt(key, 10)) .map(key => parseInt(key, 10))
.sort((a, b) => a - b); .sort((a, b) => a - b);
for (const areaId of npcAreaIds) { for (const area_id of npc_area_ids) {
const areaNpcs = groupedNpcs[areaId]; const area_npcs = grouped_npcs[area_id];
const entitiesSize = areaNpcs.length * NPC_SIZE; const entities_size = area_npcs.length * NPC_SIZE;
cursor.write_u32(2); // Entity type cursor.write_u32(2); // Entity type
cursor.write_u32(entitiesSize + 16); cursor.write_u32(entities_size + 16);
cursor.write_u32(areaId); cursor.write_u32(area_id);
cursor.write_u32(entitiesSize); cursor.write_u32(entities_size);
for (const npc of areaNpcs) { for (const npc of area_npcs) {
cursor.write_u16(npc.typeId); cursor.write_u16(npc.type_id);
cursor.write_u8_array(npc.unknown[0]); cursor.write_u8_array(npc.unknown[0]);
cursor.write_u16(npc.sectionId); cursor.write_u16(npc.section_id);
cursor.write_u8_array(npc.unknown[1]); cursor.write_u8_array(npc.unknown[1]);
cursor.write_f32(npc.position.x); cursor.write_f32(npc.position.x);
cursor.write_f32(npc.position.y); cursor.write_f32(npc.position.y);
@ -210,10 +212,10 @@ export function writeDat({ objs, npcs, unknowns }: DatFile): BufferCursor {
} }
for (const unknown of unknowns) { for (const unknown of unknowns) {
cursor.write_u32(unknown.entityType); cursor.write_u32(unknown.entity_type);
cursor.write_u32(unknown.totalSize); cursor.write_u32(unknown.total_size);
cursor.write_u32(unknown.areaId); cursor.write_u32(unknown.area_id);
cursor.write_u32(unknown.entitiesSize); cursor.write_u32(unknown.entities_size);
cursor.write_u8_array(unknown.data); cursor.write_u8_array(unknown.data);
} }

34
src/data_formats/parsing/quest/index.test.ts
View File

@ -16,7 +16,7 @@ test('parse Towards the Future', () => {
expect(quest.objects[0].type).toBe(ObjectType.MenuActivation); expect(quest.objects[0].type).toBe(ObjectType.MenuActivation);
expect(quest.objects[4].type).toBe(ObjectType.PlayerSet); expect(quest.objects[4].type).toBe(ObjectType.PlayerSet);
expect(quest.npcs.length).toBe(216); expect(quest.npcs.length).toBe(216);
expect(testableAreaVariants(quest)).toEqual([ expect(testable_area_variants(quest)).toEqual([
[0, 0], [2, 0], [11, 0], [5, 4], [12, 0], [7, 4], [13, 0], [8, 4], [10, 4], [14, 0] [0, 0], [2, 0], [11, 0], [5, 4], [12, 0], [7, 4], [13, 0], [8, 4], [10, 4], [14, 0]
]); ]);
}); });
@ -25,25 +25,25 @@ test('parse Towards the Future', () => {
* Parse a QST file, write the resulting Quest object to QST again, then parse that again. * Parse a QST file, write the resulting Quest object to QST again, then parse that again.
* Then check whether the two Quest objects are equal. * Then check whether the two Quest objects are equal.
*/ */
test('parseQuest and writeQuestQst', () => { test('parse_quest and write_quest_qst', () => {
const buffer = fs.readFileSync('test/resources/tethealla_v0.143_quests/solo/ep1/02.qst').buffer; const buffer = fs.readFileSync('test/resources/tethealla_v0.143_quests/solo/ep1/02.qst').buffer;
const cursor = new BufferCursor(buffer, true); const cursor = new BufferCursor(buffer, true);
const origQuest = parse_quest(cursor)!; const orig_quest = parse_quest(cursor)!;
const testQuest = parse_quest(write_quest_qst(origQuest, '02.qst'))!; const test_quest = parse_quest(write_quest_qst(orig_quest, '02.qst'))!;
expect(testQuest.name).toBe(origQuest.name); expect(test_quest.name).toBe(orig_quest.name);
expect(testQuest.short_description).toBe(origQuest.short_description); expect(test_quest.short_description).toBe(orig_quest.short_description);
expect(testQuest.long_description).toBe(origQuest.long_description); expect(test_quest.long_description).toBe(orig_quest.long_description);
expect(testQuest.episode).toBe(origQuest.episode); expect(test_quest.episode).toBe(orig_quest.episode);
expect(testableObjects(testQuest)) expect(testable_objects(test_quest))
.toEqual(testableObjects(origQuest)); .toEqual(testable_objects(orig_quest));
expect(testableNpcs(testQuest)) expect(testable_npcs(test_quest))
.toEqual(testableNpcs(origQuest)); .toEqual(testable_npcs(orig_quest));
expect(testableAreaVariants(testQuest)) expect(testable_area_variants(test_quest))
.toEqual(testableAreaVariants(origQuest)); .toEqual(testable_area_variants(orig_quest));
}); });
function testableObjects(quest: Quest) { function testable_objects(quest: Quest) {
return quest.objects.map(object => [ return quest.objects.map(object => [
object.area_id, object.area_id,
object.section_id, object.section_id,
@ -52,7 +52,7 @@ function testableObjects(quest: Quest) {
]); ]);
} }
function testableNpcs(quest: Quest) { function testable_npcs(quest: Quest) {
return quest.npcs.map(npc => [ return quest.npcs.map(npc => [
npc.area_id, npc.area_id,
npc.section_id, npc.section_id,
@ -61,6 +61,6 @@ function testableNpcs(quest: Quest) {
]); ]);
} }
function testableAreaVariants(quest: Quest) { function testable_area_variants(quest: Quest) {
return quest.area_variants.map(av => [av.area.id, av.id]); return quest.area_variants.map(av => [av.area.id, av.id]);
} }

392
src/data_formats/parsing/quest/index.ts
View File

@ -1,19 +1,12 @@
import Logger from 'js-logger';
import { AreaVariant, NpcType, ObjectType, Quest, QuestNpc, QuestObject } from '../../../domain';
import { area_store } from '../../../stores/AreaStore';
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import * as prs from '../../compression/prs'; import * as prs from '../../compression/prs';
import { parseDat, writeDat, DatObject, DatNpc, DatFile } from './dat'; import { Vec3 } from "../../Vec3";
import { parseBin, writeBin, Instruction } from './bin'; import { Instruction, parse_bin, write_bin } from './bin';
import { parseQst as parse_qst, writeQst as write_qst } from './qst'; import { DatFile, DatNpc, DatObject, parse_dat, write_dat } from './dat';
import { import { parse_qst, QstContainedFile, write_qst } from './qst';
Vec3,
AreaVariant,
QuestNpc,
QuestObject,
Quest,
ObjectType,
NpcType
} from '../../../domain';
import { area_store } from '../../../stores/AreaStore';
import Logger from 'js-logger';
const logger = Logger.get('data_formats/parsing/quest'); const logger = Logger.get('data_formats/parsing/quest');
@ -29,8 +22,8 @@ export function parse_quest(cursor: BufferCursor, lenient: boolean = false): Que
return; return;
} }
let dat_file = null; let dat_file: QstContainedFile | undefined;
let bin_file = null; let bin_file: QstContainedFile | undefined;
for (const file of qst.files) { for (const file of qst.files) {
const file_name = file.name.trim().toLowerCase(); const file_name = file.name.trim().toLowerCase();
@ -54,29 +47,29 @@ export function parse_quest(cursor: BufferCursor, lenient: boolean = false): Que
return; return;
} }
const dat = parseDat(prs.decompress(dat_file.data)); const dat = parse_dat(prs.decompress(dat_file.data));
const bin = parseBin(prs.decompress(bin_file.data), lenient); const bin = parse_bin(prs.decompress(bin_file.data), lenient);
let episode = 1; let episode = 1;
let area_variants: AreaVariant[] = []; let area_variants: AreaVariant[] = [];
if (bin.functionOffsets.length) { if (bin.function_offsets.length) {
const func_0_ops = get_func_operations(bin.instructions, bin.functionOffsets[0]); const func_0_ops = get_func_operations(bin.instructions, bin.function_offsets[0]);
if (func_0_ops) { if (func_0_ops) {
episode = get_episode(func_0_ops); episode = get_episode(func_0_ops);
area_variants = get_area_variants(dat, episode, func_0_ops, lenient); area_variants = get_area_variants(dat, episode, func_0_ops, lenient);
} else { } else {
logger.warn(`Function 0 offset ${bin.functionOffsets[0]} is invalid.`); logger.warn(`Function 0 offset ${bin.function_offsets[0]} is invalid.`);
} }
} else { } else {
logger.warn('File contains no functions.'); logger.warn('File contains no functions.');
} }
return new Quest( return new Quest(
bin.questName, dat_file.id,
bin.shortDescription, bin.quest_name,
bin.longDescription, bin.short_description,
dat_file.questNo, bin.long_description,
episode, episode,
area_variants, area_variants,
parse_obj_data(dat.objs), parse_obj_data(dat.objs),
@ -87,12 +80,12 @@ export function parse_quest(cursor: BufferCursor, lenient: boolean = false): Que
} }
export function write_quest_qst(quest: Quest, file_name: string): BufferCursor { export function write_quest_qst(quest: Quest, file_name: string): BufferCursor {
const dat = writeDat({ const dat = write_dat({
objs: objects_to_dat_data(quest.objects), objs: objects_to_dat_data(quest.objects),
npcs: npcsToDatData(quest.npcs), npcs: npcsToDatData(quest.npcs),
unknowns: quest.dat_unknowns unknowns: quest.dat_unknowns
}); });
const bin = writeBin({ data: quest.bin_data }); const bin = write_bin({ data: quest.bin_data });
const ext_start = file_name.lastIndexOf('.'); const ext_start = file_name.lastIndexOf('.');
const base_file_name = ext_start === -1 ? file_name : file_name.slice(0, ext_start); const base_file_name = ext_start === -1 ? file_name : file_name.slice(0, ext_start);
@ -100,12 +93,12 @@ export function write_quest_qst(quest: Quest, file_name: string): BufferCursor {
files: [ files: [
{ {
name: base_file_name + '.dat', name: base_file_name + '.dat',
questNo: quest.quest_no, id: quest.id,
data: prs.compress(dat) data: prs.compress(dat)
}, },
{ {
name: base_file_name + '.bin', name: base_file_name + '.bin',
questNo: quest.quest_no, id: quest.id,
data: prs.compress(bin) data: prs.compress(bin)
} }
] ]
@ -141,11 +134,11 @@ function get_area_variants(
const area_variants = new Map(); const area_variants = new Map();
for (const npc of dat.npcs) { for (const npc of dat.npcs) {
area_variants.set(npc.areaId, 0); area_variants.set(npc.area_id, 0);
} }
for (const obj of dat.objs) { for (const obj of dat.objs) {
area_variants.set(obj.areaId, 0); area_variants.set(obj.area_id, 0);
} }
const bb_maps = func_0_ops.filter(op => op.mnemonic === 'BB_Map_Designate'); const bb_maps = func_0_ops.filter(op => op.mnemonic === 'BB_Map_Designate');
@ -158,10 +151,10 @@ function get_area_variants(
const area_variants_array = new Array<AreaVariant>(); const area_variants_array = new Array<AreaVariant>();
for (const [areaId, variantId] of area_variants.entries()) { for (const [area_id, variant_id] of area_variants.entries()) {
try { try {
area_variants_array.push( area_variants_array.push(
area_store.get_variant(episode, areaId, variantId) area_store.get_variant(episode, area_id, variant_id)
); );
} catch (e) { } catch (e) {
if (lenient) { if (lenient) {
@ -178,7 +171,10 @@ function get_area_variants(
); );
} }
function get_func_operations(operations: Instruction[], func_offset: number) { function get_func_operations(
operations: Instruction[],
func_offset: number
): Instruction[] | undefined {
let position = 0; let position = 0;
let func_found = false; let func_found = false;
const func_ops: Instruction[] = []; const func_ops: Instruction[] = [];
@ -200,7 +196,7 @@ function get_func_operations(operations: Instruction[], func_offset: number) {
position += operation.size; position += operation.size;
} }
return func_found ? func_ops : null; return func_found ? func_ops : undefined;
} }
function parse_obj_data(objs: DatObject[]): QuestObject[] { function parse_obj_data(objs: DatObject[]): QuestObject[] {
@ -208,36 +204,36 @@ function parse_obj_data(objs: DatObject[]): QuestObject[] {
const { x, y, z } = obj_data.position; const { x, y, z } = obj_data.position;
const rot = obj_data.rotation; const rot = obj_data.rotation;
return new QuestObject( return new QuestObject(
obj_data.areaId, obj_data.area_id,
obj_data.sectionId, obj_data.section_id,
new Vec3(x, y, z), new Vec3(x, y, z),
new Vec3(rot.x, rot.y, rot.z), new Vec3(rot.x, rot.y, rot.z),
ObjectType.from_pso_id(obj_data.typeId), ObjectType.from_pso_id(obj_data.type_id),
obj_data obj_data
); );
}); });
} }
function parse_npc_data(episode: number, npcs: DatNpc[]): QuestNpc[] { function parse_npc_data(episode: number, npcs: DatNpc[]): QuestNpc[] {
return npcs.map(npcData => { return npcs.map(npc_data => {
const { x, y, z } = npcData.position; const { x, y, z } = npc_data.position;
const rot = npcData.rotation; const rot = npc_data.rotation;
return new QuestNpc( return new QuestNpc(
npcData.areaId, npc_data.area_id,
npcData.sectionId, npc_data.section_id,
new Vec3(x, y, z), new Vec3(x, y, z),
new Vec3(rot.x, rot.y, rot.z), new Vec3(rot.x, rot.y, rot.z),
get_npc_type(episode, npcData), get_npc_type(episode, npc_data),
npcData npc_data
); );
}); });
} }
// TODO: detect Mothmant, St. Rappy, Hallo Rappy, Egg Rappy, Death Gunner, Bulk and Recon. // TODO: detect Mothmant, St. Rappy, Hallo Rappy, Egg Rappy, Death Gunner, Bulk and Recon.
function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc): NpcType { function get_npc_type(episode: number, { type_id, flags, skin, area_id }: DatNpc): NpcType {
const regular = Math.abs(flags - 1) > 0.00001; const regular = Math.abs(flags - 1) > 0.00001;
switch (`${typeId}, ${skin % 3}, ${episode}`) { switch (`${type_id}, ${skin % 3}, ${episode}`) {
case `${0x044}, 0, 1`: return NpcType.Booma; case `${0x044}, 0, 1`: return NpcType.Booma;
case `${0x044}, 1, 1`: return NpcType.Gobooma; case `${0x044}, 1, 1`: return NpcType.Gobooma;
case `${0x044}, 2, 1`: return NpcType.Gigobooma; case `${0x044}, 2, 1`: return NpcType.Gigobooma;
@ -265,7 +261,7 @@ function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc):
case `${0x117}, 2, 4`: return NpcType.GoranDetonator; case `${0x117}, 2, 4`: return NpcType.GoranDetonator;
} }
switch (`${typeId}, ${skin % 2}, ${episode}`) { switch (`${type_id}, ${skin % 2}, ${episode}`) {
case `${0x040}, 0, 1`: return NpcType.Hildebear; case `${0x040}, 0, 1`: return NpcType.Hildebear;
case `${0x040}, 0, 2`: return NpcType.Hildebear2; case `${0x040}, 0, 2`: return NpcType.Hildebear2;
case `${0x040}, 1, 1`: return NpcType.Hildeblue; case `${0x040}, 1, 1`: return NpcType.Hildeblue;
@ -291,8 +287,8 @@ function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc):
case `${0x0DD}, 0, 2`: return NpcType.Dolmolm; case `${0x0DD}, 0, 2`: return NpcType.Dolmolm;
case `${0x0DD}, 1, 2`: return NpcType.Dolmdarl; case `${0x0DD}, 1, 2`: return NpcType.Dolmdarl;
case `${0x0E0}, 0, 2`: return areaId > 15 ? NpcType.Epsilon : NpcType.SinowZoa; case `${0x0E0}, 0, 2`: return area_id > 15 ? NpcType.Epsilon : NpcType.SinowZoa;
case `${0x0E0}, 1, 2`: return areaId > 15 ? NpcType.Epsilon : NpcType.SinowZele; case `${0x0E0}, 1, 2`: return area_id > 15 ? NpcType.Epsilon : NpcType.SinowZele;
case `${0x112}, 0, 4`: return NpcType.MerissaA; case `${0x112}, 0, 4`: return NpcType.MerissaA;
case `${0x112}, 1, 4`: return NpcType.MerissaAA; case `${0x112}, 1, 4`: return NpcType.MerissaAA;
@ -304,7 +300,7 @@ function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc):
case `${0x119}, 1, 4`: return regular ? NpcType.Shambertin : NpcType.Kondrieu; case `${0x119}, 1, 4`: return regular ? NpcType.Shambertin : NpcType.Kondrieu;
} }
switch (`${typeId}, ${episode}`) { switch (`${type_id}, ${episode}`) {
case `${0x042}, 1`: return NpcType.Monest; case `${0x042}, 1`: return NpcType.Monest;
case `${0x042}, 2`: return NpcType.Monest2; case `${0x042}, 2`: return NpcType.Monest2;
case `${0x043}, 1`: return regular ? NpcType.SavageWolf : NpcType.BarbarousWolf; case `${0x043}, 1`: return regular ? NpcType.SavageWolf : NpcType.BarbarousWolf;
@ -312,10 +308,12 @@ function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc):
case `${0x060}, 1`: return NpcType.GrassAssassin; case `${0x060}, 1`: return NpcType.GrassAssassin;
case `${0x060}, 2`: return NpcType.GrassAssassin2; case `${0x060}, 2`: return NpcType.GrassAssassin2;
case `${0x061}, 1`: return areaId > 15 ? NpcType.DelLily : ( case `${0x061}, 1`: return area_id > 15 ? NpcType.DelLily : (
regular ? NpcType.PoisonLily : NpcType.NarLily); regular ? NpcType.PoisonLily : NpcType.NarLily
case `${0x061}, 2`: return areaId > 15 ? NpcType.DelLily : ( );
regular ? NpcType.PoisonLily2 : NpcType.NarLily2); case `${0x061}, 2`: return area_id > 15 ? NpcType.DelLily : (
regular ? NpcType.PoisonLily2 : NpcType.NarLily2
);
case `${0x062}, 1`: return NpcType.NanoDragon; case `${0x062}, 1`: return NpcType.NanoDragon;
case `${0x064}, 1`: return regular ? NpcType.PofuillySlime : NpcType.PouillySlime; case `${0x064}, 1`: return regular ? NpcType.PofuillySlime : NpcType.PouillySlime;
case `${0x065}, 1`: return NpcType.PanArms; case `${0x065}, 1`: return NpcType.PanArms;
@ -366,7 +364,7 @@ function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc):
case `${0x113}, 4`: return NpcType.Girtablulu; case `${0x113}, 4`: return NpcType.Girtablulu;
} }
switch (typeId) { switch (type_id) {
case 0x004: return NpcType.FemaleFat; case 0x004: return NpcType.FemaleFat;
case 0x005: return NpcType.FemaleMacho; case 0x005: return NpcType.FemaleMacho;
case 0x007: return NpcType.FemaleTall; case 0x007: return NpcType.FemaleTall;
@ -391,11 +389,11 @@ function get_npc_type(episode: number, { typeId, flags, skin, areaId }: DatNpc):
function objects_to_dat_data(objects: QuestObject[]): DatObject[] { function objects_to_dat_data(objects: QuestObject[]): DatObject[] {
return objects.map(object => ({ return objects.map(object => ({
typeId: object.type.pso_id!, type_id: object.type.pso_id!,
sectionId: object.section_id, section_id: object.section_id,
position: object.section_position, position: object.section_position,
rotation: object.rotation, rotation: object.rotation,
areaId: object.area_id, area_id: object.area_id,
unknown: object.dat.unknown unknown: object.dat.unknown
})); }));
} }
@ -403,170 +401,170 @@ function objects_to_dat_data(objects: QuestObject[]): DatObject[] {
function npcsToDatData(npcs: QuestNpc[]): DatNpc[] { function npcsToDatData(npcs: QuestNpc[]): DatNpc[] {
return npcs.map(npc => { return npcs.map(npc => {
// If the type is unknown, typeData will be undefined and we use the raw data from the DAT file. // If the type is unknown, typeData will be undefined and we use the raw data from the DAT file.
const typeData = npcTypeToDatData(npc.type); const type_data = npc_type_to_dat_data(npc.type);
let flags = npc.dat.flags; let flags = npc.dat.flags;
if (typeData) { if (type_data) {
flags = (npc.dat.flags & ~0x800000) | (typeData.regular ? 0 : 0x800000); flags = (npc.dat.flags & ~0x800000) | (type_data.regular ? 0 : 0x800000);
} }
return { return {
typeId: typeData ? typeData.typeId : npc.dat.typeId, type_id: type_data ? type_data.type_id : npc.dat.type_id,
sectionId: npc.section_id, section_id: npc.section_id,
position: npc.section_position, position: npc.section_position,
rotation: npc.rotation, rotation: npc.rotation,
flags, flags,
skin: typeData ? typeData.skin : npc.dat.skin, skin: type_data ? type_data.skin : npc.dat.skin,
areaId: npc.area_id, area_id: npc.area_id,
unknown: npc.dat.unknown unknown: npc.dat.unknown
}; };
}); });
} }
function npcTypeToDatData( function npc_type_to_dat_data(
type: NpcType type: NpcType
): { typeId: number, skin: number, regular: boolean } | null { ): { type_id: number, skin: number, regular: boolean } | undefined {
switch (type) { switch (type) {
default: throw new Error(`Unexpected type ${type.code}.`); default: throw new Error(`Unexpected type ${type.code}.`);
case NpcType.Unknown: return null; case NpcType.Unknown: return undefined;
case NpcType.FemaleFat: return { typeId: 0x004, skin: 0, regular: true }; case NpcType.FemaleFat: return { type_id: 0x004, skin: 0, regular: true };
case NpcType.FemaleMacho: return { typeId: 0x005, skin: 0, regular: true }; case NpcType.FemaleMacho: return { type_id: 0x005, skin: 0, regular: true };
case NpcType.FemaleTall: return { typeId: 0x007, skin: 0, regular: true }; case NpcType.FemaleTall: return { type_id: 0x007, skin: 0, regular: true };
case NpcType.MaleDwarf: return { typeId: 0x00A, skin: 0, regular: true }; case NpcType.MaleDwarf: return { type_id: 0x00A, skin: 0, regular: true };
case NpcType.MaleFat: return { typeId: 0x00B, skin: 0, regular: true }; case NpcType.MaleFat: return { type_id: 0x00B, skin: 0, regular: true };
case NpcType.MaleMacho: return { typeId: 0x00C, skin: 0, regular: true }; case NpcType.MaleMacho: return { type_id: 0x00C, skin: 0, regular: true };
case NpcType.MaleOld: return { typeId: 0x00D, skin: 0, regular: true }; case NpcType.MaleOld: return { type_id: 0x00D, skin: 0, regular: true };
case NpcType.BlueSoldier: return { typeId: 0x019, skin: 0, regular: true }; case NpcType.BlueSoldier: return { type_id: 0x019, skin: 0, regular: true };
case NpcType.RedSoldier: return { typeId: 0x01A, skin: 0, regular: true }; case NpcType.RedSoldier: return { type_id: 0x01A, skin: 0, regular: true };
case NpcType.Principal: return { typeId: 0x01B, skin: 0, regular: true }; case NpcType.Principal: return { type_id: 0x01B, skin: 0, regular: true };
case NpcType.Tekker: return { typeId: 0x01C, skin: 0, regular: true }; case NpcType.Tekker: return { type_id: 0x01C, skin: 0, regular: true };
case NpcType.GuildLady: return { typeId: 0x01D, skin: 0, regular: true }; case NpcType.GuildLady: return { type_id: 0x01D, skin: 0, regular: true };
case NpcType.Scientist: return { typeId: 0x01E, skin: 0, regular: true }; case NpcType.Scientist: return { type_id: 0x01E, skin: 0, regular: true };
case NpcType.Nurse: return { typeId: 0x01F, skin: 0, regular: true }; case NpcType.Nurse: return { type_id: 0x01F, skin: 0, regular: true };
case NpcType.Irene: return { typeId: 0x020, skin: 0, regular: true }; case NpcType.Irene: return { type_id: 0x020, skin: 0, regular: true };
case NpcType.ItemShop: return { typeId: 0x0F1, skin: 0, regular: true }; case NpcType.ItemShop: return { type_id: 0x0F1, skin: 0, regular: true };
case NpcType.Nurse2: return { typeId: 0x0FE, skin: 0, regular: true }; case NpcType.Nurse2: return { type_id: 0x0FE, skin: 0, regular: true };
case NpcType.Hildebear: return { typeId: 0x040, skin: 0, regular: true }; case NpcType.Hildebear: return { type_id: 0x040, skin: 0, regular: true };
case NpcType.Hildeblue: return { typeId: 0x040, skin: 1, regular: true }; case NpcType.Hildeblue: return { type_id: 0x040, skin: 1, regular: true };
case NpcType.RagRappy: return { typeId: 0x041, skin: 0, regular: true }; case NpcType.RagRappy: return { type_id: 0x041, skin: 0, regular: true };
case NpcType.AlRappy: return { typeId: 0x041, skin: 1, regular: true }; case NpcType.AlRappy: return { type_id: 0x041, skin: 1, regular: true };
case NpcType.Monest: return { typeId: 0x042, skin: 0, regular: true }; case NpcType.Monest: return { type_id: 0x042, skin: 0, regular: true };
case NpcType.SavageWolf: return { typeId: 0x043, skin: 0, regular: true }; case NpcType.SavageWolf: return { type_id: 0x043, skin: 0, regular: true };
case NpcType.BarbarousWolf: return { typeId: 0x043, skin: 0, regular: false }; case NpcType.BarbarousWolf: return { type_id: 0x043, skin: 0, regular: false };
case NpcType.Booma: return { typeId: 0x044, skin: 0, regular: true }; case NpcType.Booma: return { type_id: 0x044, skin: 0, regular: true };
case NpcType.Gobooma: return { typeId: 0x044, skin: 1, regular: true }; case NpcType.Gobooma: return { type_id: 0x044, skin: 1, regular: true };
case NpcType.Gigobooma: return { typeId: 0x044, skin: 2, regular: true }; case NpcType.Gigobooma: return { type_id: 0x044, skin: 2, regular: true };
case NpcType.Dragon: return { typeId: 0x0C0, skin: 0, regular: true }; case NpcType.Dragon: return { type_id: 0x0C0, skin: 0, regular: true };
case NpcType.GrassAssassin: return { typeId: 0x060, skin: 0, regular: true }; case NpcType.GrassAssassin: return { type_id: 0x060, skin: 0, regular: true };
case NpcType.PoisonLily: return { typeId: 0x061, skin: 0, regular: true }; case NpcType.PoisonLily: return { type_id: 0x061, skin: 0, regular: true };
case NpcType.NarLily: return { typeId: 0x061, skin: 1, regular: true }; case NpcType.NarLily: return { type_id: 0x061, skin: 1, regular: true };
case NpcType.NanoDragon: return { typeId: 0x062, skin: 0, regular: true }; case NpcType.NanoDragon: return { type_id: 0x062, skin: 0, regular: true };
case NpcType.EvilShark: return { typeId: 0x063, skin: 0, regular: true }; case NpcType.EvilShark: return { type_id: 0x063, skin: 0, regular: true };
case NpcType.PalShark: return { typeId: 0x063, skin: 1, regular: true }; case NpcType.PalShark: return { type_id: 0x063, skin: 1, regular: true };
case NpcType.GuilShark: return { typeId: 0x063, skin: 2, regular: true }; case NpcType.GuilShark: return { type_id: 0x063, skin: 2, regular: true };
case NpcType.PofuillySlime: return { typeId: 0x064, skin: 0, regular: true }; case NpcType.PofuillySlime: return { type_id: 0x064, skin: 0, regular: true };
case NpcType.PouillySlime: return { typeId: 0x064, skin: 0, regular: false }; case NpcType.PouillySlime: return { type_id: 0x064, skin: 0, regular: false };
case NpcType.PanArms: return { typeId: 0x065, skin: 0, regular: true }; case NpcType.PanArms: return { type_id: 0x065, skin: 0, regular: true };
case NpcType.DeRolLe: return { typeId: 0x0C1, skin: 0, regular: true }; case NpcType.DeRolLe: return { type_id: 0x0C1, skin: 0, regular: true };
case NpcType.Dubchic: return { typeId: 0x080, skin: 0, regular: true }; case NpcType.Dubchic: return { type_id: 0x080, skin: 0, regular: true };
case NpcType.Gilchic: return { typeId: 0x080, skin: 1, regular: true }; case NpcType.Gilchic: return { type_id: 0x080, skin: 1, regular: true };
case NpcType.Garanz: return { typeId: 0x081, skin: 0, regular: true }; case NpcType.Garanz: return { type_id: 0x081, skin: 0, regular: true };
case NpcType.SinowBeat: return { typeId: 0x082, skin: 0, regular: true }; case NpcType.SinowBeat: return { type_id: 0x082, skin: 0, regular: true };
case NpcType.SinowGold: return { typeId: 0x082, skin: 0, regular: false }; case NpcType.SinowGold: return { type_id: 0x082, skin: 0, regular: false };
case NpcType.Canadine: return { typeId: 0x083, skin: 0, regular: true }; case NpcType.Canadine: return { type_id: 0x083, skin: 0, regular: true };
case NpcType.Canane: return { typeId: 0x084, skin: 0, regular: true }; case NpcType.Canane: return { type_id: 0x084, skin: 0, regular: true };
case NpcType.Dubswitch: return { typeId: 0x085, skin: 0, regular: true }; case NpcType.Dubswitch: return { type_id: 0x085, skin: 0, regular: true };
case NpcType.VolOpt: return { typeId: 0x0C5, skin: 0, regular: true }; case NpcType.VolOpt: return { type_id: 0x0C5, skin: 0, regular: true };
case NpcType.Delsaber: return { typeId: 0x0A0, skin: 0, regular: true }; case NpcType.Delsaber: return { type_id: 0x0A0, skin: 0, regular: true };
case NpcType.ChaosSorcerer: return { typeId: 0x0A1, skin: 0, regular: true }; case NpcType.ChaosSorcerer: return { type_id: 0x0A1, skin: 0, regular: true };
case NpcType.DarkGunner: return { typeId: 0x0A2, skin: 0, regular: true }; case NpcType.DarkGunner: return { type_id: 0x0A2, skin: 0, regular: true };
case NpcType.ChaosBringer: return { typeId: 0x0A4, skin: 0, regular: true }; case NpcType.ChaosBringer: return { type_id: 0x0A4, skin: 0, regular: true };
case NpcType.DarkBelra: return { typeId: 0x0A5, skin: 0, regular: true }; case NpcType.DarkBelra: return { type_id: 0x0A5, skin: 0, regular: true };
case NpcType.Dimenian: return { typeId: 0x0A6, skin: 0, regular: true }; case NpcType.Dimenian: return { type_id: 0x0A6, skin: 0, regular: true };
case NpcType.LaDimenian: return { typeId: 0x0A6, skin: 1, regular: true }; case NpcType.LaDimenian: return { type_id: 0x0A6, skin: 1, regular: true };
case NpcType.SoDimenian: return { typeId: 0x0A6, skin: 2, regular: true }; case NpcType.SoDimenian: return { type_id: 0x0A6, skin: 2, regular: true };
case NpcType.Bulclaw: return { typeId: 0x0A7, skin: 0, regular: true }; case NpcType.Bulclaw: return { type_id: 0x0A7, skin: 0, regular: true };
case NpcType.Claw: return { typeId: 0x0A8, skin: 0, regular: true }; case NpcType.Claw: return { type_id: 0x0A8, skin: 0, regular: true };
case NpcType.DarkFalz: return { typeId: 0x0C8, skin: 0, regular: true }; case NpcType.DarkFalz: return { type_id: 0x0C8, skin: 0, regular: true };
case NpcType.Hildebear2: return { typeId: 0x040, skin: 0, regular: true }; case NpcType.Hildebear2: return { type_id: 0x040, skin: 0, regular: true };
case NpcType.Hildeblue2: return { typeId: 0x040, skin: 1, regular: true }; case NpcType.Hildeblue2: return { type_id: 0x040, skin: 1, regular: true };
case NpcType.RagRappy2: return { typeId: 0x041, skin: 0, regular: true }; case NpcType.RagRappy2: return { type_id: 0x041, skin: 0, regular: true };
case NpcType.LoveRappy: return { typeId: 0x041, skin: 1, regular: true }; case NpcType.LoveRappy: return { type_id: 0x041, skin: 1, regular: true };
case NpcType.Monest2: return { typeId: 0x042, skin: 0, regular: true }; case NpcType.Monest2: return { type_id: 0x042, skin: 0, regular: true };
case NpcType.PoisonLily2: return { typeId: 0x061, skin: 0, regular: true }; case NpcType.PoisonLily2: return { type_id: 0x061, skin: 0, regular: true };
case NpcType.NarLily2: return { typeId: 0x061, skin: 1, regular: true }; case NpcType.NarLily2: return { type_id: 0x061, skin: 1, regular: true };
case NpcType.GrassAssassin2: return { typeId: 0x060, skin: 0, regular: true }; case NpcType.GrassAssassin2: return { type_id: 0x060, skin: 0, regular: true };
case NpcType.Dimenian2: return { typeId: 0x0A6, skin: 0, regular: true }; case NpcType.Dimenian2: return { type_id: 0x0A6, skin: 0, regular: true };
case NpcType.LaDimenian2: return { typeId: 0x0A6, skin: 1, regular: true }; case NpcType.LaDimenian2: return { type_id: 0x0A6, skin: 1, regular: true };
case NpcType.SoDimenian2: return { typeId: 0x0A6, skin: 2, regular: true }; case NpcType.SoDimenian2: return { type_id: 0x0A6, skin: 2, regular: true };
case NpcType.DarkBelra2: return { typeId: 0x0A5, skin: 0, regular: true }; case NpcType.DarkBelra2: return { type_id: 0x0A5, skin: 0, regular: true };
case NpcType.BarbaRay: return { typeId: 0x0CB, skin: 0, regular: true }; case NpcType.BarbaRay: return { type_id: 0x0CB, skin: 0, regular: true };
case NpcType.SavageWolf2: return { typeId: 0x043, skin: 0, regular: true }; case NpcType.SavageWolf2: return { type_id: 0x043, skin: 0, regular: true };
case NpcType.BarbarousWolf2: return { typeId: 0x043, skin: 0, regular: false }; case NpcType.BarbarousWolf2: return { type_id: 0x043, skin: 0, regular: false };
case NpcType.PanArms2: return { typeId: 0x065, skin: 0, regular: true }; case NpcType.PanArms2: return { type_id: 0x065, skin: 0, regular: true };
case NpcType.Dubchic2: return { typeId: 0x080, skin: 0, regular: true }; case NpcType.Dubchic2: return { type_id: 0x080, skin: 0, regular: true };
case NpcType.Gilchic2: return { typeId: 0x080, skin: 1, regular: true }; case NpcType.Gilchic2: return { type_id: 0x080, skin: 1, regular: true };
case NpcType.Garanz2: return { typeId: 0x081, skin: 0, regular: true }; case NpcType.Garanz2: return { type_id: 0x081, skin: 0, regular: true };
case NpcType.Dubswitch2: return { typeId: 0x085, skin: 0, regular: true }; case NpcType.Dubswitch2: return { type_id: 0x085, skin: 0, regular: true };
case NpcType.Delsaber2: return { typeId: 0x0A0, skin: 0, regular: true }; case NpcType.Delsaber2: return { type_id: 0x0A0, skin: 0, regular: true };
case NpcType.ChaosSorcerer2: return { typeId: 0x0A1, skin: 0, regular: true }; case NpcType.ChaosSorcerer2: return { type_id: 0x0A1, skin: 0, regular: true };
case NpcType.GolDragon: return { typeId: 0x0CC, skin: 0, regular: true }; case NpcType.GolDragon: return { type_id: 0x0CC, skin: 0, regular: true };
case NpcType.SinowBerill: return { typeId: 0x0D4, skin: 0, regular: true }; case NpcType.SinowBerill: return { type_id: 0x0D4, skin: 0, regular: true };
case NpcType.SinowSpigell: return { typeId: 0x0D4, skin: 1, regular: true }; case NpcType.SinowSpigell: return { type_id: 0x0D4, skin: 1, regular: true };
case NpcType.Merillia: return { typeId: 0x0D5, skin: 0, regular: true }; case NpcType.Merillia: return { type_id: 0x0D5, skin: 0, regular: true };
case NpcType.Meriltas: return { typeId: 0x0D5, skin: 1, regular: true }; case NpcType.Meriltas: return { type_id: 0x0D5, skin: 1, regular: true };
case NpcType.Mericarol: return { typeId: 0x0D6, skin: 0, regular: true }; case NpcType.Mericarol: return { type_id: 0x0D6, skin: 0, regular: true };
case NpcType.Mericus: return { typeId: 0x0D6, skin: 1, regular: true }; case NpcType.Mericus: return { type_id: 0x0D6, skin: 1, regular: true };
case NpcType.Merikle: return { typeId: 0x0D6, skin: 2, regular: true }; case NpcType.Merikle: return { type_id: 0x0D6, skin: 2, regular: true };
case NpcType.UlGibbon: return { typeId: 0x0D7, skin: 0, regular: true }; case NpcType.UlGibbon: return { type_id: 0x0D7, skin: 0, regular: true };
case NpcType.ZolGibbon: return { typeId: 0x0D7, skin: 1, regular: true }; case NpcType.ZolGibbon: return { type_id: 0x0D7, skin: 1, regular: true };
case NpcType.Gibbles: return { typeId: 0x0D8, skin: 0, regular: true }; case NpcType.Gibbles: return { type_id: 0x0D8, skin: 0, regular: true };
case NpcType.Gee: return { typeId: 0x0D9, skin: 0, regular: true }; case NpcType.Gee: return { type_id: 0x0D9, skin: 0, regular: true };
case NpcType.GiGue: return { typeId: 0x0DA, skin: 0, regular: true }; case NpcType.GiGue: return { type_id: 0x0DA, skin: 0, regular: true };
case NpcType.GalGryphon: return { typeId: 0x0C0, skin: 0, regular: true }; case NpcType.GalGryphon: return { type_id: 0x0C0, skin: 0, regular: true };
case NpcType.Deldepth: return { typeId: 0x0DB, skin: 0, regular: true }; case NpcType.Deldepth: return { type_id: 0x0DB, skin: 0, regular: true };
case NpcType.Delbiter: return { typeId: 0x0DC, skin: 0, regular: true }; case NpcType.Delbiter: return { type_id: 0x0DC, skin: 0, regular: true };
case NpcType.Dolmolm: return { typeId: 0x0DD, skin: 0, regular: true }; case NpcType.Dolmolm: return { type_id: 0x0DD, skin: 0, regular: true };
case NpcType.Dolmdarl: return { typeId: 0x0DD, skin: 1, regular: true }; case NpcType.Dolmdarl: return { type_id: 0x0DD, skin: 1, regular: true };
case NpcType.Morfos: return { typeId: 0x0DE, skin: 0, regular: true }; case NpcType.Morfos: return { type_id: 0x0DE, skin: 0, regular: true };
case NpcType.Recobox: return { typeId: 0x0DF, skin: 0, regular: true }; case NpcType.Recobox: return { type_id: 0x0DF, skin: 0, regular: true };
case NpcType.Epsilon: return { typeId: 0x0E0, skin: 0, regular: true }; case NpcType.Epsilon: return { type_id: 0x0E0, skin: 0, regular: true };
case NpcType.SinowZoa: return { typeId: 0x0E0, skin: 0, regular: true }; case NpcType.SinowZoa: return { type_id: 0x0E0, skin: 0, regular: true };
case NpcType.SinowZele: return { typeId: 0x0E0, skin: 1, regular: true }; case NpcType.SinowZele: return { type_id: 0x0E0, skin: 1, regular: true };
case NpcType.IllGill: return { typeId: 0x0E1, skin: 0, regular: true }; case NpcType.IllGill: return { type_id: 0x0E1, skin: 0, regular: true };
case NpcType.DelLily: return { typeId: 0x061, skin: 0, regular: true }; case NpcType.DelLily: return { type_id: 0x061, skin: 0, regular: true };
case NpcType.OlgaFlow: return { typeId: 0x0CA, skin: 0, regular: true }; case NpcType.OlgaFlow: return { type_id: 0x0CA, skin: 0, regular: true };
case NpcType.SandRappy: return { typeId: 0x041, skin: 0, regular: true }; case NpcType.SandRappy: return { type_id: 0x041, skin: 0, regular: true };
case NpcType.DelRappy: return { typeId: 0x041, skin: 1, regular: true }; case NpcType.DelRappy: return { type_id: 0x041, skin: 1, regular: true };
case NpcType.Astark: return { typeId: 0x110, skin: 0, regular: true }; case NpcType.Astark: return { type_id: 0x110, skin: 0, regular: true };
case NpcType.SatelliteLizard: return { typeId: 0x111, skin: 0, regular: true }; case NpcType.SatelliteLizard: return { type_id: 0x111, skin: 0, regular: true };
case NpcType.Yowie: return { typeId: 0x111, skin: 0, regular: false }; case NpcType.Yowie: return { type_id: 0x111, skin: 0, regular: false };
case NpcType.MerissaA: return { typeId: 0x112, skin: 0, regular: true }; case NpcType.MerissaA: return { type_id: 0x112, skin: 0, regular: true };
case NpcType.MerissaAA: return { typeId: 0x112, skin: 1, regular: true }; case NpcType.MerissaAA: return { type_id: 0x112, skin: 1, regular: true };
case NpcType.Girtablulu: return { typeId: 0x113, skin: 0, regular: true }; case NpcType.Girtablulu: return { type_id: 0x113, skin: 0, regular: true };
case NpcType.Zu: return { typeId: 0x114, skin: 0, regular: true }; case NpcType.Zu: return { type_id: 0x114, skin: 0, regular: true };
case NpcType.Pazuzu: return { typeId: 0x114, skin: 1, regular: true }; case NpcType.Pazuzu: return { type_id: 0x114, skin: 1, regular: true };
case NpcType.Boota: return { typeId: 0x115, skin: 0, regular: true }; case NpcType.Boota: return { type_id: 0x115, skin: 0, regular: true };
case NpcType.ZeBoota: return { typeId: 0x115, skin: 1, regular: true }; case NpcType.ZeBoota: return { type_id: 0x115, skin: 1, regular: true };
case NpcType.BaBoota: return { typeId: 0x115, skin: 2, regular: true }; case NpcType.BaBoota: return { type_id: 0x115, skin: 2, regular: true };
case NpcType.Dorphon: return { typeId: 0x116, skin: 0, regular: true }; case NpcType.Dorphon: return { type_id: 0x116, skin: 0, regular: true };
case NpcType.DorphonEclair: return { typeId: 0x116, skin: 1, regular: true }; case NpcType.DorphonEclair: return { type_id: 0x116, skin: 1, regular: true };
case NpcType.Goran: return { typeId: 0x117, skin: 0, regular: true }; case NpcType.Goran: return { type_id: 0x117, skin: 0, regular: true };
case NpcType.PyroGoran: return { typeId: 0x117, skin: 1, regular: true }; case NpcType.PyroGoran: return { type_id: 0x117, skin: 1, regular: true };
case NpcType.GoranDetonator: return { typeId: 0x117, skin: 2, regular: true }; case NpcType.GoranDetonator: return { type_id: 0x117, skin: 2, regular: true };
case NpcType.SaintMilion: return { typeId: 0x119, skin: 0, regular: true }; case NpcType.SaintMilion: return { type_id: 0x119, skin: 0, regular: true };
case NpcType.Shambertin: return { typeId: 0x119, skin: 1, regular: true }; case NpcType.Shambertin: return { type_id: 0x119, skin: 1, regular: true };
case NpcType.Kondrieu: return { typeId: 0x119, skin: 0, regular: false }; case NpcType.Kondrieu: return { type_id: 0x119, skin: 0, regular: false };
} }
} }

24
src/data_formats/parsing/quest/qst.test.ts
View File

@ -1,25 +1,25 @@
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import { parseQst, writeQst } from './qst'; import { parse_qst, write_qst } from './qst';
import { walkQstFiles } from '../../../../test/src/utils'; import { walk_qst_files } from '../../../../test/src/utils';
/** /**
* Parse a file, convert the resulting structure to QST again and check whether the end result is equal to the original. * Parse a file, convert the resulting structure to QST again and check whether the end result is equal to the original.
*/ */
test('parseQst and writeQst', () => { test('parse_qst and write_qst', () => {
walkQstFiles((_filePath, _fileName, fileContent) => { walk_qst_files((_file_path, _file_name, file_content) => {
const origQst = new BufferCursor(fileContent.buffer, true); const orig_qst = new BufferCursor(file_content.buffer, true);
const origQuest = parseQst(origQst); const orig_quest = parse_qst(orig_qst);
if (origQuest) { if (orig_quest) {
const testQst = writeQst(origQuest); const test_qst = write_qst(orig_quest);
origQst.seek_start(0); orig_qst.seek_start(0);
expect(testQst.size).toBe(origQst.size); expect(test_qst.size).toBe(orig_qst.size);
let match = true; let match = true;
while (origQst.bytes_left) { while (orig_qst.bytes_left) {
if (testQst.u8() !== origQst.u8()) { if (test_qst.u8() !== orig_qst.u8()) {
match = false; match = false;
break; break;
} }

195
src/data_formats/parsing/quest/qst.ts
View File

@ -3,40 +3,40 @@ import Logger from 'js-logger';
const logger = Logger.get('data_formats/parsing/quest/qst'); const logger = Logger.get('data_formats/parsing/quest/qst');
interface QstContainedFile { export type QstContainedFile = {
name: string; id?: number,
name2?: string; // Unsure what this is name: string,
questNo?: number; name_2?: string, // Unsure what this is
expectedSize?: number; expected_size?: number,
data: BufferCursor; data: BufferCursor,
chunkNos: Set<number>; chunk_nos: Set<number>,
} }
interface ParseQstResult { export type ParseQstResult = {
version: string; version: string,
files: QstContainedFile[]; files: QstContainedFile[],
} }
/** /**
* Low level parsing function for .qst files. * Low level parsing function for .qst files.
* Can only read the Blue Burst format. * Can only read the Blue Burst format.
*/ */
export function parseQst(cursor: BufferCursor): ParseQstResult | undefined { export function parse_qst(cursor: BufferCursor): ParseQstResult | undefined {
// A .qst file contains two 88-byte headers that describe the embedded .dat and .bin files. // A .qst file contains two 88-byte headers that describe the embedded .dat and .bin files.
let version = 'PC'; let version = 'PC';
// Detect version. // Detect version.
const versionA = cursor.u8(); const version_a = cursor.u8();
cursor.seek(1); cursor.seek(1);
const versionB = cursor.u8(); const version_b = cursor.u8();
if (versionA === 0x44) { if (version_a === 0x44) {
version = 'Dreamcast/GameCube'; version = 'Dreamcast/GameCube';
} else if (versionA === 0x58) { } else if (version_a === 0x58) {
if (versionB === 0x44) { if (version_b === 0x44) {
version = 'Blue Burst'; version = 'Blue Burst';
} }
} else if (versionA === 0xA6) { } else if (version_a === 0xA6) {
version = 'Dreamcast download'; version = 'Dreamcast download';
} }
@ -44,17 +44,18 @@ export function parseQst(cursor: BufferCursor): ParseQstResult | undefined {
// Read headers and contained files. // Read headers and contained files.
cursor.seek_start(0); cursor.seek_start(0);
const headers = parseHeaders(cursor); const headers = parse_headers(cursor);
const files = parseFiles( const files = parse_files(
cursor, new Map(headers.map(h => [h.fileName, h.size]))); cursor, new Map(headers.map(h => [h.file_name, h.size]))
);
for (const file of files) { for (const file of files) {
const header = headers.find(h => h.fileName === file.name); const header = headers.find(h => h.file_name === file.name);
if (header) { if (header) {
file.questNo = header.questNo; file.id = header.quest_id;
file.name2 = header.fileName2; file.name_2 = header.file_name_2;
} }
} }
@ -68,64 +69,64 @@ export function parseQst(cursor: BufferCursor): ParseQstResult | undefined {
} }
} }
interface SimpleQstContainedFile { export type SimpleQstContainedFile = {
name: string; id?: number,
name2?: string; name: string,
questNo?: number; name_2?: string,
data: BufferCursor; data: BufferCursor,
} }
interface WriteQstParams { export type WriteQstParams = {
version?: string; version?: string,
files: SimpleQstContainedFile[]; files: SimpleQstContainedFile[],
} }
/** /**
* Always writes in Blue Burst format. * Always uses Blue Burst format.
*/ */
export function writeQst(params: WriteQstParams): BufferCursor { export function write_qst(params: WriteQstParams): BufferCursor {
const files = params.files; const files = params.files;
const totalSize = files const total_size = files
.map(f => 88 + Math.ceil(f.data.size / 1024) * 1056) .map(f => 88 + Math.ceil(f.data.size / 1024) * 1056)
.reduce((a, b) => a + b); .reduce((a, b) => a + b);
const cursor = new BufferCursor(totalSize, true); const cursor = new BufferCursor(total_size, true);
writeFileHeaders(cursor, files); write_file_headers(cursor, files);
writeFileChunks(cursor, files); write_file_chunks(cursor, files);
if (cursor.size !== totalSize) { if (cursor.size !== total_size) {
throw new Error(`Expected a final file size of ${totalSize}, but got ${cursor.size}.`); throw new Error(`Expected a final file size of ${total_size}, but got ${cursor.size}.`);
} }
return cursor.seek_start(0); return cursor.seek_start(0);
} }
interface QstHeader { type QstHeader = {
questNo: number; quest_id: number,
fileName: string; file_name: string,
fileName2: string; file_name_2: string,
size: number; size: number,
} }
/** /**
* TODO: Read all headers instead of just the first 2. * TODO: Read all headers instead of just the first 2.
*/ */
function parseHeaders(cursor: BufferCursor): QstHeader[] { function parse_headers(cursor: BufferCursor): QstHeader[] {
const headers = []; const headers: QstHeader[] = [];
for (let i = 0; i < 2; ++i) { for (let i = 0; i < 2; ++i) {
cursor.seek(4); cursor.seek(4);
const questNo = cursor.u16(); const quest_id = cursor.u16();
cursor.seek(38); cursor.seek(38);
const fileName = cursor.string_ascii(16, true, true); const file_name = cursor.string_ascii(16, true, true);
const size = cursor.u32(); const size = cursor.u32();
// Not sure what this is: // Not sure what this is:
const fileName2 = cursor.string_ascii(24, true, true); const file_name_2 = cursor.string_ascii(24, true, true);
headers.push({ headers.push({
questNo, quest_id,
fileName, file_name,
fileName2, file_name_2,
size size
}); });
} }
@ -133,34 +134,34 @@ function parseHeaders(cursor: BufferCursor): QstHeader[] {
return headers; return headers;
} }
function parseFiles(cursor: BufferCursor, expectedSizes: Map<string, number>): QstContainedFile[] { function parse_files(cursor: BufferCursor, expected_sizes: Map<string, number>): QstContainedFile[] {
// Files are interleaved in 1056 byte chunks. // Files are interleaved in 1056 byte chunks.
// Each chunk has a 24 byte header, 1024 byte data segment and an 8 byte trailer. // Each chunk has a 24 byte header, 1024 byte data segment and an 8 byte trailer.
const files = new Map<string, QstContainedFile>(); const files = new Map<string, QstContainedFile>();
while (cursor.bytes_left >= 1056) { while (cursor.bytes_left >= 1056) {
const startPosition = cursor.position; const start_position = cursor.position;
// Read meta data. // Read meta data.
const chunkNo = cursor.seek(4).u8(); const chunk_no = cursor.seek(4).u8();
const fileName = cursor.seek(3).string_ascii(16, true, true); const file_name = cursor.seek(3).string_ascii(16, true, true);
let file = files.get(fileName); let file = files.get(file_name);
if (!file) { if (!file) {
const expectedSize = expectedSizes.get(fileName); const expected_size = expected_sizes.get(file_name);
files.set(fileName, file = { files.set(file_name, file = {
name: fileName, name: file_name,
expectedSize, expected_size,
data: new BufferCursor(expectedSize || (10 * 1024), true), data: new BufferCursor(expected_size || (10 * 1024), true),
chunkNos: new Set() chunk_nos: new Set()
}); });
} }
if (file.chunkNos.has(chunkNo)) { if (file.chunk_nos.has(chunk_no)) {
logger.warn(`File chunk number ${chunkNo} of file ${fileName} was already encountered, overwriting previous chunk.`); logger.warn(`File chunk number ${chunk_no} of file ${file_name} was already encountered, overwriting previous chunk.`);
} else { } else {
file.chunkNos.add(chunkNo); file.chunk_nos.add(chunk_no);
} }
// Read file data. // Read file data.
@ -173,15 +174,15 @@ function parseFiles(cursor: BufferCursor, expectedSizes: Map<string, number>): Q
} }
const data = cursor.take(size); const data = cursor.take(size);
const chunkPosition = chunkNo * 1024; const chunk_position = chunk_no * 1024;
file.data.size = Math.max(chunkPosition + size, file.data.size); file.data.size = Math.max(chunk_position + size, file.data.size);
file.data.seek_start(chunkPosition).write_cursor(data); file.data.seek_start(chunk_position).write_cursor(data);
// Skip the padding and the trailer. // Skip the padding and the trailer.
cursor.seek(1032 - data.size); cursor.seek(1032 - data.size);
if (cursor.position !== startPosition + 1056) { if (cursor.position !== start_position + 1056) {
throw new Error(`Read ${cursor.position - startPosition} file chunk message bytes instead of expected 1056.`); throw new Error(`Read ${cursor.position - start_position} file chunk message bytes instead of expected 1056.`);
} }
} }
@ -192,19 +193,19 @@ function parseFiles(cursor: BufferCursor, expectedSizes: Map<string, number>): Q
for (const file of files.values()) { for (const file of files.values()) {
// Clean up file properties. // Clean up file properties.
file.data.seek_start(0); file.data.seek_start(0);
file.chunkNos = new Set(Array.from(file.chunkNos.values()).sort((a, b) => a - b)); file.chunk_nos = new Set(Array.from(file.chunk_nos.values()).sort((a, b) => a - b));
// Check whether the expected size was correct. // Check whether the expected size was correct.
if (file.expectedSize != null && file.data.size !== file.expectedSize) { if (file.expected_size != null && file.data.size !== file.expected_size) {
logger.warn(`File ${file.name} has an actual size of ${file.data.size} instead of the expected size ${file.expectedSize}.`); logger.warn(`File ${file.name} has an actual size of ${file.data.size} instead of the expected size ${file.expected_size}.`);
} }
// Detect missing file chunks. // Detect missing file chunks.
const actualSize = Math.max(file.data.size, file.expectedSize || 0); const actual_size = Math.max(file.data.size, file.expected_size || 0);
for (let chunkNo = 0; chunkNo < Math.ceil(actualSize / 1024); ++chunkNo) { for (let chunk_no = 0; chunk_no < Math.ceil(actual_size / 1024); ++chunk_no) {
if (!file.chunkNos.has(chunkNo)) { if (!file.chunk_nos.has(chunk_no)) {
logger.warn(`File ${file.name} is missing chunk ${chunkNo}.`); logger.warn(`File ${file.name} is missing chunk ${chunk_no}.`);
} }
} }
} }
@ -212,7 +213,7 @@ function parseFiles(cursor: BufferCursor, expectedSizes: Map<string, number>): Q
return Array.from(files.values()); return Array.from(files.values());
} }
function writeFileHeaders(cursor: BufferCursor, files: SimpleQstContainedFile[]): void { function write_file_headers(cursor: BufferCursor, files: SimpleQstContainedFile[]): void {
for (const file of files) { for (const file of files) {
if (file.name.length > 16) { if (file.name.length > 16) {
throw Error(`File ${file.name} has a name longer than 16 characters.`); throw Error(`File ${file.name} has a name longer than 16 characters.`);
@ -220,7 +221,7 @@ function writeFileHeaders(cursor: BufferCursor, files: SimpleQstContainedFile[])
cursor.write_u16(88); // Header size. cursor.write_u16(88); // Header size.
cursor.write_u16(0x44); // Magic number. cursor.write_u16(0x44); // Magic number.
cursor.write_u16(file.questNo || 0); cursor.write_u16(file.id || 0);
for (let i = 0; i < 38; ++i) { for (let i = 0; i < 38; ++i) {
cursor.write_u8(0); cursor.write_u8(0);
@ -229,40 +230,40 @@ function writeFileHeaders(cursor: BufferCursor, files: SimpleQstContainedFile[])
cursor.write_string_ascii(file.name, 16); cursor.write_string_ascii(file.name, 16);
cursor.write_u32(file.data.size); cursor.write_u32(file.data.size);
let fileName2: string; let file_name_2: string;
if (file.name2 == null) { if (file.name_2 == null) {
// Not sure this makes sense. // Not sure this makes sense.
const dotPos = file.name.lastIndexOf('.'); const dot_pos = file.name.lastIndexOf('.');
fileName2 = dotPos === -1 file_name_2 = dot_pos === -1
? file.name + '_j' ? file.name + '_j'
: file.name.slice(0, dotPos) + '_j' + file.name.slice(dotPos); : file.name.slice(0, dot_pos) + '_j' + file.name.slice(dot_pos);
} else { } else {
fileName2 = file.name2; file_name_2 = file.name_2;
} }
if (fileName2.length > 24) { if (file_name_2.length > 24) {
throw Error(`File ${file.name} has a fileName2 length (${fileName2}) longer than 24 characters.`); throw Error(`File ${file.name} has a file_name_2 length (${file_name_2}) longer than 24 characters.`);
} }
cursor.write_string_ascii(fileName2, 24); cursor.write_string_ascii(file_name_2, 24);
} }
} }
function writeFileChunks(cursor: BufferCursor, files: SimpleQstContainedFile[]): void { function write_file_chunks(cursor: BufferCursor, files: SimpleQstContainedFile[]): void {
// Files are interleaved in 1056 byte chunks. // Files are interleaved in 1056 byte chunks.
// Each chunk has a 24 byte header, 1024 byte data segment and an 8 byte trailer. // Each chunk has a 24 byte header, 1024 byte data segment and an 8 byte trailer.
files = files.slice(); files = files.slice();
const chunkNos = new Array(files.length).fill(0); const chunk_nos = new Array(files.length).fill(0);
while (files.length) { while (files.length) {
let i = 0; let i = 0;
while (i < files.length) { while (i < files.length) {
if (!writeFileChunk(cursor, files[i].data, chunkNos[i]++, files[i].name)) { if (!write_file_chunk(cursor, files[i].data, chunk_nos[i]++, files[i].name)) {
// Remove if there are no more chunks to write. // Remove if there are no more chunks to write.
files.splice(i, 1); files.splice(i, 1);
chunkNos.splice(i, 1); chunk_nos.splice(i, 1);
} else { } else {
++i; ++i;
} }
@ -273,14 +274,14 @@ function writeFileChunks(cursor: BufferCursor, files: SimpleQstContainedFile[]):
/** /**
* @returns true if there are bytes left to write in data, false otherwise. * @returns true if there are bytes left to write in data, false otherwise.
*/ */
function writeFileChunk( function write_file_chunk(
cursor: BufferCursor, cursor: BufferCursor,
data: BufferCursor, data: BufferCursor,
chunkNo: number, chunk_no: number,
name: string name: string
): boolean { ): boolean {
cursor.write_u8_array([28, 4, 19, 0]); cursor.write_u8_array([28, 4, 19, 0]);
cursor.write_u8(chunkNo); cursor.write_u8(chunk_no);
cursor.write_u8_array([0, 0, 0]); cursor.write_u8_array([0, 0, 0]);
cursor.write_string_ascii(name, 16); cursor.write_string_ascii(name, 16);
@ -295,5 +296,5 @@ function writeFileChunk(
cursor.write_u32(size); cursor.write_u32(size);
cursor.write_u32(0); cursor.write_u32(0);
return !!data.bytes_left; return data.bytes_left > 0;
} }

18
src/data_formats/parsing/unitxt.ts
View File

@ -3,27 +3,27 @@ import { decompress } from "../compression/prs";
export type Unitxt = string[][]; export type Unitxt = string[][];
export function parseUnitxt(buf: BufferCursor, compressed: boolean = true): Unitxt { export function parse_unitxt(buf: BufferCursor, compressed: boolean = true): Unitxt {
if (compressed) { if (compressed) {
buf = decompress(buf); buf = decompress(buf);
} }
const categoryCount = buf.u32(); const category_count = buf.u32();
const entryCounts = buf.u32_array(categoryCount); const entry_counts = buf.u32_array(category_count);
const categoryEntryOffsets: Array<Array<number>> = []; const category_entry_offsets: Array<Array<number>> = [];
for (const entryCount of entryCounts) { for (const entry_count of entry_counts) {
categoryEntryOffsets.push(buf.u32_array(entryCount)); category_entry_offsets.push(buf.u32_array(entry_count));
} }
const categories: Unitxt = []; const categories: Unitxt = [];
for (const categoryEntryOffset of categoryEntryOffsets) { for (const category_entry_offset of category_entry_offsets) {
const entries: string[] = []; const entries: string[] = [];
categories.push(entries); categories.push(entries);
for (const entryOffset of categoryEntryOffset) { for (const entry_offset of category_entry_offset) {
buf.seek_start(entryOffset); buf.seek_start(entry_offset);
const str = buf.string_utf16(1024, true, true); const str = buf.string_utf16(1024, true, true);
entries.push(str); entries.push(str);
} }

28
src/domain/NpcType.ts
View File

@ -19,7 +19,7 @@ export class NpcType {
readonly ultimate_name: string; readonly ultimate_name: string;
readonly episode?: number; readonly episode?: number;
readonly enemy: boolean; readonly enemy: boolean;
rareType?: NpcType; rare_type?: NpcType;
constructor( constructor(
id: number, id: number,
@ -300,10 +300,10 @@ export class NpcType {
NpcType.Hildebear = new NpcType(id++, 'Hildebear', 'Hildebear', 'Hildebear', 'Hildelt', 1, true); NpcType.Hildebear = new NpcType(id++, 'Hildebear', 'Hildebear', 'Hildebear', 'Hildelt', 1, true);
NpcType.Hildeblue = new NpcType(id++, 'Hildeblue', 'Hildeblue', 'Hildeblue', 'Hildetorr', 1, true); NpcType.Hildeblue = new NpcType(id++, 'Hildeblue', 'Hildeblue', 'Hildeblue', 'Hildetorr', 1, true);
NpcType.Hildebear.rareType = NpcType.Hildeblue; NpcType.Hildebear.rare_type = NpcType.Hildeblue;
NpcType.RagRappy = new NpcType(id++, 'RagRappy', 'Rag Rappy', 'Rag Rappy', 'El Rappy', 1, true); NpcType.RagRappy = new NpcType(id++, 'RagRappy', 'Rag Rappy', 'Rag Rappy', 'El Rappy', 1, true);
NpcType.AlRappy = new NpcType(id++, 'AlRappy', 'Al Rappy', 'Al Rappy', 'Pal Rappy', 1, true); NpcType.AlRappy = new NpcType(id++, 'AlRappy', 'Al Rappy', 'Al Rappy', 'Pal Rappy', 1, true);
NpcType.RagRappy.rareType = NpcType.AlRappy; NpcType.RagRappy.rare_type = NpcType.AlRappy;
NpcType.Monest = new NpcType(id++, 'Monest', 'Monest', 'Monest', 'Mothvist', 1, true); NpcType.Monest = new NpcType(id++, 'Monest', 'Monest', 'Monest', 'Mothvist', 1, true);
NpcType.Mothmant = new NpcType(id++, 'Mothmant', 'Mothmant', 'Mothmant', 'Mothvert', 1, true); NpcType.Mothmant = new NpcType(id++, 'Mothmant', 'Mothmant', 'Mothmant', 'Mothvert', 1, true);
NpcType.SavageWolf = new NpcType(id++, 'SavageWolf', 'Savage Wolf', 'Savage Wolf', 'Gulgus', 1, true); NpcType.SavageWolf = new NpcType(id++, 'SavageWolf', 'Savage Wolf', 'Savage Wolf', 'Gulgus', 1, true);
@ -318,14 +318,14 @@ export class NpcType {
NpcType.GrassAssassin = new NpcType(id++, 'GrassAssassin', 'Grass Assassin', 'Grass Assassin', 'Crimson Assassin', 1, true); NpcType.GrassAssassin = new NpcType(id++, 'GrassAssassin', 'Grass Assassin', 'Grass Assassin', 'Crimson Assassin', 1, true);
NpcType.PoisonLily = new NpcType(id++, 'PoisonLily', 'Poison Lily', 'Poison Lily', 'Ob Lily', 1, true); NpcType.PoisonLily = new NpcType(id++, 'PoisonLily', 'Poison Lily', 'Poison Lily', 'Ob Lily', 1, true);
NpcType.NarLily = new NpcType(id++, 'NarLily', 'Nar Lily', 'Nar Lily', 'Mil Lily', 1, true); NpcType.NarLily = new NpcType(id++, 'NarLily', 'Nar Lily', 'Nar Lily', 'Mil Lily', 1, true);
NpcType.PoisonLily.rareType = NpcType.NarLily; NpcType.PoisonLily.rare_type = NpcType.NarLily;
NpcType.NanoDragon = new NpcType(id++, 'NanoDragon', 'Nano Dragon', 'Nano Dragon', 'Nano Dragon', 1, true); NpcType.NanoDragon = new NpcType(id++, 'NanoDragon', 'Nano Dragon', 'Nano Dragon', 'Nano Dragon', 1, true);
NpcType.EvilShark = new NpcType(id++, 'EvilShark', 'Evil Shark', 'Evil Shark', 'Vulmer', 1, true); NpcType.EvilShark = new NpcType(id++, 'EvilShark', 'Evil Shark', 'Evil Shark', 'Vulmer', 1, true);
NpcType.PalShark = new NpcType(id++, 'PalShark', 'Pal Shark', 'Pal Shark', 'Govulmer', 1, true); NpcType.PalShark = new NpcType(id++, 'PalShark', 'Pal Shark', 'Pal Shark', 'Govulmer', 1, true);
NpcType.GuilShark = new NpcType(id++, 'GuilShark', 'Guil Shark', 'Guil Shark', 'Melqueek', 1, true); NpcType.GuilShark = new NpcType(id++, 'GuilShark', 'Guil Shark', 'Guil Shark', 'Melqueek', 1, true);
NpcType.PofuillySlime = new NpcType(id++, 'PofuillySlime', 'Pofuilly Slime', 'Pofuilly Slime', 'Pofuilly Slime', 1, true); NpcType.PofuillySlime = new NpcType(id++, 'PofuillySlime', 'Pofuilly Slime', 'Pofuilly Slime', 'Pofuilly Slime', 1, true);
NpcType.PouillySlime = new NpcType(id++, 'PouillySlime', 'Pouilly Slime', 'Pouilly Slime', 'Pouilly Slime', 1, true); NpcType.PouillySlime = new NpcType(id++, 'PouillySlime', 'Pouilly Slime', 'Pouilly Slime', 'Pouilly Slime', 1, true);
NpcType.PofuillySlime.rareType = NpcType.PouillySlime; NpcType.PofuillySlime.rare_type = NpcType.PouillySlime;
NpcType.PanArms = new NpcType(id++, 'PanArms', 'Pan Arms', 'Pan Arms', 'Pan Arms', 1, true); NpcType.PanArms = new NpcType(id++, 'PanArms', 'Pan Arms', 'Pan Arms', 'Pan Arms', 1, true);
NpcType.Migium = new NpcType(id++, 'Migium', 'Migium', 'Migium', 'Migium', 1, true); NpcType.Migium = new NpcType(id++, 'Migium', 'Migium', 'Migium', 'Migium', 1, true);
NpcType.Hidoom = new NpcType(id++, 'Hidoom', 'Hidoom', 'Hidoom', 'Hidoom', 1, true); NpcType.Hidoom = new NpcType(id++, 'Hidoom', 'Hidoom', 'Hidoom', 'Hidoom', 1, true);
@ -363,10 +363,10 @@ export class NpcType {
NpcType.Hildebear2 = new NpcType(id++, 'Hildebear2', 'Hildebear (Ep. II)', 'Hildebear', 'Hildelt', 2, true); NpcType.Hildebear2 = new NpcType(id++, 'Hildebear2', 'Hildebear (Ep. II)', 'Hildebear', 'Hildelt', 2, true);
NpcType.Hildeblue2 = new NpcType(id++, 'Hildeblue2', 'Hildeblue (Ep. II)', 'Hildeblue', 'Hildetorr', 2, true); NpcType.Hildeblue2 = new NpcType(id++, 'Hildeblue2', 'Hildeblue (Ep. II)', 'Hildeblue', 'Hildetorr', 2, true);
NpcType.Hildebear2.rareType = NpcType.Hildeblue2; NpcType.Hildebear2.rare_type = NpcType.Hildeblue2;
NpcType.RagRappy2 = new NpcType(id++, 'RagRappy2', 'Rag Rappy (Ep. II)', 'Rag Rappy', 'El Rappy', 2, true); NpcType.RagRappy2 = new NpcType(id++, 'RagRappy2', 'Rag Rappy (Ep. II)', 'Rag Rappy', 'El Rappy', 2, true);
NpcType.LoveRappy = new NpcType(id++, 'LoveRappy', 'Love Rappy', 'Love Rappy', 'Love Rappy', 2, true); NpcType.LoveRappy = new NpcType(id++, 'LoveRappy', 'Love Rappy', 'Love Rappy', 'Love Rappy', 2, true);
NpcType.RagRappy2.rareType = NpcType.LoveRappy; NpcType.RagRappy2.rare_type = NpcType.LoveRappy;
NpcType.StRappy = new NpcType(id++, 'StRappy', 'St. Rappy', 'St. Rappy', 'St. Rappy', 2, true); NpcType.StRappy = new NpcType(id++, 'StRappy', 'St. Rappy', 'St. Rappy', 'St. Rappy', 2, true);
NpcType.HalloRappy = new NpcType(id++, 'HalloRappy', 'Hallo Rappy', 'Hallo Rappy', 'Hallo Rappy', 2, true); NpcType.HalloRappy = new NpcType(id++, 'HalloRappy', 'Hallo Rappy', 'Hallo Rappy', 'Hallo Rappy', 2, true);
NpcType.EggRappy = new NpcType(id++, 'EggRappy', 'Egg Rappy', 'Egg Rappy', 'Egg Rappy', 2, true); NpcType.EggRappy = new NpcType(id++, 'EggRappy', 'Egg Rappy', 'Egg Rappy', 'Egg Rappy', 2, true);
@ -374,7 +374,7 @@ export class NpcType {
NpcType.Mothmant2 = new NpcType(id++, 'Mothmant2', 'Mothmant', 'Mothmant', 'Mothvert', 2, true); NpcType.Mothmant2 = new NpcType(id++, 'Mothmant2', 'Mothmant', 'Mothmant', 'Mothvert', 2, true);
NpcType.PoisonLily2 = new NpcType(id++, 'PoisonLily2', 'Poison Lily (Ep. II)', 'Poison Lily', 'Ob Lily', 2, true); NpcType.PoisonLily2 = new NpcType(id++, 'PoisonLily2', 'Poison Lily (Ep. II)', 'Poison Lily', 'Ob Lily', 2, true);
NpcType.NarLily2 = new NpcType(id++, 'NarLily2', 'Nar Lily (Ep. II)', 'Nar Lily', 'Mil Lily', 2, true); NpcType.NarLily2 = new NpcType(id++, 'NarLily2', 'Nar Lily (Ep. II)', 'Nar Lily', 'Mil Lily', 2, true);
NpcType.PoisonLily2.rareType = NpcType.NarLily2; NpcType.PoisonLily2.rare_type = NpcType.NarLily2;
NpcType.GrassAssassin2 = new NpcType(id++, 'GrassAssassin2', 'Grass Assassin (Ep. II)', 'Grass Assassin', 'Crimson Assassin', 2, true); NpcType.GrassAssassin2 = new NpcType(id++, 'GrassAssassin2', 'Grass Assassin (Ep. II)', 'Grass Assassin', 'Crimson Assassin', 2, true);
NpcType.Dimenian2 = new NpcType(id++, 'Dimenian2', 'Dimenian (Ep. II)', 'Dimenian', 'Arlan', 2, true); NpcType.Dimenian2 = new NpcType(id++, 'Dimenian2', 'Dimenian (Ep. II)', 'Dimenian', 'Arlan', 2, true);
NpcType.LaDimenian2 = new NpcType(id++, 'LaDimenian2', 'La Dimenian (Ep. II)', 'La Dimenian', 'Merlan', 2, true); NpcType.LaDimenian2 = new NpcType(id++, 'LaDimenian2', 'La Dimenian (Ep. II)', 'La Dimenian', 'Merlan', 2, true);
@ -433,31 +433,31 @@ export class NpcType {
NpcType.SandRappy = new NpcType(id++, 'SandRappy', 'Sand Rappy', 'Sand Rappy', 'Sand Rappy', 4, true); NpcType.SandRappy = new NpcType(id++, 'SandRappy', 'Sand Rappy', 'Sand Rappy', 'Sand Rappy', 4, true);
NpcType.DelRappy = new NpcType(id++, 'DelRappy', 'Del Rappy', 'Del Rappy', 'Del Rappy', 4, true); NpcType.DelRappy = new NpcType(id++, 'DelRappy', 'Del Rappy', 'Del Rappy', 'Del Rappy', 4, true);
NpcType.SandRappy.rareType = NpcType.DelRappy; NpcType.SandRappy.rare_type = NpcType.DelRappy;
NpcType.Astark = new NpcType(id++, 'Astark', 'Astark', 'Astark', 'Astark', 4, true); NpcType.Astark = new NpcType(id++, 'Astark', 'Astark', 'Astark', 'Astark', 4, true);
NpcType.SatelliteLizard = new NpcType(id++, 'SatelliteLizard', 'Satellite Lizard', 'Satellite Lizard', 'Satellite Lizard', 4, true); NpcType.SatelliteLizard = new NpcType(id++, 'SatelliteLizard', 'Satellite Lizard', 'Satellite Lizard', 'Satellite Lizard', 4, true);
NpcType.Yowie = new NpcType(id++, 'Yowie', 'Yowie', 'Yowie', 'Yowie', 4, true); NpcType.Yowie = new NpcType(id++, 'Yowie', 'Yowie', 'Yowie', 'Yowie', 4, true);
NpcType.MerissaA = new NpcType(id++, 'MerissaA', 'Merissa A', 'Merissa A', 'Merissa A', 4, true); NpcType.MerissaA = new NpcType(id++, 'MerissaA', 'Merissa A', 'Merissa A', 'Merissa A', 4, true);
NpcType.MerissaAA = new NpcType(id++, 'MerissaAA', 'Merissa AA', 'Merissa AA', 'Merissa AA', 4, true); NpcType.MerissaAA = new NpcType(id++, 'MerissaAA', 'Merissa AA', 'Merissa AA', 'Merissa AA', 4, true);
NpcType.MerissaA.rareType = NpcType.MerissaAA; NpcType.MerissaA.rare_type = NpcType.MerissaAA;
NpcType.Girtablulu = new NpcType(id++, 'Girtablulu', 'Girtablulu', 'Girtablulu', 'Girtablulu', 4, true); NpcType.Girtablulu = new NpcType(id++, 'Girtablulu', 'Girtablulu', 'Girtablulu', 'Girtablulu', 4, true);
NpcType.Zu = new NpcType(id++, 'Zu', 'Zu', 'Zu', 'Zu', 4, true); NpcType.Zu = new NpcType(id++, 'Zu', 'Zu', 'Zu', 'Zu', 4, true);
NpcType.Pazuzu = new NpcType(id++, 'Pazuzu', 'Pazuzu', 'Pazuzu', 'Pazuzu', 4, true); NpcType.Pazuzu = new NpcType(id++, 'Pazuzu', 'Pazuzu', 'Pazuzu', 'Pazuzu', 4, true);
NpcType.Zu.rareType = NpcType.Pazuzu; NpcType.Zu.rare_type = NpcType.Pazuzu;
NpcType.Boota = new NpcType(id++, 'Boota', 'Boota', 'Boota', 'Boota', 4, true); NpcType.Boota = new NpcType(id++, 'Boota', 'Boota', 'Boota', 'Boota', 4, true);
NpcType.ZeBoota = new NpcType(id++, 'ZeBoota', 'Ze Boota', 'Ze Boota', 'Ze Boota', 4, true); NpcType.ZeBoota = new NpcType(id++, 'ZeBoota', 'Ze Boota', 'Ze Boota', 'Ze Boota', 4, true);
NpcType.BaBoota = new NpcType(id++, 'BaBoota', 'Ba Boota', 'Ba Boota', 'Ba Boota', 4, true); NpcType.BaBoota = new NpcType(id++, 'BaBoota', 'Ba Boota', 'Ba Boota', 'Ba Boota', 4, true);
NpcType.Dorphon = new NpcType(id++, 'Dorphon', 'Dorphon', 'Dorphon', 'Dorphon', 4, true); NpcType.Dorphon = new NpcType(id++, 'Dorphon', 'Dorphon', 'Dorphon', 'Dorphon', 4, true);
NpcType.DorphonEclair = new NpcType(id++, 'DorphonEclair', 'Dorphon Eclair', 'Dorphon Eclair', 'Dorphon Eclair', 4, true); NpcType.DorphonEclair = new NpcType(id++, 'DorphonEclair', 'Dorphon Eclair', 'Dorphon Eclair', 'Dorphon Eclair', 4, true);
NpcType.Dorphon.rareType = NpcType.DorphonEclair; NpcType.Dorphon.rare_type = NpcType.DorphonEclair;
NpcType.Goran = new NpcType(id++, 'Goran', 'Goran', 'Goran', 'Goran', 4, true); NpcType.Goran = new NpcType(id++, 'Goran', 'Goran', 'Goran', 'Goran', 4, true);
NpcType.PyroGoran = new NpcType(id++, 'PyroGoran', 'Pyro Goran', 'Pyro Goran', 'Pyro Goran', 4, true); NpcType.PyroGoran = new NpcType(id++, 'PyroGoran', 'Pyro Goran', 'Pyro Goran', 'Pyro Goran', 4, true);
NpcType.GoranDetonator = new NpcType(id++, 'GoranDetonator', 'Goran Detonator', 'Goran Detonator', 'Goran Detonator', 4, true); NpcType.GoranDetonator = new NpcType(id++, 'GoranDetonator', 'Goran Detonator', 'Goran Detonator', 'Goran Detonator', 4, true);
NpcType.SaintMilion = new NpcType(id++, 'SaintMilion', 'Saint-Milion', 'Saint-Milion', 'Saint-Milion', 4, true); NpcType.SaintMilion = new NpcType(id++, 'SaintMilion', 'Saint-Milion', 'Saint-Milion', 'Saint-Milion', 4, true);
NpcType.Shambertin = new NpcType(id++, 'Shambertin', 'Shambertin', 'Shambertin', 'Shambertin', 4, true); NpcType.Shambertin = new NpcType(id++, 'Shambertin', 'Shambertin', 'Shambertin', 'Shambertin', 4, true);
NpcType.Kondrieu = new NpcType(id++, 'Kondrieu', 'Kondrieu', 'Kondrieu', 'Kondrieu', 4, true); NpcType.Kondrieu = new NpcType(id++, 'Kondrieu', 'Kondrieu', 'Kondrieu', 'Kondrieu', 4, true);
NpcType.SaintMilion.rareType = NpcType.Kondrieu; NpcType.SaintMilion.rare_type = NpcType.Kondrieu;
NpcType.Shambertin.rareType = NpcType.Kondrieu; NpcType.Shambertin.rare_type = NpcType.Kondrieu;
}()); }());
export const NpcTypes: Array<NpcType> = [ export const NpcTypes: Array<NpcType> = [

34
src/domain/index.ts
View File

@ -4,8 +4,9 @@ import { BufferCursor } from '../data_formats/BufferCursor';
import { DatNpc, DatObject, DatUnknown } from '../data_formats/parsing/quest/dat'; import { DatNpc, DatObject, DatUnknown } from '../data_formats/parsing/quest/dat';
import { NpcType } from './NpcType'; import { NpcType } from './NpcType';
import { ObjectType } from './ObjectType'; import { ObjectType } from './ObjectType';
import { enumValues as enum_values } from '../enums'; import { enum_values } from '../enums';
import { ItemType } from './items'; import { ItemType } from './items';
import { Vec3 } from '../data_formats/Vec3';
export * from './items'; export * from './items';
export * from './NpcType'; export * from './NpcType';
@ -55,29 +56,6 @@ export enum Difficulty {
export const Difficulties: Difficulty[] = enum_values(Difficulty); export const Difficulties: Difficulty[] = enum_values(Difficulty);
export class Vec3 {
x: number;
y: number;
z: number;
constructor(x: number, y: number, z: number) {
this.x = x;
this.y = y;
this.z = z;
}
add(v: Vec3): Vec3 {
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this;
}
clone() {
return new Vec3(this.x, this.y, this.z);
}
};
export class Section { export class Section {
id: number; id: number;
@observable position: Vec3; @observable position: Vec3;
@ -108,10 +86,10 @@ export class Section {
} }
export class Quest { export class Quest {
@observable id?: number;
@observable name: string; @observable name: string;
@observable short_description: string; @observable short_description: string;
@observable long_description: string; @observable long_description: string;
@observable quest_no?: number;
@observable episode: Episode; @observable episode: Episode;
@observable area_variants: AreaVariant[]; @observable area_variants: AreaVariant[];
@observable objects: QuestObject[]; @observable objects: QuestObject[];
@ -126,10 +104,10 @@ export class Quest {
bin_data: BufferCursor; bin_data: BufferCursor;
constructor( constructor(
id: number | undefined,
name: string, name: string,
short_description: string, short_description: string,
long_description: string, long_description: string,
quest_no: number | undefined,
episode: Episode, episode: Episode,
area_variants: AreaVariant[], area_variants: AreaVariant[],
objects: QuestObject[], objects: QuestObject[],
@ -137,15 +115,15 @@ export class Quest {
dat_unknowns: DatUnknown[], dat_unknowns: DatUnknown[],
bin_data: BufferCursor bin_data: BufferCursor
) { ) {
if (quest_no != null && (!Number.isInteger(quest_no) || quest_no < 0)) throw new Error('quest_no should be null or a non-negative integer.'); if (id != null && (!Number.isInteger(id) || id < 0)) throw new Error('id should be undefined or a non-negative integer.');
check_episode(episode); check_episode(episode);
if (!objects || !(objects instanceof Array)) throw new Error('objs is required.'); if (!objects || !(objects instanceof Array)) throw new Error('objs is required.');
if (!npcs || !(npcs instanceof Array)) throw new Error('npcs is required.'); if (!npcs || !(npcs instanceof Array)) throw new Error('npcs is required.');
this.id = id;
this.name = name; this.name = name;
this.short_description = short_description; this.short_description = short_description;
this.long_description = long_description; this.long_description = long_description;
this.quest_no = quest_no;
this.episode = episode; this.episode = episode;
this.area_variants = area_variants; this.area_variants = area_variants;
this.objects = objects; this.objects = objects;

26
src/domain/items.ts
View File

@ -15,11 +15,11 @@ export class WeaponItemType implements ItemType {
constructor( constructor(
readonly id: number, readonly id: number,
readonly name: string, readonly name: string,
readonly minAtp: number, readonly min_atp: number,
readonly maxAtp: number, readonly max_atp: number,
readonly ata: number, readonly ata: number,
readonly maxGrind: number, readonly max_grind: number,
readonly requiredAtp: number, readonly required_atp: number,
) { } ) { }
} }
@ -29,10 +29,10 @@ export class ArmorItemType implements ItemType {
readonly name: string, readonly name: string,
readonly atp: number, readonly atp: number,
readonly ata: number, readonly ata: number,
readonly minEvp: number, readonly min_evp: number,
readonly maxEvp: number, readonly max_evp: number,
readonly minDfp: number, readonly min_dfp: number,
readonly maxDfp: number, readonly max_dfp: number,
readonly mst: number, readonly mst: number,
readonly hp: number, readonly hp: number,
readonly lck: number, readonly lck: number,
@ -45,10 +45,10 @@ export class ShieldItemType implements ItemType {
readonly name: string, readonly name: string,
readonly atp: number, readonly atp: number,
readonly ata: number, readonly ata: number,
readonly minEvp: number, readonly min_evp: number,
readonly maxEvp: number, readonly max_evp: number,
readonly minDfp: number, readonly min_dfp: number,
readonly maxDfp: number, readonly max_dfp: number,
readonly mst: number, readonly mst: number,
readonly hp: number, readonly hp: number,
readonly lck: number, readonly lck: number,
@ -90,7 +90,7 @@ export class WeaponItem implements Item {
@observable hit: number = 0; @observable hit: number = 0;
@observable grind: number = 0; @observable grind: number = 0;
@computed get grindAtp(): number { @computed get grind_atp(): number {
return 2 * this.grind; return 2 * this.grind;
} }

16
src/enums.ts
View File

@ -1,15 +1,15 @@
export function enumValues<E>(e: any): E[] { export function enum_values<E>(e: any): E[] {
const values = Object.values(e); const values = Object.values(e);
const numberValues = values.filter(v => typeof v === 'number'); const number_values = values.filter(v => typeof v === 'number');
if (numberValues.length) { if (number_values.length) {
return numberValues as any as E[]; return number_values as any as E[];
} else { } else {
return values as any as E[]; return values as any as E[];
} }
} }
export function enumNames(e: any): string[] { export function enum_names(e: any): string[] {
return Object.keys(e).filter(k => typeof (e as any)[k] === 'string'); return Object.keys(e).filter(k => typeof (e as any)[k] === 'string');
} }
@ -20,11 +20,11 @@ export class EnumMap<K, V> {
private keys: K[]; private keys: K[];
private values = new Map<K, V>(); private values = new Map<K, V>();
constructor(enum_: any, initialValue: (key: K) => V) { constructor(enum_: any, initial_value: (key: K) => V) {
this.keys = enumValues(enum_); this.keys = enum_values(enum_);
for (const key of this.keys) { for (const key of this.keys) {
this.values.set(key, initialValue(key)); this.values.set(key, initial_value(key));
} }
} }

3
src/rendering/QuestRenderer.ts
View File

@ -1,5 +1,6 @@
import { Intersection, Mesh, MeshLambertMaterial, Object3D, Plane, Raycaster, Vector2, Vector3 } from "three"; import { Intersection, Mesh, MeshLambertMaterial, Object3D, Plane, Raycaster, Vector2, Vector3 } from "three";
import { Area, Quest, QuestEntity, QuestNpc, QuestObject, Section, Vec3 } from "../domain"; import { Area, Quest, QuestEntity, QuestNpc, QuestObject, Section } from "../domain";
import { Vec3 } from "../data_formats/Vec3";
import { area_store } from "../stores/AreaStore"; import { area_store } from "../stores/AreaStore";
import { quest_editor_store } from "../stores/QuestEditorStore"; import { quest_editor_store } from "../stores/QuestEditorStore";
import { NPC_COLOR, NPC_HOVER_COLOR, NPC_SELECTED_COLOR, OBJECT_COLOR, OBJECT_HOVER_COLOR, OBJECT_SELECTED_COLOR } from "./entities"; import { NPC_COLOR, NPC_HOVER_COLOR, NPC_SELECTED_COLOR, OBJECT_COLOR, OBJECT_HOVER_COLOR, OBJECT_SELECTED_COLOR } from "./entities";

3
src/rendering/entities.test.ts
View File

@ -1,6 +1,7 @@
import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from 'three'; import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from 'three';
import { DatNpc, DatObject } from '../data_formats/parsing/quest/dat'; import { DatNpc, DatObject } from '../data_formats/parsing/quest/dat';
import { NpcType, ObjectType, QuestNpc, QuestObject, Vec3 } from '../domain'; import { NpcType, ObjectType, QuestNpc, QuestObject } from '../domain';
import { Vec3 } from "../data_formats/Vec3";
import { create_npc_mesh, create_object_mesh, NPC_COLOR, OBJECT_COLOR } from './entities'; import { create_npc_mesh, create_object_mesh, NPC_COLOR, OBJECT_COLOR } from './entities';
const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0); const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0);

2
src/rendering/index.ts
View File

@ -1,4 +1,4 @@
import { Vec3 } from "../domain"; import { Vec3 } from "../data_formats/Vec3";
import { Vector3 } from "three"; import { Vector3 } from "three";
export function vec3_to_threejs(v: Vec3): Vector3 { export function vec3_to_threejs(v: Vec3): Vector3 {

4
src/stores/ApplicationStore.ts
View File

@ -2,7 +2,7 @@ import { observable } from "mobx";
import { Server } from "../domain"; import { Server } from "../domain";
class ApplicationStore { class ApplicationStore {
@observable currentServer: Server = Server.Ephinea; @observable current_server: Server = Server.Ephinea;
} }
export const applicationStore = new ApplicationStore(); export const application_store = new ApplicationStore();

16
src/stores/AreaStore.ts
View File

@ -1,9 +1,9 @@
import { Area, AreaVariant, Section } from '../domain'; import { Area, AreaVariant, Section } from '../domain';
import { Object3D } from 'three'; import { Object3D } from 'three';
import { parseCRel, parseNRel } from '../data_formats/parsing/geometry'; import { parse_c_rel, parse_n_rel } from '../data_formats/parsing/geometry';
import { get_area_render_data, get_area_collision_data } from './binary_assets'; import { get_area_render_data, get_area_collision_data } from './binary_assets';
function area(id: number, name: string, order: number, variants: number) { function area(id: number, name: string, order: number, variants: number): Area {
const area = new Area(id, name, order, []); const area = new Area(id, name, order, []);
const varis = Array(variants).fill(null).map((_, i) => new AreaVariant(i, area)); const varis = Array(variants).fill(null).map((_, i) => new AreaVariant(i, area));
area.area_variants.splice(0, 0, ...varis); area.area_variants.splice(0, 0, ...varis);
@ -77,7 +77,7 @@ class AreaStore {
]; ];
} }
get_variant(episode: number, area_id: number, variant_id: number) { get_variant(episode: number, area_id: number, variant_id: number): AreaVariant {
if (episode !== 1 && episode !== 2 && episode !== 4) if (episode !== 1 && episode !== 2 && episode !== 4)
throw new Error(`Expected episode to be 1, 2 or 4, got ${episode}.`); throw new Error(`Expected episode to be 1, 2 or 4, got ${episode}.`);
@ -120,7 +120,7 @@ class AreaStore {
} else { } else {
return this.get_area_sections_and_render_geometry( return this.get_area_sections_and_render_geometry(
episode, area_id, area_variant episode, area_id, area_variant
).then(({ object3d }) => object3d); ).then(({ object_3d }) => object_3d);
} }
} }
@ -136,7 +136,7 @@ class AreaStore {
} else { } else {
const object_3d = get_area_collision_data( const object_3d = get_area_collision_data(
episode, area_id, area_variant episode, area_id, area_variant
).then(parseCRel); ).then(parse_c_rel);
collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d); collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d);
return object_3d; return object_3d;
} }
@ -146,16 +146,16 @@ class AreaStore {
episode: number, episode: number,
area_id: number, area_id: number,
area_variant: number area_variant: number
): Promise<{ sections: Section[], object3d: Object3D }> { ): Promise<{ sections: Section[], object_3d: Object3D }> {
const promise = get_area_render_data( const promise = get_area_render_data(
episode, area_id, area_variant episode, area_id, area_variant
).then(parseNRel); ).then(parse_n_rel);
const sections = new Promise<Section[]>((resolve, reject) => { const sections = new Promise<Section[]>((resolve, reject) => {
promise.then(({ sections }) => resolve(sections)).catch(reject); promise.then(({ sections }) => resolve(sections)).catch(reject);
}); });
const object_3d = new Promise<Object3D>((resolve, reject) => { const object_3d = new Promise<Object3D>((resolve, reject) => {
promise.then(({ object3d }) => resolve(object3d)).catch(reject); promise.then(({ object_3d }) => resolve(object_3d)).catch(reject);
}); });
sections_cache.set(`${episode}-${area_id}-${area_variant}`, sections); sections_cache.set(`${episode}-${area_id}-${area_variant}`, sections);

108
src/stores/DpsCalcStore.ts
View File

@ -1,6 +1,6 @@
import { observable, IObservableArray, computed } from "mobx"; import { observable, IObservableArray, computed } from "mobx";
import { WeaponItem, WeaponItemType, ArmorItemType, ShieldItemType } from "../domain"; import { WeaponItem, WeaponItemType, ArmorItemType, ShieldItemType } from "../domain";
import { itemTypeStores } from "./ItemTypeStore"; import { item_type_stores } from "./ItemTypeStore";
const NORMAL_DAMAGE_FACTOR = 0.2 * 0.9; const NORMAL_DAMAGE_FACTOR = 0.2 * 0.9;
const HEAVY_DAMAGE_FACTOR = NORMAL_DAMAGE_FACTOR * 1.89; const HEAVY_DAMAGE_FACTOR = NORMAL_DAMAGE_FACTOR * 1.89;
@ -11,60 +11,60 @@ const HEAVY_DAMAGE_FACTOR = NORMAL_DAMAGE_FACTOR * 1.89;
class Weapon { class Weapon {
readonly item: WeaponItem; readonly item: WeaponItem;
@computed get shiftaAtp(): number { @computed get shifta_atp(): number {
if (this.item.type.minAtp === this.item.type.maxAtp) { if (this.item.type.min_atp === this.item.type.max_atp) {
return 0; return 0;
} else { } else {
return this.item.type.maxAtp * this.store.shiftaFactor; return this.item.type.max_atp * this.store.shifta_factor;
} }
} }
@computed get minAtp(): number { @computed get min_atp(): number {
return this.item.type.minAtp + this.item.grindAtp; return this.item.type.min_atp + this.item.grind_atp;
} }
@computed get maxAtp(): number { @computed get max_atp(): number {
return this.item.type.maxAtp + this.item.grindAtp + this.shiftaAtp; return this.item.type.max_atp + this.item.grind_atp + this.shifta_atp;
} }
@computed get finalMinAtp(): number { @computed get final_min_atp(): number {
return this.minAtp return this.min_atp
+ this.store.armorAtp + this.store.armor_atp
+ this.store.shieldAtp + this.store.shield_atp
+ this.store.baseAtp + this.store.base_atp
+ this.store.baseShiftaAtp; + this.store.base_shifta_atp;
} }
@computed get finalMaxAtp(): number { @computed get final_max_atp(): number {
return this.maxAtp return this.max_atp
+ this.store.armorAtp + this.store.armor_atp
+ this.store.shieldAtp + this.store.shield_atp
+ this.store.baseAtp + this.store.base_atp
+ this.store.baseShiftaAtp; + this.store.base_shifta_atp;
} }
@computed get minNormalDamage(): number { @computed get min_normal_damage(): number {
return (this.finalMinAtp - this.store.enemyDfp) * NORMAL_DAMAGE_FACTOR; return (this.final_min_atp - this.store.enemy_dfp) * NORMAL_DAMAGE_FACTOR;
} }
@computed get maxNormalDamage(): number { @computed get max_normal_damage(): number {
return (this.finalMaxAtp - this.store.enemyDfp) * NORMAL_DAMAGE_FACTOR; return (this.final_max_atp - this.store.enemy_dfp) * NORMAL_DAMAGE_FACTOR;
} }
@computed get avgNormalDamage(): number { @computed get avg_normal_damage(): number {
return (this.minNormalDamage + this.maxNormalDamage) / 2; return (this.min_normal_damage + this.max_normal_damage) / 2;
} }
@computed get minHeavyDamage(): number { @computed get min_heavy_damage(): number {
return (this.finalMinAtp - this.store.enemyDfp) * HEAVY_DAMAGE_FACTOR; return (this.final_min_atp - this.store.enemy_dfp) * HEAVY_DAMAGE_FACTOR;
} }
@computed get maxHeavyDamage(): number { @computed get max_heavy_damage(): number {
return (this.finalMaxAtp - this.store.enemyDfp) * HEAVY_DAMAGE_FACTOR; return (this.final_max_atp - this.store.enemy_dfp) * HEAVY_DAMAGE_FACTOR;
} }
@computed get avgHeavyDamage(): number { @computed get avg_heavy_damage(): number {
return (this.minHeavyDamage + this.maxHeavyDamage) / 2; return (this.min_heavy_damage + this.max_heavy_damage) / 2;
} }
constructor( constructor(
@ -76,20 +76,20 @@ class Weapon {
} }
class DpsCalcStore { class DpsCalcStore {
@computed get weaponTypes(): WeaponItemType[] { @computed get weapon_types(): WeaponItemType[] {
return itemTypeStores.current.value.itemTypes.filter(it => return item_type_stores.current.value.item_types.filter(it =>
it instanceof WeaponItemType it instanceof WeaponItemType
) as WeaponItemType[]; ) as WeaponItemType[];
} }
@computed get armorTypes(): ArmorItemType[] { @computed get armor_types(): ArmorItemType[] {
return itemTypeStores.current.value.itemTypes.filter(it => return item_type_stores.current.value.item_types.filter(it =>
it instanceof ArmorItemType it instanceof ArmorItemType
) as ArmorItemType[]; ) as ArmorItemType[];
} }
@computed get shieldTypes(): ShieldItemType[] { @computed get shield_types(): ShieldItemType[] {
return itemTypeStores.current.value.itemTypes.filter(it => return item_type_stores.current.value.item_types.filter(it =>
it instanceof ShieldItemType it instanceof ShieldItemType
) as ShieldItemType[]; ) as ShieldItemType[];
} }
@ -98,41 +98,41 @@ class DpsCalcStore {
// Character Details // Character Details
// //
@observable charAtp: number = 0; @observable char_atp: number = 0;
@observable magPow: number = 0; @observable mag_pow: number = 0;
@computed get armorAtp(): number { return this.armorType ? this.armorType.atp : 0 } @computed get armor_atp(): number { return this.armor_type ? this.armor_type.atp : 0 }
@computed get shieldAtp(): number { return this.shieldType ? this.shieldType.atp : 0 } @computed get shield_atp(): number { return this.shield_type ? this.shield_type.atp : 0 }
@observable shiftaLvl: number = 0; @observable shifta_lvl: number = 0;
@computed get baseAtp(): number { @computed get base_atp(): number {
return this.charAtp + 2 * this.magPow; return this.char_atp + 2 * this.mag_pow;
} }
@computed get shiftaFactor(): number { @computed get shifta_factor(): number {
return this.shiftaLvl ? 0.013 * (this.shiftaLvl - 1) + 0.1 : 0; return this.shifta_lvl ? 0.013 * (this.shifta_lvl - 1) + 0.1 : 0;
} }
@computed get baseShiftaAtp(): number { @computed get base_shifta_atp(): number {
return this.baseAtp * this.shiftaFactor; return this.base_atp * this.shifta_factor;
} }
@observable readonly weapons: IObservableArray<Weapon> = observable.array(); @observable readonly weapons: IObservableArray<Weapon> = observable.array();
addWeapon = (type: WeaponItemType) => { add_weapon = (type: WeaponItemType) => {
this.weapons.push(new Weapon( this.weapons.push(new Weapon(
this, this,
new WeaponItem(type) new WeaponItem(type)
)); ));
} }
@observable armorType?: ArmorItemType; @observable armor_type?: ArmorItemType;
@observable shieldType?: ShieldItemType; @observable shield_type?: ShieldItemType;
// //
// Enemy Details // Enemy Details
// //
@observable enemyDfp: number = 0; @observable enemy_dfp: number = 0;
} }
export const dpsCalcStore = new DpsCalcStore(); export const dps_calc_store = new DpsCalcStore();

56
src/stores/HuntMethodStore.ts
View File

@ -9,12 +9,12 @@ const logger = Logger.get('stores/HuntMethodStore');
class HuntMethodStore { class HuntMethodStore {
@observable methods: ServerMap<Loadable<Array<HuntMethod>>> = new ServerMap(server => @observable methods: ServerMap<Loadable<Array<HuntMethod>>> = new ServerMap(server =>
new Loadable([], () => this.loadHuntMethods(server)) new Loadable([], () => this.load_hunt_methods(server))
); );
private storageDisposer?: IReactionDisposer; private storage_disposer?: IReactionDisposer;
private async loadHuntMethods(server: Server): Promise<HuntMethod[]> { private async load_hunt_methods(server: Server): Promise<HuntMethod[]> {
const response = await fetch( const response = await fetch(
`${process.env.PUBLIC_URL}/quests.${Server[server].toLowerCase()}.json` `${process.env.PUBLIC_URL}/quests.${Server[server].toLowerCase()}.json`
); );
@ -22,17 +22,17 @@ class HuntMethodStore {
const methods = new Array<HuntMethod>(); const methods = new Array<HuntMethod>();
for (const quest of quests) { for (const quest of quests) {
let totalCount = 0; let total_count = 0;
const enemyCounts = new Map<NpcType, number>(); const enemy_counts = new Map<NpcType, number>();
for (const [code, count] of Object.entries(quest.enemyCounts)) { for (const [code, count] of Object.entries(quest.enemyCounts)) {
const npcType = NpcType.by_code(code); const npc_type = NpcType.by_code(code);
if (!npcType) { if (!npc_type) {
logger.error(`No NpcType found for code ${code}.`); logger.error(`No NpcType found for code ${code}.`);
} else { } else {
enemyCounts.set(npcType, count); enemy_counts.set(npc_type, count);
totalCount += count; total_count += count;
} }
} }
@ -61,56 +61,56 @@ class HuntMethodStore {
quest.id, quest.id,
quest.name, quest.name,
quest.episode, quest.episode,
enemyCounts enemy_counts
), ),
/^\d-\d.*/.test(quest.name) ? 0.75 : (totalCount > 400 ? 0.75 : 0.5) /^\d-\d.*/.test(quest.name) ? 0.75 : (total_count > 400 ? 0.75 : 0.5)
) )
); );
} }
this.loadFromLocalStorage(methods, server); this.load_from_local_storage(methods, server);
return methods; return methods;
} }
private loadFromLocalStorage = (methods: HuntMethod[], server: Server) => { private load_from_local_storage = (methods: HuntMethod[], server: Server) => {
try { try {
const methodUserTimesJson = localStorage.getItem( const method_user_times_json = localStorage.getItem(
`HuntMethodStore.methodUserTimes.${Server[server]}` `HuntMethodStore.methodUserTimes.${Server[server]}`
); );
if (methodUserTimesJson) { if (method_user_times_json) {
const userTimes = JSON.parse(methodUserTimesJson); const user_times: StoredUserTimes = JSON.parse(method_user_times_json);
for (const method of methods) { for (const method of methods) {
method.user_time = userTimes[method.id] as number; method.user_time = user_times[method.id];
} }
} }
if (this.storageDisposer) { if (this.storage_disposer) {
this.storageDisposer(); this.storage_disposer();
} }
this.storageDisposer = autorun(() => this.storage_disposer = autorun(() =>
this.storeInLocalStorage(methods, server) this.store_in_local_storage(methods, server)
); );
} catch (e) { } catch (e) {
logger.error(e); logger.error(e);
} }
} }
private storeInLocalStorage = (methods: HuntMethod[], server: Server) => { private store_in_local_storage = (methods: HuntMethod[], server: Server) => {
try { try {
const userTimes: any = {}; const user_times: StoredUserTimes = {};
for (const method of methods) { for (const method of methods) {
if (method.user_time != null) { if (method.user_time != undefined) {
userTimes[method.id] = method.user_time; user_times[method.id] = method.user_time;
} }
} }
localStorage.setItem( localStorage.setItem(
`HuntMethodStore.methodUserTimes.${Server[server]}`, `HuntMethodStore.methodUserTimes.${Server[server]}`,
JSON.stringify(userTimes) JSON.stringify(user_times)
); );
} catch (e) { } catch (e) {
logger.error(e); logger.error(e);
@ -118,4 +118,6 @@ class HuntMethodStore {
} }
} }
export const huntMethodStore = new HuntMethodStore(); type StoredUserTimes = { [method_id: string]: number };
export const hunt_method_store = new HuntMethodStore();

252
src/stores/HuntOptimizerStore.ts
View File

@ -1,44 +1,44 @@
import solver from 'javascript-lp-solver'; import solver from 'javascript-lp-solver';
import { autorun, IObservableArray, observable, computed } from "mobx"; import { autorun, IObservableArray, observable, computed } from "mobx";
import { Difficulties, Difficulty, HuntMethod, ItemType, KONDRIEU_PROB, NpcType, RARE_ENEMY_PROB, SectionId, SectionIds, Server, Episode } from "../domain"; import { Difficulties, Difficulty, HuntMethod, ItemType, KONDRIEU_PROB, NpcType, RARE_ENEMY_PROB, SectionId, SectionIds, Server, Episode } from "../domain";
import { applicationStore } from './ApplicationStore'; import { application_store } from './ApplicationStore';
import { huntMethodStore } from "./HuntMethodStore"; import { hunt_method_store } from "./HuntMethodStore";
import { itemDropStores } from './ItemDropStore'; import { item_drop_stores as item_drop_stores } from './ItemDropStore';
import { itemTypeStores } from './ItemTypeStore'; import { item_type_stores } from './ItemTypeStore';
import Logger from 'js-logger'; import Logger from 'js-logger';
const logger = Logger.get('stores/HuntOptimizerStore'); const logger = Logger.get('stores/HuntOptimizerStore');
export class WantedItem { export class WantedItem {
@observable readonly itemType: ItemType; @observable readonly item_type: ItemType;
@observable amount: number; @observable amount: number;
constructor(itemType: ItemType, amount: number) { constructor(item_type: ItemType, amount: number) {
this.itemType = itemType; this.item_type = item_type;
this.amount = amount; this.amount = amount;
} }
} }
export class OptimalResult { export class OptimalResult {
constructor( constructor(
readonly wantedItems: Array<ItemType>, readonly wanted_items: Array<ItemType>,
readonly optimalMethods: Array<OptimalMethod> readonly optimal_methods: Array<OptimalMethod>
) { } ) { }
} }
export class OptimalMethod { export class OptimalMethod {
readonly totalTime: number; readonly total_time: number;
constructor( constructor(
readonly difficulty: Difficulty, readonly difficulty: Difficulty,
readonly sectionIds: Array<SectionId>, readonly section_ids: Array<SectionId>,
readonly methodName: string, readonly method_name: string,
readonly methodEpisode: Episode, readonly method_episode: Episode,
readonly methodTime: number, readonly method_time: number,
readonly runs: number, readonly runs: number,
readonly itemCounts: Map<ItemType, number> readonly item_counts: Map<ItemType, number>
) { ) {
this.totalTime = runs * methodTime; this.total_time = runs * method_time;
} }
} }
@ -50,15 +50,15 @@ export class OptimalMethod {
// Can be useful when deciding which item to hunt first. // Can be useful when deciding which item to hunt first.
// TODO: boxes. // TODO: boxes.
class HuntOptimizerStore { class HuntOptimizerStore {
@computed get huntableItemTypes(): Array<ItemType> { @computed get huntable_item_types(): Array<ItemType> {
const itemDropStore = itemDropStores.current.value; const item_drop_store = item_drop_stores.current.value;
return itemTypeStores.current.value.itemTypes.filter(i => return item_type_stores.current.value.item_types.filter(i =>
itemDropStore.enemyDrops.getDropsForItemType(i.id).length item_drop_store.enemy_drops.get_drops_for_item_type(i.id).length
); );
} }
// TODO: wanted items per server. // TODO: wanted items per server.
@observable readonly wantedItems: IObservableArray<WantedItem> = observable.array(); @observable readonly wanted_items: IObservableArray<WantedItem> = observable.array();
@observable result?: OptimalResult; @observable result?: OptimalResult;
constructor() { constructor() {
@ -66,23 +66,23 @@ class HuntOptimizerStore {
} }
optimize = async () => { optimize = async () => {
if (!this.wantedItems.length) { if (!this.wanted_items.length) {
this.result = undefined; this.result = undefined;
return; return;
} }
// Initialize this set before awaiting data, so user changes don't affect this optimization // Initialize this set before awaiting data, so user changes don't affect this optimization
// run from this point on. // run from this point on.
const wantedItems = new Set(this.wantedItems.filter(w => w.amount > 0).map(w => w.itemType)); const wanted_items = new Set(this.wanted_items.filter(w => w.amount > 0).map(w => w.item_type));
const methods = await huntMethodStore.methods.current.promise; const methods = await hunt_method_store.methods.current.promise;
const dropTable = (await itemDropStores.current.promise).enemyDrops; const drop_table = (await item_drop_stores.current.promise).enemy_drops;
// Add a constraint per wanted item. // Add a constraint per wanted item.
const constraints: { [itemName: string]: { min: number } } = {}; const constraints: { [item_name: string]: { min: number } } = {};
for (const wanted of this.wantedItems) { for (const wanted of this.wanted_items) {
constraints[wanted.itemType.name] = { min: wanted.amount }; constraints[wanted.item_type.name] = { min: wanted.amount };
} }
// Add a variable to the LP model per method per difficulty per section ID. // Add a variable to the LP model per method per difficulty per section ID.
@ -92,107 +92,107 @@ class HuntOptimizerStore {
// of enemies that drop the item multiplied by the corresponding drop rate as its value. // of enemies that drop the item multiplied by the corresponding drop rate as its value.
type Variable = { type Variable = {
time: number, time: number,
[itemName: string]: number, [item_name: string]: number,
} }
const variables: { [methodName: string]: Variable } = {}; const variables: { [method_name: string]: Variable } = {};
type VariableDetails = { type VariableDetails = {
method: HuntMethod, method: HuntMethod,
difficulty: Difficulty, difficulty: Difficulty,
sectionId: SectionId, section_id: SectionId,
splitPanArms: boolean, split_pan_arms: boolean,
} }
const variableDetails: Map<string, VariableDetails> = new Map(); const variable_details: Map<string, VariableDetails> = new Map();
for (const method of methods) { for (const method of methods) {
// Counts include rare enemies, so they are fractional. // Counts include rare enemies, so they are fractional.
const counts = new Map<NpcType, number>(); const counts = new Map<NpcType, number>();
for (const [enemy, count] of method.enemy_counts.entries()) { for (const [enemy, count] of method.enemy_counts.entries()) {
const oldCount = counts.get(enemy) || 0; const old_count = counts.get(enemy) || 0;
if (enemy.rareType == null) { if (enemy.rare_type == null) {
counts.set(enemy, oldCount + count); counts.set(enemy, old_count + count);
} else { } else {
let rate, rareRate; let rate, rare_rate;
if (enemy.rareType === NpcType.Kondrieu) { if (enemy.rare_type === NpcType.Kondrieu) {
rate = 1 - KONDRIEU_PROB; rate = 1 - KONDRIEU_PROB;
rareRate = KONDRIEU_PROB; rare_rate = KONDRIEU_PROB;
} else { } else {
rate = 1 - RARE_ENEMY_PROB; rate = 1 - RARE_ENEMY_PROB;
rareRate = RARE_ENEMY_PROB; rare_rate = RARE_ENEMY_PROB;
} }
counts.set(enemy, oldCount + count * rate); counts.set(enemy, old_count + count * rate);
counts.set( counts.set(
enemy.rareType, enemy.rare_type,
(counts.get(enemy.rareType) || 0) + count * rareRate (counts.get(enemy.rare_type) || 0) + count * rare_rate
); );
} }
} }
// Create a secondary counts map if there are any pan arms that can be split into // Create a secondary counts map if there are any pan arms that can be split into
// migiums and hidooms. // migiums and hidooms.
const countsList: Array<Map<NpcType, number>> = [counts]; const counts_list: Array<Map<NpcType, number>> = [counts];
const panArmsCount = counts.get(NpcType.PanArms); const pan_arms_count = counts.get(NpcType.PanArms);
if (panArmsCount) { if (pan_arms_count) {
const splitCounts = new Map(counts); const split_counts = new Map(counts);
splitCounts.delete(NpcType.PanArms); split_counts.delete(NpcType.PanArms);
splitCounts.set(NpcType.Migium, panArmsCount); split_counts.set(NpcType.Migium, pan_arms_count);
splitCounts.set(NpcType.Hidoom, panArmsCount); split_counts.set(NpcType.Hidoom, pan_arms_count);
countsList.push(splitCounts); counts_list.push(split_counts);
} }
const panArms2Count = counts.get(NpcType.PanArms2); const pan_arms_2_count = counts.get(NpcType.PanArms2);
if (panArms2Count) { if (pan_arms_2_count) {
const splitCounts = new Map(counts); const split_counts = new Map(counts);
splitCounts.delete(NpcType.PanArms2); split_counts.delete(NpcType.PanArms2);
splitCounts.set(NpcType.Migium2, panArms2Count); split_counts.set(NpcType.Migium2, pan_arms_2_count);
splitCounts.set(NpcType.Hidoom2, panArms2Count); split_counts.set(NpcType.Hidoom2, pan_arms_2_count);
countsList.push(splitCounts); counts_list.push(split_counts);
} }
for (let i = 0; i < countsList.length; i++) { for (let i = 0; i < counts_list.length; i++) {
const counts = countsList[i]; const counts = counts_list[i];
const splitPanArms = i === 1; const split_pan_arms = i === 1;
for (const diff of Difficulties) { for (const difficulty of Difficulties) {
for (const sectionId of SectionIds) { for (const section_id of SectionIds) {
// Will contain an entry per wanted item dropped by enemies in this method/ // Will contain an entry per wanted item dropped by enemies in this method/
// difficulty/section ID combo. // difficulty/section ID combo.
const variable: Variable = { const variable: Variable = {
time: method.time time: method.time
}; };
// Only add the variable if the method provides at least 1 item we want. // Only add the variable if the method provides at least 1 item we want.
let addVariable = false; let add_variable = false;
for (const [npcType, count] of counts.entries()) { for (const [npc_type, count] of counts.entries()) {
const drop = dropTable.getDrop(diff, sectionId, npcType); const drop = drop_table.get_drop(difficulty, section_id, npc_type);
if (drop && wantedItems.has(drop.item_type)) { if (drop && wanted_items.has(drop.item_type)) {
const value = variable[drop.item_type.name] || 0; const value = variable[drop.item_type.name] || 0;
variable[drop.item_type.name] = value + count * drop.rate; variable[drop.item_type.name] = value + count * drop.rate;
addVariable = true; add_variable = true;
} }
} }
if (addVariable) { if (add_variable) {
const name = this.fullMethodName( const name = this.full_method_name(
diff, sectionId, method, splitPanArms difficulty, section_id, method, split_pan_arms
); );
variables[name] = variable; variables[name] = variable;
variableDetails.set(name, { variable_details.set(name, {
method, method,
difficulty: diff, difficulty,
sectionId, section_id,
splitPanArms split_pan_arms
}); });
} }
} }
@ -220,23 +220,23 @@ class HuntOptimizerStore {
return; return;
} }
const optimalMethods: Array<OptimalMethod> = []; const optimal_methods: Array<OptimalMethod> = [];
// Loop over the entries in result, ignore standard properties that aren't variables. // Loop over the entries in result, ignore standard properties that aren't variables.
for (const [variableName, runsOrOther] of Object.entries(result)) { for (const [variable_name, runs_or_other] of Object.entries(result)) {
const details = variableDetails.get(variableName); const details = variable_details.get(variable_name);
if (details) { if (details) {
const { method, difficulty, sectionId, splitPanArms } = details; const { method, difficulty, section_id, split_pan_arms } = details;
const runs = runsOrOther as number; const runs = runs_or_other as number;
const variable = variables[variableName]; const variable = variables[variable_name];
const items = new Map<ItemType, number>(); const items = new Map<ItemType, number>();
for (const [itemName, expectedAmount] of Object.entries(variable)) { for (const [item_name, expected_amount] of Object.entries(variable)) {
for (const item of wantedItems) { for (const item of wanted_items) {
if (itemName === item.name) { if (item_name === item.name) {
items.set(item, runs * expectedAmount); items.set(item, runs * expected_amount);
break; break;
} }
} }
@ -245,37 +245,37 @@ class HuntOptimizerStore {
// Find all section IDs that provide the same items with the same expected amount. // Find all section IDs that provide the same items with the same expected amount.
// E.g. if you need a spread needle and a bringer's right arm, using either // E.g. if you need a spread needle and a bringer's right arm, using either
// purplenum or yellowboze will give you the exact same probabilities. // purplenum or yellowboze will give you the exact same probabilities.
const sectionIds: Array<SectionId> = []; const section_ids: Array<SectionId> = [];
for (const sid of SectionIds) { for (const sid of SectionIds) {
let matchFound = true; let match_found = true;
if (sid !== sectionId) { if (sid !== section_id) {
const v = variables[ const v = variables[
this.fullMethodName(difficulty, sid, method, splitPanArms) this.full_method_name(difficulty, sid, method, split_pan_arms)
]; ];
if (!v) { if (!v) {
matchFound = false; match_found = false;
} else { } else {
for (const itemName of Object.keys(variable)) { for (const item_name of Object.keys(variable)) {
if (variable[itemName] !== v[itemName]) { if (variable[item_name] !== v[item_name]) {
matchFound = false; match_found = false;
break; break;
} }
} }
} }
} }
if (matchFound) { if (match_found) {
sectionIds.push(sid); section_ids.push(sid);
} }
} }
optimalMethods.push(new OptimalMethod( optimal_methods.push(new OptimalMethod(
difficulty, difficulty,
sectionIds, section_ids,
method.name + (splitPanArms ? ' (Split Pan Arms)' : ''), method.name + (split_pan_arms ? ' (Split Pan Arms)' : ''),
method.episode, method.episode,
method.time, method.time,
runs, runs,
@ -285,62 +285,62 @@ class HuntOptimizerStore {
} }
this.result = new OptimalResult( this.result = new OptimalResult(
[...wantedItems], [...wanted_items],
optimalMethods optimal_methods
); );
} }
private fullMethodName( private full_method_name(
difficulty: Difficulty, difficulty: Difficulty,
sectionId: SectionId, section_id: SectionId,
method: HuntMethod, method: HuntMethod,
splitPanArms: boolean split_pan_arms: boolean
): string { ): string {
let name = `${difficulty}\t${sectionId}\t${method.id}`; let name = `${difficulty}\t${section_id}\t${method.id}`;
if (splitPanArms) name += '\tspa'; if (split_pan_arms) name += '\tspa';
return name; return name;
} }
private initialize = async () => { private initialize = async () => {
try { try {
await this.loadFromLocalStorage(); await this.load_from_local_storage();
autorun(this.storeInLocalStorage); autorun(this.store_in_local_storage);
} catch (e) { } catch (e) {
logger.error(e); logger.error(e);
} }
} }
private loadFromLocalStorage = async () => { private load_from_local_storage = async () => {
const wantedItemsJson = localStorage.getItem( const wanted_items_json = localStorage.getItem(
`HuntOptimizerStore.wantedItems.${Server[applicationStore.currentServer]}` `HuntOptimizerStore.wantedItems.${Server[application_store.current_server]}`
); );
if (wantedItemsJson) { if (wanted_items_json) {
const itemStore = await itemTypeStores.current.promise; const item_store = await item_type_stores.current.promise;
const wi = JSON.parse(wantedItemsJson); const wi: StoredWantedItem[] = JSON.parse(wanted_items_json);
const wantedItems: WantedItem[] = []; const wanted_items: WantedItem[] = [];
for (const { itemTypeId, itemKindId, amount } of wi) { for (const { itemTypeId, itemKindId, amount } of wi) {
const item = itemTypeId != null const item = itemTypeId != undefined
? itemStore.getById(itemTypeId) ? item_store.get_by_id(itemTypeId)
: itemStore.getById(itemKindId); // Legacy name. : item_store.get_by_id(itemKindId!);
if (item) { if (item) {
wantedItems.push(new WantedItem(item, amount)); wanted_items.push(new WantedItem(item, amount));
} }
} }
this.wantedItems.replace(wantedItems); this.wanted_items.replace(wanted_items);
} }
} }
private storeInLocalStorage = () => { private store_in_local_storage = () => {
try { try {
localStorage.setItem( localStorage.setItem(
`HuntOptimizerStore.wantedItems.${Server[applicationStore.currentServer]}`, `HuntOptimizerStore.wantedItems.${Server[application_store.current_server]}`,
JSON.stringify( JSON.stringify(
this.wantedItems.map(({ itemType, amount }) => ({ this.wanted_items.map(({ item_type: itemType, amount }): StoredWantedItem => ({
itemTypeId: itemType.id, itemTypeId: itemType.id,
amount amount
})) }))
@ -352,4 +352,10 @@ class HuntOptimizerStore {
} }
} }
export const huntOptimizerStore = new HuntOptimizerStore(); type StoredWantedItem = {
itemTypeId?: number, // Should only be undefined if the legacy name is still used.
itemKindId?: number, // Legacy name.
amount: number,
};
export const hunt_optimizer_store = new HuntOptimizerStore();

88
src/stores/ItemDropStore.ts
View File

@ -3,101 +3,101 @@ import { Difficulties, Difficulty, EnemyDrop, NpcType, SectionId, SectionIds, Se
import { NpcTypes } from "../domain/NpcType"; import { NpcTypes } from "../domain/NpcType";
import { EnemyDropDto } from "../dto"; import { EnemyDropDto } from "../dto";
import { Loadable } from "../Loadable"; import { Loadable } from "../Loadable";
import { itemTypeStores } from "./ItemTypeStore"; import { item_type_stores } from "./ItemTypeStore";
import { ServerMap } from "./ServerMap"; import { ServerMap } from "./ServerMap";
import Logger from 'js-logger'; import Logger from 'js-logger';
const logger = Logger.get('stores/ItemDropStore'); const logger = Logger.get('stores/ItemDropStore');
class EnemyDropTable { export class EnemyDropTable {
// Mapping of difficulties to section IDs to NpcTypes to EnemyDrops. // Mapping of difficulties to section IDs to NpcTypes to EnemyDrops.
private table: Array<EnemyDrop> = private table: EnemyDrop[] =
new Array(Difficulties.length * SectionIds.length * NpcTypes.length); new Array(Difficulties.length * SectionIds.length * NpcTypes.length);
// Mapping of ItemType ids to EnemyDrops. // Mapping of ItemType ids to EnemyDrops.
private itemTypeToDrops: Array<Array<EnemyDrop>> = []; private item_type_to_drops: EnemyDrop[][] = [];
getDrop(difficulty: Difficulty, sectionId: SectionId, npcType: NpcType): EnemyDrop | undefined { get_drop(difficulty: Difficulty, section_id: SectionId, npc_type: NpcType): EnemyDrop | undefined {
return this.table[ return this.table[
difficulty * SectionIds.length * NpcTypes.length difficulty * SectionIds.length * NpcTypes.length
+ sectionId * NpcTypes.length + section_id * NpcTypes.length
+ npcType.id + npc_type.id
]; ];
} }
setDrop(difficulty: Difficulty, sectionId: SectionId, npcType: NpcType, drop: EnemyDrop) { set_drop(difficulty: Difficulty, section_id: SectionId, npc_type: NpcType, drop: EnemyDrop) {
this.table[ this.table[
difficulty * SectionIds.length * NpcTypes.length difficulty * SectionIds.length * NpcTypes.length
+ sectionId * NpcTypes.length + section_id * NpcTypes.length
+ npcType.id + npc_type.id
] = drop; ] = drop;
let drops = this.itemTypeToDrops[drop.item_type.id]; let drops = this.item_type_to_drops[drop.item_type.id];
if (!drops) { if (!drops) {
drops = []; drops = [];
this.itemTypeToDrops[drop.item_type.id] = drops; this.item_type_to_drops[drop.item_type.id] = drops;
} }
drops.push(drop); drops.push(drop);
} }
getDropsForItemType(itemTypeId: number): Array<EnemyDrop> { get_drops_for_item_type(item_type_id: number): EnemyDrop[] {
return this.itemTypeToDrops[itemTypeId] || []; return this.item_type_to_drops[item_type_id] || [];
} }
} }
class ItemDropStore { export class ItemDropStore {
@observable enemyDrops: EnemyDropTable = new EnemyDropTable(); @observable.ref enemy_drops: EnemyDropTable = new EnemyDropTable();
}
load = async (server: Server): Promise<ItemDropStore> => { export const item_drop_stores: ServerMap<Loadable<ItemDropStore>> = new ServerMap(server => {
const itemTypeStore = await itemTypeStores.current.promise; const store = new ItemDropStore();
return new Loadable(store, () => load(store, server));
});
async function load(store: ItemDropStore, server: Server): Promise<ItemDropStore> {
const item_type_store = await item_type_stores.current.promise;
const response = await fetch( const response = await fetch(
`${process.env.PUBLIC_URL}/enemyDrops.${Server[server].toLowerCase()}.json` `${process.env.PUBLIC_URL}/enemyDrops.${Server[server].toLowerCase()}.json`
); );
const data: Array<EnemyDropDto> = await response.json(); const data: EnemyDropDto[] = await response.json();
const drops = new EnemyDropTable(); const drops = new EnemyDropTable();
for (const dropDto of data) { for (const drop_dto of data) {
const npcType = NpcType.by_code(dropDto.enemy); const npc_type = NpcType.by_code(drop_dto.enemy);
if (!npcType) { if (!npc_type) {
logger.warn(`Couldn't determine NpcType of episode ${dropDto.episode} ${dropDto.enemy}.`); logger.warn(`Couldn't determine NpcType of episode ${drop_dto.episode} ${drop_dto.enemy}.`);
continue; continue;
} }
const difficulty = (Difficulty as any)[dropDto.difficulty]; const difficulty = (Difficulty as any)[drop_dto.difficulty];
const itemType = itemTypeStore.getById(dropDto.itemTypeId); const item_type = item_type_store.get_by_id(drop_dto.itemTypeId);
if (!itemType) { if (!item_type) {
logger.warn(`Couldn't find item kind ${dropDto.itemTypeId}.`); logger.warn(`Couldn't find item kind ${drop_dto.itemTypeId}.`);
continue; continue;
} }
const sectionId = (SectionId as any)[dropDto.sectionId]; const section_id = (SectionId as any)[drop_dto.sectionId];
if (sectionId == null) { if (section_id == null) {
logger.warn(`Couldn't find section ID ${dropDto.sectionId}.`); logger.warn(`Couldn't find section ID ${drop_dto.sectionId}.`);
continue; continue;
} }
drops.setDrop(difficulty, sectionId, npcType, new EnemyDrop( drops.set_drop(difficulty, section_id, npc_type, new EnemyDrop(
difficulty, difficulty,
sectionId, section_id,
npcType, npc_type,
itemType, item_type,
dropDto.dropRate, drop_dto.dropRate,
dropDto.rareRate drop_dto.rareRate
)); ));
} }
this.enemyDrops = drops; store.enemy_drops = drops;
return this; return store;
} }
}
export const itemDropStores: ServerMap<Loadable<ItemDropStore>> = new ServerMap(server => {
const store = new ItemDropStore();
return new Loadable(store, () => store.load(server));
});

102
src/stores/ItemTypeStore.ts
View File

@ -4,13 +4,13 @@ import { Loadable } from "../Loadable";
import { ServerMap } from "./ServerMap"; import { ServerMap } from "./ServerMap";
import { ItemTypeDto } from "../dto"; import { ItemTypeDto } from "../dto";
class ItemTypeStore { export class ItemTypeStore {
private idToItemType: Array<ItemType> = []; private id_to_item_type: Array<ItemType> = [];
@observable itemTypes: Array<ItemType> = []; @observable item_types: Array<ItemType> = [];
getById(id: number): ItemType | undefined { get_by_id(id: number): ItemType | undefined {
return this.idToItemType[id]; return this.id_to_item_type[id];
} }
load = async (server: Server): Promise<ItemTypeStore> => { load = async (server: Server): Promise<ItemTypeStore> => {
@ -19,80 +19,80 @@ class ItemTypeStore {
); );
const data: Array<ItemTypeDto> = await response.json(); const data: Array<ItemTypeDto> = await response.json();
const itemTypes = new Array<ItemType>(); const item_types = new Array<ItemType>();
for (const itemTypeDto of data) { for (const item_type_dto of data) {
let itemType: ItemType; let item_type: ItemType;
switch (itemTypeDto.class) { switch (item_type_dto.class) {
case 'weapon': case 'weapon':
itemType = new WeaponItemType( item_type = new WeaponItemType(
itemTypeDto.id, item_type_dto.id,
itemTypeDto.name, item_type_dto.name,
itemTypeDto.minAtp, item_type_dto.minAtp,
itemTypeDto.maxAtp, item_type_dto.maxAtp,
itemTypeDto.ata, item_type_dto.ata,
itemTypeDto.maxGrind, item_type_dto.maxGrind,
itemTypeDto.requiredAtp, item_type_dto.requiredAtp,
); );
break; break;
case 'armor': case 'armor':
itemType = new ArmorItemType( item_type = new ArmorItemType(
itemTypeDto.id, item_type_dto.id,
itemTypeDto.name, item_type_dto.name,
itemTypeDto.atp, item_type_dto.atp,
itemTypeDto.ata, item_type_dto.ata,
itemTypeDto.minEvp, item_type_dto.minEvp,
itemTypeDto.maxEvp, item_type_dto.maxEvp,
itemTypeDto.minDfp, item_type_dto.minDfp,
itemTypeDto.maxDfp, item_type_dto.maxDfp,
itemTypeDto.mst, item_type_dto.mst,
itemTypeDto.hp, item_type_dto.hp,
itemTypeDto.lck, item_type_dto.lck,
); );
break; break;
case 'shield': case 'shield':
itemType = new ShieldItemType( item_type = new ShieldItemType(
itemTypeDto.id, item_type_dto.id,
itemTypeDto.name, item_type_dto.name,
itemTypeDto.atp, item_type_dto.atp,
itemTypeDto.ata, item_type_dto.ata,
itemTypeDto.minEvp, item_type_dto.minEvp,
itemTypeDto.maxEvp, item_type_dto.maxEvp,
itemTypeDto.minDfp, item_type_dto.minDfp,
itemTypeDto.maxDfp, item_type_dto.maxDfp,
itemTypeDto.mst, item_type_dto.mst,
itemTypeDto.hp, item_type_dto.hp,
itemTypeDto.lck, item_type_dto.lck,
); );
break; break;
case 'unit': case 'unit':
itemType = new UnitItemType( item_type = new UnitItemType(
itemTypeDto.id, item_type_dto.id,
itemTypeDto.name, item_type_dto.name,
); );
break; break;
case 'tool': case 'tool':
itemType = new ToolItemType( item_type = new ToolItemType(
itemTypeDto.id, item_type_dto.id,
itemTypeDto.name, item_type_dto.name,
); );
break; break;
default: default:
continue; continue;
} }
this.idToItemType[itemType.id] = itemType; this.id_to_item_type[item_type.id] = item_type;
itemTypes.push(itemType); item_types.push(item_type);
} }
this.itemTypes = itemTypes; this.item_types = item_types;
return this; return this;
} }
} }
export const itemTypeStores: ServerMap<Loadable<ItemTypeStore>> = new ServerMap(server => { export const item_type_stores: ServerMap<Loadable<ItemTypeStore>> = new ServerMap(server => {
const store = new ItemTypeStore(); const store = new ItemTypeStore();
return new Loadable(store, () => store.load(server)); return new Loadable(store, () => store.load(server));
}); });

3
src/stores/QuestEditorStore.ts
View File

@ -2,7 +2,8 @@ import Logger from 'js-logger';
import { action, observable } from 'mobx'; import { action, observable } from 'mobx';
import { BufferCursor } from '../data_formats/BufferCursor'; import { BufferCursor } from '../data_formats/BufferCursor';
import { parse_quest, write_quest_qst } from '../data_formats/parsing/quest'; import { parse_quest, write_quest_qst } from '../data_formats/parsing/quest';
import { Area, Quest, QuestEntity, Section, Vec3 } from '../domain'; import { Area, Quest, QuestEntity, Section } from '../domain';
import { Vec3 } from "../data_formats/Vec3";
import { create_npc_mesh as create_npc_object_3d, create_object_mesh as create_object_object_3d } from '../rendering/entities'; import { create_npc_mesh as create_npc_object_3d, create_object_mesh as create_object_object_3d } from '../rendering/entities';
import { area_store } from './AreaStore'; import { area_store } from './AreaStore';
import { entity_store } from './EntityStore'; import { entity_store } from './EntityStore';

13
src/stores/ServerMap.ts
View File

@ -1,17 +1,20 @@
import { computed } from "mobx"; import { computed } from "mobx";
import { Server } from "../domain"; import { Server } from "../domain";
import { applicationStore } from "./ApplicationStore"; import { application_store } from "./ApplicationStore";
import { EnumMap } from "../enums"; import { EnumMap } from "../enums";
/**
* Map with a guaranteed value per server.
*/
export class ServerMap<V> extends EnumMap<Server, V> { export class ServerMap<V> extends EnumMap<Server, V> {
constructor(initialValue: (server: Server) => V) { constructor(initial_value: (server: Server) => V) {
super(Server, initialValue) super(Server, initial_value)
} }
/** /**
* @returns the value for the current server as set in {@link applicationStore}. * @returns the value for the current server as set in {@link application_store}.
*/ */
@computed get current(): V { @computed get current(): V {
return this.get(applicationStore.currentServer); return this.get(application_store.current_server);
} }
} }

82
src/ui/BigTable.tsx
View File

@ -6,14 +6,14 @@ export type Column<T> = {
key?: string, key?: string,
name: string, name: string,
width: number, width: number,
cellRenderer: (record: T) => ReactNode, cell_renderer: (record: T) => ReactNode,
tooltip?: (record: T) => string, tooltip?: (record: T) => string,
footerValue?: string, footer_value?: string,
footerTooltip?: string, footer_tooltip?: string,
/** /**
* "number" and "integrated" have special meaning. * "number" and "integrated" have special meaning.
*/ */
className?: string, class_name?: string,
sortable?: boolean sortable?: boolean
} }
@ -27,20 +27,20 @@ export type ColumnSort<T> = { column: Column<T>, direction: SortDirectionType }
export class BigTable<T> extends React.Component<{ export class BigTable<T> extends React.Component<{
width: number, width: number,
height: number, height: number,
rowCount: number, row_count: number,
overscanRowCount?: number, overscan_row_count?: number,
columns: Array<Column<T>>, columns: Array<Column<T>>,
fixedColumnCount?: number, fixed_column_count?: number,
overscanColumnCount?: number, overscan_column_count?: number,
record: (index: Index) => T, record: (index: Index) => T,
footer?: boolean, footer?: boolean,
/** /**
* When this changes, the DataTable will re-render. * When this changes, the DataTable will re-render.
*/ */
updateTrigger?: any, update_trigger?: any,
sort?: (sortColumns: Array<ColumnSort<T>>) => void sort?: (sort_columns: Array<ColumnSort<T>>) => void
}> { }> {
private sortColumns = new Array<ColumnSort<T>>(); private sort_columns = new Array<ColumnSort<T>>();
render() { render() {
return ( return (
@ -52,30 +52,30 @@ export class BigTable<T> extends React.Component<{
width={this.props.width} width={this.props.width}
height={this.props.height} height={this.props.height}
rowHeight={26} rowHeight={26}
rowCount={this.props.rowCount + 1 + (this.props.footer ? 1 : 0)} rowCount={this.props.row_count + 1 + (this.props.footer ? 1 : 0)}
fixedRowCount={1} fixedRowCount={1}
overscanRowCount={this.props.overscanRowCount} overscanRowCount={this.props.overscan_row_count}
columnWidth={this.columnWidth} columnWidth={this.column_width}
columnCount={this.props.columns.length} columnCount={this.props.columns.length}
fixedColumnCount={this.props.fixedColumnCount} fixedColumnCount={this.props.fixed_column_count}
overscanColumnCount={this.props.overscanColumnCount} overscanColumnCount={this.props.overscan_column_count}
cellRenderer={this.cellRenderer} cellRenderer={this.cell_renderer}
classNameTopLeftGrid="DataTable-header" classNameTopLeftGrid="DataTable-header"
classNameTopRightGrid="DataTable-header" classNameTopRightGrid="DataTable-header"
updateTigger={this.props.updateTrigger} updateTigger={this.props.update_trigger}
/> />
</div> </div>
); );
} }
private columnWidth = ({ index }: Index): number => { private column_width = ({ index }: Index): number => {
return this.props.columns[index].width; return this.props.columns[index].width;
} }
private cellRenderer: GridCellRenderer = ({ columnIndex, rowIndex, style }) => { private cell_renderer: GridCellRenderer = ({ columnIndex, rowIndex, style }) => {
const column = this.props.columns[columnIndex]; const column = this.props.columns[columnIndex];
let cell: ReactNode; let cell: ReactNode;
let sortIndicator: ReactNode; let sort_indicator: ReactNode;
let title: string | undefined; let title: string | undefined;
const classes = ['DataTable-cell']; const classes = ['DataTable-cell'];
@ -90,18 +90,18 @@ export class BigTable<T> extends React.Component<{
if (column.sortable) { if (column.sortable) {
classes.push('sortable'); classes.push('sortable');
const sort = this.sortColumns[0]; const sort = this.sort_columns[0];
if (sort && sort.column === column) { if (sort && sort.column === column) {
if (sort.direction === SortDirection.ASC) { if (sort.direction === SortDirection.ASC) {
sortIndicator = ( sort_indicator = (
<svg className="DataTable-sort-indictator" width="18" height="18" viewBox="0 0 24 24"> <svg className="DataTable-sort-indictator" width="18" height="18" viewBox="0 0 24 24">
<path d="M7 14l5-5 5 5z"></path> <path d="M7 14l5-5 5 5z"></path>
<path d="M0 0h24v24H0z" fill="none"></path> <path d="M0 0h24v24H0z" fill="none"></path>
</svg> </svg>
); );
} else { } else {
sortIndicator = ( sort_indicator = (
<svg className="DataTable-sort-indictator" width="18" height="18" viewBox="0 0 24 24"> <svg className="DataTable-sort-indictator" width="18" height="18" viewBox="0 0 24 24">
<path d="M7 10l5 5 5-5z"></path> <path d="M7 10l5 5 5-5z"></path>
<path d="M0 0h24v24H0z" fill="none"></path> <path d="M0 0h24v24H0z" fill="none"></path>
@ -112,20 +112,20 @@ export class BigTable<T> extends React.Component<{
} }
} else { } else {
// Record or footer row // Record or footer row
if (column.className) { if (column.class_name) {
classes.push(column.className); classes.push(column.class_name);
} }
if (this.props.footer && rowIndex === 1 + this.props.rowCount) { if (this.props.footer && rowIndex === 1 + this.props.row_count) {
// Footer row // Footer row
classes.push('footer-cell'); classes.push('footer-cell');
cell = column.footerValue == null ? '' : column.footerValue; cell = column.footer_value == null ? '' : column.footer_value;
title = column.footerTooltip == null ? '' : column.footerTooltip; title = column.footer_tooltip == null ? '' : column.footer_tooltip;
} else { } else {
// Record row // Record row
const result = this.props.record({ index: rowIndex - 1 }); const result = this.props.record({ index: rowIndex - 1 });
cell = column.cellRenderer(result); cell = column.cell_renderer(result);
if (column.tooltip) { if (column.tooltip) {
title = column.tooltip(result); title = column.tooltip(result);
@ -137,8 +137,8 @@ export class BigTable<T> extends React.Component<{
classes.push('custom'); classes.push('custom');
} }
const onClick = rowIndex === 0 && column.sortable const on_click = rowIndex === 0 && column.sortable
? () => this.headerClicked(column) ? () => this.header_clicked(column)
: undefined; : undefined;
return ( return (
@ -147,29 +147,29 @@ export class BigTable<T> extends React.Component<{
key={`${columnIndex}, ${rowIndex}`} key={`${columnIndex}, ${rowIndex}`}
style={style} style={style}
title={title} title={title}
onClick={onClick} onClick={on_click}
> >
{typeof cell === 'string' ? ( {typeof cell === 'string' ? (
<span className="DataTable-cell-text">{cell}</span> <span className="DataTable-cell-text">{cell}</span>
) : cell} ) : cell}
{sortIndicator} {sort_indicator}
</div> </div>
); );
} }
private headerClicked = (column: Column<T>) => { private header_clicked = (column: Column<T>) => {
const oldIndex = this.sortColumns.findIndex(sc => sc.column === column); const old_index = this.sort_columns.findIndex(sc => sc.column === column);
let old = oldIndex === -1 ? undefined : this.sortColumns.splice(oldIndex, 1)[0]; let old = old_index === -1 ? undefined : this.sort_columns.splice(old_index, 1)[0];
const direction = oldIndex === 0 && old!.direction === SortDirection.ASC const direction = old_index === 0 && old!.direction === SortDirection.ASC
? SortDirection.DESC ? SortDirection.DESC
: SortDirection.ASC : SortDirection.ASC
this.sortColumns.unshift({ column, direction }); this.sort_columns.unshift({ column, direction });
this.sortColumns.splice(10); this.sort_columns.splice(10);
if (this.props.sort) { if (this.props.sort) {
this.props.sort(this.sortColumns); this.props.sort(this.sort_columns);
} }
} }
} }

6
src/ui/SectionIdIcon.tsx
View File

@ -2,11 +2,11 @@ import React from "react";
import { SectionId } from "../domain"; import { SectionId } from "../domain";
export function SectionIdIcon({ export function SectionIdIcon({
sectionId, section_id,
size = 28, size = 28,
title title
}: { }: {
sectionId: SectionId, section_id: SectionId,
size?: number, size?: number,
title?: string title?: string
}) { }) {
@ -17,7 +17,7 @@ export function SectionIdIcon({
display: 'inline-block', display: 'inline-block',
width: size, width: size,
height: size, height: size,
backgroundImage: `url(${process.env.PUBLIC_URL}/images/sectionids/${SectionId[sectionId]}.png)`, backgroundImage: `url(${process.env.PUBLIC_URL}/images/sectionids/${SectionId[section_id]}.png)`,
backgroundSize: size backgroundSize: size
}} }}
/> />

90
src/ui/dps_calc/DpsCalcComponent.tsx
View File

@ -2,8 +2,8 @@ import { InputNumber } from "antd";
import { observer } from "mobx-react"; import { observer } from "mobx-react";
import React from "react"; import React from "react";
import { WeaponItemType, ArmorItemType, ShieldItemType } from "../../domain"; import { WeaponItemType, ArmorItemType, ShieldItemType } from "../../domain";
import { dpsCalcStore } from "../../stores/DpsCalcStore"; import { dps_calc_store } from "../../stores/DpsCalcStore";
import { itemTypeStores } from "../../stores/ItemTypeStore"; import { item_type_stores } from "../../stores/ItemTypeStore";
import { BigSelect } from "../BigSelect"; import { BigSelect } from "../BigSelect";
@observer @observer
@ -16,11 +16,11 @@ export class DpsCalcComponent extends React.Component {
<BigSelect <BigSelect
placeholder="Add a weapon" placeholder="Add a weapon"
value={undefined} value={undefined}
options={dpsCalcStore.weaponTypes.map(wt => ({ options={dps_calc_store.weapon_types.map(wt => ({
label: wt.name, label: wt.name,
value: wt.id value: wt.id
}))} }))}
onChange={this.addWeapon} onChange={this.add_weapon}
/> />
<table> <table>
<thead> <thead>
@ -42,111 +42,111 @@ export class DpsCalcComponent extends React.Component {
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
{dpsCalcStore.weapons.map((weapon, i) => ( {dps_calc_store.weapons.map((weapon, i) => (
<tr key={i}> <tr key={i}>
<td>{weapon.item.type.name}</td> <td>{weapon.item.type.name}</td>
<td>{weapon.item.type.minAtp}</td> <td>{weapon.item.type.min_atp}</td>
<td>{weapon.item.type.maxAtp}</td> <td>{weapon.item.type.max_atp}</td>
<td> <td>
<InputNumber <InputNumber
size="small" size="small"
value={weapon.item.grind} value={weapon.item.grind}
min={0} min={0}
max={weapon.item.type.maxGrind} max={weapon.item.type.max_grind}
step={1} step={1}
onChange={(value) => weapon.item.grind = value || 0} onChange={(value) => weapon.item.grind = value || 0}
/> />
</td> </td>
<td>{weapon.item.grindAtp}</td> <td>{weapon.item.grind_atp}</td>
<td>{weapon.shiftaAtp.toFixed(1)}</td> <td>{weapon.shifta_atp.toFixed(1)}</td>
<td>{weapon.finalMinAtp.toFixed(1)}</td> <td>{weapon.final_min_atp.toFixed(1)}</td>
<td>{weapon.finalMaxAtp.toFixed(1)}</td> <td>{weapon.final_max_atp.toFixed(1)}</td>
<td>{weapon.minNormalDamage.toFixed(1)}</td> <td>{weapon.min_normal_damage.toFixed(1)}</td>
<td>{weapon.maxNormalDamage.toFixed(1)}</td> <td>{weapon.max_normal_damage.toFixed(1)}</td>
<td>{weapon.avgNormalDamage.toFixed(1)}</td> <td>{weapon.avg_normal_damage.toFixed(1)}</td>
<td>{weapon.minHeavyDamage.toFixed(1)}</td> <td>{weapon.min_heavy_damage.toFixed(1)}</td>
<td>{weapon.maxHeavyDamage.toFixed(1)}</td> <td>{weapon.max_heavy_damage.toFixed(1)}</td>
<td>{weapon.avgHeavyDamage.toFixed(1)}</td> <td>{weapon.avg_heavy_damage.toFixed(1)}</td>
</tr> </tr>
))} ))}
</tbody> </tbody>
</table> </table>
<div>Character ATP:</div> <div>Character ATP:</div>
<InputNumber <InputNumber
value={dpsCalcStore.charAtp} value={dps_calc_store.char_atp}
min={0} min={0}
step={1} step={1}
onChange={(value) => dpsCalcStore.charAtp = value || 0} onChange={(value) => dps_calc_store.char_atp = value || 0}
/> />
<div>MAG POW:</div> <div>MAG POW:</div>
<InputNumber <InputNumber
value={dpsCalcStore.magPow} value={dps_calc_store.mag_pow}
min={0} min={0}
max={200} max={200}
step={1} step={1}
onChange={(value) => dpsCalcStore.magPow = value || 0} onChange={(value) => dps_calc_store.mag_pow = value || 0}
/> />
<div>Armor:</div> <div>Armor:</div>
<BigSelect <BigSelect
placeholder="Choose an armor" placeholder="Choose an armor"
value={dpsCalcStore.armorType && dpsCalcStore.armorType.id} value={dps_calc_store.armor_type && dps_calc_store.armor_type.id}
options={dpsCalcStore.armorTypes.map(at => ({ options={dps_calc_store.armor_types.map(at => ({
label: at.name, label: at.name,
value: at.id value: at.id
}))} }))}
onChange={this.armorChanged} onChange={this.armor_changed}
/> />
<span>Armor ATP: {dpsCalcStore.armorAtp}</span> <span>Armor ATP: {dps_calc_store.armor_atp}</span>
<div>Shield:</div> <div>Shield:</div>
<BigSelect <BigSelect
placeholder="Choose a shield" placeholder="Choose a shield"
value={dpsCalcStore.shieldType && dpsCalcStore.shieldType.id} value={dps_calc_store.shield_type && dps_calc_store.shield_type.id}
options={dpsCalcStore.shieldTypes.map(st => ({ options={dps_calc_store.shield_types.map(st => ({
label: st.name, label: st.name,
value: st.id value: st.id
}))} }))}
onChange={this.shieldChanged} onChange={this.shield_changed}
/> />
<span>Shield ATP: {dpsCalcStore.shieldAtp}</span> <span>Shield ATP: {dps_calc_store.shield_atp}</span>
<div>Shifta level:</div> <div>Shifta level:</div>
<InputNumber <InputNumber
value={dpsCalcStore.shiftaLvl} value={dps_calc_store.shifta_lvl}
min={0} min={0}
max={30} max={30}
step={1} step={1}
onChange={(value) => dpsCalcStore.shiftaLvl = value || 0} onChange={(value) => dps_calc_store.shifta_lvl = value || 0}
/> />
<div>Shifta factor:</div> <div>Shifta factor:</div>
<div>{dpsCalcStore.shiftaFactor.toFixed(3)}</div> <div>{dps_calc_store.shifta_factor.toFixed(3)}</div>
<div>Base shifta ATP:</div> <div>Base shifta ATP:</div>
<div>{dpsCalcStore.baseShiftaAtp.toFixed(2)}</div> <div>{dps_calc_store.base_shifta_atp.toFixed(2)}</div>
</section> </section>
</section> </section>
); );
} }
private addWeapon = (selected: any) => { private add_weapon = (selected: any) => {
if (selected) { if (selected) {
let type = itemTypeStores.current.value.getById(selected.value)!; let type = item_type_stores.current.value.get_by_id(selected.value)!;
dpsCalcStore.addWeapon(type as WeaponItemType); dps_calc_store.add_weapon(type as WeaponItemType);
} }
} }
private armorChanged = (selected: any) => { private armor_changed = (selected: any) => {
if (selected) { if (selected) {
let type = itemTypeStores.current.value.getById(selected.value)!; let type = item_type_stores.current.value.get_by_id(selected.value)!;
dpsCalcStore.armorType = (type as ArmorItemType); dps_calc_store.armor_type = (type as ArmorItemType);
} else { } else {
dpsCalcStore.armorType = undefined; dps_calc_store.armor_type = undefined;
} }
} }
private shieldChanged = (selected: any) => { private shield_changed = (selected: any) => {
if (selected) { if (selected) {
let type = itemTypeStores.current.value.getById(selected.value)!; let type = item_type_stores.current.value.get_by_id(selected.value)!;
dpsCalcStore.shieldType = (type as ShieldItemType); dps_calc_store.shield_type = (type as ShieldItemType);
} else { } else {
dpsCalcStore.shieldType = undefined; dps_calc_store.shield_type = undefined;
} }
} }
} }

28
src/ui/hunt_optimizer/MethodsComponent.tsx
View File

@ -5,7 +5,7 @@ import React from "react";
import { AutoSizer, Index, SortDirection } from "react-virtualized"; import { AutoSizer, Index, SortDirection } from "react-virtualized";
import { Episode, HuntMethod } from "../../domain"; import { Episode, HuntMethod } from "../../domain";
import { EnemyNpcTypes, NpcType } from "../../domain/NpcType"; import { EnemyNpcTypes, NpcType } from "../../domain/NpcType";
import { huntMethodStore } from "../../stores/HuntMethodStore"; import { hunt_method_store } from "../../stores/HuntMethodStore";
import { BigTable, Column, ColumnSort } from "../BigTable"; import { BigTable, Column, ColumnSort } from "../BigTable";
import "./MethodsComponent.css"; import "./MethodsComponent.css";
@ -18,22 +18,22 @@ export class MethodsComponent extends React.Component {
key: 'name', key: 'name',
name: 'Method', name: 'Method',
width: 250, width: 250,
cellRenderer: (method) => method.name, cell_renderer: (method) => method.name,
sortable: true, sortable: true,
}, },
{ {
key: 'episode', key: 'episode',
name: 'Ep.', name: 'Ep.',
width: 34, width: 34,
cellRenderer: (method) => Episode[method.episode], cell_renderer: (method) => Episode[method.episode],
sortable: true, sortable: true,
}, },
{ {
key: 'time', key: 'time',
name: 'Time', name: 'Time',
width: 50, width: 50,
cellRenderer: (method) => <TimeComponent method={method} />, cell_renderer: (method) => <TimeComponent method={method} />,
className: 'integrated', class_name: 'integrated',
sortable: true, sortable: true,
}, },
]; ];
@ -44,11 +44,11 @@ export class MethodsComponent extends React.Component {
key: enemy.code, key: enemy.code,
name: enemy.name, name: enemy.name,
width: 75, width: 75,
cellRenderer: (method) => { cell_renderer: (method) => {
const count = method.enemy_counts.get(enemy); const count = method.enemy_counts.get(enemy);
return count == null ? '' : count.toString(); return count == null ? '' : count.toString();
}, },
className: 'number', class_name: 'number',
sortable: true, sortable: true,
}); });
} }
@ -57,7 +57,7 @@ export class MethodsComponent extends React.Component {
})(); })();
render() { render() {
const methods = huntMethodStore.methods.current.value; const methods = hunt_method_store.methods.current.value;
return ( return (
<section className="ho-MethodsComponent"> <section className="ho-MethodsComponent">
@ -66,12 +66,12 @@ export class MethodsComponent extends React.Component {
<BigTable<HuntMethod> <BigTable<HuntMethod>
width={width} width={width}
height={height} height={height}
rowCount={methods.length} row_count={methods.length}
columns={MethodsComponent.columns} columns={MethodsComponent.columns}
fixedColumnCount={3} fixed_column_count={3}
record={this.record} record={this.record}
sort={this.sort} sort={this.sort}
updateTrigger={huntMethodStore.methods.current.value} update_trigger={hunt_method_store.methods.current.value}
/> />
)} )}
</AutoSizer> </AutoSizer>
@ -80,11 +80,11 @@ export class MethodsComponent extends React.Component {
} }
private record = ({ index }: Index) => { private record = ({ index }: Index) => {
return huntMethodStore.methods.current.value[index]; return hunt_method_store.methods.current.value[index];
} }
private sort = (sorts: ColumnSort<HuntMethod>[]) => { private sort = (sorts: ColumnSort<HuntMethod>[]) => {
const methods = huntMethodStore.methods.current.value.slice(); const methods = hunt_method_store.methods.current.value.slice();
methods.sort((a, b) => { methods.sort((a, b) => {
for (const { column, direction } of sorts) { for (const { column, direction } of sorts) {
@ -112,7 +112,7 @@ export class MethodsComponent extends React.Component {
return 0; return 0;
}); });
huntMethodStore.methods.current.value = methods; hunt_method_store.methods.current.value = methods;
} }
} }

92
src/ui/hunt_optimizer/OptimizationResultComponent.tsx
View File

@ -3,105 +3,105 @@ import { observer } from "mobx-react";
import React from "react"; import React from "react";
import { AutoSizer, Index } from "react-virtualized"; import { AutoSizer, Index } from "react-virtualized";
import { Difficulty, Episode, SectionId } from "../../domain"; import { Difficulty, Episode, SectionId } from "../../domain";
import { huntOptimizerStore, OptimalMethod } from "../../stores/HuntOptimizerStore"; import { hunt_optimizer_store, OptimalMethod } from "../../stores/HuntOptimizerStore";
import { BigTable, Column } from "../BigTable"; import { BigTable, Column } from "../BigTable";
import { SectionIdIcon } from "../SectionIdIcon"; import { SectionIdIcon } from "../SectionIdIcon";
import { hoursToString } from "../time"; import { hours_to_string } from "../time";
import "./OptimizationResultComponent.less"; import "./OptimizationResultComponent.less";
@observer @observer
export class OptimizationResultComponent extends React.Component { export class OptimizationResultComponent extends React.Component {
@computed private get columns(): Column<OptimalMethod>[] { @computed private get columns(): Column<OptimalMethod>[] {
// Standard columns. // Standard columns.
const result = huntOptimizerStore.result; const result = hunt_optimizer_store.result;
const optimalMethods = result ? result.optimalMethods : []; const optimal_methods = result ? result.optimal_methods : [];
let totalRuns = 0; let total_runs = 0;
let totalTime = 0; let total_time = 0;
for (const method of optimalMethods) { for (const method of optimal_methods) {
totalRuns += method.runs; total_runs += method.runs;
totalTime += method.totalTime; total_time += method.total_time;
} }
const columns: Column<OptimalMethod>[] = [ const columns: Column<OptimalMethod>[] = [
{ {
name: 'Difficulty', name: 'Difficulty',
width: 75, width: 75,
cellRenderer: (result) => Difficulty[result.difficulty], cell_renderer: (result) => Difficulty[result.difficulty],
footerValue: 'Totals:', footer_value: 'Totals:',
}, },
{ {
name: 'Method', name: 'Method',
width: 200, width: 200,
cellRenderer: (result) => result.methodName, cell_renderer: (result) => result.method_name,
tooltip: (result) => result.methodName, tooltip: (result) => result.method_name,
}, },
{ {
name: 'Ep.', name: 'Ep.',
width: 34, width: 34,
cellRenderer: (result) => Episode[result.methodEpisode], cell_renderer: (result) => Episode[result.method_episode],
}, },
{ {
name: 'Section ID', name: 'Section ID',
width: 80, width: 80,
cellRenderer: (result) => ( cell_renderer: (result) => (
<div className="ho-OptimizationResultComponent-sid-col"> <div className="ho-OptimizationResultComponent-sid-col">
{result.sectionIds.map(sid => {result.section_ids.map(sid =>
<SectionIdIcon sectionId={sid} key={sid} size={20} /> <SectionIdIcon section_id={sid} key={sid} size={20} />
)} )}
</div> </div>
), ),
tooltip: (result) => result.sectionIds.map(sid => SectionId[sid]).join(', '), tooltip: (result) => result.section_ids.map(sid => SectionId[sid]).join(', '),
}, },
{ {
name: 'Time/Run', name: 'Time/Run',
width: 80, width: 80,
cellRenderer: (result) => hoursToString(result.methodTime), cell_renderer: (result) => hours_to_string(result.method_time),
className: 'number', class_name: 'number',
}, },
{ {
name: 'Runs', name: 'Runs',
width: 60, width: 60,
cellRenderer: (result) => result.runs.toFixed(1), cell_renderer: (result) => result.runs.toFixed(1),
tooltip: (result) => result.runs.toString(), tooltip: (result) => result.runs.toString(),
footerValue: totalRuns.toFixed(1), footer_value: total_runs.toFixed(1),
footerTooltip: totalRuns.toString(), footer_tooltip: total_runs.toString(),
className: 'number', class_name: 'number',
}, },
{ {
name: 'Total Hours', name: 'Total Hours',
width: 90, width: 90,
cellRenderer: (result) => result.totalTime.toFixed(1), cell_renderer: (result) => result.total_time.toFixed(1),
tooltip: (result) => result.totalTime.toString(), tooltip: (result) => result.total_time.toString(),
footerValue: totalTime.toFixed(1), footer_value: total_time.toFixed(1),
footerTooltip: totalTime.toString(), footer_tooltip: total_time.toString(),
className: 'number', class_name: 'number',
}, },
]; ];
// Add one column per item. // Add one column per item.
if (result) { if (result) {
for (const item of result.wantedItems) { for (const item of result.wanted_items) {
let totalCount = 0; let totalCount = 0;
for (const method of optimalMethods) { for (const method of optimal_methods) {
totalCount += method.itemCounts.get(item) || 0; totalCount += method.item_counts.get(item) || 0;
} }
columns.push({ columns.push({
name: item.name, name: item.name,
width: 80, width: 80,
cellRenderer: (result) => { cell_renderer: (result) => {
const count = result.itemCounts.get(item); const count = result.item_counts.get(item);
return count ? count.toFixed(2) : ''; return count ? count.toFixed(2) : '';
}, },
tooltip: (result) => { tooltip: (result) => {
const count = result.itemCounts.get(item); const count = result.item_counts.get(item);
return count ? count.toString() : ''; return count ? count.toString() : '';
}, },
className: 'number', class_name: 'number',
footerValue: totalCount.toFixed(2), footer_value: totalCount.toFixed(2),
footerTooltip: totalCount.toString() footer_tooltip: totalCount.toString()
}); });
} }
} }
@ -110,13 +110,13 @@ export class OptimizationResultComponent extends React.Component {
} }
// Make sure render is called when result changes. // Make sure render is called when result changes.
@computed private get updateTrigger() { @computed private get update_trigger() {
return huntOptimizerStore.result; return hunt_optimizer_store.result;
} }
render() { render() {
this.updateTrigger; // eslint-disable-line this.update_trigger; // eslint-disable-line
const result = huntOptimizerStore.result; const result = hunt_optimizer_store.result;
return ( return (
<section className="ho-OptimizationResultComponent"> <section className="ho-OptimizationResultComponent">
@ -127,12 +127,12 @@ export class OptimizationResultComponent extends React.Component {
<BigTable <BigTable
width={width} width={width}
height={height} height={height}
rowCount={result ? result.optimalMethods.length : 0} row_count={result ? result.optimal_methods.length : 0}
columns={this.columns} columns={this.columns}
fixedColumnCount={4} fixed_column_count={4}
record={this.record} record={this.record}
footer={result != null} footer={result != null}
updateTrigger={this.updateTrigger} update_trigger={this.update_trigger}
/> />
} }
</AutoSizer> </AutoSizer>
@ -142,6 +142,6 @@ export class OptimizationResultComponent extends React.Component {
} }
private record = ({ index }: Index): OptimalMethod => { private record = ({ index }: Index): OptimalMethod => {
return huntOptimizerStore.result!.optimalMethods[index]; return hunt_optimizer_store.result!.optimal_methods[index];
} }
} }

54
src/ui/hunt_optimizer/WantedItemsComponent.tsx
View File

@ -2,20 +2,20 @@ import { Button, InputNumber, Popover } from "antd";
import { observer } from "mobx-react"; import { observer } from "mobx-react";
import React from "react"; import React from "react";
import { AutoSizer, Column, Table, TableCellRenderer } from "react-virtualized"; import { AutoSizer, Column, Table, TableCellRenderer } from "react-virtualized";
import { huntOptimizerStore, WantedItem } from "../../stores/HuntOptimizerStore"; import { hunt_optimizer_store, WantedItem } from "../../stores/HuntOptimizerStore";
import { itemTypeStores } from "../../stores/ItemTypeStore"; import { item_type_stores } from "../../stores/ItemTypeStore";
import { BigSelect } from "../BigSelect"; import { BigSelect } from "../BigSelect";
import './WantedItemsComponent.less'; import './WantedItemsComponent.less';
@observer @observer
export class WantedItemsComponent extends React.Component { export class WantedItemsComponent extends React.Component {
state = { state = {
helpVisible: false help_visible: false
} }
render() { render() {
// Make sure render is called on updates. // Make sure render is called on updates.
huntOptimizerStore.wantedItems.slice(0, 0); hunt_optimizer_store.wanted_items.slice(0, 0);
return ( return (
<section className="ho-WantedItemsComponent"> <section className="ho-WantedItemsComponent">
@ -24,8 +24,8 @@ export class WantedItemsComponent extends React.Component {
<Popover <Popover
content={<Help />} content={<Help />}
trigger="click" trigger="click"
visible={this.state.helpVisible} visible={this.state.help_visible}
onVisibleChange={this.onHelpVisibleChange} onVisibleChange={this.on_help_visible_change}
> >
<Button icon="info-circle" type="link" /> <Button icon="info-circle" type="link" />
</Popover> </Popover>
@ -35,14 +35,14 @@ export class WantedItemsComponent extends React.Component {
placeholder="Add an item" placeholder="Add an item"
value={undefined} value={undefined}
style={{ width: 200 }} style={{ width: 200 }}
options={huntOptimizerStore.huntableItemTypes.map(itemType => ({ options={hunt_optimizer_store.huntable_item_types.map(itemType => ({
label: itemType.name, label: itemType.name,
value: itemType.id value: itemType.id
}))} }))}
onChange={this.addWanted} onChange={this.add_wanted}
/> />
<Button <Button
onClick={huntOptimizerStore.optimize} onClick={hunt_optimizer_store.optimize}
style={{ marginLeft: 10 }} style={{ marginLeft: 10 }}
> >
Optimize Optimize
@ -56,9 +56,9 @@ export class WantedItemsComponent extends React.Component {
height={height} height={height}
headerHeight={30} headerHeight={30}
rowHeight={30} rowHeight={30}
rowCount={huntOptimizerStore.wantedItems.length} rowCount={hunt_optimizer_store.wanted_items.length}
rowGetter={({ index }) => huntOptimizerStore.wantedItems[index]} rowGetter={({ index }) => hunt_optimizer_store.wanted_items[index]}
noRowsRenderer={this.noRowsRenderer} noRowsRenderer={this.no_rows_renderer}
> >
<Column <Column
label="Amount" label="Amount"
@ -74,13 +74,13 @@ export class WantedItemsComponent extends React.Component {
width={150} width={150}
flexGrow={1} flexGrow={1}
cellDataGetter={({ rowData }) => cellDataGetter={({ rowData }) =>
(rowData as WantedItem).itemType.name (rowData as WantedItem).item_type.name
} }
/> />
<Column <Column
dataKey="remove" dataKey="remove"
width={30} width={30}
cellRenderer={this.tableRemoveCellRenderer} cellRenderer={this.table_remove_cell_renderer}
/> />
</Table> </Table>
)} )}
@ -90,30 +90,30 @@ export class WantedItemsComponent extends React.Component {
); );
} }
private addWanted = (selected: any) => { private add_wanted = (selected: any) => {
if (selected) { if (selected) {
let added = huntOptimizerStore.wantedItems.find(w => w.itemType.id === selected.value); let added = hunt_optimizer_store.wanted_items.find(w => w.item_type.id === selected.value);
if (!added) { if (!added) {
const itemType = itemTypeStores.current.value.getById(selected.value)!; const item_type = item_type_stores.current.value.get_by_id(selected.value)!;
huntOptimizerStore.wantedItems.push(new WantedItem(itemType, 1)); hunt_optimizer_store.wanted_items.push(new WantedItem(item_type, 1));
} }
} }
} }
private removeWanted = (wanted: WantedItem) => () => { private remove_wanted = (wanted: WantedItem) => () => {
const i = huntOptimizerStore.wantedItems.findIndex(w => w === wanted); const i = hunt_optimizer_store.wanted_items.findIndex(w => w === wanted);
if (i !== -1) { if (i !== -1) {
huntOptimizerStore.wantedItems.splice(i, 1); hunt_optimizer_store.wanted_items.splice(i, 1);
} }
} }
private tableRemoveCellRenderer: TableCellRenderer = ({ rowData }) => { private table_remove_cell_renderer: TableCellRenderer = ({ rowData }) => {
return <Button type="link" icon="delete" onClick={this.removeWanted(rowData)} />; return <Button type="link" icon="delete" onClick={this.remove_wanted(rowData)} />;
} }
private noRowsRenderer = () => { private no_rows_renderer = () => {
return ( return (
<div className="ho-WantedItemsComponent-no-rows"> <div className="ho-WantedItemsComponent-no-rows">
<p> <p>
@ -123,7 +123,7 @@ export class WantedItemsComponent extends React.Component {
); );
} }
private onHelpVisibleChange = (visible: boolean) => { private on_help_visible_change = (visible: boolean) => {
this.setState({ helpVisible: visible }); this.setState({ helpVisible: visible });
} }
} }
@ -157,14 +157,14 @@ class WantedAmountCell extends React.Component<{ wantedItem: WantedItem }> {
min={0} min={0}
max={10} max={10}
value={wanted.amount} value={wanted.amount}
onChange={this.wantedAmountChanged} onChange={this.wanted_amount_changed}
size="small" size="small"
style={{ width: '100%' }} style={{ width: '100%' }}
/> />
); );
} }
private wantedAmountChanged = (value?: number) => { private wanted_amount_changed = (value?: number) => {
if (value != null && value >= 0) { if (value != null && value >= 0) {
this.props.wantedItem.amount = value; this.props.wantedItem.amount = value;
} }

4
src/ui/model_viewer/RendererComponent.tsx
View File

@ -37,7 +37,7 @@ export class RendererComponent extends React.Component<Props> {
} }
private onResize = () => { private onResize = () => {
const wrapperDiv = this.renderer.dom_element.parentNode as HTMLDivElement; const wrapper_div = this.renderer.dom_element.parentNode as HTMLDivElement;
this.renderer.set_size(wrapperDiv.clientWidth, wrapperDiv.clientHeight); this.renderer.set_size(wrapper_div.clientWidth, wrapper_div.clientHeight);
} }
} }

4
src/ui/quest_editor/EntityInfoComponent.tsx
View File

@ -4,8 +4,8 @@ import React from 'react';
import { QuestNpc, QuestObject, QuestEntity } from '../../domain'; import { QuestNpc, QuestObject, QuestEntity } from '../../domain';
import './EntityInfoComponent.css'; import './EntityInfoComponent.css';
interface Props { export type Props = {
entity?: QuestEntity; entity?: QuestEntity,
} }
@observer @observer

20
src/ui/quest_editor/QuestInfoComponent.tsx
View File

@ -5,23 +5,23 @@ import './QuestInfoComponent.css';
export function QuestInfoComponent({ quest }: { quest?: Quest }) { export function QuestInfoComponent({ quest }: { quest?: Quest }) {
if (quest) { if (quest) {
const episode = quest.episode === 4 ? 'IV' : (quest.episode === 2 ? 'II' : 'I'); const episode = quest.episode === 4 ? 'IV' : (quest.episode === 2 ? 'II' : 'I');
const npcCounts = new Map<NpcType, number>(); const npc_counts = new Map<NpcType, number>();
for (const npc of quest.npcs) { for (const npc of quest.npcs) {
const val = npcCounts.get(npc.type) || 0; const val = npc_counts.get(npc.type) || 0;
npcCounts.set(npc.type, val + 1); npc_counts.set(npc.type, val + 1);
} }
const extraCanadines = (npcCounts.get(NpcType.Canane) || 0) * 8; const extra_canadines = (npc_counts.get(NpcType.Canane) || 0) * 8;
// Sort by type ID. // Sort by type ID.
const sortedNpcCounts = [...npcCounts].sort((a, b) => a[0].id - b[0].id); const sorted_npc_counts = [...npc_counts].sort((a, b) => a[0].id - b[0].id);
const npcCountRows = sortedNpcCounts.map(([npcType, count]) => { const npc_count_rows = sorted_npc_counts.map(([npc_type, count]) => {
const extra = npcType === NpcType.Canadine ? extraCanadines : 0; const extra = npc_type === NpcType.Canadine ? extra_canadines : 0;
return ( return (
<tr key={npcType.id}> <tr key={npc_type.id}>
<td>{npcType.name}:</td> <td>{npc_type.name}:</td>
<td>{count + extra}</td> <td>{count + extra}</td>
</tr> </tr>
); );
@ -55,7 +55,7 @@ export function QuestInfoComponent({ quest }: { quest?: Quest }) {
<tr><th colSpan={2}>NPC Counts</th></tr> <tr><th colSpan={2}>NPC Counts</th></tr>
</thead> </thead>
<tbody> <tbody>
{npcCountRows} {npc_count_rows}
</tbody> </tbody>
</table> </table>
</div> </div>

4
src/ui/quest_editor/RendererComponent.tsx
View File

@ -38,7 +38,7 @@ export class RendererComponent extends React.Component<Props> {
} }
private onResize = () => { private onResize = () => {
const wrapperDiv = this.renderer.dom_element.parentNode as HTMLDivElement; const wrapper_div = this.renderer.dom_element.parentNode as HTMLDivElement;
this.renderer.set_size(wrapperDiv.clientWidth, wrapperDiv.clientHeight); this.renderer.set_size(wrapper_div.clientWidth, wrapper_div.clientHeight);
} }
} }

2
src/ui/time.ts
View File

@ -2,7 +2,7 @@
* @param hours can be fractional. * @param hours can be fractional.
* @returns a string of the shape ##:##. * @returns a string of the shape ##:##.
*/ */
export function hoursToString(hours: number): string { export function hours_to_string(hours: number): string {
const h = Math.floor(hours); const h = Math.floor(hours);
const m = Math.round(60 * (hours - h)); const m = Math.round(60 * (hours - h));
return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}`; return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}`;

10
test/src/utils.ts
View File

@ -5,16 +5,16 @@ import * as fs from 'fs';
* F is called with the path to the file, the file name and the content of the file. * F is called with the path to the file, the file name and the content of the file.
* Uses the QST files provided with Tethealla version 0.143 by default. * Uses the QST files provided with Tethealla version 0.143 by default.
*/ */
export function walkQstFiles( export function walk_qst_files(
f: (path: string, fileName: string, contents: Buffer) => void, f: (path: string, file_name: string, contents: Buffer) => void,
dir: string = 'test/resources/tethealla_v0.143_quests' dir: string = 'test/resources/tethealla_v0.143_quests'
) { ) {
for (const [path, file] of getQstFiles(dir)) { for (const [path, file] of get_qst_files(dir)) {
f(path, file, fs.readFileSync(path)); f(path, file, fs.readFileSync(path));
} }
} }
export function getQstFiles(dir: string): [string, string][] { export function get_qst_files(dir: string): [string, string][] {
let files: [string, string][] = []; let files: [string, string][] = [];
for (const file of fs.readdirSync(dir)) { for (const file of fs.readdirSync(dir)) {
@ -22,7 +22,7 @@ export function getQstFiles(dir: string): [string, string][] {
const stats = fs.statSync(path); const stats = fs.statSync(path);
if (stats.isDirectory()) { if (stats.isDirectory()) {
files = files.concat(getQstFiles(path)); files = files.concat(get_qst_files(path));
} else if (path.endsWith('.qst')) { } else if (path.endsWith('.qst')) {
// BUG: Battle quests are not always parsed in the same way. // BUG: Battle quests are not always parsed in the same way.
// Could be a bug in Jest or Node as the quest parsing code has no randomness or dependency on mutable state. // Could be a bug in Jest or Node as the quest parsing code has no randomness or dependency on mutable state.