@benev/tact 0.3.0-5 → 0.4.0-0

package/s/_archive/lib3/input/sources/keyboard.ts

@@ -0,0 +1,49 @@
+
+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))
+	}
+
+	#publish = (code: string, value: number) =>
+		this.onSample.publish({code, value, mode: "sticky"})
+
+	#targetListeners = {
+		keydown: (event: KeyboardEvent) => {
+			if (event.repeat) return
+
+			if (this.#down.size === 0)
+				this.#publish("keyboard.any", 1)
+
+			this.#publish(event.code, 1)
+			this.#down.add(event.code)
+		},
+
+		keyup: (event: KeyboardEvent) => {
+			this.#publish(event.code, 0)
+			this.#down.delete(event.code)
+
+			if (this.#down.size === 0)
+				this.#publish("keyboard.any", 0)
+		},
+	}
+
+	#windowListeners = {
+		blur: () => {
+			for (const code of this.#down)
+				this.#publish(code, 0)
+
+			if (this.#down.size)
+				this.#publish("keyboard.any", 0)
+
+			this.#down.clear()
+		},
+	}
+}
+

package/s/_archive/lib3/input/sources/plain.ts

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

package/s/_archive/lib3/input/sources/pointer.ts

@@ -0,0 +1,58 @@
+
+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)
+		)
+	}
+
+	#publishSticky(code: string, value: number) {
+		this.onSample.publish({code, value, mode: "sticky"})
+	}
+
+	#publishPulse(code: string, value: number) {
+		this.onSample.publish({code, value, mode: "pulse"})
+	}
+
+	#listeners = {
+		pointerdown: (event: PointerEvent) => {
+			this.#publishSticky(mouseButton(event.button), 1)
+		},
+
+		pointerup: (event: PointerEvent) => {
+			this.#publishSticky(mouseButton(event.button), 0)
+		},
+
+		pointermove: (event: PointerEvent) => {
+			this.client.set_(event.clientX, event.clientY)
+
+			const [right, left] = splitAxis(event.movementX)
+			const [down, up] = splitAxis(event.movementY)
+
+			if (left) this.#publishPulse("pointer.move.left", left)
+			if (right) this.#publishPulse("pointer.move.right", right)
+			if (up) this.#publishPulse("pointer.move.up", up)
+			if (down) this.#publishPulse("pointer.move.down", down)
+		},
+
+		wheel: (event: WheelEvent) => {
+			const [right, left] = splitAxis(event.deltaX)
+			const [down, up] = splitAxis(event.deltaY)
+
+			if (left) this.#publishPulse("pointer.wheel.left", left)
+			if (right) this.#publishPulse("pointer.wheel.right", right)
+			if (up) this.#publishPulse("pointer.wheel.up", up)
+			if (down) this.#publishPulse("pointer.wheel.down", down)
+		},
+	}
+}
+

package/s/_archive/lib3/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/_archive/lib3/input/sources/stick.ts

@@ -0,0 +1,29 @@
+
+import {Vec2, Xy} from "@benev/math"
+import {Sample} from "../types.js"
+import {PlainSource} from "./plain.js"
+import {splitVector} from "../utils/split-axis.js"
+
+export class StickSource extends PlainSource {
+	samples: Sample[] = []
+	vector = Vec2.zero()
+
+	constructor(public channel = "stick") {
+		super()
+	}
+
+	set(vector: Xy) {
+		this.vector.set_(vector.x, vector.y)
+		const {up, down, left, right} = splitVector(this.vector)
+		this.#publish(`${this.channel}.up`, up)
+		this.#publish(`${this.channel}.down`, down)
+		this.#publish(`${this.channel}.left`, left)
+		this.#publish(`${this.channel}.right`, right)
+		return this
+	}
+
+	#publish(code: string, value: number) {
+		this.onSample.publish({code, value, mode: "sticky"})
+	}
+}
+

package/s/_archive/lib3/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.resolve(encoder.encode(time))
+
+	return {source, encoder, decoder, sample, solve}
+}
+

package/s/_archive/lib3/input/types.ts

@@ -0,0 +1,96 @@
+
+export type Sample = {
+	code: string
+	value: number
+	mode: "sticky" | "pulse"
+}
+
+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
+
+	/** sum of values in batch. */
+	pulses: number
+
+	/** number of times this value has changed in this batch. */
+	change: number
+
+	/** number of changes to up in this batch. */
+	up: number
+
+	/** number of changes to down in this batch. */
+	down: number
+
+	/** lowest value in batch. */
+	lowest: number | null
+
+	/** highest value in batch. */
+	highest: number | null
+}
+
+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
+)
+
+export type Expression = (
+	| string // a code like "KeyW", "pointer.move.up"
+	| number // constants for doing math
+
+	// combiners
+	| ["min", ...Expression[]]
+	| ["max", ...Expression[]]
+	| ["+", ...(Expression | number)[]]
+	| ["*", ...(Expression | number)[]]
+
+	// comparisons
+	| ["==", Expression, Expression]
+	| ["!=", Expression, Expression]
+	| [">", Expression, Expression]
+	| ["<", Expression, Expression]
+	| [">=", Expression, Expression]
+	| ["<=", Expression, Expression]
+
+	// transforms
+	| ["!", Expression]
+	| ["!!", Expression]
+	| ["clamp", low: Expression | null, high: Expression | null, Expression]
+	| ["remap", inLow: Expression, inHigh: Expression, outLow: Expression, outHigh: Expression, Expression]
+
+	// temporal
+	| ["dt"] // delta time in seconds since last resolve, used for stick sensitivity
+	| ["taps", taps: number, ms: number, Expression]
+	| ["held", ms: number, Expression]
+)
+

package/s/_archive/lib3/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/_archive/lib3/input/utils/is-down.ts

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

package/s/_archive/lib3/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/_archive/lib3/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/_archive/lib3/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/_archive/lib3/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/_archive/lib3/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}
+}
+

package/s/_archive/lib3/test.ts

@@ -0,0 +1,100 @@
+
+import {expect, run, suite, test} from "@e280/science"
+import {quickbind} from "./input/testing/quickbind.js"
+
+await run({
+	input: suite({
+		"roundtrip": test(async() => {
+			const {sample, solve} = quickbind("KeyE")
+
+			sample({code: "KeyE", value: 0, mode: "sticky"})
+			expect(solve().value).is(0)
+
+			sample({code: "KeyE", value: 1, mode: "sticky"})
+			const inputs = solve()
+
+			expect(inputs.value).is(1)
+			expect(inputs.was).is(0)
+			expect(inputs.change).is(1)
+		}),
+
+		"encoder dedupes sticky samples": test(async() => {
+			const {sample, encoder} = quickbind("KeyE")
+			sample({code: "KeyE", value: 0, mode: "sticky"})
+			sample({code: "KeyE", value: 1, mode: "sticky"})
+			sample({code: "KeyE", value: 1, mode: "sticky"})
+			const intents = [...encoder.evaluate(2)]
+			expect(intents.length).is(2)
+		}),
+
+		"pulse accumulation": test(async() => {
+			const {sample, solve} = quickbind("pointer.up")
+			sample({mode: "pulse", code: "pointer.up", value: 2})
+			sample({mode: "pulse", code: "pointer.up", value: 3})
+			expect(solve().pulses).is(5)
+			expect(solve().pulses).is(0)
+		}),
+
+		"sticky persists": test(async() => {
+			const {sample, solve} = quickbind(["*", "ShiftLeft", "pointer.up"])
+			sample({mode: "sticky", code: "ShiftLeft", value: 1})
+			solve()
+			sample({mode: "pulse", code: "pointer.up", value: 5})
+			sample({mode: "pulse", code: "pointer.up", value: 3})
+			expect(solve().pulses).is(8)
+		}),
+
+		"pulses don't linger": test(async() => {
+			const {sample, solve} = quickbind(["max", "pointer.up", "gamepad.up"])
+			sample({mode: "pulse", code: "pointer.up", value: 5})
+			sample({mode: "sticky", code: "gamepad.up", value: 2})
+			expect(solve().pulses).is(7)
+		}),
+
+		"pointer and joystick coexist": test(async() => {
+			const {sample, solve} = quickbind(["+", "pointer.up", ["*", ["dt"], "gamepad.up"]])
+			solve(0)
+			sample({mode: "pulse", code: "pointer.up", value: 1})
+			sample({mode: "sticky", code: "gamepad.up", value: 1})
+			sample({mode: "pulse", code: "pointer.up", value: 1})
+			expect(solve(1000).pulses).is(3)
+			expect(solve(2000).pulses).is(1)
+		}),
+
+		"rapid transitions": test(async() => {
+			const {sample, solve} = quickbind("KeyE")
+
+			for (const value of [1, 0, 1])
+				sample({mode: "sticky", code: "KeyE", value})
+
+			const input = solve()
+			expect(input.value).is(1)
+			expect(input.down).is(2)
+			expect(input.up).is(1)
+			expect(input.change).is(3)
+		}),
+
+		"taps and holds don't interfere": test(async() => {
+			const {sample, solve} = quickbind({
+				tapper: ["taps", 1, 10, "KeyE"],
+				holder: ["held", 10, "KeyE"],
+			})
+
+			sample({mode: "sticky", code: "KeyE", value: 0})
+			expect(solve(0).tapper.down).is(0)
+
+			sample({mode: "sticky", code: "KeyE", value: 1})
+			expect(solve(1).tapper.down).is(1)
+
+			sample({mode: "sticky", code: "KeyE", value: 0})
+			const released = solve(2)
+			expect(released.tapper.down).is(0)
+			expect(released.holder.down).is(0)
+
+			sample({mode: "sticky", code: "KeyE", value: 1})
+			expect(solve(3).holder.down).is(0)
+			expect(solve(13).holder.down).is(1)
+		}),
+	}),
+})
+

package/s/_archive/lib4/input/data/decode.ts

@@ -0,0 +1,25 @@
+
+import {Intent} from "../types.js"
+import {endian, sizeHash, sizeId, sizeValue} from "./params.js"
+
+export function decodeData(buffer: ArrayBuffer) {
+	const intents: Intent[] = []
+	const dv = new DataView(buffer)
+	let cursor = 0
+
+	const hash = dv.getUint32(cursor, endian)
+	cursor += sizeHash
+
+	while (cursor < buffer.byteLength) {
+		const id = dv.getUint16(cursor, endian)
+		cursor += sizeId
+
+		const value = dv.getFloat32(cursor, endian)
+		cursor += sizeValue
+
+		intents.push({id, value})
+	}
+
+	return {hash, intents}
+}
+

package/s/_archive/lib4/input/data/encode.ts

@@ -0,0 +1,24 @@
+
+import {Intent} from "../types.js"
+import {endian, sizeHash, sizeId, sizeIntention, sizeValue} from "./params.js"
+
+export function encodeData(hash: number, intents: Intent[]) {
+	const byteCount = sizeHash + (intents.length * sizeIntention)
+	const buffer = new ArrayBuffer(byteCount)
+	const dv = new DataView(buffer)
+	let cursor = 0
+
+	dv.setUint32(cursor, hash, endian)
+	cursor += sizeHash
+
+	for (const intention of intents) {
+		dv.setUint16(cursor, intention.id, endian)
+		cursor += sizeId
+
+		dv.setFloat32(cursor, intention.value, endian)
+		cursor += sizeValue
+	}
+
+	return buffer
+}
+

package/s/_archive/lib4/input/data/params.ts

@@ -0,0 +1,7 @@
+
+export const endian = false
+export const sizeHash = 4
+export const sizeId = 2
+export const sizeValue = 4
+export const sizeIntention = sizeId + sizeValue
+

package/s/_archive/lib4/input/encoder.ts

@@ -0,0 +1,100 @@
+
+import {deepClone, deepFreeze, got} from "@e280/stz"
+import {Sampler} from "./utils/sampler.js"
+import {encodeData} from "./data/encode.js"
+import {evaluate} from "./evaluate/evaluate.js"
+import {isDeltaRoot} from "./investigate/is.js"
+import {EvaluationContext} from "./evaluate/context.js"
+import {investigate} from "./investigate/investigate.js"
+import {Bindings, InputData, Rebindings, RootExpression, Source} from "./types.js"
+
+export class InputEncoder<B extends Bindings = any> {
+	#sampler
+	#bindings
+	#investigation
+	#context
+	#processedIds = new Set<number>()
+	#expressionResults = new Map<number, number>()
+
+	constructor(source: Source, bindings: B) {
+		this.#bindings = deepFreeze(deepClone(bindings)) as any as Rebindings<B>
+		this.#investigation = investigate(this.#bindings)
+		this.#sampler = new Sampler(source)
+		this.#context = new EvaluationContext()
+		this.#init()
+	}
+
+	get bindings() {
+		return this.#bindings
+	}
+
+	set bindings(b: Rebindings<B>) {
+		const fresh = investigate(b)
+
+		if (fresh.hash !== this.#investigation.hash)
+			throw new Error("incompatible bindings")
+
+		this.#investigation.rootList = fresh.rootList
+		this.#investigation.rootIndex = fresh.rootIndex
+		this.#context = new EvaluationContext()
+		this.#expressionResults.clear()
+		this.#init()
+	}
+
+	encode(time = performance.now()): InputData {
+		return encodeData(this.#investigation.hash, [...this.evaluate(time)])
+	}
+
+	*evaluate(time = performance.now()) {
+		const samples = this.#sampler.take()
+		this.#processedIds.clear()
+		this.#context.clock.update(time)
+		this.#context.currentSample = undefined
+		this.#context.dt = this.#context.clock.since
+
+		// evaluate expressions for each sample in order
+		for (const sample of samples) {
+			this.#context.currentSample = sample
+			this.#context.sampleValues.set(sample.code, sample.value)
+			const relevantRoots = got(this.#investigation.rootIndex.get(sample.code))
+
+			for (const {id, root} of relevantRoots) {
+				yield* this.#evaluateRootExpression(id, root)
+			}
+		}
+
+		// make sure 'held' expressions get evaluated every time
+		this.#context.currentSample = undefined
+		for (const id of this.#context.holdyRoots) {
+			if (!this.#processedIds.has(id))
+				yield* this.#evaluateRootExpression(id, this.#investigation.rootList[id])
+		}
+	}
+
+	*#evaluateRootExpression(id: number, root: RootExpression) {
+		const value = evaluate(this.#context, id, root, root)
+		this.#processedIds.add(id)
+
+		if (isDeltaRoot(root)) {
+			if (value !== 0)
+				yield {id, value}
+		}
+		else {
+			const was = this.#expressionResults.get(id)
+			if (value !== was) {
+				this.#expressionResults.set(id, value)
+				yield {id, value}
+			}
+		}
+	}
+
+	#init() {
+		for (const [id, root] of this.#investigation.rootList.entries())
+			evaluate(this.#context, id, root, root)
+	}
+
+	dispose() {
+		return this.#sampler.dispose()
+	}
+}
+