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

Reformatted most of the code to comply to TypeScript conventions.

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

2
public/index.html
View File

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

66
src/actions.ts
View File

@ -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;
}

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

@ -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]);
}
}
});

207
src/data/ArrayBufferCursor.ts
View File

@ -14,6 +14,8 @@ const UTF_16LE_ENCODER = new TextEncoder('utf-16le');
* Uses an ArrayBuffer internally. This buffer is reallocated if and only if a write beyond the current capacity happens.
*/
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);
}
}
}

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

@ -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<number | null> = new Array(HASH_SIZE).fill(null);
masked_offset_to_prev: Array<number | null> = new Array(MAX_WINDOW).fill(null);
hashToOffset: Array<number | null> = new Array(HASH_SIZE).fill(null);
maskedOffsetToPrev: Array<number | null> = 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;
}
}

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

@ -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));
}
}

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

@ -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;
}
}

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

@ -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<string, Promise<Section[]>> = new Map();
const render_geometry_cache: Map<string, Promise<Object3D>> = new Map();
const collision_geometry_cache: Map<string, Promise<Object3D>> = new Map();
const sectionsCache: Map<string, Promise<Section[]>> = new Map();
const renderGeometryCache: Map<string, Promise<Object3D>> = new Map();
const collisionGeometryCache: Map<string, Promise<Object3D>> = new Map();
export function get_area_sections(
export function getAreaSections(
episode: number,
area_id: number,
area_variant: number
areaId: number,
areaVariant: number
): Promise<Section[]> {
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<Object3D> {
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<Object3D> {
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<Section[]>((resolve, reject) => {
promise.then(({sections}) => resolve(sections)).catch(reject);
});
const object_3d = new Promise<Object3D>((resolve, reject) => {
promise.then(({object_3d}) => resolve(object_3d)).catch(reject);
const object3d = new Promise<Object3D>((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;
}

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

@ -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<ArrayBuffer> {
return get_area_asset(episode, area_id, area_version, 'render');
return getAreaAsset(episode, areaId, areaVersion, 'render');
}
export function get_area_collision_data(
export function getAreaCollisionData(
episode: number,
area_id: number,
area_version: number
areaId: number,
areaVersion: number
): Promise<ArrayBuffer> {
return get_area_asset(episode, area_id, area_version, 'collision');
return getAreaAsset(episode, areaId, areaVersion, 'collision');
}
export async function get_npc_data(npc_type: NpcType): Promise<{ url: string, data: ArrayBuffer }> {
export async function getNpcData(npcType: NpcType): Promise<{ url: string, data: ArrayBuffer }> {
try {
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<string, Promise<ArrayBuffer>> = new Map();
const bufferCache: Map<string, Promise<ArrayBuffer>> = new Map();
function get_asset(url: string): Promise<ArrayBuffer> {
const promise = buffer_cache.get(url);
function getAsset(url: string): Promise<ArrayBuffer> {
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<ArrayBuffer> {
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`;
}
}

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

@ -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<string, Promise<BufferGeometry>> = new Map();
const object_cache: Map<string, Promise<BufferGeometry>> = new Map();
const npcCache: Map<string, Promise<BufferGeometry>> = new Map();
const objectCache: Map<string, Promise<BufferGeometry>> = new Map();
export function get_npc_geometry(npc_type: NpcType): Promise<BufferGeometry> {
let geometry = npc_cache.get(String(npc_type.id));
export function getNpcGeometry(npcType: NpcType): Promise<BufferGeometry> {
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<BufferGeometry> {
let geometry = object_cache.get(String(object_type.id));
export function getObjectGeometry(objectType: ObjectType): Promise<BufferGeometry> {
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;
}
}

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

@ -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;
}

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

@ -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'],

50
src/data/parsing/dat.test.ts
View File

@ -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;
}

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

@ -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;
}

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

@ -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
};
}

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

@ -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);
}
}

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

@ -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;

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

@ -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;
}

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

@ -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;
}

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

@ -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<number>;
chunkNos: Set<number>;
}
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<string, number>): QstContainedFile[] {
function parseFiles(cursor: ArrayBufferCursor, expectedSizes: Map<string, number>): 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<string, QstContainedFile>();
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<string, numb
}
const data = cursor.take(size);
const chunk_position = chunk_no * 1024;
file.data.size = Math.max(chunk_position + size, file.data.size);
file.data.seek_start(chunk_position).write_cursor(data);
const chunkPosition = chunkNo * 1024;
file.data.size = Math.max(chunkPosition + size, file.data.size);
file.data.seekStart(chunkPosition).writeCursor(data);
// Skip the padding and the trailer.
cursor.seek(1032 - data.size);
if (cursor.position !== start_position + 1056) {
throw new Error(`Read ${cursor.position - start_position} file chunk message bytes instead of expected 1056.`);
if (cursor.position !== startPosition + 1056) {
throw new Error(`Read ${cursor.position - startPosition} file chunk message bytes instead of expected 1056.`);
}
}
for (const file of files.values()) {
// Clean up file properties.
file.data.seek_start(0);
file.chunk_nos = new Set(Array.from(file.chunk_nos.values()).sort((a, b) => 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<string, numb
return Array.from(files.values());
}
function write_file_headers(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void {
function writeFileHeaders(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void {
for (const file of files) {
cursor.write_u16(88); // Header size.
cursor.write_u16(0x44); // Magic number.
cursor.write_u16(file.quest_no || 0);
cursor.writeU16(88); // Header size.
cursor.writeU16(0x44); // Magic number.
cursor.writeU16(file.questNo || 0);
for (let i = 0; i < 38; ++i) {
cursor.write_u8(0);
cursor.writeU8(0);
}
cursor.write_string_ascii(file.name, 16);
cursor.write_u32(file.data.size);
cursor.writeStringAscii(file.name, 16);
cursor.writeU32(file.data.size);
let file_name_2: string;
let fileName2: string;
if (file.name_2 == null) {
if (file.name2 == null) {
// Not sure this makes sense.
const dot_pos = file.name.lastIndexOf('.');
file_name_2 = dot_pos === -1
const dotPos = file.name.lastIndexOf('.');
fileName2 = dotPos === -1
? file.name + '_j'
: file.name.slice(0, dot_pos) + '_j' + file.name.slice(dot_pos);
: file.name.slice(0, dotPos) + '_j' + file.name.slice(dotPos);
} else {
file_name_2 = file.name_2;
fileName2 = file.name2;
}
cursor.write_string_ascii(file_name_2, 24);
cursor.writeStringAscii(fileName2, 24);
}
}
function write_file_chunks(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void {
function writeFileChunks(cursor: ArrayBufferCursor, files: SimpleQstContainedFile[]): void {
// Files are interleaved in 1056 byte chunks.
// Each chunk has a 24 byte header, 1024 byte data segment and an 8 byte trailer.
files = files.slice();
const chunk_nos = new Array(files.length).fill(0);
const chunkNos = new Array(files.length).fill(0);
while (files.length) {
let i = 0;
while (i < files.length) {
if (!write_file_chunk(cursor, files[i].data, chunk_nos[i]++, files[i].name)) {
if (!writeFileChunk(cursor, files[i].data, chunkNos[i]++, files[i].name)) {
// Remove if there are no more chunks to write.
files.splice(i, 1);
chunk_nos.splice(i, 1);
chunkNos.splice(i, 1);
} else {
++i;
}
@ -250,27 +257,27 @@ function write_file_chunks(cursor: ArrayBufferCursor, files: SimpleQstContainedF
/**
* @returns true if there are bytes left to write in data, false otherwise.
*/
function write_file_chunk(
function writeFileChunk(
cursor: ArrayBufferCursor,
data: ArrayBufferCursor,
chunk_no: number,
chunkNo: number,
name: string
): boolean {
cursor.write_u8_array([28, 4, 19, 0]);
cursor.write_u8(chunk_no);
cursor.write_u8_array([0, 0, 0]);
cursor.write_string_ascii(name, 16);
cursor.writeU8Array([28, 4, 19, 0]);
cursor.writeU8(chunkNo);
cursor.writeU8Array([0, 0, 0]);
cursor.writeStringAscii(name, 16);
const size = Math.min(1024, data.bytes_left);
cursor.write_cursor(data.take(size));
const size = Math.min(1024, data.bytesLeft);
cursor.writeCursor(data.take(size));
// Padding.
for (let i = size; i < 1024; ++i) {
cursor.write_u8(0);
cursor.writeU8(0);
}
cursor.write_u32(size);
cursor.write_u32(0);
cursor.writeU32(size);
cursor.writeU32(0);
return !!data.bytes_left;
return !!data.bytesLeft;
}

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

@ -1,67 +1,66 @@
import * as fs from 'fs';
import { ArrayBufferCursor } from '../ArrayBufferCursor';
import * as prs from '../compression/prs';
import { parse_quest, write_quest_qst } from './quest';
import { parseQuest, writeQuestQst } from './quest';
import { ObjectType, Quest } from '../../domain';
import { walk_qst_files } from '../../../test/src/utils';
test('parse Towards the Future', () => {
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]);
}

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

@ -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 };
}
}

14
src/domain/ObjectType.ts
View File

@ -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;

150
src/domain/index.ts
View File

@ -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;
}
}

2
src/index.css
View File

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

2
src/index.tsx
View File

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

20
src/rendering/Renderer.ts
View File

@ -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 {

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

@ -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);

38
src/rendering/entities.ts
View File

@ -9,15 +9,15 @@ export const NPC_COLOR = 0xFF0000;
export const NPC_HOVER_COLOR = 0xFF3F5F;
export const NPC_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;
}

2
src/rendering/models.ts
View File

@ -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({

28
src/store.ts
View File

@ -5,7 +5,7 @@ import { Area, AreaVariant, Quest, VisibleQuestEntity } from './domain';
function area(id: number, name: string, order: number, variants: number) {
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();

12
src/ui/ApplicationComponent.tsx
View File

@ -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} />
<EntityInfoComponent entity={application_state.selected_entity} />
<EntityInfoComponent entity={applicationState.selectedEntity} />
</div>
<Dialog
title="Save as..."

2
src/ui/EntityInfoComponent.tsx
View File

@ -44,7 +44,7 @@ export class EntityInfoComponent extends React.Component<Props, any> {
const entity = this.props.entity;
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) {

4
src/ui/QuestInfoComponent.tsx
View File

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

10
test/src/utils.ts
View File

@ -5,16 +5,16 @@ import * as fs from 'fs';
* F is called with the path to the file, the file name and the content of the file.
* 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.