@benev/tact 0.4.0-0 → 0.4.0-10

package/s/lib/input/sources/pointer.ts

@@ -2,7 +2,6 @@
 import {ev} from "@e280/stz"
 import {Vec2} from "@benev/math"
 import {PlainSource} from "./plain.js"
-import {splitAxis} from "../utils/split-axis.js"
 import {mouseButton} from "../utils/mouse-button.js"
 
 export class PointerSource extends PlainSource {
@@ -26,30 +25,13 @@ export class PointerSource extends PlainSource {
 
 		pointermove: ({clientX, clientY, movementX, movementY}: PointerEvent) => {
 			this.client.set_(clientX, clientY)
-
-			const [xPos, xNeg] = splitAxis(movementX)
-			const [yPos, yNeg] = splitAxis(movementY)
-
 			if (movementX) this.onSample.publish({code: "pointer.x", value: movementX})
-			if (xPos) this.onSample.publish({code: "pointer.x.pos", value: xPos})
-			if (xNeg) this.onSample.publish({code: "pointer.x.neg", value: xNeg})
-
 			if (movementY) this.onSample.publish({code: "pointer.y", value: movementY})
-			if (yPos) this.onSample.publish({code: "pointer.y.pos", value: yPos})
-			if (yNeg) this.onSample.publish({code: "pointer.y.neg", value: yNeg})
 		},
 
 		wheel: ({deltaX, deltaY}: WheelEvent) => {
-			const [xPos, xNeg] = splitAxis(deltaX)
-			const [yPos, yNeg] = splitAxis(deltaY)
-
 			if (deltaX) this.onSample.publish({code: "pointer.wheel.x", value: deltaX})
-			if (xPos) this.onSample.publish({code: "pointer.wheel.x.pos", value: xPos})
-			if (xNeg) this.onSample.publish({code: "pointer.wheel.x.neg", value: xNeg})
-
 			if (deltaY) this.onSample.publish({code: "pointer.wheel.y", value: deltaY})
-			if (yPos) this.onSample.publish({code: "pointer.wheel.y.pos", value: yPos})
-			if (yNeg) this.onSample.publish({code: "pointer.wheel.y.neg", value: yNeg})
 		},
 	}
 }

package/s/lib/input/test.ts

@@ -0,0 +1,216 @@
+
+import {expect, suite, test} from "@e280/science"
+
+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"
+
+export default suite({
+	parcel,
+
+	"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)
+	}),
+
+	"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")
+
+		sample({code: "KeyA", value: 1})
+		expect(solve().value).is(1)
+
+		sample({code: "KeyA", value: 0})
+		expect(solve().value).is(0)
+
+		controller.bindings = "KeyB"
+		expect(controller.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)
+	}),
+
+	"incompatible bindings throws an error": test(async() => {
+		const {controller} = quickbind({alpha: "KeyA"})
+		expect(() => controller.bindings = <any>{bravo: "KeyA"}).throws()
+	}),
+
+	"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)
+	}),
+
+	"quick tap controller-level": test(async() => {
+		const {sample, solve, inputs} = quickbind("KeyE")
+
+		solve()
+		expect(inputs.sum).is(0)
+
+		for (const value of [0, 1, 0])
+			sample({code: "KeyE", value})
+
+		solve()
+		expect(inputs.sum).is(1)
+
+		solve()
+		expect(inputs.sum).is(0)
+	}),
+
+	"quick tap decoder-level": test(async() => {
+		const {sample, solve, controller, decoder, inputs} = quickbind("KeyE")
+
+		solve()
+		expect(inputs.sum).is(0)
+		const datas: ArrayBuffer[] = []
+
+		for (const value of [0, 1, 0]) {
+			sample({code: "KeyE", value})
+			datas.push(controller.encode())
+		}
+
+		decoder.decode(...datas)
+		expect(inputs.sum).is(1)
+
+		solve()
+		expect(inputs.sum).is(0)
+	}),
+
+	"single tap": test(async() => {
+		const {sample, solve} = quickbind(["taps", 1, 400, "KeyE"])
+		const hit = (time: number, value: number) => {
+			sample({code: "KeyE", value})
+			return solve(time).value
+		}
+		expect(hit(0, 0)).is(0)
+		expect(hit(100, 1)).is(0)
+		expect(hit(200, 0)).is(1)
+	}),
+
+	"double tap": test(async() => {
+		const {sample, solve} = quickbind(["taps", 2, 400, "KeyE"])
+		const hit = (time: number, value: number) => {
+			sample({code: "KeyE", value})
+			return solve(time).value
+		}
+		expect(hit(0, 0)).is(0)
+		expect(hit(100, 1)).is(0)
+		expect(hit(200, 0)).is(0)
+		expect(hit(300, 1)).is(0)
+		expect(hit(400, 0)).is(1)
+	}),
+
+	"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)
+	}),
+
+	"taps vs held": test(async() => {
+		const {sample, solve} = quickbind({
+			tappy: ["taps", 1, 300, "KeyE"],
+			holdy: ["held", 300, "KeyE"],
+		})
+		const hit = (time: number, value: number) => {
+			sample({code: "KeyE", value})
+			return solve(time)
+		}
+		const __up = (time: number) => hit(time, 0)
+		const DOWN = (time: number) => hit(time, 1)
+
+		expect(__up(1000).tappy.value).is(0)
+		expect(DOWN(1100).tappy.value).is(0)
+		expect(__up(1200).tappy.value).is(1)
+		expect(__up(1300).tappy.value).is(0)
+
+		expect(__up(2000).holdy.value).is(0)
+		expect(DOWN(2100).holdy.value).is(0)
+		expect(DOWN(2200).holdy.value).is(0)
+		expect(DOWN(2300).holdy.value).is(0)
+		expect(DOWN(2400).holdy.value).is(1)
+		expect(__up(2500).tappy.value).is(0) // FAILS
+	}),
+
+	"independent controller consumers": test(async() => {
+		const source = new PlainSource()
+		const bindings = asBindings({
+			downs: ["down", "KeyE"],
+			ups: ["up", "KeyE"],
+		})
+
+		const fast = new Controller({source, bindings})
+		const slow = new Controller({source, bindings})
+
+		source.onSample.publish({code: "KeyE", value: 1})
+		expect([...fast.evaluate(1)]).deep([
+			{id: 0, value: 1},
+		])
+
+		source.onSample.publish({code: "KeyE", value: 0})
+		expect([...fast.evaluate(2)]).deep([
+			{id: 1, value: 1},
+		])
+
+		expect([...slow.evaluate(20)]).deep([
+			{id: 0, value: 1},
+			{id: 1, value: 1},
+		])
+
+		fast.dispose()
+		slow.dispose()
+	}),
+})
+

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

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

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,30 @@
+
+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 () => {
+			controller.dispose()
+			hub.remove(controller)
+			dispose?.()
+		}
+	})
+}
+

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"),
+		},
+	}
+}
+