@benev/tact 0.4.0-7 → 0.4.0-9

package/README.md

@@ -72,13 +72,14 @@ i care about the little things. all input types are boiled down to simple number
     - 💡 *you can call `tact.dispose()` to release resources.*
 - 🍏 **encoding, decoding, and your game logic.**
     ```ts
-    import {Collector} from "@benev/tact"
+    import {Players} from "@benev/tact"
 
-    const collector = new Collector(bindings)
+    const players = new Players(bindings)
 
     setInterval(() => {
       const buffer = tact.encodeAll()
-      for (const {playerId, inputs} of collector.decodeAll(buffer)) {
+      players.decodeAll(buffer)
+      for (const [playerId, inputs] of players) {
 
         // your game logic can read these handy input values.
         inputs.jump.value // button-like values are numbers 0 to 1.
@@ -90,8 +91,8 @@ i care about the little things. all input types are boiled down to simple number
       }
     }, 16.67)
     ```
-    - 💡 *you could stream the buffers across the network to a remote collector, maybe with [renraku](https://github.com/e280/renraku).*
-    - 💡 *you could have the tact deck on the clientside, and the collector on the serverside (or a web worker!).*
+    - 💡 *maybe you'd like to stream the buffers over a network with [renraku](https://github.com/e280/renraku).*
+    - 💡 *maybe you'd like the tact deck on the clientside and the players on the serverside.*
 - 🍏 **put the `<tact-deck>` element in your html page.**
     ```html
     <tact-deck></tact-deck>
@@ -116,11 +117,11 @@ i care about the little things. all input types are boiled down to simple number
 
 - ⚙️ **pov: your app isn't a game, no multiplayer, no gamepads.**  
     ```ts
-    import {setupTact, InputDecoder} from "@benev/tact"
+    import {setupTact, Decoder} from "@benev/tact"
 
     const tact = await setupTact({presets, maxPlayers: 1})
     const controller = tact.mouseKeyboard()
-    const decoder = new InputDecoder(bindings)
+    const decoder = new Decoder(bindings)
     tact.registerElements()
 
     setInterval(() => {
@@ -134,11 +135,11 @@ i care about the little things. all input types are boiled down to simple number
     - 💡 *then the only ui you need is the `<tact-customize>` panel (also available as a sly view `CustomizeView`).*
 - ⚙️ **pov: your app doesn't even want any ui, or persistence.**  
     ```ts
-    import {Controller, InputDecoder, KeyboardSource, PointerSource, Sources} from "@benev/tact"
+    import {Controller, Decoder, KeyboardSource, PointerSource, Sources} from "@benev/tact"
 
     const source = new Sources(new KeyboardSource(), new PointerSource())
     const controller = new Controller({bindings, source})
-    const decoder = new InputDecoder(bindings)
+    const decoder = new Decoder(bindings)
 
     setInterval(() => {
       const inputs = decoder.decode(controller.encode())
@@ -165,14 +166,14 @@ i care about the little things. all input types are boiled down to simple number
     ```
     ```ts
     asBindings({
-      actions: {
-        special: {
-          castMagicSpell: ["*", ["mod", "shift", "alt"], "KeyR"],
+      special: {
+        magic: {
+          castSpell: ["*", ["mod", "shift", "alt"], "KeyR"],
         }
       }
     })
 
-    inputs.actions.special.castMagicSpell.value // 1
+    inputs.special.magic.castSpell.value // 1
     ```
 - 🧬 **you can differentiate taps versus holds on the same key.**
     ```ts
@@ -191,21 +192,24 @@ i care about the little things. all input types are boiled down to simple number
       lookX: ["accumulate", "pointer.x"],
     })
 
-    inputs.lookX.sum // use sum instead of value, to ensure you don't lose any pointer movement.
+    inputs.lookX.sum // use sum instead of value.
     ```
 - 🧬 **gamepads thumbstick inputs are best done with some math.**
     ```ts
     asBindings({
       forward: ["*",
 
-        // user-customizable sensitivity, equivalent with pointer-pixels-per-second.
+        // user-customizable sensitivity,
+        // equivalent with pointer-pixels-per-second.
         1234,
 
-        // delta time factor, to ensure sensitivity is framerate-independent.
+        // delta time factor,
+        // to ensure sensitivity is framerate-independent.
         ["dt"],
 
-        // remapping the ranges because gamepads are naughty and often have jiggly deadzones.
-        ["remap", -0.1, -0.9, 0, 1, "gamepad.axis.1"],
+        // remapping the ranges,
+        // because different gamepads represent the values differently.
+        ["remap", 0, -1, 0, 1, "gamepad.axis.1"],
       ],
     })
     ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@benev/tact",
-	"version": "0.4.0-7",
+	"version": "0.4.0-9",
 	"description": "🎮 from keypress to couch co-op",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -21,21 +21,22 @@
 		"count": "find s -path '*/_archive' -prune -o -name '*.ts' -exec wc -l {} +"
 	},
 	"peerDependencies": {
-		"@e280/sly": "^0.4.9",
+		"@e280/sly": "^0.4.12",
 		"@e280/strata": "^0.5.6",
 		"lit": "^3.3.3"
 	},
 	"dependencies": {
+		"@awasm/noble": "^0.1.4",
 		"@benev/math": "0.4.0-9",
-		"@e280/kv": "^0.2.4",
+		"@e280/kv": "^0.2.6",
 		"@e280/shiny": "^0.1.1",
-		"@e280/stz": "^0.4.14"
+		"@e280/stz": "^0.4.15"
 	},
 	"devDependencies": {
 		"@e280/hottie": "^0.1.7",
 		"@e280/octo": "^0.1.7",
 		"@e280/science": "^0.1.14",
-		"@e280/scute": "^0.5.4",
+		"@e280/scute": "^0.5.5",
 		"http-server": "^14.1.1",
 		"npm-run-all": "^4.1.5",
 		"typescript": "^7.0.2"

package/s/lib/index.ts

@@ -19,7 +19,7 @@ export * from "./ui/deck/controls/types.js"
 export * from "./ui/deck/setup/deck.js"
 export * from "./ui/deck/setup/tact.js"
 export * from "./ui/deck/auto-gamepads.js"
-export * from "./ui/deck/collector.js"
+export * from "./ui/deck/players.js"
 export * from "./ui/deck/hub.js"
 export * from "./ui/deck/types.js"
 export * from "./ui/views/customize/view.js"

package/s/lib/input/controller.ts

@@ -58,7 +58,10 @@ export class Controller<B extends Bindings = any> {
 	}
 
 	encode(time = performance.now()) {
-		return encodeIntents(this.#investigation.hash, [...this.evaluate(time)])
+		return encodeIntents(
+			this.#investigation.minihash,
+			[...this.evaluate(time)],
+		)
 	}
 
 	clear() {

package/s/lib/input/data/intent/decode.ts

@@ -8,7 +8,7 @@ export function decodeIntents(buffer: ArrayBuffer) {
 	const dv = new DataView(buffer)
 	let cursor = 0
 
-	const hash = dv.getUint32(cursor, endian)
+	const minihash = dv.getUint32(cursor, endian)
 	cursor += sizeHash
 
 	while (cursor < buffer.byteLength) {
@@ -21,6 +21,6 @@ export function decodeIntents(buffer: ArrayBuffer) {
 		intents.push({id, value})
 	}
 
-	return {hash, intents}
+	return {minihash, intents}
 }
 

package/s/lib/input/data/intent/encode.ts

@@ -3,13 +3,13 @@ import {Intent} from "./types.js"
 import {endian} from "../endian.js"
 import {sizeHash, sizeId, sizeIntent, sizeValue} from "./sizes.js"
 
-export function encodeIntents(hash: number, intents: Intent[]) {
+export function encodeIntents(minihash: number, intents: Intent[]) {
 	const byteCount = sizeHash + (intents.length * sizeIntent)
 	const buffer = new ArrayBuffer(byteCount)
 	const dv = new DataView(buffer)
 	let cursor = 0
 
-	dv.setUint32(cursor, hash, endian)
+	dv.setUint32(cursor, minihash, endian)
 	cursor += sizeHash
 
 	for (const intent of intents) {

package/s/lib/input/data/intent/minihash.ts

@@ -0,0 +1,5 @@
+
+export function minihash(hash: string) {
+	return Number.parseInt(hash.slice(0, 8), 16)
+}
+

package/s/lib/input/decoder.ts

@@ -3,7 +3,7 @@ import {Inputs, Bindings} from "./types.js"
 import {decodeIntents} from "./data/intent/decode.js"
 import {investigate} from "./investigate/investigate.js"
 
-export class InputDecoder<B extends Bindings> {
+export class Decoder<B extends Bindings> {
 	#investigation
 
 	constructor(bindings: B) {
@@ -25,7 +25,7 @@ export class InputDecoder<B extends Bindings> {
 		for (const buffer of buffers) {
 			const decoded = decodeIntents(buffer)
 
-			if (decoded.hash !== this.#investigation.hash)
+			if (decoded.minihash !== this.#investigation.minihash)
 				throw new Error("intent bindings hash mismatch")
 
 			for (const input of inputs)

package/s/lib/input/investigate/hash-bindings.ts

@@ -1,6 +1,7 @@
 
-import {hash32} from "@e280/stz"
+import {hex} from "@e280/stz"
 import {Bindings} from "../types.js"
+import {hash} from "../../utils/hash.js"
 import {isExpression} from "./is-expression.js"
 
 export function hashBindings(bindings: Bindings) {
@@ -8,7 +9,7 @@ export function hashBindings(bindings: Bindings) {
 
 	function recurse(b: Bindings, path: string[]) {
 		if (isExpression(b)) {
-			paths.push(path.join("."))
+			paths.push(JSON.stringify(path))
 		}
 		else {
 			for (const [key, value] of Object.entries(b))
@@ -17,6 +18,7 @@ export function hashBindings(bindings: Bindings) {
 	}
 
 	recurse(bindings, ["b"])
-	return hash32(...paths)
+	paths.sort()
+	return hex(hash("tact/bindings/v1", ...paths).slice(16))
 }
 

package/s/lib/input/investigate/investigate.ts

@@ -5,31 +5,46 @@ import {Expression} from "../expression.js"
 import {hashBindings} from "./hash-bindings.js"
 import {isExpression} from "./is-expression.js"
 import {Bindings, Input, Inputs} from "../types.js"
+import {minihash} from "../data/intent/minihash.js"
 
 export function investigate<B extends Bindings>(bindings: B) {
 	const hash = hashBindings(bindings)
-	const inputList: Input[] = []
-	const rootList: Expression[] = []
 
-	function makeInputs(b: Bindings): unknown {
+	const leaves: {
+		path: string
+		input: Input
+		expression: Expression
+	}[] = []
+
+	function makeInputs(b: Bindings, path: string[]): unknown {
 		if (isExpression(b)) {
 			const input = makeInput()
-			inputList.push(input)
-			rootList.push(b)
+			leaves.push({
+				path: JSON.stringify(path),
+				input,
+				expression: b,
+			})
 			return input
 		}
 		else {
-			return obmap(b, makeInputs)
+			return obmap(b, (value, key) =>
+				makeInputs(value, [...path, key as string])
+			)
 		}
 	}
 
-	const inputs = makeInputs(bindings) as Inputs<B>
+	const inputs = makeInputs(bindings, ["b"]) as Inputs<B>
+
+	leaves.sort((a, b) =>
+		a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+	)
 
 	return {
 		hash,
+		minihash: minihash(hash),
 		inputs,
-		inputList,
-		rootList,
+		inputList: leaves.map(l => l.input),
+		rootList: leaves.map(l => l.expression),
 	}
 }
 

package/s/lib/input/test.ts

@@ -5,6 +5,7 @@ import {asBindings} from "./types.js"
 import {Controller} from "./controller.js"
 import {PlainSource} from "./sources/plain.js"
 import {quickbind} from "./testing/quickbind.js"
+import {isCompatible} from "./investigate/is-compatible.js"
 
 import parcel from "./data/test.js"
 
@@ -23,6 +24,16 @@ export default suite({
 		expect(inputs.was).is(0)
 	}),
 
+	"reordered bindings are equivalent": test(async() => {
+		const able = quickbind({alpha: "KeyA", bravo: "KeyB"})
+		const baker = quickbind({bravo: "KeyB", alpha: "KeyA"})
+		expect(isCompatible(able.bindings, baker.bindings)).is(true)
+		able.sample({code: "KeyA", value: 1})
+		const inputs = baker.decoder.decode(able.controller.encode())
+		expect(inputs.alpha.value).is(1)
+		expect(inputs.bravo.value).is(0)
+	}),
+
 	"update bindings": test(async() => {
 		const {sample, solve, controller} = quickbind("KeyA")
 

package/s/lib/input/testing/quickbind.ts

@@ -1,5 +1,5 @@
 
-import {InputDecoder} from "../decoder.js"
+import {Decoder} from "../decoder.js"
 import {Controller} from "../controller.js"
 import {Bindings, Sample} from "../types.js"
 import {PlainSource} from "../sources/plain.js"
@@ -7,7 +7,7 @@ import {PlainSource} from "../sources/plain.js"
 export function quickbind<B extends Bindings>(b: B) {
 	const source = new PlainSource()
 	const controller = new Controller({source, bindings: b})
-	const decoder = new InputDecoder(controller.bindings)
+	const decoder = new Decoder(controller.bindings)
 	const {inputs} = decoder
 
 	const sample = (...samples: Sample[]) =>
@@ -16,6 +16,6 @@ export function quickbind<B extends Bindings>(b: B) {
 	const solve = (time?: number) =>
 		decoder.decode(controller.encode(time))
 
-	return {source, controller, decoder, sample, solve, inputs}
+	return {bindings: b, source, controller, decoder, sample, solve, inputs}
 }
 

package/s/lib/ui/deck/hub.ts

@@ -5,18 +5,19 @@ import {got, IdCounter} from "@e280/stz"
 import {PlayerId} from "./types.js"
 import {Bindings} from "../../input/types.js"
 import {Controller} from "../../input/controller.js"
+import {minihash} from "../../input/data/intent/minihash.js"
 import {encodeParcels} from "../../input/data/parcel/encode.js"
 import {encodeIntents} from "../../input/data/intent/encode.js"
 import {hashBindings} from "../../input/investigate/hash-bindings.js"
 
 export class Hub<B extends Bindings = any> {
-	#hash
+	#minihash
 	#ids = new IdCounter()
 	#unassigned = new RSet<Controller<B>>()
 	#players = new RMap<PlayerId, {controllers: RSet<Controller<B>>}>()
 
 	constructor(readonly bindings: B) {
-		this.#hash = hashBindings(bindings)
+		this.#minihash = minihash(hashBindings(bindings))
 	}
 
 	get playerIds() {
@@ -86,7 +87,7 @@ export class Hub<B extends Bindings = any> {
 			.filter(([, value]) => value !== 0)
 			.map(([id, value]) => ({id, value}))
 
-		return encodeIntents(this.#hash, changedIntents)
+		return encodeIntents(this.#minihash, changedIntents)
 	}
 
 	encodeAll(time = performance.now()) {

package/s/lib/ui/deck/players.ts

@@ -0,0 +1,73 @@
+
+import {RMap} from "@e280/strata"
+import {guarantee} from "@e280/stz"
+
+import {PlayerId} from "./types.js"
+import {Bindings} from "../../input/types.js"
+import {Decoder} from "../../input/decoder.js"
+import {decodeParcels} from "../../input/data/parcel/decode.js"
+
+export class Players<B extends Bindings> {
+	#bindings: B
+	#decoders = new RMap<PlayerId, Decoder<B>>()
+
+	constructor(bindings: B) {
+		this.#bindings = bindings
+	}
+
+	decodeAll(...buffers: ArrayBuffer[]) {
+		const added: PlayerId[] = []
+		const removed: PlayerId[] = []
+		const grouped = new Map<PlayerId, ArrayBuffer[]>()
+
+		for (const buffer of buffers)
+			for (const {playerId, intents} of decodeParcels(buffer))
+				guarantee(grouped, playerId, () => []).push(intents)
+
+		for (const [playerId, intents] of grouped) {
+			let decoder = this.#decoders.get(playerId)
+			if (!decoder) {
+				decoder = new Decoder(this.#bindings)
+				this.#decoders.set(playerId, decoder)
+				added.push(playerId)
+			}
+			decoder.decode(...intents)
+		}
+
+		for (const playerId of this.#decoders.keys()) {
+			if (!grouped.has(playerId)) {
+				this.#decoders.delete(playerId)
+				removed.push(playerId)
+			}
+		}
+
+		return {added, removed}
+	}
+
+	has(playerId: PlayerId) {
+		return this.#decoders.has(playerId)
+	}
+
+	get(playerId: PlayerId) {
+		return this.#decoders.get(playerId)?.inputs
+	}
+
+	keys() {
+		return this.#decoders.keys()
+	}
+
+	*values() {
+		for (const {inputs} of this.#decoders.values())
+			yield inputs
+	}
+
+	*entries() {
+		for (const [playerId, {inputs}] of this.#decoders)
+			yield [playerId, inputs] as const
+	}
+
+	[Symbol.iterator]() {
+		return this.entries()
+	}
+}
+

package/s/lib/utils/hash.ts

@@ -0,0 +1,47 @@
+
+import {blake3} from "@awasm/noble/js.js"
+import {dataViewFrom, txt} from "@e280/stz"
+
+const endian = false
+enum EntropyType {String, Number, Bytes}
+
+export function hash(...entropy: (string | number | Uint8Array)[]) {
+	if (entropy.length === 0)
+		throw new RangeError("hash requires entropy")
+
+	const hasher = blake3.create()
+	const typeTag = new Uint8Array(1)
+	const lengthTag = new Uint8Array(4)
+	const lengthDataview = dataViewFrom(lengthTag)
+
+	for (const part of entropy) {
+		if (typeof part === "string") {
+			const bytes = txt.toBytes(part)
+			typeTag[0] = EntropyType.String
+			lengthDataview.setUint32(0, bytes.byteLength, endian)
+			hasher.update(typeTag)
+			hasher.update(lengthTag)
+			hasher.update(bytes)
+		}
+		else if (typeof part === "number") {
+			const bytes = new Uint8Array(8)
+			dataViewFrom(bytes).setFloat64(0, part, endian)
+			typeTag[0] = EntropyType.Number
+			lengthDataview.setUint32(0, bytes.byteLength, endian)
+			hasher.update(typeTag)
+			hasher.update(lengthTag)
+			hasher.update(bytes)
+		}
+		else if (part instanceof Uint8Array) {
+			typeTag[0] = EntropyType.Bytes
+			lengthDataview.setUint32(0, part.byteLength, endian)
+			hasher.update(typeTag)
+			hasher.update(lengthTag)
+			hasher.update(part)
+		}
+		else throw new Error("unknown part type")
+	}
+
+	return hasher.digest() as Uint8Array
+}
+