@benev/tact 0.3.0-5 → 0.4.0-0

package/s/lib/input/expression.ts

@@ -0,0 +1,44 @@
+
+export type Expression = (
+	| number // constants for doing math.
+
+	// special
+	| ["accumulate", Expression] // add each frame's result to a running total.
+
+	// samplers
+	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
+	| ["sum", string] // sum values this frame.
+	| ["up", string] // count releases this frame.
+	| ["down", string] // count presses this frame.
+	| ["was", string] // get previously known value from before this frame.
+	| ["since", string] // get change in value since previous frame.
+
+	// logic
+	| ["if", condition: Expression, yes: Expression, no?: Expression]
+
+	// combiners
+	| ["min", ...Expression[]]
+	| ["max", ...Expression[]]
+	| ["+", ...Expression[]]
+	| ["*", ...Expression[]]
+
+	// comparisons
+	| ["==", Expression, Expression]
+	| ["!=", Expression, Expression]
+	| [">", Expression, Expression]
+	| ["<", Expression, Expression]
+	| [">=", Expression, Expression]
+	| ["<=", Expression, Expression]
+
+	// transforms
+	| ["!", Expression]
+	| ["!!", Expression]
+	| ["clamp", low: Expression | null, high: Expression | null, subject: Expression]
+	| ["remap", inLow: Expression, inHigh: Expression, outLow: Expression, outHigh: Expression, subject: Expression]
+
+	// temporal
+	| ["dt"] // delta time in seconds since last frame, useful for stick sensitivity.
+	| ["held", ms: number, Expression]
+	| ["taps", taps: number, ms: number, Expression]
+)
+

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

@@ -0,0 +1,22 @@
+
+import {hash32} from "@e280/stz"
+import {Bindings} from "../types.js"
+import {isExpression} from "./is-expression.js"
+
+export function hashBindings(bindings: Bindings) {
+	const paths: string[] = []
+
+	function recurse(b: Bindings, path: string[]) {
+		if (isExpression(b)) {
+			paths.push(path.join("."))
+		}
+		else {
+			for (const [key, value] of Object.entries(b))
+				recurse(value, [...path, key])
+		}
+	}
+
+	recurse(bindings, ["b"])
+	return hash32(...paths)
+}
+

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

@@ -0,0 +1,35 @@
+
+import {obmap} from "@e280/stz"
+import {makeInput} from "./make-input.js"
+import {Expression} from "../expression.js"
+import {hashBindings} from "./hash-bindings.js"
+import {isExpression} from "./is-expression.js"
+import {Bindings, Input, Inputs} from "../types.js"
+
+export function investigate<B extends Bindings>(bindings: B) {
+	const hash = hashBindings(bindings)
+	const inputList: Input[] = []
+	const rootList: Expression[] = []
+
+	function makeInputs(b: Bindings): unknown {
+		if (isExpression(b)) {
+			const input = makeInput()
+			inputList.push(input)
+			rootList.push(b)
+			return input
+		}
+		else {
+			return obmap(b, makeInputs)
+		}
+	}
+
+	const inputs = makeInputs(bindings) as Inputs<B>
+
+	return {
+		hash,
+		inputs,
+		inputList,
+		rootList,
+	}
+}
+

package/s/lib/input/investigate/is-compatible.ts

@@ -0,0 +1,8 @@
+
+import {Bindings} from "../types.js"
+import {hashBindings} from "./hash-bindings.js"
+
+export function isCompatible(bindingsA: Bindings, bindingsB: Bindings) {
+	return hashBindings(bindingsA) === hashBindings(bindingsB)
+}
+

package/s/lib/input/investigate/is-expression.ts

@@ -0,0 +1,12 @@
+
+import {isArray, isNumber, isString} from "@e280/stz"
+import type {Bindings} from "../types.js"
+import type {Expression} from "../expression.js"
+
+export function isExpression(b: Bindings): b is Expression {
+	if (isString(b)) return true
+	if (isNumber(b)) return true
+	if (isArray(b)) return true
+	return false
+}
+

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

@@ -0,0 +1,11 @@
+
+import {Input} from "../types.js"
+
+export function makeInput(): Input {
+	return {
+		value: 0,
+		was: 0,
+		delta: 0,
+	}
+}
+

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

@@ -0,0 +1,55 @@
+
+import {PlainSource} from "./plain.js"
+import {Pad} from "../utils/pad/pad.js"
+import {splitAxis} from "../utils/split-axis.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
+			const i = index + 1
+			this.#publish(`gamepad.button.${i}`, value)
+			any = Math.max(any, value)
+		}
+
+		this.#publish("gamepad.button.any", any)
+	}
+
+	#pollAxes(gamepad: Gamepad) {
+		for (const [index, value] of gamepad.axes.entries()) {
+			const i = index + 1
+			const [pos, neg] = splitAxis(value)
+			this.#publish(`gamepad.axis.${i}`, value)
+			this.#publish(`gamepad.axis.${i}.neg`, neg)
+			this.#publish(`gamepad.axis.${i}.pos`, pos)
+		}
+	}
+}
+

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,56 @@
+
+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 {
+	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)
+
+			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/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/testing/quickbind.ts

@@ -0,0 +1,20 @@
+
+import {InputDecoder} from "../decoder.js"
+import {InputEncoder} from "../encoder.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 sample = (...samples: Sample[]) =>
+		samples.forEach(s => source.onSample.publish(s))
+
+	const solve = (time?: number) =>
+		decoder.decode(encoder.encode(time))
+
+	return {source, encoder, decoder, sample, solve}
+}
+

package/s/lib/input/types.ts

@@ -0,0 +1,52 @@
+
+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 Intent = {id: number, value: number}
+
+export type InputData = ArrayBuffer
+
+export type Input = {
+
+	/** latest-known value. */
+	value: number
+
+	/** previously-known value. */
+	was: number
+
+	/** change in value since the previously-known value. */
+	delta: 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/evergreen.ts

@@ -0,0 +1,10 @@
+
+export function evergreen<V>(value: V, fn: () => V | null | undefined) {
+	let cached = value
+	return () => {
+		const next = fn()
+		if (next !== undefined && next !== null) cached = next
+		return cached
+	}
+}
+

package/s/lib/input/utils/is-down.ts

@@ -0,0 +1,5 @@
+
+export function isDown(value: number) {
+	return value !== 0
+}
+

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

@@ -0,0 +1,10 @@
+
+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}`
+	}
+}
+

package/s/lib/input/utils/pad/on-pad.ts

@@ -0,0 +1,50 @@
+
+import {ev} from "@e280/stz"
+import {Pad} from "./pad.js"
+import {evergreen} from "../../utils/evergreen.js"
+
+/** listen for gamepads coming and going */
+export function onPad(fn: (pad: Pad) => () => void) {
+	const known = new Map<number, {pad: Pad, dispose: () => void}>()
+
+	function refresh() {
+		addNew()
+		deleteOld()
+	}
+
+	function addNew() {
+		for (const gamepad of navigator.getGamepads()) {
+			if (gamepad?.connected && !known.has(gamepad.index)) {
+				const get = () => navigator.getGamepads()[gamepad.index]
+				const pad = new Pad(evergreen(gamepad, get))
+				const dispose = fn(pad)
+				known.set(gamepad.index, {pad, dispose})
+			}
+		}
+	}
+
+	function deleteOld() {
+		for (const [index, {pad, dispose}] of known) {
+			const gamepad = navigator.getGamepads()[pad.gamepad.index]
+			if (!gamepad?.connected) {
+				dispose()
+				known.delete(index)
+			}
+		}
+	}
+
+	refresh()
+
+	const unlisten = ev(window, {
+		gamepadconnected: refresh,
+		gamepaddisconnected: refresh,
+	})
+
+	return () => {
+		unlisten()
+		for (const {dispose} of known.values())
+			dispose()
+		known.clear()
+	}
+}
+

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

@@ -0,0 +1,10 @@
+
+/** stable reference to a gamepad, has a getter to get the latest gamepad snapshot */
+export class Pad {
+	constructor(private get: () => Gamepad) {}
+
+	get gamepad() {
+		return this.get()
+	}
+}
+

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/input/utils/split-axis.ts

@@ -0,0 +1,15 @@
+
+import {Xy} from "@benev/math"
+
+export function splitAxis(n: number) {
+	return (n >= 0)
+		? [n, 0]
+		: [0, Math.abs(n)]
+}
+
+export function splitVector(vector: Xy) {
+	const [right, left] = splitAxis(vector.x)
+	const [down, up] = splitAxis(vector.y)
+	return {up, down, left, right}
+}
+