@hopple/netcode 0.1.0 → 0.1.1-ci.1

package/README.md

@@ -25,9 +25,11 @@ whoever comes later. A game is welcome to write any part of this its own way.
 
 ## Bytes
 
-A match's messages are bytes. `ByteWriter` and `ByteReader` write numbers and
-strings, and read them back exactly: integers as varints (a byte under 128),
-floats as their eight bytes, strings as UTF-8.
+A match's messages are bytes. `ByteWriter` and `ByteReader`, from
+[`@hopple/bytes`](https://www.npmjs.com/package/@hopple/bytes) and exported
+here as well, write numbers, strings and packed bits, and read them back
+exactly: integers as varints (a byte under 128), floats as their bits,
+strings as UTF-8.
 
 ```ts
 import { ByteReader, ByteWriter } from '@hopple/netcode';

package/index.d.ts

@@ -1,2 +1,2 @@
-import { n as ByteWriter, t as ByteReader } from "./shared-B_2uj6dc.js";
+import { ByteReader, ByteWriter } from "@hopple/bytes";
 export { ByteReader, ByteWriter };

package/index.js

@@ -1,2 +1,2 @@
-import { n as ByteWriter, t as ByteReader } from "./shared-BR4Zxz2l.js";
+import { ByteReader, ByteWriter } from "@hopple/bytes";
 export { ByteReader, ByteWriter };

package/lockstep.js

@@ -1,4 +1,4 @@
-import { n as ByteWriter, t as ByteReader } from "./shared-BR4Zxz2l.js";
+import { ByteReader, ByteWriter } from "@hopple/bytes";
 //#region src/lockstep.ts
 /**
 * One way to run a match in lockstep: every device runs the same game, step by

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@hopple/netcode",
-  "version": "0.1.0",
+  "version": "0.1.1-ci.1",
   "description": "What a Hopple game bundles to play a match over the network: exact byte encoding, a lobby, and a lockstep helper with rollback.",
   "license": "MIT",
   "homepage": "https://hopple.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pamarit/hopple.git"
+  },
   "keywords": [
     "hopple",
     "game",
@@ -16,6 +20,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@hopple/bytes": "^0.1.1-ci.1"
+  },
   "peerDependencies": {
     "@hopple/sdk": "^1.0.0-next.1",
     "@hopple/sdk-preview-network": "^0.1.0"

package/session.d.ts

@@ -1,4 +1,4 @@
-import { n as ByteWriter, t as ByteReader } from "./shared-B_2uj6dc.js";
+import { ByteReader, ByteWriter } from "@hopple/bytes";
 //#region src/session.d.ts
 /**
  * The first byte of every message the session sends. A game sending messages

package/session.js

@@ -1,4 +1,4 @@
-import { n as ByteWriter, t as ByteReader } from "./shared-BR4Zxz2l.js";
+import { ByteReader, ByteWriter } from "@hopple/bytes";
 //#region src/session.ts
 /**
 * The lobby every networked game has between its games: what each player

package/shared-BR4Zxz2l.js

@@ -1,185 +0,0 @@
-//#region src/bytes.ts
-/**
-* Numbers and strings as bytes and back, exactly: what a game sends in a
-* match, written once and read the same way on every device.
-*
-* Integers are varints — a byte for anything under 128 — so a message of small
-* numbers stays small; floats are their eight bytes, little-endian, so they
-* arrive with every bit they left with; strings are UTF-8.
-*
-* ```ts
-* const out = new ByteWriter().uint(PICK).uint(fighter).bool(ready).finish();
-* match.send(out);
-*
-* const read = new ByteReader(data);
-* if (read.uint() === PICK) setPick(from, read.uint(), read.bool());
-* ```
-*
-* @module bytes
-*/
-const scratch = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
-/**
-* Builds a message.
-*
-* @group Bytes
-*/
-var ByteWriter = class {
-	buffer = /* @__PURE__ */ new Uint8Array(64);
-	length = 0;
-	room(more) {
-		if (this.length + more <= this.buffer.length) return;
-		const grown = new Uint8Array(Math.max(this.buffer.length * 2, this.length + more));
-		grown.set(this.buffer.subarray(0, this.length));
-		this.buffer = grown;
-	}
-	/** One byte, 0..255. */
-	byte(value) {
-		this.room(1);
-		this.buffer[this.length++] = value & 255;
-		return this;
-	}
-	/** A whole number from 0 up to 2⁵³: one byte under 128, two under 16384, and so on. */
-	uint(value) {
-		if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`ByteWriter.uint: ${value} is not a whole number from 0 to 2^53.`);
-		this.room(8);
-		while (value >= 128) {
-			this.buffer[this.length++] = value % 128 | 128;
-			value = Math.floor(value / 128);
-		}
-		this.buffer[this.length++] = value;
-		return this;
-	}
-	/** An integer from −2⁵² up to, not including, 2⁵², small ones in a byte whichever their sign. */
-	int(value) {
-		if (!Number.isSafeInteger(value) || value < -4503599627370496 || value >= 4503599627370496) throw new RangeError(`ByteWriter.int: ${value} is not an integer from -2^52 up to 2^52.`);
-		return this.uint(value >= 0 ? value * 2 : -value * 2 - 1);
-	}
-	bool(value) {
-		return this.byte(value ? 1 : 0);
-	}
-	/** A number's eight bytes, exactly. */
-	float64(value) {
-		this.room(8);
-		scratch.setFloat64(0, value, true);
-		for (let i = 0; i < 8; i++) this.buffer[this.length++] = scratch.getUint8(i);
-		return this;
-	}
-	/** Bytes, after their length. */
-	bytes(value) {
-		this.uint(value.length);
-		this.room(value.length);
-		this.buffer.set(value, this.length);
-		this.length += value.length;
-		return this;
-	}
-	/** A string as UTF-8, after its length in bytes. A lone surrogate is written as U+FFFD. */
-	string(value) {
-		const encoded = [];
-		for (let i = 0; i < value.length; i++) {
-			let c = value.charCodeAt(i);
-			if (c >= 55296 && c <= 56319 && i + 1 < value.length) {
-				const d = value.charCodeAt(i + 1);
-				if (d >= 56320 && d <= 57343) {
-					c = 65536 + (c - 55296 << 10) + (d - 56320);
-					i++;
-				} else c = 65533;
-			} else if (c >= 55296 && c <= 57343) c = 65533;
-			if (c < 128) encoded.push(c);
-			else if (c < 2048) encoded.push(192 | c >> 6, 128 | c & 63);
-			else if (c < 65536) encoded.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
-			else encoded.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
-		}
-		return this.bytes(Uint8Array.from(encoded));
-	}
-	/** What has been written, as a message of its own. */
-	finish() {
-		return this.buffer.slice(0, this.length);
-	}
-};
-/**
-* Reads a message, in the order it was written. Reading past its end, or a
-* value that is not what it should be, throws a `RangeError`: a message from
-* another device is checked, not believed.
-*
-* @group Bytes
-*/
-var ByteReader = class {
-	at = 0;
-	data;
-	constructor(data) {
-		this.data = data;
-	}
-	/** Whether everything has been read. */
-	get done() {
-		return this.at >= this.data.length;
-	}
-	/** How many bytes are left. */
-	get left() {
-		return this.data.length - this.at;
-	}
-	byte() {
-		if (this.at >= this.data.length) throw new RangeError("ByteReader: read past the end.");
-		return this.data[this.at++];
-	}
-	uint() {
-		let value = 0;
-		let scale = 1;
-		for (let i = 0; i < 8; i++) {
-			const byte = this.byte();
-			value += (byte & 127) * scale;
-			if (byte < 128) {
-				if (!Number.isSafeInteger(value)) break;
-				return value;
-			}
-			scale *= 128;
-		}
-		throw new RangeError("ByteReader: not a whole number.");
-	}
-	int() {
-		const zigzag = this.uint();
-		return zigzag % 2 === 0 ? zigzag / 2 : -(zigzag + 1) / 2;
-	}
-	bool() {
-		const byte = this.byte();
-		if (byte > 1) throw new RangeError("ByteReader: not a boolean.");
-		return byte === 1;
-	}
-	float64() {
-		if (this.left < 8) throw new RangeError("ByteReader: read past the end.");
-		for (let i = 0; i < 8; i++) scratch.setUint8(i, this.data[this.at++]);
-		return scratch.getFloat64(0, true);
-	}
-	bytes() {
-		const length = this.uint();
-		if (length > this.left) throw new RangeError("ByteReader: read past the end.");
-		const out = this.data.slice(this.at, this.at + length);
-		this.at += length;
-		return out;
-	}
-	string() {
-		const bytes = this.bytes();
-		let out = "";
-		for (let i = 0; i < bytes.length;) {
-			const b = bytes[i++];
-			let c;
-			if (b < 128) c = b;
-			else if (b >= 194 && b < 224) c = (b & 31) << 6 | this.tail(bytes, i++);
-			else if (b >= 224 && b < 240) {
-				c = (b & 15) << 12 | this.tail(bytes, i++) << 6 | this.tail(bytes, i++);
-				if (c < 2048 || c >= 55296 && c <= 57343) throw new RangeError("ByteReader: not UTF-8.");
-			} else if (b >= 240 && b < 245) {
-				c = (b & 7) << 18 | this.tail(bytes, i++) << 12 | this.tail(bytes, i++) << 6 | this.tail(bytes, i++);
-				if (c < 65536 || c > 1114111) throw new RangeError("ByteReader: not UTF-8.");
-			} else throw new RangeError("ByteReader: not UTF-8.");
-			out += String.fromCodePoint(c);
-		}
-		return out;
-	}
-	tail(bytes, i) {
-		const b = bytes[i];
-		if (b === void 0 || (b & 192) !== 128) throw new RangeError("ByteReader: not UTF-8.");
-		return b & 63;
-	}
-};
-//#endregion
-export { ByteWriter as n, ByteReader as t };

package/shared-B_2uj6dc.d.ts

@@ -1,70 +0,0 @@
-//#region src/bytes.d.ts
-/**
- * Numbers and strings as bytes and back, exactly: what a game sends in a
- * match, written once and read the same way on every device.
- *
- * Integers are varints — a byte for anything under 128 — so a message of small
- * numbers stays small; floats are their eight bytes, little-endian, so they
- * arrive with every bit they left with; strings are UTF-8.
- *
- * ```ts
- * const out = new ByteWriter().uint(PICK).uint(fighter).bool(ready).finish();
- * match.send(out);
- *
- * const read = new ByteReader(data);
- * if (read.uint() === PICK) setPick(from, read.uint(), read.bool());
- * ```
- *
- * @module bytes
- */
-/**
- * Builds a message.
- *
- * @group Bytes
- */
-declare class ByteWriter {
-  private buffer;
-  private length;
-  private room;
-  /** One byte, 0..255. */
-  byte(value: number): this;
-  /** A whole number from 0 up to 2⁵³: one byte under 128, two under 16384, and so on. */
-  uint(value: number): this;
-  /** An integer from −2⁵² up to, not including, 2⁵², small ones in a byte whichever their sign. */
-  int(value: number): this;
-  bool(value: boolean): this;
-  /** A number's eight bytes, exactly. */
-  float64(value: number): this;
-  /** Bytes, after their length. */
-  bytes(value: Uint8Array): this;
-  /** A string as UTF-8, after its length in bytes. A lone surrogate is written as U+FFFD. */
-  string(value: string): this;
-  /** What has been written, as a message of its own. */
-  finish(): Uint8Array;
-}
-/**
- * Reads a message, in the order it was written. Reading past its end, or a
- * value that is not what it should be, throws a `RangeError`: a message from
- * another device is checked, not believed.
- *
- * @group Bytes
- */
-declare class ByteReader {
-  private at;
-  private readonly data;
-  constructor(data: Uint8Array);
-  /** Whether everything has been read. */
-  get done(): boolean;
-  /** How many bytes are left. */
-  get left(): number;
-  byte(): number;
-  uint(): number;
-  int(): number;
-  bool(): boolean;
-  float64(): number;
-  bytes(): Uint8Array;
-  string(): string;
-  private tail;
-}
-//#endregion
-export { ByteWriter as n, ByteReader as t };