feat: implement payload compression support with PKLib integration

- Add compression flag detection and manipulation methods to ServerMessageHeader
  - isPayloadCompressed(): Check if payload compression flag (0x02) is set
  - setPayloadCompression(): Enable/disable payload compression flag

- Extend ServerPacket with compression support methods
  - isPayloadCompressed(): Wrapper for header compression check
  - setPayloadCompression(): Wrapper for header compression control

- Integrate PKLib decompression in transaction processing
  - Add explode() function import from pklib-ts package
  - Implement decompressMessage() function with proper error handling
  - Update receiveTransactionsData() to handle compressed payloads
  - Add 64KB output buffer with overflow protection

- Add pklib-ts package as local dependency for compression algorithms
  - Link packages/pklib-ts for PKWare-compatible compression/decompression
  - Includes TypeScript implementation of explode/implode algorithms

- Add MC_CRC_PRE_RACE_DATA message ID (455/0x1C7) to message catalog

- Update dependencies and lock files for new compression functionality

This enables the server to handle compressed game packets, improving
bandwidth efficiency for large payloads while maintaining compatibility
with the original Motor City Online protocol.

Author: drazisil

package.json

@@ -46,6 +46,7 @@
         "fastify": "^5.4.0",
         "moment": "^2.30.1",
         "pino-debug": "^3.0.0",
+        "pklib-ts": "link:packages/pklib-ts",
         "rusty-motors-chat": "link:src/chat",
         "rusty-motors-cli": "link:packages/cli",
         "rusty-motors-database": "link:packages/database",

packages/shared-packets/src/ServerMessageHeader.ts

@@ -73,6 +73,10 @@ export class ServerMessageHeader
 		return (this.flags & 0x08) != 0;
 	}
 
+	isPayloadCompressed(): boolean {
+		return (this.flags & 0x02) != 0; 
+	}
+
 	setPayloadEncryption(encrypted: boolean): ServerMessageHeader {
 		if (encrypted) {
 			this.flags |= 0x08;
@@ -82,6 +86,15 @@ export class ServerMessageHeader
 		return this;
 	}
 
+	setPayloadCompression(encrypted: boolean): ServerMessageHeader {
+		if (encrypted) {
+			this.flags |= 0x02;
+		} else {
+			this.flags &= ~0x02;
+		}
+		return this;
+	}
+
 	override toString(): string {
 		return `ServerMessageHeader {length: ${this.length}, signature: ${this.signature}, sequence: ${this.sequence}, flags: ${this.flags}}`;
 	}

packages/shared-packets/src/ServerPacket.ts

@@ -72,6 +72,11 @@ export class ServerPacket extends BasePacket implements SerializableMessage {
 		return this;
 	}
 
+	setPayloadCompression(compressed: boolean): ServerPacket {
+		this.header.setPayloadCompression(compressed);
+		return this;
+	}
+
 	getMessageId(): number {
 		return this.data.getMessageId();
 	}
@@ -93,6 +98,10 @@ export class ServerPacket extends BasePacket implements SerializableMessage {
 		return this.header.isPayloadEncrypted();
 	}
 
+	isPayloadCompressed(): boolean {
+		return this.header.isPayloadCompressed();
+	}
+
 	isValidSignature(): boolean {
 		return this.header.isValidSignature();
 	}

packages/transactions/src/_MSG_STRING.ts

@@ -31,6 +31,7 @@ export function _MSG_STRING(messageID: number): string {
 		{ id: 391, name: "MC_CLUB_GET_INVITATIONS" }, // 0x187
 		{ id: 438, name: "MC_CLIENT_CONNECT_MSG" }, // 0x1b6
 		{ id: 440, name: "MC_TRACKING_MSG" },
+		{ id: 455, name: "MC_CRC_PRE_RACE_DATA" }, 
 	];
 	const result = messageIds.find((id) => id.id === messageID);
 

packages/transactions/src/compression.ts

@@ -0,0 +1,78 @@
+// mcos is a game server, written from scratch, for an old game
+// Copyright (C) <2017>  <Drazi Crendraven>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+type read_buf_func = (buf: Buffer, size: number, param: any) => number // uint
+
+type write_buf_func = (buf: Buffer, size: number, param: any) => void
+
+enum LUTSizesEnum {
+    DIST_SIZES=0x40,
+    CH_BITS_ASC_SIZE=0x100,
+    LENS_SIZES=0x10,
+};
+
+enum CommonSizes {
+    OUT_BUFF_SIZE = 0x802,
+    BUFF_SIZE=0x2204,
+};
+
+enum ExplodeSizesEnum {
+    IN_BUFF_SIZE=0x800,
+    CODES_SIZE=0x100,
+    OFFSS_SIZE=0x100,
+    OFFSS_SIZE1=0x80,
+};
+
+enum {
+    EXP_BUFFER_SIZE = sizeof(TDcmpStruct), // Size of decompression structure
+                                           // Defined as 12596 in pkware headers
+};
+
+class TDcmpStruct {
+    private offs0000 // ulong  0000
+    private ctype // ulong 0004: Compression type (CMP_BINARY or CMP_ASCII)
+    private outputPos // ulong 0008: Position in output buffer
+    private dsize_bits // ulong 000C: Dict size (4, 5, 6 for 0x400, 0x800, 0x1000)
+    private dsize_mask // ulong 0010: Dict size bitmask (0x0F, 0x1F, 0x3F for 0x400, 0x800, 0x1000)
+    private bit_buff // ulong 0014: 16-bit buffer for processing input data
+    private extra_bits // ulong 0018: Number of extra (above 8) bits in bit buffer
+    private extra_bits // uint 001C: Position in in_buff
+    private in_bytes // ulong 0020: Number of bytes in input buffer
+    private param // void* 0024: Custom parameter
+    private read_buf: read_buf_func // read_buf_func // Pointer to function that reads data from the input stream
+    private write_buf: write_buf_func // write_buf_func // Pointer to function that writes data to the output stream
+    private out_buff // uchar[BUFF_SIZE] 0030: Output circle buffer.
+                                            //       0x0000 - 0x0FFF: Previous uncompressed data, kept for repetitions
+                                            //       0x1000 - 0x1FFF: Currently decompressed data
+                                            //       0x2000 - 0x2203: Reserve space for the longest possible repetition
+    private in_buff // uchar[IN_BUFF_SIZE] 2234: Buffer for data to be decompressed
+    private DistPosCodes // uchar[CODES_SIZE] 2A34: Table of distance position codes
+    private LengthCodes // uchar[CODES_SIZE] 2B34: Table of length codes
+    private offs2C34 // uchar[OFFSS_SIZE] 2C34: Buffer for
+    private offs2D34 // uchar[OFFSS_SIZE] 2D34: Buffer for
+    private offs2E34 // uchar[OFFSS_SIZE1] 2E34: Buffer for
+    private offs2EB4 // uchar[OFFSS_SIZE] 2EB4: Buffer fo
+    private ChBitsAsc // uchar[CH_BITS_ASC_SIZE] 2FB4: Buffer for
+    private DistBits // uchar[DIST_SIZES] 30B4: Numbers of bytes to skip copied block length
+    private LenBits // uchar[LENS_SIZES] 30F4: Numbers of bits for skip copied block length
+    private ExLenBits // uchar[LENS_SIZES] 3104: Number of valid bits for copied block
+    private LenBase // ushort[LENS_SIZES] 3114: Buffer fo
+
+}
+
+export function explode(read_buf: read_buf_func, write_buf: write_buf_func, work_buf: Buffer, param: any) {}
+
+export function implode() {}

packages/transactions/src/internal.ts

@@ -34,6 +34,7 @@ import {
 	type BufferSerializer,
 } from "rusty-motors-shared-packets";
 import { _MSG_STRING } from "./_MSG_STRING.js";
+import { explode } from "pklib-ts"
 
 
 
@@ -148,11 +149,24 @@ export async function receiveTransactionsData({
 		decryptedMessage = inboundMessage;
 	}
 
+	let decompressedMessage: ServerPacket;
+
+	if (decryptedMessage.isPayloadCompressed()) {
+
+		decompressedMessage = decompressMessage(
+			decryptedMessage,
+			connectionId,
+		);
+	} else {
+		log.debug(`[${connectionId}] Message is not encrypted`);
+		decompressedMessage = decryptedMessage;
+	}
+
 	// Process the message
 
 	const response = await processInput({
 		connectionId,
-		inboundMessage: decryptedMessage,
+		inboundMessage: decompressedMessage,
 		log,
 	});
 
@@ -299,6 +313,59 @@ function encryptOutboundMessage(
 	}
 }
 
+function decompressMessage(
+	compressedMessage: ServerPacket,
+	connectionId: string,
+	log = getServerLogger("transactionServer.decompressInboundMessage"),
+): ServerPacket {
+	log.debug(`Decompressing message with initial messageId of ${compressedMessage.getMessageId()}`)
+
+	const uncompressedLen = compressedMessage.data.getMessageId()
+
+	    const outputBuffer = new Uint8Array(64 * 1024); // 64KB buffer
+    let outputPos = 0;
+
+	const compressedPayload = compressedMessage.getDataBuffer().subarray(2)
+    
+    const writeCallback = (data: Uint8Array, bytesToWrite: number): number => {
+      if (outputPos + bytesToWrite > outputBuffer.length) {
+        throw new Error('Output buffer overflow');
+      }
+      outputBuffer.set(data.slice(0, bytesToWrite), outputPos);
+      outputPos += bytesToWrite;
+      return bytesToWrite;
+    };
+    
+    let inputPos = 0;
+    const readCallback = (buffer: Uint8Array, bytesToRead: number): number => {
+      const available = Math.min(bytesToRead, compressedPayload.length - inputPos);
+      if (available <= 0) return 0;
+      
+      buffer.set(compressedPayload.subarray(inputPos, inputPos + available));
+      inputPos += available;
+      return available;
+    };
+    
+    const result = explode(readCallback, writeCallback);
+    
+    if (result.success) {
+      const outputData = Buffer.from(outputBuffer.slice(0, outputPos));
+
+	  log.debug(`DecompressedPayload: ${outputData.toString("hex")}`)
+      
+        // Output raw binary data to stdout
+		const uncompressedMessage = ServerPacket.copy(compressedMessage, outputData);
+		uncompressedMessage.setPayloadCompression(false)
+		return uncompressedMessage
+	} else {
+		log.error(`returned data len: ${result.decompressedData?.length}`)
+
+		throw new Error(result.errorCode.valueOf().toString() ?? 'Oh no!')
+	}
+
+
+}
+
 /**
  * @param {Buffer} buffer
  * @param {Buffer} buffer2