@benev/tact 0.4.0-0 → 0.4.0-2

package/s/lib/input/types.ts

@@ -12,20 +12,16 @@ export type Source = {
 	readonly poll?: () => void
 }
 
-export type Intent = {id: number, value: number}
-
-export type InputData = ArrayBuffer
-
 export type Input = {
 
 	/** latest-known value. */
 	value: number
 
-	/** previously-known value. */
+	/** previously-known value from last frame. */
 	was: number
 
-	/** change in value since the previously-known value. */
-	delta: number
+	/** sum of values since last frame. */
+	sum: number
 }
 
 export type Inputs<B extends Bindings = any> = (

package/s/lib/input/utils/mouse-button.ts

@@ -1,10 +1,5 @@
 
 export function mouseButton(button: number) {
-	switch (button) {
-		case 0: return "pointer.button.left"
-		case 1: return "pointer.button.middle"
-		case 2: return "pointer.button.right"
-		default: return `pointer.button.${button + 1}`
-	}
+	return `pointer.${button + 1}`
 }
 

package/s/lib/test.ts

@@ -1,180 +1,6 @@
 
-import {expect, run, suite, test} from "@e280/science"
-import {asBindings} from "./input/types.js"
-import {InputEncoder} from "./input/encoder.js"
-import {PlainSource} from "./input/sources/plain.js"
-import {quickbind} from "./input/testing/quickbind.js"
+import {run} from "@e280/science"
+import input from "./input/test.js"
 
-await run({
-	input: suite({
-		"roundtrip": test(async() => {
-			const {sample, solve} = quickbind("KeyE")
-
-			sample({code: "KeyE", value: 0})
-			expect(solve().value).is(0)
-
-			sample({code: "KeyE", value: 1})
-			const inputs = solve()
-			expect(inputs.value).is(1)
-			expect(inputs.was).is(0)
-			expect(inputs.delta).is(1)
-		}),
-
-		"update bindings": test(async() => {
-			const {sample, solve, encoder} = quickbind("KeyA")
-
-			sample({code: "KeyA", value: 1})
-			expect(solve().value).is(1)
-
-			sample({code: "KeyA", value: 0})
-			expect(solve().value).is(0)
-
-			encoder.bindings = "KeyB"
-			expect(encoder.bindings).is("KeyB")
-			sample({code: "KeyA", value: 1})
-			expect(solve().value).is(0)
-
-			sample({code: "KeyA", value: 0})
-			sample({code: "KeyB", value: 1})
-			expect(solve().value).is(1)
-		}),
-
-		"pointer movement accumulation": test(async() => {
-			const {sample, solve} = quickbind(["accumulate", ["sum", "pointer.x"]])
-			let inputs = solve()
-
-			sample({code: "pointer.x", value: 0})
-			sample({code: "pointer.x", value: 1})
-			sample({code: "pointer.x", value: 2})
-			sample({code: "pointer.x", value: -5})
-			inputs = solve()
-			expect(inputs.value).is(-2)
-			expect(inputs.delta).is(-2)
-
-			sample({code: "pointer.x", value: 2})
-			sample({code: "pointer.x", value: 5})
-			inputs = solve()
-			expect(inputs.value).is(5)
-			expect(inputs.delta).is(7)
-		}),
-
-		"rapid transitions": test(async() => {
-			const {sample, solve} = quickbind({
-				key: "KeyE",
-				downs: ["down", "KeyE"],
-				ups: ["up", "KeyE"],
-			})
-
-			for (const value of [1, 0, 1, 0, 1])
-				sample({code: "KeyE", value})
-
-			let inputs = solve()
-			expect(inputs.key.value).is(1)
-			expect(inputs.downs.value).is(3)
-			expect(inputs.ups.value).is(2)
-
-			inputs = solve()
-			expect(inputs.key.value).is(1)
-			expect(inputs.downs.value).is(0)
-			expect(inputs.ups.value).is(0)
-		}),
-
-		"double tap in one frame": test(async() => {
-			const {sample, solve} = quickbind(
-				["taps", 2, 300, ["down", "KeyE"]]
-			)
-
-			for (const value of [1, 0, 1, 0])
-				sample({code: "KeyE", value})
-
-			expect(solve(100).value).is(1)
-			expect(solve(200).value).is(0)
-		}),
-
-		"held across empty frames": test(async() => {
-			const {sample, solve} = quickbind(
-				["held", 300, "KeyE"]
-			)
-
-			solve(0)
-			sample({code: "KeyE", value: 1})
-
-			expect(solve(100).value).is(0)
-			expect(solve(399).value).is(0)
-			expect(solve(400).value).is(1)
-			expect(solve(500).value).is(1)
-
-			sample({code: "KeyE", value: 0})
-			expect(solve(501).value).is(0)
-
-			sample({code: "KeyE", value: 1})
-			expect(solve(600).value).is(0)
-			expect(solve(900).value).is(1)
-		}),
-
-		"joystick integration": test(async() => {
-			const {sample, solve} = quickbind(
-				["accumulate", ["*", "gamepad.x", ["dt"]]]
-			)
-
-			solve(0)
-			sample({code: "gamepad.x", value: 1})
-
-			expect(solve(500).value).is(0.5)
-			expect(solve(1000).value).is(1)
-
-			sample({code: "gamepad.x", value: 0})
-			expect(solve(1500).value).is(1)
-		}),
-
-		"taps and holds coexist": test(async() => {
-			const {sample, solve} = quickbind({
-				tapper: ["taps", 1, 10, ["down", "KeyE"]],
-				holder: ["held", 10, "KeyE"],
-			})
-
-			solve(0)
-
-			sample({code: "KeyE", value: 1})
-			expect(solve(1).tapper.value).is(1)
-
-			sample({code: "KeyE", value: 0})
-			const released = solve(2)
-			expect(released.tapper.value).is(0)
-			expect(released.holder.value).is(0)
-
-			sample({code: "KeyE", value: 1})
-			const pressed = solve(3)
-			expect(pressed.tapper.value).is(1)
-			expect(pressed.holder.value).is(0)
-
-			const holding = solve(13)
-			expect(holding.tapper.value).is(0)
-			expect(holding.holder.value).is(1)
-		}),
-
-		"independent encoder consumers": test(async() => {
-			const source = new PlainSource()
-			const bindings = asBindings({
-				downs: ["down", "KeyE"],
-				ups: ["up", "KeyE"],
-			})
-
-			const fast = new InputEncoder(source, bindings)
-			const slow = new InputEncoder(source, bindings)
-
-			source.onSample.publish({code: "KeyE", value: 1})
-			expect([...fast.evaluate(1)].map(i => i.value)).deep([1, 0])
-
-			source.onSample.publish({code: "KeyE", value: 0})
-			expect([...fast.evaluate(2)].map(i => i.value)).deep([0, 1])
-
-			// slow consumer receives both transitions in one batch.
-			expect([...slow.evaluate(20)].map(i => i.value)).deep([1, 1])
-
-			fast.dispose()
-			slow.dispose()
-		}),
-	}),
-})
+await run({input})
 

package/s/lib/ui/deck/auto-gamepads.ts

@@ -0,0 +1,29 @@
+
+import {Hub} from "./hub.js"
+import {Controller} from "../../input/controller.js"
+import {onPad} from "../../input/utils/pad/on-pad.js"
+import {GamepadSource} from "../../input/sources/gamepad.js"
+
+export function autoGamepads(
+		hub: Hub,
+		fn?: (controller: Controller, source: GamepadSource) => () => void
+	) {
+
+	return onPad(pad => {
+		const source = new GamepadSource(pad)
+
+		const controller = new Controller({
+			source,
+			bindings: hub.bindings,
+		})
+
+		hub.plug(controller)
+		const dispose = fn?.(controller, source)
+
+		return () => {
+			hub.remove(controller)
+			dispose?.()
+		}
+	})
+}
+

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

@@ -0,0 +1,52 @@
+
+import {RMap} from "@e280/strata"
+import {guarantee} from "@e280/stz"
+
+import {PlayerId} from "./types.js"
+import {Bindings} from "../../input/types.js"
+import {InputDecoder} from "../../input/decoder.js"
+import {decodeParcels} from "../../input/data/parcel/decode.js"
+
+export class Collector<B extends Bindings> {
+	#bindings: B
+	#decoders = new RMap<PlayerId, InputDecoder<B>>()
+
+	constructor(bindings: B) {
+		this.#bindings = bindings
+	}
+
+	get players() {
+		return [...this.#decoders].map(([playerId, decoder]) => ({
+			playerId,
+			inputs: decoder.inputs,
+		}))
+	}
+
+	#getDecoder(playerId: PlayerId) {
+		return guarantee(
+			this.#decoders,
+			playerId,
+			() => new InputDecoder(this.#bindings),
+		)
+	}
+
+	decodeAll(...buffers: ArrayBuffer[]) {
+		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)
+			this.#getDecoder(playerId).decode(...intents)
+
+		for (const playerId of this.#decoders.keys()) {
+			if (!grouped.has(playerId))
+				this.#decoders.delete(playerId)
+		}
+
+		return this.players
+	}
+}
+

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

@@ -0,0 +1,76 @@
+
+import {collect, got, setEntries} from "@e280/stz"
+
+import {Profiles} from "./internal/profiles.js"
+import {Bindings} from "../../../input/types.js"
+import {makeControlsData} from "./internal/data.js"
+import {Assignments} from "./internal/assignments.js"
+import {Controller} from "../../../input/controller.js"
+import {ControllerMeta, ControlsOptions} from "./types.js"
+
+export class Controls<B extends Bindings = any> {
+	#data
+	profiles
+	assignments
+	readonly presets
+
+	constructor(options: ControlsOptions<B>) {
+		this.#data = makeControlsData(options)
+		this.profiles = new Profiles(this.#data)
+		this.assignments = new Assignments(this.#data)
+		this.presets = options.presets
+	}
+
+	get on() {
+		return this.#data.subby.on
+	}
+
+	#rebind(controller: Controller) {
+		const {preferences, assignments, controllers} = this.#data
+		const meta = got(controllers.get(controller))
+
+		const profileKey = assignments.get(controller)
+			?? preferences.get(meta.handle)
+			?? meta.defaultProfileKey
+
+		controller.bindings = this.profiles.get(profileKey).bindings
+		assignments.set(controller, profileKey)
+	}
+
+	async load() {
+		const {kvs, controllers, preferences, profiles: {customs}} = this.#data
+
+		customs.clear()
+		setEntries(customs, await collect(kvs.profiles))
+
+		preferences.clear()
+		setEntries(preferences, await collect(kvs.preferences))
+
+		for (const controller of controllers.keys())
+			this.#rebind(controller)
+	}
+
+	get controllers() {
+		return [...this.#data.controllers.keys()]
+	}
+
+	get fallbackProfileKey() {
+		return this.#data.profiles.fallback.key
+	}
+
+	meta(controller: Controller) {
+		return this.#data.controllers.get(controller)
+	}
+
+	attach(controller: Controller, meta: Omit<ControllerMeta, "id">) {
+		const id = this.#data.idCounter.next()
+		this.#data.controllers.set(controller, {...meta, id})
+		this.#rebind(controller)
+	}
+
+	detach(controller: Controller) {
+		this.#data.controllers.delete(controller)
+		this.#data.assignments.delete(controller)
+	}
+}
+

package/s/lib/ui/deck/controls/internal/assignments.ts

@@ -0,0 +1,24 @@
+
+import {assignProfile} from "./fns.js"
+import {ControlsData} from "./data.js"
+import {ProfileKey} from "../../types.js"
+import {Controller} from "../../../../input/controller.js"
+
+export class Assignments {
+	#data
+
+	constructor(data: ControlsData<any>) {
+		this.#data = data
+	}
+
+	async assign(controller: Controller, profileKey: ProfileKey) {
+		await assignProfile(this.#data, controller, profileKey)
+		this.#data.subby.publish()
+	}
+
+	assignedProfileKeyOf(controller: Controller) {
+		const {assignments} = this.#data
+		return assignments.get(controller) ?? this.#data.profiles.fallback.key
+	}
+}
+

package/s/lib/ui/deck/controls/internal/data.ts

@@ -0,0 +1,53 @@
+
+import {RMap} from "@e280/strata"
+import {got, IdCounter, setEntries, subby} from "@e280/stz"
+
+import {Profile, ProfileKey} from "../../types.js"
+import {Bindings} from "../../../../input/types.js"
+import {Controller} from "../../../../input/controller.js"
+import {hashBindings} from "../../../../input/investigate/hash-bindings.js"
+import {ControllerHandle, ControllerMeta, ControlsOptions} from "../types.js"
+
+export type ControlsData<B extends Bindings> = (
+	ReturnType<typeof makeControlsData<B>>
+)
+
+export function makeControlsData<B extends Bindings>(options: ControlsOptions<B>) {
+	const {presets} = options
+	const fallbackKey = got(Object.keys(presets)[0], "missing presets")
+	const fallbackProfile = got(presets[fallbackKey])
+	const bindings = fallbackProfile.bindings
+
+	const kv = options.kv.scope(
+		hashBindings(bindings).toString()
+	)
+
+	const profiles = {
+		presets: new RMap<ProfileKey, Profile<B>>(),
+		customs: new RMap<ProfileKey, Profile<B>>(),
+		fallback: {key: fallbackKey, profile: fallbackProfile},
+	}
+
+	setEntries(profiles.presets, Object.entries(presets))
+
+	return {
+		subby: subby(),
+
+		kv,
+		presets,
+		bindings,
+		idCounter: new IdCounter(),
+
+		profiles,
+
+		controllers: new RMap<Controller, ControllerMeta>(),
+		assignments: new RMap<Controller, ProfileKey>(),
+		preferences: new RMap<ControllerHandle, ProfileKey>(),
+
+		kvs: {
+			profiles: kv.scope<Profile>("profiles"),
+			preferences: kv.scope<ProfileKey>("preferences"),
+		},
+	}
+}
+

package/s/lib/ui/deck/controls/internal/fns.ts

@@ -0,0 +1,38 @@
+
+import {given, got} from "@e280/stz"
+import {ControlsData} from "./data.js"
+import {ProfileKey} from "../../types.js"
+import {Bindings} from "../../../../input/types.js"
+import {Controller} from "../../../../input/controller.js"
+
+export function getProfile<B extends Bindings>(
+		data: ControlsData<B>,
+		profileKey?: ProfileKey,
+	) {
+
+	const {presets, customs, fallback} = data.profiles
+
+	if (profileKey === undefined)
+		return fallback.profile
+
+	return customs.get(profileKey)
+		?? presets.get(profileKey)
+		?? got(presets.get(fallback.key))
+}
+
+export async function assignProfile<B extends Bindings>(
+		data: ControlsData<B>,
+		controller: Controller,
+		profileKey: ProfileKey,
+	) {
+
+	const {kvs, controllers, assignments} = data
+	controller.bindings = getProfile(data, profileKey).bindings
+	assignments.set(controller, profileKey)
+
+	await given(controllers.get(controller)?.handle, async handle => {
+		data.preferences.set(handle, profileKey)
+		await kvs.preferences.set(handle, profileKey)
+	})
+}
+

package/s/lib/ui/deck/controls/internal/profiles.ts

@@ -0,0 +1,83 @@
+
+import {ControlsData} from "./data.js"
+import {Profile, ProfileKey} from "../../types.js"
+import {assignProfile, getProfile} from "./fns.js"
+import {Bindings} from "../../../../input/types.js"
+import {isCompatible} from "../../../../input/investigate/is-compatible.js"
+
+export class Profiles<B extends Bindings> {
+	#data
+
+	constructor(data: ControlsData<B>) {
+		this.#data = data
+	}
+
+	#ensureBindingsAreCompatible(b: B) {
+		if (!isCompatible(b, this.#data.bindings))
+			throw new Error("incompatible bindings")
+	}
+
+	get presets() {
+		return [...this.#data.profiles.presets]
+	}
+
+	get customs() {
+		return [...this.#data.profiles.customs]
+	}
+
+	isPreset(profileKey: string) {
+		return this.#data.profiles.presets.has(profileKey)
+	}
+
+	get(profileKey?: ProfileKey) {
+		return getProfile(this.#data, profileKey)
+	}
+
+	async create(key: ProfileKey, profile: Profile<B>) {
+		const {kvs, profiles} = this.#data
+		this.#ensureBindingsAreCompatible(profile.bindings)
+		profiles.customs.set(key, profile)
+		await kvs.profiles.set(key, profile)
+		this.#data.subby.publish()
+	}
+
+	async clone(key: ProfileKey, basedOn: ProfileKey) {
+		const {label, bindings} = this.get(basedOn)
+		await this.create(key, {basedOn, bindings, label: `${label} copy`})
+	}
+
+	async delete(profileKey: ProfileKey) {
+		const {kvs, assignments, profiles: {customs, fallback}} = this.#data
+		customs.delete(profileKey)
+		await kvs.profiles.delete(profileKey)
+		for (const [controller, controllerKey] of assignments)
+			if (controllerKey === profileKey)
+				await assignProfile(this.#data, controller, fallback.key)
+		this.#data.subby.publish()
+	}
+
+	async update(profileKey: ProfileKey, changes: Partial<{
+			bindings: B
+			label: string
+		}>) {
+
+		const {kvs, assignments, profiles: {customs}} = this.#data
+
+		if (changes.bindings)
+			this.#ensureBindingsAreCompatible(changes.bindings)
+
+		const staleProfile = this.get(profileKey)
+		const freshProfile = {...structuredClone(staleProfile), ...changes}
+
+		customs.set(profileKey, freshProfile)
+
+		for (const [controller, controllerKey] of assignments) {
+			if (controllerKey === profileKey)
+				controller.bindings = freshProfile.bindings
+		}
+
+		await kvs.profiles.set(profileKey, freshProfile)
+		this.#data.subby.publish()
+	}
+}
+

package/s/lib/ui/deck/controls/types.ts

@@ -0,0 +1,23 @@
+
+import {Kv} from "@e280/kv"
+import {Content} from "@e280/sly"
+
+import {Bindings} from "../../../input/types.js"
+import {ProfileKey, Presets} from "../types.js"
+
+export type ControllerHandle = string
+
+export type ControllerMeta = {
+	id: number
+	icon: Content
+	handle: ControllerHandle
+	name: string
+	tooltip: string
+	defaultProfileKey: ProfileKey
+}
+
+export type ControlsOptions<B extends Bindings> = {
+	kv: Kv
+	presets: Presets<B>
+}
+