@benev/tact 0.3.0-5 → 0.4.0-0

package/s/_archive/lib4/input/evaluate/context.ts

@@ -0,0 +1,16 @@
+
+import {Clock} from "./utils/clock.js"
+import {Sample} from "../types.js"
+
+export class EvaluationContext {
+	phase: "samples" | "holdy" | "dt" = "samples"
+	dt = 0
+	clock = new Clock()
+	currentSample: Sample | undefined
+	sampleValues = new Map<string, number>()
+	holding = new WeakMap<object, {start: number}>()
+	tapping = new WeakMap<object, {previous: number, events: number[]}>()
+	holdyRoots = new Set<number>()
+	dtRoots = new Set<number>()
+}
+

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

@@ -0,0 +1,157 @@
+
+import {remap} from "@benev/math"
+import {arraylimit, guarantee, isNumber, isString} from "@e280/stz"
+
+import {isDown} from "../utils/is-down.js"
+import {EvaluationContext} from "./context.js"
+import {Expression, RootExpression} from "../types.js"
+
+export function evaluate(
+		context: EvaluationContext,
+		id: number,
+		root: RootExpression,
+		expression: RootExpression,
+	): number {
+
+	const e = (expression: Expression) => evaluate(context, id, root, expression)
+
+	if (isNumber(expression))
+		return expression
+
+	else if (isString(expression))
+		return context.sampleValues.get(expression) ?? 0
+
+	else switch (expression[0]) {
+		case "delta":
+			return e(expression[1])
+
+		case "pulse": {
+			const [, code] = expression
+			const sample = context.currentSample
+			return (sample?.code === code)
+				? sample.value
+				: 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": {
+			context.dtRoots.add(id)
+			return context.currentSample === null
+				? context.dt
+				: 0
+		}
+
+		case "held": {
+			context.holdyRoots.add(id)
+
+			const [, ms, subexpression] = expression
+			const down = isDown(e(subexpression))
+			let held = context.holding.get(expression)
+
+			if (down && !held) {
+				held = {start: context.clock.time}
+				context.holding.set(expression, held)
+			}
+
+			if (!down && held) {
+				held = undefined
+				context.holding.delete(expression)
+			}
+
+			if (held) {
+				const timeHeld = context.clock.time - held.start
+				if (timeHeld >= ms)
+					return 1
+			}
+
+			return 0
+		}
+
+		case "taps": {
+			const [, taps, ms, subexpression] = expression
+			const value = e(subexpression)
+			const tapped = guarantee(context.tapping, expression, () => ({
+				previous: 0,
+				events: [],
+			}))
+
+			const nowDown = isDown(value)
+			const wasDown = isDown(tapped.previous)
+			tapped.previous = value
+
+			if (nowDown && !wasDown) {
+				tapped.events.push(context.clock.time)
+				tapped.events = arraylimit(
+					tapped.events.filter(time => time >= (context.clock.time - ms)),
+					1024,
+				)
+				if (tapped.events.length >= taps) {
+					tapped.events = []
+					return 1
+				}
+			}
+
+			return 0
+		}
+
+		default:
+			throw new Error("unknown expression")
+	}
+}
+

package/s/_archive/lib4/input/evaluate/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/_archive/lib4/input/investigate/hash-bindings.ts

@@ -0,0 +1,22 @@
+
+import {hash32} from "@e280/stz"
+import {Bindings} from "../types.js"
+import {isRootExpression} from "./is.js"
+
+export function hashBindings(bindings: Bindings) {
+	const paths: string[] = []
+
+	function recurse(b: Bindings, path: string[]) {
+		if (isRootExpression(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/lib4/input/investigate/investigate.ts

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

package/s/_archive/lib4/input/investigate/is.ts

@@ -0,0 +1,19 @@
+
+import {isArray, isNumber, isString} from "@e280/stz"
+import {Bindings, Expression, RootExpression} from "../types.js"
+
+export function isRootExpression(b: Bindings): b is RootExpression {
+	if (isString(b)) return true
+	if (isNumber(b)) return true
+	if (isArray(b)) return true
+	return false
+}
+
+export function isDeltaRoot(root: RootExpression) {
+	return isArray(root) && root[0] === "delta"
+}
+
+export function isExpression(b: Bindings): b is Expression {
+	return isRootExpression(b) && !isDeltaRoot(b)
+}
+

package/s/_archive/lib4/input/investigate/make-input.ts

@@ -0,0 +1,18 @@
+
+import {Input} from "../types.js"
+
+export function makeInput(): Input {
+	return {
+		value: 0,
+		was: 0,
+		pulses: 0,
+
+		change: 0,
+		down: 0,
+		up: 0,
+
+		lowest: 0,
+		highest: 0,
+	}
+}
+

package/s/_archive/lib4/input/investigate/root-index.ts

@@ -0,0 +1,26 @@
+
+import {guarantee, isArray, isString} from "@e280/stz"
+import {RootExpression} from "../types.js"
+
+export function makeRootIndex(rootList: RootExpression[]) {
+	type Code = string
+	const rootIndex = new Map<Code, Set<{id: number, root: RootExpression}>>()
+
+	function recurse(id: number, root: RootExpression, e: RootExpression) {
+		if (isString(e)) {
+			guarantee(rootIndex, e, () => new Set())
+				.add({id, root})
+		}
+		else if (isArray(e)) {
+			for (const sub of e.slice(1))
+				if (sub !== null)
+					recurse(id, root, sub)
+		}
+	}
+
+	for (const [id, root] of rootList.entries())
+		recurse(id, root, root)
+
+	return rootIndex
+}
+

package/s/_archive/lib4/input/sources/gamepad.ts

@@ -0,0 +1,58 @@
+
+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 [neg, pos] = splitAxis(value)
+
+			this.#publish(`gamepad.axis.${i}`, value)
+			this.#publish(`gamepad.axis.${i}.neg`, neg)
+			this.#publish(`gamepad.axis.${i}.pos`, pos)
+		}
+	}
+}
+

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

@@ -0,0 +1,50 @@
+
+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: (event: PointerEvent) => {
+			this.client.set_(event.clientX, event.clientY)
+
+			const [right, left] = splitAxis(event.movementX)
+			const [down, up] = splitAxis(event.movementY)
+
+			if (left) this.onSample.publish({code: "pointer.move.left", value: left})
+			if (right) this.onSample.publish({code: "pointer.move.right", value: right})
+			if (up) this.onSample.publish({code: "pointer.move.up", value: up})
+			if (down) this.onSample.publish({code: "pointer.move.down", value: down})
+		},
+
+		wheel: (event: WheelEvent) => {
+			const [right, left] = splitAxis(event.deltaX)
+			const [down, up] = splitAxis(event.deltaY)
+
+			if (left) this.onSample.publish({code: "pointer.wheel.left", value: left})
+			if (right) this.onSample.publish({code: "pointer.wheel.right", value: right})
+			if (up) this.onSample.publish({code: "pointer.wheel.up", value: up})
+			if (down) this.onSample.publish({code: "pointer.wheel.down", value: down})
+		},
+	}
+}
+

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

@@ -0,0 +1,25 @@
+
+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.onSample.publish({code: `${this.channel}.up`, value: up})
+		this.onSample.publish({code: `${this.channel}.down`, value: down})
+		this.onSample.publish({code: `${this.channel}.left`, value: left})
+		this.onSample.publish({code: `${this.channel}.right`, value: right})
+		return this
+	}
+}
+

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

@@ -0,0 +1,102 @@
+
+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
+
+	/** 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 = RootExpression | {
+	[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 RootExpression =
+	| ["delta", Expression] // values represent an amount of change, every event is respected.
+	| Expression // values represent final state, non-changes are discarded.
+
+export type Expression = (
+	| number // constants for doing math.
+	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
+
+	// special
+	| ["pulse", string] // use current sample's value, or zero.
+
+	// 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/lib4/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/lib4/input/utils/is-down.ts

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

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