Jagex Store - Revision history

Pazaz at 02:27, 24 January 2022

2022-01-24T02:27:16Z

← Older revision		Revision as of 22:27, 23 January 2022
Line 3:		Line 3:
	The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.		The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.

	=== File Types ===		===File Types===
	dat = data		dat = data

	dat0 = sd client in pack200 format		dat0 = sd client in pack200 format (minus gzip header `1f 8b`)

	dat1 = sd client in packclass format		dat1 = sd client in packclass format

Pazaz at 02:08, 24 January 2022

2022-01-24T02:08:43Z

← Older revision		Revision as of 22:08, 23 January 2022
Line 2:		Line 2:

	The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.		The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.

			=== File Types ===
			dat = data

			dat0 = sd client in pack200 format

			dat1 = sd client in packclass format

			dat2 = data

			dat3 = hd client in pack200 format

			dat4 = hd client in packclass format

			dat5 = jogl/jaggl library in pack200 format

			dat6 = jogl/jaggl library in packclass format

			idx* = file index

	===Reading===		===Reading===

Pazaz at 02:07, 24 January 2022

2022-01-24T02:07:56Z

← Older revision		Revision as of 22:07, 23 January 2022
Line 1:		Line 1:
	This format is functionally the same as [[Old Engine/File Store\|File Store]], but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255 and dividing it by 6 (each idx255 entry is its own file). Reading works the same way (520 byte sectors) except there is now a 9-byte header ~~before~~ each entry.		This format is functionally the same as [[Old Engine/File Store\|File Store]], but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255 and dividing it by 6 (each idx255 entry is its own file). Reading works the same way (520 byte sectors) except there is now a 9-byte header included as part of each entry.

	The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.		The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.

Pazaz at 01:59, 24 January 2022

2022-01-24T01:59:14Z

← Older revision		Revision as of 21:59, 23 January 2022
Line 7:		Line 7:
	const BZIP2_HEADER = new Uint8Array([0x42, 0x5A, 0x68, 0x31]);		const BZIP2_HEADER = new Uint8Array([0x42, 0x5A, 0x68, 0x31]);

	export class ~~FileStore~~ {		// Backwards compatible with 234-402 caches (legacy)
			export class JagexStore {
	constructor(path) {		constructor(path) {
	this.~~dat2~~ = ~~new RandomAccessFile(`${path}/main_file_cache.dat2`,~~ false);		this.legacy = false;
	~~this.idx255 = new RandomAccessFile(`${path}/main_file_cache.idx255`, false)~~;

	let idxCount = this.idx255.length / 6;		if (fs.existsSync(`${path}/main_file_cache.dat`)) {
	for (let i = 0; i < idxCount; ++i) {		this.legacy = true;
	this[`idx${i}`] = new RandomAccessFile(`${path}/main_file_cache.idx${i}`, false);		}

			if (!this.legacy) {
			this.dat2 = new RandomAccessFile(`${path}/main_file_cache.dat2`, false);
			this.idx255 = new RandomAccessFile(`${path}/main_file_cache.idx255`, false);

			let idxCount = this.idx255.length / 6;
			for (let i = 0; i < idxCount; ++i) {
			this[`idx${i}`] = new RandomAccessFile(`${path}/main_file_cache.idx${i}`, false);
			}

			this.index_offset = 0;
			} else {
			this.dat2 = new RandomAccessFile(`${path}/main_file_cache.dat`, false);

			for (let i = 0; i < 5; ++i) {
			this[`idx${i}`] = new RandomAccessFile(`${path}/main_file_cache.idx${i}`, false);
			}

			this.index_offset = 1;
	}		}
	}		}

	read(index, entry, extract = false) {		read(index, entry, extract = false) {
			if (!this[`idx${index}`]) {
			return null;
			}

	let buffer = this[`idx${index}`].front().seek(entry * 6).read(6);		let buffer = this[`idx${index}`].front().seek(entry * 6).read(6);
	if (!buffer.available) {		if (!buffer.available) {
Line 25:		Line 48:

	let length = buffer.readSWord();		let length = buffer.readSWord();
	if (length > this.dat2.length) {		if (length === 0 \|\| length > this.dat2.length) {
	return null;		return null;
	}		}
Line 47:		Line 70:
	let currentFile = sector.readWord();		let currentFile = sector.readWord();
	if (currentFile !== entry) {		if (currentFile !== entry) {
	~~console.error('currentFile !== entry');~~
	return null;		return null;
	}		}
Line 53:		Line 75:
	let currentPart = sector.readWord();		let currentPart = sector.readWord();
	if (currentPart !== part) {		if (currentPart !== part) {
	~~console.error('currentPart !== part');~~
	return null;		return null;
	}		}
Line 59:		Line 80:
	nextSector = sector.readSWord();		nextSector = sector.readSWord();
	if (nextSector * 520 > this.dat2.length) {		if (nextSector * 520 > this.dat2.length) {
	~~console.error('nextSector * 520 > this.dat2.length');~~
	return null;		return null;
	}		}

	let currentIndex = sector.readByte();		let currentIndex = sector.readByte();
	if (currentIndex !== index) {		if (currentIndex - this.index_offset !== index) {
	~~console.error('currentIndex !== index');~~
	return null;		return null;
	}		}
Line 74:		Line 93:
	data.front();		data.front();

	let file = {		let file = { compression: 0, size: 0, decompressedSize: 0, data };
	compression: data.readByte(),
	size: data.readDWord(),		if (!this.legacy) {
	decompressedSize: data.readDWord(),		file.compression = data.readByte(),
	data: data.read()		file.size = data.readDWord(),
	};		file.decompressedSize = data.readDWord(),
			file.data = data.read()
			} else {
			file.compression = index === 0 ? 1 : 2;
			file.size = file.data.length;
			}

	if (extract) {		if (extract) {
	if (file.compression === 1) {		if (file.compression === 1 && this.legacy) {
	file~~.data~~ = file.data.~~prepend(BZIP2_HEADER~~);		file = new FileArchive(file.data);
	file.data = bz2.decompress(file.data.raw);		} else if (file.compression === 1) {
			file.data = bz2.decompress(file.data.prepend(BZIP2_HEADER).raw);
	} else if (file.compression === 2) {		} else if (file.compression === 2) {
	file.data = new Uint8Array(zlib.gunzipSync(file.data.raw));		file.data = new Uint8Array(zlib.gunzipSync(file.data.raw));
			if (this.legacy) {
			file.decompressedSize = file.data.length;
			}
	}		}
	}		}

Pazaz at 01:37, 24 January 2022

2022-01-24T01:37:56Z

← Older revision		Revision as of 21:37, 23 January 2022
Line 1:		Line 1:
	This format is functionally the same as File Store, but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255 and dividing it by 6 (each idx255 entry is its own file). Reading works the same way (520 byte sectors) except there is now a 9-byte header before each entry.		This format is functionally the same as [[Old Engine/File Store\|File Store]], but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255 and dividing it by 6 (each idx255 entry is its own file). Reading works the same way (520 byte sectors) except there is now a 9-byte header before each entry.

	The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.		The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.

	=== Reading ===		===Reading===
	<syntaxhighlight lang="js">		<syntaxhighlight lang="js">
	const BZIP2_HEADER = new Uint8Array([0x42, 0x5A, 0x68, 0x31]);		const BZIP2_HEADER = new Uint8Array([0x42, 0x5A, 0x68, 0x31]);

Pazaz: Created page with "This format is functionally the same as File Store, but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255..."

2022-01-24T01:37:32Z

Created page with "This format is functionally the same as File Store, but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255..."

New page

This format is functionally the same as File Store, but uses more indices to separate file types. You can get the number of indices to read from by taking the length of idx255 and dividing it by 6 (each idx255 entry is its own file). Reading works the same way (520 byte sectors) except there is now a 9-byte header before each entry.

The 9-byte header has the compression type (1 byte), file size (4 bytes), and uncompressed size (4 bytes). A compression type of 1 uses BZip2 and you have to prepend the magic number. A compression type of 2 uses gzip.

=== Reading ===
<syntaxhighlight lang="js">
const BZIP2_HEADER = new Uint8Array([0x42, 0x5A, 0x68, 0x31]);

export class FileStore {
constructor(path) {
this.dat2 = new RandomAccessFile(`${path}/main_file_cache.dat2`, false);
this.idx255 = new RandomAccessFile(`${path}/main_file_cache.idx255`, false);

let idxCount = this.idx255.length / 6;
for (let i = 0; i < idxCount; ++i) {
this[`idx${i}`] = new RandomAccessFile(`${path}/main_file_cache.idx${i}`, false);
}
}

read(index, entry, extract = false) {
let buffer = this[`idx${index}`].front().seek(entry * 6).read(6);
if (!buffer.available) {
return null;
}

let length = buffer.readSWord();
if (length > this.dat2.length) {
return null;
}

let data = new ByteBuffer(new Uint8Array(length), false);
let nextSector = buffer.readSWord();

if (nextSector * 520 > this.dat2.length) {
return null;
}

let part = 0;
while (data.available && nextSector !== 0) {
let sector = this.dat2.front().seek(nextSector * 520).read(520);

let bytes = data.available;
if (bytes > 512) {
bytes = 512;
}

let currentFile = sector.readWord();
if (currentFile !== entry) {
console.error('currentFile !== entry');
return null;
}

let currentPart = sector.readWord();
if (currentPart !== part) {
console.error('currentPart !== part');
return null;
}

nextSector = sector.readSWord();
if (nextSector * 520 > this.dat2.length) {
console.error('nextSector * 520 > this.dat2.length');
return null;
}

let currentIndex = sector.readByte();
if (currentIndex !== index) {
console.error('currentIndex !== index');
return null;
}

data.write(sector.read(bytes));
part++;
}
data.front();

let file = {
compression: data.readByte(),
size: data.readDWord(),
decompressedSize: data.readDWord(),
data: data.read()
};

if (extract) {
if (file.compression === 1) {
file.data = file.data.prepend(BZIP2_HEADER);
file.data = bz2.decompress(file.data.raw);
} else if (file.compression === 2) {
file.data = new Uint8Array(zlib.gunzipSync(file.data.raw));
}
}

return file;
}
}
</syntaxhighlight>