@benev/tact 0.4.0-8 → 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>
@@ -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-8",
+	"version": "0.4.0-9",
 	"description": "🎮 from keypress to couch co-op",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -21,16 +21,16 @@
 		"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",

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/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()
+	}
+}
+