@benev/tact 0.3.0-5 → 0.4.0-1

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

@@ -0,0 +1,49 @@
+
+import {PlainSource} from "./plain.js"
+import {Pad} from "../utils/pad/pad.js"
+
+export class GamepadSource extends PlainSource {
+	#values = new Map<string, number>()
+
+	constructor(public pad: Pad) {
+		super()
+	}
+
+	get gamepad() {
+		return this.pad.gamepad
+	}
+
+	poll() {
+		const gamepad = this.gamepad
+		this.#pollButtons(gamepad)
+		this.#pollAxes(gamepad)
+	}
+
+	#publish(code: string, value: number) {
+		const previous = this.#values.get(code) ?? 0
+
+		if (value !== previous) {
+			this.#values.set(code, value)
+			this.onSample.publish({code, value})
+		}
+	}
+
+	#pollButtons(gamepad: Gamepad) {
+		let any = 0
+
+		for (const [index, button] of gamepad.buttons.entries()) {
+			const value = button.value
+			this.#publish(`gamepad.${index + 1}`, value)
+			any = Math.max(any, value)
+		}
+
+		this.#publish("gamepad.any", any >= 0.9 ? 1 : 0)
+	}
+
+	#pollAxes(gamepad: Gamepad) {
+		for (const [index, value] of gamepad.axes.entries()) {
+			this.#publish(`gamepad.axis.${index + 1}`, value)
+		}
+	}
+}
+

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

@@ -0,0 +1,46 @@
+
+import {ev} from "@e280/stz"
+import {PlainSource} from "./plain.js"
+
+export class KeyboardSource extends PlainSource {
+	#down = new Set<string>()
+
+	constructor(target: EventTarget = window) {
+		super()
+		this.dispose.schedule(ev(target, this.#targetListeners))
+		this.dispose.schedule(ev(window, this.#windowListeners))
+	}
+
+	#targetListeners = {
+		keydown: (event: KeyboardEvent) => {
+			if (event.repeat) return
+
+			if (this.#down.size === 0)
+				this.onSample.publish({code: "keyboard.any", value: 1})
+
+			this.onSample.publish({code: event.code, value: 1})
+			this.#down.add(event.code)
+		},
+
+		keyup: (event: KeyboardEvent) => {
+			this.onSample.publish({code: event.code, value: 0})
+			this.#down.delete(event.code)
+
+			if (this.#down.size === 0)
+				this.onSample.publish({code: "keyboard.any", value: 0})
+		},
+	}
+
+	#windowListeners = {
+		blur: () => {
+			for (const code of this.#down)
+				this.onSample.publish({code: code, value: 0})
+
+			if (this.#down.size)
+				this.onSample.publish({code: "keyboard.any", value: 0})
+
+			this.#down.clear()
+		},
+	}
+}
+

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

@@ -0,0 +1,9 @@
+
+import {disposer, subby} from "@e280/stz"
+import {Sample, Source} from "../types.js"
+
+export class PlainSource implements Source {
+	onSample = subby<[sample: Sample]>()
+	dispose = disposer()
+}
+

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

@@ -0,0 +1,38 @@
+
+import {ev} from "@e280/stz"
+import {Vec2} from "@benev/math"
+import {PlainSource} from "./plain.js"
+import {mouseButton} from "../utils/mouse-button.js"
+
+export class PointerSource extends PlainSource {
+	client = new Vec2()
+
+	constructor(target: EventTarget = window) {
+		super()
+		this.dispose.schedule(
+			ev(target, this.#listeners)
+		)
+	}
+
+	#listeners = {
+		pointerdown: (event: PointerEvent) => {
+			this.onSample.publish({code: mouseButton(event.button), value: 1})
+		},
+
+		pointerup: (event: PointerEvent) => {
+			this.onSample.publish({code: mouseButton(event.button), value: 0})
+		},
+
+		pointermove: ({clientX, clientY, movementX, movementY}: PointerEvent) => {
+			this.client.set_(clientX, clientY)
+			if (movementX) this.onSample.publish({code: "pointer.x", value: movementX})
+			if (movementY) this.onSample.publish({code: "pointer.y", value: movementY})
+		},
+
+		wheel: ({deltaX, deltaY}: WheelEvent) => {
+			if (deltaX) this.onSample.publish({code: "pointer.wheel.x", value: deltaX})
+			if (deltaY) this.onSample.publish({code: "pointer.wheel.y", value: deltaY})
+		},
+	}
+}
+

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

@@ -0,0 +1,24 @@
+
+import {Source} from "../types.js"
+import {PlainSource} from "./plain.js"
+
+export class Sources extends PlainSource {
+	#array
+
+	constructor(...sources: Source[]) {
+		super()
+
+		this.#array = sources
+
+		for (const source of sources)
+			this.dispose.schedule(
+				source.onSample(sample => this.onSample.publish(sample))
+			)
+	}
+
+	poll() {
+		for (const source of this.#array)
+			source.poll?.()
+	}
+}
+

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

@@ -0,0 +1,32 @@
+
+import {Vec2, Xy} from "@benev/math"
+import {Sample} from "../types.js"
+import {PlainSource} from "./plain.js"
+import {splitAxis} from "../utils/split-axis.js"
+
+export class StickSource extends PlainSource {
+	samples: Sample[] = []
+	vector = Vec2.zero()
+
+	constructor(public channel = "stick") {
+		super()
+	}
+
+	set({x, y}: Xy) {
+		this.vector.set_(x, y)
+
+		this.onSample.publish({code: `${this.channel}.x`, value: x})
+		this.onSample.publish({code: `${this.channel}.y`, value: y})
+
+		const [xPos, xNeg] = splitAxis(x)
+		this.onSample.publish({code: `${this.channel}.x.pos`, value: xPos})
+		this.onSample.publish({code: `${this.channel}.x.neg`, value: xNeg})
+
+		const [yPos, yNeg] = splitAxis(y)
+		this.onSample.publish({code: `${this.channel}.y.pos`, value: yPos})
+		this.onSample.publish({code: `${this.channel}.y.neg`, value: yNeg})
+
+		return this
+	}
+}
+

package/s/lib/input/test.ts

@@ -0,0 +1,194 @@
+
+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 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)
+	}),
+
+	"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)
+	}),
+
+	"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)
+	}),
+
+	"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 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

@@ -0,0 +1,21 @@
+
+import {InputDecoder} 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 controller = new Controller({source, bindings: b})
+	const decoder = new InputDecoder(controller.bindings)
+	const {inputs} = decoder
+
+	const sample = (...samples: Sample[]) =>
+		samples.forEach(s => source.onSample.publish(s))
+
+	const solve = (time?: number) =>
+		decoder.decode(controller.encode(time))
+
+	return {source, controller, decoder, sample, solve, inputs}
+}
+

package/s/lib/input/types.ts

@@ -0,0 +1,48 @@
+
+import type {Expression} from "./expression.js"
+
+export type Sample = {
+	code: string
+	value: number
+}
+
+export type Source = {
+	readonly onSample: (fn: (sample: Sample) => void) => () => void
+	readonly dispose: () => void
+	readonly poll?: () => void
+}
+
+export type Input = {
+
+	/** latest-known value. */
+	value: number
+
+	/** previously-known value from last frame. */
+	was: number
+
+	/** sum of values since last frame. */
+	sum: number
+}
+
+export type Inputs<B extends Bindings = any> = (
+	B extends Expression
+		? Input
+		: B extends {[key: string]: Bindings}
+			? {[K in keyof B]: Inputs<B[K]>}
+			: never
+)
+
+export type Bindings = Expression | {
+	[key: string]: Bindings
+}
+
+export const asBindings = <B extends Bindings>(bindings: B) => (bindings as any as Rebindings<B>)
+
+export type Rebindings<B extends Bindings> = (
+	B extends Expression
+		? Expression
+		: B extends {[key: string]: Bindings}
+			? {[K in keyof B]: Rebindings<B[K]>}
+			: never
+)
+

package/s/lib/input/utils/clock.ts

@@ -0,0 +1,14 @@
+
+export class Clock {
+	since = 0
+	last: number | undefined
+
+	constructor(public time = performance.now()) {}
+
+	update(time = performance.now()) {
+		this.since = time - (this.time ?? time)
+		this.last = this.time
+		this.time = time
+	}
+}
+

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

@@ -0,0 +1,5 @@
+
+export function mouseButton(button: number) {
+	return `pointer.${button + 1}`
+}
+

package/s/lib/input/utils/sampler.ts

@@ -0,0 +1,28 @@
+
+import {arraylimit} from "@e280/stz"
+import {Sample, Source} from "../types.js"
+
+const limit = 1024
+
+export class Sampler {
+	readonly dispose
+	#source
+	#samples: Sample[] = []
+
+	constructor(source: Source) {
+		this.#source = source
+		this.dispose = source.onSample(sample => {
+			this.#samples.push(sample)
+			if (this.#samples.length > limit) console.warn(`tact sampler exceeded limit ${limit}`)
+			this.#samples = arraylimit(this.#samples, limit)
+		})
+	}
+
+	take() {
+		this.#source.poll?.()
+		const samples = this.#samples
+		this.#samples = []
+		return samples
+	}
+}
+

package/s/lib/test.ts

@@ -0,0 +1,6 @@
+
+import {run} from "@e280/science"
+import input from "./input/test.js"
+
+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)
+	}
+}
+