diff --git a/public/index.html b/public/index.html index 1dcf0c39..727393c7 100644 --- a/public/index.html +++ b/public/index.html @@ -6,7 +6,7 @@ -
+
\ No newline at end of file diff --git a/src/actions.ts b/src/actions.ts index c46899b4..f1a6d1cb 100644 --- a/src/actions.ts +++ b/src/actions.ts @@ -1,15 +1,15 @@ import { ArrayBufferCursor } from './data/ArrayBufferCursor'; -import { application_state } from './store'; -import { parse_quest, write_quest_qst } from './data/parsing/quest'; -import { parse_nj, parse_xj } from './data/parsing/ninja'; -import { get_area_sections } from './data/loading/areas'; -import { get_npc_geometry, get_object_geometry } from './data/loading/entities'; -import { create_object_mesh, create_npc_mesh } from './rendering/entities'; -import { create_model_mesh } from './rendering/models'; +import { applicationState } from './store'; +import { parseQuest, writeQuestQst } from './data/parsing/quest'; +import { parseNj, parseXj} from './data/parsing/ninja'; +import { getAreaSections } from './data/loading/areas'; +import { getNpcGeometry, getObjectGeometry } from './data/loading/entities'; +import { createObjectMesh, createNpcMesh } from './rendering/entities'; +import { createModelMesh } from './rendering/models'; import { VisibleQuestEntity } from './domain'; export function entity_selected(entity?: VisibleQuestEntity) { - application_state.selected_entity = entity; + applicationState.selectedEntity = entity; } export function load_file(file: File) { @@ -25,45 +25,45 @@ export function load_file(file: File) { // Reset application state, then set the current model. // Might want to do this in a MobX transaction. 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')) { // Reset application state, then set the current model. // Might want to do this in a MobX transaction. 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 { - const quest = parse_quest(new ArrayBufferCursor(reader.result, true)); + const quest = parseQuest(new ArrayBufferCursor(reader.result, true)); if (quest) { // Reset application state, then set current quest and area in the correct order. // Might want to do this in a MobX transaction. reset_model_and_quest_state(); - application_state.current_quest = quest; + applicationState.currentQuest = quest; - if (quest.area_variants.length) { - application_state.current_area = quest.area_variants[0].area; + if (quest.areaVariants.length) { + applicationState.currentArea = quest.areaVariants[0].area; } // Load section data. - for (const variant of quest.area_variants) { - const sections = await get_area_sections(quest.episode, variant.area.id, variant.id) + for (const variant of quest.areaVariants) { + const sections = await getAreaSections(quest.episode, variant.area.id, variant.id) variant.sections = sections; // 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 { - const geometry = await get_object_geometry(object.type); - object.object3d = create_object_mesh(object, sections, geometry); + const geometry = await getObjectGeometry(object.type); + object.object3d = createObjectMesh(object, sections, geometry); } catch (e) { console.error(e); } } // 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 { - const geometry = await get_npc_geometry(npc.type); - npc.object3d = create_npc_mesh(npc, sections, geometry); + const geometry = await getNpcGeometry(npc.type); + npc.object3d = createNpcMesh(npc, sections, geometry); } catch (e) { console.error(e); } @@ -77,20 +77,20 @@ export function load_file(file: File) { } export function current_area_id_changed(area_id?: number) { - application_state.selected_entity = undefined; + applicationState.selectedEntity = undefined; if (area_id == null) { - application_state.current_area = undefined; - } else if (application_state.current_quest) { - const area_variant = application_state.current_quest.area_variants.find( + applicationState.currentArea = undefined; + } else if (applicationState.currentQuest) { + const area_variant = applicationState.currentQuest.areaVariants.find( 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) { - if (application_state.current_quest) { - const cursor = write_quest_qst(application_state.current_quest, file_name); + if (applicationState.currentQuest) { + const cursor = writeQuestQst(applicationState.currentQuest, file_name); if (!file_name.endsWith('.qst')) { file_name += '.qst'; @@ -107,8 +107,8 @@ export function save_current_quest_to_file(file_name: string) { } function reset_model_and_quest_state() { - application_state.current_quest = undefined; - application_state.current_area = undefined; - application_state.selected_entity = undefined; - application_state.current_model = undefined; + applicationState.currentQuest = undefined; + applicationState.currentArea = undefined; + applicationState.selectedEntity = undefined; + applicationState.currentModel = undefined; } diff --git a/src/data/ArrayBufferCursor.test.ts b/src/data/ArrayBufferCursor.test.ts index 09eb892b..b9ca15d3 100644 --- a/src/data/ArrayBufferCursor.test.ts +++ b/src/data/ArrayBufferCursor.test.ts @@ -3,24 +3,24 @@ import { ArrayBufferCursor } from './ArrayBufferCursor'; test('simple properties and invariants', () => { 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).toBe(0); expect(cursor.capacity).toBe(10); expect(cursor.position).toBe(0); - expect(cursor.bytes_left).toBe(0); - expect(cursor.little_endian).toBe(true); + expect(cursor.bytesLeft).toBe(0); + 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); - 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).toBe(4); expect(cursor.capacity).toBe(10); expect(cursor.position).toBe(3); - expect(cursor.bytes_left).toBe(1); - expect(cursor.little_endian).toBe(true); + expect(cursor.bytesLeft).toBe(1); + expect(cursor.littleEndian).toBe(true); }); test('correct byte order handling', () => { @@ -32,200 +32,200 @@ test('correct byte order handling', () => { test('reallocation of internal buffer when necessary', () => { 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.capacity).toBeGreaterThanOrEqual(4); expect(cursor.buffer.byteLength).toBeGreaterThanOrEqual(4); }); -function test_integer_read(method_name: string) { - test(method_name, () => { - const bytes = parseInt(method_name.replace(/^[iu](\d+)$/, '$1'), 10) / 8; - let test_number_1 = 0; - let test_number_2 = 0; +function testIntegerRead(methodName: string) { + test(methodName, () => { + const bytes = parseInt(methodName.replace(/^[iu](\d+)$/, '$1'), 10) / 8; + let testNumber1 = 0; + let testNumber2 = 0; // 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) { // Generates numbers of the form 0x010203... - test_number_1 <<= 8; - test_number_1 |= i; - test_arrays['false'].push(i); - test_arrays['true'].unshift(i); + testNumber1 <<= 8; + testNumber1 |= i; + testArrays['false'].push(i); + testArrays['true'].unshift(i); } for (let i = bytes + 1; i <= 2 * bytes; ++i) { - test_number_2 <<= 8; - test_number_2 |= i; - test_arrays['false'].push(i); - test_arrays['true'].splice(bytes, 0, i); + testNumber2 <<= 8; + testNumber2 |= i; + testArrays['false'].push(i); + testArrays['true'].splice(bytes, 0, i); } - for (const little_endian of [false, true]) { + for (const littleEndian of [false, true]) { 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 as any)[method_name]()).toBe(test_number_2); + expect((cursor as any)[methodName]()).toBe(testNumber2); expect(cursor.position).toBe(2 * bytes); } }); } -test_integer_read('u8'); -test_integer_read('u16'); -test_integer_read('u32'); -test_integer_read('i32'); +testIntegerRead('u8'); +testIntegerRead('u16'); +testIntegerRead('u32'); +testIntegerRead('i32'); -test('u8_array', () => { +test('u8Array', () => { 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.seek_start(2).u8_array(4)).toEqual([3, 4, 5, 6]); - expect(cursor.seek_start(5).u8_array(3)).toEqual([6, 7, 8]); + expect(cursor.u8Array(3)).toEqual([1, 2, 3]); + expect(cursor.seekStart(2).u8Array(4)).toEqual([3, 4, 5, 6]); + expect(cursor.seekStart(5).u8Array(3)).toEqual([6, 7, 8]); }); -function test_string_read(method_name: string, char_size: number) { - test(method_name, () => { - const char_array = [7, 65, 66, 0, 255, 13]; +function testStringRead(methodName: string, charSize: number) { + test(methodName, () => { + const charArray = [7, 65, 66, 0, 255, 13]; - for (const little_endian of [false, true]) { - const char_array_copy = []; + for (const littleEndian of [false, true]) { + const charArrayCopy = []; - for (const char of char_array) { - if (little_endian) char_array_copy.push(char); + for (const char of charArray) { + if (littleEndian) charArrayCopy.push(char); - for (let i = 0; i < char_size - 1; ++i) { - char_array_copy.push(0); + for (let i = 0; i < charSize - 1; ++i) { + charArrayCopy.push(0); } - if (!little_endian) char_array_copy.push(char); + if (!littleEndian) charArrayCopy.push(char); } const cursor = new ArrayBufferCursor( - new Uint8Array(char_array_copy).buffer, little_endian); + new Uint8Array(charArrayCopy).buffer, littleEndian); - cursor.seek_start(char_size); - expect((cursor as any)[method_name](4 * char_size, true, true)).toBe('AB'); - expect(cursor.position).toBe(5 * char_size); - cursor.seek_start(char_size); - expect((cursor as any)[method_name](2 * char_size, true, true)).toBe('AB'); - expect(cursor.position).toBe(3 * char_size); + cursor.seekStart(charSize); + expect((cursor as any)[methodName](4 * charSize, true, true)).toBe('AB'); + expect(cursor.position).toBe(5 * charSize); + cursor.seekStart(charSize); + expect((cursor as any)[methodName](2 * charSize, true, true)).toBe('AB'); + expect(cursor.position).toBe(3 * charSize); - cursor.seek_start(char_size); - expect((cursor as any)[method_name](4 * char_size, true, false)).toBe('AB'); - expect(cursor.position).toBe(4 * char_size); - cursor.seek_start(char_size); - expect((cursor as any)[method_name](2 * char_size, true, false)).toBe('AB'); - expect(cursor.position).toBe(3 * char_size); + cursor.seekStart(charSize); + expect((cursor as any)[methodName](4 * charSize, true, false)).toBe('AB'); + expect(cursor.position).toBe(4 * charSize); + cursor.seekStart(charSize); + expect((cursor as any)[methodName](2 * charSize, true, false)).toBe('AB'); + expect(cursor.position).toBe(3 * charSize); - cursor.seek_start(char_size); - expect((cursor as any)[method_name](4 * char_size, false, true)).toBe('AB\0ÿ'); - expect(cursor.position).toBe(5 * char_size); + cursor.seekStart(charSize); + expect((cursor as any)[methodName](4 * charSize, false, true)).toBe('AB\0ÿ'); + expect(cursor.position).toBe(5 * charSize); - cursor.seek_start(char_size); - expect((cursor as any)[method_name](4 * char_size, false, false)).toBe('AB\0ÿ'); - expect(cursor.position).toBe(5 * char_size); + cursor.seekStart(charSize); + expect((cursor as any)[methodName](4 * charSize, false, false)).toBe('AB\0ÿ'); + expect(cursor.position).toBe(5 * charSize); } }); } -test_string_read('string_ascii', 1); -test_string_read('string_utf_16', 2); +testStringRead('stringAscii', 1); +testStringRead('stringUtf16', 2); -function test_integer_write(method_name: string) { - test(method_name, () => { - const bytes = parseInt(method_name.replace(/^write_[iu](\d+)$/, '$1'), 10) / 8; - let test_number_1 = 0; - let test_number_2 = 0; +function testIntegerWrite(methodName: string) { + test(methodName, () => { + const bytes = parseInt(methodName.replace(/^write[IU](\d+)$/, '$1'), 10) / 8; + let testNumber1 = 0; + let testNumber2 = 0; // 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 test_arrays_2: { [index: string]: number[] } = { false: [], true: [] }; + const testArrays1: { [index: string]: number[] } = { false: [], true: [] }; + const testArrays2: { [index: string]: number[] } = { false: [], true: [] }; for (let i = 1; i <= bytes; ++i) { // Generates numbers of the form 0x010203... - test_number_1 <<= 8; - test_number_1 |= i; - test_number_2 <<= 8; - test_number_2 |= i + bytes; - test_arrays_1['false'].push(i); - test_arrays_1['true'].unshift(i); - test_arrays_2['false'].push(i + bytes); - test_arrays_2['true'].unshift(i + bytes); + testNumber1 <<= 8; + testNumber1 |= i; + testNumber2 <<= 8; + testNumber2 |= i + bytes; + testArrays1['false'].push(i); + testArrays1['true'].unshift(i); + testArrays2['false'].push(i + bytes); + testArrays2['true'].unshift(i + bytes); } - for (const little_endian of [false, true]) { - const cursor = new ArrayBufferCursor(0, little_endian); - (cursor as any)[method_name](test_number_1); + for (const littleEndian of [false, true]) { + const cursor = new ArrayBufferCursor(0, littleEndian); + (cursor as any)[methodName](testNumber1); expect(cursor.position).toBe(bytes); - expect(cursor.seek_start(0).u8_array(bytes)) - .toEqual(test_arrays_1[String(little_endian)]); + expect(cursor.seekStart(0).u8Array(bytes)) + .toEqual(testArrays1[String(littleEndian)]); 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.seek_start(0).u8_array(2 * bytes)) - .toEqual(test_arrays_1[String(little_endian)].concat(test_arrays_2[String(little_endian)])); + expect(cursor.seekStart(0).u8Array(2 * bytes)) + .toEqual(testArrays1[String(littleEndian)].concat(testArrays2[String(littleEndian)])); } }); } -test_integer_write('write_u8'); -test_integer_write('write_u16'); -test_integer_write('write_u32'); +testIntegerWrite('writeU8'); +testIntegerWrite('writeU16'); +testIntegerWrite('writeU32'); -test('write_f32', () => { - for (const little_endian of [false, true]) { - const cursor = new ArrayBufferCursor(0, little_endian); - cursor.write_f32(1337.9001); +test('writeF32', () => { + for (const littleEndian of [false, true]) { + const cursor = new ArrayBufferCursor(0, littleEndian); + cursor.writeF32(1337.9001); expect(cursor.position).toBe(4); expect(cursor.seek(-4).f32()).toBeCloseTo(1337.9001, 4); expect(cursor.position).toBe(4); - cursor.write_f32(103.502); + cursor.writeF32(103.502); expect(cursor.position).toBe(8); expect(cursor.seek(-4).f32()).toBeCloseTo(103.502, 3); } }); -test('write_u8_array', () => { - for (const little_endian of [false, true]) { +test('writeU8Array', () => { + for (const littleEndian of [false, true]) { const bytes = 10; - const cursor = new ArrayBufferCursor(2 * bytes, little_endian); - const uint8_array = new Uint8Array(cursor.buffer); - const test_array_1 = []; - const test_array_2 = []; + const cursor = new ArrayBufferCursor(2 * bytes, littleEndian); + const uint8Array = new Uint8Array(cursor.buffer); + const testArray1 = []; + const testArray2 = []; for (let i = 1; i <= bytes; ++i) { - test_array_1.push(i); - test_array_2.push(i + bytes); + testArray1.push(i); + testArray2.push(i + bytes); } - cursor.write_u8_array(test_array_1); + cursor.writeU8Array(testArray1); expect(cursor.position).toBe(bytes); 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); 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) { - expect(uint8_array[i + bytes]).toBe(test_array_2[i]); + expect(uint8Array[i + bytes]).toBe(testArray2[i]); } } }); diff --git a/src/data/ArrayBufferCursor.ts b/src/data/ArrayBufferCursor.ts index efeea9d4..93be5f64 100644 --- a/src/data/ArrayBufferCursor.ts +++ b/src/data/ArrayBufferCursor.ts @@ -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. */ 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. */ @@ -26,7 +28,7 @@ export class ArrayBufferCursor { throw new Error('Size should be non-negative.') } - this._ensure_capacity(size); + this.ensureCapacity(size); this._size = size; } @@ -38,12 +40,12 @@ export class ArrayBufferCursor { /** * Byte order mode. */ - little_endian: boolean; + littleEndian: boolean; /** * The amount of bytes left to read from the current position onward. */ - get bytes_left(): number { + get bytesLeft(): number { return this.size - this.position; } @@ -56,46 +58,41 @@ export class ArrayBufferCursor { buffer: ArrayBuffer; - private _size: number = 0; - private _dv: DataView; - private _uint8_array: Uint8Array; - private _utf_16_decoder: TextDecoder; - private _utf_16_encoder: TextEncoder; + private dv: DataView; + private uint8Array: Uint8Array; + private utf16Decoder: TextDecoder; + private utf16Encoder: 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 little_endian - Decides in which byte order multi-byte integers and floats will be interpreted + * @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 littleEndian - Decides in which byte order multi-byte integers and floats will be interpreted */ - constructor(buffer_or_capacity: ArrayBuffer | number, little_endian?: boolean) { - if (typeof buffer_or_capacity === 'number') { - this.buffer = new ArrayBuffer(buffer_or_capacity); + constructor(bufferOrCapacity: ArrayBuffer | number, littleEndian?: boolean) { + if (typeof bufferOrCapacity === 'number') { + this.buffer = new ArrayBuffer(bufferOrCapacity); this.size = 0; - } else if (buffer_or_capacity instanceof ArrayBuffer) { - this.buffer = buffer_or_capacity; + } else if (bufferOrCapacity instanceof ArrayBuffer) { + this.buffer = bufferOrCapacity; this.size = this.buffer.byteLength; } else { 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._dv = new DataView(this.buffer); - this._uint8_array = new Uint8Array(this.buffer, 0, this.size); - this._utf_16_decoder = little_endian ? UTF_16LE_DECODER : UTF_16BE_DECODER; - this._utf_16_encoder = little_endian ? UTF_16LE_ENCODER : UTF_16BE_ENCODER; + this.dv = new DataView(this.buffer); + this.uint8Array = new Uint8Array(this.buffer, 0, this.size); + this.utf16Decoder = littleEndian ? UTF_16LE_DECODER : UTF_16BE_DECODER; + this.utf16Encoder = littleEndian ? UTF_16LE_ENCODER : UTF_16BE_ENCODER; } - // - // Public methods - // - /** * Seek forward or backward by a number of bytes. * * @param offset - if positive, seeks forward by offset bytes, otherwise seeks backward by -offset bytes. */ 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 */ - seek_start(offset: number) { + seekStart(offset: number) { if (offset < 0 || offset > this.size) { 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 */ - seek_end(offset: number) { + seekEnd(offset: number) { if (offset < 0 || offset > this.size) { 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. */ u8() { - return this._dv.getUint8(this.position++); + return this.dv.getUint8(this.position++); } /** * Reads an unsigned 16-bit integer and increments position by 2. */ u16() { - const r = this._dv.getUint16(this.position, this.little_endian); + const r = this.dv.getUint16(this.position, this.littleEndian); this.position += 2; return r; } @@ -146,7 +143,7 @@ export class ArrayBufferCursor { * Reads an unsigned 32-bit integer and increments position by 4. */ u32() { - const r = this._dv.getUint32(this.position, this.little_endian); + const r = this.dv.getUint32(this.position, this.littleEndian); this.position += 4; return r; } @@ -155,7 +152,7 @@ export class ArrayBufferCursor { * Reads a signed 16-bit integer and increments position by 2. */ i16() { - const r = this._dv.getInt16(this.position, this.little_endian); + const r = this.dv.getInt16(this.position, this.littleEndian); this.position += 2; return r; } @@ -164,7 +161,7 @@ export class ArrayBufferCursor { * Reads a signed 32-bit integer and increments position by 4. */ i32() { - const r = this._dv.getInt32(this.position, this.little_endian); + const r = this.dv.getInt32(this.position, this.littleEndian); this.position += 4; return r; } @@ -173,7 +170,7 @@ export class ArrayBufferCursor { * Reads a 32-bit floating point number and increments position by 4. */ f32() { - const r = this._dv.getFloat32(this.position, this.little_endian); + const r = this.dv.getFloat32(this.position, this.littleEndian); this.position += 4; return r; } @@ -181,20 +178,20 @@ export class ArrayBufferCursor { /** * Reads n unsigned 8-bit integers and increments position by n. */ - u8_array(n: number): number[] { + u8Array(n: number): number[] { 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; } /** * Reads n unsigned 16-bit integers and increments position by 2n. */ - u16_array(n: number): number[] { + u16Array(n: number): number[] { const array = []; 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; } @@ -214,48 +211,48 @@ export class ArrayBufferCursor { this.position += size; 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) { - const string_length = null_terminated - ? this._index_of_u8(0, max_byte_length) - this.position - : max_byte_length; + stringAscii(maxByteLength: number, nullTerminated: boolean, dropRemaining: boolean) { + const string_length = nullTerminated + ? this.indexOfU8(0, maxByteLength) - this.position + : maxByteLength; const r = ASCII_DECODER.decode( new DataView(this.buffer, this.position, string_length)); - this.position += drop_remaining - ? max_byte_length - : Math.min(string_length + 1, max_byte_length); + this.position += dropRemaining + ? maxByteLength + : Math.min(string_length + 1, maxByteLength); 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) { - const string_length = null_terminated - ? this._index_of_u16(0, max_byte_length) - this.position - : Math.floor(max_byte_length / 2) * 2; + stringUtf16(maxByteLength: number, nullTerminated: boolean, dropRemaining: boolean) { + const stringLength = nullTerminated + ? this.indexOfU16(0, maxByteLength) - this.position + : Math.floor(maxByteLength / 2) * 2; - const r = this._utf_16_decoder.decode( - new DataView(this.buffer, this.position, string_length)); - this.position += drop_remaining - ? max_byte_length - : Math.min(string_length + 2, max_byte_length); + const r = this.utf16Decoder.decode( + new DataView(this.buffer, this.position, stringLength)); + this.position += dropRemaining + ? maxByteLength + : Math.min(stringLength + 2, maxByteLength); return r; } /** * 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) { - this._ensure_capacity(this.position + 1); + writeU8(value: number) { + this.ensureCapacity(this.position + 1); - this._dv.setUint8(this.position++, value); + this.dv.setUint8(this.position++, value); if (this.position > this.size) { 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. */ - write_u16(value: number) { - this._ensure_capacity(this.position + 2); + writeU16(value: number) { + 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; 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. */ - write_u32(value: number) { - this._ensure_capacity(this.position + 4); + writeU32(value: number) { + 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; 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) { - this._ensure_capacity(this.position + 4); + writeI32(value: number) { + 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; 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. */ - write_f32(value: number) { - this._ensure_capacity(this.position + 4); + writeF32(value: number) { + 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; 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. */ - write_u8_array(array: number[]) { - this._ensure_capacity(this.position + array.length); + writeU8Array(array: number[]) { + this.ensureCapacity(this.position + array.length); new Uint8Array(this.buffer, this.position).set(new Uint8Array(array)); 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. */ - write_cursor(other: ArrayBufferCursor) { - this._ensure_capacity(this.position + other.size); + writeCursor(other: ArrayBufferCursor) { + this.ensureCapacity(this.position + other.size); new Uint8Array(this.buffer, this.position).set(new Uint8Array(other.buffer)); this.position += other.size; @@ -360,18 +357,18 @@ export class ArrayBufferCursor { return this; } - write_string_ascii(str: string, byte_length: number) { + writeStringAscii(str: string, byteLength: number) { let i = 0; for (const byte of ASCII_ENCODER.encode(str)) { - if (i < byte_length) { - this.write_u8(byte); + if (i < byteLength) { + this.writeU8(byte); ++i; } } - while (i < byte_length) { - this.write_u8(0); + while (i < byteLength) { + this.writeU8(0); ++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. */ - uint8_array_view(): Uint8Array { - return this._uint8_array; + uint8ArrayView(): Uint8Array { + return this.uint8Array; } - // - // Private methods - // + private indexOfU8(value: number, maxByteLength: number) { + const maxPos = Math.min(this.position + maxByteLength, this.size); - _index_of_u8(value: number, max_byte_length: number) { - const max_pos = Math.min(this.position + max_byte_length, this.size); - - for (let i = this.position; i < max_pos; ++i) { - if (this._dv.getUint8(i) === value) { + for (let i = this.position; i < maxPos; ++i) { + if (this.dv.getUint8(i) === value) { return i; } } - return this.position + max_byte_length; + return this.position + maxByteLength; } - _index_of_u16(value: number, max_byte_length: number) { - const max_pos = Math.min(this.position + max_byte_length, this.size); + private indexOfU16(value: number, maxByteLength: number) { + const maxPos = Math.min(this.position + maxByteLength, this.size); - for (let i = this.position; i < max_pos; i += 2) { - if (this._dv.getUint16(i, this.little_endian) === value) { + for (let i = this.position; i < maxPos; i += 2) { + if (this.dv.getUint16(i, this.littleEndian) === value) { return i; } } - return this.position + max_byte_length; + return this.position + maxByteLength; } /** * Increases buffer size if necessary. */ - _ensure_capacity(min_new_size: number) { - if (min_new_size > this.capacity) { - let new_size = this.capacity || min_new_size; + private ensureCapacity(minNewSize: number) { + if (minNewSize > this.capacity) { + let newSize = this.capacity || minNewSize; do { - new_size *= 2; - } while (new_size < min_new_size); + newSize *= 2; + } while (newSize < minNewSize); - const new_buffer = new ArrayBuffer(new_size); - new Uint8Array(new_buffer).set(new Uint8Array(this.buffer, 0, this.size)); - this.buffer = new_buffer; - this._dv = new DataView(this.buffer); - this._uint8_array = new Uint8Array(this.buffer, 0, min_new_size); + const newBuffer = new ArrayBuffer(newSize); + new Uint8Array(newBuffer).set(new Uint8Array(this.buffer, 0, this.size)); + this.buffer = newBuffer; + this.dv = new DataView(this.buffer); + this.uint8Array = new Uint8Array(this.buffer, 0, minNewSize); } } } diff --git a/src/data/compression/prs/compress.ts b/src/data/compression/prs/compress.ts index 5f23f53a..6e79a34e 100644 --- a/src/data/compression/prs/compress.ts +++ b/src/data/compression/prs/compress.ts @@ -6,50 +6,50 @@ import { ArrayBufferCursor } from '../../ArrayBufferCursor'; export function compress(src: ArrayBufferCursor): ArrayBufferCursor { const ctx = new Context(src); - const hash_table = new HashTable(); + const hashTable = new HashTable(); if (ctx.src.size <= 3) { // Make a literal copy of the input. - while (ctx.src.bytes_left) { - ctx.set_bit(1); - ctx.copy_literal(); + while (ctx.src.bytesLeft) { + ctx.setBit(1); + ctx.copyLiteral(); } } else { // 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); - hash_table.put(hash_table.hash(ctx.src), 1); + hashTable.put(hashTable.hash(ctx.src), 1); ctx.src.seek(-1); // Copy the first two bytes as literals. - ctx.set_bit(1); - ctx.copy_literal(); - ctx.set_bit(1); - ctx.copy_literal(); + ctx.setBit(1); + ctx.copyLiteral(); + ctx.setBit(1); + ctx.copyLiteral(); - while (ctx.src.bytes_left > 1) { - let [offset, mlen] = ctx.find_longest_match(hash_table, false); + while (ctx.src.bytesLeft > 1) { + let [offset, mlen] = ctx.findLongestMatch(hashTable, false); if (mlen > 0) { 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); // Did the "lazy match" produce something more compressed? 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. if (mlen >= 2 && mlen <= 5 && offset2 < offset) { if (offset >= -256 && offset2 < -256) { if (mlen2 - mlen < 3) { - copy_literal = false; + copyLiteral = false; } } } - if (copy_literal) { - ctx.set_bit(1); - ctx.copy_literal(); + if (copyLiteral) { + ctx.setBit(1); + ctx.copyLiteral(); continue; } } @@ -57,20 +57,20 @@ export function compress(src: ArrayBufferCursor): ArrayBufferCursor { // What kind of match did we find? if (mlen >= 2 && mlen <= 5 && offset >= -256) { // Short match. - ctx.set_bit(0); - ctx.set_bit(0); - ctx.set_bit((mlen - 2) & 0x02); - ctx.set_bit((mlen - 2) & 0x01); - ctx.write_literal(offset & 0xFF); - ctx.add_intermediates(hash_table, mlen); + ctx.setBit(0); + ctx.setBit(0); + ctx.setBit((mlen - 2) & 0x02); + ctx.setBit((mlen - 2) & 0x01); + ctx.writeLiteral(offset & 0xFF); + ctx.addIntermediates(hashTable, mlen); continue; } else if (mlen >= 3 && mlen <= 9) { // Long match, short length. - ctx.set_bit(0); - ctx.set_bit(1); - ctx.write_literal(((offset & 0x1F) << 3) | ((mlen - 2) & 0x07)); - ctx.write_literal(offset >> 5); - ctx.add_intermediates(hash_table, mlen); + ctx.setBit(0); + ctx.setBit(1); + ctx.writeLiteral(((offset & 0x1F) << 3) | ((mlen - 2) & 0x07)); + ctx.writeLiteral(offset >> 5); + ctx.addIntermediates(hashTable, mlen); continue; } else if (mlen > 9) { // Long match, long length. @@ -78,31 +78,31 @@ export function compress(src: ArrayBufferCursor): ArrayBufferCursor { mlen = 256; } - ctx.set_bit(0); - ctx.set_bit(1); - ctx.write_literal((offset & 0x1F) << 3); - ctx.write_literal(offset >> 5); - ctx.write_literal(mlen - 1); - ctx.add_intermediates(hash_table, mlen); + ctx.setBit(0); + ctx.setBit(1); + ctx.writeLiteral((offset & 0x1F) << 3); + ctx.writeLiteral(offset >> 5); + ctx.writeLiteral(mlen - 1); + ctx.addIntermediates(hashTable, mlen); continue; } } // If we get here, we didn't find a suitable match, so just we just make a literal copy. - ctx.set_bit(1); - ctx.copy_literal(); + ctx.setBit(1); + ctx.copyLiteral(); } // If there's a left over byte at the end, make a literal copy. - if (ctx.src.bytes_left) { - ctx.set_bit(1); - ctx.copy_literal(); + if (ctx.src.bytesLeft) { + ctx.setBit(1); + ctx.copyLiteral(); } } - ctx.write_eof(); + ctx.writeEof(); - return ctx.dst.seek_start(0); + return ctx.dst.seekStart(0); } const MAX_WINDOW = 0x2000; @@ -113,28 +113,28 @@ class Context { src: ArrayBufferCursor; dst: ArrayBufferCursor; flags: number; - flag_bits_left: number; - flag_offset: number; + flagBitsLeft: number; + flagOffset: number; constructor(cursor: ArrayBufferCursor) { this.src = cursor; - this.dst = new ArrayBufferCursor(cursor.size, cursor.little_endian); + this.dst = new ArrayBufferCursor(cursor.size, cursor.littleEndian); this.flags = 0; - this.flag_bits_left = 0; - this.flag_offset = 0; + this.flagBitsLeft = 0; + this.flagOffset = 0; } - set_bit(bit: number): void { - if (!this.flag_bits_left--) { + setBit(bit: number): void { + if (!this.flagBitsLeft--) { // Write out the flags to their position in the file, and store the next flags byte position. const pos = this.dst.position; this.dst - .seek_start(this.flag_offset) - .write_u8(this.flags) - .seek_start(pos) - .write_u8(0); // Placeholder for the next flags byte. - this.flag_offset = pos; - this.flag_bits_left = 7; + .seekStart(this.flagOffset) + .writeU8(this.flags) + .seekStart(pos) + .writeU8(0); // Placeholder for the next flags byte. + this.flagOffset = pos; + this.flagBitsLeft = 7; } this.flags >>>= 1; @@ -144,35 +144,35 @@ class Context { } } - copy_literal(): void { - this.dst.write_u8(this.src.u8()); + copyLiteral(): void { + this.dst.writeU8(this.src.u8()); } - write_literal(value: number): void { - this.dst.write_u8(value); + writeLiteral(value: number): void { + this.dst.writeU8(value); } - write_final_flags(): void { - this.flags >>>= this.flag_bits_left; + writeFinalFlags(): void { + this.flags >>>= this.flagBitsLeft; const pos = this.dst.position; this.dst - .seek_start(this.flag_offset) - .write_u8(this.flags) - .seek_start(pos); + .seekStart(this.flagOffset) + .writeU8(this.flags) + .seekStart(pos); } - write_eof(): void { - this.set_bit(0); - this.set_bit(1); + writeEof(): void { + this.setBit(0); + this.setBit(1); - this.write_final_flags(); + this.writeFinalFlags(); - this.write_literal(0); - this.write_literal(0); + this.writeLiteral(0); + this.writeLiteral(0); } - match_length(s2: number): number { - const array = this.src.uint8_array_view(); + matchLength(s2: number): number { + const array = this.src.uint8ArrayView(); let len = 0; let s1 = this.src.position; @@ -185,20 +185,20 @@ class Context { return len; } - find_longest_match(hash_table: HashTable, lazy: boolean): [number, number] { - if (!this.src.bytes_left) { + findLongestMatch(hashTable: HashTable, lazy: boolean): [number, number] { + if (!this.src.bytesLeft) { return [0, 0]; } // 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. - let entry = hash_table.get(hash); + let entry = hashTable.get(hash); if (entry === null) { if (!lazy) { - hash_table.put(hash, this.src.position); + hashTable.put(hash, this.src.position); } return [0, 0]; @@ -206,10 +206,10 @@ class Context { // If we'd go outside the window, truncate the hash chain now. if (this.src.position - entry > MAX_WINDOW) { - hash_table.hash_to_offset[hash] = null; + hashTable.hashToOffset[hash] = null; if (!lazy) { - hash_table.put(hash, this.src.position); + hashTable.put(hash, this.src.position); } return [0, 0]; @@ -217,24 +217,24 @@ class Context { // 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. - let longest_length = 0; - let longest_match = 0; + let longestLength = 0; + let longestMatch = 0; while (entry != null) { - const mlen = this.match_length(entry); + const mlen = this.matchLength(entry); - if (mlen > longest_length || mlen >= 256) { - longest_length = mlen; - longest_match = entry; + if (mlen > longestLength || mlen >= 256) { + longestLength = mlen; + longestMatch = entry; } // 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 we'd go outside the window, truncate the hash chain now. if (this.src.position - entry2 > MAX_WINDOW) { - hash_table.set_prev(entry, null); + hashTable.setPrev(entry, null); entry2 = null; } } @@ -244,33 +244,33 @@ class Context { // Add our current string to the hash. if (!lazy) { - hash_table.put(hash, this.src.position); + hashTable.put(hash, this.src.position); } // Did we find a match? - const offset = longest_length > 0 ? longest_match - this.src.position : 0; - return [offset, longest_length]; + const offset = longestLength > 0 ? longestMatch - this.src.position : 0; + return [offset, longestLength]; } - add_intermediates(hash_table: HashTable, len: number): void { + addIntermediates(hashTable: HashTable, len: number): void { this.src.seek(1); for (let i = 1; i < len; ++i) { - const hash = hash_table.hash(this.src); - hash_table.put(hash, this.src.position); + const hash = hashTable.hash(this.src); + hashTable.put(hash, this.src.position); this.src.seek(1); } } } class HashTable { - hash_to_offset: Array = new Array(HASH_SIZE).fill(null); - masked_offset_to_prev: Array = new Array(MAX_WINDOW).fill(null); + hashToOffset: Array = new Array(HASH_SIZE).fill(null); + maskedOffsetToPrev: Array = new Array(MAX_WINDOW).fill(null); hash(cursor: ArrayBufferCursor): number { let hash = cursor.u8(); - if (cursor.bytes_left) { + if (cursor.bytesLeft) { hash ^= cursor.u8(); cursor.seek(-1); } @@ -280,19 +280,19 @@ class HashTable { } get(hash: number): number | null { - return this.hash_to_offset[hash]; + return this.hashToOffset[hash]; } put(hash: number, offset: number): void { - this.set_prev(offset, this.hash_to_offset[hash]); - this.hash_to_offset[hash] = offset; + this.setPrev(offset, this.hashToOffset[hash]); + this.hashToOffset[hash] = offset; } 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 { - this.masked_offset_to_prev[offset & WINDOW_MASK] = prev_offset; + setPrev(offset: number, prevOffset: number | null): void { + this.maskedOffsetToPrev[offset & WINDOW_MASK] = prevOffset; } } diff --git a/src/data/compression/prs/decompress.ts b/src/data/compression/prs/decompress.ts index 9ed5c07b..8e18543a 100644 --- a/src/data/compression/prs/decompress.ts +++ b/src/data/compression/prs/decompress.ts @@ -9,24 +9,24 @@ export function decompress(cursor: ArrayBufferCursor) { const ctx = new Context(cursor); while (true) { - if (ctx.read_flag_bit() === 1) { + if (ctx.readFlagBit() === 1) { // Single byte copy. - ctx.copy_u8(); + ctx.copyU8(); } else { // Multi byte copy. let length; let offset; - if (ctx.read_flag_bit() === 0) { + if (ctx.readFlagBit() === 0) { // Short copy. - length = ctx.read_flag_bit() << 1; - length |= ctx.read_flag_bit(); + length = ctx.readFlagBit() << 1; + length |= ctx.readFlagBit(); length += 2; - offset = ctx.read_u8() - 256; + offset = ctx.readU8() - 256; } else { // 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. if (offset === 0) { @@ -38,7 +38,7 @@ export function decompress(cursor: ArrayBufferCursor) { offset >>>= 3; if (length === 0) { - length = ctx.read_u8(); + length = ctx.readU8(); length += 1; } else { length += 2; @@ -47,52 +47,52 @@ export function decompress(cursor: ArrayBufferCursor) { offset -= 8192; } - ctx.offset_copy(offset, length); + ctx.offsetCopy(offset, length); } } - return ctx.dst.seek_start(0); + return ctx.dst.seekStart(0); } class Context { src: ArrayBufferCursor; dst: ArrayBufferCursor; flags: number; - flag_bits_left: number; + flagBitsLeft: number; constructor(cursor: ArrayBufferCursor) { 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.flag_bits_left = 0; + this.flagBitsLeft = 0; } - read_flag_bit() { + readFlagBit() { // Fetch a new flag byte when the previous byte has been processed. - if (this.flag_bits_left === 0) { - this.flags = this.read_u8(); - this.flag_bits_left = 8; + if (this.flagBitsLeft === 0) { + this.flags = this.readU8(); + this.flagBitsLeft = 8; } let bit = this.flags & 1; this.flags >>>= 1; - this.flag_bits_left -= 1; + this.flagBitsLeft -= 1; return bit; } - copy_u8() { - this.dst.write_u8(this.read_u8()); + copyU8() { + this.dst.writeU8(this.readU8()); } - read_u8() { + readU8() { return this.src.u8(); } - read_u16() { + readU16() { return this.src.u16(); } - offset_copy(offset: number, length: number) { + offsetCopy(offset: number, length: number) { if (offset < -8192 || offset > 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. - const buf_size = Math.min(-offset, length); + const bufSize = Math.min(-offset, length); this.dst.seek(offset); - const buf = this.dst.take(buf_size); - this.dst.seek(-offset - buf_size); + const buf = this.dst.take(bufSize); + this.dst.seek(-offset - bufSize); - for (let i = 0; i < Math.floor(length / buf_size); ++i) { - this.dst.write_cursor(buf); + for (let i = 0; i < Math.floor(length / bufSize); ++i) { + this.dst.writeCursor(buf); } - this.dst.write_cursor(buf.take(length % buf_size)); + this.dst.writeCursor(buf.take(length % bufSize)); } } diff --git a/src/data/compression/prs/index.test.ts b/src/data/compression/prs/index.test.ts index 29581444..86c8f5d2 100644 --- a/src/data/compression/prs/index.test.ts +++ b/src/data/compression/prs/index.test.ts @@ -1,44 +1,44 @@ import { ArrayBufferCursor } from '../../ArrayBufferCursor'; 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); for (const byte of bytes) { - cursor.write_u8(byte); + cursor.writeU8(byte); } - cursor.seek_start(0); - const compressed_cursor = compress(cursor); + cursor.seekStart(0); + const compressedCursor = compress(cursor); - expect(compressed_cursor.size).toBe(expected_compressed_size); + expect(compressedCursor.size).toBe(expectedCompressedSize); - const test_cursor = decompress(compressed_cursor); - cursor.seek_start(0); + const testCursor = decompress(compressedCursor); + cursor.seekStart(0); - expect(test_cursor.size).toBe(cursor.size); + expect(testCursor.size).toBe(cursor.size); - while (cursor.bytes_left) { - if (cursor.u8() !== test_cursor.u8()) { + while (cursor.bytesLeft) { + if (cursor.u8() !== testCursor.u8()) { cursor.seek(-1); - test_cursor.seek(-1); + testCursor.seek(-1); break; } } - expect(test_cursor.position).toBe(test_cursor.size); + expect(testCursor.position).toBe(testCursor.size); } test('PRS compression and decompression, best case', () => { // 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', () => { const prng = new Prng(); // 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', () => { @@ -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 arrays = new Array(100) .fill(pattern) - .map(array => array.map((e: number) => e + prng.next_integer(0, 10))); - const flattened_array = [].concat.apply([], arrays); + .map(array => array.map((e: number) => e + prng.nextInteger(0, 10))); + const flattenedArray = [].concat.apply([], arrays); // Compression factor: 0.834 - test_with_bytes(flattened_array, 1335); + testWithBytes(flattenedArray, 1335); }); test('PRS compression and decompression, 0 bytes', () => { - test_with_bytes([], 3); + testWithBytes([], 3); }); test('PRS compression and decompression, 1 byte', () => { - test_with_bytes([111], 4); + testWithBytes([111], 4); }); 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_with_bytes([56, 237, 158], 6); + testWithBytes([56, 237, 158], 6); }); class Prng { @@ -77,7 +77,7 @@ class Prng { 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; } } diff --git a/src/data/loading/areas.ts b/src/data/loading/areas.ts index a26762c1..62bd4670 100644 --- a/src/data/loading/areas.ts +++ b/src/data/loading/areas.ts @@ -1,79 +1,79 @@ import { Object3D } from 'three'; import { Section } from '../../domain'; -import { get_area_render_data, get_area_collision_data } from './assets'; -import { parse_c_rel, parse_n_rel } from '../parsing/geometry'; +import { getAreaRenderData, getAreaCollisionData } from './assets'; +import { parseCRel, parseNRel } from '../parsing/geometry'; // // Caches // -const sections_cache: Map> = new Map(); -const render_geometry_cache: Map> = new Map(); -const collision_geometry_cache: Map> = new Map(); +const sectionsCache: Map> = new Map(); +const renderGeometryCache: Map> = new Map(); +const collisionGeometryCache: Map> = new Map(); -export function get_area_sections( +export function getAreaSections( episode: number, - area_id: number, - area_variant: number + areaId: number, + areaVariant: number ): Promise { - const sections = sections_cache.get(`${episode}-${area_id}-${area_variant}`); + const sections = sectionsCache.get(`${episode}-${areaId}-${areaVariant}`); if (sections) { return sections; } else { - return get_area_sections_and_render_geometry( - episode, area_id, area_variant).then(({sections}) => sections); + return getAreaSectionsAndRenderGeometry( + episode, areaId, areaVariant).then(({sections}) => sections); } } -export function get_area_render_geometry( +export function getAreaRenderGeometry( episode: number, - area_id: number, - area_variant: number + areaId: number, + areaVariant: number ): Promise { - const object_3d = render_geometry_cache.get(`${episode}-${area_id}-${area_variant}`); + const object3d = renderGeometryCache.get(`${episode}-${areaId}-${areaVariant}`); - if (object_3d) { - return object_3d; + if (object3d) { + return object3d; } else { - return get_area_sections_and_render_geometry( - episode, area_id, area_variant).then(({object_3d}) => object_3d); + return getAreaSectionsAndRenderGeometry( + episode, areaId, areaVariant).then(({object3d}) => object3d); } } -export function get_area_collision_geometry( +export function getAreaCollisionGeometry( episode: number, - area_id: number, - area_variant: number + areaId: number, + areaVariant: number ): Promise { - const object_3d = collision_geometry_cache.get(`${episode}-${area_id}-${area_variant}`); + const object3d = collisionGeometryCache.get(`${episode}-${areaId}-${areaVariant}`); - if (object_3d) { - return object_3d; + if (object3d) { + return object3d; } else { - const object_3d = get_area_collision_data( - episode, area_id, area_variant).then(parse_c_rel); - collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d); - return object_3d; + const object3d = getAreaCollisionData( + episode, areaId, areaVariant).then(parseCRel); + collisionGeometryCache.set(`${areaId}-${areaVariant}`, object3d); + return object3d; } } -function get_area_sections_and_render_geometry( +function getAreaSectionsAndRenderGeometry( episode: number, - area_id: number, - area_variant: number -): Promise<{ sections: Section[], object_3d: Object3D }> { - const promise = get_area_render_data( - episode, area_id, area_variant).then(parse_n_rel); + areaId: number, + areaVariant: number +): Promise<{ sections: Section[], object3d: Object3D }> { + const promise = getAreaRenderData( + episode, areaId, areaVariant).then(parseNRel); const sections = new Promise((resolve, reject) => { promise.then(({sections}) => resolve(sections)).catch(reject); }); - const object_3d = new Promise((resolve, reject) => { - promise.then(({object_3d}) => resolve(object_3d)).catch(reject); + const object3d = new Promise((resolve, reject) => { + promise.then(({object3d}) => resolve(object3d)).catch(reject); }); - sections_cache.set(`${episode}-${area_id}-${area_variant}`, sections); - render_geometry_cache.set(`${episode}-${area_id}-${area_variant}`, object_3d); + sectionsCache.set(`${episode}-${areaId}-${areaVariant}`, sections); + renderGeometryCache.set(`${episode}-${areaId}-${areaVariant}`, object3d); return promise; } diff --git a/src/data/loading/assets.ts b/src/data/loading/assets.ts index 53dead84..b5e77b8b 100644 --- a/src/data/loading/assets.ts +++ b/src/data/loading/assets.ts @@ -1,35 +1,35 @@ import { NpcType, ObjectType } from '../../domain'; -export function get_area_render_data( +export function getAreaRenderData( episode: number, - area_id: number, - area_version: number + areaId: number, + areaVersion: number ): Promise { - 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, - area_id: number, - area_version: number + areaId: number, + areaVersion: number ): Promise { - 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 { - const url = npc_type_to_url(npc_type); - const data = await get_asset(url); + const url = npcTypeToUrl(npcType); + const data = await getAsset(url); return ({ url, data }); } catch (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 { - const url = object_type_to_url(object_type); - const data = await get_asset(url); + const url = objectTypeToUrl(objectType); + const data = await getAsset(url); return ({ url, data }); } catch (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. */ -const buffer_cache: Map> = new Map(); +const bufferCache: Map> = new Map(); -function get_asset(url: string): Promise { - const promise = buffer_cache.get(url); +function getAsset(url: string): Promise { + const promise = bufferCache.get(url); if (promise) { return promise; } else { - const base_url = process.env.PUBLIC_URL; - const promise = fetch(base_url + url).then(r => r.arrayBuffer()); - buffer_cache.set(url, promise); + const baseUrl = process.env.PUBLIC_URL; + const promise = fetch(baseUrl + url).then(r => r.arrayBuffer()); + bufferCache.set(url, promise); return promise; } } -const area_base_names = [ +const areaBaseNames = [ [ ['city00_00', 1], ['forest01', 1], @@ -93,7 +93,7 @@ const area_base_names = [ ['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], @@ -109,89 +109,89 @@ const area_base_names = [ ] ]; -function area_version_to_base_url( +function areaVersionToBaseUrl( episode: number, - area_id: number, - area_variant: number + areaId: number, + areaVariant: number ): 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) { - const [base_name, variants] = episode_base_names[area_id]; + if (0 <= areaId && areaId < episodeBaseNames.length) { + const [baseName, variants] = episodeBaseNames[areaId]; - if (0 <= area_variant && area_variant < variants) { + if (0 <= areaVariant && areaVariant < variants) { let variant: string; if (variants === 1) { variant = ''; } else { - variant = String(area_variant); + variant = String(areaVariant); while (variant.length < 2) variant = '0' + variant; } - return `/maps/map_${base_name}${variant}`; + return `/maps/map_${baseName}${variant}`; } 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 { - throw new Error(`Unknown episode ${episode} area ${area_id}.`); + throw new Error(`Unknown episode ${episode} area ${areaId}.`); } } type AreaAssetType = 'render' | 'collision'; -function get_area_asset( +function getAreaAsset( episode: number, - area_id: number, - area_variant: number, + areaId: number, + areaVariant: number, type: AreaAssetType ): Promise { 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'; - return get_asset(base_url + suffix); + return getAsset(baseUrl + suffix); } catch (e) { return Promise.reject(e); } } -function npc_type_to_url(npc_type: NpcType): string { - switch (npc_type) { +function npcTypeToUrl(npcType: NpcType): string { + switch (npcType) { // 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 - case NpcType.Hildebear2: return npc_type_to_url(NpcType.Hildebear); - case NpcType.Hildeblue2: return npc_type_to_url(NpcType.Hildeblue); - case NpcType.RagRappy2: return npc_type_to_url(NpcType.RagRappy); - case NpcType.Monest2: return npc_type_to_url(NpcType.Monest); - case NpcType.PoisonLily2: return npc_type_to_url(NpcType.PoisonLily); - case NpcType.NarLily2: return npc_type_to_url(NpcType.NarLily); - case NpcType.GrassAssassin2: return npc_type_to_url(NpcType.GrassAssassin); - case NpcType.Dimenian2: return npc_type_to_url(NpcType.Dimenian); - case NpcType.LaDimenian2: return npc_type_to_url(NpcType.LaDimenian); - case NpcType.SoDimenian2: return npc_type_to_url(NpcType.SoDimenian); - case NpcType.DarkBelra2: return npc_type_to_url(NpcType.DarkBelra); + case NpcType.Hildebear2: return npcTypeToUrl(NpcType.Hildebear); + case NpcType.Hildeblue2: return npcTypeToUrl(NpcType.Hildeblue); + case NpcType.RagRappy2: return npcTypeToUrl(NpcType.RagRappy); + case NpcType.Monest2: return npcTypeToUrl(NpcType.Monest); + case NpcType.PoisonLily2: return npcTypeToUrl(NpcType.PoisonLily); + case NpcType.NarLily2: return npcTypeToUrl(NpcType.NarLily); + case NpcType.GrassAssassin2: return npcTypeToUrl(NpcType.GrassAssassin); + case NpcType.Dimenian2: return npcTypeToUrl(NpcType.Dimenian); + case NpcType.LaDimenian2: return npcTypeToUrl(NpcType.LaDimenian); + case NpcType.SoDimenian2: return npcTypeToUrl(NpcType.SoDimenian); + case NpcType.DarkBelra2: return npcTypeToUrl(NpcType.DarkBelra); // Episode II VR Spaceship - case NpcType.SavageWolf2: return npc_type_to_url(NpcType.SavageWolf); - case NpcType.BarbarousWolf2: return npc_type_to_url(NpcType.BarbarousWolf); - case NpcType.PanArms2: return npc_type_to_url(NpcType.PanArms); - case NpcType.Dubchic2: return npc_type_to_url(NpcType.Dubchic); - case NpcType.Gilchic2: return npc_type_to_url(NpcType.Gilchic); - case NpcType.Garanz2: return npc_type_to_url(NpcType.Garanz); - case NpcType.Dubswitch2: return npc_type_to_url(NpcType.Dubswitch); - case NpcType.Delsaber2: return npc_type_to_url(NpcType.Delsaber); - case NpcType.ChaosSorcerer2: return npc_type_to_url(NpcType.ChaosSorcerer); + case NpcType.SavageWolf2: return npcTypeToUrl(NpcType.SavageWolf); + case NpcType.BarbarousWolf2: return npcTypeToUrl(NpcType.BarbarousWolf); + case NpcType.PanArms2: return npcTypeToUrl(NpcType.PanArms); + case NpcType.Dubchic2: return npcTypeToUrl(NpcType.Dubchic); + case NpcType.Gilchic2: return npcTypeToUrl(NpcType.Gilchic); + case NpcType.Garanz2: return npcTypeToUrl(NpcType.Garanz); + case NpcType.Dubswitch2: return npcTypeToUrl(NpcType.Dubswitch); + case NpcType.Delsaber2: return npcTypeToUrl(NpcType.Delsaber); + 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 { - switch (object_type) { +function objectTypeToUrl(objectType: ObjectType): string { + switch (objectType) { case ObjectType.EasterEgg: case ObjectType.ChristmasTree: case ObjectType.ChristmasWreath: @@ -208,9 +208,9 @@ function object_type_to_url(object_type: ObjectType): string { case ObjectType.FallingRock: case ObjectType.DesertFixedTypeBoxBreakableCrystals: case ObjectType.BeeHive: - return `/objects/${String(object_type.pso_id)}.nj`; + return `/objects/${String(objectType.psoId)}.nj`; default: - return `/objects/${String(object_type.pso_id)}.xj`; + return `/objects/${String(objectType.psoId)}.xj`; } } diff --git a/src/data/loading/entities.ts b/src/data/loading/entities.ts index 9455329c..5fcb79aa 100644 --- a/src/data/loading/entities.ts +++ b/src/data/loading/entities.ts @@ -1,52 +1,52 @@ import { BufferGeometry } from 'three'; import { NpcType, ObjectType } from '../../domain'; -import { get_npc_data, get_object_data } from './assets'; +import { getNpcData, getObjectData } from './assets'; import { ArrayBufferCursor } from '../ArrayBufferCursor'; -import { parse_nj, parse_xj } from '../parsing/ninja'; +import { parseNj, parseXj } from '../parsing/ninja'; -const npc_cache: Map> = new Map(); -const object_cache: Map> = new Map(); +const npcCache: Map> = new Map(); +const objectCache: Map> = new Map(); -export function get_npc_geometry(npc_type: NpcType): Promise { - let geometry = npc_cache.get(String(npc_type.id)); +export function getNpcGeometry(npcType: NpcType): Promise { + let geometry = npcCache.get(String(npcType.id)); if (geometry) { return geometry; } else { - geometry = get_npc_data(npc_type).then(({ url, data }) => { + geometry = getNpcData(npcType).then(({ url, data }) => { 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) { - return object_3d; + if (object3d) { + return object3d; } else { 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; } } -export function get_object_geometry(object_type: ObjectType): Promise { - let geometry = object_cache.get(String(object_type.id)); +export function getObjectGeometry(objectType: ObjectType): Promise { + let geometry = objectCache.get(String(objectType.id)); if (geometry) { return geometry; } else { - geometry = get_object_data(object_type).then(({ url, data }) => { + geometry = getObjectData(objectType).then(({ url, data }) => { 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) { - return object_3d; + if (object3d) { + return object3d; } else { 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; } } diff --git a/src/data/parsing/bin.test.ts b/src/data/parsing/bin.test.ts index 5d499314..450fb126 100644 --- a/src/data/parsing/bin.test.ts +++ b/src/data/parsing/bin.test.ts @@ -1,23 +1,23 @@ import * as fs from 'fs'; import { ArrayBufferCursor } from '../ArrayBufferCursor'; 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. */ -test('parse_bin and write_bin', () => { - const orig_buffer = fs.readFileSync('test/resources/quest118_e.bin').buffer; - const orig_bin = prs.decompress(new ArrayBufferCursor(orig_buffer, true)); - const test_bin = write_bin(parse_bin(orig_bin)); - orig_bin.seek_start(0); +test('parseBin and writeBin', () => { + const origBuffer = fs.readFileSync('test/resources/quest118_e.bin').buffer; + const origBin = prs.decompress(new ArrayBufferCursor(origBuffer, true)); + const testBin = writeBin(parseBin(origBin)); + origBin.seekStart(0); - expect(test_bin.size).toBe(orig_bin.size); + expect(testBin.size).toBe(origBin.size); let match = true; - while (orig_bin.bytes_left) { - if (test_bin.u8() !== orig_bin.u8()) { + while (origBin.bytesLeft) { + if (testBin.u8() !== origBin.u8()) { match = false; break; } diff --git a/src/data/parsing/bin.ts b/src/data/parsing/bin.ts index ff05e8f6..9f993fad 100644 --- a/src/data/parsing/bin.ts +++ b/src/data/parsing/bin.ts @@ -1,47 +1,59 @@ import { ArrayBufferCursor } from '../ArrayBufferCursor'; -export function parse_bin(cursor: ArrayBufferCursor) { - const object_code_offset = cursor.u32(); - const function_offset_table_offset = cursor.u32(); // Relative offsets +export interface BinFile { + questNumber: number; + 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(); cursor.seek(4); // Always seems to be 0xFFFFFFFF - const quest_number = cursor.u32(); + const questNumber = cursor.u32(); const language = cursor.u32(); - const quest_name = cursor.string_utf_16(64, true, true); - const short_description = cursor.string_utf_16(256, true, true); - const long_description = cursor.string_utf_16(576, true, true); + const questName = cursor.stringUtf16(64, true, true); + const shortDescription = cursor.stringUtf16(256, true, true); + const longDescription = cursor.stringUtf16(576, true, true); if (size !== cursor.size) { console.warn(`Value ${size} in bin size field does not match actual size ${cursor.size}.`); } - const function_offset_count = Math.floor( - (cursor.size - function_offset_table_offset) / 4); + const functionOffsetCount = Math.floor( + (cursor.size - functionOffsetTableOffset) / 4); - cursor.seek_start(function_offset_table_offset); - const function_offsets = []; + cursor.seekStart(functionOffsetTableOffset); + const functionOffsets = []; - for (let i = 0; i < function_offset_count; ++i) { - function_offsets.push(cursor.i32()); + for (let i = 0; i < functionOffsetCount; ++i) { + functionOffsets.push(cursor.i32()); } - const instructions = parse_object_code( - cursor.seek_start(object_code_offset).take(function_offset_table_offset - object_code_offset)); + const instructions = parseObjectCode( + cursor.seekStart(objectCodeOffset).take(functionOffsetTableOffset - objectCodeOffset) + ); return { - quest_number, + questNumber, language, - quest_name, - short_description, - long_description, - function_offsets, + questName, + shortDescription, + longDescription, + functionOffsets, instructions, - data: cursor.seek_start(0).take(cursor.size) + data: cursor.seekStart(0).take(cursor.size) }; } -export function write_bin({ data }: { data: ArrayBufferCursor }): ArrayBufferCursor { - return data.seek_start(0); +export function writeBin({ data }: { data: ArrayBufferCursor }): ArrayBufferCursor { + return data.seekStart(0); } export interface Instruction { @@ -51,35 +63,35 @@ export interface Instruction { size: number; } -function parse_object_code(cursor: ArrayBufferCursor): Instruction[] { +function parseObjectCode(cursor: ArrayBufferCursor): Instruction[] { const instructions = []; - while (cursor.bytes_left) { - const main_opcode = cursor.u8(); + while (cursor.bytesLeft) { + const mainOpcode = cursor.u8(); let opcode; let opsize; let list; - switch (main_opcode) { + switch (mainOpcode) { case 0xF8: opcode = cursor.u8(); opsize = 2; - list = F8opcode_list; + list = F8opcodeList; break; case 0xF9: opcode = cursor.u8(); opsize = 2; - list = F9opcode_list; + list = F9opcodeList; break; default: - opcode = main_opcode; + opcode = mainOpcode; opsize = 1; - list = opcode_list; + list = opcodeList; break; } const [, mnemonic, mask] = list[opcode]; - const opargs = parse_instruction_arguments(cursor, mask); + const opargs = parseInstructionArguments(cursor, mask); if (!opargs) { console.error(`Parameters unknown for opcode 0x${opcode.toString(16).toUpperCase()}.`); @@ -97,12 +109,12 @@ function parse_object_code(cursor: ArrayBufferCursor): Instruction[] { return instructions; } -function parse_instruction_arguments(cursor: ArrayBufferCursor, mask: string | null) { +function parseInstructionArguments(cursor: ArrayBufferCursor, mask: string | null) { if (mask == null) { return; } - const old_pos = cursor.position; + const oldPos = cursor.position; const args = []; 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 }; } -const opcode_list: Array<[number, string, string | null]> = [ +const opcodeList: Array<[number, string, string | null]> = [ [0x00, 'nop', ''], [0x01, 'ret', ''], [0x02, 'sync', ''], @@ -476,7 +488,7 @@ const opcode_list: Array<[number, string, string | null]> = [ [0xFF, 'unknownFF', ''], ]; -const F8opcode_list: Array<[number, string, string | null]> = [ +const F8opcodeList: Array<[number, string, string | null]> = [ [0x00, 'unknown', null], [0x01, 'set_chat_callback?', 'aRs'], [0x02, 'unknown', null], @@ -735,7 +747,7 @@ const F8opcode_list: Array<[number, string, string | null]> = [ [0xFF, 'unknown', null], ]; -const F9opcode_list: Array<[number, string, string | null]> = [ +const F9opcodeList: Array<[number, string, string | null]> = [ [0x00, 'unknown', null], [0x01, 'dec2float', 'RR'], [0x02, 'float2dec', 'RR'], diff --git a/src/data/parsing/dat.test.ts b/src/data/parsing/dat.test.ts index d6495749..b9ed6383 100644 --- a/src/data/parsing/dat.test.ts +++ b/src/data/parsing/dat.test.ts @@ -1,23 +1,23 @@ import * as fs from 'fs'; import { ArrayBufferCursor } from '../ArrayBufferCursor'; 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. */ -test('parse_dat and write_dat', () => { - const orig_buffer = fs.readFileSync('test/resources/quest118_e.dat').buffer; - const orig_dat = prs.decompress(new ArrayBufferCursor(orig_buffer, true)); - const test_dat = write_dat(parse_dat(orig_dat)); - orig_dat.seek_start(0); +test('parseDat and writeDat', () => { + const origBuffer = fs.readFileSync('test/resources/quest118_e.dat').buffer; + const origDat = prs.decompress(new ArrayBufferCursor(origBuffer, true)); + const testDat = writeDat(parseDat(origDat)); + origDat.seekStart(0); - expect(test_dat.size).toBe(orig_dat.size); + expect(testDat.size).toBe(origDat.size); let match = true; - while (orig_dat.bytes_left) { - if (test_dat.u8() !== orig_dat.u8()) { + while (origDat.bytesLeft) { + if (testDat.u8() !== origDat.u8()) { match = false; 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. */ test('parse, modify and write DAT', () => { - const orig_buffer = fs.readFileSync('./test/resources/quest118_e.dat').buffer; - const orig_dat = prs.decompress(new ArrayBufferCursor(orig_buffer, true)); - const test_parsed = parse_dat(orig_dat); - orig_dat.seek_start(0); + const origBuffer = fs.readFileSync('./test/resources/quest118_e.dat').buffer; + const origDat = prs.decompress(new ArrayBufferCursor(origBuffer, true)); + const testParsed = parseDat(origDat); + origDat.seekStart(0); - test_parsed.objs[9].position.x = 13; - test_parsed.objs[9].position.y = 17; - test_parsed.objs[9].position.z = 19; + testParsed.objs[9].position.x = 13; + testParsed.objs[9].position.y = 17; + 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; - while (orig_dat.bytes_left) { - if (orig_dat.position === 16 + 9 * 68 + 16) { - orig_dat.seek(12); + while (origDat.bytesLeft) { + if (origDat.position === 16 + 9 * 68 + 16) { + origDat.seek(12); - expect(test_dat.f32()).toBe(13); - expect(test_dat.f32()).toBe(17); - expect(test_dat.f32()).toBe(19); - } else if (test_dat.u8() !== orig_dat.u8()) { + expect(testDat.f32()).toBe(13); + expect(testDat.f32()).toBe(17); + expect(testDat.f32()).toBe(19); + } else if (testDat.u8() !== origDat.u8()) { match = false; break; } diff --git a/src/data/parsing/dat.ts b/src/data/parsing/dat.ts index 5a131a2c..3d5024b3 100644 --- a/src/data/parsing/dat.ts +++ b/src/data/parsing/dat.ts @@ -4,102 +4,132 @@ import { ArrayBufferCursor } from '../ArrayBufferCursor'; const OBJECT_SIZE = 68; const NPC_SIZE = 72; -export function parse_dat(cursor: ArrayBufferCursor) { - const objs = []; - const npcs = []; - const unknowns = []; +export interface DatFile { + objs: DatObject[]; + npcs: DatNpc[]; + unknowns: DatUnknown[]; +} - while (cursor.bytes_left) { - const entity_type = cursor.u32(); - const total_size = cursor.u32(); - const area_id = cursor.u32(); - const entities_size = cursor.u32(); +interface DatEntity { + typeId: number; + sectionId: number; + position: { x: number, y: number, z: number }; + 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; } else { - if (entities_size !== total_size - 16) { - throw Error(`Malformed DAT file. Expected an entities size of ${total_size - 16}, got ${entities_size}.`); + if (entitiesSize !== totalSize - 16) { + throw Error(`Malformed DAT file. Expected an entities size of ${totalSize - 16}, got ${entitiesSize}.`); } - if (entity_type === 1) { // Objects - const object_count = Math.floor(entities_size / OBJECT_SIZE); - const start_position = cursor.position; + if (entityType === 1) { // Objects + const objectCount = Math.floor(entitiesSize / OBJECT_SIZE); + const startPosition = cursor.position; - for (let i = 0; i < object_count; ++i) { - const type_id = cursor.u16(); - const unknown1 = cursor.u8_array(10); - const section_id = cursor.u16(); - const unknown2 = cursor.u8_array(2); + for (let i = 0; i < objectCount; ++i) { + const typeId = cursor.u16(); + const unknown1 = cursor.u8Array(10); + const sectionId = cursor.u16(); + const unknown2 = cursor.u8Array(2); const x = cursor.f32(); const y = cursor.f32(); const z = cursor.f32(); - const rotation_x = cursor.i32() / 0xFFFF * 2 * Math.PI; - const rotation_y = cursor.i32() / 0xFFFF * 2 * Math.PI; - const rotation_z = cursor.i32() / 0xFFFF * 2 * Math.PI; + const rotationX = cursor.i32() / 0xFFFF * 2 * Math.PI; + const rotationY = cursor.i32() / 0xFFFF * 2 * Math.PI; + const rotationZ = cursor.i32() / 0xFFFF * 2 * Math.PI; // The next 3 floats seem to be scale values. - const unknown3 = cursor.u8_array(28); + const unknown3 = cursor.u8Array(28); objs.push({ - type_id, - section_id, + typeId, + sectionId, position: { x, y, z }, - rotation: { x: rotation_x, y: rotation_y, z: rotation_z }, - area_id, + rotation: { x: rotationX, y: rotationY, z: rotationZ }, + areaId, unknown: [unknown1, unknown2, unknown3] }); } - const bytes_read = cursor.position - start_position; + const bytesRead = cursor.position - startPosition; - if (bytes_read !== entities_size) { - console.warn(`Read ${bytes_read} bytes instead of expected ${entities_size} for entity type ${entity_type} (Object).`); - cursor.seek(entities_size - bytes_read); + if (bytesRead !== entitiesSize) { + console.warn(`Read ${bytesRead} bytes instead of expected ${entitiesSize} for entity type ${entityType} (Object).`); + cursor.seek(entitiesSize - bytesRead); } - } else if (entity_type === 2) { // NPCs - const npc_count = Math.floor(entities_size / NPC_SIZE); - const start_position = cursor.position; + } else if (entityType === 2) { // NPCs + const npcCount = Math.floor(entitiesSize / NPC_SIZE); + const startPosition = cursor.position; - for (let i = 0; i < npc_count; ++i) { - const type_id = cursor.u16(); - const unknown1 = cursor.u8_array(10); - const section_id = cursor.u16(); - const unknown2 = cursor.u8_array(6); + for (let i = 0; i < npcCount; ++i) { + const typeId = cursor.u16(); + const unknown1 = cursor.u8Array(10); + const sectionId = cursor.u16(); + const unknown2 = cursor.u8Array(6); const x = cursor.f32(); const y = cursor.f32(); const z = cursor.f32(); - const rotation_x = cursor.i32() / 0xFFFF * 2 * Math.PI; - const rotation_y = cursor.i32() / 0xFFFF * 2 * Math.PI; - const rotation_z = cursor.i32() / 0xFFFF * 2 * Math.PI; - const unknown3 = cursor.u8_array(20); + const rotationX = cursor.i32() / 0xFFFF * 2 * Math.PI; + const rotationY = cursor.i32() / 0xFFFF * 2 * Math.PI; + const rotationZ = cursor.i32() / 0xFFFF * 2 * Math.PI; + const unknown3 = cursor.u8Array(20); const skin = cursor.u32(); - const unknown4 = cursor.u8_array(4); + const unknown4 = cursor.u8Array(4); npcs.push({ - type_id, - section_id, + typeId, + sectionId, position: { x, y, z }, - rotation: { x: rotation_x, y: rotation_y, z: rotation_z }, + rotation: { x: rotationX, y: rotationY, z: rotationZ }, skin, - area_id, + areaId, unknown: [unknown1, unknown2, unknown3, unknown4] }); } - const bytes_read = cursor.position - start_position; + const bytesRead = cursor.position - startPosition; - if (bytes_read !== entities_size) { - console.warn(`Read ${bytes_read} bytes instead of expected ${entities_size} for entity type ${entity_type} (NPC).`); - cursor.seek(entities_size - bytes_read); + if (bytesRead !== entitiesSize) { + console.warn(`Read ${bytesRead} bytes instead of expected ${entitiesSize} for entity type ${entityType} (NPC).`); + cursor.seek(entitiesSize - bytesRead); } } else { // There are also waves (type 3) and unknown entity types 4 and 5. unknowns.push({ - entity_type, - total_size, - area_id, - entities_size, - data: cursor.u8_array(entities_size) + entityType, + totalSize, + areaId, + entitiesSize, + data: cursor.u8Array(entitiesSize) }); } } @@ -108,85 +138,83 @@ export function parse_dat(cursor: ArrayBufferCursor) { return { objs, npcs, unknowns }; } -export function write_dat( - {objs, npcs, unknowns}: { objs: any[], npcs: any[], unknowns: any[] } -): ArrayBufferCursor { +export function writeDat({ objs, npcs, unknowns }: DatFile): ArrayBufferCursor { const cursor = new ArrayBufferCursor( objs.length * OBJECT_SIZE + npcs.length * NPC_SIZE + unknowns.length * 1000, true); - const grouped_objs = groupBy(objs, obj => obj.area_id); - const obj_area_ids = Object.keys(grouped_objs) + const groupedObjs = groupBy(objs, obj => obj.areaId); + const objAreaIds = Object.keys(groupedObjs) .map(key => parseInt(key, 10)) .sort((a, b) => a - b); - for (const area_id of obj_area_ids) { - const area_objs = grouped_objs[area_id]; - const entities_size = area_objs.length * OBJECT_SIZE; - cursor.write_u32(1); // Entity type - cursor.write_u32(entities_size + 16); - cursor.write_u32(area_id); - cursor.write_u32(entities_size); + for (const areaId of objAreaIds) { + const areaObjs = groupedObjs[areaId]; + const entitiesSize = areaObjs.length * OBJECT_SIZE; + cursor.writeU32(1); // Entity type + cursor.writeU32(entitiesSize + 16); + cursor.writeU32(areaId); + cursor.writeU32(entitiesSize); - for (const obj of area_objs) { - cursor.write_u16(obj.type_id); - cursor.write_u8_array(obj.unknown[0]); - cursor.write_u16(obj.section_id); - cursor.write_u8_array(obj.unknown[1]); - cursor.write_f32(obj.position.x); - cursor.write_f32(obj.position.y); - cursor.write_f32(obj.position.z); - cursor.write_i32(Math.round(obj.rotation.x / (2 * Math.PI) * 0xFFFF)); - cursor.write_i32(Math.round(obj.rotation.y / (2 * Math.PI) * 0xFFFF)); - cursor.write_i32(Math.round(obj.rotation.z / (2 * Math.PI) * 0xFFFF)); - cursor.write_u8_array(obj.unknown[2]); + for (const obj of areaObjs) { + cursor.writeU16(obj.typeId); + cursor.writeU8Array(obj.unknown[0]); + cursor.writeU16(obj.sectionId); + cursor.writeU8Array(obj.unknown[1]); + cursor.writeF32(obj.position.x); + cursor.writeF32(obj.position.y); + cursor.writeF32(obj.position.z); + cursor.writeI32(Math.round(obj.rotation.x / (2 * Math.PI) * 0xFFFF)); + cursor.writeI32(Math.round(obj.rotation.y / (2 * Math.PI) * 0xFFFF)); + cursor.writeI32(Math.round(obj.rotation.z / (2 * Math.PI) * 0xFFFF)); + cursor.writeU8Array(obj.unknown[2]); } } - const grouped_npcs = groupBy(npcs, npc => npc.area_id); - const npc_area_ids = Object.keys(grouped_npcs) + const groupedNpcs = groupBy(npcs, npc => npc.areaId); + const npcAreaIds = Object.keys(groupedNpcs) .map(key => parseInt(key, 10)) .sort((a, b) => a - b); - for (const area_id of npc_area_ids) { - const area_npcs = grouped_npcs[area_id]; - const entities_size = area_npcs.length * NPC_SIZE; - cursor.write_u32(2); // Entity type - cursor.write_u32(entities_size + 16); - cursor.write_u32(area_id); - cursor.write_u32(entities_size); + for (const areaId of npcAreaIds) { + const areaNpcs = groupedNpcs[areaId]; + const entitiesSize = areaNpcs.length * NPC_SIZE; + cursor.writeU32(2); // Entity type + cursor.writeU32(entitiesSize + 16); + cursor.writeU32(areaId); + cursor.writeU32(entitiesSize); - for (const npc of area_npcs) { - cursor.write_u16(npc.type_id); - cursor.write_u8_array(npc.unknown[0]); - cursor.write_u16(npc.section_id); - cursor.write_u8_array(npc.unknown[1]); - cursor.write_f32(npc.position.x); - cursor.write_f32(npc.position.y); - cursor.write_f32(npc.position.z); - cursor.write_i32(Math.round(npc.rotation.x / (2 * Math.PI) * 0xFFFF)); - cursor.write_i32(Math.round(npc.rotation.y / (2 * Math.PI) * 0xFFFF)); - cursor.write_i32(Math.round(npc.rotation.z / (2 * Math.PI) * 0xFFFF)); - cursor.write_u8_array(npc.unknown[2]); - cursor.write_u32(npc.skin); - cursor.write_u8_array(npc.unknown[3]); + for (const npc of areaNpcs) { + cursor.writeU16(npc.typeId); + cursor.writeU8Array(npc.unknown[0]); + cursor.writeU16(npc.sectionId); + cursor.writeU8Array(npc.unknown[1]); + cursor.writeF32(npc.position.x); + cursor.writeF32(npc.position.y); + cursor.writeF32(npc.position.z); + cursor.writeI32(Math.round(npc.rotation.x / (2 * Math.PI) * 0xFFFF)); + cursor.writeI32(Math.round(npc.rotation.y / (2 * Math.PI) * 0xFFFF)); + cursor.writeI32(Math.round(npc.rotation.z / (2 * Math.PI) * 0xFFFF)); + cursor.writeU8Array(npc.unknown[2]); + cursor.writeU32(npc.skin); + cursor.writeU8Array(npc.unknown[3]); } } for (const unknown of unknowns) { - cursor.write_u32(unknown.entity_type); - cursor.write_u32(unknown.total_size); - cursor.write_u32(unknown.area_id); - cursor.write_u32(unknown.entities_size); - cursor.write_u8_array(unknown.data); + cursor.writeU32(unknown.entityType); + cursor.writeU32(unknown.totalSize); + cursor.writeU32(unknown.areaId); + cursor.writeU32(unknown.entitiesSize); + cursor.writeU8Array(unknown.data); } // Final header. - cursor.write_u32(0); - cursor.write_u32(0); - cursor.write_u32(0); - cursor.write_u32(0); + cursor.writeU32(0); + cursor.writeU32(0); + cursor.writeU32(0); + cursor.writeU32(0); - cursor.seek_start(0); + cursor.seekStart(0); return cursor; } diff --git a/src/data/parsing/geometry.ts b/src/data/parsing/geometry.ts index 4a95db9e..1b86bfba 100644 --- a/src/data/parsing/geometry.ts +++ b/src/data/parsing/geometry.ts @@ -13,8 +13,8 @@ import { } from 'three'; import { Vec3, Section } from '../../domain'; -export function parse_c_rel(array_buffer: ArrayBuffer): Object3D { - const dv = new DataView(array_buffer); +export function parseCRel(arrayBuffer: ArrayBuffer): Object3D { + const dv = new DataView(arrayBuffer); const object = new Object3D(); const materials = [ @@ -40,7 +40,7 @@ export function parse_c_rel(array_buffer: ArrayBuffer): Object3D { side: DoubleSide }) ]; - const wireframe_materials = [ + const wireframeMaterials = [ // Wall new MeshBasicMaterial({ 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 main_offset_table_offset = dv.getUint32(main_block_offset, true); + const mainBlockOffset = dv.getUint32(dv.byteLength - 16, true); + const mainOffsetTableOffset = dv.getUint32(mainBlockOffset, true); for ( - let i = main_offset_table_offset; - i === main_offset_table_offset || dv.getUint32(i) !== 0; + let i = mainOffsetTableOffset; + i === mainOffsetTableOffset || dv.getUint32(i) !== 0; i += 24 ) { - const block_geometry = new Geometry(); + const blockGeometry = new Geometry(); - const block_trailer_offset = dv.getUint32(i, true); - const vertex_count = dv.getUint32(block_trailer_offset, true); - const vertex_table_offset = dv.getUint32(block_trailer_offset + 4, true); - const vertex_table_end = vertex_table_offset + 12 * vertex_count; - const triangle_count = dv.getUint32(block_trailer_offset + 8, true); - const triangle_table_offset = dv.getUint32(block_trailer_offset + 12, true); - const triangle_table_end = triangle_table_offset + 36 * triangle_count; + const blockTrailerOffset = dv.getUint32(i, true); + const vertexCount = dv.getUint32(blockTrailerOffset, true); + const vertexTableOffset = dv.getUint32(blockTrailerOffset + 4, true); + const vertexTableEnd = vertexTableOffset + 12 * vertexCount; + const triangleCount = dv.getUint32(blockTrailerOffset + 8, true); + const triangleTableOffset = dv.getUint32(blockTrailerOffset + 12, true); + 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 y = dv.getFloat32(j + 4, 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 v2 = dv.getUint16(j + 2, 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 + 16, true) ); - const is_section_transition = flags & 0b1000000; - const is_vegetation = flags & 0b10000; - const is_ground = flags & 0b1; - const color_index = is_section_transition ? 3 : (is_vegetation ? 2 : (is_ground ? 1 : 0)); + const isSectionTransition = flags & 0b1000000; + const isVegetation = flags & 0b10000; + const isGround = flags & 0b1; + 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; object.add(mesh); - const wireframe_mesh = new Mesh(block_geometry, wireframe_materials); - wireframe_mesh.renderOrder = 2; - object.add(wireframe_mesh); + const wireframeMesh = new Mesh(blockGeometry, wireframeMaterials); + wireframeMesh.renderOrder = 2; + object.add(wireframeMesh); } return object; } -export function parse_n_rel( - array_buffer: ArrayBuffer -): { sections: Section[], object_3d: Object3D } { - const dv = new DataView(array_buffer); +export function parseNRel( + arrayBuffer: ArrayBuffer +): { sections: Section[], object3d: Object3D } { + const dv = new DataView(arrayBuffer); const sections = new Map(); const object = new Object3D(); - const main_block_offset = dv.getUint32(dv.byteLength - 16, true); - const section_count = dv.getUint32(main_block_offset + 8, true); - const section_table_offset = dv.getUint32(main_block_offset + 16, true); - // const texture_name_offset = dv.getUint32(main_block_offset + 20, true); + const mainBlockOffset = dv.getUint32(dv.byteLength - 16, true); + const sectionCount = dv.getUint32(mainBlockOffset + 8, true); + const sectionTableOffset = dv.getUint32(mainBlockOffset + 16, true); + // const textureNameOffset = dv.getUint32(mainBlockOffset + 20, true); for ( - let i = section_table_offset; - i < section_table_offset + section_count * 52; + let i = sectionTableOffset; + i < sectionTableOffset + sectionCount * 52; i += 52 ) { - const section_id = dv.getInt32(i, true); - const section_x = dv.getFloat32(i + 4, true); - const section_y = dv.getFloat32(i + 8, true); - const section_z = dv.getFloat32(i + 12, true); - const section_rotation = dv.getInt32(i + 20, true) / 0xFFFF * 2 * Math.PI; + const sectionId = dv.getInt32(i, true); + const sectionX = dv.getFloat32(i + 4, true); + const sectionY = dv.getFloat32(i + 8, true); + const sectionZ = dv.getFloat32(i + 12, true); + const sectionRotation = dv.getInt32(i + 20, true) / 0xFFFF * 2 * Math.PI; const section = new Section( - section_id, - new Vec3(section_x, section_y, section_z), - section_rotation); - sections.set(section_id, section); + sectionId, + new Vec3(sectionX, sectionY, sectionZ), + sectionRotation + ); + sections.set(sectionId, section); - const index_lists_list = []; - const position_lists_list = []; - const normal_lists_list = []; + const indexListsList = []; + const positionListsList = []; + const normalListsList = []; - const simple_geometry_offset_table_offset = dv.getUint32(i + 32, true); - // const complex_geometry_offset_table_offset = dv.getUint32(i + 36, true); - const simple_geometry_offset_count = dv.getUint32(i + 40, true); - // const complex_geometry_offset_count = dv.getUint32(i + 44, true); + const simpleGeometryOffsetTableOffset = dv.getUint32(i + 32, true); + // const complexGeometryOffsetTableOffset = dv.getUint32(i + 36, true); + const simpleGeometryOffsetCount = dv.getUint32(i + 40, 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 ( - let j = simple_geometry_offset_table_offset; - j < simple_geometry_offset_table_offset + simple_geometry_offset_count * 16; + let j = simpleGeometryOffsetTableOffset; + j < simpleGeometryOffsetTableOffset + simpleGeometryOffsetCount * 16; j += 16 ) { let offset = dv.getUint32(j, true); @@ -173,133 +174,133 @@ export function parse_n_rel( offset = dv.getUint32(offset, true); } - const geometry_offset = dv.getUint32(offset + 4, true); + const geometryOffset = dv.getUint32(offset + 4, true); - if (geometry_offset > 0) { - const vertex_info_table_offset = dv.getUint32(geometry_offset + 4, true); - const vertex_info_count = dv.getUint32(geometry_offset + 8, true); - const triangle_strip_table_offset = dv.getUint32(geometry_offset + 12, true); - const triangle_strip_count = dv.getUint32(geometry_offset + 16, true); - // const transparent_object_table_offset = dv.getUint32(block_offset + 20, true); - // const transparent_object_count = dv.getUint32(block_offset + 24, true); + if (geometryOffset > 0) { + const vertexInfoTableOffset = dv.getUint32(geometryOffset + 4, true); + const vertexInfoCount = dv.getUint32(geometryOffset + 8, true); + const triangleStripTableOffset = dv.getUint32(geometryOffset + 12, true); + const triangleStripCount = dv.getUint32(geometryOffset + 16, true); + // const transparentObjectTableOffset = dv.getUint32(blockOffset + 20, 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 ( - let k = triangle_strip_table_offset; - k < triangle_strip_table_offset + triangle_strip_count * 20; + let k = triangleStripTableOffset; + k < triangleStripTableOffset + triangleStripCount * 20; k += 20 ) { - // const flag_and_texture_id_offset = dv.getUint32(k, true); - // const data_type = dv.getUint32(k + 4, true); - const triangle_strip_index_table_offset = dv.getUint32(k + 8, true); - const triangle_strip_index_count = dv.getUint32(k + 12, true); + // const flagAndTextureIdOffset = dv.getUint32(k, true); + // const dataType = dv.getUint32(k + 4, true); + const triangleStripIndexTableOffset = dv.getUint32(k + 8, true); + const triangleStripIndexCount = dv.getUint32(k + 12, true); - const triangle_strip_indices = []; + const triangleStripIndices = []; for ( - let l = triangle_strip_index_table_offset; - l < triangle_strip_index_table_offset + triangle_strip_index_count * 2; + let l = triangleStripIndexTableOffset; + l < triangleStripIndexTableOffset + triangleStripIndexCount * 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: Do the previous for the transparent index table. - // Assume vertex_info_count == 1. TODO: Does that make sense? - if (vertex_info_count > 1) { - console.warn(`Vertex info count of ${vertex_info_count} was larger than expected.`); + // Assume vertexInfoCount == 1. TODO: Does that make sense? + if (vertexInfoCount > 1) { + console.warn(`Vertex info count of ${vertexInfoCount} was larger than expected.`); } - // const vertex_type = dv.getUint32(vertex_info_table_offset, true); - const vertex_table_offset = dv.getUint32(vertex_info_table_offset + 4, true); - const vertex_size = dv.getUint32(vertex_info_table_offset + 8, true); - const vertex_count = dv.getUint32(vertex_info_table_offset + 12, true); + // const vertexType = dv.getUint32(vertexInfoTableOffset, true); + const vertexTableOffset = dv.getUint32(vertexInfoTableOffset + 4, true); + const vertexSize = dv.getUint32(vertexInfoTableOffset + 8, 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 geom_normals = []; + const geomPositions = []; + const geomNormals = []; for ( - let k = vertex_table_offset; - k < vertex_table_offset + vertex_count * vertex_size; - k += vertex_size + let k = vertexTableOffset; + k < vertexTableOffset + vertexCount * vertexSize; + k += vertexSize ) { - let n_x, n_y, n_z; + let nX, nY, nZ; - switch (vertex_size) { + switch (vertexSize) { case 16: case 24: // TODO: are these values sensible? - n_x = 0; - n_y = 1; - n_z = 0; + nX = 0; + nY = 1; + nZ = 0; break; case 28: case 36: - n_x = dv.getFloat32(k + 12, true); - n_y = dv.getFloat32(k + 16, true); - n_z = dv.getFloat32(k + 20, true); + nX = dv.getFloat32(k + 12, true); + nY = dv.getFloat32(k + 16, true); + nZ = dv.getFloat32(k + 20, true); // TODO: color, texture coords. break; default: - console.error(`Unexpected vertex size of ${vertex_size}.`); + console.error(`Unexpected vertex size of ${vertexSize}.`); continue; } const x = dv.getFloat32(k, true); const y = dv.getFloat32(k + 4, true); const z = dv.getFloat32(k + 8, true); - const rotated_x = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z; - const rotated_z = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z; + const rotatedX = section.cosYAxisRotation * x + section.sinYAxisRotation * z; + const rotatedZ = -section.sinYAxisRotation * x + section.cosYAxisRotation * z; - geom_positions.push(section_x + rotated_x); - geom_positions.push(section_y + y); - geom_positions.push(section_z + rotated_z); - geom_normals.push(n_x); - geom_normals.push(n_y); - geom_normals.push(n_z); + geomPositions.push(sectionX + rotatedX); + geomPositions.push(sectionY + y); + geomPositions.push(sectionZ + rotatedZ); + geomNormals.push(nX); + geomNormals.push(nY); + geomNormals.push(nZ); } - index_lists_list.push(geom_index_lists); - position_lists_list.push(geom_positions); - normal_lists_list.push(geom_normals); + indexListsList.push(geomIndexLists); + positionListsList.push(geomPositions); + normalListsList.push(geomNormals); } 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]; // } - for (let i = 0; i < position_lists_list.length; ++i) { - const positions = position_lists_list[i]; - const normals = normal_lists_list[i]; - const geom_index_lists = index_lists_list[i]; + for (let i = 0; i < positionListsList.length; ++i) { + const positions = positionListsList[i]; + const normals = normalListsList[i]; + const geomIndexLists = indexListsList[i]; // const indices = []; - geom_index_lists.forEach(object_indices => { - // for (let j = 2; j < object_indices.length; ++j) { - // const a = object_indices[j - 2]; - // const b = object_indices[j - 1]; - // const c = object_indices[j]; + geomIndexLists.forEach(objectIndices => { + // for (let j = 2; j < objectIndices.length; ++j) { + // const a = objectIndices[j - 2]; + // const b = objectIndices[j - 1]; + // const c = objectIndices[j]; // if (a !== b && a !== c && b !== c) { // const ap = positions.slice(3 * a, 3 * a + 3); // const bp = positions.slice(3 * b, 3 * b + 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) { // indices.push(a); // indices.push(b); @@ -318,7 +319,7 @@ export function parse_n_rel( 'position', new BufferAttribute(new Float32Array(positions), 3)); geometry.addAttribute( '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( geometry, @@ -352,7 +353,7 @@ export function parse_n_rel( // ); // object.add(mesh); - // const wireframe_mesh = new Mesh( + // const wireframeMesh = new Mesh( // geometry, // new MeshBasicMaterial({ // color: 0x88ccff, @@ -361,13 +362,13 @@ export function parse_n_rel( // opacity: 0.75, // }) // ); - // wireframe_mesh.setDrawMode(THREE.TriangleStripDrawMode); - // object.add(wireframe_mesh); + // wireframeMesh.setDrawMode(THREE.TriangleStripDrawMode); + // object.add(wireframeMesh); } } return { sections: [...sections.values()].sort((a, b) => a.id - b.id), - object_3d: object + object3d: object }; } diff --git a/src/data/parsing/ninja/index.ts b/src/data/parsing/ninja/index.ts index 418294b0..4feb687f 100644 --- a/src/data/parsing/ninja/index.ts +++ b/src/data/parsing/ninja/index.ts @@ -7,42 +7,42 @@ import { Vector3 } from 'three'; import { ArrayBufferCursor } from '../../ArrayBufferCursor'; -import { parse_nj_model, NjContext } from './nj'; -import { parse_xj_model, XjContext } from './xj'; +import { parseNjModel, NjContext } from './nj'; +import { parseXjModel, XjContext } from './xj'; // TODO: // - deal with multiple NJCM chunks // - deal with other types of chunks -export function parse_nj(cursor: ArrayBufferCursor): BufferGeometry | undefined { - return parse_ninja(cursor, 'nj'); +export function parseNj(cursor: ArrayBufferCursor): BufferGeometry | undefined { + return parseNinja(cursor, 'nj'); } -export function parse_xj(cursor: ArrayBufferCursor): BufferGeometry | undefined { - return parse_ninja(cursor, 'xj'); +export function parseXj(cursor: ArrayBufferCursor): BufferGeometry | undefined { + return parseNinja(cursor, 'xj'); } type Format = 'nj' | 'xj'; type Context = NjContext | XjContext; -function parse_ninja(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined { - while (cursor.bytes_left) { +function parseNinja(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined { + while (cursor.bytesLeft) { // Ninja uses a little endian variant of the IFF format. // 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. - const iff_type_id = cursor.string_ascii(4, false, false); - const iff_chunk_size = cursor.u32(); + const iffTypeId = cursor.stringAscii(4, false, false); + const iffChunkSize = cursor.u32(); - if (iff_type_id === 'NJCM') { - return parse_njcm(cursor.take(iff_chunk_size), format); + if (iffTypeId === 'NJCM') { + return parseNjcm(cursor.take(iffChunkSize), format); } else { - cursor.seek(iff_chunk_size); + cursor.seek(iffChunkSize); } } } -function parse_njcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined { - if (cursor.bytes_left) { +function parseNjcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry | undefined { + if (cursor.bytesLeft) { let context: Context; if (format === 'nj') { @@ -50,7 +50,7 @@ function parse_njcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry | format, positions: [], normals: [], - cached_chunk_offsets: [], + cachedChunkOffsets: [], vertices: [] }; } else { @@ -62,63 +62,63 @@ function parse_njcm(cursor: ArrayBufferCursor, format: Format): BufferGeometry | }; } - parse_sibling_objects(cursor, new Matrix4(), context); - return create_buffer_geometry(context); + parseSiblingObjects(cursor, new Matrix4(), context); + return createBufferGeometry(context); } } -function parse_sibling_objects( +function parseSiblingObjects( cursor: ArrayBufferCursor, - parent_matrix: Matrix4, + parentMatrix: Matrix4, context: Context ): void { - const eval_flags = cursor.u32(); - const no_translate = (eval_flags & 0b1) !== 0; - const no_rotate = (eval_flags & 0b10) !== 0; - const no_scale = (eval_flags & 0b100) !== 0; - const hidden = (eval_flags & 0b1000) !== 0; - const break_child_trace = (eval_flags & 0b10000) !== 0; - const zxy_rotation_order = (eval_flags & 0b100000) !== 0; + const evalFlags = cursor.u32(); + const noTranslate = (evalFlags & 0b1) !== 0; + const noRotate = (evalFlags & 0b10) !== 0; + const noScale = (evalFlags & 0b100) !== 0; + const hidden = (evalFlags & 0b1000) !== 0; + const breakChildTrace = (evalFlags & 0b10000) !== 0; + const zxyRotationOrder = (evalFlags & 0b100000) !== 0; - const model_offset = cursor.u32(); - const pos_x = cursor.f32(); - const pos_y = cursor.f32(); - const pos_z = cursor.f32(); - const rotation_x = cursor.i32() * (2 * Math.PI / 0xFFFF); - const rotation_y = cursor.i32() * (2 * Math.PI / 0xFFFF); - const rotation_z = cursor.i32() * (2 * Math.PI / 0xFFFF); - const scale_x = cursor.f32(); - const scale_y = cursor.f32(); - const scale_z = cursor.f32(); - const child_offset = cursor.u32(); - const sibling_offset = cursor.u32(); + const modelOffset = cursor.u32(); + const posX = cursor.f32(); + const posY = cursor.f32(); + const posZ = cursor.f32(); + const rotationX = cursor.i32() * (2 * Math.PI / 0xFFFF); + const rotationY = cursor.i32() * (2 * Math.PI / 0xFFFF); + const rotationZ = cursor.i32() * (2 * Math.PI / 0xFFFF); + const scaleX = cursor.f32(); + const scaleY = cursor.f32(); + const scaleZ = cursor.f32(); + const childOffset = 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() .compose( - no_translate ? new Vector3() : new Vector3(pos_x, pos_y, pos_z), - no_rotate ? 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) + noTranslate ? new Vector3() : new Vector3(posX, posY, posZ), + noRotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation), + noScale ? new Vector3(1, 1, 1) : new Vector3(scaleX, scaleY, scaleZ) ) - .premultiply(parent_matrix); + .premultiply(parentMatrix); - if (model_offset && !hidden) { - cursor.seek_start(model_offset); - parse_model(cursor, matrix, context); + if (modelOffset && !hidden) { + cursor.seekStart(modelOffset); + parseModel(cursor, matrix, context); } - if (child_offset && !break_child_trace) { - cursor.seek_start(child_offset); - parse_sibling_objects(cursor, matrix, context); + if (childOffset && !breakChildTrace) { + cursor.seekStart(childOffset); + parseSiblingObjects(cursor, matrix, context); } - if (sibling_offset) { - cursor.seek_start(sibling_offset); - parse_sibling_objects(cursor, parent_matrix, context); + if (siblingOffset) { + cursor.seekStart(siblingOffset); + parseSiblingObjects(cursor, parentMatrix, context); } } -function create_buffer_geometry(context: Context): BufferGeometry { +function createBufferGeometry(context: Context): BufferGeometry { const geometry = new BufferGeometry(); geometry.addAttribute('position', new BufferAttribute(new Float32Array(context.positions), 3)); geometry.addAttribute('normal', new BufferAttribute(new Float32Array(context.normals), 3)); @@ -130,10 +130,10 @@ function create_buffer_geometry(context: Context): BufferGeometry { 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') { - parse_nj_model(cursor, matrix, context); + parseNjModel(cursor, matrix, context); } else { - parse_xj_model(cursor, matrix, context); + parseXjModel(cursor, matrix, context); } } diff --git a/src/data/parsing/ninja/nj.ts b/src/data/parsing/ninja/nj.ts index 261ea8a2..4eb305c2 100644 --- a/src/data/parsing/ninja/nj.ts +++ b/src/data/parsing/ninja/nj.ts @@ -14,7 +14,7 @@ export interface NjContext { format: 'nj'; positions: number[]; normals: number[]; - cached_chunk_offsets: number[]; + cachedChunkOffsets: number[]; vertices: { position: Vector3, normal: Vector3 }[]; } @@ -32,47 +32,47 @@ interface ChunkVertex { } interface ChunkTriangleStrip { - clockwise_winding: boolean; + clockwiseWinding: boolean; indices: number[]; } -export function parse_nj_model(cursor: ArrayBufferCursor, matrix: Matrix4, context: NjContext): void { - const { positions, normals, cached_chunk_offsets, vertices } = context; +export function parseNjModel(cursor: ArrayBufferCursor, matrix: Matrix4, context: NjContext): void { + const { positions, normals, cachedChunkOffsets, vertices } = context; - const vlist_offset = cursor.u32(); // Vertex list - const plist_offset = cursor.u32(); // Triangle strip index list + const vlistOffset = cursor.u32(); // Vertex 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) { - cursor.seek_start(vlist_offset); + if (vlistOffset) { + cursor.seekStart(vlistOffset); - for (const chunk of parse_chunks(cursor, cached_chunk_offsets, true)) { - if (chunk.chunk_type === 'VERTEX') { - const chunk_vertices: ChunkVertex[] = chunk.data; + for (const chunk of parseChunks(cursor, cachedChunkOffsets, true)) { + if (chunk.chunkType === 'VERTEX') { + 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 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 }; } } } } - if (plist_offset) { - cursor.seek_start(plist_offset); + if (plistOffset) { + cursor.seekStart(plistOffset); - for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) { - if (chunk.chunk_type === 'STRIP') { - for (const { clockwise_winding, indices: strip_indices } of chunk.data) { - for (let j = 2; j < strip_indices.length; ++j) { - const a = vertices[strip_indices[j - 2]]; - const b = vertices[strip_indices[j - 1]]; - const c = vertices[strip_indices[j]]; + for (const chunk of parseChunks(cursor, cachedChunkOffsets, false)) { + if (chunk.chunkType === 'STRIP') { + for (const { clockwiseWinding, indices: stripIndices } of chunk.data) { + for (let j = 2; j < stripIndices.length; ++j) { + const a = vertices[stripIndices[j - 2]]; + const b = vertices[stripIndices[j - 1]]; + const c = vertices[stripIndices[j]]; 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, b.position.x, b.position.y, b.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 = []; let loop = true; while (loop) { - const chunk_type_id = cursor.u8(); + const chunkTypeId = cursor.u8(); const flags = cursor.u8(); - const chunk_start_position = cursor.position; - let chunk_type = 'UNKOWN'; - let chunk_sub_type = null; + const chunkStartPosition = cursor.position; + let chunkType = 'UNKOWN'; + let chunkSubType = null; let data = null; let size = 0; - if (chunk_type_id === 0) { - chunk_type = 'NULL'; - } else if (1 <= chunk_type_id && chunk_type_id <= 5) { - chunk_type = 'BITS'; + if (chunkTypeId === 0) { + chunkType = 'NULL'; + } else if (1 <= chunkTypeId && chunkTypeId <= 5) { + chunkType = 'BITS'; - if (chunk_type_id === 4) { - chunk_sub_type = 'CACHE_POLYGON_LIST'; + if (chunkTypeId === 4) { + chunkSubType = 'CACHE_POLYGON_LIST'; data = { - store_index: flags, + storeIndex: flags, offset: cursor.position }; - cached_chunk_offsets[data.store_index] = data.offset; + cachedChunkOffsets[data.storeIndex] = data.offset; loop = false; - } else if (chunk_type_id === 5) { - chunk_sub_type = 'DRAW_POLYGON_LIST'; + } else if (chunkTypeId === 5) { + chunkSubType = 'DRAW_POLYGON_LIST'; data = { - store_index: flags + storeIndex: flags }; - cursor.seek_start(cached_chunk_offsets[data.store_index]); - chunks.splice(chunks.length, 0, ...parse_chunks(cursor, cached_chunk_offsets, wide_end_chunks)); + cursor.seekStart(cachedChunkOffsets[data.storeIndex]); + chunks.splice(chunks.length, 0, ...parseChunks(cursor, cachedChunkOffsets, wideEndChunks)); } - } else if (8 <= chunk_type_id && chunk_type_id <= 9) { - chunk_type = 'TINY'; + } else if (8 <= chunkTypeId && chunkTypeId <= 9) { + chunkType = 'TINY'; size = 2; - } else if (17 <= chunk_type_id && chunk_type_id <= 31) { - chunk_type = 'MATERIAL'; + } else if (17 <= chunkTypeId && chunkTypeId <= 31) { + chunkType = 'MATERIAL'; size = 2 + 2 * cursor.u16(); - } else if (32 <= chunk_type_id && chunk_type_id <= 50) { - chunk_type = 'VERTEX'; + } else if (32 <= chunkTypeId && chunkTypeId <= 50) { + chunkType = 'VERTEX'; size = 2 + 4 * cursor.u16(); - data = parse_chunk_vertex(cursor, chunk_type_id, flags); - } else if (56 <= chunk_type_id && chunk_type_id <= 58) { - chunk_type = 'VOLUME'; + data = parseChunkVertex(cursor, chunkTypeId, flags); + } else if (56 <= chunkTypeId && chunkTypeId <= 58) { + chunkType = 'VOLUME'; size = 2 + 2 * cursor.u16(); - } else if (64 <= chunk_type_id && chunk_type_id <= 75) { - chunk_type = 'STRIP'; + } else if (64 <= chunkTypeId && chunkTypeId <= 75) { + chunkType = 'STRIP'; size = 2 + 2 * cursor.u16(); - data = parse_chunk_triangle_strip(cursor, chunk_type_id); - } else if (chunk_type_id === 255) { - chunk_type = 'END'; - size = wide_end_chunks ? 2 : 0; + data = parseChunkTriangleStrip(cursor, chunkTypeId); + } else if (chunkTypeId === 255) { + chunkType = 'END'; + size = wideEndChunks ? 2 : 0; loop = false; } else { // Ignore unknown chunks. - console.warn(`Unknown chunk type: ${chunk_type_id}.`); + console.warn(`Unknown chunk type: ${chunkTypeId}.`); size = 2 + 2 * cursor.u16(); } - cursor.seek_start(chunk_start_position + size); + cursor.seekStart(chunkStartPosition + size); chunks.push({ - chunk_type, - chunk_sub_type, - chunk_type_id, + chunkType, + chunkSubType, + chunkTypeId, data }); } @@ -169,18 +174,18 @@ function parse_chunks(cursor: ArrayBufferCursor, cached_chunk_offsets: number[], 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. if ((flags & 0b11) !== 0) { return []; } const index = cursor.u16(); - const vertex_count = cursor.u16(); + const vertexCount = cursor.u16(); const vertices: ChunkVertex[] = []; - for (let i = 0; i < vertex_count; ++i) { + for (let i = 0; i < vertexCount; ++i) { const vertex: ChunkVertex = { index: index + i, 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 - } else if (chunk_type_id === 33) { + } else if (chunkTypeId === 33) { cursor.seek(4); // Always 1.0 vertex.normal = [ cursor.f32(), // x @@ -200,8 +205,8 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl cursor.f32(), // z ]; cursor.seek(4); // Always 0.0 - } else if (35 <= chunk_type_id && chunk_type_id <= 40) { - if (chunk_type_id === 37) { + } else if (35 <= chunkTypeId && chunkTypeId <= 40) { + if (chunkTypeId === 37) { // Ninja flags vertex.index = index + cursor.u16(); cursor.seek(2); @@ -209,15 +214,15 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl // Skip user flags and material information. cursor.seek(4); } - } else if (41 <= chunk_type_id && chunk_type_id <= 47) { + } else if (41 <= chunkTypeId && chunkTypeId <= 47) { vertex.normal = [ cursor.f32(), // x cursor.f32(), // y cursor.f32(), // z ]; - if (chunk_type_id >= 42) { - if (chunk_type_id === 44) { + if (chunkTypeId >= 42) { + if (chunkTypeId === 44) { // Ninja flags vertex.index = index + cursor.u16(); cursor.seek(2); @@ -226,11 +231,11 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl 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) cursor.seek(4); - if (chunk_type_id >= 49) { + if (chunkTypeId >= 49) { // Skip user flags and material information. cursor.seek(4); } @@ -242,13 +247,13 @@ function parse_chunk_vertex(cursor: ArrayBufferCursor, chunk_type_id: number, fl return vertices; } -function parse_chunk_triangle_strip(cursor: ArrayBufferCursor, chunk_type_id: number): ChunkTriangleStrip[] { - const user_offset_and_strip_count = cursor.u16(); - const user_flags_size = user_offset_and_strip_count >>> 14; - const strip_count = user_offset_and_strip_count & 0x3FFF; +function parseChunkTriangleStrip(cursor: ArrayBufferCursor, chunkTypeId: number): ChunkTriangleStrip[] { + const userOffsetAndStripCount = cursor.u16(); + const userFlagsSize = userOffsetAndStripCount >>> 14; + const stripCount = userOffsetAndStripCount & 0x3FFF; let options; - switch (chunk_type_id) { + switch (chunkTypeId) { case 64: options = [false, false, false, false]; break; case 65: 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 74: 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 [ - parse_texture_coords, - parse_color, - parse_normal, - parse_texture_coords_hires + parseTextureCoords, + parseColor, + parseNormal, + parseTextureCoordsHires ] = options; const strips = []; - for (let i = 0; i < strip_count; ++i) { - const winding_flag_and_index_count = cursor.i16(); - const clockwise_winding = winding_flag_and_index_count < 1; - const index_count = Math.abs(winding_flag_and_index_count); + for (let i = 0; i < stripCount; ++i) { + const windingFlagAndIndexCount = cursor.i16(); + const clockwiseWinding = windingFlagAndIndexCount < 1; + const indexCount = Math.abs(windingFlagAndIndexCount); const indices = []; - for (let j = 0; j < index_count; ++j) { + for (let j = 0; j < indexCount; ++j) { indices.push(cursor.u16()); - if (parse_texture_coords) { + if (parseTextureCoords) { cursor.seek(4); } - if (parse_color) { + if (parseColor) { cursor.seek(4); } - if (parse_normal) { + if (parseNormal) { cursor.seek(6); } - if (parse_texture_coords_hires) { + if (parseTextureCoordsHires) { cursor.seek(8); } if (j >= 2) { - cursor.seek(2 * user_flags_size); + cursor.seek(2 * userFlagsSize); } } - strips.push({ clockwise_winding, indices }); + strips.push({ clockwiseWinding, indices }); } return strips; diff --git a/src/data/parsing/ninja/xj.ts b/src/data/parsing/ninja/xj.ts index 9ea3442f..e863e818 100644 --- a/src/data/parsing/ninja/xj.ts +++ b/src/data/parsing/ninja/xj.ts @@ -14,30 +14,30 @@ export interface XjContext { 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; cursor.seek(4); // Flags according to QEdit, seemingly always 0. - const vertex_info_list_offset = cursor.u32(); - cursor.seek(4); // Seems to be the vertex_info_count, always 1. - const triangle_strip_list_a_offset = cursor.u32(); - const triangle_strip_a_count = cursor.u32(); - const triangle_strip_list_b_offset = cursor.u32(); - const triangle_strip_b_count = cursor.u32(); + const vertexInfoListOffset = cursor.u32(); + cursor.seek(4); // Seems to be the vertexInfoCount, always 1. + const triangleStripListAOffset = cursor.u32(); + const triangleStripACount = cursor.u32(); + const triangleStripListBOffset = cursor.u32(); + const triangleStripBCount = cursor.u32(); cursor.seek(16); // Bounding sphere position and radius in floats. - const normal_matrix = new Matrix3().getNormalMatrix(matrix); - const index_offset = positions.length / 3; + const normalMatrix = new Matrix3().getNormalMatrix(matrix); + const indexOffset = positions.length / 3; - if (vertex_info_list_offset) { - cursor.seek_start(vertex_info_list_offset); + if (vertexInfoListOffset) { + cursor.seekStart(vertexInfoListOffset); cursor.seek(4); // Possibly the vertex type. - const vertex_list_offset = cursor.u32(); - const vertex_size = cursor.u32(); - const vertex_count = cursor.u32(); + const vertexListOffset = cursor.u32(); + const vertexSize = cursor.u32(); + const vertexCount = cursor.u32(); - for (let i = 0; i < vertex_count; ++i) { - cursor.seek_start(vertex_list_offset + i * vertex_size); + for (let i = 0; i < vertexCount; ++i) { + cursor.seekStart(vertexListOffset + i * vertexSize); const position = new Vector3( cursor.f32(), cursor.f32(), @@ -45,12 +45,12 @@ export function parse_xj_model(cursor: ArrayBufferCursor, matrix: Matrix4, conte ).applyMatrix4(matrix); let normal; - if (vertex_size === 28 || vertex_size === 32 || vertex_size === 36) { + if (vertexSize === 28 || vertexSize === 32 || vertexSize === 36) { normal = new Vector3( cursor.f32(), cursor.f32(), cursor.f32() - ).applyMatrix3(normal_matrix); + ).applyMatrix3(normalMatrix); } else { 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) { - parse_triangle_strip_list( + if (triangleStripListAOffset) { + parseTriangleStripList( cursor, - triangle_strip_list_a_offset, - triangle_strip_a_count, + triangleStripListAOffset, + triangleStripACount, positions, normals, indices, - index_offset); + indexOffset + ); } - if (triangle_strip_list_b_offset) { - parse_triangle_strip_list( + if (triangleStripListBOffset) { + parseTriangleStripList( cursor, - triangle_strip_list_b_offset, - triangle_strip_b_count, + triangleStripListBOffset, + triangleStripBCount, positions, normals, indices, - index_offset); + indexOffset + ); } } -function parse_triangle_strip_list( +function parseTriangleStripList( cursor: ArrayBufferCursor, - triangle_strip_list_offset: number, - triangle_strip_count: number, + triangleStripListOffset: number, + triangleStripCount: number, positions: number[], normals: number[], indices: number[], - index_offset: number + indexOffset: number ): void { - for (let i = 0; i < triangle_strip_count; ++i) { - cursor.seek_start(triangle_strip_list_offset + i * 20); + for (let i = 0; i < triangleStripCount; ++i) { + cursor.seekStart(triangleStripListOffset + i * 20); cursor.seek(8); // Skip material information. - const index_list_offset = cursor.u32(); - const index_count = cursor.u32(); + const indexListOffset = cursor.u32(); + const indexCount = cursor.u32(); // Ignoring 4 bytes. - cursor.seek_start(index_list_offset); - const strip_indices = cursor.u16_array(index_count); + cursor.seekStart(indexListOffset); + const stripIndices = cursor.u16Array(indexCount); let clockwise = true; - for (let j = 2; j < strip_indices.length; ++j) { - const a = index_offset + strip_indices[j - 2]; - const b = index_offset + strip_indices[j - 1]; - const c = index_offset + strip_indices[j]; + for (let j = 2; j < stripIndices.length; ++j) { + const a = indexOffset + stripIndices[j - 2]; + const b = indexOffset + stripIndices[j - 1]; + const c = indexOffset + stripIndices[j]; 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 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(); } - const opposite_count = + const oppositeCount = (normal.dot(na) < 0 ? 1 : 0) + (normal.dot(nb) < 0 ? 1 : 0) + (normal.dot(nc) < 0 ? 1 : 0); - if (opposite_count >= 2) { + if (oppositeCount >= 2) { clockwise = !clockwise; } diff --git a/src/data/parsing/qst.test.ts b/src/data/parsing/qst.test.ts index 8ad24044..3381b9a9 100644 --- a/src/data/parsing/qst.test.ts +++ b/src/data/parsing/qst.test.ts @@ -1,27 +1,25 @@ -import * as fs from 'fs'; import { ArrayBufferCursor } from '../ArrayBufferCursor'; -import * as prs from '../compression/prs'; -import { parse_qst, write_qst } from './qst'; -import { walk_qst_files } from '../../../test/src/utils'; +import { parseQst, writeQst } from './qst'; +import { walkQstFiles } 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. */ -test('parse_qst and write_qst', () => { - walk_qst_files((file_path, file_name, file_content) => { - const orig_qst = new ArrayBufferCursor(file_content.buffer, true); - const orig_quest = parse_qst(orig_qst); +test('parseQst and writeQst', () => { + walkQstFiles((_filePath, _fileName, fileContent) => { + const origQst = new ArrayBufferCursor(fileContent.buffer, true); + const origQuest = parseQst(origQst); - if (orig_quest) { - const test_qst = write_qst(orig_quest); - orig_qst.seek_start(0); + if (origQuest) { + const testQst = writeQst(origQuest); + origQst.seekStart(0); - expect(test_qst.size).toBe(orig_qst.size); + expect(testQst.size).toBe(origQst.size); let match = true; - while (orig_qst.bytes_left) { - if (test_qst.u8() !== orig_qst.u8()) { + while (origQst.bytesLeft) { + if (testQst.u8() !== origQst.u8()) { match = false; break; } diff --git a/src/data/parsing/qst.ts b/src/data/parsing/qst.ts index 8eec3d5c..58ffd885 100644 --- a/src/data/parsing/qst.ts +++ b/src/data/parsing/qst.ts @@ -2,11 +2,11 @@ import { ArrayBufferCursor } from '../ArrayBufferCursor'; interface QstContainedFile { name: string; - name_2?: string; // Unsure what this is - quest_no?: number; - expected_size?: number; + name2?: string; // Unsure what this is + questNo?: number; + expectedSize?: number; data: ArrayBufferCursor; - chunk_nos: Set; + chunkNos: Set; } interface ParseQstResult { @@ -18,40 +18,40 @@ interface ParseQstResult { * Low level parsing function for .qst files. * 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. let version = 'PC'; // Detect version. - const version_a = cursor.u8(); + const versionA = cursor.u8(); cursor.seek(1); - const version_b = cursor.u8(); + const versionB = cursor.u8(); - if (version_a === 0x44) { + if (versionA === 0x44) { version = 'Dreamcast/GameCube'; - } else if (version_a === 0x58) { - if (version_b === 0x44) { + } else if (versionA === 0x58) { + if (versionB === 0x44) { version = 'Blue Burst'; } - } else if (version_a === 0xA6) { + } else if (versionA === 0xA6) { version = 'Dreamcast download'; } if (version === 'Blue Burst') { // 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( - cursor, new Map(headers.map(h => [h.file_name, h.size]))); + const files = parseFiles( + cursor, new Map(headers.map(h => [h.fileName, h.size]))); 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) { - file.quest_no = header.quest_no; - file.name_2 = header.file_name_2; + file.questNo = header.questNo; + file.name2 = header.fileName2; } } @@ -66,8 +66,8 @@ export function parse_qst(cursor: ArrayBufferCursor): ParseQstResult | null { interface SimpleQstContainedFile { name: string; - name_2?: string; - quest_no?: number; + name2?: string; + questNo?: number; data: ArrayBufferCursor; } @@ -79,77 +79,84 @@ interface WriteQstParams { /** * Always writes in Blue Burst format. */ -export function write_qst(params: WriteQstParams): ArrayBufferCursor { +export function writeQst(params: WriteQstParams): ArrayBufferCursor { const files = params.files; - const total_size = files + const totalSize = files .map(f => 88 + Math.ceil(f.data.size / 1024) * 1056) .reduce((a, b) => a + b); - const cursor = new ArrayBufferCursor(total_size, true); + const cursor = new ArrayBufferCursor(totalSize, true); - write_file_headers(cursor, files); - write_file_chunks(cursor, files); + writeFileHeaders(cursor, files); + writeFileChunks(cursor, files); - if (cursor.size !== total_size) { - throw new Error(`Expected a final file size of ${total_size}, but got ${cursor.size}.`); + if (cursor.size !== totalSize) { + 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. */ -function parse_headers(cursor: ArrayBufferCursor): any[] { - const files = []; +function parseHeaders(cursor: ArrayBufferCursor): QstHeader[] { + const headers = []; for (let i = 0; i < 2; ++i) { cursor.seek(4); - const quest_no = cursor.u16(); + const questNo = cursor.u16(); cursor.seek(38); - const file_name = cursor.string_ascii(16, true, true); + const fileName = cursor.stringAscii(16, true, true); const size = cursor.u32(); // Not sure what this is: - const file_name_2 = cursor.string_ascii(24, true, true); + const fileName2 = cursor.stringAscii(24, true, true); - files.push({ - quest_no, - file_name, - file_name_2, + headers.push({ + questNo, + fileName, + fileName2, size }); } - return files; + return headers; } -function parse_files(cursor: ArrayBufferCursor, expected_sizes: Map): QstContainedFile[] { +function parseFiles(cursor: ArrayBufferCursor, expectedSizes: Map): QstContainedFile[] { // Files are interleaved in 1056 byte chunks. // Each chunk has a 24 byte header, 1024 byte data segment and an 8 byte trailer. const files = new Map(); - while (cursor.bytes_left) { - const start_position = cursor.position; + while (cursor.bytesLeft) { + const startPosition = cursor.position; // Read meta data. - const chunk_no = cursor.seek(4).u8(); - const file_name = cursor.seek(3).string_ascii(16, true, true); + const chunkNo = cursor.seek(4).u8(); + const fileName = cursor.seek(3).stringAscii(16, true, true); - let file = files.get(file_name); + let file = files.get(fileName); if (!file) { - const expected_size = expected_sizes.get(file_name); - files.set(file_name, file = { - name: file_name, - expected_size, - data: new ArrayBufferCursor(expected_size || (10 * 1024), true), - chunk_nos: new Set() + const expectedSize = expectedSizes.get(fileName); + files.set(fileName, file = { + name: fileName, + expectedSize, + data: new ArrayBufferCursor(expectedSize || (10 * 1024), true), + chunkNos: new Set() }); } - if (file.chunk_nos.has(chunk_no)) { - console.warn(`File chunk number ${chunk_no} of file ${file_name} was already encountered, overwriting previous chunk.`); + if (file.chunkNos.has(chunkNo)) { + console.warn(`File chunk number ${chunkNo} of file ${fileName} was already encountered, overwriting previous chunk.`); } else { - file.chunk_nos.add(chunk_no); + file.chunkNos.add(chunkNo); } // Read file data. @@ -162,34 +169,34 @@ function parse_files(cursor: ArrayBufferCursor, expected_sizes: Map a - b)); + file.data.seekStart(0); + file.chunkNos = new Set(Array.from(file.chunkNos.values()).sort((a, b) => a - b)); // Check whether the expected size was correct. - if (file.expected_size != null && file.data.size !== file.expected_size) { - console.warn(`File ${file.name} has an actual size of ${file.data.size} instead of the expected 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.expectedSize}.`); } // 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) { - if (!file.chunk_nos.has(chunk_no)) { - console.warn(`File ${file.name} is missing chunk ${chunk_no}.`); + for (let chunkNo = 0; chunkNo < Math.ceil(actualSize / 1024); ++chunkNo) { + if (!file.chunkNos.has(chunkNo)) { + console.warn(`File ${file.name} is missing chunk ${chunkNo}.`); } } } @@ -197,49 +204,49 @@ function parse_files(cursor: ArrayBufferCursor, expected_sizes: Map { const buffer = fs.readFileSync('test/resources/quest118_e.qst').buffer; const cursor = new ArrayBufferCursor(buffer, true); - const quest = parse_quest(cursor)!; + const quest = parseQuest(cursor)!; expect(quest.name).toBe('Towards the Future'); - expect(quest.short_description).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.shortDescription).toBe('Challenge the\nnew simulator.'); + expect(quest.longDescription).toBe('Client: Principal\nQuest: Wishes to have\nhunters challenge the\nnew simulator\nReward: ??? Meseta'); expect(quest.episode).toBe(1); expect(quest.objects.length).toBe(277); expect(quest.objects[0].type).toBe(ObjectType.MenuActivation); expect(quest.objects[4].type).toBe(ObjectType.PlayerSet); expect(quest.npcs.length).toBe(216); - expect(testable_area_variants(quest)).toEqual([ - [0, 0], [2, 0], [11, 0], [5, 4], [12, 0], [7, 4], [13, 0], [8, 4], [10, 4], [14, 0]]); + expect(testableAreaVariants(quest)).toEqual([ + [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. * 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 cursor = new ArrayBufferCursor(buffer, true); - const orig_quest = parse_quest(cursor)!; - const test_quest = parse_quest(write_quest_qst(orig_quest, '02.qst'))!; + const origQuest = parseQuest(cursor)!; + const testQuest = parseQuest(writeQuestQst(origQuest, '02.qst'))!; - expect(test_quest.name).toBe(orig_quest.name); - expect(test_quest.short_description).toBe(orig_quest.short_description); - expect(test_quest.long_description).toBe(orig_quest.long_description); - expect(test_quest.episode).toBe(orig_quest.episode); - expect(testable_objects(test_quest)) - .toEqual(testable_objects(orig_quest)); - expect(testable_npcs(test_quest)) - .toEqual(testable_npcs(orig_quest)); - expect(testable_area_variants(test_quest)) - .toEqual(testable_area_variants(orig_quest)); + expect(testQuest.name).toBe(origQuest.name); + expect(testQuest.shortDescription).toBe(origQuest.shortDescription); + expect(testQuest.longDescription).toBe(origQuest.longDescription); + expect(testQuest.episode).toBe(origQuest.episode); + expect(testableObjects(testQuest)) + .toEqual(testableObjects(origQuest)); + expect(testableNpcs(testQuest)) + .toEqual(testableNpcs(origQuest)); + expect(testableAreaVariants(testQuest)) + .toEqual(testableAreaVariants(origQuest)); }); -function testable_objects(quest: Quest) { +function testableObjects(quest: Quest) { return quest.objects.map(object => [ - object.area_id, - object.section_id, + object.areaId, + object.sectionId, object.position, object.type ]); } -function testable_npcs(quest: Quest) { +function testableNpcs(quest: Quest) { return quest.npcs.map(npc => [ - npc.area_id, - npc.section_id, + npc.areaId, + npc.sectionId, npc.position, npc.type ]); } -function testable_area_variants(quest: Quest) { - return quest.area_variants.map(av => [av.area.id, av.id]); +function testableAreaVariants(quest: Quest) { + return quest.areaVariants.map(av => [av.area.id, av.id]); } diff --git a/src/data/parsing/quest.ts b/src/data/parsing/quest.ts index 1c02d1a3..18afb63f 100644 --- a/src/data/parsing/quest.ts +++ b/src/data/parsing/quest.ts @@ -1,8 +1,8 @@ import { ArrayBufferCursor } from '../ArrayBufferCursor'; import * as prs from '../compression/prs'; -import { parse_dat, write_dat } from './dat'; -import { parse_bin, write_bin, Instruction } from './bin'; -import { parse_qst, write_qst } from './qst'; +import { parseDat, writeDat, DatObject, DatNpc } from './dat'; +import { parseBin, writeBin, Instruction } from './bin'; +import { parseQst, writeQst } from './qst'; import { Vec3, AreaVariant, @@ -12,89 +12,89 @@ import { ObjectType, NpcType } from '../../domain'; -import { area_store } from '../../store'; +import { areaStore } from '../../store'; /** * 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 { - const qst = parse_qst(cursor); +export function parseQuest(cursor: ArrayBufferCursor): Quest | null { + const qst = parseQst(cursor); if (!qst) { return null; } - let dat_file = null; - let bin_file = null; + let datFile = null; + let binFile = null; for (const file of qst.files) { if (file.name.endsWith('.dat')) { - dat_file = file; + datFile = file; } else if (file.name.endsWith('.bin')) { - bin_file = file; + binFile = file; } } // TODO: deal with missing/multiple DAT or BIN file. - if (!dat_file || !bin_file) { + if (!datFile || !binFile) { return null; } - const dat = parse_dat(prs.decompress(dat_file.data)); - const bin = parse_bin(prs.decompress(bin_file.data)); + const dat = parseDat(prs.decompress(datFile.data)); + const bin = parseBin(prs.decompress(binFile.data)); let episode = 1; - let area_variants: AreaVariant[] = []; + let areaVariants: AreaVariant[] = []; - if (bin.function_offsets.length) { - const func_0_ops = get_func_operations(bin.instructions, bin.function_offsets[0]); + if (bin.functionOffsets.length) { + const func0Ops = getFuncOperations(bin.instructions, bin.functionOffsets[0]); - if (func_0_ops) { - episode = get_episode(func_0_ops); - area_variants = get_area_variants(episode, func_0_ops); + if (func0Ops) { + episode = getEpisode(func0Ops); + areaVariants = getAreaVariants(episode, func0Ops); } else { - console.warn(`Function 0 offset ${bin.function_offsets[0]} is invalid.`); + console.warn(`Function 0 offset ${bin.functionOffsets[0]} is invalid.`); } } else { console.warn('File contains no functions.'); } return new Quest( - bin.quest_name, - bin.short_description, - bin.long_description, - dat_file.quest_no, + bin.questName, + bin.shortDescription, + bin.longDescription, + datFile.questNo, episode, - area_variants, - parse_obj_data(dat.objs), - parse_npc_data(episode, dat.npcs), - { unknowns: dat.unknowns }, + areaVariants, + parseObjData(dat.objs), + parseNpcData(episode, dat.npcs), + dat.unknowns, bin.data ); } -export function write_quest_qst(quest: Quest, file_name: string): ArrayBufferCursor { - const dat = write_dat({ - objs: objects_to_dat_data(quest.episode, quest.objects), - npcs: npcs_to_dat_data(quest.episode, quest.npcs), - unknowns: quest.dat.unknowns +export function writeQuestQst(quest: Quest, fileName: string): ArrayBufferCursor { + const dat = writeDat({ + objs: objectsToDatData(quest.objects), + npcs: npcsToDatData(quest.npcs), + unknowns: quest.datUnkowns }); - const bin = write_bin({ data: quest.bin }); - const ext_start = file_name.lastIndexOf('.'); - const base_file_name = ext_start === -1 ? file_name : file_name.slice(0, ext_start); + const bin = writeBin({ data: quest.binData }); + const extStart = fileName.lastIndexOf('.'); + const baseFileName = extStart === -1 ? fileName : fileName.slice(0, extStart); - return write_qst({ + return writeQst({ files: [ { - name: base_file_name + '.dat', - quest_no: quest.quest_no, + name: baseFileName + '.dat', + questNo: quest.questNo, data: prs.compress(dat) }, { - name: base_file_name + '.bin', - quest_no: quest.quest_no, + name: baseFileName + '.bin', + questNo: quest.questNo, data: prs.compress(bin) } ] @@ -104,11 +104,11 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBufferCur /** * Defaults to episode I. */ -function get_episode(func_0_ops: Instruction[]): number { - const set_episode = func_0_ops.find(op => op.mnemonic === 'set_episode'); +function getEpisode(func0Ops: Instruction[]): number { + const setEpisode = func0Ops.find(op => op.mnemonic === 'set_episode'); - if (set_episode) { - switch (set_episode.args[0]) { + if (setEpisode) { + switch (setEpisode.args[0]) { default: case 0: return 1; 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[] { - const area_variants = new Map(); - const bb_maps = func_0_ops.filter(op => op.mnemonic === 'BB_Map_Designate'); +function getAreaVariants(episode: number, func0Ops: Instruction[]): AreaVariant[] { + const areaVariants = new Map(); + const bbMaps = func0Ops.filter(op => op.mnemonic === 'BB_Map_Designate'); - for (const bb_map of bb_maps) { - const area_id = bb_map.args[0]; - const variant_id = bb_map.args[2]; - area_variants.set(area_id, variant_id); + for (const bbMap of bbMaps) { + const areaId = bbMap.args[0]; + const variantId = bbMap.args[2]; + areaVariants.set(areaId, variantId); } // Sort by area order and then variant id. return ( - Array.from(area_variants) - .map(([area_id, variant_id]) => - area_store.get_variant(episode, area_id, variant_id)) + Array.from(areaVariants) + .map(([areaId, variantId]) => + areaStore.getVariant(episode, areaId, variantId)) .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 func_found = false; - const func_ops = []; + let funcFound = false; + const funcOps: Instruction[] = []; for (const operation of operations) { - if (position === func_offset) { - func_found = true; + if (position === funcOffset) { + funcFound = true; } - if (func_found) { - func_ops.push(operation); + if (funcFound) { + funcOps.push(operation); // Break when ret is encountered. if (operation.opcode === 1) { @@ -161,43 +161,43 @@ function get_func_operations(operations: Instruction[], func_offset: number) { position += operation.size; } - return func_found ? func_ops : null; + return funcFound ? funcOps : null; } -function parse_obj_data(objs: any[]): QuestObject[] { - return objs.map(obj_data => { - const { x, y, z } = obj_data.position; - const rot = obj_data.rotation; +function parseObjData(objs: DatObject[]): QuestObject[] { + return objs.map(objData => { + const { x, y, z } = objData.position; + const rot = objData.rotation; return new QuestObject( - obj_data.area_id, - obj_data.section_id, + objData.areaId, + objData.sectionId, new Vec3(x, y, z), new Vec3(rot.x, rot.y, rot.z), - ObjectType.from_pso_id(obj_data.type_id), - obj_data + ObjectType.fromPsoId(objData.typeId), + objData ); }); } -function parse_npc_data(episode: number, npcs: any[]): QuestNpc[] { - return npcs.map(npc_data => { - const { x, y, z } = npc_data.position; - const rot = npc_data.rotation; +function parseNpcData(episode: number, npcs: DatNpc[]): QuestNpc[] { + return npcs.map(npcData => { + const { x, y, z } = npcData.position; + const rot = npcData.rotation; return new QuestNpc( - npc_data.area_id, - npc_data.section_id, + npcData.areaId, + npcData.sectionId, new Vec3(x, y, z), new Vec3(rot.x, rot.y, rot.z), - get_npc_type(episode, npc_data), - npc_data + getNpcType(episode, npcData), + 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; - switch (`${type_id}, ${skin % 3}, ${episode}`) { + switch (`${typeId}, ${skin % 3}, ${episode}`) { case `${0x044}, 0, 1`: return NpcType.Booma; case `${0x044}, 1, 1`: return NpcType.Gobooma; 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; } - switch (`${type_id}, ${skin % 2}, ${episode}`) { + switch (`${typeId}, ${skin % 2}, ${episode}`) { case `${0x040}, 0, 1`: return NpcType.Hildebear; case `${0x040}, 0, 2`: return NpcType.Hildebear2; 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, 4`: return NpcType.DelRappy; - case `${0x061}, 0, 1`: return area_id > 15 ? NpcType.DelLily : NpcType.PoisonLily; - case `${0x061}, 0, 2`: return area_id > 15 ? NpcType.DelLily : NpcType.PoisonLily2; - case `${0x061}, 1, 1`: return area_id > 15 ? NpcType.DelLily : NpcType.NarLily; - case `${0x061}, 1, 2`: return area_id > 15 ? NpcType.DelLily : NpcType.NarLily2; + case `${0x061}, 0, 1`: return areaId > 15 ? NpcType.DelLily : NpcType.PoisonLily; + case `${0x061}, 0, 2`: return areaId > 15 ? NpcType.DelLily : NpcType.PoisonLily2; + case `${0x061}, 1, 1`: return areaId > 15 ? NpcType.DelLily : NpcType.NarLily; + case `${0x061}, 1, 2`: return areaId > 15 ? NpcType.DelLily : NpcType.NarLily2; case `${0x080}, 0, 1`: return NpcType.Dubchic; 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}, 1, 2`: return NpcType.Dolmdarl; - case `${0x0E0}, 0, 2`: return area_id > 15 ? NpcType.Epsilon : NpcType.SinowZoa; - case `${0x0E0}, 1, 2`: return area_id > 15 ? NpcType.Epsilon : NpcType.SinowZele; + case `${0x0E0}, 0, 2`: return areaId > 15 ? NpcType.Epsilon : NpcType.SinowZoa; + case `${0x0E0}, 1, 2`: return areaId > 15 ? NpcType.Epsilon : NpcType.SinowZele; case `${0x112}, 0, 4`: return NpcType.MerissaA; 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; } - switch (`${type_id}, ${episode}`) { + switch (`${typeId}, ${episode}`) { case `${0x042}, 1`: return NpcType.Monest; case `${0x042}, 2`: return NpcType.Monest2; 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; } - switch (type_id) { + switch (typeId) { case 0x004: return NpcType.FemaleFat; case 0x005: return NpcType.FemaleMacho; 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: - 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; } -function objects_to_dat_data(episode: number, objects: QuestObject[]): any[] { +function objectsToDatData(objects: QuestObject[]): DatObject[] { return objects.map(object => ({ - type_id: object.type.pso_id, - section_id: object.section_id, - position: object.section_position, + typeId: object.type.psoId!, + sectionId: object.sectionId, + position: object.sectionPosition, rotation: object.rotation, - area_id: object.area_id, + areaId: object.areaId, unknown: object.dat.unknown })); } -function npcs_to_dat_data(episode: number, npcs: QuestNpc[]): any[] { +function npcsToDatData(npcs: QuestNpc[]): DatNpc[] { return npcs.map(npc => { - // If the type is unknown, type_data will be null and we use the raw data from the DAT file. - const type_data = npc_type_to_dat_data(npc.type); + // If the type is unknown, typeData will be null and we use the raw data from the DAT file. + const typeData = npcTypeToDatData(npc.type); - if (type_data) { - npc.dat.unknown[2][18] = (npc.dat.unknown[2][18] & ~0x80) | (type_data.regular ? 0 : 0x80); + if (typeData) { + npc.dat.unknown[2][18] = (npc.dat.unknown[2][18] & ~0x80) | (typeData.regular ? 0 : 0x80); } return { - type_id: type_data ? type_data.type_id : npc.dat.type_id, - section_id: npc.section_id, - position: npc.section_position, + typeId: typeData ? typeData.typeId : npc.dat.typeId, + sectionId: npc.sectionId, + position: npc.sectionPosition, rotation: npc.rotation, - skin: type_data ? type_data.skin : npc.dat.skin, - area_id: npc.area_id, + skin: typeData ? typeData.skin : npc.dat.skin, + areaId: npc.areaId, unknown: npc.dat.unknown }; }); } -function npc_type_to_dat_data( +function npcTypeToDatData( type: NpcType -): { type_id: number, skin: number, regular: boolean } | null { +): { typeId: number, skin: number, regular: boolean } | null { switch (type) { default: throw new Error(`Unexpected type ${type.code}.`); case NpcType.Unknown: return null; - case NpcType.FemaleFat: return { type_id: 0x004, skin: 0, regular: true }; - case NpcType.FemaleMacho: return { type_id: 0x005, skin: 0, regular: true }; - case NpcType.FemaleTall: return { type_id: 0x007, skin: 0, regular: true }; - case NpcType.MaleDwarf: return { type_id: 0x00A, skin: 0, regular: true }; - case NpcType.MaleFat: return { type_id: 0x00B, skin: 0, regular: true }; - case NpcType.MaleMacho: return { type_id: 0x00C, skin: 0, regular: true }; - case NpcType.MaleOld: return { type_id: 0x00D, skin: 0, regular: true }; - case NpcType.BlueSoldier: return { type_id: 0x019, skin: 0, regular: true }; - case NpcType.RedSoldier: return { type_id: 0x01A, skin: 0, regular: true }; - case NpcType.Principal: return { type_id: 0x01B, skin: 0, regular: true }; - case NpcType.Tekker: return { type_id: 0x01C, skin: 0, regular: true }; - case NpcType.GuildLady: return { type_id: 0x01D, skin: 0, regular: true }; - case NpcType.Scientist: return { type_id: 0x01E, skin: 0, regular: true }; - case NpcType.Nurse: return { type_id: 0x01F, skin: 0, regular: true }; - case NpcType.Irene: return { type_id: 0x020, skin: 0, regular: true }; - case NpcType.ItemShop: return { type_id: 0x0F1, skin: 0, regular: true }; - case NpcType.Nurse2: return { type_id: 0x0FE, skin: 0, regular: true }; + case NpcType.FemaleFat: return { typeId: 0x004, skin: 0, regular: true }; + case NpcType.FemaleMacho: return { typeId: 0x005, skin: 0, regular: true }; + case NpcType.FemaleTall: return { typeId: 0x007, skin: 0, regular: true }; + case NpcType.MaleDwarf: return { typeId: 0x00A, skin: 0, regular: true }; + case NpcType.MaleFat: return { typeId: 0x00B, skin: 0, regular: true }; + case NpcType.MaleMacho: return { typeId: 0x00C, skin: 0, regular: true }; + case NpcType.MaleOld: return { typeId: 0x00D, skin: 0, regular: true }; + case NpcType.BlueSoldier: return { typeId: 0x019, skin: 0, regular: true }; + case NpcType.RedSoldier: return { typeId: 0x01A, skin: 0, regular: true }; + case NpcType.Principal: return { typeId: 0x01B, skin: 0, regular: true }; + case NpcType.Tekker: return { typeId: 0x01C, skin: 0, regular: true }; + case NpcType.GuildLady: return { typeId: 0x01D, skin: 0, regular: true }; + case NpcType.Scientist: return { typeId: 0x01E, skin: 0, regular: true }; + case NpcType.Nurse: return { typeId: 0x01F, skin: 0, regular: true }; + case NpcType.Irene: return { typeId: 0x020, skin: 0, regular: true }; + case NpcType.ItemShop: return { typeId: 0x0F1, 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.Hildeblue: return { type_id: 0x040, skin: 1, regular: true }; - case NpcType.RagRappy: return { type_id: 0x041, skin: 0, regular: true }; - case NpcType.AlRappy: return { type_id: 0x041, skin: 1, regular: true }; - case NpcType.Monest: return { type_id: 0x042, skin: 0, regular: true }; - case NpcType.SavageWolf: return { type_id: 0x043, skin: 0, regular: true }; - case NpcType.BarbarousWolf: return { type_id: 0x043, skin: 0, regular: false }; - case NpcType.Booma: return { type_id: 0x044, skin: 0, regular: true }; - case NpcType.Gobooma: return { type_id: 0x044, skin: 1, regular: true }; - case NpcType.Gigobooma: return { type_id: 0x044, skin: 2, regular: true }; - case NpcType.Dragon: return { type_id: 0x0C0, skin: 0, regular: true }; + case NpcType.Hildebear: return { typeId: 0x040, skin: 0, regular: true }; + case NpcType.Hildeblue: return { typeId: 0x040, skin: 1, regular: true }; + case NpcType.RagRappy: return { typeId: 0x041, skin: 0, regular: true }; + case NpcType.AlRappy: return { typeId: 0x041, skin: 1, regular: true }; + case NpcType.Monest: return { typeId: 0x042, skin: 0, regular: true }; + case NpcType.SavageWolf: return { typeId: 0x043, skin: 0, regular: true }; + case NpcType.BarbarousWolf: return { typeId: 0x043, skin: 0, regular: false }; + case NpcType.Booma: return { typeId: 0x044, skin: 0, regular: true }; + case NpcType.Gobooma: return { typeId: 0x044, skin: 1, regular: true }; + case NpcType.Gigobooma: return { typeId: 0x044, skin: 2, 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.PoisonLily: return { type_id: 0x061, skin: 0, regular: true }; - case NpcType.NarLily: return { type_id: 0x061, skin: 1, regular: true }; - case NpcType.NanoDragon: return { type_id: 0x062, skin: 0, regular: true }; - case NpcType.EvilShark: return { type_id: 0x063, skin: 0, regular: true }; - case NpcType.PalShark: return { type_id: 0x063, skin: 1, regular: true }; - case NpcType.GuilShark: return { type_id: 0x063, skin: 2, regular: true }; - case NpcType.PofuillySlime: return { type_id: 0x064, skin: 0, regular: true }; - case NpcType.PouillySlime: return { type_id: 0x064, skin: 0, regular: false }; - case NpcType.PanArms: return { type_id: 0x065, skin: 0, regular: true }; - case NpcType.DeRolLe: return { type_id: 0x0C1, skin: 0, regular: true }; + case NpcType.GrassAssassin: return { typeId: 0x060, skin: 0, regular: true }; + case NpcType.PoisonLily: return { typeId: 0x061, skin: 0, regular: true }; + case NpcType.NarLily: return { typeId: 0x061, skin: 1, regular: true }; + case NpcType.NanoDragon: return { typeId: 0x062, skin: 0, regular: true }; + case NpcType.EvilShark: return { typeId: 0x063, skin: 0, regular: true }; + case NpcType.PalShark: return { typeId: 0x063, skin: 1, regular: true }; + case NpcType.GuilShark: return { typeId: 0x063, skin: 2, regular: true }; + case NpcType.PofuillySlime: return { typeId: 0x064, skin: 0, regular: true }; + case NpcType.PouillySlime: return { typeId: 0x064, skin: 0, regular: false }; + case NpcType.PanArms: return { typeId: 0x065, 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.Gilchic: return { type_id: 0x080, skin: 1, regular: true }; - case NpcType.Garanz: return { type_id: 0x081, skin: 0, regular: true }; - case NpcType.SinowBeat: return { type_id: 0x082, skin: 0, regular: true }; - case NpcType.SinowGold: return { type_id: 0x082, skin: 0, regular: false }; - case NpcType.Canadine: return { type_id: 0x083, skin: 0, regular: true }; - case NpcType.Canane: return { type_id: 0x084, skin: 0, regular: true }; - case NpcType.Dubswitch: return { type_id: 0x085, skin: 0, regular: true }; - case NpcType.VolOpt: return { type_id: 0x0C5, skin: 0, regular: true }; + case NpcType.Dubchic: return { typeId: 0x080, skin: 0, regular: true }; + case NpcType.Gilchic: return { typeId: 0x080, skin: 1, regular: true }; + case NpcType.Garanz: return { typeId: 0x081, skin: 0, regular: true }; + case NpcType.SinowBeat: return { typeId: 0x082, skin: 0, regular: true }; + case NpcType.SinowGold: return { typeId: 0x082, skin: 0, regular: false }; + case NpcType.Canadine: return { typeId: 0x083, skin: 0, regular: true }; + case NpcType.Canane: return { typeId: 0x084, skin: 0, regular: true }; + case NpcType.Dubswitch: return { typeId: 0x085, 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.ChaosSorcerer: return { type_id: 0x0A1, skin: 0, regular: true }; - case NpcType.DarkGunner: return { type_id: 0x0A2, skin: 0, regular: true }; - case NpcType.ChaosBringer: return { type_id: 0x0A4, skin: 0, regular: true }; - case NpcType.DarkBelra: return { type_id: 0x0A5, skin: 0, regular: true }; - case NpcType.Dimenian: return { type_id: 0x0A6, skin: 0, regular: true }; - case NpcType.LaDimenian: return { type_id: 0x0A6, skin: 1, regular: true }; - case NpcType.SoDimenian: return { type_id: 0x0A6, skin: 2, regular: true }; - case NpcType.Bulclaw: return { type_id: 0x0A7, skin: 0, regular: true }; - case NpcType.Claw: return { type_id: 0x0A8, skin: 0, regular: true }; - case NpcType.DarkFalz: return { type_id: 0x0C8, skin: 0, regular: true }; + case NpcType.Delsaber: return { typeId: 0x0A0, skin: 0, regular: true }; + case NpcType.ChaosSorcerer: return { typeId: 0x0A1, skin: 0, regular: true }; + case NpcType.DarkGunner: return { typeId: 0x0A2, skin: 0, regular: true }; + case NpcType.ChaosBringer: return { typeId: 0x0A4, skin: 0, regular: true }; + case NpcType.DarkBelra: return { typeId: 0x0A5, skin: 0, regular: true }; + case NpcType.Dimenian: return { typeId: 0x0A6, skin: 0, regular: true }; + case NpcType.LaDimenian: return { typeId: 0x0A6, skin: 1, regular: true }; + case NpcType.SoDimenian: return { typeId: 0x0A6, skin: 2, regular: true }; + case NpcType.Bulclaw: return { typeId: 0x0A7, skin: 0, regular: true }; + case NpcType.Claw: return { typeId: 0x0A8, 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.Hildeblue2: return { type_id: 0x040, skin: 1, regular: true }; - case NpcType.RagRappy2: return { type_id: 0x041, skin: 0, regular: true }; - case NpcType.LoveRappy: return { type_id: 0x041, skin: 1, regular: true }; - case NpcType.Monest2: return { type_id: 0x042, skin: 0, regular: true }; - case NpcType.PoisonLily2: return { type_id: 0x061, skin: 0, regular: true }; - case NpcType.NarLily2: return { type_id: 0x061, skin: 1, regular: true }; - case NpcType.GrassAssassin2: return { type_id: 0x060, skin: 0, regular: true }; - case NpcType.Dimenian2: return { type_id: 0x0A6, skin: 0, regular: true }; - case NpcType.LaDimenian2: return { type_id: 0x0A6, skin: 1, regular: true }; - case NpcType.SoDimenian2: return { type_id: 0x0A6, skin: 2, regular: true }; - case NpcType.DarkBelra2: return { type_id: 0x0A5, skin: 0, regular: true }; - case NpcType.BarbaRay: return { type_id: 0x0CB, skin: 0, regular: true }; + case NpcType.Hildebear2: return { typeId: 0x040, skin: 0, regular: true }; + case NpcType.Hildeblue2: return { typeId: 0x040, skin: 1, regular: true }; + case NpcType.RagRappy2: return { typeId: 0x041, skin: 0, regular: true }; + case NpcType.LoveRappy: return { typeId: 0x041, skin: 1, regular: true }; + case NpcType.Monest2: return { typeId: 0x042, skin: 0, regular: true }; + case NpcType.PoisonLily2: return { typeId: 0x061, skin: 0, regular: true }; + case NpcType.NarLily2: return { typeId: 0x061, skin: 1, regular: true }; + case NpcType.GrassAssassin2: return { typeId: 0x060, skin: 0, regular: true }; + case NpcType.Dimenian2: return { typeId: 0x0A6, skin: 0, regular: true }; + case NpcType.LaDimenian2: return { typeId: 0x0A6, skin: 1, regular: true }; + case NpcType.SoDimenian2: return { typeId: 0x0A6, skin: 2, regular: true }; + case NpcType.DarkBelra2: return { typeId: 0x0A5, 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.BarbarousWolf2: return { type_id: 0x043, skin: 0, regular: false }; - case NpcType.PanArms2: return { type_id: 0x065, skin: 0, regular: true }; - case NpcType.Dubchic2: return { type_id: 0x080, skin: 0, regular: true }; - case NpcType.Gilchic2: return { type_id: 0x080, skin: 1, regular: true }; - case NpcType.Garanz2: return { type_id: 0x081, skin: 0, regular: true }; - case NpcType.Dubswitch2: return { type_id: 0x085, skin: 0, regular: true }; - case NpcType.Delsaber2: return { type_id: 0x0A0, skin: 0, regular: true }; - case NpcType.ChaosSorcerer2: return { type_id: 0x0A1, skin: 0, regular: true }; - case NpcType.GolDragon: return { type_id: 0x0CC, skin: 0, regular: true }; + case NpcType.SavageWolf2: return { typeId: 0x043, skin: 0, regular: true }; + case NpcType.BarbarousWolf2: return { typeId: 0x043, skin: 0, regular: false }; + case NpcType.PanArms2: return { typeId: 0x065, skin: 0, regular: true }; + case NpcType.Dubchic2: return { typeId: 0x080, skin: 0, regular: true }; + case NpcType.Gilchic2: return { typeId: 0x080, skin: 1, regular: true }; + case NpcType.Garanz2: return { typeId: 0x081, skin: 0, regular: true }; + case NpcType.Dubswitch2: return { typeId: 0x085, skin: 0, regular: true }; + case NpcType.Delsaber2: return { typeId: 0x0A0, skin: 0, regular: true }; + case NpcType.ChaosSorcerer2: return { typeId: 0x0A1, 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.SinowSpigell: return { type_id: 0x0D4, skin: 1, regular: true }; - case NpcType.Merillia: return { type_id: 0x0D5, skin: 0, regular: true }; - case NpcType.Meriltas: return { type_id: 0x0D5, skin: 1, regular: true }; - case NpcType.Mericarol: return { type_id: 0x0D6, skin: 0, regular: true }; - case NpcType.Mericus: return { type_id: 0x0D6, skin: 1, regular: true }; - case NpcType.Merikle: return { type_id: 0x0D6, skin: 2, regular: true }; - case NpcType.UlGibbon: return { type_id: 0x0D7, skin: 0, regular: true }; - case NpcType.ZolGibbon: return { type_id: 0x0D7, skin: 1, regular: true }; - case NpcType.Gibbles: return { type_id: 0x0D8, skin: 0, regular: true }; - case NpcType.Gee: return { type_id: 0x0D9, skin: 0, regular: true }; - case NpcType.GiGue: return { type_id: 0x0DA, skin: 0, regular: true }; - case NpcType.GalGryphon: return { type_id: 0x0C0, skin: 0, regular: true }; + case NpcType.SinowBerill: return { typeId: 0x0D4, skin: 0, regular: true }; + case NpcType.SinowSpigell: return { typeId: 0x0D4, skin: 1, regular: true }; + case NpcType.Merillia: return { typeId: 0x0D5, skin: 0, regular: true }; + case NpcType.Meriltas: return { typeId: 0x0D5, skin: 1, regular: true }; + case NpcType.Mericarol: return { typeId: 0x0D6, skin: 0, regular: true }; + case NpcType.Mericus: return { typeId: 0x0D6, skin: 1, regular: true }; + case NpcType.Merikle: return { typeId: 0x0D6, skin: 2, regular: true }; + case NpcType.UlGibbon: return { typeId: 0x0D7, skin: 0, regular: true }; + case NpcType.ZolGibbon: return { typeId: 0x0D7, skin: 1, regular: true }; + case NpcType.Gibbles: return { typeId: 0x0D8, skin: 0, regular: true }; + case NpcType.Gee: return { typeId: 0x0D9, skin: 0, regular: true }; + case NpcType.GiGue: return { typeId: 0x0DA, 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.Delbiter: return { type_id: 0x0DC, skin: 0, regular: true }; - case NpcType.Dolmolm: return { type_id: 0x0DD, skin: 0, regular: true }; - case NpcType.Dolmdarl: return { type_id: 0x0DD, skin: 1, regular: true }; - case NpcType.Morfos: return { type_id: 0x0DE, skin: 0, regular: true }; - case NpcType.Recobox: return { type_id: 0x0DF, skin: 0, regular: true }; - case NpcType.Epsilon: return { type_id: 0x0E0, skin: 0, regular: true }; - case NpcType.SinowZoa: return { type_id: 0x0E0, skin: 0, regular: true }; - case NpcType.SinowZele: return { type_id: 0x0E0, skin: 1, regular: true }; - case NpcType.IllGill: return { type_id: 0x0E1, skin: 0, regular: true }; - case NpcType.DelLily: return { type_id: 0x061, skin: 0, regular: true }; - case NpcType.OlgaFlow: return { type_id: 0x0CA, skin: 0, regular: true }; + case NpcType.Deldepth: return { typeId: 0x0DB, skin: 0, regular: true }; + case NpcType.Delbiter: return { typeId: 0x0DC, skin: 0, regular: true }; + case NpcType.Dolmolm: return { typeId: 0x0DD, skin: 0, regular: true }; + case NpcType.Dolmdarl: return { typeId: 0x0DD, skin: 1, regular: true }; + case NpcType.Morfos: return { typeId: 0x0DE, skin: 0, regular: true }; + case NpcType.Recobox: return { typeId: 0x0DF, skin: 0, regular: true }; + case NpcType.Epsilon: return { typeId: 0x0E0, skin: 0, regular: true }; + case NpcType.SinowZoa: return { typeId: 0x0E0, skin: 0, regular: true }; + case NpcType.SinowZele: return { typeId: 0x0E0, skin: 1, regular: true }; + case NpcType.IllGill: return { typeId: 0x0E1, skin: 0, regular: true }; + case NpcType.DelLily: return { typeId: 0x061, 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.DelRappy: return { type_id: 0x041, skin: 1, regular: true }; - case NpcType.Astark: return { type_id: 0x110, skin: 0, regular: true }; - case NpcType.SatelliteLizard: return { type_id: 0x111, skin: 0, regular: true }; - case NpcType.Yowie: return { type_id: 0x111, skin: 0, regular: false }; - case NpcType.MerissaA: return { type_id: 0x112, skin: 0, regular: true }; - case NpcType.MerissaAA: return { type_id: 0x112, skin: 1, regular: true }; - case NpcType.Girtablulu: return { type_id: 0x113, skin: 0, regular: true }; - case NpcType.Zu: return { type_id: 0x114, skin: 0, regular: true }; - case NpcType.Pazuzu: return { type_id: 0x114, skin: 1, regular: true }; - case NpcType.Boota: return { type_id: 0x115, skin: 0, regular: true }; - case NpcType.ZeBoota: return { type_id: 0x115, skin: 1, regular: true }; - case NpcType.BaBoota: return { type_id: 0x115, skin: 2, regular: true }; - case NpcType.Dorphon: return { type_id: 0x116, skin: 0, regular: true }; - case NpcType.DorphonEclair: return { type_id: 0x116, skin: 1, regular: true }; - case NpcType.Goran: return { type_id: 0x117, skin: 0, regular: true }; - case NpcType.PyroGoran: return { type_id: 0x117, skin: 1, regular: true }; - case NpcType.GoranDetonator: return { type_id: 0x117, skin: 2, regular: true }; - case NpcType.SaintMillion: return { type_id: 0x119, skin: 0, regular: true }; - case NpcType.Shambertin: return { type_id: 0x119, skin: 1, regular: true }; - case NpcType.Kondrieu: return { type_id: 0x119, skin: 0, regular: false }; + case NpcType.SandRappy: return { typeId: 0x041, skin: 0, regular: true }; + case NpcType.DelRappy: return { typeId: 0x041, skin: 1, regular: true }; + case NpcType.Astark: return { typeId: 0x110, skin: 0, regular: true }; + case NpcType.SatelliteLizard: return { typeId: 0x111, skin: 0, regular: true }; + case NpcType.Yowie: return { typeId: 0x111, skin: 0, regular: false }; + case NpcType.MerissaA: return { typeId: 0x112, skin: 0, regular: true }; + case NpcType.MerissaAA: return { typeId: 0x112, skin: 1, regular: true }; + case NpcType.Girtablulu: return { typeId: 0x113, skin: 0, regular: true }; + case NpcType.Zu: return { typeId: 0x114, skin: 0, regular: true }; + case NpcType.Pazuzu: return { typeId: 0x114, skin: 1, regular: true }; + case NpcType.Boota: return { typeId: 0x115, skin: 0, regular: true }; + case NpcType.ZeBoota: return { typeId: 0x115, skin: 1, regular: true }; + case NpcType.BaBoota: return { typeId: 0x115, skin: 2, regular: true }; + case NpcType.Dorphon: return { typeId: 0x116, skin: 0, regular: true }; + case NpcType.DorphonEclair: return { typeId: 0x116, skin: 1, regular: true }; + case NpcType.Goran: return { typeId: 0x117, skin: 0, regular: true }; + case NpcType.PyroGoran: return { typeId: 0x117, skin: 1, regular: true }; + case NpcType.GoranDetonator: return { typeId: 0x117, skin: 2, regular: true }; + case NpcType.SaintMillion: return { typeId: 0x119, skin: 0, regular: true }; + case NpcType.Shambertin: return { typeId: 0x119, skin: 1, regular: true }; + case NpcType.Kondrieu: return { typeId: 0x119, skin: 0, regular: false }; } } diff --git a/src/domain/ObjectType.ts b/src/domain/ObjectType.ts index 158fb93f..f59190ad 100644 --- a/src/domain/ObjectType.ts +++ b/src/domain/ObjectType.ts @@ -1,17 +1,17 @@ export class ObjectType { id: number; - pso_id?: number; + psoId?: number; 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) 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)) - throw new Error(`Expected pso_id to be null or an integer greater than or equal to 0, got ${pso_id}.`); + if (psoId != null && (!Number.isInteger(psoId) || psoId < 0)) + 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.'); this.id = id; - this.pso_id = pso_id; + this.psoId = psoId; this.name = name; } @@ -296,8 +296,8 @@ export class ObjectType { static TopOfSaintMillionEgg: ObjectType; static UnknownItem961: ObjectType; - static from_pso_id(pso_id: number): ObjectType { - switch (pso_id) { + static fromPsoId(psoId: number): ObjectType { + switch (psoId) { default: return ObjectType.Unknown; case 0: return ObjectType.PlayerSet; diff --git a/src/domain/index.ts b/src/domain/index.ts index 16effe43..194f26eb 100644 --- a/src/domain/index.ts +++ b/src/domain/index.ts @@ -2,6 +2,8 @@ import { Object3D } from 'three'; import { computed, observable } from 'mobx'; import { NpcType } from './NpcType'; import { ObjectType } from './ObjectType'; +import { DatObject, DatNpc, DatUnknown } from '../data/parsing/dat'; +import { ArrayBufferCursor } from '../data/ArrayBufferCursor'; export { NpcType } from './NpcType'; export { ObjectType } from './ObjectType'; @@ -35,85 +37,87 @@ export class Vec3 { export class Section { id: number; @observable position: Vec3; - @observable y_axis_rotation: number; + @observable yAxisRotation: number; - @computed get sin_y_axis_rotation(): number { - return Math.sin(this.y_axis_rotation); + @computed get sinYAxisRotation(): number { + return Math.sin(this.yAxisRotation); } - @computed get cos_y_axis_rotation(): number { - return Math.cos(this.y_axis_rotation); + @computed get cosYAxisRotation(): number { + return Math.cos(this.yAxisRotation); } constructor( id: number, position: Vec3, - y_axis_rotation: number + yAxisRotation: number ) { if (!Number.isInteger(id) || id < -1) 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 (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.position = position; - this.y_axis_rotation = y_axis_rotation; + this.yAxisRotation = yAxisRotation; } } export class Quest { @observable name: string; - @observable short_description: string; - @observable long_description: string; - @observable quest_no?: number; + @observable shortDescription: string; + @observable longDescription: string; + @observable questNo?: number; @observable episode: number; - @observable area_variants: AreaVariant[]; + @observable areaVariants: AreaVariant[]; @observable objects: QuestObject[]; @observable npcs: QuestNpc[]; /** * (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. */ - bin: any; + binData: ArrayBufferCursor; constructor( name: string, - short_description: string, - long_description: string, - quest_no: number | undefined, + shortDescription: string, + longDescription: string, + questNo: number | undefined, episode: number, - area_variants: AreaVariant[], + areaVariants: AreaVariant[], objects: QuestObject[], npcs: QuestNpc[], - dat: any, - bin: any + datUnknowns: DatUnknown[], + 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 (!objects || !(objects instanceof Array)) throw new Error('objs is required.'); if (!npcs || !(npcs instanceof Array)) throw new Error('npcs is required.'); this.name = name; - this.short_description = short_description; - this.long_description = long_description; - this.quest_no = quest_no; + this.shortDescription = shortDescription; + this.longDescription = longDescription; + this.questNo = questNo; this.episode = episode; - this.area_variants = area_variants; + this.areaVariants = areaVariants; this.objects = objects; this.npcs = npcs; - this.dat = dat; - this.bin = bin; + this.datUnkowns = datUnknowns; + this.binData = binData; } } export class VisibleQuestEntity { - @observable area_id: number; + @observable areaId: number; - @computed get section_id(): number { - return this.section ? this.section.id : this._section_id; + private _sectionId: number; + + @computed get sectionId(): number { + return this.section ? this.section.id : this._sectionId; } @observable section?: Section; @@ -128,36 +132,36 @@ export class VisibleQuestEntity { /** * Section-relative position */ - @computed get section_position(): Vec3 { + @computed get sectionPosition(): Vec3 { let { x, y, z } = this.position; if (this.section) { - const rel_x = x - this.section.position.x; - const rel_y = y - this.section.position.y; - const rel_z = z - this.section.position.z; - const sin = -this.section.sin_y_axis_rotation; - const cos = this.section.cos_y_axis_rotation; - const rot_x = cos * rel_x + sin * rel_z; - const rot_z = -sin * rel_x + cos * rel_z; - x = rot_x; - y = rel_y; - z = rot_z; + const relX = x - this.section.position.x; + const relY = y - this.section.position.y; + const relZ = z - this.section.position.z; + const sin = -this.section.sinYAxisRotation; + const cos = this.section.cosYAxisRotation; + const rotX = cos * relX + sin * relZ; + const rotZ = -sin * relX + cos * relZ; + x = rotX; + y = relY; + z = rotZ; } return new Vec3(x, y, z); } - set section_position(sect_pos: Vec3) { - let { x: rel_x, y: rel_y, z: rel_z } = sect_pos; + set sectionPosition(sectPos: Vec3) { + let { x: relX, y: relY, z: relZ } = sectPos; if (this.section) { - const sin = -this.section.sin_y_axis_rotation; - const cos = this.section.cos_y_axis_rotation; - const rot_x = cos * rel_x - sin * rel_z; - const rot_z = sin * rel_x + cos * rel_z; - const x = rot_x + this.section.position.x; - const y = rel_y + this.section.position.y; - const z = rot_z + this.section.position.z; + const sin = -this.section.sinYAxisRotation; + const cos = this.section.cosYAxisRotation; + const rotX = cos * relX - sin * relZ; + const rotZ = sin * relX + cos * relZ; + const x = rotX + this.section.position.x; + const y = relY + this.section.position.y; + const z = rotZ + this.section.position.z; this.position = new Vec3(x, y, z); } } @@ -165,27 +169,25 @@ export class VisibleQuestEntity { object3d?: Object3D; constructor( - area_id: number, - section_id: number, + areaId: number, + sectionId: number, position: Vec3, rotation: Vec3 ) { if (Object.getPrototypeOf(this) === Object.getPrototypeOf(VisibleQuestEntity)) throw new Error('Abstract class should not be instantiated directly.'); - if (!Number.isInteger(area_id) || area_id < 0) - throw new Error(`Expected area_id to be a non-negative integer, got ${area_id}.`); - if (!Number.isInteger(section_id) || section_id < 0) - throw new Error(`Expected section_id to be a non-negative integer, got ${section_id}.`); + if (!Number.isInteger(areaId) || areaId < 0) + throw new Error(`Expected areaId to be a non-negative integer, got ${areaId}.`); + if (!Number.isInteger(sectionId) || sectionId < 0) + throw new Error(`Expected sectionId to be a non-negative integer, got ${sectionId}.`); if (!position) throw new Error('position is required.'); if (!rotation) throw new Error('rotation is required.'); - this.area_id = area_id; - this._section_id = section_id; + this.areaId = areaId; + this._sectionId = sectionId; this.position = position; this.rotation = rotation; } - - private _section_id: number; } export class QuestObject extends VisibleQuestEntity { @@ -193,17 +195,17 @@ export class QuestObject extends VisibleQuestEntity { /** * The raw data from a DAT file. */ - dat: any; + dat: DatObject; constructor( - area_id: number, - section_id: number, + areaId: number, + sectionId: number, position: Vec3, rotation: Vec3, 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.'); @@ -217,17 +219,17 @@ export class QuestNpc extends VisibleQuestEntity { /** * The raw data from a DAT file. */ - dat: any; + dat: DatNpc; constructor( - area_id: number, - section_id: number, + areaId: number, + sectionId: number, position: Vec3, rotation: Vec3, 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.'); @@ -240,18 +242,18 @@ export class Area { id: number; name: string; 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) throw new Error(`Expected id to be a non-negative integer, got ${id}.`); 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.name = name; this.order = order; - this.area_variants = area_variants; + this.areaVariants = areaVariants; } } diff --git a/src/index.css b/src/index.css index 4f91c1d9..bbaf036e 100644 --- a/src/index.css +++ b/src/index.css @@ -3,7 +3,7 @@ body { margin: 0; } -body, #phantq-root { +body, #phantasmal-world-root { position: absolute; top: 0; bottom: 0; diff --git a/src/index.tsx b/src/index.tsx index ca0ee6ed..d65b3206 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -8,5 +8,5 @@ import "@blueprintjs/icons/lib/css/blueprint-icons.css"; ReactDOM.render( , - document.getElementById('phantq-root') + document.getElementById('phantasmal-world-root') ); diff --git a/src/rendering/Renderer.ts b/src/rendering/Renderer.ts index 855fd491..29230b21 100644 --- a/src/rendering/Renderer.ts +++ b/src/rendering/Renderer.ts @@ -17,7 +17,7 @@ import { } from 'three'; import OrbitControlsCreator from 'three-orbit-controls'; 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 { OBJECT_COLOR, OBJECT_HOVER_COLOR, @@ -115,15 +115,15 @@ export class Renderer { if (quest) { for (const obj of quest.objects) { - const array = this._objs.get(obj.area_id) || []; + const array = this._objs.get(obj.areaId) || []; array.push(obj); - this._objs.set(obj.area_id, array); + this._objs.set(obj.areaId, array); } for (const npc of quest.npcs) { - const array = this._npcs.get(npc.area_id) || []; + const array = this._npcs.get(npc.areaId) || []; 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) { const episode = this._quest.episode; 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; - get_area_collision_geometry(episode, area_id, variant_id).then(geometry => { + getAreaCollisionGeometry(episode, area_id, variant_id).then(geometry => { if (this._quest && this._area) { this.set_model(undefined); 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) { this._render_geometry = geometry; } @@ -209,7 +209,7 @@ export class Renderer { let loaded = true; for (const object of this._quest.objects) { - if (object.area_id === this._area.id) { + if (object.areaId === this._area.id) { if (object.object3d) { this._obj_geometry.add(object.object3d); } else { @@ -219,7 +219,7 @@ export class Renderer { } for (const npc of this._quest.npcs) { - if (npc.area_id === this._area.id) { + if (npc.areaId === this._area.id) { if (npc.object3d) { this._npc_geometry.add(npc.object3d); } else { diff --git a/src/rendering/entities.test.ts b/src/rendering/entities.test.ts index 440b5203..6d4b98da 100644 --- a/src/rendering/entities.test.ts +++ b/src/rendering/entities.test.ts @@ -1,51 +1,52 @@ import { - create_object_mesh, - create_npc_mesh, + createObjectMesh, + createNpcMesh, OBJECT_COLOR, NPC_COLOR } from './entities'; import { Object3D, Vector3, MeshLambertMaterial, CylinderBufferGeometry } from 'three'; 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); test('create geometry for quest objects', () => { - const object = new QuestObject(7, 13, new Vec3(17, 19, 23), new Vec3(), ObjectType.PrincipalWarp, null); - const sect_rot = 0.6; - const sect_rot_sin = Math.sin(sect_rot); - const sect_rot_cos = Math.cos(sect_rot); - const geometry = create_object_mesh( - object, [new Section(13, new Vec3(29, 31, 37), sect_rot)], cylinder); + const object = new QuestObject(7, 13, new Vec3(17, 19, 23), new Vec3(), ObjectType.PrincipalWarp, {} as DatObject); + const sectRot = 0.6; + const sectRotSin = Math.sin(sectRot); + const sectRotCos = Math.cos(sectRot); + const geometry = createObjectMesh( + object, [new Section(13, new Vec3(29, 31, 37), sectRot)], cylinder); expect(geometry).toBeInstanceOf(Object3D); expect(geometry.name).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.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); }); test('create geometry for quest NPCs', () => { - const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, null); - const sect_rot = 0.6; - const sect_rot_sin = Math.sin(sect_rot); - const sect_rot_cos = Math.cos(sect_rot); - const geometry = create_npc_mesh( - npc, [new Section(13, new Vec3(29, 31, 37), sect_rot)], cylinder); + const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc); + const sectRot = 0.6; + const sectRotSin = Math.sin(sectRot); + const sectRotCos = Math.cos(sectRot); + const geometry = createNpcMesh( + npc, [new Section(13, new Vec3(29, 31, 37), sectRot)], cylinder); expect(geometry).toBeInstanceOf(Object3D); expect(geometry.name).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.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); }); 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 geometry = create_npc_mesh( + const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc); + const geometry = createNpcMesh( npc, [new Section(13, new Vec3(0, 0, 0), 0)], cylinder); 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', () => { - const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, null); - const geometry = create_npc_mesh( + const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc); + const geometry = createNpcMesh( npc, [new Section(13, new Vec3(0, 0, 0), 0)], cylinder); npc.position = new Vec3(2, 3, 5); diff --git a/src/rendering/entities.ts b/src/rendering/entities.ts index 42b37691..7de5ddc4 100644 --- a/src/rendering/entities.ts +++ b/src/rendering/entities.ts @@ -9,15 +9,15 @@ export const NPC_COLOR = 0xFF0000; export const NPC_HOVER_COLOR = 0xFF3F5F; export const NPC_SELECTED_COLOR = 0xFF0054; -export function create_object_mesh(object: QuestObject, sections: Section[], geometry: BufferGeometry): Mesh { - return create_mesh(object, sections, geometry, OBJECT_COLOR, 'Object'); +export function createObjectMesh(object: QuestObject, sections: Section[], geometry: BufferGeometry): Mesh { + return createMesh(object, sections, geometry, OBJECT_COLOR, 'Object'); } -export function create_npc_mesh(npc: QuestNpc, sections: Section[], geometry: BufferGeometry): Mesh { - return create_mesh(npc, sections, geometry, NPC_COLOR, 'NPC'); +export function createNpcMesh(npc: QuestNpc, sections: Section[], geometry: BufferGeometry): Mesh { + return createMesh(npc, sections, geometry, NPC_COLOR, 'NPC'); } -function create_mesh( +function createMesh( entity: VisibleQuestEntity, sections: Section[], geometry: BufferGeometry, @@ -26,39 +26,39 @@ function create_mesh( ): Mesh { 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; if (section) { - const {x: sec_x, y: sec_y, z: sec_z} = section.position; - const rot_x = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z; - const rot_z = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z; - x = rot_x + sec_x; - y += sec_y; - z = rot_z + sec_z; + const {x: secX, y: secY, z: secZ} = section.position; + const rotX = section.cosYAxisRotation * x + section.sinYAxisRotation * z; + const rotZ = -section.sinYAxisRotation * x + section.cosYAxisRotation * z; + x = rotX + secX; + y += secY; + z = rotZ + secZ; } 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, new MeshLambertMaterial({ color, side: DoubleSide }) ); - object_3d.name = type; - object_3d.userData.entity = entity; + object3d.name = type; + object3d.userData.entity = entity; // TODO: dispose autorun? autorun(() => { const {x, y, z} = entity.position; - object_3d.position.set(x, y, z); + object3d.position.set(x, y, z); 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); - return object_3d; + return object3d; } diff --git a/src/rendering/models.ts b/src/rendering/models.ts index e0ef5264..856dff11 100644 --- a/src/rendering/models.ts +++ b/src/rendering/models.ts @@ -1,6 +1,6 @@ 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( geometry, new MeshLambertMaterial({ diff --git a/src/store.ts b/src/store.ts index bb420789..48e0d405 100644 --- a/src/store.ts +++ b/src/store.ts @@ -5,7 +5,7 @@ import { Area, AreaVariant, Quest, VisibleQuestEntity } from './domain'; function area(id: number, name: string, order: number, variants: number) { const area = new Area(id, name, order, []); 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; } @@ -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) 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) - 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]; - if (!area_variant) - throw new Error(`Area variant id ${variant_id} for area ${area_id} of episode ${episode} is invalid.`); + const areaVariant = area.areaVariants[variantId]; + if (!areaVariant) + 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 { - @observable current_model?: Object3D; - @observable current_quest?: Quest; - @observable current_area?: Area; - @observable selected_entity?: VisibleQuestEntity; + @observable currentModel?: Object3D; + @observable currentQuest?: Quest; + @observable currentArea?: Area; + @observable selectedEntity?: VisibleQuestEntity; } -export const application_state = new ApplicationState(); +export const applicationState = new ApplicationState(); diff --git a/src/ui/ApplicationComponent.tsx b/src/ui/ApplicationComponent.tsx index fb45b4ea..e206cec3 100644 --- a/src/ui/ApplicationComponent.tsx +++ b/src/ui/ApplicationComponent.tsx @@ -1,7 +1,7 @@ import React, { ChangeEvent, KeyboardEvent } from 'react'; import { observer } from 'mobx-react'; 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 { Area3DComponent } from './Area3DComponent'; import { EntityInfoComponent } from './EntityInfoComponent'; @@ -21,10 +21,10 @@ export class ApplicationComponent extends React.Component<{}, { }; render() { - const quest = application_state.current_quest; - const model = application_state.current_model; - const areas = quest ? Array.from(quest.area_variants).map(a => a.area) : undefined; - const area = application_state.current_area; + const quest = applicationState.currentQuest; + const model = applicationState.currentModel; + const areas = quest ? Array.from(quest.areaVariants).map(a => a.area) : undefined; + const area = applicationState.currentArea; const area_id = area ? String(area.id) : undefined; return ( @@ -73,7 +73,7 @@ export class ApplicationComponent extends React.Component<{}, { quest={quest} area={area} model={model} /> - + { const entity = this.props.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; if (entity instanceof QuestObject) { diff --git a/src/ui/QuestInfoComponent.tsx b/src/ui/QuestInfoComponent.tsx index e27f4ac8..3214fa67 100644 --- a/src/ui/QuestInfoComponent.tsx +++ b/src/ui/QuestInfoComponent.tsx @@ -64,12 +64,12 @@ export function QuestInfoComponent({ quest }: { quest?: Quest }) { - 
{quest.short_description}
+ 
{quest.shortDescription}
- 
{quest.long_description}
+ 
{quest.longDescription}
diff --git a/test/src/utils.ts b/test/src/utils.ts index a536c82f..62c3b7d2 100644 --- a/test/src/utils.ts +++ b/test/src/utils.ts @@ -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. * Uses the QST files provided with Tethealla version 0.143 by default. */ -export function walk_qst_files( - f: (path: string, file_name: string, contents: Buffer) => void, +export function walkQstFiles( + f: (path: string, fileName: string, contents: Buffer) => void, 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)); } } -export function get_qst_files(dir: string): [string, string][] { +export function getQstFiles(dir: string): [string, string][] { let files: [string, string][] = []; 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); if (stats.isDirectory()) { - files = files.concat(get_qst_files(path)); + files = files.concat(getQstFiles(path)); } else if (path.endsWith('.qst')) { // 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.