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

Reformatted most of the code to comply to TypeScript conventions.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-05-29 01:37:00 +02:00
parent 119b2cb71a
commit ad5372fa98
35 changed files with 1623 additions and 1575 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
public/index.html
View File

@ -6,7 +6,7 @@
</head> </head>
<body> <body>
<div id="phantq-root"></div> <div id="phantasmal-world-root"></div>
</body> </body>
</html> </html>

66
src/actions.ts
View File

@ -1,15 +1,15 @@
import { ArrayBufferCursor } from './data/ArrayBufferCursor'; import { ArrayBufferCursor } from './data/ArrayBufferCursor';
import { application_state } from './store'; import { applicationState } from './store';
import { parse_quest, write_quest_qst } from './data/parsing/quest'; import { parseQuest, writeQuestQst } from './data/parsing/quest';
import { parse_nj, parse_xj } from './data/parsing/ninja'; import { parseNj, parseXj} from './data/parsing/ninja';
import { get_area_sections } from './data/loading/areas'; import { getAreaSections } from './data/loading/areas';
import { get_npc_geometry, get_object_geometry } from './data/loading/entities'; import { getNpcGeometry, getObjectGeometry } from './data/loading/entities';
import { create_object_mesh, create_npc_mesh } from './rendering/entities'; import { createObjectMesh, createNpcMesh } from './rendering/entities';
import { create_model_mesh } from './rendering/models'; import { createModelMesh } from './rendering/models';
import { VisibleQuestEntity } from './domain'; import { VisibleQuestEntity } from './domain';
export function entity_selected(entity?: VisibleQuestEntity) { export function entity_selected(entity?: VisibleQuestEntity) {
application_state.selected_entity = entity; applicationState.selectedEntity = entity;
} }
export function load_file(file: File) { export function load_file(file: File) {
@ -25,45 +25,45 @@ export function load_file(file: File) {
// Reset application state, then set the current model. // Reset application state, then set the current model.
// Might want to do this in a MobX transaction. // Might want to do this in a MobX transaction.
reset_model_and_quest_state(); reset_model_and_quest_state();
application_state.current_model = create_model_mesh(parse_nj(new ArrayBufferCursor(reader.result, true))); applicationState.currentModel = createModelMesh(parseNj(new ArrayBufferCursor(reader.result, true)));
} else if (file.name.endsWith('.xj')) { } else if (file.name.endsWith('.xj')) {
// Reset application state, then set the current model. // Reset application state, then set the current model.
// Might want to do this in a MobX transaction. // Might want to do this in a MobX transaction.
reset_model_and_quest_state(); reset_model_and_quest_state();
application_state.current_model = create_model_mesh(parse_xj(new ArrayBufferCursor(reader.result, true))); applicationState.currentModel = createModelMesh(parseXj(new ArrayBufferCursor(reader.result, true)));
} else { } else {
const quest = parse_quest(new ArrayBufferCursor(reader.result, true)); const quest = parseQuest(new ArrayBufferCursor(reader.result, true));
if (quest) { if (quest) {
// Reset application state, then set current quest and area in the correct order. // Reset application state, then set current quest and area in the correct order.
// Might want to do this in a MobX transaction. // Might want to do this in a MobX transaction.
reset_model_and_quest_state(); reset_model_and_quest_state();
application_state.current_quest = quest; applicationState.currentQuest = quest;
if (quest.area_variants.length) { if (quest.areaVariants.length) {
application_state.current_area = quest.area_variants[0].area; applicationState.currentArea = quest.areaVariants[0].area;
} }
// Load section data. // Load section data.
for (const variant of quest.area_variants) { for (const variant of quest.areaVariants) {
const sections = await get_area_sections(quest.episode, variant.area.id, variant.id) const sections = await getAreaSections(quest.episode, variant.area.id, variant.id)
variant.sections = sections; variant.sections = sections;
// Generate object geometry. // Generate object geometry.
for (const object of quest.objects.filter(o => o.area_id === variant.area.id)) { for (const object of quest.objects.filter(o => o.areaId === variant.area.id)) {
try { try {
const geometry = await get_object_geometry(object.type); const geometry = await getObjectGeometry(object.type);
object.object3d = create_object_mesh(object, sections, geometry); object.object3d = createObjectMesh(object, sections, geometry);
} catch (e) { } catch (e) {
console.error(e); console.error(e);
} }
} }
// Generate NPC geometry. // Generate NPC geometry.
for (const npc of quest.npcs.filter(npc => npc.area_id === variant.area.id)) { for (const npc of quest.npcs.filter(npc => npc.areaId === variant.area.id)) {
try { try {
const geometry = await get_npc_geometry(npc.type); const geometry = await getNpcGeometry(npc.type);
npc.object3d = create_npc_mesh(npc, sections, geometry); npc.object3d = createNpcMesh(npc, sections, geometry);
} catch (e) { } catch (e) {
console.error(e); console.error(e);
} }
@ -77,20 +77,20 @@ export function load_file(file: File) {
} }
export function current_area_id_changed(area_id?: number) { export function current_area_id_changed(area_id?: number) {
application_state.selected_entity = undefined; applicationState.selectedEntity = undefined;
if (area_id == null) { if (area_id == null) {
application_state.current_area = undefined; applicationState.currentArea = undefined;
} else if (application_state.current_quest) { } else if (applicationState.currentQuest) {
const area_variant = application_state.current_quest.area_variants.find( const area_variant = applicationState.currentQuest.areaVariants.find(
variant => variant.area.id === area_id); variant => variant.area.id === area_id);
application_state.current_area = area_variant && area_variant.area; applicationState.currentArea = area_variant && area_variant.area;
} }
} }
export function save_current_quest_to_file(file_name: string) { export function save_current_quest_to_file(file_name: string) {
if (application_state.current_quest) { if (applicationState.currentQuest) {
const cursor = write_quest_qst(application_state.current_quest, file_name); const cursor = writeQuestQst(applicationState.currentQuest, file_name);
if (!file_name.endsWith('.qst')) { if (!file_name.endsWith('.qst')) {
file_name += '.qst'; file_name += '.qst';
@ -107,8 +107,8 @@ export function save_current_quest_to_file(file_name: string) {
} }
function reset_model_and_quest_state() { function reset_model_and_quest_state() {
application_state.current_quest = undefined; applicationState.currentQuest = undefined;
application_state.current_area = undefined; applicationState.currentArea = undefined;
application_state.selected_entity = undefined; applicationState.selectedEntity = undefined;
application_state.current_model = undefined; applicationState.currentModel = undefined;
} }

218
src/data/ArrayBufferCursor.test.ts
View File

@ -3,24 +3,24 @@ import { ArrayBufferCursor } from './ArrayBufferCursor';
test('simple properties and invariants', () => { test('simple properties and invariants', () => {
const cursor = new ArrayBufferCursor(10, true); const cursor = new ArrayBufferCursor(10, true);
expect(cursor.size).toBe(cursor.position + cursor.bytes_left); expect(cursor.size).toBe(cursor.position + cursor.bytesLeft);
expect(cursor.size).toBeLessThanOrEqual(cursor.capacity); expect(cursor.size).toBeLessThanOrEqual(cursor.capacity);
expect(cursor.size).toBe(0); expect(cursor.size).toBe(0);
expect(cursor.capacity).toBe(10); expect(cursor.capacity).toBe(10);
expect(cursor.position).toBe(0); expect(cursor.position).toBe(0);
expect(cursor.bytes_left).toBe(0); expect(cursor.bytesLeft).toBe(0);
expect(cursor.little_endian).toBe(true); expect(cursor.littleEndian).toBe(true);
cursor.write_u8(99).write_u8(99).write_u8(99).write_u8(99); cursor.writeU8(99).writeU8(99).writeU8(99).writeU8(99);
cursor.seek(-1); cursor.seek(-1);
expect(cursor.size).toBe(cursor.position + cursor.bytes_left); expect(cursor.size).toBe(cursor.position + cursor.bytesLeft);
expect(cursor.size).toBeLessThanOrEqual(cursor.capacity); expect(cursor.size).toBeLessThanOrEqual(cursor.capacity);
expect(cursor.size).toBe(4); expect(cursor.size).toBe(4);
expect(cursor.capacity).toBe(10); expect(cursor.capacity).toBe(10);
expect(cursor.position).toBe(3); expect(cursor.position).toBe(3);
expect(cursor.bytes_left).toBe(1); expect(cursor.bytesLeft).toBe(1);
expect(cursor.little_endian).toBe(true); expect(cursor.littleEndian).toBe(true);
}); });
test('correct byte order handling', () => { test('correct byte order handling', () => {
@ -32,200 +32,200 @@ test('correct byte order handling', () => {
test('reallocation of internal buffer when necessary', () => { test('reallocation of internal buffer when necessary', () => {
const cursor = new ArrayBufferCursor(3, true); const cursor = new ArrayBufferCursor(3, true);
cursor.write_u8(99).write_u8(99).write_u8(99).write_u8(99); cursor.writeU8(99).writeU8(99).writeU8(99).writeU8(99);
expect(cursor.size).toBe(4); expect(cursor.size).toBe(4);
expect(cursor.capacity).toBeGreaterThanOrEqual(4); expect(cursor.capacity).toBeGreaterThanOrEqual(4);
expect(cursor.buffer.byteLength).toBeGreaterThanOrEqual(4); expect(cursor.buffer.byteLength).toBeGreaterThanOrEqual(4);
}); });
function test_integer_read(method_name: string) { function testIntegerRead(methodName: string) {
test(method_name, () => { test(methodName, () => {
const bytes = parseInt(method_name.replace(/^[iu](\d+)$/, '$1'), 10) / 8; const bytes = parseInt(methodName.replace(/^[iu](\d+)$/, '$1'), 10) / 8;
let test_number_1 = 0; let testNumber1 = 0;
let test_number_2 = 0; let testNumber2 = 0;
// The "false" arrays are for big endian tests and the "true" arrays for little endian tests. // The "false" arrays are for big endian tests and the "true" arrays for little endian tests.
const test_arrays: { [index: string]: number[] } = { false: [], true: [] }; const testArrays: { [index: string]: number[] } = { false: [], true: [] };
for (let i = 1; i <= bytes; ++i) { for (let i = 1; i <= bytes; ++i) {
// Generates numbers of the form 0x010203... // Generates numbers of the form 0x010203...
test_number_1 <<= 8; testNumber1 <<= 8;
test_number_1 |= i; testNumber1 |= i;
test_arrays['false'].push(i); testArrays['false'].push(i);
test_arrays['true'].unshift(i); testArrays['true'].unshift(i);
} }
for (let i = bytes + 1; i <= 2 * bytes; ++i) { for (let i = bytes + 1; i <= 2 * bytes; ++i) {
test_number_2 <<= 8; testNumber2 <<= 8;
test_number_2 |= i; testNumber2 |= i;
test_arrays['false'].push(i); testArrays['false'].push(i);
test_arrays['true'].splice(bytes, 0, i); testArrays['true'].splice(bytes, 0, i);
} }
for (const little_endian of [false, true]) { for (const littleEndian of [false, true]) {
const cursor = new ArrayBufferCursor( const cursor = new ArrayBufferCursor(
new Uint8Array(test_arrays[String(little_endian)]).buffer, little_endian); new Uint8Array(testArrays[String(littleEndian)]).buffer, littleEndian);
expect((cursor as any)[method_name]()).toBe(test_number_1); expect((cursor as any)[methodName]()).toBe(testNumber1);
expect(cursor.position).toBe(bytes); expect(cursor.position).toBe(bytes);
expect((cursor as any)[method_name]()).toBe(test_number_2); expect((cursor as any)[methodName]()).toBe(testNumber2);
expect(cursor.position).toBe(2 * bytes); expect(cursor.position).toBe(2 * bytes);
} }
}); });
} }
test_integer_read('u8'); testIntegerRead('u8');
test_integer_read('u16'); testIntegerRead('u16');
test_integer_read('u32'); testIntegerRead('u32');
test_integer_read('i32'); testIntegerRead('i32');
test('u8_array', () => { test('u8Array', () => {
const cursor = new ArrayBufferCursor(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]).buffer, true); const cursor = new ArrayBufferCursor(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]).buffer, true);
expect(cursor.u8_array(3)).toEqual([1, 2, 3]); expect(cursor.u8Array(3)).toEqual([1, 2, 3]);
expect(cursor.seek_start(2).u8_array(4)).toEqual([3, 4, 5, 6]); expect(cursor.seekStart(2).u8Array(4)).toEqual([3, 4, 5, 6]);
expect(cursor.seek_start(5).u8_array(3)).toEqual([6, 7, 8]); expect(cursor.seekStart(5).u8Array(3)).toEqual([6, 7, 8]);
}); });
function test_string_read(method_name: string, char_size: number) { function testStringRead(methodName: string, charSize: number) {
test(method_name, () => { test(methodName, () => {
const char_array = [7, 65, 66, 0, 255, 13]; const charArray = [7, 65, 66, 0, 255, 13];
for (const little_endian of [false, true]) { for (const littleEndian of [false, true]) {
const char_array_copy = []; const charArrayCopy = [];
for (const char of char_array) { for (const char of charArray) {
if (little_endian) char_array_copy.push(char); if (littleEndian) charArrayCopy.push(char);
for (let i = 0; i < char_size - 1; ++i) { for (let i = 0; i < charSize - 1; ++i) {
char_array_copy.push(0); charArrayCopy.push(0);
} }
if (!little_endian) char_array_copy.push(char); if (!littleEndian) charArrayCopy.push(char);
} }
const cursor = new ArrayBufferCursor( const cursor = new ArrayBufferCursor(
new Uint8Array(char_array_copy).buffer, little_endian); new Uint8Array(charArrayCopy).buffer, littleEndian);
cursor.seek_start(char_size); cursor.seekStart(charSize);
expect((cursor as any)[method_name](4 * char_size, true, true)).toBe('AB'); expect((cursor as any)[methodName](4 * charSize, true, true)).toBe('AB');
expect(cursor.position).toBe(5 * char_size); expect(cursor.position).toBe(5 * charSize);
cursor.seek_start(char_size); cursor.seekStart(charSize);
expect((cursor as any)[method_name](2 * char_size, true, true)).toBe('AB'); expect((cursor as any)[methodName](2 * charSize, true, true)).toBe('AB');
expect(cursor.position).toBe(3 * char_size); expect(cursor.position).toBe(3 * charSize);
cursor.seek_start(char_size); cursor.seekStart(charSize);
expect((cursor as any)[method_name](4 * char_size, true, false)).toBe('AB'); expect((cursor as any)[methodName](4 * charSize, true, false)).toBe('AB');
expect(cursor.position).toBe(4 * char_size); expect(cursor.position).toBe(4 * charSize);
cursor.seek_start(char_size); cursor.seekStart(charSize);
expect((cursor as any)[method_name](2 * char_size, true, false)).toBe('AB'); expect((cursor as any)[methodName](2 * charSize, true, false)).toBe('AB');
expect(cursor.position).toBe(3 * char_size); expect(cursor.position).toBe(3 * charSize);
cursor.seek_start(char_size); cursor.seekStart(charSize);
expect((cursor as any)[method_name](4 * char_size, false, true)).toBe('AB\0ÿ'); expect((cursor as any)[methodName](4 * charSize, false, true)).toBe('AB\0ÿ');
expect(cursor.position).toBe(5 * char_size); expect(cursor.position).toBe(5 * charSize);
cursor.seek_start(char_size); cursor.seekStart(charSize);
expect((cursor as any)[method_name](4 * char_size, false, false)).toBe('AB\0ÿ'); expect((cursor as any)[methodName](4 * charSize, false, false)).toBe('AB\0ÿ');
expect(cursor.position).toBe(5 * char_size); expect(cursor.position).toBe(5 * charSize);
} }
}); });
} }
test_string_read('string_ascii', 1); testStringRead('stringAscii', 1);
test_string_read('string_utf_16', 2); testStringRead('stringUtf16', 2);
function test_integer_write(method_name: string) { function testIntegerWrite(methodName: string) {
test(method_name, () => { test(methodName, () => {
const bytes = parseInt(method_name.replace(/^write_[iu](\d+)$/, '$1'), 10) / 8; const bytes = parseInt(methodName.replace(/^write[IU](\d+)$/, '$1'), 10) / 8;
let test_number_1 = 0; let testNumber1 = 0;
let test_number_2 = 0; let testNumber2 = 0;
// The "false" arrays are for big endian tests and the "true" arrays for little endian tests. // The "false" arrays are for big endian tests and the "true" arrays for little endian tests.
const test_arrays_1: { [index: string]: number[] } = { false: [], true: [] }; const testArrays1: { [index: string]: number[] } = { false: [], true: [] };
const test_arrays_2: { [index: string]: number[] } = { false: [], true: [] }; const testArrays2: { [index: string]: number[] } = { false: [], true: [] };
for (let i = 1; i <= bytes; ++i) { for (let i = 1; i <= bytes; ++i) {
// Generates numbers of the form 0x010203... // Generates numbers of the form 0x010203...
test_number_1 <<= 8; testNumber1 <<= 8;
test_number_1 |= i; testNumber1 |= i;
test_number_2 <<= 8; testNumber2 <<= 8;
test_number_2 |= i + bytes; testNumber2 |= i + bytes;
test_arrays_1['false'].push(i); testArrays1['false'].push(i);
test_arrays_1['true'].unshift(i); testArrays1['true'].unshift(i);
test_arrays_2['false'].push(i + bytes); testArrays2['false'].push(i + bytes);
test_arrays_2['true'].unshift(i + bytes); testArrays2['true'].unshift(i + bytes);
} }
for (const little_endian of [false, true]) { for (const littleEndian of [false, true]) {
const cursor = new ArrayBufferCursor(0, little_endian); const cursor = new ArrayBufferCursor(0, littleEndian);
(cursor as any)[method_name](test_number_1); (cursor as any)[methodName](testNumber1);
expect(cursor.position).toBe(bytes); expect(cursor.position).toBe(bytes);
expect(cursor.seek_start(0).u8_array(bytes)) expect(cursor.seekStart(0).u8Array(bytes))
.toEqual(test_arrays_1[String(little_endian)]); .toEqual(testArrays1[String(littleEndian)]);
expect(cursor.position).toBe(bytes); expect(cursor.position).toBe(bytes);
(cursor as any)[method_name](test_number_2); (cursor as any)[methodName](testNumber2);
expect(cursor.position).toBe(2 * bytes); expect(cursor.position).toBe(2 * bytes);
expect(cursor.seek_start(0).u8_array(2 * bytes)) expect(cursor.seekStart(0).u8Array(2 * bytes))
.toEqual(test_arrays_1[String(little_endian)].concat(test_arrays_2[String(little_endian)])); .toEqual(testArrays1[String(littleEndian)].concat(testArrays2[String(littleEndian)]));
} }
}); });
} }
test_integer_write('write_u8'); testIntegerWrite('writeU8');
test_integer_write('write_u16'); testIntegerWrite('writeU16');
test_integer_write('write_u32'); testIntegerWrite('writeU32');
test('write_f32', () => { test('writeF32', () => {
for (const little_endian of [false, true]) { for (const littleEndian of [false, true]) {
const cursor = new ArrayBufferCursor(0, little_endian); const cursor = new ArrayBufferCursor(0, littleEndian);
cursor.write_f32(1337.9001); cursor.writeF32(1337.9001);
expect(cursor.position).toBe(4); expect(cursor.position).toBe(4);
expect(cursor.seek(-4).f32()).toBeCloseTo(1337.9001, 4); expect(cursor.seek(-4).f32()).toBeCloseTo(1337.9001, 4);
expect(cursor.position).toBe(4); expect(cursor.position).toBe(4);
cursor.write_f32(103.502); cursor.writeF32(103.502);
expect(cursor.position).toBe(8); expect(cursor.position).toBe(8);
expect(cursor.seek(-4).f32()).toBeCloseTo(103.502, 3); expect(cursor.seek(-4).f32()).toBeCloseTo(103.502, 3);
} }
}); });
test('write_u8_array', () => { test('writeU8Array', () => {
for (const little_endian of [false, true]) { for (const littleEndian of [false, true]) {
const bytes = 10; const bytes = 10;
const cursor = new ArrayBufferCursor(2 * bytes, little_endian); const cursor = new ArrayBufferCursor(2 * bytes, littleEndian);
const uint8_array = new Uint8Array(cursor.buffer); const uint8Array = new Uint8Array(cursor.buffer);
const test_array_1 = []; const testArray1 = [];
const test_array_2 = []; const testArray2 = [];
for (let i = 1; i <= bytes; ++i) { for (let i = 1; i <= bytes; ++i) {
test_array_1.push(i); testArray1.push(i);
test_array_2.push(i + bytes); testArray2.push(i + bytes);
} }
cursor.write_u8_array(test_array_1); cursor.writeU8Array(testArray1);
expect(cursor.position).toBe(bytes); expect(cursor.position).toBe(bytes);
for (let i = 0; i < bytes; ++i) { for (let i = 0; i < bytes; ++i) {
expect(uint8_array[i]).toBe(test_array_1[i]); expect(uint8Array[i]).toBe(testArray1[i]);
} }
cursor.write_u8_array(test_array_2); cursor.writeU8Array(testArray2);
expect(cursor.position).toBe(2 * bytes); expect(cursor.position).toBe(2 * bytes);
for (let i = 0; i < bytes; ++i) { for (let i = 0; i < bytes; ++i) {
expect(uint8_array[i]).toBe(test_array_1[i]); expect(uint8Array[i]).toBe(testArray1[i]);
} }
for (let i = 0; i < bytes; ++i) { for (let i = 0; i < bytes; ++i) {
expect(uint8_array[i + bytes]).toBe(test_array_2[i]); expect(uint8Array[i + bytes]).toBe(testArray2[i]);
} }
} }
}); });

207
src/data/ArrayBufferCursor.ts
View File

@ -14,6 +14,8 @@ const UTF_16LE_ENCODER = new TextEncoder('utf-16le');
* Uses an ArrayBuffer internally. This buffer is reallocated if and only if a write beyond the current capacity happens. * Uses an ArrayBuffer internally. This buffer is reallocated if and only if a write beyond the current capacity happens.
*/ */
export class ArrayBufferCursor { export class ArrayBufferCursor {
private _size: number = 0;
/** /**
* The cursor's size. This value will always be non-negative and equal to or smaller than the cursor's capacity. * The cursor's size. This value will always be non-negative and equal to or smaller than the cursor's capacity.
*/ */
@ -26,7 +28,7 @@ export class ArrayBufferCursor {
throw new Error('Size should be non-negative.') throw new Error('Size should be non-negative.')
} }
this._ensure_capacity(size); this.ensureCapacity(size);
this._size = size; this._size = size;
} }
@ -38,12 +40,12 @@ export class ArrayBufferCursor {
/** /**
* Byte order mode. * Byte order mode.
*/ */
little_endian: boolean; littleEndian: boolean;
/** /**
* The amount of bytes left to read from the current position onward. * The amount of bytes left to read from the current position onward.
*/ */
get bytes_left(): number { get bytesLeft(): number {
return this.size - this.position; return this.size - this.position;
} }
@ -56,46 +58,41 @@ export class ArrayBufferCursor {
buffer: ArrayBuffer; buffer: ArrayBuffer;
private _size: number = 0; private dv: DataView;
private _dv: DataView; private uint8Array: Uint8Array;
private _uint8_array: Uint8Array; private utf16Decoder: TextDecoder;
private _utf_16_decoder: TextDecoder; private utf16Encoder: TextEncoder;
private _utf_16_encoder: TextEncoder;
/** /**
* @param buffer_or_capacity - If an ArrayBuffer is given, writes to the cursor will be reflected in this array buffer and vice versa until a cursor write that requires allocating a new internal buffer happens * @param bufferOrCapacity - If an ArrayBuffer is given, writes to the cursor will be reflected in this array buffer and vice versa until a cursor write that requires allocating a new internal buffer happens
* @param little_endian - Decides in which byte order multi-byte integers and floats will be interpreted * @param littleEndian - Decides in which byte order multi-byte integers and floats will be interpreted
*/ */
constructor(buffer_or_capacity: ArrayBuffer | number, little_endian?: boolean) { constructor(bufferOrCapacity: ArrayBuffer | number, littleEndian?: boolean) {
if (typeof buffer_or_capacity === 'number') { if (typeof bufferOrCapacity === 'number') {
this.buffer = new ArrayBuffer(buffer_or_capacity); this.buffer = new ArrayBuffer(bufferOrCapacity);
this.size = 0; this.size = 0;
} else if (buffer_or_capacity instanceof ArrayBuffer) { } else if (bufferOrCapacity instanceof ArrayBuffer) {
this.buffer = buffer_or_capacity; this.buffer = bufferOrCapacity;
this.size = this.buffer.byteLength; this.size = this.buffer.byteLength;
} else { } else {
throw new Error('buffer_or_capacity should be an ArrayBuffer or a number.'); throw new Error('buffer_or_capacity should be an ArrayBuffer or a number.');
} }
this.little_endian = !!little_endian; this.littleEndian = !!littleEndian;
this.position = 0; this.position = 0;
this._dv = new DataView(this.buffer); this.dv = new DataView(this.buffer);
this._uint8_array = new Uint8Array(this.buffer, 0, this.size); this.uint8Array = new Uint8Array(this.buffer, 0, this.size);
this._utf_16_decoder = little_endian ? UTF_16LE_DECODER : UTF_16BE_DECODER; this.utf16Decoder = littleEndian ? UTF_16LE_DECODER : UTF_16BE_DECODER;
this._utf_16_encoder = little_endian ? UTF_16LE_ENCODER : UTF_16BE_ENCODER; this.utf16Encoder = littleEndian ? UTF_16LE_ENCODER : UTF_16BE_ENCODER;
} }
//
// Public methods
//
/** /**
* Seek forward or backward by a number of bytes. * Seek forward or backward by a number of bytes.
* *
* @param offset - if positive, seeks forward by offset bytes, otherwise seeks backward by -offset bytes. * @param offset - if positive, seeks forward by offset bytes, otherwise seeks backward by -offset bytes.
*/ */
seek(offset: number) { seek(offset: number) {
return this.seek_start(this.position + offset); return this.seekStart(this.position + offset);
} }
/** /**
@ -103,7 +100,7 @@ export class ArrayBufferCursor {
* *
* @param offset - greater or equal to 0 and smaller than size * @param offset - greater or equal to 0 and smaller than size
*/ */
seek_start(offset: number) { seekStart(offset: number) {
if (offset < 0 || offset > this.size) { if (offset < 0 || offset > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`); throw new Error(`Offset ${offset} is out of bounds.`);
} }
@ -117,7 +114,7 @@ export class ArrayBufferCursor {
* *
* @param offset - greater or equal to 0 and smaller than size * @param offset - greater or equal to 0 and smaller than size
*/ */
seek_end(offset: number) { seekEnd(offset: number) {
if (offset < 0 || offset > this.size) { if (offset < 0 || offset > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`); throw new Error(`Offset ${offset} is out of bounds.`);
} }
@ -130,14 +127,14 @@ export class ArrayBufferCursor {
* Reads an unsigned 8-bit integer and increments position by 1. * Reads an unsigned 8-bit integer and increments position by 1.
*/ */
u8() { u8() {
return this._dv.getUint8(this.position++); return this.dv.getUint8(this.position++);
} }
/** /**
* Reads an unsigned 16-bit integer and increments position by 2. * Reads an unsigned 16-bit integer and increments position by 2.
*/ */
u16() { u16() {
const r = this._dv.getUint16(this.position, this.little_endian); const r = this.dv.getUint16(this.position, this.littleEndian);
this.position += 2; this.position += 2;
return r; return r;
} }
@ -146,7 +143,7 @@ export class ArrayBufferCursor {
* Reads an unsigned 32-bit integer and increments position by 4. * Reads an unsigned 32-bit integer and increments position by 4.
*/ */
u32() { u32() {
const r = this._dv.getUint32(this.position, this.little_endian); const r = this.dv.getUint32(this.position, this.littleEndian);
this.position += 4; this.position += 4;
return r; return r;
} }
@ -155,7 +152,7 @@ export class ArrayBufferCursor {
* Reads a signed 16-bit integer and increments position by 2. * Reads a signed 16-bit integer and increments position by 2.
*/ */
i16() { i16() {
const r = this._dv.getInt16(this.position, this.little_endian); const r = this.dv.getInt16(this.position, this.littleEndian);
this.position += 2; this.position += 2;
return r; return r;
} }
@ -164,7 +161,7 @@ export class ArrayBufferCursor {
* Reads a signed 32-bit integer and increments position by 4. * Reads a signed 32-bit integer and increments position by 4.
*/ */
i32() { i32() {
const r = this._dv.getInt32(this.position, this.little_endian); const r = this.dv.getInt32(this.position, this.littleEndian);
this.position += 4; this.position += 4;
return r; return r;
} }
@ -173,7 +170,7 @@ export class ArrayBufferCursor {
* Reads a 32-bit floating point number and increments position by 4. * Reads a 32-bit floating point number and increments position by 4.
*/ */
f32() { f32() {
const r = this._dv.getFloat32(this.position, this.little_endian); const r = this.dv.getFloat32(this.position, this.littleEndian);
this.position += 4; this.position += 4;
return r; return r;
} }
@ -181,20 +178,20 @@ export class ArrayBufferCursor {
/** /**
* Reads n unsigned 8-bit integers and increments position by n. * Reads n unsigned 8-bit integers and increments position by n.
*/ */
u8_array(n: number): number[] { u8Array(n: number): number[] {
const array = []; const array = [];
for (let i = 0; i < n; ++i) array.push(this._dv.getUint8(this.position++)); for (let i = 0; i < n; ++i) array.push(this.dv.getUint8(this.position++));
return array; return array;
} }
/** /**
* Reads n unsigned 16-bit integers and increments position by 2n. * Reads n unsigned 16-bit integers and increments position by 2n.
*/ */
u16_array(n: number): number[] { u16Array(n: number): number[] {
const array = []; const array = [];
for (let i = 0; i < n; ++i) { for (let i = 0; i < n; ++i) {
array.push(this._dv.getUint16(this.position, this.little_endian)); array.push(this.dv.getUint16(this.position, this.littleEndian));
this.position += 2; this.position += 2;
} }
@ -214,48 +211,48 @@ export class ArrayBufferCursor {
this.position += size; this.position += size;
return new ArrayBufferCursor( return new ArrayBufferCursor(
this.buffer.slice(this.position - size, this.position), this.little_endian); this.buffer.slice(this.position - size, this.position), this.littleEndian);
} }
/** /**
* Consumes up to max_byte_length bytes. * Consumes up to maxByteLength bytes.
*/ */
string_ascii(max_byte_length: number, null_terminated: boolean, drop_remaining: boolean) { stringAscii(maxByteLength: number, nullTerminated: boolean, dropRemaining: boolean) {
const string_length = null_terminated const string_length = nullTerminated
? this._index_of_u8(0, max_byte_length) - this.position ? this.indexOfU8(0, maxByteLength) - this.position
: max_byte_length; : maxByteLength;
const r = ASCII_DECODER.decode( const r = ASCII_DECODER.decode(
new DataView(this.buffer, this.position, string_length)); new DataView(this.buffer, this.position, string_length));
this.position += drop_remaining this.position += dropRemaining
? max_byte_length ? maxByteLength
: Math.min(string_length + 1, max_byte_length); : Math.min(string_length + 1, maxByteLength);
return r; return r;
} }
/** /**
* Consumes up to max_byte_length bytes. * Consumes up to maxByteLength bytes.
*/ */
string_utf_16(max_byte_length: number, null_terminated: boolean, drop_remaining: boolean) { stringUtf16(maxByteLength: number, nullTerminated: boolean, dropRemaining: boolean) {
const string_length = null_terminated const stringLength = nullTerminated
? this._index_of_u16(0, max_byte_length) - this.position ? this.indexOfU16(0, maxByteLength) - this.position
: Math.floor(max_byte_length / 2) * 2; : Math.floor(maxByteLength / 2) * 2;
const r = this._utf_16_decoder.decode( const r = this.utf16Decoder.decode(
new DataView(this.buffer, this.position, string_length)); new DataView(this.buffer, this.position, stringLength));
this.position += drop_remaining this.position += dropRemaining
? max_byte_length ? maxByteLength
: Math.min(string_length + 2, max_byte_length); : Math.min(stringLength + 2, maxByteLength);
return r; return r;
} }
/** /**
* Writes an unsigned 8-bit integer and increments position by 1. If necessary, grows the cursor and reallocates the underlying buffer. * Writes an unsigned 8-bit integer and increments position by 1. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_u8(value: number) { writeU8(value: number) {
this._ensure_capacity(this.position + 1); this.ensureCapacity(this.position + 1);
this._dv.setUint8(this.position++, value); this.dv.setUint8(this.position++, value);
if (this.position > this.size) { if (this.position > this.size) {
this.size = this.position; this.size = this.position;
@ -267,10 +264,10 @@ export class ArrayBufferCursor {
/** /**
* Writes an unsigned 16-bit integer and increments position by 2. If necessary, grows the cursor and reallocates the underlying buffer. * Writes an unsigned 16-bit integer and increments position by 2. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_u16(value: number) { writeU16(value: number) {
this._ensure_capacity(this.position + 2); this.ensureCapacity(this.position + 2);
this._dv.setUint16(this.position, value, this.little_endian); this.dv.setUint16(this.position, value, this.littleEndian);
this.position += 2; this.position += 2;
if (this.position > this.size) { if (this.position > this.size) {
@ -283,10 +280,10 @@ export class ArrayBufferCursor {
/** /**
* Writes an unsigned 32-bit integer and increments position by 4. If necessary, grows the cursor and reallocates the underlying buffer. * Writes an unsigned 32-bit integer and increments position by 4. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_u32(value: number) { writeU32(value: number) {
this._ensure_capacity(this.position + 4); this.ensureCapacity(this.position + 4);
this._dv.setUint32(this.position, value, this.little_endian); this.dv.setUint32(this.position, value, this.littleEndian);
this.position += 4; this.position += 4;
if (this.position > this.size) { if (this.position > this.size) {
@ -297,12 +294,12 @@ export class ArrayBufferCursor {
} }
/** /**
* Writes an signed 32-bit integer and increments position by 4. If necessary, grows the cursor and reallocates the underlying buffer. * Writes a signed 32-bit integer and increments position by 4. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_i32(value: number) { writeI32(value: number) {
this._ensure_capacity(this.position + 4); this.ensureCapacity(this.position + 4);
this._dv.setInt32(this.position, value, this.little_endian); this.dv.setInt32(this.position, value, this.littleEndian);
this.position += 4; this.position += 4;
if (this.position > this.size) { if (this.position > this.size) {
@ -315,10 +312,10 @@ export class ArrayBufferCursor {
/** /**
* Writes a 32-bit floating point number and increments position by 4. If necessary, grows the cursor and reallocates the underlying buffer. * Writes a 32-bit floating point number and increments position by 4. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_f32(value: number) { writeF32(value: number) {
this._ensure_capacity(this.position + 4); this.ensureCapacity(this.position + 4);
this._dv.setFloat32(this.position, value, this.little_endian); this.dv.setFloat32(this.position, value, this.littleEndian);
this.position += 4; this.position += 4;
if (this.position > this.size) { if (this.position > this.size) {
@ -331,8 +328,8 @@ export class ArrayBufferCursor {
/** /**
* Writes an array of unsigned 8-bit integers and increments position by the array's length. If necessary, grows the cursor and reallocates the underlying buffer. * Writes an array of unsigned 8-bit integers and increments position by the array's length. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_u8_array(array: number[]) { writeU8Array(array: number[]) {
this._ensure_capacity(this.position + array.length); this.ensureCapacity(this.position + array.length);
new Uint8Array(this.buffer, this.position).set(new Uint8Array(array)); new Uint8Array(this.buffer, this.position).set(new Uint8Array(array));
this.position += array.length; this.position += array.length;
@ -347,8 +344,8 @@ export class ArrayBufferCursor {
/** /**
* Writes the contents of other and increments position by the size of other. If necessary, grows the cursor and reallocates the underlying buffer. * Writes the contents of other and increments position by the size of other. If necessary, grows the cursor and reallocates the underlying buffer.
*/ */
write_cursor(other: ArrayBufferCursor) { writeCursor(other: ArrayBufferCursor) {
this._ensure_capacity(this.position + other.size); this.ensureCapacity(this.position + other.size);
new Uint8Array(this.buffer, this.position).set(new Uint8Array(other.buffer)); new Uint8Array(this.buffer, this.position).set(new Uint8Array(other.buffer));
this.position += other.size; this.position += other.size;
@ -360,18 +357,18 @@ export class ArrayBufferCursor {
return this; return this;
} }
write_string_ascii(str: string, byte_length: number) { writeStringAscii(str: string, byteLength: number) {
let i = 0; let i = 0;
for (const byte of ASCII_ENCODER.encode(str)) { for (const byte of ASCII_ENCODER.encode(str)) {
if (i < byte_length) { if (i < byteLength) {
this.write_u8(byte); this.writeU8(byte);
++i; ++i;
} }
} }
while (i < byte_length) { while (i < byteLength) {
this.write_u8(0); this.writeU8(0);
++i; ++i;
} }
} }
@ -379,54 +376,50 @@ export class ArrayBufferCursor {
/** /**
* @returns a Uint8Array that remains a write-through view of the underlying array buffer until the buffer is reallocated. * @returns a Uint8Array that remains a write-through view of the underlying array buffer until the buffer is reallocated.
*/ */
uint8_array_view(): Uint8Array { uint8ArrayView(): Uint8Array {
return this._uint8_array; return this.uint8Array;
} }
// private indexOfU8(value: number, maxByteLength: number) {
// Private methods const maxPos = Math.min(this.position + maxByteLength, this.size);
//
_index_of_u8(value: number, max_byte_length: number) { for (let i = this.position; i < maxPos; ++i) {
const max_pos = Math.min(this.position + max_byte_length, this.size); if (this.dv.getUint8(i) === value) {
for (let i = this.position; i < max_pos; ++i) {
if (this._dv.getUint8(i) === value) {
return i; return i;
} }
} }
return this.position + max_byte_length; return this.position + maxByteLength;
} }
_index_of_u16(value: number, max_byte_length: number) { private indexOfU16(value: number, maxByteLength: number) {
const max_pos = Math.min(this.position + max_byte_length, this.size); const maxPos = Math.min(this.position + maxByteLength, this.size);
for (let i = this.position; i < max_pos; i += 2) { for (let i = this.position; i < maxPos; i += 2) {
if (this._dv.getUint16(i, this.little_endian) === value) { if (this.dv.getUint16(i, this.littleEndian) === value) {
return i; return i;
} }
} }
return this.position + max_byte_length; return this.position + maxByteLength;
} }
/** /**
* Increases buffer size if necessary. * Increases buffer size if necessary.
*/ */
_ensure_capacity(min_new_size: number) { private ensureCapacity(minNewSize: number) {
if (min_new_size > this.capacity) { if (minNewSize > this.capacity) {
let new_size = this.capacity || min_new_size; let newSize = this.capacity || minNewSize;
do { do {
new_size *= 2; newSize *= 2;
} while (new_size < min_new_size); } while (newSize < minNewSize);
const new_buffer = new ArrayBuffer(new_size); const newBuffer = new ArrayBuffer(newSize);
new Uint8Array(new_buffer).set(new Uint8Array(this.buffer, 0, this.size)); new Uint8Array(newBuffer).set(new Uint8Array(this.buffer, 0, this.size));
this.buffer = new_buffer; this.buffer = newBuffer;
this._dv = new DataView(this.buffer); this.dv = new DataView(this.buffer);
this._uint8_array = new Uint8Array(this.buffer, 0, min_new_size); this.uint8Array = new Uint8Array(this.buffer, 0, minNewSize);
} }
} }
} }

204
src/data/compression/prs/compress.ts
View File

@ -6,50 +6,50 @@ import { ArrayBufferCursor } from '../../ArrayBufferCursor';
export function compress(src: ArrayBufferCursor): ArrayBufferCursor { export function compress(src: ArrayBufferCursor): ArrayBufferCursor {
const ctx = new Context(src); const ctx = new Context(src);
const hash_table = new HashTable(); const hashTable = new HashTable();
if (ctx.src.size <= 3) { if (ctx.src.size <= 3) {
// Make a literal copy of the input. // Make a literal copy of the input.
while (ctx.src.bytes_left) { while (ctx.src.bytesLeft) {
ctx.set_bit(1); ctx.setBit(1);
ctx.copy_literal(); ctx.copyLiteral();
} }
} else { } else {
// Add the first two "strings" to the hash table. // Add the first two "strings" to the hash table.
hash_table.put(hash_table.hash(ctx.src), 0); hashTable.put(hashTable.hash(ctx.src), 0);
ctx.src.seek(1); ctx.src.seek(1);
hash_table.put(hash_table.hash(ctx.src), 1); hashTable.put(hashTable.hash(ctx.src), 1);
ctx.src.seek(-1); ctx.src.seek(-1);
// Copy the first two bytes as literals. // Copy the first two bytes as literals.
ctx.set_bit(1); ctx.setBit(1);
ctx.copy_literal(); ctx.copyLiteral();
ctx.set_bit(1); ctx.setBit(1);
ctx.copy_literal(); ctx.copyLiteral();
while (ctx.src.bytes_left > 1) { while (ctx.src.bytesLeft > 1) {
let [offset, mlen] = ctx.find_longest_match(hash_table, false); let [offset, mlen] = ctx.findLongestMatch(hashTable, false);
if (mlen > 0) { if (mlen > 0) {
ctx.src.seek(1); ctx.src.seek(1);
const [offset2, mlen2] = ctx.find_longest_match(hash_table, true); const [offset2, mlen2] = ctx.findLongestMatch(hashTable, true);
ctx.src.seek(-1); ctx.src.seek(-1);
// Did the "lazy match" produce something more compressed? // Did the "lazy match" produce something more compressed?
if (mlen2 > mlen) { if (mlen2 > mlen) {
let copy_literal = true; let copyLiteral = true;
// Check if it is a good idea to switch from a short match to a long one. // Check if it is a good idea to switch from a short match to a long one.
if (mlen >= 2 && mlen <= 5 && offset2 < offset) { if (mlen >= 2 && mlen <= 5 && offset2 < offset) {
if (offset >= -256 && offset2 < -256) { if (offset >= -256 && offset2 < -256) {
if (mlen2 - mlen < 3) { if (mlen2 - mlen < 3) {
copy_literal = false; copyLiteral = false;
} }
} }
} }
if (copy_literal) { if (copyLiteral) {
ctx.set_bit(1); ctx.setBit(1);
ctx.copy_literal(); ctx.copyLiteral();
continue; continue;
} }
} }
@ -57,20 +57,20 @@ export function compress(src: ArrayBufferCursor): ArrayBufferCursor {
// What kind of match did we find? // What kind of match did we find?
if (mlen >= 2 && mlen <= 5 && offset >= -256) { if (mlen >= 2 && mlen <= 5 && offset >= -256) {
// Short match. // Short match.
ctx.set_bit(0); ctx.setBit(0);
ctx.set_bit(0); ctx.setBit(0);
ctx.set_bit((mlen - 2) & 0x02); ctx.setBit((mlen - 2) & 0x02);
ctx.set_bit((mlen - 2) & 0x01); ctx.setBit((mlen - 2) & 0x01);
ctx.write_literal(offset & 0xFF); ctx.writeLiteral(offset & 0xFF);
ctx.add_intermediates(hash_table, mlen); ctx.addIntermediates(hashTable, mlen);
continue; continue;
} else if (mlen >= 3 && mlen <= 9) { } else if (mlen >= 3 && mlen <= 9) {
// Long match, short length. // Long match, short length.
ctx.set_bit(0); ctx.setBit(0);
ctx.set_bit(1); ctx.setBit(1);
ctx.write_literal(((offset & 0x1F) << 3) | ((mlen - 2) & 0x07)); ctx.writeLiteral(((offset & 0x1F) << 3) | ((mlen - 2) & 0x07));
ctx.write_literal(offset >> 5); ctx.writeLiteral(offset >> 5);
ctx.add_intermediates(hash_table, mlen); ctx.addIntermediates(hashTable, mlen);
continue; continue;
} else if (mlen > 9) { } else if (mlen > 9) {
// Long match, long length. // Long match, long length.
@ -78,31 +78,31 @@ export function compress(src: ArrayBufferCursor): ArrayBufferCursor {
mlen = 256; mlen = 256;
} }
ctx.set_bit(0); ctx.setBit(0);
ctx.set_bit(1); ctx.setBit(1);
ctx.write_literal((offset & 0x1F) << 3); ctx.writeLiteral((offset & 0x1F) << 3);
ctx.write_literal(offset >> 5); ctx.writeLiteral(offset >> 5);
ctx.write_literal(mlen - 1); ctx.writeLiteral(mlen - 1);
ctx.add_intermediates(hash_table, mlen); ctx.addIntermediates(hashTable, mlen);
continue; continue;
} }
} }
// If we get here, we didn't find a suitable match, so just we just make a literal copy. // If we get here, we didn't find a suitable match, so just we just make a literal copy.
ctx.set_bit(1); ctx.setBit(1);
ctx.copy_literal(); ctx.copyLiteral();
} }
// If there's a left over byte at the end, make a literal copy. // If there's a left over byte at the end, make a literal copy.
if (ctx.src.bytes_left) { if (ctx.src.bytesLeft) {
ctx.set_bit(1); ctx.setBit(1);
ctx.copy_literal(); ctx.copyLiteral();
} }
} }
ctx.write_eof(); ctx.writeEof();
return ctx.dst.seek_start(0); return ctx.dst.seekStart(0);
} }
const MAX_WINDOW = 0x2000; const MAX_WINDOW = 0x2000;
@ -113,28 +113,28 @@ class Context {
src: ArrayBufferCursor; src: ArrayBufferCursor;
dst: ArrayBufferCursor; dst: ArrayBufferCursor;
flags: number; flags: number;
flag_bits_left: number; flagBitsLeft: number;
flag_offset: number; flagOffset: number;
constructor(cursor: ArrayBufferCursor) { constructor(cursor: ArrayBufferCursor) {
this.src = cursor; this.src = cursor;
this.dst = new ArrayBufferCursor(cursor.size, cursor.little_endian); this.dst = new ArrayBufferCursor(cursor.size, cursor.littleEndian);
this.flags = 0; this.flags = 0;
this.flag_bits_left = 0; this.flagBitsLeft = 0;
this.flag_offset = 0; this.flagOffset = 0;
} }
set_bit(bit: number): void { setBit(bit: number): void {
if (!this.flag_bits_left--) { if (!this.flagBitsLeft--) {
// Write out the flags to their position in the file, and store the next flags byte position. // Write out the flags to their position in the file, and store the next flags byte position.
const pos = this.dst.position; const pos = this.dst.position;
this.dst this.dst
.seek_start(this.flag_offset) .seekStart(this.flagOffset)
.write_u8(this.flags) .writeU8(this.flags)
.seek_start(pos) .seekStart(pos)
.write_u8(0); // Placeholder for the next flags byte. .writeU8(0); // Placeholder for the next flags byte.
this.flag_offset = pos; this.flagOffset = pos;
this.flag_bits_left = 7; this.flagBitsLeft = 7;
} }
this.flags >>>= 1; this.flags >>>= 1;
@ -144,35 +144,35 @@ class Context {
} }
} }
copy_literal(): void { copyLiteral(): void {
this.dst.write_u8(this.src.u8()); this.dst.writeU8(this.src.u8());
} }
write_literal(value: number): void { writeLiteral(value: number): void {
this.dst.write_u8(value); this.dst.writeU8(value);
} }
write_final_flags(): void { writeFinalFlags(): void {
this.flags >>>= this.flag_bits_left; this.flags >>>= this.flagBitsLeft;
const pos = this.dst.position; const pos = this.dst.position;
this.dst this.dst
.seek_start(this.flag_offset) .seekStart(this.flagOffset)
.write_u8(this.flags) .writeU8(this.flags)
.seek_start(pos); .seekStart(pos);
} }
write_eof(): void { writeEof(): void {
this.set_bit(0); this.setBit(0);
this.set_bit(1); this.setBit(1);
this.write_final_flags(); this.writeFinalFlags();
this.write_literal(0); this.writeLiteral(0);
this.write_literal(0); this.writeLiteral(0);
} }
match_length(s2: number): number { matchLength(s2: number): number {
const array = this.src.uint8_array_view(); const array = this.src.uint8ArrayView();
let len = 0; let len = 0;
let s1 = this.src.position; let s1 = this.src.position;
@ -185,20 +185,20 @@ class Context {
return len; return len;
} }
find_longest_match(hash_table: HashTable, lazy: boolean): [number, number] { findLongestMatch(hashTable: HashTable, lazy: boolean): [number, number] {
if (!this.src.bytes_left) { if (!this.src.bytesLeft) {
return [0, 0]; return [0, 0];
} }
// Figure out where we're looking. // Figure out where we're looking.
const hash = hash_table.hash(this.src); const hash = hashTable.hash(this.src);
// If there is nothing in the table at that point, bail out now. // If there is nothing in the table at that point, bail out now.
let entry = hash_table.get(hash); let entry = hashTable.get(hash);
if (entry === null) { if (entry === null) {
if (!lazy) { if (!lazy) {
hash_table.put(hash, this.src.position); hashTable.put(hash, this.src.position);
} }
return [0, 0]; return [0, 0];
@ -206,10 +206,10 @@ class Context {
// If we'd go outside the window, truncate the hash chain now. // If we'd go outside the window, truncate the hash chain now.
if (this.src.position - entry > MAX_WINDOW) { if (this.src.position - entry > MAX_WINDOW) {
hash_table.hash_to_offset[hash] = null; hashTable.hashToOffset[hash] = null;
if (!lazy) { if (!lazy) {
hash_table.put(hash, this.src.position); hashTable.put(hash, this.src.position);
} }
return [0, 0]; return [0, 0];
@ -217,24 +217,24 @@ class Context {
// Ok, we have something in the hash table that matches the hash value. // Ok, we have something in the hash table that matches the hash value.
// Follow the chain to see if we have an actual string match, and find the longest match. // Follow the chain to see if we have an actual string match, and find the longest match.
let longest_length = 0; let longestLength = 0;
let longest_match = 0; let longestMatch = 0;
while (entry != null) { while (entry != null) {
const mlen = this.match_length(entry); const mlen = this.matchLength(entry);
if (mlen > longest_length || mlen >= 256) { if (mlen > longestLength || mlen >= 256) {
longest_length = mlen; longestLength = mlen;
longest_match = entry; longestMatch = entry;
} }
// Follow the chain, making sure not to exceed a difference of MAX_WINDOW. // Follow the chain, making sure not to exceed a difference of MAX_WINDOW.
let entry2 = hash_table.prev(entry); let entry2 = hashTable.prev(entry);
if (entry2 !== null) { if (entry2 !== null) {
// If we'd go outside the window, truncate the hash chain now. // If we'd go outside the window, truncate the hash chain now.
if (this.src.position - entry2 > MAX_WINDOW) { if (this.src.position - entry2 > MAX_WINDOW) {
hash_table.set_prev(entry, null); hashTable.setPrev(entry, null);
entry2 = null; entry2 = null;
} }
} }
@ -244,33 +244,33 @@ class Context {
// Add our current string to the hash. // Add our current string to the hash.
if (!lazy) { if (!lazy) {
hash_table.put(hash, this.src.position); hashTable.put(hash, this.src.position);
} }
// Did we find a match? // Did we find a match?
const offset = longest_length > 0 ? longest_match - this.src.position : 0; const offset = longestLength > 0 ? longestMatch - this.src.position : 0;
return [offset, longest_length]; return [offset, longestLength];
} }
add_intermediates(hash_table: HashTable, len: number): void { addIntermediates(hashTable: HashTable, len: number): void {
this.src.seek(1); this.src.seek(1);
for (let i = 1; i < len; ++i) { for (let i = 1; i < len; ++i) {
const hash = hash_table.hash(this.src); const hash = hashTable.hash(this.src);
hash_table.put(hash, this.src.position); hashTable.put(hash, this.src.position);
this.src.seek(1); this.src.seek(1);
} }
} }
} }
class HashTable { class HashTable {
hash_to_offset: Array<number | null> = new Array(HASH_SIZE).fill(null); hashToOffset: Array<number | null> = new Array(HASH_SIZE).fill(null);
masked_offset_to_prev: Array<number | null> = new Array(MAX_WINDOW).fill(null); maskedOffsetToPrev: Array<number | null> = new Array(MAX_WINDOW).fill(null);
hash(cursor: ArrayBufferCursor): number { hash(cursor: ArrayBufferCursor): number {
let hash = cursor.u8(); let hash = cursor.u8();
if (cursor.bytes_left) { if (cursor.bytesLeft) {
hash ^= cursor.u8(); hash ^= cursor.u8();
cursor.seek(-1); cursor.seek(-1);
} }
@ -280,19 +280,19 @@ class HashTable {
} }
get(hash: number): number | null { get(hash: number): number | null {
return this.hash_to_offset[hash]; return this.hashToOffset[hash];
} }
put(hash: number, offset: number): void { put(hash: number, offset: number): void {
this.set_prev(offset, this.hash_to_offset[hash]); this.setPrev(offset, this.hashToOffset[hash]);
this.hash_to_offset[hash] = offset; this.hashToOffset[hash] = offset;
} }
prev(offset: number): number | null { prev(offset: number): number | null {
return this.masked_offset_to_prev[offset & WINDOW_MASK]; return this.maskedOffsetToPrev[offset & WINDOW_MASK];
} }
set_prev(offset: number, prev_offset: number | null): void { setPrev(offset: number, prevOffset: number | null): void {
this.masked_offset_to_prev[offset & WINDOW_MASK] = prev_offset; this.maskedOffsetToPrev[offset & WINDOW_MASK] = prevOffset;
} }
} }

58
src/data/compression/prs/decompress.ts
View File

@ -9,24 +9,24 @@ export function decompress(cursor: ArrayBufferCursor) {
const ctx = new Context(cursor); const ctx = new Context(cursor);
while (true) { while (true) {
if (ctx.read_flag_bit() === 1) { if (ctx.readFlagBit() === 1) {
// Single byte copy. // Single byte copy.
ctx.copy_u8(); ctx.copyU8();
} else { } else {
// Multi byte copy. // Multi byte copy.
let length; let length;
let offset; let offset;
if (ctx.read_flag_bit() === 0) { if (ctx.readFlagBit() === 0) {
// Short copy. // Short copy.
length = ctx.read_flag_bit() << 1; length = ctx.readFlagBit() << 1;
length |= ctx.read_flag_bit(); length |= ctx.readFlagBit();
length += 2; length += 2;
offset = ctx.read_u8() - 256; offset = ctx.readU8() - 256;
} else { } else {
// Long copy or end of file. // Long copy or end of file.
offset = ctx.read_u16(); offset = ctx.readU16();
// Two zero bytes implies that this is the end of the file. // Two zero bytes implies that this is the end of the file.
if (offset === 0) { if (offset === 0) {
@ -38,7 +38,7 @@ export function decompress(cursor: ArrayBufferCursor) {
offset >>>= 3; offset >>>= 3;
if (length === 0) { if (length === 0) {
length = ctx.read_u8(); length = ctx.readU8();
length += 1; length += 1;
} else { } else {
length += 2; length += 2;
@ -47,52 +47,52 @@ export function decompress(cursor: ArrayBufferCursor) {
offset -= 8192; offset -= 8192;
} }
ctx.offset_copy(offset, length); ctx.offsetCopy(offset, length);
} }
} }
return ctx.dst.seek_start(0); return ctx.dst.seekStart(0);
} }
class Context { class Context {
src: ArrayBufferCursor; src: ArrayBufferCursor;
dst: ArrayBufferCursor; dst: ArrayBufferCursor;
flags: number; flags: number;
flag_bits_left: number; flagBitsLeft: number;
constructor(cursor: ArrayBufferCursor) { constructor(cursor: ArrayBufferCursor) {
this.src = cursor; this.src = cursor;
this.dst = new ArrayBufferCursor(4 * cursor.size, cursor.little_endian); this.dst = new ArrayBufferCursor(4 * cursor.size, cursor.littleEndian);
this.flags = 0; this.flags = 0;
this.flag_bits_left = 0; this.flagBitsLeft = 0;
} }
read_flag_bit() { readFlagBit() {
// Fetch a new flag byte when the previous byte has been processed. // Fetch a new flag byte when the previous byte has been processed.
if (this.flag_bits_left === 0) { if (this.flagBitsLeft === 0) {
this.flags = this.read_u8(); this.flags = this.readU8();
this.flag_bits_left = 8; this.flagBitsLeft = 8;
} }
let bit = this.flags & 1; let bit = this.flags & 1;
this.flags >>>= 1; this.flags >>>= 1;
this.flag_bits_left -= 1; this.flagBitsLeft -= 1;
return bit; return bit;
} }
copy_u8() { copyU8() {
this.dst.write_u8(this.read_u8()); this.dst.writeU8(this.readU8());
} }
read_u8() { readU8() {
return this.src.u8(); return this.src.u8();
} }
read_u16() { readU16() {
return this.src.u16(); return this.src.u16();
} }
offset_copy(offset: number, length: number) { offsetCopy(offset: number, length: number) {
if (offset < -8192 || offset > 0) { if (offset < -8192 || offset > 0) {
console.error(`offset was ${offset}, should be between -8192 and 0.`); console.error(`offset was ${offset}, should be between -8192 and 0.`);
} }
@ -102,16 +102,16 @@ class Context {
} }
// The length can be larger than -offset, in that case we copy -offset bytes size/-offset times. // The length can be larger than -offset, in that case we copy -offset bytes size/-offset times.
const buf_size = Math.min(-offset, length); const bufSize = Math.min(-offset, length);
this.dst.seek(offset); this.dst.seek(offset);
const buf = this.dst.take(buf_size); const buf = this.dst.take(bufSize);
this.dst.seek(-offset - buf_size); this.dst.seek(-offset - bufSize);
for (let i = 0; i < Math.floor(length / buf_size); ++i) { for (let i = 0; i < Math.floor(length / bufSize); ++i) {
this.dst.write_cursor(buf); this.dst.writeCursor(buf);
} }
this.dst.write_cursor(buf.take(length % buf_size)); this.dst.writeCursor(buf.take(length % bufSize));
} }
} }

44
src/data/compression/prs/index.test.ts
View File

@ -1,44 +1,44 @@
import { ArrayBufferCursor } from '../../ArrayBufferCursor'; import { ArrayBufferCursor } from '../../ArrayBufferCursor';
import { compress, decompress } from '.'; import { compress, decompress } from '.';
function test_with_bytes(bytes: number[], expected_compressed_size: number) { function testWithBytes(bytes: number[], expectedCompressedSize: number) {
const cursor = new ArrayBufferCursor(new Uint8Array(bytes).buffer, true); const cursor = new ArrayBufferCursor(new Uint8Array(bytes).buffer, true);
for (const byte of bytes) { for (const byte of bytes) {
cursor.write_u8(byte); cursor.writeU8(byte);
} }
cursor.seek_start(0); cursor.seekStart(0);
const compressed_cursor = compress(cursor); const compressedCursor = compress(cursor);
expect(compressed_cursor.size).toBe(expected_compressed_size); expect(compressedCursor.size).toBe(expectedCompressedSize);
const test_cursor = decompress(compressed_cursor); const testCursor = decompress(compressedCursor);
cursor.seek_start(0); cursor.seekStart(0);
expect(test_cursor.size).toBe(cursor.size); expect(testCursor.size).toBe(cursor.size);
while (cursor.bytes_left) { while (cursor.bytesLeft) {
if (cursor.u8() !== test_cursor.u8()) { if (cursor.u8() !== testCursor.u8()) {
cursor.seek(-1); cursor.seek(-1);
test_cursor.seek(-1); testCursor.seek(-1);
break; break;
} }
} }
expect(test_cursor.position).toBe(test_cursor.size); expect(testCursor.position).toBe(testCursor.size);
} }
test('PRS compression and decompression, best case', () => { test('PRS compression and decompression, best case', () => {
// Compression factor: 0.018 // Compression factor: 0.018
test_with_bytes(new Array(1000).fill(128), 18); testWithBytes(new Array(1000).fill(128), 18);
}); });
test('PRS compression and decompression, worst case', () => { test('PRS compression and decompression, worst case', () => {
const prng = new Prng(); const prng = new Prng();
// Compression factor: 1.124 // Compression factor: 1.124
test_with_bytes(new Array(1000).fill(0).map(_ => prng.next_integer(0, 255)), 1124); testWithBytes(new Array(1000).fill(0).map(_ => prng.nextInteger(0, 255)), 1124);
}); });
test('PRS compression and decompression, typical case', () => { test('PRS compression and decompression, typical case', () => {
@ -46,27 +46,27 @@ test('PRS compression and decompression, typical case', () => {
const pattern = [0, 0, 2, 0, 3, 0, 5, 0, 0, 0, 7, 9, 11, 13, 0, 0]; const pattern = [0, 0, 2, 0, 3, 0, 5, 0, 0, 0, 7, 9, 11, 13, 0, 0];
const arrays = new Array(100) const arrays = new Array(100)
.fill(pattern) .fill(pattern)
.map(array => array.map((e: number) => e + prng.next_integer(0, 10))); .map(array => array.map((e: number) => e + prng.nextInteger(0, 10)));
const flattened_array = [].concat.apply([], arrays); const flattenedArray = [].concat.apply([], arrays);
// Compression factor: 0.834 // Compression factor: 0.834
test_with_bytes(flattened_array, 1335); testWithBytes(flattenedArray, 1335);
}); });
test('PRS compression and decompression, 0 bytes', () => { test('PRS compression and decompression, 0 bytes', () => {
test_with_bytes([], 3); testWithBytes([], 3);
}); });
test('PRS compression and decompression, 1 byte', () => { test('PRS compression and decompression, 1 byte', () => {
test_with_bytes([111], 4); testWithBytes([111], 4);
}); });
test('PRS compression and decompression, 2 bytes', () => { test('PRS compression and decompression, 2 bytes', () => {
test_with_bytes([111, 224], 5); testWithBytes([111, 224], 5);
}); });
test('PRS compression and decompression, 3 bytes', () => { test('PRS compression and decompression, 3 bytes', () => {
test_with_bytes([56, 237, 158], 6); testWithBytes([56, 237, 158], 6);
}); });
class Prng { class Prng {
@ -77,7 +77,7 @@ class Prng {
return x - Math.floor(x); return x - Math.floor(x);
} }
next_integer(min: number, max: number): number { nextInteger(min: number, max: number): number {
return Math.floor(this.next() * (max + 1 - min)) + min; return Math.floor(this.next() * (max + 1 - min)) + min;
} }
} }

78
src/data/loading/areas.ts
View File

@ -1,79 +1,79 @@
import { Object3D } from 'three'; import { Object3D } from 'three';
import { Section } from '../../domain'; import { Section } from '../../domain';
import { get_area_render_data, get_area_collision_data } from './assets'; import { getAreaRenderData, getAreaCollisionData } from './assets';
import { parse_c_rel, parse_n_rel } from '../parsing/geometry'; import { parseCRel, parseNRel } from '../parsing/geometry';
// //
// Caches // Caches
// //
const sections_cache: Map<string, Promise<Section[]>> = new Map(); const sectionsCache: Map<string, Promise<Section[]>> = new Map();
const render_geometry_cache: Map<string, Promise<Object3D>> = new Map(); const renderGeometryCache: Map<string, Promise<Object3D>> = new Map();
const collision_geometry_cache: Map<string, Promise<Object3D>> = new Map(); const collisionGeometryCache: Map<string, Promise<Object3D>> = new Map();
export function get_area_sections( export function getAreaSections(
episode: number, episode: number,
area_id: number, areaId: number,
area_variant: number areaVariant: number
): Promise<Section[]> { ): Promise<Section[]> {
const sections = sections_cache.get(`${episode}-${area_id}-${area_variant}`); const sections = sectionsCache.get(`${episode}-${areaId}-${areaVariant}`);
if (sections) { if (sections) {
return sections; return sections;
} else { } else {
return get_area_sections_and_render_geometry( return getAreaSectionsAndRenderGeometry(
episode, area_id, area_variant).then(({sections}) => sections); episode, areaId, areaVariant).then(({sections}) => sections);
} }
} }
export function get_area_render_geometry( export function getAreaRenderGeometry(
episode: number, episode: number,
area_id: number, areaId: number,
area_variant: number areaVariant: number
): Promise<Object3D> { ): Promise<Object3D> {
const object_3d = render_geometry_cache.get(`${episode}-${area_id}-${area_variant}`); const object3d = renderGeometryCache.get(`${episode}-${areaId}-${areaVariant}`);
if (object_3d) { if (object3d) {
return object_3d; return object3d;
} else { } else {
return get_area_sections_and_render_geometry( return getAreaSectionsAndRenderGeometry(
episode, area_id, area_variant).then(({object_3d}) => object_3d); episode, areaId, areaVariant).then(({object3d}) => object3d);
} }
} }
export function get_area_collision_geometry( export function getAreaCollisionGeometry(
episode: number, episode: number,
area_id: number, areaId: number,
area_variant: number areaVariant: number
): Promise<Object3D> { ): Promise<Object3D> {
const object_3d = collision_geometry_cache.get(`${episode}-${area_id}-${area_variant}`); const object3d = collisionGeometryCache.get(`${episode}-${areaId}-${areaVariant}`);
if (object_3d) { if (object3d) {
return object_3d; return object3d;
} else { } else {
const object_3d = get_area_collision_data( const object3d = getAreaCollisionData(
episode, area_id, area_variant).then(parse_c_rel); episode, areaId, areaVariant).then(parseCRel);
collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d); collisionGeometryCache.set(`${areaId}-${areaVariant}`, object3d);
return object_3d; return object3d;
} }
} }
function get_area_sections_and_render_geometry( function getAreaSectionsAndRenderGeometry(
episode: number, episode: number,
area_id: number, areaId: number,
area_variant: number areaVariant: number
): Promise<{ sections: Section[], object_3d: Object3D }> { ): Promise<{ sections: Section[], object3d: Object3D }> {
const promise = get_area_render_data( const promise = getAreaRenderData(
episode, area_id, area_variant).then(parse_n_rel); episode, areaId, areaVariant).then(parseNRel);
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 object3d = new Promise<Object3D>((resolve, reject) => {
promise.then(({object_3d}) => resolve(object_3d)).catch(reject); promise.then(({object3d}) => resolve(object3d)).catch(reject);
}); });
sections_cache.set(`${episode}-${area_id}-${area_variant}`, sections); sectionsCache.set(`${episode}-${areaId}-${areaVariant}`, sections);
render_geometry_cache.set(`${episode}-${area_id}-${area_variant}`, object_3d); renderGeometryCache.set(`${episode}-${areaId}-${areaVariant}`, object3d);
return promise; return promise;
} }

132
src/data/loading/assets.ts
View File

@ -1,35 +1,35 @@
import { NpcType, ObjectType } from '../../domain'; import { NpcType, ObjectType } from '../../domain';
export function get_area_render_data( export function getAreaRenderData(
episode: number, episode: number,
area_id: number, areaId: number,
area_version: number areaVersion: number
): Promise<ArrayBuffer> { ): Promise<ArrayBuffer> {
return get_area_asset(episode, area_id, area_version, 'render'); return getAreaAsset(episode, areaId, areaVersion, 'render');
} }
export function get_area_collision_data( export function getAreaCollisionData(
episode: number, episode: number,
area_id: number, areaId: number,
area_version: number areaVersion: number
): Promise<ArrayBuffer> { ): Promise<ArrayBuffer> {
return get_area_asset(episode, area_id, area_version, 'collision'); return getAreaAsset(episode, areaId, areaVersion, 'collision');
} }
export async function get_npc_data(npc_type: NpcType): Promise<{ url: string, data: ArrayBuffer }> { export async function getNpcData(npcType: NpcType): Promise<{ url: string, data: ArrayBuffer }> {
try { try {
const url = npc_type_to_url(npc_type); const url = npcTypeToUrl(npcType);
const data = await get_asset(url); const data = await getAsset(url);
return ({ url, data }); return ({ url, data });
} catch (e) { } catch (e) {
return Promise.reject(e); return Promise.reject(e);
} }
} }
export async function get_object_data(object_type: ObjectType): Promise<{ url: string, data: ArrayBuffer }> { export async function getObjectData(objectType: ObjectType): Promise<{ url: string, data: ArrayBuffer }> {
try { try {
const url = object_type_to_url(object_type); const url = objectTypeToUrl(objectType);
const data = await get_asset(url); const data = await getAsset(url);
return ({ url, data }); return ({ url, data });
} catch (e) { } catch (e) {
return Promise.reject(e); return Promise.reject(e);
@ -39,22 +39,22 @@ export async function get_object_data(object_type: ObjectType): Promise<{ url: s
/** /**
* Cache for the binary data. * Cache for the binary data.
*/ */
const buffer_cache: Map<string, Promise<ArrayBuffer>> = new Map(); const bufferCache: Map<string, Promise<ArrayBuffer>> = new Map();
function get_asset(url: string): Promise<ArrayBuffer> { function getAsset(url: string): Promise<ArrayBuffer> {
const promise = buffer_cache.get(url); const promise = bufferCache.get(url);
if (promise) { if (promise) {
return promise; return promise;
} else { } else {
const base_url = process.env.PUBLIC_URL; const baseUrl = process.env.PUBLIC_URL;
const promise = fetch(base_url + url).then(r => r.arrayBuffer()); const promise = fetch(baseUrl + url).then(r => r.arrayBuffer());
buffer_cache.set(url, promise); bufferCache.set(url, promise);
return promise; return promise;
} }
} }
const area_base_names = [ const areaBaseNames = [
[ [
['city00_00', 1], ['city00_00', 1],
['forest01', 1], ['forest01', 1],
@ -93,7 +93,7 @@ const area_base_names = [
['jungle07_', 5] ['jungle07_', 5]
], ],
[ [
// Don't remove, see usage of area_base_names in area_version_to_base_url. // Don't remove this empty array, see usage of areaBaseNames in areaVersionToBaseUrl.
], ],
[ [
['city02_00', 1], ['city02_00', 1],
@ -109,89 +109,89 @@ const area_base_names = [
] ]
]; ];
function area_version_to_base_url( function areaVersionToBaseUrl(
episode: number, episode: number,
area_id: number, areaId: number,
area_variant: number areaVariant: number
): string { ): string {
const episode_base_names = area_base_names[episode - 1]; const episodeBaseNames = areaBaseNames[episode - 1];
if (0 <= area_id && area_id < episode_base_names.length) { if (0 <= areaId && areaId < episodeBaseNames.length) {
const [base_name, variants] = episode_base_names[area_id]; const [baseName, variants] = episodeBaseNames[areaId];
if (0 <= area_variant && area_variant < variants) { if (0 <= areaVariant && areaVariant < variants) {
let variant: string; let variant: string;
if (variants === 1) { if (variants === 1) {
variant = ''; variant = '';
} else { } else {
variant = String(area_variant); variant = String(areaVariant);
while (variant.length < 2) variant = '0' + variant; while (variant.length < 2) variant = '0' + variant;
} }
return `/maps/map_${base_name}${variant}`; return `/maps/map_${baseName}${variant}`;
} else { } else {
throw new Error(`Unknown variant ${area_variant} of area ${area_id} in episode ${episode}.`); throw new Error(`Unknown variant ${areaVariant} of area ${areaId} in episode ${episode}.`);
} }
} else { } else {
throw new Error(`Unknown episode ${episode} area ${area_id}.`); throw new Error(`Unknown episode ${episode} area ${areaId}.`);
} }
} }
type AreaAssetType = 'render' | 'collision'; type AreaAssetType = 'render' | 'collision';
function get_area_asset( function getAreaAsset(
episode: number, episode: number,
area_id: number, areaId: number,
area_variant: number, areaVariant: number,
type: AreaAssetType type: AreaAssetType
): Promise<ArrayBuffer> { ): Promise<ArrayBuffer> {
try { try {
const base_url = area_version_to_base_url(episode, area_id, area_variant); const baseUrl = areaVersionToBaseUrl(episode, areaId, areaVariant);
const suffix = type === 'render' ? 'n.rel' : 'c.rel'; const suffix = type === 'render' ? 'n.rel' : 'c.rel';
return get_asset(base_url + suffix); return getAsset(baseUrl + suffix);
} catch (e) { } catch (e) {
return Promise.reject(e); return Promise.reject(e);
} }
} }
function npc_type_to_url(npc_type: NpcType): string { function npcTypeToUrl(npcType: NpcType): string {
switch (npc_type) { switch (npcType) {
// The dubswitch model in in XJ format. // The dubswitch model in in XJ format.
case NpcType.Dubswitch: return `/npcs/${npc_type.code}.xj`; case NpcType.Dubswitch: return `/npcs/${npcType.code}.xj`;
// Episode II VR Temple // Episode II VR Temple
case NpcType.Hildebear2: return npc_type_to_url(NpcType.Hildebear); case NpcType.Hildebear2: return npcTypeToUrl(NpcType.Hildebear);
case NpcType.Hildeblue2: return npc_type_to_url(NpcType.Hildeblue); case NpcType.Hildeblue2: return npcTypeToUrl(NpcType.Hildeblue);
case NpcType.RagRappy2: return npc_type_to_url(NpcType.RagRappy); case NpcType.RagRappy2: return npcTypeToUrl(NpcType.RagRappy);
case NpcType.Monest2: return npc_type_to_url(NpcType.Monest); case NpcType.Monest2: return npcTypeToUrl(NpcType.Monest);
case NpcType.PoisonLily2: return npc_type_to_url(NpcType.PoisonLily); case NpcType.PoisonLily2: return npcTypeToUrl(NpcType.PoisonLily);
case NpcType.NarLily2: return npc_type_to_url(NpcType.NarLily); case NpcType.NarLily2: return npcTypeToUrl(NpcType.NarLily);
case NpcType.GrassAssassin2: return npc_type_to_url(NpcType.GrassAssassin); case NpcType.GrassAssassin2: return npcTypeToUrl(NpcType.GrassAssassin);
case NpcType.Dimenian2: return npc_type_to_url(NpcType.Dimenian); case NpcType.Dimenian2: return npcTypeToUrl(NpcType.Dimenian);
case NpcType.LaDimenian2: return npc_type_to_url(NpcType.LaDimenian); case NpcType.LaDimenian2: return npcTypeToUrl(NpcType.LaDimenian);
case NpcType.SoDimenian2: return npc_type_to_url(NpcType.SoDimenian); case NpcType.SoDimenian2: return npcTypeToUrl(NpcType.SoDimenian);
case NpcType.DarkBelra2: return npc_type_to_url(NpcType.DarkBelra); case NpcType.DarkBelra2: return npcTypeToUrl(NpcType.DarkBelra);
// Episode II VR Spaceship // Episode II VR Spaceship
case NpcType.SavageWolf2: return npc_type_to_url(NpcType.SavageWolf); case NpcType.SavageWolf2: return npcTypeToUrl(NpcType.SavageWolf);
case NpcType.BarbarousWolf2: return npc_type_to_url(NpcType.BarbarousWolf); case NpcType.BarbarousWolf2: return npcTypeToUrl(NpcType.BarbarousWolf);
case NpcType.PanArms2: return npc_type_to_url(NpcType.PanArms); case NpcType.PanArms2: return npcTypeToUrl(NpcType.PanArms);
case NpcType.Dubchic2: return npc_type_to_url(NpcType.Dubchic); case NpcType.Dubchic2: return npcTypeToUrl(NpcType.Dubchic);
case NpcType.Gilchic2: return npc_type_to_url(NpcType.Gilchic); case NpcType.Gilchic2: return npcTypeToUrl(NpcType.Gilchic);
case NpcType.Garanz2: return npc_type_to_url(NpcType.Garanz); case NpcType.Garanz2: return npcTypeToUrl(NpcType.Garanz);
case NpcType.Dubswitch2: return npc_type_to_url(NpcType.Dubswitch); case NpcType.Dubswitch2: return npcTypeToUrl(NpcType.Dubswitch);
case NpcType.Delsaber2: return npc_type_to_url(NpcType.Delsaber); case NpcType.Delsaber2: return npcTypeToUrl(NpcType.Delsaber);
case NpcType.ChaosSorcerer2: return npc_type_to_url(NpcType.ChaosSorcerer); case NpcType.ChaosSorcerer2: return npcTypeToUrl(NpcType.ChaosSorcerer);
default: return `/npcs/${npc_type.code}.nj`; default: return `/npcs/${npcType.code}.nj`;
} }
} }
function object_type_to_url(object_type: ObjectType): string { function objectTypeToUrl(objectType: ObjectType): string {
switch (object_type) { switch (objectType) {
case ObjectType.EasterEgg: case ObjectType.EasterEgg:
case ObjectType.ChristmasTree: case ObjectType.ChristmasTree:
case ObjectType.ChristmasWreath: case ObjectType.ChristmasWreath:
@ -208,9 +208,9 @@ function object_type_to_url(object_type: ObjectType): string {
case ObjectType.FallingRock: case ObjectType.FallingRock:
case ObjectType.DesertFixedTypeBoxBreakableCrystals: case ObjectType.DesertFixedTypeBoxBreakableCrystals:
case ObjectType.BeeHive: case ObjectType.BeeHive:
return `/objects/${String(object_type.pso_id)}.nj`; return `/objects/${String(objectType.psoId)}.nj`;
default: default:
return `/objects/${String(object_type.pso_id)}.xj`; return `/objects/${String(objectType.psoId)}.xj`;
} }
} }

36
src/data/loading/entities.ts
View File

@ -1,52 +1,52 @@
import { BufferGeometry } from 'three'; import { BufferGeometry } from 'three';
import { NpcType, ObjectType } from '../../domain'; import { NpcType, ObjectType } from '../../domain';
import { get_npc_data, get_object_data } from './assets'; import { getNpcData, getObjectData } from './assets';
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
import { parse_nj, parse_xj } from '../parsing/ninja'; import { parseNj, parseXj } from '../parsing/ninja';
const npc_cache: Map<string, Promise<BufferGeometry>> = new Map(); const npcCache: Map<string, Promise<BufferGeometry>> = new Map();
const object_cache: Map<string, Promise<BufferGeometry>> = new Map(); const objectCache: Map<string, Promise<BufferGeometry>> = new Map();
export function get_npc_geometry(npc_type: NpcType): Promise<BufferGeometry> { export function getNpcGeometry(npcType: NpcType): Promise<BufferGeometry> {
let geometry = npc_cache.get(String(npc_type.id)); let geometry = npcCache.get(String(npcType.id));
if (geometry) { if (geometry) {
return geometry; return geometry;
} else { } else {
geometry = get_npc_data(npc_type).then(({ url, data }) => { geometry = getNpcData(npcType).then(({ url, data }) => {
const cursor = new ArrayBufferCursor(data, true); const cursor = new ArrayBufferCursor(data, true);
const object_3d = url.endsWith('.nj') ? parse_nj(cursor) : parse_xj(cursor); const object3d = url.endsWith('.nj') ? parseNj(cursor) : parseXj(cursor);
if (object_3d) { if (object3d) {
return object_3d; return object3d;
} else { } else {
throw new Error('File could not be parsed into a BufferGeometry.'); throw new Error('File could not be parsed into a BufferGeometry.');
} }
}); });
npc_cache.set(String(npc_type.id), geometry); npcCache.set(String(npcType.id), geometry);
return geometry; return geometry;
} }
} }
export function get_object_geometry(object_type: ObjectType): Promise<BufferGeometry> { export function getObjectGeometry(objectType: ObjectType): Promise<BufferGeometry> {
let geometry = object_cache.get(String(object_type.id)); let geometry = objectCache.get(String(objectType.id));
if (geometry) { if (geometry) {
return geometry; return geometry;
} else { } else {
geometry = get_object_data(object_type).then(({ url, data }) => { geometry = getObjectData(objectType).then(({ url, data }) => {
const cursor = new ArrayBufferCursor(data, true); const cursor = new ArrayBufferCursor(data, true);
const object_3d = url.endsWith('.nj') ? parse_nj(cursor) : parse_xj(cursor); const object3d = url.endsWith('.nj') ? parseNj(cursor) : parseXj(cursor);
if (object_3d) { if (object3d) {
return object_3d; return object3d;
} else { } else {
throw new Error('File could not be parsed into a BufferGeometry.'); throw new Error('File could not be parsed into a BufferGeometry.');
} }
}); });
object_cache.set(String(object_type.id), geometry); objectCache.set(String(objectType.id), geometry);
return geometry; return geometry;
} }
} }

18
src/data/parsing/bin.test.ts
View File

@ -1,23 +1,23 @@
import * as fs from 'fs'; import * as fs from 'fs';
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
import * as prs from '../compression/prs'; import * as prs from '../compression/prs';
import { parse_bin, write_bin } from './bin'; import { parseBin, writeBin } 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('parse_bin and write_bin', () => { test('parseBin and writeBin', () => {
const orig_buffer = fs.readFileSync('test/resources/quest118_e.bin').buffer; const origBuffer = fs.readFileSync('test/resources/quest118_e.bin').buffer;
const orig_bin = prs.decompress(new ArrayBufferCursor(orig_buffer, true)); const origBin = prs.decompress(new ArrayBufferCursor(origBuffer, true));
const test_bin = write_bin(parse_bin(orig_bin)); const testBin = writeBin(parseBin(origBin));
orig_bin.seek_start(0); origBin.seekStart(0);
expect(test_bin.size).toBe(orig_bin.size); expect(testBin.size).toBe(origBin.size);
let match = true; let match = true;
while (orig_bin.bytes_left) { while (origBin.bytesLeft) {
if (test_bin.u8() !== orig_bin.u8()) { if (testBin.u8() !== origBin.u8()) {
match = false; match = false;
break; break;
} }

88
src/data/parsing/bin.ts
View File

@ -1,47 +1,59 @@
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
export function parse_bin(cursor: ArrayBufferCursor) { export interface BinFile {
const object_code_offset = cursor.u32(); questNumber: number;
const function_offset_table_offset = cursor.u32(); // Relative offsets language: number;
questName: string;
shortDescription: string;
longDescription: string;
functionOffsets: number[];
instructions: Instruction[];
data: ArrayBufferCursor;
}
export function parseBin(cursor: ArrayBufferCursor): BinFile {
const objectCodeOffset = cursor.u32();
const functionOffsetTableOffset = 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 quest_number = cursor.u32(); const questNumber = cursor.u32();
const language = cursor.u32(); const language = cursor.u32();
const quest_name = cursor.string_utf_16(64, true, true); const questName = cursor.stringUtf16(64, true, true);
const short_description = cursor.string_utf_16(256, true, true); const shortDescription = cursor.stringUtf16(256, true, true);
const long_description = cursor.string_utf_16(576, true, true); const longDescription = cursor.stringUtf16(576, true, true);
if (size !== cursor.size) { if (size !== cursor.size) {
console.warn(`Value ${size} in bin size field does not match actual size ${cursor.size}.`); console.warn(`Value ${size} in bin size field does not match actual size ${cursor.size}.`);
} }
const function_offset_count = Math.floor( const functionOffsetCount = Math.floor(
(cursor.size - function_offset_table_offset) / 4); (cursor.size - functionOffsetTableOffset) / 4);
cursor.seek_start(function_offset_table_offset); cursor.seekStart(functionOffsetTableOffset);
const function_offsets = []; const functionOffsets = [];
for (let i = 0; i < function_offset_count; ++i) { for (let i = 0; i < functionOffsetCount; ++i) {
function_offsets.push(cursor.i32()); functionOffsets.push(cursor.i32());
} }
const instructions = parse_object_code( const instructions = parseObjectCode(
cursor.seek_start(object_code_offset).take(function_offset_table_offset - object_code_offset)); cursor.seekStart(objectCodeOffset).take(functionOffsetTableOffset - objectCodeOffset)
);
return { return {
quest_number, questNumber,
language, language,
quest_name, questName,
short_description, shortDescription,
long_description, longDescription,
function_offsets, functionOffsets,
instructions, instructions,
data: cursor.seek_start(0).take(cursor.size) data: cursor.seekStart(0).take(cursor.size)
}; };
} }
export function write_bin({ data }: { data: ArrayBufferCursor }): ArrayBufferCursor { export function writeBin({ data }: { data: ArrayBufferCursor }): ArrayBufferCursor {
return data.seek_start(0); return data.seekStart(0);
} }
export interface Instruction { export interface Instruction {
@ -51,35 +63,35 @@ export interface Instruction {
size: number; size: number;
} }
function parse_object_code(cursor: ArrayBufferCursor): Instruction[] { function parseObjectCode(cursor: ArrayBufferCursor): Instruction[] {
const instructions = []; const instructions = [];
while (cursor.bytes_left) { while (cursor.bytesLeft) {
const main_opcode = cursor.u8(); const mainOpcode = cursor.u8();
let opcode; let opcode;
let opsize; let opsize;
let list; let list;
switch (main_opcode) { switch (mainOpcode) {
case 0xF8: case 0xF8:
opcode = cursor.u8(); opcode = cursor.u8();
opsize = 2; opsize = 2;
list = F8opcode_list; list = F8opcodeList;
break; break;
case 0xF9: case 0xF9:
opcode = cursor.u8(); opcode = cursor.u8();
opsize = 2; opsize = 2;
list = F9opcode_list; list = F9opcodeList;
break; break;
default: default:
opcode = main_opcode; opcode = mainOpcode;
opsize = 1; opsize = 1;
list = opcode_list; list = opcodeList;
break; break;
} }
const [, mnemonic, mask] = list[opcode]; const [, mnemonic, mask] = list[opcode];
const opargs = parse_instruction_arguments(cursor, mask); const opargs = parseInstructionArguments(cursor, mask);
if (!opargs) { if (!opargs) {
console.error(`Parameters unknown for opcode 0x${opcode.toString(16).toUpperCase()}.`); console.error(`Parameters unknown for opcode 0x${opcode.toString(16).toUpperCase()}.`);
@ -97,12 +109,12 @@ function parse_object_code(cursor: ArrayBufferCursor): Instruction[] {
return instructions; return instructions;
} }
function parse_instruction_arguments(cursor: ArrayBufferCursor, mask: string | null) { function parseInstructionArguments(cursor: ArrayBufferCursor, mask: string | null) {
if (mask == null) { if (mask == null) {
return; return;
} }
const old_pos = cursor.position; const oldPos = cursor.position;
const args = []; const args = [];
let size = 0; let size = 0;
@ -191,11 +203,11 @@ function parse_instruction_arguments(cursor: ArrayBufferCursor, mask: string | n
} }
} }
cursor.seek_start(old_pos + size); cursor.seekStart(oldPos + size);
return { args, size }; return { args, size };
} }
const opcode_list: Array<[number, string, string | null]> = [ const opcodeList: Array<[number, string, string | null]> = [
[0x00, 'nop', ''], [0x00, 'nop', ''],
[0x01, 'ret', ''], [0x01, 'ret', ''],
[0x02, 'sync', ''], [0x02, 'sync', ''],
@ -476,7 +488,7 @@ const opcode_list: Array<[number, string, string | null]> = [
[0xFF, 'unknownFF', ''], [0xFF, 'unknownFF', ''],
]; ];
const F8opcode_list: Array<[number, string, string | null]> = [ const F8opcodeList: 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],
@ -735,7 +747,7 @@ const F8opcode_list: Array<[number, string, string | null]> = [
[0xFF, 'unknown', null], [0xFF, 'unknown', null],
]; ];
const F9opcode_list: Array<[number, string, string | null]> = [ const F9opcodeList: 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/parsing/dat.test.ts
View File

@ -1,23 +1,23 @@
import * as fs from 'fs'; import * as fs from 'fs';
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
import * as prs from '../compression/prs'; import * as prs from '../compression/prs';
import { parse_dat, write_dat } from './dat'; import { parseDat, writeDat } 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('parse_dat and write_dat', () => { test('parseDat and writeDat', () => {
const orig_buffer = fs.readFileSync('test/resources/quest118_e.dat').buffer; const origBuffer = fs.readFileSync('test/resources/quest118_e.dat').buffer;
const orig_dat = prs.decompress(new ArrayBufferCursor(orig_buffer, true)); const origDat = prs.decompress(new ArrayBufferCursor(origBuffer, true));
const test_dat = write_dat(parse_dat(orig_dat)); const testDat = writeDat(parseDat(origDat));
orig_dat.seek_start(0); origDat.seekStart(0);
expect(test_dat.size).toBe(orig_dat.size); expect(testDat.size).toBe(origDat.size);
let match = true; let match = true;
while (orig_dat.bytes_left) { while (origDat.bytesLeft) {
if (test_dat.u8() !== orig_dat.u8()) { if (testDat.u8() !== origDat.u8()) {
match = false; match = false;
break; break;
} }
@ -30,29 +30,29 @@ test('parse_dat and write_dat', () => {
* 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 orig_buffer = fs.readFileSync('./test/resources/quest118_e.dat').buffer; const origBuffer = fs.readFileSync('./test/resources/quest118_e.dat').buffer;
const orig_dat = prs.decompress(new ArrayBufferCursor(orig_buffer, true)); const origDat = prs.decompress(new ArrayBufferCursor(origBuffer, true));
const test_parsed = parse_dat(orig_dat); const testParsed = parseDat(origDat);
orig_dat.seek_start(0); origDat.seekStart(0);
test_parsed.objs[9].position.x = 13; testParsed.objs[9].position.x = 13;
test_parsed.objs[9].position.y = 17; testParsed.objs[9].position.y = 17;
test_parsed.objs[9].position.z = 19; testParsed.objs[9].position.z = 19;
const test_dat = write_dat(test_parsed); const testDat = writeDat(testParsed);
expect(test_dat.size).toBe(orig_dat.size); expect(testDat.size).toBe(origDat.size);
let match = true; let match = true;
while (orig_dat.bytes_left) { while (origDat.bytesLeft) {
if (orig_dat.position === 16 + 9 * 68 + 16) { if (origDat.position === 16 + 9 * 68 + 16) {
orig_dat.seek(12); origDat.seek(12);
expect(test_dat.f32()).toBe(13); expect(testDat.f32()).toBe(13);
expect(test_dat.f32()).toBe(17); expect(testDat.f32()).toBe(17);
expect(test_dat.f32()).toBe(19); expect(testDat.f32()).toBe(19);
} else if (test_dat.u8() !== orig_dat.u8()) { } else if (testDat.u8() !== origDat.u8()) {
match = false; match = false;
break; break;
} }

258
src/data/parsing/dat.ts
View File

@ -4,102 +4,132 @@ import { ArrayBufferCursor } from '../ArrayBufferCursor';
const OBJECT_SIZE = 68; const OBJECT_SIZE = 68;
const NPC_SIZE = 72; const NPC_SIZE = 72;
export function parse_dat(cursor: ArrayBufferCursor) { export interface DatFile {
const objs = []; objs: DatObject[];
const npcs = []; npcs: DatNpc[];
const unknowns = []; unknowns: DatUnknown[];
}
while (cursor.bytes_left) { interface DatEntity {
const entity_type = cursor.u32(); typeId: number;
const total_size = cursor.u32(); sectionId: number;
const area_id = cursor.u32(); position: { x: number, y: number, z: number };
const entities_size = cursor.u32(); rotation: { x: number, y: number, z: number };
areaId: number;
unknown: number[][];
}
if (entity_type === 0) { export interface DatObject extends DatEntity {
}
export interface DatNpc extends DatEntity {
skin: number;
}
export interface DatUnknown {
entityType: number;
totalSize: number;
areaId: number;
entitiesSize: number;
data: number[];
}
export function parseDat(cursor: ArrayBufferCursor): DatFile {
const objs: DatObject[] = [];
const npcs: DatNpc[] = [];
const unknowns: DatUnknown[] = [];
while (cursor.bytesLeft) {
const entityType = cursor.u32();
const totalSize = cursor.u32();
const areaId = cursor.u32();
const entitiesSize = cursor.u32();
if (entityType === 0) {
break; break;
} else { } else {
if (entities_size !== total_size - 16) { if (entitiesSize !== totalSize - 16) {
throw Error(`Malformed DAT file. Expected an entities size of ${total_size - 16}, got ${entities_size}.`); throw Error(`Malformed DAT file. Expected an entities size of ${totalSize - 16}, got ${entitiesSize}.`);
} }
if (entity_type === 1) { // Objects if (entityType === 1) { // Objects
const object_count = Math.floor(entities_size / OBJECT_SIZE); const objectCount = Math.floor(entitiesSize / OBJECT_SIZE);
const start_position = cursor.position; const startPosition = cursor.position;
for (let i = 0; i < object_count; ++i) { for (let i = 0; i < objectCount; ++i) {
const type_id = cursor.u16(); const typeId = cursor.u16();
const unknown1 = cursor.u8_array(10); const unknown1 = cursor.u8Array(10);
const section_id = cursor.u16(); const sectionId = cursor.u16();
const unknown2 = cursor.u8_array(2); const unknown2 = cursor.u8Array(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 rotation_x = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotationX = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotation_y = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotationY = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotation_z = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotationZ = 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.u8Array(28);
objs.push({ objs.push({
type_id, typeId,
section_id, sectionId,
position: { x, y, z }, position: { x, y, z },
rotation: { x: rotation_x, y: rotation_y, z: rotation_z }, rotation: { x: rotationX, y: rotationY, z: rotationZ },
area_id, areaId,
unknown: [unknown1, unknown2, unknown3] unknown: [unknown1, unknown2, unknown3]
}); });
} }
const bytes_read = cursor.position - start_position; const bytesRead = cursor.position - startPosition;
if (bytes_read !== entities_size) { if (bytesRead !== entitiesSize) {
console.warn(`Read ${bytes_read} bytes instead of expected ${entities_size} for entity type ${entity_type} (Object).`); console.warn(`Read ${bytesRead} bytes instead of expected ${entitiesSize} for entity type ${entityType} (Object).`);
cursor.seek(entities_size - bytes_read); cursor.seek(entitiesSize - bytesRead);
} }
} else if (entity_type === 2) { // NPCs } else if (entityType === 2) { // NPCs
const npc_count = Math.floor(entities_size / NPC_SIZE); const npcCount = Math.floor(entitiesSize / NPC_SIZE);
const start_position = cursor.position; const startPosition = cursor.position;
for (let i = 0; i < npc_count; ++i) { for (let i = 0; i < npcCount; ++i) {
const type_id = cursor.u16(); const typeId = cursor.u16();
const unknown1 = cursor.u8_array(10); const unknown1 = cursor.u8Array(10);
const section_id = cursor.u16(); const sectionId = cursor.u16();
const unknown2 = cursor.u8_array(6); const unknown2 = cursor.u8Array(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 rotation_x = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotationX = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotation_y = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotationY = cursor.i32() / 0xFFFF * 2 * Math.PI;
const rotation_z = cursor.i32() / 0xFFFF * 2 * Math.PI; const rotationZ = cursor.i32() / 0xFFFF * 2 * Math.PI;
const unknown3 = cursor.u8_array(20); const unknown3 = cursor.u8Array(20);
const skin = cursor.u32(); const skin = cursor.u32();
const unknown4 = cursor.u8_array(4); const unknown4 = cursor.u8Array(4);
npcs.push({ npcs.push({
type_id, typeId,
section_id, sectionId,
position: { x, y, z }, position: { x, y, z },
rotation: { x: rotation_x, y: rotation_y, z: rotation_z }, rotation: { x: rotationX, y: rotationY, z: rotationZ },
skin, skin,
area_id, areaId,
unknown: [unknown1, unknown2, unknown3, unknown4] unknown: [unknown1, unknown2, unknown3, unknown4]
}); });
} }
const bytes_read = cursor.position - start_position; const bytesRead = cursor.position - startPosition;
if (bytes_read !== entities_size) { if (bytesRead !== entitiesSize) {
console.warn(`Read ${bytes_read} bytes instead of expected ${entities_size} for entity type ${entity_type} (NPC).`); console.warn(`Read ${bytesRead} bytes instead of expected ${entitiesSize} for entity type ${entityType} (NPC).`);
cursor.seek(entities_size - bytes_read); cursor.seek(entitiesSize - bytesRead);
} }
} 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({
entity_type, entityType,
total_size, totalSize,
area_id, areaId,
entities_size, entitiesSize,
data: cursor.u8_array(entities_size) data: cursor.u8Array(entitiesSize)
}); });
} }
} }
@ -108,85 +138,83 @@ export function parse_dat(cursor: ArrayBufferCursor) {
return { objs, npcs, unknowns }; return { objs, npcs, unknowns };
} }
export function write_dat( export function writeDat({ objs, npcs, unknowns }: DatFile): ArrayBufferCursor {
{objs, npcs, unknowns}: { objs: any[], npcs: any[], unknowns: any[] }
): ArrayBufferCursor {
const cursor = new ArrayBufferCursor( const cursor = new ArrayBufferCursor(
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 grouped_objs = groupBy(objs, obj => obj.area_id); const groupedObjs = groupBy(objs, obj => obj.areaId);
const obj_area_ids = Object.keys(grouped_objs) const objAreaIds = Object.keys(groupedObjs)
.map(key => parseInt(key, 10)) .map(key => parseInt(key, 10))
.sort((a, b) => a - b); .sort((a, b) => a - b);
for (const area_id of obj_area_ids) { for (const areaId of objAreaIds) {
const area_objs = grouped_objs[area_id]; const areaObjs = groupedObjs[areaId];
const entities_size = area_objs.length * OBJECT_SIZE; const entitiesSize = areaObjs.length * OBJECT_SIZE;
cursor.write_u32(1); // Entity type cursor.writeU32(1); // Entity type
cursor.write_u32(entities_size + 16); cursor.writeU32(entitiesSize + 16);
cursor.write_u32(area_id); cursor.writeU32(areaId);
cursor.write_u32(entities_size); cursor.writeU32(entitiesSize);
for (const obj of area_objs) { for (const obj of areaObjs) {
cursor.write_u16(obj.type_id); cursor.writeU16(obj.typeId);
cursor.write_u8_array(obj.unknown[0]); cursor.writeU8Array(obj.unknown[0]);
cursor.write_u16(obj.section_id); cursor.writeU16(obj.sectionId);
cursor.write_u8_array(obj.unknown[1]); cursor.writeU8Array(obj.unknown[1]);
cursor.write_f32(obj.position.x); cursor.writeF32(obj.position.x);
cursor.write_f32(obj.position.y); cursor.writeF32(obj.position.y);
cursor.write_f32(obj.position.z); cursor.writeF32(obj.position.z);
cursor.write_i32(Math.round(obj.rotation.x / (2 * Math.PI) * 0xFFFF)); cursor.writeI32(Math.round(obj.rotation.x / (2 * Math.PI) * 0xFFFF));
cursor.write_i32(Math.round(obj.rotation.y / (2 * Math.PI) * 0xFFFF)); cursor.writeI32(Math.round(obj.rotation.y / (2 * Math.PI) * 0xFFFF));
cursor.write_i32(Math.round(obj.rotation.z / (2 * Math.PI) * 0xFFFF)); cursor.writeI32(Math.round(obj.rotation.z / (2 * Math.PI) * 0xFFFF));
cursor.write_u8_array(obj.unknown[2]); cursor.writeU8Array(obj.unknown[2]);
} }
} }
const grouped_npcs = groupBy(npcs, npc => npc.area_id); const groupedNpcs = groupBy(npcs, npc => npc.areaId);
const npc_area_ids = Object.keys(grouped_npcs) const npcAreaIds = Object.keys(groupedNpcs)
.map(key => parseInt(key, 10)) .map(key => parseInt(key, 10))
.sort((a, b) => a - b); .sort((a, b) => a - b);
for (const area_id of npc_area_ids) { for (const areaId of npcAreaIds) {
const area_npcs = grouped_npcs[area_id]; const areaNpcs = groupedNpcs[areaId];
const entities_size = area_npcs.length * NPC_SIZE; const entitiesSize = areaNpcs.length * NPC_SIZE;
cursor.write_u32(2); // Entity type cursor.writeU32(2); // Entity type
cursor.write_u32(entities_size + 16); cursor.writeU32(entitiesSize + 16);
cursor.write_u32(area_id); cursor.writeU32(areaId);
cursor.write_u32(entities_size); cursor.writeU32(entitiesSize);
for (const npc of area_npcs) { for (const npc of areaNpcs) {
cursor.write_u16(npc.type_id); cursor.writeU16(npc.typeId);
cursor.write_u8_array(npc.unknown[0]); cursor.writeU8Array(npc.unknown[0]);
cursor.write_u16(npc.section_id); cursor.writeU16(npc.sectionId);
cursor.write_u8_array(npc.unknown[1]); cursor.writeU8Array(npc.unknown[1]);
cursor.write_f32(npc.position.x); cursor.writeF32(npc.position.x);
cursor.write_f32(npc.position.y); cursor.writeF32(npc.position.y);
cursor.write_f32(npc.position.z); cursor.writeF32(npc.position.z);
cursor.write_i32(Math.round(npc.rotation.x / (2 * Math.PI) * 0xFFFF)); cursor.writeI32(Math.round(npc.rotation.x / (2 * Math.PI) * 0xFFFF));
cursor.write_i32(Math.round(npc.rotation.y / (2 * Math.PI) * 0xFFFF)); cursor.writeI32(Math.round(npc.rotation.y / (2 * Math.PI) * 0xFFFF));
cursor.write_i32(Math.round(npc.rotation.z / (2 * Math.PI) * 0xFFFF)); cursor.writeI32(Math.round(npc.rotation.z / (2 * Math.PI) * 0xFFFF));
cursor.write_u8_array(npc.unknown[2]); cursor.writeU8Array(npc.unknown[2]);
cursor.write_u32(npc.skin); cursor.writeU32(npc.skin);
cursor.write_u8_array(npc.unknown[3]); cursor.writeU8Array(npc.unknown[3]);
} }
} }
for (const unknown of unknowns) { for (const unknown of unknowns) {
cursor.write_u32(unknown.entity_type); cursor.writeU32(unknown.entityType);
cursor.write_u32(unknown.total_size); cursor.writeU32(unknown.totalSize);
cursor.write_u32(unknown.area_id); cursor.writeU32(unknown.areaId);
cursor.write_u32(unknown.entities_size); cursor.writeU32(unknown.entitiesSize);
cursor.write_u8_array(unknown.data); cursor.writeU8Array(unknown.data);
} }
// Final header. // Final header.
cursor.write_u32(0); cursor.writeU32(0);
cursor.write_u32(0); cursor.writeU32(0);
cursor.write_u32(0); cursor.writeU32(0);
cursor.write_u32(0); cursor.writeU32(0);
cursor.seek_start(0); cursor.seekStart(0);
return cursor; return cursor;
} }

255
src/data/parsing/geometry.ts
View File

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

114
src/data/parsing/ninja/index.ts
View File

@ -7,42 +7,42 @@ import {
Vector3 Vector3
} from 'three'; } from 'three';
import { ArrayBufferCursor } from '../../ArrayBufferCursor'; import { ArrayBufferCursor } from '../../ArrayBufferCursor';
import { parse_nj_model, NjContext } from './nj'; import { parseNjModel, NjContext } from './nj';
import { parse_xj_model, XjContext } from './xj'; import { parseXjModel, XjContext } from './xj';
// TODO: // TODO:
// - deal with multiple NJCM chunks // - deal with multiple NJCM chunks
// - deal with other types of chunks // - deal with other types of chunks
export function parse_nj(cursor: ArrayBufferCursor): BufferGeometry | undefined { export function parseNj(cursor: ArrayBufferCursor): BufferGeometry | undefined {
return parse_ninja(cursor, 'nj'); return parseNinja(cursor, 'nj');
} }
export function parse_xj(cursor: ArrayBufferCursor): BufferGeometry | undefined { export function parseXj(cursor: ArrayBufferCursor): BufferGeometry | undefined {
return parse_ninja(cursor, 'xj'); return parseNinja(cursor, 'xj');
} }
type Format = 'nj' | 'xj'; type Format = 'nj' | 'xj';
type Context = NjContext | XjContext; type Context = NjContext | XjContext;
function parse_ninja(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined { function parseNinja(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined {
while (cursor.bytes_left) { while (cursor.bytesLeft) {
// Ninja uses a little endian variant of the IFF format. // Ninja uses a little endian variant of the IFF format.
// IFF files contain chunks preceded by an 8-byte header. // IFF files contain chunks preceded by an 8-byte header.
// The header consists of 4 ASCII characters for the "Type ID" and a 32-bit integer specifying the chunk size. // The header consists of 4 ASCII characters for the "Type ID" and a 32-bit integer specifying the chunk size.
const iff_type_id = cursor.string_ascii(4, false, false); const iffTypeId = cursor.stringAscii(4, false, false);
const iff_chunk_size = cursor.u32(); const iffChunkSize = cursor.u32();
if (iff_type_id === 'NJCM') { if (iffTypeId === 'NJCM') {
return parse_njcm(cursor.take(iff_chunk_size), format); return parseNjcm(cursor.take(iffChunkSize), format);
} else { } else {
cursor.seek(iff_chunk_size); cursor.seek(iffChunkSize);
} }
} }
} }
function parse_njcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined { function parseNjcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined {
if (cursor.bytes_left) { if (cursor.bytesLeft) {
let context: Context; let context: Context;
if (format === 'nj') { if (format === 'nj') {
@ -50,7 +50,7 @@ function parse_njcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry |
format, format,
positions: [], positions: [],
normals: [], normals: [],
cached_chunk_offsets: [], cachedChunkOffsets: [],
vertices: [] vertices: []
}; };
} else { } else {
@ -62,63 +62,63 @@ function parse_njcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry |
}; };
} }
parse_sibling_objects(cursor, new Matrix4(), context); parseSiblingObjects(cursor, new Matrix4(), context);
return create_buffer_geometry(context); return createBufferGeometry(context);
} }
} }
function parse_sibling_objects( function parseSiblingObjects(
cursor: ArrayBufferCursor, cursor: ArrayBufferCursor,
parent_matrix: Matrix4, parentMatrix: Matrix4,
context: Context context: Context
): void { ): void {
const eval_flags = cursor.u32(); const evalFlags = cursor.u32();
const no_translate = (eval_flags & 0b1) !== 0; const noTranslate = (evalFlags & 0b1) !== 0;
const no_rotate = (eval_flags & 0b10) !== 0; const noRotate = (evalFlags & 0b10) !== 0;
const no_scale = (eval_flags & 0b100) !== 0; const noScale = (evalFlags & 0b100) !== 0;
const hidden = (eval_flags & 0b1000) !== 0; const hidden = (evalFlags & 0b1000) !== 0;
const break_child_trace = (eval_flags & 0b10000) !== 0; const breakChildTrace = (evalFlags & 0b10000) !== 0;
const zxy_rotation_order = (eval_flags & 0b100000) !== 0; const zxyRotationOrder = (evalFlags & 0b100000) !== 0;
const model_offset = cursor.u32(); const modelOffset = cursor.u32();
const pos_x = cursor.f32(); const posX = cursor.f32();
const pos_y = cursor.f32(); const posY = cursor.f32();
const pos_z = cursor.f32(); const posZ = cursor.f32();
const rotation_x = cursor.i32() * (2 * Math.PI / 0xFFFF); const rotationX = cursor.i32() * (2 * Math.PI / 0xFFFF);
const rotation_y = cursor.i32() * (2 * Math.PI / 0xFFFF); const rotationY = cursor.i32() * (2 * Math.PI / 0xFFFF);
const rotation_z = cursor.i32() * (2 * Math.PI / 0xFFFF); const rotationZ = cursor.i32() * (2 * Math.PI / 0xFFFF);
const scale_x = cursor.f32(); const scaleX = cursor.f32();
const scale_y = cursor.f32(); const scaleY = cursor.f32();
const scale_z = cursor.f32(); const scaleZ = cursor.f32();
const child_offset = cursor.u32(); const childOffset = cursor.u32();
const sibling_offset = cursor.u32(); const siblingOffset = cursor.u32();
const rotation = new Euler(rotation_x, rotation_y, rotation_z, zxy_rotation_order ? 'ZXY' : 'ZYX'); const rotation = new Euler(rotationX, rotationY, rotationZ, zxyRotationOrder ? 'ZXY' : 'ZYX');
const matrix = new Matrix4() const matrix = new Matrix4()
.compose( .compose(
no_translate ? new Vector3() : new Vector3(pos_x, pos_y, pos_z), noTranslate ? new Vector3() : new Vector3(posX, posY, posZ),
no_rotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation), noRotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation),
no_scale ? new Vector3(1, 1, 1) : new Vector3(scale_x, scale_y, scale_z) noScale ? new Vector3(1, 1, 1) : new Vector3(scaleX, scaleY, scaleZ)
) )
.premultiply(parent_matrix); .premultiply(parentMatrix);
if (model_offset && !hidden) { if (modelOffset && !hidden) {
cursor.seek_start(model_offset); cursor.seekStart(modelOffset);
parse_model(cursor, matrix, context); parseModel(cursor, matrix, context);
} }
if (child_offset && !break_child_trace) { if (childOffset && !breakChildTrace) {
cursor.seek_start(child_offset); cursor.seekStart(childOffset);
parse_sibling_objects(cursor, matrix, context); parseSiblingObjects(cursor, matrix, context);
} }
if (sibling_offset) { if (siblingOffset) {
cursor.seek_start(sibling_offset); cursor.seekStart(siblingOffset);
parse_sibling_objects(cursor, parent_matrix, context); parseSiblingObjects(cursor, parentMatrix, context);
} }
} }
function create_buffer_geometry(context: Context): BufferGeometry { function createBufferGeometry(context: Context): BufferGeometry {
const geometry = new BufferGeometry(); const geometry = new BufferGeometry();
geometry.addAttribute('position', new BufferAttribute(new Float32Array(context.positions), 3)); geometry.addAttribute('position', new BufferAttribute(new Float32Array(context.positions), 3));
geometry.addAttribute('normal', new BufferAttribute(new Float32Array(context.normals), 3)); geometry.addAttribute('normal', new BufferAttribute(new Float32Array(context.normals), 3));
@ -130,10 +130,10 @@ function create_buffer_geometry(context: Context): BufferGeometry {
return geometry; return geometry;
} }
function parse_model(cursor: ArrayBufferCursor, matrix: Matrix4, context: Context): void { function parseModel(cursor: ArrayBufferCursor, matrix: Matrix4, context: Context): void {
if (context.format === 'nj') { if (context.format === 'nj') {
parse_nj_model(cursor, matrix, context); parseNjModel(cursor, matrix, context);
} else { } else {
parse_xj_model(cursor, matrix, context); parseXjModel(cursor, matrix, context);
} }
} }

195
src/data/parsing/ninja/nj.ts
View File

@ -14,7 +14,7 @@ export interface NjContext {
format: 'nj'; format: 'nj';
positions: number[]; positions: number[];
normals: number[]; normals: number[];
cached_chunk_offsets: number[]; cachedChunkOffsets: number[];
vertices: { position: Vector3, normal: Vector3 }[]; vertices: { position: Vector3, normal: Vector3 }[];
} }
@ -32,47 +32,47 @@ interface ChunkVertex {
} }
interface ChunkTriangleStrip { interface ChunkTriangleStrip {
clockwise_winding: boolean; clockwiseWinding: boolean;
indices: number[]; indices: number[];
} }
export function parse_nj_model(cursor: ArrayBufferCursor, matrix: Matrix4, context: NjContext): void { export function parseNjModel(cursor: ArrayBufferCursor, matrix: Matrix4, context: NjContext): void {
const { positions, normals, cached_chunk_offsets, vertices } = context; const { positions, normals, cachedChunkOffsets, vertices } = context;
const vlist_offset = cursor.u32(); // Vertex list const vlistOffset = cursor.u32(); // Vertex list
const plist_offset = cursor.u32(); // Triangle strip index list const plistOffset = cursor.u32(); // Triangle strip index list
const normal_matrix = new Matrix3().getNormalMatrix(matrix); const normalMatrix = new Matrix3().getNormalMatrix(matrix);
if (vlist_offset) { if (vlistOffset) {
cursor.seek_start(vlist_offset); cursor.seekStart(vlistOffset);
for (const chunk of parse_chunks(cursor, cached_chunk_offsets, true)) { for (const chunk of parseChunks(cursor, cachedChunkOffsets, true)) {
if (chunk.chunk_type === 'VERTEX') { if (chunk.chunkType === 'VERTEX') {
const chunk_vertices: ChunkVertex[] = chunk.data; const chunkVertices: ChunkVertex[] = chunk.data;
for (const vertex of chunk_vertices) { for (const vertex of chunkVertices) {
const position = new Vector3(...vertex.position).applyMatrix4(matrix); const position = new Vector3(...vertex.position).applyMatrix4(matrix);
const normal = vertex.normal ? new Vector3(...vertex.normal).applyMatrix3(normal_matrix) : new Vector3(0, 1, 0); const normal = vertex.normal ? new Vector3(...vertex.normal).applyMatrix3(normalMatrix) : new Vector3(0, 1, 0);
vertices[vertex.index] = { position, normal }; vertices[vertex.index] = { position, normal };
} }
} }
} }
} }
if (plist_offset) { if (plistOffset) {
cursor.seek_start(plist_offset); cursor.seekStart(plistOffset);
for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) { for (const chunk of parseChunks(cursor, cachedChunkOffsets, false)) {
if (chunk.chunk_type === 'STRIP') { if (chunk.chunkType === 'STRIP') {
for (const { clockwise_winding, indices: strip_indices } of chunk.data) { for (const { clockwiseWinding, indices: stripIndices } of chunk.data) {
for (let j = 2; j < strip_indices.length; ++j) { for (let j = 2; j < stripIndices.length; ++j) {
const a = vertices[strip_indices[j - 2]]; const a = vertices[stripIndices[j - 2]];
const b = vertices[strip_indices[j - 1]]; const b = vertices[stripIndices[j - 1]];
const c = vertices[strip_indices[j]]; const c = vertices[stripIndices[j]];
if (a && b && c) { if (a && b && c) {
if (j % 2 === (clockwise_winding ? 1 : 0)) { if (j % 2 === (clockwiseWinding ? 1 : 0)) {
positions.splice(positions.length, 0, a.position.x, a.position.y, a.position.z); positions.splice(positions.length, 0, a.position.x, a.position.y, a.position.z);
positions.splice(positions.length, 0, b.position.x, b.position.y, b.position.z); positions.splice(positions.length, 0, b.position.x, b.position.y, b.position.z);
positions.splice(positions.length, 0, c.position.x, c.position.y, c.position.z); positions.splice(positions.length, 0, c.position.x, c.position.y, c.position.z);
@ -95,73 +95,78 @@ export function parse_nj_model(cursor: ArrayBufferCursor, matrix: Matrix4, conte
} }
} }
function parse_chunks(cursor: ArrayBufferCursor, cached_chunk_offsets: number[], wide_end_chunks: boolean): any[] { function parseChunks(cursor: ArrayBufferCursor, cachedChunkOffsets: number[], wideEndChunks: boolean): Array<{
chunkType: string,
chunkSubType: string | null,
chunkTypeId: number,
data: any
}> {
const chunks = []; const chunks = [];
let loop = true; let loop = true;
while (loop) { while (loop) {
const chunk_type_id = cursor.u8(); const chunkTypeId = cursor.u8();
const flags = cursor.u8(); const flags = cursor.u8();
const chunk_start_position = cursor.position; const chunkStartPosition = cursor.position;
let chunk_type = 'UNKOWN'; let chunkType = 'UNKOWN';
let chunk_sub_type = null; let chunkSubType = null;
let data = null; let data = null;
let size = 0; let size = 0;
if (chunk_type_id === 0) { if (chunkTypeId === 0) {
chunk_type = 'NULL'; chunkType = 'NULL';
} else if (1 <= chunk_type_id && chunk_type_id <= 5) { } else if (1 <= chunkTypeId && chunkTypeId <= 5) {
chunk_type = 'BITS'; chunkType = 'BITS';
if (chunk_type_id === 4) { if (chunkTypeId === 4) {
chunk_sub_type = 'CACHE_POLYGON_LIST'; chunkSubType = 'CACHE_POLYGON_LIST';
data = { data = {
store_index: flags, storeIndex: flags,
offset: cursor.position offset: cursor.position
}; };
cached_chunk_offsets[data.store_index] = data.offset; cachedChunkOffsets[data.storeIndex] = data.offset;
loop = false; loop = false;
} else if (chunk_type_id === 5) { } else if (chunkTypeId === 5) {
chunk_sub_type = 'DRAW_POLYGON_LIST'; chunkSubType = 'DRAW_POLYGON_LIST';
data = { data = {
store_index: flags storeIndex: flags
}; };
cursor.seek_start(cached_chunk_offsets[data.store_index]); cursor.seekStart(cachedChunkOffsets[data.storeIndex]);
chunks.splice(chunks.length, 0, ...parse_chunks(cursor, cached_chunk_offsets, wide_end_chunks)); chunks.splice(chunks.length, 0, ...parseChunks(cursor, cachedChunkOffsets, wideEndChunks));
} }
} else if (8 <= chunk_type_id && chunk_type_id <= 9) { } else if (8 <= chunkTypeId && chunkTypeId <= 9) {
chunk_type = 'TINY'; chunkType = 'TINY';
size = 2; size = 2;
} else if (17 <= chunk_type_id && chunk_type_id <= 31) { } else if (17 <= chunkTypeId && chunkTypeId <= 31) {
chunk_type = 'MATERIAL'; chunkType = 'MATERIAL';
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
} else if (32 <= chunk_type_id && chunk_type_id <= 50) { } else if (32 <= chunkTypeId && chunkTypeId <= 50) {
chunk_type = 'VERTEX'; chunkType = 'VERTEX';
size = 2 + 4 * cursor.u16(); size = 2 + 4 * cursor.u16();
data = parse_chunk_vertex(cursor, chunk_type_id, flags); data = parseChunkVertex(cursor, chunkTypeId, flags);
} else if (56 <= chunk_type_id && chunk_type_id <= 58) { } else if (56 <= chunkTypeId && chunkTypeId <= 58) {
chunk_type = 'VOLUME'; chunkType = 'VOLUME';
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
} else if (64 <= chunk_type_id && chunk_type_id <= 75) { } else if (64 <= chunkTypeId && chunkTypeId <= 75) {
chunk_type = 'STRIP'; chunkType = 'STRIP';
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
data = parse_chunk_triangle_strip(cursor, chunk_type_id); data = parseChunkTriangleStrip(cursor, chunkTypeId);
} else if (chunk_type_id === 255) { } else if (chunkTypeId === 255) {
chunk_type = 'END'; chunkType = 'END';
size = wide_end_chunks ? 2 : 0; size = wideEndChunks ? 2 : 0;
loop = false; loop = false;
} else { } else {
// Ignore unknown chunks. // Ignore unknown chunks.
console.warn(`Unknown chunk type: ${chunk_type_id}.`); console.warn(`Unknown chunk type: ${chunkTypeId}.`);
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
} }
cursor.seek_start(chunk_start_position + size); cursor.seekStart(chunkStartPosition + size);
chunks.push({ chunks.push({
chunk_type, chunkType,
chunk_sub_type, chunkSubType,
chunk_type_id, chunkTypeId,
data data
}); });
} }
@ -169,18 +174,18 @@ function parse_chunks(cursor: ArrayBufferCursor, cached_chunk_offsets: number[],
return chunks; return chunks;
} }
function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, flags: number): ChunkVertex[] { function parseChunkVertex(cursor: ArrayBufferCursor, chunkTypeId: number, flags: number): ChunkVertex[] {
// There are apparently 4 different sets of vertices, ignore all but set 0. // There are apparently 4 different sets of vertices, ignore all but set 0.
if ((flags & 0b11) !== 0) { if ((flags & 0b11) !== 0) {
return []; return [];
} }
const index = cursor.u16(); const index = cursor.u16();
const vertex_count = cursor.u16(); const vertexCount = cursor.u16();
const vertices: ChunkVertex[] = []; const vertices: ChunkVertex[] = [];
for (let i = 0; i < vertex_count; ++i) { for (let i = 0; i < vertexCount; ++i) {
const vertex: ChunkVertex = { const vertex: ChunkVertex = {
index: index + i, index: index + i,
position: [ position: [
@ -190,9 +195,9 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl
] ]
}; };
if (chunk_type_id === 32) { if (chunkTypeId === 32) {
cursor.seek(4); // Always 1.0 cursor.seek(4); // Always 1.0
} else if (chunk_type_id === 33) { } else if (chunkTypeId === 33) {
cursor.seek(4); // Always 1.0 cursor.seek(4); // Always 1.0
vertex.normal = [ vertex.normal = [
cursor.f32(), // x cursor.f32(), // x
@ -200,8 +205,8 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl
cursor.f32(), // z cursor.f32(), // z
]; ];
cursor.seek(4); // Always 0.0 cursor.seek(4); // Always 0.0
} else if (35 <= chunk_type_id && chunk_type_id <= 40) { } else if (35 <= chunkTypeId && chunkTypeId <= 40) {
if (chunk_type_id === 37) { if (chunkTypeId === 37) {
// Ninja flags // Ninja flags
vertex.index = index + cursor.u16(); vertex.index = index + cursor.u16();
cursor.seek(2); cursor.seek(2);
@ -209,15 +214,15 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl
// Skip user flags and material information. // Skip user flags and material information.
cursor.seek(4); cursor.seek(4);
} }
} else if (41 <= chunk_type_id && chunk_type_id <= 47) { } else if (41 <= chunkTypeId && chunkTypeId <= 47) {
vertex.normal = [ vertex.normal = [
cursor.f32(), // x cursor.f32(), // x
cursor.f32(), // y cursor.f32(), // y
cursor.f32(), // z cursor.f32(), // z
]; ];
if (chunk_type_id >= 42) { if (chunkTypeId >= 42) {
if (chunk_type_id === 44) { if (chunkTypeId === 44) {
// Ninja flags // Ninja flags
vertex.index = index + cursor.u16(); vertex.index = index + cursor.u16();
cursor.seek(2); cursor.seek(2);
@ -226,11 +231,11 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl
cursor.seek(4); cursor.seek(4);
} }
} }
} else if (chunk_type_id >= 48) { } else if (chunkTypeId >= 48) {
// Skip 32-bit vertex normal in format: reserved(2)|x(10)|y(10)|z(10) // Skip 32-bit vertex normal in format: reserved(2)|x(10)|y(10)|z(10)
cursor.seek(4); cursor.seek(4);
if (chunk_type_id >= 49) { if (chunkTypeId >= 49) {
// Skip user flags and material information. // Skip user flags and material information.
cursor.seek(4); cursor.seek(4);
} }
@ -242,13 +247,13 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl
return vertices; return vertices;
} }
function parse_chunk_triangle_strip(cursor: ArrayBufferCursor, chunk_type_id: number): ChunkTriangleStrip[] { function parseChunkTriangleStrip(cursor: ArrayBufferCursor, chunkTypeId: number): ChunkTriangleStrip[] {
const user_offset_and_strip_count = cursor.u16(); const userOffsetAndStripCount = cursor.u16();
const user_flags_size = user_offset_and_strip_count >>> 14; const userFlagsSize = userOffsetAndStripCount >>> 14;
const strip_count = user_offset_and_strip_count & 0x3FFF; const stripCount = userOffsetAndStripCount & 0x3FFF;
let options; let options;
switch (chunk_type_id) { switch (chunkTypeId) {
case 64: options = [false, false, false, false]; break; case 64: options = [false, false, false, false]; break;
case 65: options = [true, false, false, false]; break; case 65: options = [true, false, false, false]; break;
case 66: options = [true, false, false, false]; break; case 66: options = [true, false, false, false]; break;
@ -261,50 +266,50 @@ function parse_chunk_triangle_strip(cursor: ArrayBufferCursor, chunk_type_id: nu
case 73: options = [false, false, false, false]; break; case 73: options = [false, false, false, false]; break;
case 74: options = [true, false, false, true]; break; case 74: options = [true, false, false, true]; break;
case 75: options = [true, false, false, true]; break; case 75: options = [true, false, false, true]; break;
default: throw new Error(`Unexpected chunk type ID: ${chunk_type_id}.`); default: throw new Error(`Unexpected chunk type ID: ${chunkTypeId}.`);
} }
const [ const [
parse_texture_coords, parseTextureCoords,
parse_color, parseColor,
parse_normal, parseNormal,
parse_texture_coords_hires parseTextureCoordsHires
] = options; ] = options;
const strips = []; const strips = [];
for (let i = 0; i < strip_count; ++i) { for (let i = 0; i < stripCount; ++i) {
const winding_flag_and_index_count = cursor.i16(); const windingFlagAndIndexCount = cursor.i16();
const clockwise_winding = winding_flag_and_index_count < 1; const clockwiseWinding = windingFlagAndIndexCount < 1;
const index_count = Math.abs(winding_flag_and_index_count); const indexCount = Math.abs(windingFlagAndIndexCount);
const indices = []; const indices = [];
for (let j = 0; j < index_count; ++j) { for (let j = 0; j < indexCount; ++j) {
indices.push(cursor.u16()); indices.push(cursor.u16());
if (parse_texture_coords) { if (parseTextureCoords) {
cursor.seek(4); cursor.seek(4);
} }
if (parse_color) { if (parseColor) {
cursor.seek(4); cursor.seek(4);
} }
if (parse_normal) { if (parseNormal) {
cursor.seek(6); cursor.seek(6);
} }
if (parse_texture_coords_hires) { if (parseTextureCoordsHires) {
cursor.seek(8); cursor.seek(8);
} }
if (j >= 2) { if (j >= 2) {
cursor.seek(2 * user_flags_size); cursor.seek(2 * userFlagsSize);
} }
} }
strips.push({ clockwise_winding, indices }); strips.push({ clockwiseWinding, indices });
} }
return strips; return strips;

90
src/data/parsing/ninja/xj.ts
View File

@ -14,30 +14,30 @@ export interface XjContext {
indices: number[]; indices: number[];
} }
export function parse_xj_model(cursor: ArrayBufferCursor, matrix: Matrix4, context: XjContext): void { export function parseXjModel(cursor: ArrayBufferCursor, matrix: Matrix4, context: XjContext): void {
const { positions, normals, indices } = context; const { positions, normals, indices } = context;
cursor.seek(4); // Flags according to QEdit, seemingly always 0. cursor.seek(4); // Flags according to QEdit, seemingly always 0.
const vertex_info_list_offset = cursor.u32(); const vertexInfoListOffset = cursor.u32();
cursor.seek(4); // Seems to be the vertex_info_count, always 1. cursor.seek(4); // Seems to be the vertexInfoCount, always 1.
const triangle_strip_list_a_offset = cursor.u32(); const triangleStripListAOffset = cursor.u32();
const triangle_strip_a_count = cursor.u32(); const triangleStripACount = cursor.u32();
const triangle_strip_list_b_offset = cursor.u32(); const triangleStripListBOffset = cursor.u32();
const triangle_strip_b_count = cursor.u32(); const triangleStripBCount = cursor.u32();
cursor.seek(16); // Bounding sphere position and radius in floats. cursor.seek(16); // Bounding sphere position and radius in floats.
const normal_matrix = new Matrix3().getNormalMatrix(matrix); const normalMatrix = new Matrix3().getNormalMatrix(matrix);
const index_offset = positions.length / 3; const indexOffset = positions.length / 3;
if (vertex_info_list_offset) { if (vertexInfoListOffset) {
cursor.seek_start(vertex_info_list_offset); cursor.seekStart(vertexInfoListOffset);
cursor.seek(4); // Possibly the vertex type. cursor.seek(4); // Possibly the vertex type.
const vertex_list_offset = cursor.u32(); const vertexListOffset = cursor.u32();
const vertex_size = cursor.u32(); const vertexSize = cursor.u32();
const vertex_count = cursor.u32(); const vertexCount = cursor.u32();
for (let i = 0; i < vertex_count; ++i) { for (let i = 0; i < vertexCount; ++i) {
cursor.seek_start(vertex_list_offset + i * vertex_size); cursor.seekStart(vertexListOffset + i * vertexSize);
const position = new Vector3( const position = new Vector3(
cursor.f32(), cursor.f32(),
cursor.f32(), cursor.f32(),
@ -45,12 +45,12 @@ export function parse_xj_model(cursor: ArrayBufferCursor, matrix: Matrix4, conte
).applyMatrix4(matrix); ).applyMatrix4(matrix);
let normal; let normal;
if (vertex_size === 28 || vertex_size === 32 || vertex_size === 36) { if (vertexSize === 28 || vertexSize === 32 || vertexSize === 36) {
normal = new Vector3( normal = new Vector3(
cursor.f32(), cursor.f32(),
cursor.f32(), cursor.f32(),
cursor.f32() cursor.f32()
).applyMatrix3(normal_matrix); ).applyMatrix3(normalMatrix);
} else { } else {
normal = new Vector3(0, 1, 0); normal = new Vector3(0, 1, 0);
} }
@ -64,53 +64,55 @@ export function parse_xj_model(cursor: ArrayBufferCursor, matrix: Matrix4, conte
} }
} }
if (triangle_strip_list_a_offset) { if (triangleStripListAOffset) {
parse_triangle_strip_list( parseTriangleStripList(
cursor, cursor,
triangle_strip_list_a_offset, triangleStripListAOffset,
triangle_strip_a_count, triangleStripACount,
positions, positions,
normals, normals,
indices, indices,
index_offset); indexOffset
);
} }
if (triangle_strip_list_b_offset) { if (triangleStripListBOffset) {
parse_triangle_strip_list( parseTriangleStripList(
cursor, cursor,
triangle_strip_list_b_offset, triangleStripListBOffset,
triangle_strip_b_count, triangleStripBCount,
positions, positions,
normals, normals,
indices, indices,
index_offset); indexOffset
);
} }
} }
function parse_triangle_strip_list( function parseTriangleStripList(
cursor: ArrayBufferCursor, cursor: ArrayBufferCursor,
triangle_strip_list_offset: number, triangleStripListOffset: number,
triangle_strip_count: number, triangleStripCount: number,
positions: number[], positions: number[],
normals: number[], normals: number[],
indices: number[], indices: number[],
index_offset: number indexOffset: number
): void { ): void {
for (let i = 0; i < triangle_strip_count; ++i) { for (let i = 0; i < triangleStripCount; ++i) {
cursor.seek_start(triangle_strip_list_offset + i * 20); cursor.seekStart(triangleStripListOffset + i * 20);
cursor.seek(8); // Skip material information. cursor.seek(8); // Skip material information.
const index_list_offset = cursor.u32(); const indexListOffset = cursor.u32();
const index_count = cursor.u32(); const indexCount = cursor.u32();
// Ignoring 4 bytes. // Ignoring 4 bytes.
cursor.seek_start(index_list_offset); cursor.seekStart(indexListOffset);
const strip_indices = cursor.u16_array(index_count); const stripIndices = cursor.u16Array(indexCount);
let clockwise = true; let clockwise = true;
for (let j = 2; j < strip_indices.length; ++j) { for (let j = 2; j < stripIndices.length; ++j) {
const a = index_offset + strip_indices[j - 2]; const a = indexOffset + stripIndices[j - 2];
const b = index_offset + strip_indices[j - 1]; const b = indexOffset + stripIndices[j - 1];
const c = index_offset + strip_indices[j]; const c = indexOffset + stripIndices[j];
const pa = new Vector3(positions[3 * a], positions[3 * a + 1], positions[3 * a + 2]); const pa = new Vector3(positions[3 * a], positions[3 * a + 1], positions[3 * a + 2]);
const pb = new Vector3(positions[3 * b], positions[3 * b + 1], positions[3 * b + 2]); const pb = new Vector3(positions[3 * b], positions[3 * b + 1], positions[3 * b + 2]);
const pc = new Vector3(positions[3 * c], positions[3 * c + 1], positions[3 * c + 2]); const pc = new Vector3(positions[3 * c], positions[3 * c + 1], positions[3 * c + 2]);
@ -126,12 +128,12 @@ function parse_triangle_strip_list(
normal.negate(); normal.negate();
} }
const opposite_count = const oppositeCount =
(normal.dot(na) < 0 ? 1 : 0) + (normal.dot(na) < 0 ? 1 : 0) +
(normal.dot(nb) < 0 ? 1 : 0) + (normal.dot(nb) < 0 ? 1 : 0) +
(normal.dot(nc) < 0 ? 1 : 0); (normal.dot(nc) < 0 ? 1 : 0);
if (opposite_count >= 2) { if (oppositeCount >= 2) {
clockwise = !clockwise; clockwise = !clockwise;
} }

26
src/data/parsing/qst.test.ts
View File

@ -1,27 +1,25 @@
import * as fs from 'fs';
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
import * as prs from '../compression/prs'; 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('parse_qst and write_qst', () => { test('parseQst and writeQst', () => {
walk_qst_files((file_path, file_name, file_content) => { walkQstFiles((_filePath, _fileName, fileContent) => {
const orig_qst = new ArrayBufferCursor(file_content.buffer, true); const origQst = new ArrayBufferCursor(fileContent.buffer, true);
const orig_quest = parse_qst(orig_qst); const origQuest = parseQst(origQst);
if (orig_quest) { if (origQuest) {
const test_qst = write_qst(orig_quest); const testQst = writeQst(origQuest);
orig_qst.seek_start(0); origQst.seekStart(0);
expect(test_qst.size).toBe(orig_qst.size); expect(testQst.size).toBe(origQst.size);
let match = true; let match = true;
while (orig_qst.bytes_left) { while (origQst.bytesLeft) {
if (test_qst.u8() !== orig_qst.u8()) { if (testQst.u8() !== origQst.u8()) {
match = false; match = false;
break; break;
} }

199
src/data/parsing/qst.ts
View File

@ -2,11 +2,11 @@ import { ArrayBufferCursor } from '../ArrayBufferCursor';
interface QstContainedFile { interface QstContainedFile {
name: string; name: string;
name_2?: string; // Unsure what this is name2?: string; // Unsure what this is
quest_no?: number; questNo?: number;
expected_size?: number; expectedSize?: number;
data: ArrayBufferCursor; data: ArrayBufferCursor;
chunk_nos: Set<number>; chunkNos: Set<number>;
} }
interface ParseQstResult { interface ParseQstResult {
@ -18,40 +18,40 @@ interface ParseQstResult {
* 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 parse_qst(cursor: ArrayBufferCursor): ParseQstResult | null { export function parseQst(cursor: ArrayBufferCursor): ParseQstResult | null {
// 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 version_a = cursor.u8(); const versionA = cursor.u8();
cursor.seek(1); cursor.seek(1);
const version_b = cursor.u8(); const versionB = cursor.u8();
if (version_a === 0x44) { if (versionA === 0x44) {
version = 'Dreamcast/GameCube'; version = 'Dreamcast/GameCube';
} else if (version_a === 0x58) { } else if (versionA === 0x58) {
if (version_b === 0x44) { if (versionB === 0x44) {
version = 'Blue Burst'; version = 'Blue Burst';
} }
} else if (version_a === 0xA6) { } else if (versionA === 0xA6) {
version = 'Dreamcast download'; version = 'Dreamcast download';
} }
if (version === 'Blue Burst') { if (version === 'Blue Burst') {
// Read headers and contained files. // Read headers and contained files.
cursor.seek_start(0); cursor.seekStart(0);
const headers = parse_headers(cursor); const headers = parseHeaders(cursor);
const files = parse_files( const files = parseFiles(
cursor, new Map(headers.map(h => [h.file_name, h.size]))); cursor, new Map(headers.map(h => [h.fileName, h.size])));
for (const file of files) { for (const file of files) {
const header = headers.find(h => h.file_name === file.name); const header = headers.find(h => h.fileName === file.name);
if (header) { if (header) {
file.quest_no = header.quest_no; file.questNo = header.questNo;
file.name_2 = header.file_name_2; file.name2 = header.fileName2;
} }
} }
@ -66,8 +66,8 @@ export function parse_qst(cursor: ArrayBufferCursor): ParseQstResult | null {
interface SimpleQstContainedFile { interface SimpleQstContainedFile {
name: string; name: string;
name_2?: string; name2?: string;
quest_no?: number; questNo?: number;
data: ArrayBufferCursor; data: ArrayBufferCursor;
} }
@ -79,77 +79,84 @@ interface WriteQstParams {
/** /**
* Always writes in Blue Burst format. * Always writes in Blue Burst format.
*/ */
export function write_qst(params: WriteQstParams): ArrayBufferCursor { export function writeQst(params: WriteQstParams): ArrayBufferCursor {
const files = params.files; const files = params.files;
const total_size = files const totalSize = 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 ArrayBufferCursor(total_size, true); const cursor = new ArrayBufferCursor(totalSize, true);
write_file_headers(cursor, files); writeFileHeaders(cursor, files);
write_file_chunks(cursor, files); writeFileChunks(cursor, files);
if (cursor.size !== total_size) { if (cursor.size !== totalSize) {
throw new Error(`Expected a final file size of ${total_size}, but got ${cursor.size}.`); throw new Error(`Expected a final file size of ${totalSize}, but got ${cursor.size}.`);
} }
return cursor.seek_start(0); return cursor.seekStart(0);
}
interface QstHeader {
questNo: number;
fileName: string;
fileName2: string;
size: number;
} }
/** /**
* TODO: Read all headers instead of just the first 2. * TODO: Read all headers instead of just the first 2.
*/ */
function parse_headers(cursor: ArrayBufferCursor): any[] { function parseHeaders(cursor: ArrayBufferCursor): QstHeader[] {
const files = []; const headers = [];
for (let i = 0; i < 2; ++i) { for (let i = 0; i < 2; ++i) {
cursor.seek(4); cursor.seek(4);
const quest_no = cursor.u16(); const questNo = cursor.u16();
cursor.seek(38); cursor.seek(38);
const file_name = cursor.string_ascii(16, true, true); const fileName = cursor.stringAscii(16, true, true);
const size = cursor.u32(); const size = cursor.u32();
// Not sure what this is: // Not sure what this is:
const file_name_2 = cursor.string_ascii(24, true, true); const fileName2 = cursor.stringAscii(24, true, true);
files.push({ headers.push({
quest_no, questNo,
file_name, fileName,
file_name_2, fileName2,
size size
}); });
} }
return files; return headers;
} }
function parse_files(cursor: ArrayBufferCursor, expected_sizes: Map<string, number>): QstContainedFile[] { function parseFiles(cursor: ArrayBufferCursor, expectedSizes: 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) { while (cursor.bytesLeft) {
const start_position = cursor.position; const startPosition = cursor.position;
// Read meta data. // Read meta data.
const chunk_no = cursor.seek(4).u8(); const chunkNo = cursor.seek(4).u8();
const file_name = cursor.seek(3).string_ascii(16, true, true); const fileName = cursor.seek(3).stringAscii(16, true, true);
let file = files.get(file_name); let file = files.get(fileName);
if (!file) { if (!file) {
const expected_size = expected_sizes.get(file_name); const expectedSize = expectedSizes.get(fileName);
files.set(file_name, file = { files.set(fileName, file = {
name: file_name, name: fileName,
expected_size, expectedSize,
data: new ArrayBufferCursor(expected_size || (10 * 1024), true), data: new ArrayBufferCursor(expectedSize || (10 * 1024), true),
chunk_nos: new Set() chunkNos: new Set()
}); });
} }
if (file.chunk_nos.has(chunk_no)) { if (file.chunkNos.has(chunkNo)) {
console.warn(`File chunk number ${chunk_no} of file ${file_name} was already encountered, overwriting previous chunk.`); console.warn(`File chunk number ${chunkNo} of file ${fileName} was already encountered, overwriting previous chunk.`);
} else { } else {
file.chunk_nos.add(chunk_no); file.chunkNos.add(chunkNo);
} }
// Read file data. // Read file data.
@ -162,34 +169,34 @@ function parse_files(cursor: ArrayBufferCursor, expected_sizes: Map<string, numb
} }
const data = cursor.take(size); const data = cursor.take(size);
const chunk_position = chunk_no * 1024; const chunkPosition = chunkNo * 1024;
file.data.size = Math.max(chunk_position + size, file.data.size); file.data.size = Math.max(chunkPosition + size, file.data.size);
file.data.seek_start(chunk_position).write_cursor(data); file.data.seekStart(chunkPosition).writeCursor(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 !== start_position + 1056) { if (cursor.position !== startPosition + 1056) {
throw new Error(`Read ${cursor.position - start_position} file chunk message bytes instead of expected 1056.`); throw new Error(`Read ${cursor.position - startPosition} file chunk message bytes instead of expected 1056.`);
} }
} }
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.seekStart(0);
file.chunk_nos = new Set(Array.from(file.chunk_nos.values()).sort((a, b) => a - b)); file.chunkNos = new Set(Array.from(file.chunkNos.values()).sort((a, b) => a - b));
// Check whether the expected size was correct. // Check whether the expected size was correct.
if (file.expected_size != null && file.data.size !== file.expected_size) { if (file.expectedSize != null && file.data.size !== file.expectedSize) {
console.warn(`File ${file.name} has an actual size of ${file.data.size} instead of the expected size ${file.expected_size}.`); console.warn(`File ${file.name} has an actual size of ${file.data.size} instead of the expected size ${file.expectedSize}.`);
} }
// Detect missing file chunks. // Detect missing file chunks.
const actual_size = Math.max(file.data.size, file.expected_size || 0); const actualSize = Math.max(file.data.size, file.expectedSize || 0);
for (let chunk_no = 0; chunk_no < Math.ceil(actual_size / 1024); ++chunk_no) { for (let chunkNo = 0; chunkNo < Math.ceil(actualSize / 1024); ++chunkNo) {
if (!file.chunk_nos.has(chunk_no)) { if (!file.chunkNos.has(chunkNo)) {
console.warn(`File ${file.name} is missing chunk ${chunk_no}.`); console.warn(`File ${file.name} is missing chunk ${chunkNo}.`);
} }
} }
} }
@ -197,49 +204,49 @@ function parse_files(cursor: ArrayBufferCursor, expected_sizes: Map<string, numb
return Array.from(files.values()); return Array.from(files.values());
} }
function write_file_headers(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void { function writeFileHeaders(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void {
for (const file of files) { for (const file of files) {
cursor.write_u16(88); // Header size. cursor.writeU16(88); // Header size.
cursor.write_u16(0x44); // Magic number. cursor.writeU16(0x44); // Magic number.
cursor.write_u16(file.quest_no || 0); cursor.writeU16(file.questNo || 0);
for (let i = 0; i < 38; ++i) { for (let i = 0; i < 38; ++i) {
cursor.write_u8(0); cursor.writeU8(0);
} }
cursor.write_string_ascii(file.name, 16); cursor.writeStringAscii(file.name, 16);
cursor.write_u32(file.data.size); cursor.writeU32(file.data.size);
let file_name_2: string; let fileName2: string;
if (file.name_2 == null) { if (file.name2 == null) {
// Not sure this makes sense. // Not sure this makes sense.
const dot_pos = file.name.lastIndexOf('.'); const dotPos = file.name.lastIndexOf('.');
file_name_2 = dot_pos === -1 fileName2 = dotPos === -1
? file.name + '_j' ? file.name + '_j'
: file.name.slice(0, dot_pos) + '_j' + file.name.slice(dot_pos); : file.name.slice(0, dotPos) + '_j' + file.name.slice(dotPos);
} else { } else {
file_name_2 = file.name_2; fileName2 = file.name2;
} }
cursor.write_string_ascii(file_name_2, 24); cursor.writeStringAscii(fileName2, 24);
} }
} }
function write_file_chunks(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void { function writeFileChunks(cursor: ArrayBufferCursor, 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 chunk_nos = new Array(files.length).fill(0); const chunkNos = 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 (!write_file_chunk(cursor, files[i].data, chunk_nos[i]++, files[i].name)) { if (!writeFileChunk(cursor, files[i].data, chunkNos[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);
chunk_nos.splice(i, 1); chunkNos.splice(i, 1);
} else { } else {
++i; ++i;
} }
@ -250,27 +257,27 @@ function write_file_chunks(cursor: ArrayBufferCursor, files: SimpleQstContainedF
/** /**
* @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 write_file_chunk( function writeFileChunk(
cursor: ArrayBufferCursor, cursor: ArrayBufferCursor,
data: ArrayBufferCursor, data: ArrayBufferCursor,
chunk_no: number, chunkNo: number,
name: string name: string
): boolean { ): boolean {
cursor.write_u8_array([28, 4, 19, 0]); cursor.writeU8Array([28, 4, 19, 0]);
cursor.write_u8(chunk_no); cursor.writeU8(chunkNo);
cursor.write_u8_array([0, 0, 0]); cursor.writeU8Array([0, 0, 0]);
cursor.write_string_ascii(name, 16); cursor.writeStringAscii(name, 16);
const size = Math.min(1024, data.bytes_left); const size = Math.min(1024, data.bytesLeft);
cursor.write_cursor(data.take(size)); cursor.writeCursor(data.take(size));
// Padding. // Padding.
for (let i = size; i < 1024; ++i) { for (let i = size; i < 1024; ++i) {
cursor.write_u8(0); cursor.writeU8(0);
} }
cursor.write_u32(size); cursor.writeU32(size);
cursor.write_u32(0); cursor.writeU32(0);
return !!data.bytes_left; return !!data.bytesLeft;
} }

57
src/data/parsing/quest.test.ts
View File

@ -1,67 +1,66 @@
import * as fs from 'fs'; import * as fs from 'fs';
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
import * as prs from '../compression/prs'; import { parseQuest, writeQuestQst } from './quest';
import { parse_quest, write_quest_qst } from './quest';
import { ObjectType, Quest } from '../../domain'; import { ObjectType, Quest } from '../../domain';
import { walk_qst_files } from '../../../test/src/utils';
test('parse Towards the Future', () => { test('parse Towards the Future', () => {
const buffer = fs.readFileSync('test/resources/quest118_e.qst').buffer; const buffer = fs.readFileSync('test/resources/quest118_e.qst').buffer;
const cursor = new ArrayBufferCursor(buffer, true); const cursor = new ArrayBufferCursor(buffer, true);
const quest = parse_quest(cursor)!; const quest = parseQuest(cursor)!;
expect(quest.name).toBe('Towards the Future'); expect(quest.name).toBe('Towards the Future');
expect(quest.short_description).toBe('Challenge the\nnew simulator.'); expect(quest.shortDescription).toBe('Challenge the\nnew simulator.');
expect(quest.long_description).toBe('Client: Principal\nQuest: Wishes to have\nhunters challenge the\nnew simulator\nReward: ??? Meseta'); expect(quest.longDescription).toBe('Client: Principal\nQuest: Wishes to have\nhunters challenge the\nnew simulator\nReward: ??? Meseta');
expect(quest.episode).toBe(1); expect(quest.episode).toBe(1);
expect(quest.objects.length).toBe(277); expect(quest.objects.length).toBe(277);
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(testable_area_variants(quest)).toEqual([ expect(testableAreaVariants(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]
]);
}); });
/** /**
* 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('parse_quest and write_quest_qst', () => { test('parseQuest and writeQuestQst', () => {
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 ArrayBufferCursor(buffer, true); const cursor = new ArrayBufferCursor(buffer, true);
const orig_quest = parse_quest(cursor)!; const origQuest = parseQuest(cursor)!;
const test_quest = parse_quest(write_quest_qst(orig_quest, '02.qst'))!; const testQuest = parseQuest(writeQuestQst(origQuest, '02.qst'))!;
expect(test_quest.name).toBe(orig_quest.name); expect(testQuest.name).toBe(origQuest.name);
expect(test_quest.short_description).toBe(orig_quest.short_description); expect(testQuest.shortDescription).toBe(origQuest.shortDescription);
expect(test_quest.long_description).toBe(orig_quest.long_description); expect(testQuest.longDescription).toBe(origQuest.longDescription);
expect(test_quest.episode).toBe(orig_quest.episode); expect(testQuest.episode).toBe(origQuest.episode);
expect(testable_objects(test_quest)) expect(testableObjects(testQuest))
.toEqual(testable_objects(orig_quest)); .toEqual(testableObjects(origQuest));
expect(testable_npcs(test_quest)) expect(testableNpcs(testQuest))
.toEqual(testable_npcs(orig_quest)); .toEqual(testableNpcs(origQuest));
expect(testable_area_variants(test_quest)) expect(testableAreaVariants(testQuest))
.toEqual(testable_area_variants(orig_quest)); .toEqual(testableAreaVariants(origQuest));
}); });
function testable_objects(quest: Quest) { function testableObjects(quest: Quest) {
return quest.objects.map(object => [ return quest.objects.map(object => [
object.area_id, object.areaId,
object.section_id, object.sectionId,
object.position, object.position,
object.type object.type
]); ]);
} }
function testable_npcs(quest: Quest) { function testableNpcs(quest: Quest) {
return quest.npcs.map(npc => [ return quest.npcs.map(npc => [
npc.area_id, npc.areaId,
npc.section_id, npc.sectionId,
npc.position, npc.position,
npc.type npc.type
]); ]);
} }
function testable_area_variants(quest: Quest) { function testableAreaVariants(quest: Quest) {
return quest.area_variants.map(av => [av.area.id, av.id]); return quest.areaVariants.map(av => [av.area.id, av.id]);
} }

474
src/data/parsing/quest.ts
View File

@ -1,8 +1,8 @@
import { ArrayBufferCursor } from '../ArrayBufferCursor'; import { ArrayBufferCursor } from '../ArrayBufferCursor';
import * as prs from '../compression/prs'; import * as prs from '../compression/prs';
import { parse_dat, write_dat } from './dat'; import { parseDat, writeDat, DatObject, DatNpc } from './dat';
import { parse_bin, write_bin, Instruction } from './bin'; import { parseBin, writeBin, Instruction } from './bin';
import { parse_qst, write_qst } from './qst'; import { parseQst, writeQst } from './qst';
import { import {
Vec3, Vec3,
AreaVariant, AreaVariant,
@ -12,89 +12,89 @@ import {
ObjectType, ObjectType,
NpcType NpcType
} from '../../domain'; } from '../../domain';
import { area_store } from '../../store'; import { areaStore } from '../../store';
/** /**
* High level parsing function that delegates to lower level parsing functions. * High level parsing function that delegates to lower level parsing functions.
* *
* Always delegates to parse_qst at the moment. * Always delegates to parseQst at the moment.
*/ */
export function parse_quest(cursor: ArrayBufferCursor): Quest | null { export function parseQuest(cursor: ArrayBufferCursor): Quest | null {
const qst = parse_qst(cursor); const qst = parseQst(cursor);
if (!qst) { if (!qst) {
return null; return null;
} }
let dat_file = null; let datFile = null;
let bin_file = null; let binFile = null;
for (const file of qst.files) { for (const file of qst.files) {
if (file.name.endsWith('.dat')) { if (file.name.endsWith('.dat')) {
dat_file = file; datFile = file;
} else if (file.name.endsWith('.bin')) { } else if (file.name.endsWith('.bin')) {
bin_file = file; binFile = file;
} }
} }
// TODO: deal with missing/multiple DAT or BIN file. // TODO: deal with missing/multiple DAT or BIN file.
if (!dat_file || !bin_file) { if (!datFile || !binFile) {
return null; return null;
} }
const dat = parse_dat(prs.decompress(dat_file.data)); const dat = parseDat(prs.decompress(datFile.data));
const bin = parse_bin(prs.decompress(bin_file.data)); const bin = parseBin(prs.decompress(binFile.data));
let episode = 1; let episode = 1;
let area_variants: AreaVariant[] = []; let areaVariants: AreaVariant[] = [];
if (bin.function_offsets.length) { if (bin.functionOffsets.length) {
const func_0_ops = get_func_operations(bin.instructions, bin.function_offsets[0]); const func0Ops = getFuncOperations(bin.instructions, bin.functionOffsets[0]);
if (func_0_ops) { if (func0Ops) {
episode = get_episode(func_0_ops); episode = getEpisode(func0Ops);
area_variants = get_area_variants(episode, func_0_ops); areaVariants = getAreaVariants(episode, func0Ops);
} else { } else {
console.warn(`Function 0 offset ${bin.function_offsets[0]} is invalid.`); console.warn(`Function 0 offset ${bin.functionOffsets[0]} is invalid.`);
} }
} else { } else {
console.warn('File contains no functions.'); console.warn('File contains no functions.');
} }
return new Quest( return new Quest(
bin.quest_name, bin.questName,
bin.short_description, bin.shortDescription,
bin.long_description, bin.longDescription,
dat_file.quest_no, datFile.questNo,
episode, episode,
area_variants, areaVariants,
parse_obj_data(dat.objs), parseObjData(dat.objs),
parse_npc_data(episode, dat.npcs), parseNpcData(episode, dat.npcs),
{ unknowns: dat.unknowns }, dat.unknowns,
bin.data bin.data
); );
} }
export function write_quest_qst(quest: Quest, file_name: string): ArrayBufferCursor { export function writeQuestQst(quest: Quest, fileName: string): ArrayBufferCursor {
const dat = write_dat({ const dat = writeDat({
objs: objects_to_dat_data(quest.episode, quest.objects), objs: objectsToDatData(quest.objects),
npcs: npcs_to_dat_data(quest.episode, quest.npcs), npcs: npcsToDatData(quest.npcs),
unknowns: quest.dat.unknowns unknowns: quest.datUnkowns
}); });
const bin = write_bin({ data: quest.bin }); const bin = writeBin({ data: quest.binData });
const ext_start = file_name.lastIndexOf('.'); const extStart = fileName.lastIndexOf('.');
const base_file_name = ext_start === -1 ? file_name : file_name.slice(0, ext_start); const baseFileName = extStart === -1 ? fileName : fileName.slice(0, extStart);
return write_qst({ return writeQst({
files: [ files: [
{ {
name: base_file_name + '.dat', name: baseFileName + '.dat',
quest_no: quest.quest_no, questNo: quest.questNo,
data: prs.compress(dat) data: prs.compress(dat)
}, },
{ {
name: base_file_name + '.bin', name: baseFileName + '.bin',
quest_no: quest.quest_no, questNo: quest.questNo,
data: prs.compress(bin) data: prs.compress(bin)
} }
] ]
@ -104,11 +104,11 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBufferCur
/** /**
* Defaults to episode I. * Defaults to episode I.
*/ */
function get_episode(func_0_ops: Instruction[]): number { function getEpisode(func0Ops: Instruction[]): number {
const set_episode = func_0_ops.find(op => op.mnemonic === 'set_episode'); const setEpisode = func0Ops.find(op => op.mnemonic === 'set_episode');
if (set_episode) { if (setEpisode) {
switch (set_episode.args[0]) { switch (setEpisode.args[0]) {
default: default:
case 0: return 1; case 0: return 1;
case 1: return 2; case 1: return 2;
@ -120,37 +120,37 @@ function get_episode(func_0_ops: Instruction[]): number {
} }
} }
function get_area_variants(episode: number, func_0_ops: Instruction[]): AreaVariant[] { function getAreaVariants(episode: number, func0Ops: Instruction[]): AreaVariant[] {
const area_variants = new Map(); const areaVariants = new Map();
const bb_maps = func_0_ops.filter(op => op.mnemonic === 'BB_Map_Designate'); const bbMaps = func0Ops.filter(op => op.mnemonic === 'BB_Map_Designate');
for (const bb_map of bb_maps) { for (const bbMap of bbMaps) {
const area_id = bb_map.args[0]; const areaId = bbMap.args[0];
const variant_id = bb_map.args[2]; const variantId = bbMap.args[2];
area_variants.set(area_id, variant_id); areaVariants.set(areaId, variantId);
} }
// Sort by area order and then variant id. // Sort by area order and then variant id.
return ( return (
Array.from(area_variants) Array.from(areaVariants)
.map(([area_id, variant_id]) => .map(([areaId, variantId]) =>
area_store.get_variant(episode, area_id, variant_id)) areaStore.getVariant(episode, areaId, variantId))
.sort((a, b) => a.area.order - b.area.order || a.id - b.id) .sort((a, b) => a.area.order - b.area.order || a.id - b.id)
); );
} }
function get_func_operations(operations: Instruction[], func_offset: number) { function getFuncOperations(operations: Instruction[], funcOffset: number) {
let position = 0; let position = 0;
let func_found = false; let funcFound = false;
const func_ops = []; const funcOps: Instruction[] = [];
for (const operation of operations) { for (const operation of operations) {
if (position === func_offset) { if (position === funcOffset) {
func_found = true; funcFound = true;
} }
if (func_found) { if (funcFound) {
func_ops.push(operation); funcOps.push(operation);
// Break when ret is encountered. // Break when ret is encountered.
if (operation.opcode === 1) { if (operation.opcode === 1) {
@ -161,43 +161,43 @@ function get_func_operations(operations: Instruction[], func_offset: number) {
position += operation.size; position += operation.size;
} }
return func_found ? func_ops : null; return funcFound ? funcOps : null;
} }
function parse_obj_data(objs: any[]): QuestObject[] { function parseObjData(objs: DatObject[]): QuestObject[] {
return objs.map(obj_data => { return objs.map(objData => {
const { x, y, z } = obj_data.position; const { x, y, z } = objData.position;
const rot = obj_data.rotation; const rot = objData.rotation;
return new QuestObject( return new QuestObject(
obj_data.area_id, objData.areaId,
obj_data.section_id, objData.sectionId,
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.type_id), ObjectType.fromPsoId(objData.typeId),
obj_data objData
); );
}); });
} }
function parse_npc_data(episode: number, npcs: any[]): QuestNpc[] { function parseNpcData(episode: number, npcs: DatNpc[]): QuestNpc[] {
return npcs.map(npc_data => { return npcs.map(npcData => {
const { x, y, z } = npc_data.position; const { x, y, z } = npcData.position;
const rot = npc_data.rotation; const rot = npcData.rotation;
return new QuestNpc( return new QuestNpc(
npc_data.area_id, npcData.areaId,
npc_data.section_id, npcData.sectionId,
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, npc_data), getNpcType(episode, npcData),
npc_data npcData
); );
}); });
} }
function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any): NpcType { function getNpcType(episode: number, { typeId, unknown, skin, areaId }: DatNpc): NpcType {
const regular = (unknown[2][18] & 0x80) === 0; const regular = (unknown[2][18] & 0x80) === 0;
switch (`${type_id}, ${skin % 3}, ${episode}`) { switch (`${typeId}, ${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;
@ -225,7 +225,7 @@ function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any)
case `${0x117}, 2, 4`: return NpcType.GoranDetonator; case `${0x117}, 2, 4`: return NpcType.GoranDetonator;
} }
switch (`${type_id}, ${skin % 2}, ${episode}`) { switch (`${typeId}, ${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;
@ -237,10 +237,10 @@ function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any)
case `${0x041}, 1, 2`: return NpcType.LoveRappy; case `${0x041}, 1, 2`: return NpcType.LoveRappy;
case `${0x041}, 1, 4`: return NpcType.DelRappy; case `${0x041}, 1, 4`: return NpcType.DelRappy;
case `${0x061}, 0, 1`: return area_id > 15 ? NpcType.DelLily : NpcType.PoisonLily; case `${0x061}, 0, 1`: return areaId > 15 ? NpcType.DelLily : NpcType.PoisonLily;
case `${0x061}, 0, 2`: return area_id > 15 ? NpcType.DelLily : NpcType.PoisonLily2; case `${0x061}, 0, 2`: return areaId > 15 ? NpcType.DelLily : NpcType.PoisonLily2;
case `${0x061}, 1, 1`: return area_id > 15 ? NpcType.DelLily : NpcType.NarLily; case `${0x061}, 1, 1`: return areaId > 15 ? NpcType.DelLily : NpcType.NarLily;
case `${0x061}, 1, 2`: return area_id > 15 ? NpcType.DelLily : NpcType.NarLily2; case `${0x061}, 1, 2`: return areaId > 15 ? NpcType.DelLily : NpcType.NarLily2;
case `${0x080}, 0, 1`: return NpcType.Dubchic; case `${0x080}, 0, 1`: return NpcType.Dubchic;
case `${0x080}, 0, 2`: return NpcType.Dubchic2; case `${0x080}, 0, 2`: return NpcType.Dubchic2;
@ -256,8 +256,8 @@ function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any)
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 area_id > 15 ? NpcType.Epsilon : NpcType.SinowZoa; case `${0x0E0}, 0, 2`: return areaId > 15 ? NpcType.Epsilon : NpcType.SinowZoa;
case `${0x0E0}, 1, 2`: return area_id > 15 ? NpcType.Epsilon : NpcType.SinowZele; case `${0x0E0}, 1, 2`: return areaId > 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;
@ -269,7 +269,7 @@ function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any)
case `${0x119}, 1, 4`: return regular ? NpcType.Shambertin : NpcType.Kondrieu; case `${0x119}, 1, 4`: return regular ? NpcType.Shambertin : NpcType.Kondrieu;
} }
switch (`${type_id}, ${episode}`) { switch (`${typeId}, ${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;
@ -327,7 +327,7 @@ function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any)
case `${0x113}, 4`: return NpcType.Girtablulu; case `${0x113}, 4`: return NpcType.Girtablulu;
} }
switch (type_id) { switch (typeId) {
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;
@ -348,186 +348,186 @@ function get_npc_type(episode: number, { type_id, unknown, skin, area_id }: any)
} }
// TODO: remove log statement: // TODO: remove log statement:
console.log(`Unknown type ID: ${type_id} (0x${type_id.toString(16)}).`); console.log(`Unknown type ID: ${typeId} (0x${typeId.toString(16)}).`);
return NpcType.Unknown; return NpcType.Unknown;
} }
function objects_to_dat_data(episode: number, objects: QuestObject[]): any[] { function objectsToDatData(objects: QuestObject[]): DatObject[] {
return objects.map(object => ({ return objects.map(object => ({
type_id: object.type.pso_id, typeId: object.type.psoId!,
section_id: object.section_id, sectionId: object.sectionId,
position: object.section_position, position: object.sectionPosition,
rotation: object.rotation, rotation: object.rotation,
area_id: object.area_id, areaId: object.areaId,
unknown: object.dat.unknown unknown: object.dat.unknown
})); }));
} }
function npcs_to_dat_data(episode: number, npcs: QuestNpc[]): any[] { function npcsToDatData(npcs: QuestNpc[]): DatNpc[] {
return npcs.map(npc => { return npcs.map(npc => {
// If the type is unknown, type_data will be null and we use the raw data from the DAT file. // If the type is unknown, typeData will be null and we use the raw data from the DAT file.
const type_data = npc_type_to_dat_data(npc.type); const typeData = npcTypeToDatData(npc.type);
if (type_data) { if (typeData) {
npc.dat.unknown[2][18] = (npc.dat.unknown[2][18] & ~0x80) | (type_data.regular ? 0 : 0x80); npc.dat.unknown[2][18] = (npc.dat.unknown[2][18] & ~0x80) | (typeData.regular ? 0 : 0x80);
} }
return { return {
type_id: type_data ? type_data.type_id : npc.dat.type_id, typeId: typeData ? typeData.typeId : npc.dat.typeId,
section_id: npc.section_id, sectionId: npc.sectionId,
position: npc.section_position, position: npc.sectionPosition,
rotation: npc.rotation, rotation: npc.rotation,
skin: type_data ? type_data.skin : npc.dat.skin, skin: typeData ? typeData.skin : npc.dat.skin,
area_id: npc.area_id, areaId: npc.areaId,
unknown: npc.dat.unknown unknown: npc.dat.unknown
}; };
}); });
} }
function npc_type_to_dat_data( function npcTypeToDatData(
type: NpcType type: NpcType
): { type_id: number, skin: number, regular: boolean } | null { ): { typeId: number, skin: number, regular: boolean } | null {
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 null;
case NpcType.FemaleFat: return { type_id: 0x004, skin: 0, regular: true }; case NpcType.FemaleFat: return { typeId: 0x004, skin: 0, regular: true };
case NpcType.FemaleMacho: return { type_id: 0x005, skin: 0, regular: true }; case NpcType.FemaleMacho: return { typeId: 0x005, skin: 0, regular: true };
case NpcType.FemaleTall: return { type_id: 0x007, skin: 0, regular: true }; case NpcType.FemaleTall: return { typeId: 0x007, skin: 0, regular: true };
case NpcType.MaleDwarf: return { type_id: 0x00A, skin: 0, regular: true }; case NpcType.MaleDwarf: return { typeId: 0x00A, skin: 0, regular: true };
case NpcType.MaleFat: return { type_id: 0x00B, skin: 0, regular: true }; case NpcType.MaleFat: return { typeId: 0x00B, skin: 0, regular: true };
case NpcType.MaleMacho: return { type_id: 0x00C, skin: 0, regular: true }; case NpcType.MaleMacho: return { typeId: 0x00C, skin: 0, regular: true };
case NpcType.MaleOld: return { type_id: 0x00D, skin: 0, regular: true }; case NpcType.MaleOld: return { typeId: 0x00D, skin: 0, regular: true };
case NpcType.BlueSoldier: return { type_id: 0x019, skin: 0, regular: true }; case NpcType.BlueSoldier: return { typeId: 0x019, skin: 0, regular: true };
case NpcType.RedSoldier: return { type_id: 0x01A, skin: 0, regular: true }; case NpcType.RedSoldier: return { typeId: 0x01A, skin: 0, regular: true };
case NpcType.Principal: return { type_id: 0x01B, skin: 0, regular: true }; case NpcType.Principal: return { typeId: 0x01B, skin: 0, regular: true };
case NpcType.Tekker: return { type_id: 0x01C, skin: 0, regular: true }; case NpcType.Tekker: return { typeId: 0x01C, skin: 0, regular: true };
case NpcType.GuildLady: return { type_id: 0x01D, skin: 0, regular: true }; case NpcType.GuildLady: return { typeId: 0x01D, skin: 0, regular: true };
case NpcType.Scientist: return { type_id: 0x01E, skin: 0, regular: true }; case NpcType.Scientist: return { typeId: 0x01E, skin: 0, regular: true };
case NpcType.Nurse: return { type_id: 0x01F, skin: 0, regular: true }; case NpcType.Nurse: return { typeId: 0x01F, skin: 0, regular: true };
case NpcType.Irene: return { type_id: 0x020, skin: 0, regular: true }; case NpcType.Irene: return { typeId: 0x020, skin: 0, regular: true };
case NpcType.ItemShop: return { type_id: 0x0F1, skin: 0, regular: true }; case NpcType.ItemShop: return { typeId: 0x0F1, skin: 0, regular: true };
case NpcType.Nurse2: return { type_id: 0x0FE, skin: 0, regular: true }; case NpcType.Nurse2: return { typeId: 0x0FE, skin: 0, regular: true };
case NpcType.Hildebear: return { type_id: 0x040, skin: 0, regular: true }; case NpcType.Hildebear: return { typeId: 0x040, skin: 0, regular: true };
case NpcType.Hildeblue: return { type_id: 0x040, skin: 1, regular: true }; case NpcType.Hildeblue: return { typeId: 0x040, skin: 1, regular: true };
case NpcType.RagRappy: return { type_id: 0x041, skin: 0, regular: true }; case NpcType.RagRappy: return { typeId: 0x041, skin: 0, regular: true };
case NpcType.AlRappy: return { type_id: 0x041, skin: 1, regular: true }; case NpcType.AlRappy: return { typeId: 0x041, skin: 1, regular: true };
case NpcType.Monest: return { type_id: 0x042, skin: 0, regular: true }; case NpcType.Monest: return { typeId: 0x042, skin: 0, regular: true };
case NpcType.SavageWolf: return { type_id: 0x043, skin: 0, regular: true }; case NpcType.SavageWolf: return { typeId: 0x043, skin: 0, regular: true };
case NpcType.BarbarousWolf: return { type_id: 0x043, skin: 0, regular: false }; case NpcType.BarbarousWolf: return { typeId: 0x043, skin: 0, regular: false };
case NpcType.Booma: return { type_id: 0x044, skin: 0, regular: true }; case NpcType.Booma: return { typeId: 0x044, skin: 0, regular: true };
case NpcType.Gobooma: return { type_id: 0x044, skin: 1, regular: true }; case NpcType.Gobooma: return { typeId: 0x044, skin: 1, regular: true };
case NpcType.Gigobooma: return { type_id: 0x044, skin: 2, regular: true }; case NpcType.Gigobooma: return { typeId: 0x044, skin: 2, regular: true };
case NpcType.Dragon: return { type_id: 0x0C0, skin: 0, regular: true }; case NpcType.Dragon: return { typeId: 0x0C0, skin: 0, regular: true };
case NpcType.GrassAssassin: return { type_id: 0x060, skin: 0, regular: true }; case NpcType.GrassAssassin: return { typeId: 0x060, skin: 0, regular: true };
case NpcType.PoisonLily: return { type_id: 0x061, skin: 0, regular: true }; case NpcType.PoisonLily: return { typeId: 0x061, skin: 0, regular: true };
case NpcType.NarLily: return { type_id: 0x061, skin: 1, regular: true }; case NpcType.NarLily: return { typeId: 0x061, skin: 1, regular: true };
case NpcType.NanoDragon: return { type_id: 0x062, skin: 0, regular: true }; case NpcType.NanoDragon: return { typeId: 0x062, skin: 0, regular: true };
case NpcType.EvilShark: return { type_id: 0x063, skin: 0, regular: true }; case NpcType.EvilShark: return { typeId: 0x063, skin: 0, regular: true };
case NpcType.PalShark: return { type_id: 0x063, skin: 1, regular: true }; case NpcType.PalShark: return { typeId: 0x063, skin: 1, regular: true };
case NpcType.GuilShark: return { type_id: 0x063, skin: 2, regular: true }; case NpcType.GuilShark: return { typeId: 0x063, skin: 2, regular: true };
case NpcType.PofuillySlime: return { type_id: 0x064, skin: 0, regular: true }; case NpcType.PofuillySlime: return { typeId: 0x064, skin: 0, regular: true };
case NpcType.PouillySlime: return { type_id: 0x064, skin: 0, regular: false }; case NpcType.PouillySlime: return { typeId: 0x064, skin: 0, regular: false };
case NpcType.PanArms: return { type_id: 0x065, skin: 0, regular: true }; case NpcType.PanArms: return { typeId: 0x065, skin: 0, regular: true };
case NpcType.DeRolLe: return { type_id: 0x0C1, skin: 0, regular: true }; case NpcType.DeRolLe: return { typeId: 0x0C1, skin: 0, regular: true };
case NpcType.Dubchic: return { type_id: 0x080, skin: 0, regular: true }; case NpcType.Dubchic: return { typeId: 0x080, skin: 0, regular: true };
case NpcType.Gilchic: return { type_id: 0x080, skin: 1, regular: true }; case NpcType.Gilchic: return { typeId: 0x080, skin: 1, regular: true };
case NpcType.Garanz: return { type_id: 0x081, skin: 0, regular: true }; case NpcType.Garanz: return { typeId: 0x081, skin: 0, regular: true };
case NpcType.SinowBeat: return { type_id: 0x082, skin: 0, regular: true }; case NpcType.SinowBeat: return { typeId: 0x082, skin: 0, regular: true };
case NpcType.SinowGold: return { type_id: 0x082, skin: 0, regular: false }; case NpcType.SinowGold: return { typeId: 0x082, skin: 0, regular: false };
case NpcType.Canadine: return { type_id: 0x083, skin: 0, regular: true }; case NpcType.Canadine: return { typeId: 0x083, skin: 0, regular: true };
case NpcType.Canane: return { type_id: 0x084, skin: 0, regular: true }; case NpcType.Canane: return { typeId: 0x084, skin: 0, regular: true };
case NpcType.Dubswitch: return { type_id: 0x085, skin: 0, regular: true }; case NpcType.Dubswitch: return { typeId: 0x085, skin: 0, regular: true };
case NpcType.VolOpt: return { type_id: 0x0C5, skin: 0, regular: true }; case NpcType.VolOpt: return { typeId: 0x0C5, skin: 0, regular: true };
case NpcType.Delsaber: return { type_id: 0x0A0, skin: 0, regular: true }; case NpcType.Delsaber: return { typeId: 0x0A0, skin: 0, regular: true };
case NpcType.ChaosSorcerer: return { type_id: 0x0A1, skin: 0, regular: true }; case NpcType.ChaosSorcerer: return { typeId: 0x0A1, skin: 0, regular: true };
case NpcType.DarkGunner: return { type_id: 0x0A2, skin: 0, regular: true }; case NpcType.DarkGunner: return { typeId: 0x0A2, skin: 0, regular: true };
case NpcType.ChaosBringer: return { type_id: 0x0A4, skin: 0, regular: true }; case NpcType.ChaosBringer: return { typeId: 0x0A4, skin: 0, regular: true };
case NpcType.DarkBelra: return { type_id: 0x0A5, skin: 0, regular: true }; case NpcType.DarkBelra: return { typeId: 0x0A5, skin: 0, regular: true };
case NpcType.Dimenian: return { type_id: 0x0A6, skin: 0, regular: true }; case NpcType.Dimenian: return { typeId: 0x0A6, skin: 0, regular: true };
case NpcType.LaDimenian: return { type_id: 0x0A6, skin: 1, regular: true }; case NpcType.LaDimenian: return { typeId: 0x0A6, skin: 1, regular: true };
case NpcType.SoDimenian: return { type_id: 0x0A6, skin: 2, regular: true }; case NpcType.SoDimenian: return { typeId: 0x0A6, skin: 2, regular: true };
case NpcType.Bulclaw: return { type_id: 0x0A7, skin: 0, regular: true }; case NpcType.Bulclaw: return { typeId: 0x0A7, skin: 0, regular: true };
case NpcType.Claw: return { type_id: 0x0A8, skin: 0, regular: true }; case NpcType.Claw: return { typeId: 0x0A8, skin: 0, regular: true };
case NpcType.DarkFalz: return { type_id: 0x0C8, skin: 0, regular: true }; case NpcType.DarkFalz: return { typeId: 0x0C8, skin: 0, regular: true };
case NpcType.Hildebear2: return { type_id: 0x040, skin: 0, regular: true }; case NpcType.Hildebear2: return { typeId: 0x040, skin: 0, regular: true };
case NpcType.Hildeblue2: return { type_id: 0x040, skin: 1, regular: true }; case NpcType.Hildeblue2: return { typeId: 0x040, skin: 1, regular: true };
case NpcType.RagRappy2: return { type_id: 0x041, skin: 0, regular: true }; case NpcType.RagRappy2: return { typeId: 0x041, skin: 0, regular: true };
case NpcType.LoveRappy: return { type_id: 0x041, skin: 1, regular: true }; case NpcType.LoveRappy: return { typeId: 0x041, skin: 1, regular: true };
case NpcType.Monest2: return { type_id: 0x042, skin: 0, regular: true }; case NpcType.Monest2: return { typeId: 0x042, skin: 0, regular: true };
case NpcType.PoisonLily2: return { type_id: 0x061, skin: 0, regular: true }; case NpcType.PoisonLily2: return { typeId: 0x061, skin: 0, regular: true };
case NpcType.NarLily2: return { type_id: 0x061, skin: 1, regular: true }; case NpcType.NarLily2: return { typeId: 0x061, skin: 1, regular: true };
case NpcType.GrassAssassin2: return { type_id: 0x060, skin: 0, regular: true }; case NpcType.GrassAssassin2: return { typeId: 0x060, skin: 0, regular: true };
case NpcType.Dimenian2: return { type_id: 0x0A6, skin: 0, regular: true }; case NpcType.Dimenian2: return { typeId: 0x0A6, skin: 0, regular: true };
case NpcType.LaDimenian2: return { type_id: 0x0A6, skin: 1, regular: true }; case NpcType.LaDimenian2: return { typeId: 0x0A6, skin: 1, regular: true };
case NpcType.SoDimenian2: return { type_id: 0x0A6, skin: 2, regular: true }; case NpcType.SoDimenian2: return { typeId: 0x0A6, skin: 2, regular: true };
case NpcType.DarkBelra2: return { type_id: 0x0A5, skin: 0, regular: true }; case NpcType.DarkBelra2: return { typeId: 0x0A5, skin: 0, regular: true };
case NpcType.BarbaRay: return { type_id: 0x0CB, skin: 0, regular: true }; case NpcType.BarbaRay: return { typeId: 0x0CB, skin: 0, regular: true };
case NpcType.SavageWolf2: return { type_id: 0x043, skin: 0, regular: true }; case NpcType.SavageWolf2: return { typeId: 0x043, skin: 0, regular: true };
case NpcType.BarbarousWolf2: return { type_id: 0x043, skin: 0, regular: false }; case NpcType.BarbarousWolf2: return { typeId: 0x043, skin: 0, regular: false };
case NpcType.PanArms2: return { type_id: 0x065, skin: 0, regular: true }; case NpcType.PanArms2: return { typeId: 0x065, skin: 0, regular: true };
case NpcType.Dubchic2: return { type_id: 0x080, skin: 0, regular: true }; case NpcType.Dubchic2: return { typeId: 0x080, skin: 0, regular: true };
case NpcType.Gilchic2: return { type_id: 0x080, skin: 1, regular: true }; case NpcType.Gilchic2: return { typeId: 0x080, skin: 1, regular: true };
case NpcType.Garanz2: return { type_id: 0x081, skin: 0, regular: true }; case NpcType.Garanz2: return { typeId: 0x081, skin: 0, regular: true };
case NpcType.Dubswitch2: return { type_id: 0x085, skin: 0, regular: true }; case NpcType.Dubswitch2: return { typeId: 0x085, skin: 0, regular: true };
case NpcType.Delsaber2: return { type_id: 0x0A0, skin: 0, regular: true }; case NpcType.Delsaber2: return { typeId: 0x0A0, skin: 0, regular: true };
case NpcType.ChaosSorcerer2: return { type_id: 0x0A1, skin: 0, regular: true }; case NpcType.ChaosSorcerer2: return { typeId: 0x0A1, skin: 0, regular: true };
case NpcType.GolDragon: return { type_id: 0x0CC, skin: 0, regular: true }; case NpcType.GolDragon: return { typeId: 0x0CC, skin: 0, regular: true };
case NpcType.SinowBerill: return { type_id: 0x0D4, skin: 0, regular: true }; case NpcType.SinowBerill: return { typeId: 0x0D4, skin: 0, regular: true };
case NpcType.SinowSpigell: return { type_id: 0x0D4, skin: 1, regular: true }; case NpcType.SinowSpigell: return { typeId: 0x0D4, skin: 1, regular: true };
case NpcType.Merillia: return { type_id: 0x0D5, skin: 0, regular: true }; case NpcType.Merillia: return { typeId: 0x0D5, skin: 0, regular: true };
case NpcType.Meriltas: return { type_id: 0x0D5, skin: 1, regular: true }; case NpcType.Meriltas: return { typeId: 0x0D5, skin: 1, regular: true };
case NpcType.Mericarol: return { type_id: 0x0D6, skin: 0, regular: true }; case NpcType.Mericarol: return { typeId: 0x0D6, skin: 0, regular: true };
case NpcType.Mericus: return { type_id: 0x0D6, skin: 1, regular: true }; case NpcType.Mericus: return { typeId: 0x0D6, skin: 1, regular: true };
case NpcType.Merikle: return { type_id: 0x0D6, skin: 2, regular: true }; case NpcType.Merikle: return { typeId: 0x0D6, skin: 2, regular: true };
case NpcType.UlGibbon: return { type_id: 0x0D7, skin: 0, regular: true }; case NpcType.UlGibbon: return { typeId: 0x0D7, skin: 0, regular: true };
case NpcType.ZolGibbon: return { type_id: 0x0D7, skin: 1, regular: true }; case NpcType.ZolGibbon: return { typeId: 0x0D7, skin: 1, regular: true };
case NpcType.Gibbles: return { type_id: 0x0D8, skin: 0, regular: true }; case NpcType.Gibbles: return { typeId: 0x0D8, skin: 0, regular: true };
case NpcType.Gee: return { type_id: 0x0D9, skin: 0, regular: true }; case NpcType.Gee: return { typeId: 0x0D9, skin: 0, regular: true };
case NpcType.GiGue: return { type_id: 0x0DA, skin: 0, regular: true }; case NpcType.GiGue: return { typeId: 0x0DA, skin: 0, regular: true };
case NpcType.GalGryphon: return { type_id: 0x0C0, skin: 0, regular: true }; case NpcType.GalGryphon: return { typeId: 0x0C0, skin: 0, regular: true };
case NpcType.Deldepth: return { type_id: 0x0DB, skin: 0, regular: true }; case NpcType.Deldepth: return { typeId: 0x0DB, skin: 0, regular: true };
case NpcType.Delbiter: return { type_id: 0x0DC, skin: 0, regular: true }; case NpcType.Delbiter: return { typeId: 0x0DC, skin: 0, regular: true };
case NpcType.Dolmolm: return { type_id: 0x0DD, skin: 0, regular: true }; case NpcType.Dolmolm: return { typeId: 0x0DD, skin: 0, regular: true };
case NpcType.Dolmdarl: return { type_id: 0x0DD, skin: 1, regular: true }; case NpcType.Dolmdarl: return { typeId: 0x0DD, skin: 1, regular: true };
case NpcType.Morfos: return { type_id: 0x0DE, skin: 0, regular: true }; case NpcType.Morfos: return { typeId: 0x0DE, skin: 0, regular: true };
case NpcType.Recobox: return { type_id: 0x0DF, skin: 0, regular: true }; case NpcType.Recobox: return { typeId: 0x0DF, skin: 0, regular: true };
case NpcType.Epsilon: return { type_id: 0x0E0, skin: 0, regular: true }; case NpcType.Epsilon: return { typeId: 0x0E0, skin: 0, regular: true };
case NpcType.SinowZoa: return { type_id: 0x0E0, skin: 0, regular: true }; case NpcType.SinowZoa: return { typeId: 0x0E0, skin: 0, regular: true };
case NpcType.SinowZele: return { type_id: 0x0E0, skin: 1, regular: true }; case NpcType.SinowZele: return { typeId: 0x0E0, skin: 1, regular: true };
case NpcType.IllGill: return { type_id: 0x0E1, skin: 0, regular: true }; case NpcType.IllGill: return { typeId: 0x0E1, skin: 0, regular: true };
case NpcType.DelLily: return { type_id: 0x061, skin: 0, regular: true }; case NpcType.DelLily: return { typeId: 0x061, skin: 0, regular: true };
case NpcType.OlgaFlow: return { type_id: 0x0CA, skin: 0, regular: true }; case NpcType.OlgaFlow: return { typeId: 0x0CA, skin: 0, regular: true };
case NpcType.SandRappy: return { type_id: 0x041, skin: 0, regular: true }; case NpcType.SandRappy: return { typeId: 0x041, skin: 0, regular: true };
case NpcType.DelRappy: return { type_id: 0x041, skin: 1, regular: true }; case NpcType.DelRappy: return { typeId: 0x041, skin: 1, regular: true };
case NpcType.Astark: return { type_id: 0x110, skin: 0, regular: true }; case NpcType.Astark: return { typeId: 0x110, skin: 0, regular: true };
case NpcType.SatelliteLizard: return { type_id: 0x111, skin: 0, regular: true }; case NpcType.SatelliteLizard: return { typeId: 0x111, skin: 0, regular: true };
case NpcType.Yowie: return { type_id: 0x111, skin: 0, regular: false }; case NpcType.Yowie: return { typeId: 0x111, skin: 0, regular: false };
case NpcType.MerissaA: return { type_id: 0x112, skin: 0, regular: true }; case NpcType.MerissaA: return { typeId: 0x112, skin: 0, regular: true };
case NpcType.MerissaAA: return { type_id: 0x112, skin: 1, regular: true }; case NpcType.MerissaAA: return { typeId: 0x112, skin: 1, regular: true };
case NpcType.Girtablulu: return { type_id: 0x113, skin: 0, regular: true }; case NpcType.Girtablulu: return { typeId: 0x113, skin: 0, regular: true };
case NpcType.Zu: return { type_id: 0x114, skin: 0, regular: true }; case NpcType.Zu: return { typeId: 0x114, skin: 0, regular: true };
case NpcType.Pazuzu: return { type_id: 0x114, skin: 1, regular: true }; case NpcType.Pazuzu: return { typeId: 0x114, skin: 1, regular: true };
case NpcType.Boota: return { type_id: 0x115, skin: 0, regular: true }; case NpcType.Boota: return { typeId: 0x115, skin: 0, regular: true };
case NpcType.ZeBoota: return { type_id: 0x115, skin: 1, regular: true }; case NpcType.ZeBoota: return { typeId: 0x115, skin: 1, regular: true };
case NpcType.BaBoota: return { type_id: 0x115, skin: 2, regular: true }; case NpcType.BaBoota: return { typeId: 0x115, skin: 2, regular: true };
case NpcType.Dorphon: return { type_id: 0x116, skin: 0, regular: true }; case NpcType.Dorphon: return { typeId: 0x116, skin: 0, regular: true };
case NpcType.DorphonEclair: return { type_id: 0x116, skin: 1, regular: true }; case NpcType.DorphonEclair: return { typeId: 0x116, skin: 1, regular: true };
case NpcType.Goran: return { type_id: 0x117, skin: 0, regular: true }; case NpcType.Goran: return { typeId: 0x117, skin: 0, regular: true };
case NpcType.PyroGoran: return { type_id: 0x117, skin: 1, regular: true }; case NpcType.PyroGoran: return { typeId: 0x117, skin: 1, regular: true };
case NpcType.GoranDetonator: return { type_id: 0x117, skin: 2, regular: true }; case NpcType.GoranDetonator: return { typeId: 0x117, skin: 2, regular: true };
case NpcType.SaintMillion: return { type_id: 0x119, skin: 0, regular: true }; case NpcType.SaintMillion: return { typeId: 0x119, skin: 0, regular: true };
case NpcType.Shambertin: return { type_id: 0x119, skin: 1, regular: true }; case NpcType.Shambertin: return { typeId: 0x119, skin: 1, regular: true };
case NpcType.Kondrieu: return { type_id: 0x119, skin: 0, regular: false }; case NpcType.Kondrieu: return { typeId: 0x119, skin: 0, regular: false };
} }
} }

14
src/domain/ObjectType.ts
View File

@ -1,17 +1,17 @@
export class ObjectType { export class ObjectType {
id: number; id: number;
pso_id?: number; psoId?: number;
name: string; name: string;
constructor(id: number, pso_id: number | undefined, name: string) { constructor(id: number, psoId: number | undefined, name: string) {
if (!Number.isInteger(id) || id < 1) if (!Number.isInteger(id) || id < 1)
throw new Error(`Expected id to be an integer greater than or equal to 1, got ${id}.`); throw new Error(`Expected id to be an integer greater than or equal to 1, got ${id}.`);
if (pso_id != null && (!Number.isInteger(pso_id) || pso_id < 0)) if (psoId != null && (!Number.isInteger(psoId) || psoId < 0))
throw new Error(`Expected pso_id to be null or an integer greater than or equal to 0, got ${pso_id}.`); throw new Error(`Expected psoId to be null or an integer greater than or equal to 0, got ${psoId}.`);
if (!name) throw new Error('name is required.'); if (!name) throw new Error('name is required.');
this.id = id; this.id = id;
this.pso_id = pso_id; this.psoId = psoId;
this.name = name; this.name = name;
} }
@ -296,8 +296,8 @@ export class ObjectType {
static TopOfSaintMillionEgg: ObjectType; static TopOfSaintMillionEgg: ObjectType;
static UnknownItem961: ObjectType; static UnknownItem961: ObjectType;
static from_pso_id(pso_id: number): ObjectType { static fromPsoId(psoId: number): ObjectType {
switch (pso_id) { switch (psoId) {
default: return ObjectType.Unknown; default: return ObjectType.Unknown;
case 0: return ObjectType.PlayerSet; case 0: return ObjectType.PlayerSet;

150
src/domain/index.ts
View File

@ -2,6 +2,8 @@ import { Object3D } from 'three';
import { computed, observable } from 'mobx'; import { computed, observable } from 'mobx';
import { NpcType } from './NpcType'; import { NpcType } from './NpcType';
import { ObjectType } from './ObjectType'; import { ObjectType } from './ObjectType';
import { DatObject, DatNpc, DatUnknown } from '../data/parsing/dat';
import { ArrayBufferCursor } from '../data/ArrayBufferCursor';
export { NpcType } from './NpcType'; export { NpcType } from './NpcType';
export { ObjectType } from './ObjectType'; export { ObjectType } from './ObjectType';
@ -35,85 +37,87 @@ export class Vec3 {
export class Section { export class Section {
id: number; id: number;
@observable position: Vec3; @observable position: Vec3;
@observable y_axis_rotation: number; @observable yAxisRotation: number;
@computed get sin_y_axis_rotation(): number { @computed get sinYAxisRotation(): number {
return Math.sin(this.y_axis_rotation); return Math.sin(this.yAxisRotation);
} }
@computed get cos_y_axis_rotation(): number { @computed get cosYAxisRotation(): number {
return Math.cos(this.y_axis_rotation); return Math.cos(this.yAxisRotation);
} }
constructor( constructor(
id: number, id: number,
position: Vec3, position: Vec3,
y_axis_rotation: number yAxisRotation: number
) { ) {
if (!Number.isInteger(id) || id < -1) if (!Number.isInteger(id) || id < -1)
throw new Error(`Expected id to be an integer greater than or equal to -1, got ${id}.`); throw new Error(`Expected id to be an integer greater than or equal to -1, got ${id}.`);
if (!position) throw new Error('position is required.'); if (!position) throw new Error('position is required.');
if (typeof y_axis_rotation !== 'number') throw new Error('y_axis_rotation is required.'); if (typeof yAxisRotation !== 'number') throw new Error('yAxisRotation is required.');
this.id = id; this.id = id;
this.position = position; this.position = position;
this.y_axis_rotation = y_axis_rotation; this.yAxisRotation = yAxisRotation;
} }
} }
export class Quest { export class Quest {
@observable name: string; @observable name: string;
@observable short_description: string; @observable shortDescription: string;
@observable long_description: string; @observable longDescription: string;
@observable quest_no?: number; @observable questNo?: number;
@observable episode: number; @observable episode: number;
@observable area_variants: AreaVariant[]; @observable areaVariants: AreaVariant[];
@observable objects: QuestObject[]; @observable objects: QuestObject[];
@observable npcs: QuestNpc[]; @observable npcs: QuestNpc[];
/** /**
* (Partial) raw DAT data that can't be parsed yet by Phantasmal. * (Partial) raw DAT data that can't be parsed yet by Phantasmal.
*/ */
dat: any; datUnkowns: DatUnknown[];
/** /**
* (Partial) raw BIN data that can't be parsed yet by Phantasmal. * (Partial) raw BIN data that can't be parsed yet by Phantasmal.
*/ */
bin: any; binData: ArrayBufferCursor;
constructor( constructor(
name: string, name: string,
short_description: string, shortDescription: string,
long_description: string, longDescription: string,
quest_no: number | undefined, questNo: number | undefined,
episode: number, episode: number,
area_variants: AreaVariant[], areaVariants: AreaVariant[],
objects: QuestObject[], objects: QuestObject[],
npcs: QuestNpc[], npcs: QuestNpc[],
dat: any, datUnknowns: DatUnknown[],
bin: any binData: ArrayBufferCursor
) { ) {
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 (questNo != null && (!Number.isInteger(questNo) || questNo < 0)) throw new Error('questNo should be null or a non-negative integer.');
if (episode !== 1 && episode !== 2 && episode !== 4) throw new Error('episode should be 1, 2 or 4.'); if (episode !== 1 && episode !== 2 && episode !== 4) throw new Error('episode should be 1, 2 or 4.');
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.name = name; this.name = name;
this.short_description = short_description; this.shortDescription = shortDescription;
this.long_description = long_description; this.longDescription = longDescription;
this.quest_no = quest_no; this.questNo = questNo;
this.episode = episode; this.episode = episode;
this.area_variants = area_variants; this.areaVariants = areaVariants;
this.objects = objects; this.objects = objects;
this.npcs = npcs; this.npcs = npcs;
this.dat = dat; this.datUnkowns = datUnknowns;
this.bin = bin; this.binData = binData;
} }
} }
export class VisibleQuestEntity { export class VisibleQuestEntity {
@observable area_id: number; @observable areaId: number;
@computed get section_id(): number { private _sectionId: number;
return this.section ? this.section.id : this._section_id;
@computed get sectionId(): number {
return this.section ? this.section.id : this._sectionId;
} }
@observable section?: Section; @observable section?: Section;
@ -128,36 +132,36 @@ export class VisibleQuestEntity {
/** /**
* Section-relative position * Section-relative position
*/ */
@computed get section_position(): Vec3 { @computed get sectionPosition(): Vec3 {
let { x, y, z } = this.position; let { x, y, z } = this.position;
if (this.section) { if (this.section) {
const rel_x = x - this.section.position.x; const relX = x - this.section.position.x;
const rel_y = y - this.section.position.y; const relY = y - this.section.position.y;
const rel_z = z - this.section.position.z; const relZ = z - this.section.position.z;
const sin = -this.section.sin_y_axis_rotation; const sin = -this.section.sinYAxisRotation;
const cos = this.section.cos_y_axis_rotation; const cos = this.section.cosYAxisRotation;
const rot_x = cos * rel_x + sin * rel_z; const rotX = cos * relX + sin * relZ;
const rot_z = -sin * rel_x + cos * rel_z; const rotZ = -sin * relX + cos * relZ;
x = rot_x; x = rotX;
y = rel_y; y = relY;
z = rot_z; z = rotZ;
} }
return new Vec3(x, y, z); return new Vec3(x, y, z);
} }
set section_position(sect_pos: Vec3) { set sectionPosition(sectPos: Vec3) {
let { x: rel_x, y: rel_y, z: rel_z } = sect_pos; let { x: relX, y: relY, z: relZ } = sectPos;
if (this.section) { if (this.section) {
const sin = -this.section.sin_y_axis_rotation; const sin = -this.section.sinYAxisRotation;
const cos = this.section.cos_y_axis_rotation; const cos = this.section.cosYAxisRotation;
const rot_x = cos * rel_x - sin * rel_z; const rotX = cos * relX - sin * relZ;
const rot_z = sin * rel_x + cos * rel_z; const rotZ = sin * relX + cos * relZ;
const x = rot_x + this.section.position.x; const x = rotX + this.section.position.x;
const y = rel_y + this.section.position.y; const y = relY + this.section.position.y;
const z = rot_z + this.section.position.z; const z = rotZ + this.section.position.z;
this.position = new Vec3(x, y, z); this.position = new Vec3(x, y, z);
} }
} }
@ -165,27 +169,25 @@ export class VisibleQuestEntity {
object3d?: Object3D; object3d?: Object3D;
constructor( constructor(
area_id: number, areaId: number,
section_id: number, sectionId: number,
position: Vec3, position: Vec3,
rotation: Vec3 rotation: Vec3
) { ) {
if (Object.getPrototypeOf(this) === Object.getPrototypeOf(VisibleQuestEntity)) if (Object.getPrototypeOf(this) === Object.getPrototypeOf(VisibleQuestEntity))
throw new Error('Abstract class should not be instantiated directly.'); throw new Error('Abstract class should not be instantiated directly.');
if (!Number.isInteger(area_id) || area_id < 0) if (!Number.isInteger(areaId) || areaId < 0)
throw new Error(`Expected area_id to be a non-negative integer, got ${area_id}.`); throw new Error(`Expected areaId to be a non-negative integer, got ${areaId}.`);
if (!Number.isInteger(section_id) || section_id < 0) if (!Number.isInteger(sectionId) || sectionId < 0)
throw new Error(`Expected section_id to be a non-negative integer, got ${section_id}.`); throw new Error(`Expected sectionId to be a non-negative integer, got ${sectionId}.`);
if (!position) throw new Error('position is required.'); if (!position) throw new Error('position is required.');
if (!rotation) throw new Error('rotation is required.'); if (!rotation) throw new Error('rotation is required.');
this.area_id = area_id; this.areaId = areaId;
this._section_id = section_id; this._sectionId = sectionId;
this.position = position; this.position = position;
this.rotation = rotation; this.rotation = rotation;
} }
private _section_id: number;
} }
export class QuestObject extends VisibleQuestEntity { export class QuestObject extends VisibleQuestEntity {
@ -193,17 +195,17 @@ export class QuestObject extends VisibleQuestEntity {
/** /**
* The raw data from a DAT file. * The raw data from a DAT file.
*/ */
dat: any; dat: DatObject;
constructor( constructor(
area_id: number, areaId: number,
section_id: number, sectionId: number,
position: Vec3, position: Vec3,
rotation: Vec3, rotation: Vec3,
type: ObjectType, type: ObjectType,
dat: any dat: DatObject
) { ) {
super(area_id, section_id, position, rotation); super(areaId, sectionId, position, rotation);
if (!type) throw new Error('type is required.'); if (!type) throw new Error('type is required.');
@ -217,17 +219,17 @@ export class QuestNpc extends VisibleQuestEntity {
/** /**
* The raw data from a DAT file. * The raw data from a DAT file.
*/ */
dat: any; dat: DatNpc;
constructor( constructor(
area_id: number, areaId: number,
section_id: number, sectionId: number,
position: Vec3, position: Vec3,
rotation: Vec3, rotation: Vec3,
type: NpcType, type: NpcType,
dat: any dat: DatNpc
) { ) {
super(area_id, section_id, position, rotation); super(areaId, sectionId, position, rotation);
if (!type) throw new Error('type is required.'); if (!type) throw new Error('type is required.');
@ -240,18 +242,18 @@ export class Area {
id: number; id: number;
name: string; name: string;
order: number; order: number;
area_variants: AreaVariant[]; areaVariants: AreaVariant[];
constructor(id: number, name: string, order: number, area_variants: AreaVariant[]) { constructor(id: number, name: string, order: number, areaVariants: AreaVariant[]) {
if (!Number.isInteger(id) || id < 0) if (!Number.isInteger(id) || id < 0)
throw new Error(`Expected id to be a non-negative integer, got ${id}.`); throw new Error(`Expected id to be a non-negative integer, got ${id}.`);
if (!name) throw new Error('name is required.'); if (!name) throw new Error('name is required.');
if (!area_variants) throw new Error('area_variants is required.'); if (!areaVariants) throw new Error('areaVariants is required.');
this.id = id; this.id = id;
this.name = name; this.name = name;
this.order = order; this.order = order;
this.area_variants = area_variants; this.areaVariants = areaVariants;
} }
} }

2
src/index.css
View File

@ -3,7 +3,7 @@ body {
margin: 0; margin: 0;
} }
body, #phantq-root { body, #phantasmal-world-root {
position: absolute; position: absolute;
top: 0; top: 0;
bottom: 0; bottom: 0;

2
src/index.tsx
View File

@ -8,5 +8,5 @@ import "@blueprintjs/icons/lib/css/blueprint-icons.css";
ReactDOM.render( ReactDOM.render(
<ApplicationComponent />, <ApplicationComponent />,
document.getElementById('phantq-root') document.getElementById('phantasmal-world-root')
); );

20
src/rendering/Renderer.ts
View File

@ -17,7 +17,7 @@ import {
} from 'three'; } from 'three';
import OrbitControlsCreator from 'three-orbit-controls'; import OrbitControlsCreator from 'three-orbit-controls';
import { Vec3, Area, Quest, VisibleQuestEntity, QuestObject, QuestNpc, Section } from '../domain'; import { Vec3, Area, Quest, VisibleQuestEntity, QuestObject, QuestNpc, Section } from '../domain';
import { get_area_collision_geometry, get_area_render_geometry } from '../data/loading/areas'; import { getAreaCollisionGeometry, getAreaRenderGeometry } from '../data/loading/areas';
import { import {
OBJECT_COLOR, OBJECT_COLOR,
OBJECT_HOVER_COLOR, OBJECT_HOVER_COLOR,
@ -115,15 +115,15 @@ export class Renderer {
if (quest) { if (quest) {
for (const obj of quest.objects) { for (const obj of quest.objects) {
const array = this._objs.get(obj.area_id) || []; const array = this._objs.get(obj.areaId) || [];
array.push(obj); array.push(obj);
this._objs.set(obj.area_id, array); this._objs.set(obj.areaId, array);
} }
for (const npc of quest.npcs) { for (const npc of quest.npcs) {
const array = this._npcs.get(npc.area_id) || []; const array = this._npcs.get(npc.areaId) || [];
array.push(npc); array.push(npc);
this._npcs.set(npc.area_id, array); this._npcs.set(npc.areaId, array);
} }
} }
@ -168,10 +168,10 @@ export class Renderer {
if (this._quest && this._area) { if (this._quest && this._area) {
const episode = this._quest.episode; const episode = this._quest.episode;
const area_id = this._area.id; const area_id = this._area.id;
const variant = this._quest.area_variants.find(v => v.area.id === area_id); const variant = this._quest.areaVariants.find(v => v.area.id === area_id);
const variant_id = (variant && variant.id) || 0; const variant_id = (variant && variant.id) || 0;
get_area_collision_geometry(episode, area_id, variant_id).then(geometry => { getAreaCollisionGeometry(episode, area_id, variant_id).then(geometry => {
if (this._quest && this._area) { if (this._quest && this._area) {
this.set_model(undefined); this.set_model(undefined);
this._scene.remove(this._collision_geometry); this._scene.remove(this._collision_geometry);
@ -183,7 +183,7 @@ export class Renderer {
} }
}); });
get_area_render_geometry(episode, area_id, variant_id).then(geometry => { getAreaRenderGeometry(episode, area_id, variant_id).then(geometry => {
if (this._quest && this._area) { if (this._quest && this._area) {
this._render_geometry = geometry; this._render_geometry = geometry;
} }
@ -209,7 +209,7 @@ export class Renderer {
let loaded = true; let loaded = true;
for (const object of this._quest.objects) { for (const object of this._quest.objects) {
if (object.area_id === this._area.id) { if (object.areaId === this._area.id) {
if (object.object3d) { if (object.object3d) {
this._obj_geometry.add(object.object3d); this._obj_geometry.add(object.object3d);
} else { } else {
@ -219,7 +219,7 @@ export class Renderer {
} }
for (const npc of this._quest.npcs) { for (const npc of this._quest.npcs) {
if (npc.area_id === this._area.id) { if (npc.areaId === this._area.id) {
if (npc.object3d) { if (npc.object3d) {
this._npc_geometry.add(npc.object3d); this._npc_geometry.add(npc.object3d);
} else { } else {

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

@ -1,51 +1,52 @@
import { import {
create_object_mesh, createObjectMesh,
create_npc_mesh, createNpcMesh,
OBJECT_COLOR, OBJECT_COLOR,
NPC_COLOR NPC_COLOR
} from './entities'; } from './entities';
import { Object3D, Vector3, MeshLambertMaterial, CylinderBufferGeometry } from 'three'; import { Object3D, Vector3, MeshLambertMaterial, CylinderBufferGeometry } from 'three';
import { Vec3, QuestNpc, QuestObject, Section, NpcType, ObjectType } from '../domain'; import { Vec3, QuestNpc, QuestObject, Section, NpcType, ObjectType } from '../domain';
import { DatObject, DatNpc } from '../data/parsing/dat';
const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0); const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0);
test('create geometry for quest objects', () => { test('create geometry for quest objects', () => {
const object = new QuestObject(7, 13, new Vec3(17, 19, 23), new Vec3(), ObjectType.PrincipalWarp, null); const object = new QuestObject(7, 13, new Vec3(17, 19, 23), new Vec3(), ObjectType.PrincipalWarp, {} as DatObject);
const sect_rot = 0.6; const sectRot = 0.6;
const sect_rot_sin = Math.sin(sect_rot); const sectRotSin = Math.sin(sectRot);
const sect_rot_cos = Math.cos(sect_rot); const sectRotCos = Math.cos(sectRot);
const geometry = create_object_mesh( const geometry = createObjectMesh(
object, [new Section(13, new Vec3(29, 31, 37), sect_rot)], cylinder); object, [new Section(13, new Vec3(29, 31, 37), sectRot)], cylinder);
expect(geometry).toBeInstanceOf(Object3D); expect(geometry).toBeInstanceOf(Object3D);
expect(geometry.name).toBe('Object'); expect(geometry.name).toBe('Object');
expect(geometry.userData.entity).toBe(object); expect(geometry.userData.entity).toBe(object);
expect(geometry.position.x).toBe(sect_rot_cos * 17 + sect_rot_sin * 23 + 29); expect(geometry.position.x).toBe(sectRotCos * 17 + sectRotSin * 23 + 29);
expect(geometry.position.y).toBe(19 + 31); expect(geometry.position.y).toBe(19 + 31);
expect(geometry.position.z).toBe(-sect_rot_sin * 17 + sect_rot_cos * 23 + 37); expect(geometry.position.z).toBe(-sectRotSin * 17 + sectRotCos * 23 + 37);
expect((geometry.material as MeshLambertMaterial).color.getHex()).toBe(OBJECT_COLOR); expect((geometry.material as MeshLambertMaterial).color.getHex()).toBe(OBJECT_COLOR);
}); });
test('create geometry for quest NPCs', () => { test('create geometry for quest NPCs', () => {
const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, null); const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc);
const sect_rot = 0.6; const sectRot = 0.6;
const sect_rot_sin = Math.sin(sect_rot); const sectRotSin = Math.sin(sectRot);
const sect_rot_cos = Math.cos(sect_rot); const sectRotCos = Math.cos(sectRot);
const geometry = create_npc_mesh( const geometry = createNpcMesh(
npc, [new Section(13, new Vec3(29, 31, 37), sect_rot)], cylinder); npc, [new Section(13, new Vec3(29, 31, 37), sectRot)], cylinder);
expect(geometry).toBeInstanceOf(Object3D); expect(geometry).toBeInstanceOf(Object3D);
expect(geometry.name).toBe('NPC'); expect(geometry.name).toBe('NPC');
expect(geometry.userData.entity).toBe(npc); expect(geometry.userData.entity).toBe(npc);
expect(geometry.position.x).toBe(sect_rot_cos * 17 + sect_rot_sin * 23 + 29); expect(geometry.position.x).toBe(sectRotCos * 17 + sectRotSin * 23 + 29);
expect(geometry.position.y).toBe(19 + 31); expect(geometry.position.y).toBe(19 + 31);
expect(geometry.position.z).toBe(-sect_rot_sin * 17 + sect_rot_cos * 23 + 37); expect(geometry.position.z).toBe(-sectRotSin * 17 + sectRotCos * 23 + 37);
expect((geometry.material as MeshLambertMaterial).color.getHex()).toBe(NPC_COLOR); expect((geometry.material as MeshLambertMaterial).color.getHex()).toBe(NPC_COLOR);
}); });
test('geometry position changes when entity position changes element-wise', () => { test('geometry position changes when entity position changes element-wise', () => {
const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, null); const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc);
const geometry = create_npc_mesh( const geometry = createNpcMesh(
npc, [new Section(13, new Vec3(0, 0, 0), 0)], cylinder); npc, [new Section(13, new Vec3(0, 0, 0), 0)], cylinder);
npc.position = new Vec3(2, 3, 5).add(npc.position); npc.position = new Vec3(2, 3, 5).add(npc.position);
@ -53,8 +54,8 @@ test('geometry position changes when entity position changes element-wise', () =
}); });
test('geometry position changes when entire entity position changes', () => { test('geometry position changes when entire entity position changes', () => {
const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, null); const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc);
const geometry = create_npc_mesh( const geometry = createNpcMesh(
npc, [new Section(13, new Vec3(0, 0, 0), 0)], cylinder); npc, [new Section(13, new Vec3(0, 0, 0), 0)], cylinder);
npc.position = new Vec3(2, 3, 5); npc.position = new Vec3(2, 3, 5);

38
src/rendering/entities.ts
View File

@ -9,15 +9,15 @@ export const NPC_COLOR = 0xFF0000;
export const NPC_HOVER_COLOR = 0xFF3F5F; export const NPC_HOVER_COLOR = 0xFF3F5F;
export const NPC_SELECTED_COLOR = 0xFF0054; export const NPC_SELECTED_COLOR = 0xFF0054;
export function create_object_mesh(object: QuestObject, sections: Section[], geometry: BufferGeometry): Mesh { export function createObjectMesh(object: QuestObject, sections: Section[], geometry: BufferGeometry): Mesh {
return create_mesh(object, sections, geometry, OBJECT_COLOR, 'Object'); return createMesh(object, sections, geometry, OBJECT_COLOR, 'Object');
} }
export function create_npc_mesh(npc: QuestNpc, sections: Section[], geometry: BufferGeometry): Mesh { export function createNpcMesh(npc: QuestNpc, sections: Section[], geometry: BufferGeometry): Mesh {
return create_mesh(npc, sections, geometry, NPC_COLOR, 'NPC'); return createMesh(npc, sections, geometry, NPC_COLOR, 'NPC');
} }
function create_mesh( function createMesh(
entity: VisibleQuestEntity, entity: VisibleQuestEntity,
sections: Section[], sections: Section[],
geometry: BufferGeometry, geometry: BufferGeometry,
@ -26,39 +26,39 @@ function create_mesh(
): Mesh { ): Mesh {
let {x, y, z} = entity.position; let {x, y, z} = entity.position;
const section = sections.find(s => s.id === entity.section_id); const section = sections.find(s => s.id === entity.sectionId);
entity.section = section; entity.section = section;
if (section) { if (section) {
const {x: sec_x, y: sec_y, z: sec_z} = section.position; const {x: secX, y: secY, z: secZ} = section.position;
const rot_x = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z; const rotX = section.cosYAxisRotation * x + section.sinYAxisRotation * z;
const rot_z = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z; const rotZ = -section.sinYAxisRotation * x + section.cosYAxisRotation * z;
x = rot_x + sec_x; x = rotX + secX;
y += sec_y; y += secY;
z = rot_z + sec_z; z = rotZ + secZ;
} else { } else {
console.warn(`Section ${entity.section_id} not found.`); console.warn(`Section ${entity.sectionId} not found.`);
} }
const object_3d = new Mesh( const object3d = new Mesh(
geometry, geometry,
new MeshLambertMaterial({ new MeshLambertMaterial({
color, color,
side: DoubleSide side: DoubleSide
}) })
); );
object_3d.name = type; object3d.name = type;
object_3d.userData.entity = entity; object3d.userData.entity = entity;
// TODO: dispose autorun? // TODO: dispose autorun?
autorun(() => { autorun(() => {
const {x, y, z} = entity.position; const {x, y, z} = entity.position;
object_3d.position.set(x, y, z); object3d.position.set(x, y, z);
const rot = entity.rotation; const rot = entity.rotation;
object_3d.rotation.set(rot.x, rot.y, rot.z); object3d.rotation.set(rot.x, rot.y, rot.z);
}); });
entity.position = new Vec3(x, y, z); entity.position = new Vec3(x, y, z);
return object_3d; return object3d;
} }

2
src/rendering/models.ts
View File

@ -1,6 +1,6 @@
import { BufferGeometry, DoubleSide, Mesh, MeshLambertMaterial } from 'three'; import { BufferGeometry, DoubleSide, Mesh, MeshLambertMaterial } from 'three';
export function create_model_mesh(geometry?: BufferGeometry): Mesh | undefined { export function createModelMesh(geometry?: BufferGeometry): Mesh | undefined {
return geometry && new Mesh( return geometry && new Mesh(
geometry, geometry,
new MeshLambertMaterial({ new MeshLambertMaterial({

28
src/store.ts
View File

@ -5,7 +5,7 @@ import { Area, AreaVariant, Quest, VisibleQuestEntity } from './domain';
function area(id: number, name: string, order: number, variants: number) { function area(id: number, name: string, order: number, variants: number) {
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.areaVariants.splice(0, 0, ...varis);
return area; return area;
} }
@ -69,29 +69,29 @@ class AreaStore {
]; ];
} }
get_variant(episode: number, area_id: number, variant_id: number) { getVariant(episode: number, areaId: number, variantId: number) {
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}.`);
const area = this.areas[episode].find(a => a.id === area_id); const area = this.areas[episode].find(a => a.id === areaId);
if (!area) if (!area)
throw new Error(`Area id ${area_id} for episode ${episode} is invalid.`); throw new Error(`Area id ${areaId} for episode ${episode} is invalid.`);
const area_variant = area.area_variants[variant_id]; const areaVariant = area.areaVariants[variantId];
if (!area_variant) if (!areaVariant)
throw new Error(`Area variant id ${variant_id} for area ${area_id} of episode ${episode} is invalid.`); throw new Error(`Area variant id ${variantId} for area ${areaId} of episode ${episode} is invalid.`);
return area_variant; return areaVariant;
} }
} }
export const area_store = new AreaStore(); export const areaStore = new AreaStore();
class ApplicationState { class ApplicationState {
@observable current_model?: Object3D; @observable currentModel?: Object3D;
@observable current_quest?: Quest; @observable currentQuest?: Quest;
@observable current_area?: Area; @observable currentArea?: Area;
@observable selected_entity?: VisibleQuestEntity; @observable selectedEntity?: VisibleQuestEntity;
} }
export const application_state = new ApplicationState(); export const applicationState = new ApplicationState();

12
src/ui/ApplicationComponent.tsx
View File

@ -1,7 +1,7 @@
import React, { ChangeEvent, KeyboardEvent } from 'react'; import React, { ChangeEvent, KeyboardEvent } from 'react';
import { observer } from 'mobx-react'; import { observer } from 'mobx-react';
import { Button, Dialog, Intent } from '@blueprintjs/core'; import { Button, Dialog, Intent } from '@blueprintjs/core';
import { application_state } from '../store'; import { applicationState } from '../store';
import { current_area_id_changed, load_file, save_current_quest_to_file } from '../actions'; import { current_area_id_changed, load_file, save_current_quest_to_file } from '../actions';
import { Area3DComponent } from './Area3DComponent'; import { Area3DComponent } from './Area3DComponent';
import { EntityInfoComponent } from './EntityInfoComponent'; import { EntityInfoComponent } from './EntityInfoComponent';
@ -21,10 +21,10 @@ export class ApplicationComponent extends React.Component<{}, {
}; };
render() { render() {
const quest = application_state.current_quest; const quest = applicationState.currentQuest;
const model = application_state.current_model; const model = applicationState.currentModel;
const areas = quest ? Array.from(quest.area_variants).map(a => a.area) : undefined; const areas = quest ? Array.from(quest.areaVariants).map(a => a.area) : undefined;
const area = application_state.current_area; const area = applicationState.currentArea;
const area_id = area ? String(area.id) : undefined; const area_id = area ? String(area.id) : undefined;
return ( return (
@ -73,7 +73,7 @@ export class ApplicationComponent extends React.Component<{}, {
quest={quest} quest={quest}
area={area} area={area}
model={model} /> model={model} />
<EntityInfoComponent entity={application_state.selected_entity} /> <EntityInfoComponent entity={applicationState.selectedEntity} />
</div> </div>
<Dialog <Dialog
title="Save as..." title="Save as..."

2
src/ui/EntityInfoComponent.tsx
View File

@ -44,7 +44,7 @@ export class EntityInfoComponent extends React.Component<Props, any> {
const entity = this.props.entity; const entity = this.props.entity;
if (entity) { if (entity) {
const section_id = entity.section ? entity.section.id : entity.section_id; const section_id = entity.section ? entity.section.id : entity.sectionId;
let name = null; let name = null;
if (entity instanceof QuestObject) { if (entity instanceof QuestObject) {

4
src/ui/QuestInfoComponent.tsx
View File

@ -64,12 +64,12 @@ export function QuestInfoComponent({ quest }: { quest?: Quest }) {
</tr> </tr>
<tr> <tr>
<td colSpan={2}> <td colSpan={2}>
<pre className="bp3-code-block" style={description_style}>{quest.short_description}</pre> <pre className="bp3-code-block" style={description_style}>{quest.shortDescription}</pre>
</td> </td>
</tr> </tr>
<tr> <tr>
<td colSpan={2}> <td colSpan={2}>
<pre className="bp3-code-block" style={description_style}>{quest.long_description}</pre> <pre className="bp3-code-block" style={description_style}>{quest.longDescription}</pre>
</td> </td>
</tr> </tr>
</tbody> </tbody>

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 walk_qst_files( export function walkQstFiles(
f: (path: string, file_name: string, contents: Buffer) => void, f: (path: string, fileName: 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 get_qst_files(dir)) { for (const [path, file] of getQstFiles(dir)) {
f(path, file, fs.readFileSync(path)); f(path, file, fs.readFileSync(path));
} }
} }
export function get_qst_files(dir: string): [string, string][] { export function getQstFiles(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 get_qst_files(dir: string): [string, string][] {
const stats = fs.statSync(path); const stats = fs.statSync(path);
if (stats.isDirectory()) { if (stats.isDirectory()) {
files = files.concat(get_qst_files(path)); files = files.concat(getQstFiles(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.