✨ support BufferStream

example/ping_mc_server.ts

@@ -1,6 +1,5 @@
 import { createConnection, Socket } from "net";
-import { StructBuilder, BaseTypes, write, Package, read } from "../src/";
-import { format } from "util";
+import { StructBuilder, BaseTypes, Package, read, BufferStream } from "../dist";
 
 const enum State {
     HANDSHAKE = 0,
@@ -33,46 +32,50 @@ namespace Packages {
 type casedPacket = { packetId: number; data: Buffer };
 
 function createCasedPacketBuffer(packetId: number, data: Buffer): Buffer {
-    const payloadBuffer = Buffer.concat([write(BaseTypes.VarInt32, packetId), data]);
-    return Buffer.concat([write(BaseTypes.VarInt32, payloadBuffer.length), payloadBuffer]);
+    const payloadBS = new BufferStream();
+    payloadBS.write(BaseTypes.VarInt32, packetId);
+    payloadBS.write(data);
+
+    const bs = new BufferStream();
+    bs.write(BaseTypes.VarInt32, payloadBS.length);
+    bs.write(payloadBS.buffer);
+
+    return bs.buffer;
 }
 
-function readCasedPacket(buffer: Buffer): [casedPacket | undefined, number] {
-    if (buffer.length === 0) return [undefined, 0];
-    const [length, lengthOffset] = read(BaseTypes.VarInt32, buffer, 0);
-    if (length > buffer.length) {
-        return [undefined, 0];
-    }
-    const [packetId, idOffset] = read(BaseTypes.VarInt32, buffer, lengthOffset);
-    const offset = lengthOffset + idOffset;
-    const data = buffer.subarray(offset, offset + length);
-    return [{ packetId, data }, offset + length];
+function readCasedPacket(bs: BufferStream): casedPacket | void {
+    if (bs.length === 0) return;
+    const [length, offset] = read(BaseTypes.VarInt32, bs.buffer, 0);
+    if (length > bs.length) return;
+    bs.read(offset);
+
+    const payload = bs.read(length);
+    const payloadBS = new BufferStream(payload);
+
+    const packetId = payloadBS.read(BaseTypes.VarInt32);
+    const data = payloadBS.read(payloadBS.length);
+    return { packetId, data };
 }
 
 function sendMcPacket(client: Socket, packetId: number, packet: Package<any>) {
     client.write(createCasedPacketBuffer(packetId, packet.buffer));
 }
 
-const host = "2b2t.xin";
+const host = "mc.xasmc.xyz";
 const port = 25565;
 let state: State = State.HANDSHAKE;
 
 const client = createConnection({ host, port }, () => {
     console.log("已连接到服务器");
 
-    let tempBuffer = Buffer.alloc(0);
+    const bs = new BufferStream();
 
     client.on("data", (data) => {
-        console.log("awa");
-        console.log(data);
-        tempBuffer = Buffer.concat([tempBuffer, data]);
-
+        bs.write(data);
         while (true) {
-            const [casedPacket, casedPacketOffset] = readCasedPacket(tempBuffer);
+            const casedPacket = readCasedPacket(bs);
             if (!casedPacket) break;
 
-            tempBuffer = tempBuffer.subarray(casedPacketOffset);
-
             // 处理数据包
             const { packetId, data: packetData } = casedPacket;
             if (state == State.HANDSHAKE) {

src/bufferStream.ts

@@ -0,0 +1,40 @@
+import { DataType } from "./dataType";
+
+export class BufferStream {
+    private innerBuffer: Buffer;
+    get buffer() {
+        return this.innerBuffer;
+    }
+
+    get length() {
+        return this.innerBuffer.length;
+    }
+
+    constructor(buffer: Buffer = Buffer.alloc(0)) {
+        this.innerBuffer = buffer;
+    }
+
+    read<T>(type: DataType<T>): T;
+    read(length: number): Buffer;
+    read<T>(type_or_length: DataType<T> | number): T | Buffer {
+        if (typeof type_or_length === "number") {
+            const value = this.innerBuffer.subarray(0, type_or_length);
+            this.innerBuffer = this.innerBuffer.subarray(type_or_length);
+            return value;
+        } else {
+            const [value, offset] = type_or_length.read(this.innerBuffer, 0);
+            this.innerBuffer = this.innerBuffer.subarray(offset);
+            return value;
+        }
+    }
+
+    write<T>(type: DataType<T>, value: T): void;
+    write(buffer: Buffer): void;
+    write<T>(type_or_buffer: DataType<T> | Buffer, value?: T) {
+        if (type_or_buffer instanceof Buffer) {
+            this.innerBuffer = Buffer.concat([this.innerBuffer, type_or_buffer]);
+        } else {
+            this.innerBuffer = Buffer.concat([this.innerBuffer, type_or_buffer.write(value as T)]);
+        }
+    }
+}

src/index.ts

@@ -1,6 +1,7 @@
 export { DataType } from "./dataType";
 export { BaseTypes } from "./baseTypes";
 export { defineType, defineTypeGenerator } from "./defineType";
+export { BufferStream } from "./bufferStream";
 export { read, write } from "./utils";
 export { Struct } from "./struct/struct";
 export { StructBuilder } from "./struct/structBuilder";