@benev/tact 0.3.0-5 → 0.4.0-0

package/s/_archive/lib/test.ts

@@ -0,0 +1,57 @@
+
+import {expect, run, suite, test} from "@e280/science"
+import {Resolver} from "./bindings/resolver.js"
+import {ExampleSource} from "./sampling/sources/example.js"
+
+await run({
+	resolver: suite({
+		"resolver update bindings": test(async() => {
+			const resolver = new Resolver({forward: ["max", "KeyW", "ArrowUp"]})
+			resolver.bindings = {forward: "KeyW"}
+			expect(resolver).ok()
+		}),
+
+		"multiple resolvers coexist": test(async() => {
+			const source = new ExampleSource()
+			source.samples = [
+				{code: "KeyW", value: 0},
+				{code: "KeyW", value: 1},
+			]
+			const resolverA = new Resolver({forward: "KeyW"})
+			const resolverB = new Resolver({forward: "KeyW"})
+			resolverA.resolveActions(resolverA.resolveIntent(source.samples, 1))
+			resolverB.resolveActions(resolverB.resolveIntent(source.samples, 1))
+			expect(resolverA.actions.forward.value).is(1)
+			expect(resolverB.actions.forward.value).is(1)
+
+			source.samples.push({code: "KeyW", value: 0})
+
+			resolverA.resolveActions(resolverA.resolveIntent(source.samples, 2))
+			expect(resolverA.actions.forward.value).is(0)
+
+			resolverB.resolveActions(resolverB.resolveIntent(source.samples, 2))
+			expect(resolverB.actions.forward.value).is(0)
+		}),
+
+		"samples to actions": test(async() => {
+			const resolver = new Resolver({forward: "KeyW"})
+			const {forward} = resolver.actions
+			const source = new ExampleSource()
+			source.samples = [
+				{code: "KeyW", value: 0},
+				{code: "KeyW", value: 1},
+			]
+
+			resolver.resolveActions(resolver.resolveIntent(source.samples, 3))
+			expect(forward).deep({value: 1, previous: 0, change: 1, down: 1, up: 0, lowest: 0, highest: 1})
+
+			resolver.resolveActions(resolver.resolveIntent(source.samples, 4))
+			expect(forward).deep({value: 1, previous: 1, change: 0, down: 0, up: 0, lowest: 1, highest: 1})
+
+			source.samples.push({code: "KeyW", value: 0})
+			resolver.resolveActions(resolver.resolveIntent(source.samples, 6))
+			expect(forward).deep({value: 0, previous: 1, change: 1, down: 0, up: 1, lowest: 0, highest: 1})
+		}),
+	}),
+})
+

package/s/_archive/lib/utils/backwards.ts

@@ -0,0 +1,6 @@
+
+export function* backwards<X>(items: X[]) {
+	for (let i = items.length - 1; i >= 0; i--)
+		yield items[i]
+}
+

package/s/_archive/lib/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/lib/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/lib/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/lib2/core/decoder/decoder.ts

@@ -0,0 +1,34 @@
+
+import {decodeData} from "../utils/data.js"
+import {updateInput} from "./utils/update-input.js"
+import {Inputs, Bindings, InputData} from "../types.js"
+import {investigate} from "../encoder/parts/investigate.js"
+
+export class InputDecoder<B extends Bindings> {
+	#investigation
+
+	constructor(bindings: B) {
+		this.#investigation = investigate(bindings)
+	}
+
+	get inputs() {
+		return this.#investigation.inputs
+	}
+
+	resolve(data: InputData): Inputs<B> {
+		const {hash, inputList} = this.#investigation
+		const decoded = decodeData(data)
+
+		if (decoded.hash !== hash)
+			throw new Error("intent bindings hash mismatch")
+
+		for (const {id, value} of decoded.intentions) {
+			const input = inputList[id]
+			if (!input) throw new Error(`unknown action id ${id}`)
+			updateInput(input, value)
+		}
+
+		return this.inputs
+	}
+}
+

package/s/_archive/lib2/core/decoder/utils/update-input.ts

@@ -0,0 +1,21 @@
+
+import {Input} from "../../types.js"
+import {isDown} from "../../utils/is-down.js"
+
+export function updateInput(input: Input, value: number) {
+	const previous = input.value
+
+	input.value = value
+	input.lowest = Math.min(input.lowest, value)
+	input.highest = Math.max(input.highest, value)
+
+	if (value !== previous)
+		input.change = 1
+
+	if (!isDown(previous) && isDown(value))
+		input.down = 1
+
+	if (isDown(previous) && !isDown(value))
+		input.up = 1
+}
+

package/s/_archive/lib2/core/encoder/encoder.ts

@@ -0,0 +1,60 @@
+
+import {deep} from "@e280/stz"
+import {Sampler} from "./parts/sampler.js"
+import {evaluate} from "./evaluate/evaluate.js"
+import {investigate} from "./parts/investigate.js"
+import {encodeData, Intention} from "../utils/data.js"
+import {EvaluationContext} from "./evaluate/context.js"
+import {Bindings, InputData, Rebindings, Source} from "../types.js"
+
+export class InputEncoder<B extends Bindings> {
+	#sampler
+	#bindings
+	#investigation
+	#context
+
+	constructor(source: Source, bindings: B) {
+		this.#bindings = deep.freeze(deep.clone(bindings)) as any as Rebindings<B>
+		this.#investigation = investigate(this.#bindings)
+		this.#sampler = new Sampler(source)
+		this.#context = new EvaluationContext()
+	}
+
+	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.expressionList = fresh.expressionList
+	}
+
+	encode(): InputData {
+		this.#context.start()
+		const intentions: Intention[] = []
+		const samples = this.#sampler.take()
+
+		for (const sample of samples) {
+			this.#context.update(sample)
+
+			const indexed = this.#investigation.expressionIndex.get(sample.code)
+			const expressions = [...indexed ?? []]
+
+			for (const {id, expression} of expressions) {
+				const value = evaluate(this.#context, expression)
+				intentions.push({id, value})
+			}
+		}
+
+		return encodeData(this.#investigation.hash, intentions)
+	}
+
+	dispose() {
+		return this.#sampler.dispose()
+	}
+}
+

package/s/_archive/lib2/core/encoder/evaluate/context.ts

@@ -0,0 +1,22 @@
+
+import {Sample} from "../../types.js"
+
+export class EvaluationContext {
+	sample!: Sample
+	since = 0
+	last: number | undefined
+
+	held = new WeakMap<object, {start: number}>()
+	tapped = new WeakMap<object, {previous: number, events: number[]}>()
+	accumulations = new Map<object, {value: number}>()
+
+	start() {
+		this.accumulations.clear()
+	}
+
+	update(sample: Sample) {
+		this.since = sample.time - (this.last ?? sample.time)
+		this.last = sample.time
+	}
+}
+

package/s/_archive/lib2/core/encoder/evaluate/evaluate.ts

@@ -0,0 +1,144 @@
+
+import {remap} from "@benev/math"
+import {arraylimit, guarantee, is} from "@e280/stz"
+import {Expression} from "../../types.js"
+import {isDown} from "../../utils/is-down.js"
+import {EvaluationContext} from "./context.js"
+
+export function evaluate(
+		context: EvaluationContext,
+		expression: Expression,
+	): number {
+
+	const e = (expression: Expression) => evaluate(context, expression)
+
+	if (is.number(expression))
+		return expression
+
+	else if (is.string(expression))
+		return context.sample.value
+
+	else switch (expression[0]) {
+		case "min":
+			return Math.min(...expression.slice(1).map(e))
+
+		case "max":
+			return Math.max(...expression.slice(1).map(e))
+
+		case "+":
+			return expression.slice(1)
+				.map(e)
+				.reduce((p, c) => p + c, 0)
+
+		case "*":
+			return expression.slice(1)
+				.map(e)
+				.reduce((p, c) => p * c, 1)
+
+		case "!":
+			return +(e(expression[1]) === 0)
+
+		case "!!":
+			return +(e(expression[1]) !== 0)
+
+		case "==":
+			return +(e(expression[1]) === e(expression[2]))
+
+		case "!=":
+			return +(e(expression[1]) !== e(expression[2]))
+
+		case ">":
+			return +(e(expression[1]) > e(expression[2]))
+
+		case "<":
+			return +(e(expression[1]) < e(expression[2]))
+
+		case ">=":
+			return +(e(expression[1]) >= e(expression[2]))
+
+		case "<=":
+			return +(e(expression[1]) <= e(expression[2]))
+
+		case "clamp": {
+			const [, min, max, expr] = expression
+			const value = e(expr)
+			return Math.min(
+				max === null ? Infinity : e(max),
+				Math.max(
+					min === null ? -Infinity : e(min),
+					value,
+				),
+			)
+		}
+
+		case "remap": {
+			const [, a, b, c, d, expr] = expression
+			return remap(e(expr), e(a), e(b), e(c), e(d))
+		}
+
+		case "dt":
+			return context.since / 1000
+
+		case "accumulate": {
+			const [, subexpression] = expression
+			const accumulation = guarantee(context.accumulations, expression, () => ({value: 0}))
+			accumulation.value += e(subexpression)
+			return accumulation.value
+		}
+
+		case "held": {
+			const [, ms, subexpression] = expression
+			const down = isDown(e(subexpression))
+			let held = context.held.get(expression)
+
+			if (down && !held) {
+				held = {start: context.sample.time}
+				context.held.set(expression, held)
+			}
+
+			if (!down && held) {
+				held = undefined
+				context.held.delete(expression)
+			}
+
+			if (held) {
+				const timeHeld = context.sample.time - held.start
+				if (timeHeld >= ms)
+					return 1
+			}
+
+			return 0
+		}
+
+		case "tapped": {
+			const [, ms, n, subexpression] = expression
+			const value = e(subexpression)
+			const tapped = guarantee(context.tapped, expression, () => ({
+				previous: 0,
+				events: [],
+			}))
+
+			const nowDown = isDown(value)
+			const wasDown = isDown(tapped.previous)
+			tapped.previous = value
+
+			if (nowDown && !wasDown) {
+				tapped.events.push(context.sample.time)
+				tapped.events = arraylimit(
+					tapped.events.filter(time => time >= (context.sample.time - ms)),
+					1024,
+				)
+				if (tapped.events.length >= n) {
+					tapped.events = []
+					return 1
+				}
+			}
+
+			return 0
+		}
+
+		default:
+			throw new Error("unknown expression")
+	}
+}
+

package/s/_archive/lib2/core/encoder/parts/expression-index.ts

@@ -0,0 +1,27 @@
+
+import {guarantee, is} from "@e280/stz"
+import {Expression} from "../../types.js"
+
+export function makeExpressionIndex(expressionlist: Expression[]) {
+	type Code = string
+	type Info = {id: number, expression: Expression}
+	const expressionIndex = new Map<Code, Set<Info>>()
+
+	function recurse(info: {id: number, expression: Expression}, e: Expression) {
+		if (is.string(e)) {
+			guarantee(expressionIndex, e, () => new Set())
+				.add(info)
+		}
+		else if (is.array(e)) {
+			for (const sub of e.slice(1))
+				if (sub !== null)
+					recurse(info, sub)
+		}
+	}
+
+	for (const [id, expression] of expressionlist.entries())
+		recurse({id, expression}, expression)
+
+	return expressionIndex
+}
+

package/s/_archive/lib2/core/encoder/parts/hash-bindings.ts

@@ -0,0 +1,22 @@
+
+import {hash32} from "@e280/stz"
+import {Bindings} from "../../types.js"
+import {isExpression} from "../../utils/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/_archive/lib2/core/encoder/parts/investigate.ts

@@ -0,0 +1,50 @@
+
+import {obMap} from "@e280/stz"
+import {hashBindings} from "./hash-bindings.js"
+import {isExpression} from "../../utils/is-expression.js"
+import {makeExpressionIndex} from "./expression-index.js"
+import {Bindings, Expression, Input, Inputs} from "../../types.js"
+
+export function investigate<B extends Bindings>(bindings: B) {
+	const hash = hashBindings(bindings)
+	const inputList: Input[] = []
+	const expressionList: Expression[] = []
+
+	function makeInputs(b: Bindings): unknown {
+		if (isExpression(b)) {
+			const input = makeInput()
+			inputList.push(input)
+			expressionList.push(b)
+			return input
+		}
+		else {
+			return obMap(b, makeInputs)
+		}
+	}
+
+	const inputs = makeInputs(bindings) as Inputs<B>
+	const expressionIndex = makeExpressionIndex(expressionList)
+
+	return {
+		hash,
+		inputs,
+		inputList,
+		expressionList,
+		expressionIndex,
+	}
+}
+
+function makeInput(): Input {
+	return {
+		value: 0,
+		previous: 0,
+
+		change: 0,
+		down: 0,
+		up: 0,
+
+		lowest: 0,
+		highest: 0,
+	}
+}
+

package/s/_archive/lib2/core/encoder/parts/sampler.ts

@@ -0,0 +1,22 @@
+
+import {arraylimit} from "@e280/stz"
+import {Sample, Source} from "../../types.js"
+
+export class Sampler {
+	readonly dispose
+	#samples: Sample[] = []
+
+	constructor(source: Source) {
+		this.dispose = source.onSample(sample => {
+			this.#samples.push(sample)
+			this.#samples = arraylimit(this.#samples, 1024)
+		})
+	}
+
+	take() {
+		const samples = this.#samples
+		this.#samples = []
+		return samples
+	}
+}
+

package/s/_archive/lib2/core/sources/example.ts

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

package/s/_archive/lib2/core/sources/sources.ts

@@ -0,0 +1,16 @@
+
+import {disposer, sub} from "@e280/stz"
+import {Sample, Source} from "../types.js"
+
+export class Sources implements Source {
+	readonly dispose = disposer()
+	readonly onSample = sub<[Sample]>()
+
+	constructor(...sources: Source[]) {
+		for (const source of sources)
+			this.dispose.schedule(
+				source.onSample(sample => this.onSample.publish(sample))
+			)
+	}
+}
+

package/s/_archive/lib2/core/types.ts

@@ -0,0 +1,78 @@
+
+export type Sample = {
+	code: string
+	value: number
+	time: number
+}
+
+export type Source = {
+	readonly onSample: (fn: (sample: Sample) => void) => () => void
+	readonly dispose: () => void
+}
+
+export type InputData = ArrayBuffer
+
+export type Input = {
+	value: number // latest-known value
+	previous: number // previously-known value
+
+	change: number // how many times the value has changed since previous resolve
+	up: number // how many times this button has been released since previous resolve
+	down: number // how many times this button has been pressed since previous resolve
+
+	lowest: number // lowest value since we last checked
+	highest: number // highest value since we last checked
+}
+
+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 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
+	| ["accumulate", Expression] // sum all values of this expression since last resolve
+	| ["tapped", ms: number, taps: number, Expression]
+	| ["held", ms: number, Expression]
+)
+