@benev/tact 0.3.0-5 → 0.4.0-1

package/s/lib/input/controller.ts

@@ -0,0 +1,72 @@
+
+import {deepFreeze} from "@e280/stz"
+import {Sampler} from "./utils/sampler.js"
+import {Intent} from "./data/intent/types.js"
+import {evaluate} from "./evaluate/evaluate.js"
+import {encodeIntents} from "./data/intent/encode.js"
+import {Bindings, Rebindings, Source} from "./types.js"
+import {EvaluationContext} from "./evaluate/context.js"
+import {investigate} from "./investigate/investigate.js"
+
+export class Controller<B extends Bindings = any> {
+	#sampler
+	#bindings: Rebindings<B>
+	#investigation
+	#context
+
+	constructor(options: {source: Source, bindings: B}) {
+		this.#bindings = deepFreeze(structuredClone(options.bindings)) as any as Rebindings<B>
+		this.#investigation = investigate(this.#bindings)
+		this.#sampler = new Sampler(options.source)
+		this.#context = new EvaluationContext()
+	}
+
+	get bindings() {
+		return this.#bindings
+	}
+
+	set bindings(b: Rebindings<B>) {
+		const bindings = deepFreeze(structuredClone(b)) as Rebindings<B>
+		const fresh = investigate(bindings)
+		const goodHash = this.#investigation.hash
+
+		if (fresh.hash !== goodHash)
+			throw new Error("incompatible bindings")
+
+		this.#bindings = bindings
+		this.#investigation.rootList = fresh.rootList
+	}
+
+	*evaluate(time = performance.now()) {
+		const samples = this.#sampler.take()
+
+		this.#context.clock.update(time)
+		this.#context.recentSamples = samples
+		this.#context.dt = this.#context.clock.since / 1000
+
+		for (const {code, value} of samples)
+			this.#context.latestValues.set(code, value)
+
+		for (const [id, expression] of this.#investigation.rootList.entries()) {
+			const value = evaluate(this.#context, expression)
+			if (value !== 0)
+				yield {id, value} as Intent
+		}
+
+		for (const {code, value} of samples)
+			this.#context.previousValues.set(code, value)
+	}
+
+	encode(time = performance.now()) {
+		return encodeIntents(this.#investigation.hash, [...this.evaluate(time)])
+	}
+
+	clear() {
+		void this.#sampler.take()
+	}
+
+	dispose() {
+		return this.#sampler.dispose()
+	}
+}
+

package/s/lib/input/data/endian.ts

@@ -0,0 +1,3 @@
+
+export const endian = false
+

package/s/lib/input/data/intent/decode.ts

@@ -0,0 +1,26 @@
+
+import {Intent} from "./types.js"
+import {endian} from "../endian.js"
+import {sizeHash, sizeId, sizeValue} from "./sizes.js"
+
+export function decodeIntents(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/lib/input/data/intent/encode.ts

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

package/s/lib/input/data/intent/sizes.ts

@@ -0,0 +1,6 @@
+
+export const sizeHash = 4
+export const sizeId = 2
+export const sizeValue = 4
+export const sizeIntent = sizeId + sizeValue
+

package/s/lib/input/data/intent/types.ts

@@ -0,0 +1,6 @@
+
+export type Intent = {
+	id: number
+	value: number
+}
+

package/s/lib/input/data/parcel/decode.ts

@@ -0,0 +1,32 @@
+
+import {Parcel} from "./types.js"
+import {endian} from "../endian.js"
+import {sizeHeader, sizeLength, sizePlayerId} from "./sizes.js"
+
+export function decodeParcels(buffer: ArrayBuffer): Parcel[] {
+	const view = new DataView(buffer)
+	const parcels: Parcel[] = []
+	let cursor = 0
+
+	while (cursor < buffer.byteLength) {
+		if (buffer.byteLength - cursor < sizeHeader)
+			throw new Error("truncated header")
+
+		const playerId = view.getUint32(cursor, endian)
+		cursor += sizePlayerId
+
+		const length = view.getUint32(cursor, endian)
+		cursor += sizeLength
+
+		if (length > buffer.byteLength - cursor)
+			throw new Error("truncated data")
+
+		const intents = buffer.slice(cursor, cursor + length)
+		cursor += length
+
+		parcels.push({playerId: playerId, intents})
+	}
+
+	return parcels
+}
+

package/s/lib/input/data/parcel/encode.ts

@@ -0,0 +1,30 @@
+
+import {Parcel} from "./types.js"
+import {endian} from "../endian.js"
+
+export function encodeParcels(parcels: Parcel[]): ArrayBuffer {
+	const sizeHeader = 8
+	const size = parcels.reduce(
+		(total, {intents}) => total + sizeHeader + intents.byteLength,
+		0,
+	)
+
+	const buffer = new ArrayBuffer(size)
+	const view = new DataView(buffer)
+	const bytes = new Uint8Array(buffer)
+	let cursor = 0
+
+	for (const {playerId, intents} of parcels) {
+		view.setUint32(cursor, playerId, endian)
+		cursor += 4
+
+		view.setUint32(cursor, intents.byteLength, endian)
+		cursor += 4
+
+		bytes.set(new Uint8Array(intents), cursor)
+		cursor += intents.byteLength
+	}
+
+	return buffer
+}
+

package/s/lib/input/data/parcel/sizes.ts

@@ -0,0 +1,5 @@
+
+export const sizeLength = 4
+export const sizePlayerId = 4
+export const sizeHeader = sizePlayerId + sizeLength
+

package/s/lib/input/data/parcel/types.ts

@@ -0,0 +1,8 @@
+
+import {PlayerId} from "../../../ui/deck/types.js"
+
+export type Parcel = {
+	playerId: PlayerId
+	intents: ArrayBuffer
+}
+

package/s/lib/input/data/test.ts

@@ -0,0 +1,23 @@
+
+import {hex} from "@e280/stz"
+import {expect, suite, test} from "@e280/science"
+
+import {Parcel} from "./parcel/types.js"
+import {encodeParcels} from "./parcel/encode.js"
+import {decodeParcels} from "./parcel/decode.js"
+
+export default suite({
+	parcel: suite({
+		"roundtrip": test(async() => {
+			const dataA = hex.random(16)
+			const dataB = hex.random(32)
+			const parcels = [
+				{playerId: 0, intents: hex.toBytes(dataA).buffer},
+				{playerId: 1, intents: hex.toBytes(dataB).buffer},
+			] as Parcel[]
+			expect(decodeParcels(encodeParcels(parcels)))
+				.deep(parcels)
+		}),
+	}),
+})
+

package/s/lib/input/decoder.ts

@@ -0,0 +1,46 @@
+
+import {Inputs, Bindings} from "./types.js"
+import {decodeIntents} from "./data/intent/decode.js"
+import {investigate} from "./investigate/investigate.js"
+
+export class InputDecoder<B extends Bindings> {
+	#investigation
+
+	constructor(bindings: B) {
+		this.#investigation = investigate(bindings)
+	}
+
+	get inputs() {
+		return this.#investigation.inputs
+	}
+
+	decode(...buffers: ArrayBuffer[]): Inputs<B> {
+		const inputs = this.#investigation.inputList
+
+		for (const input of inputs) {
+			input.was = input.value
+			input.sum = 0
+		}
+
+		for (const buffer of buffers) {
+			const decoded = decodeIntents(buffer)
+
+			if (decoded.hash !== this.#investigation.hash)
+				throw new Error("intent bindings hash mismatch")
+
+			for (const input of inputs)
+				input.value = 0
+
+			for (const {id, value} of decoded.intents) {
+				const input = inputs[id]
+				input.value = value
+			}
+
+			for (const input of inputs)
+				input.sum += input.value
+		}
+
+		return this.inputs
+	}
+}
+

package/s/lib/input/evaluate/context.ts

@@ -0,0 +1,16 @@
+
+import {Sample} from "../types.js"
+import {Clock} from "../utils/clock.js"
+
+export class EvaluationContext {
+	dt = 0
+	clock = new Clock()
+
+	recentSamples: Sample[] = []
+	latestValues = new Map<string, number>()
+	previousValues = new Map<string, number>()
+
+	holding = new Map<object, {start: number}>()
+	tapping = new Map<object, {events: number[]}>()
+}
+

package/s/lib/input/evaluate/evaluate.ts

@@ -0,0 +1,229 @@
+
+import {remap} from "@benev/math"
+import {arraylimit, guarantee, isHappy, isNumber, isString} from "@e280/stz"
+
+import {isDown} from "../utils/is-down.js"
+import {EvaluationContext} from "./context.js"
+import type {Expression} from "../expression.js"
+
+export function evaluate(
+		context: EvaluationContext,
+		expression: Expression,
+	): number {
+
+	const e = (expression: Expression) => evaluate(context, expression)
+
+	if (expression === null)
+		return 0
+
+	if (isNumber(expression))
+		return expression
+
+	else if (isString(expression)) {
+		const latest = context.latestValues.get(expression) ?? 0
+		return context.recentSamples
+			.filter(s => s.code === expression)
+			.reduce(
+				(peak, s) => Math.abs(s.value) > Math.abs(peak)
+					? s.value
+					: peak,
+				latest,
+			)
+	}
+
+	else switch (expression[0]) {
+		case "accumulate": {
+			const code = expression[1]
+			let x = 0
+			for (const sample of context.recentSamples) {
+				if (sample.code === code)
+					x += sample.value
+			}
+			return x
+		}
+
+		case "up": {
+			const code = expression[1]
+			let ups = 0
+			let was = context.previousValues.get(code) ?? 0
+			for (const sample of context.recentSamples) {
+				if (sample.code !== code) continue
+				if (isDown(was) && !isDown(sample.value))
+					ups++
+				was = sample.value
+			}
+			return ups
+		}
+
+		case "down": {
+			const code = expression[1]
+			let downs = 0
+			let was = context.previousValues.get(code) ?? 0
+			for (const sample of context.recentSamples) {
+				if (sample.code !== code) continue
+				if (!isDown(was) && isDown(sample.value))
+					downs++
+				was = sample.value
+			}
+			return downs
+		}
+
+		case "was": {
+			const code = expression[1]
+			return context.previousValues.get(code) ?? 0
+		}
+
+		case "since": {
+			const code = expression[1]
+			const was = context.previousValues.get(code) ?? 0
+			const latest = context.latestValues.get(code) ?? 0
+			return latest - was
+		}
+
+		case "if": {
+			const [, condition, yes, no] = expression
+			return e(condition)
+				? e(yes)
+				: (isHappy(no) ? e(no) : 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]) === 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 "!":
+			return +(e(expression[1]) === 0)
+
+		case "!!":
+			return +(e(expression[1]) !== 0)
+
+		case "-": {
+			const [, first, ...rest] = expression
+			if (rest.length === 0) return -e(first)
+			let value = e(first)
+			for (const neg of rest) value -= e(neg)
+			return value
+		}
+
+		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, value] = expression.slice(1).map(e)
+			return remap(value, a, b, c, d)
+		}
+
+		case "dt":
+			return context.dt
+
+		case "held": {
+			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 presses = e(subexpression)
+			const now = context.clock.time
+
+			const tapped = guarantee(context.tapping, expression, () => ({
+				events: [] as number[],
+			}))
+
+			for (let i = 0; i < presses; i++)
+				tapped.events.push(now)
+
+			tapped.events = arraylimit(
+				tapped.events.filter(time => time >= now - ms),
+				128,
+			)
+
+			if (tapped.events.length >= taps) {
+				tapped.events = []
+				return 1
+			}
+
+			return 0
+		}
+
+		case "mod": {
+			const [, ...modifiers] = expression
+			const down = (code: string) =>
+				isDown(context.latestValues.get(code) ?? 0)
+
+			const shift = down("ShiftLeft") || down("ShiftRight")
+			const ctrl = down("ControlLeft") || down("ControlRight")
+			const alt = down("AltLeft") || down("AltRight")
+			const meta = down("MetaLeft") || down("MetaRight")
+
+			if (modifiers.includes("shift") !== shift) return 0
+			if (modifiers.includes("ctrl") !== ctrl) return 0
+			if (modifiers.includes("alt") !== alt) return 0
+			if (modifiers.includes("meta") !== meta) return 0
+
+			return 1
+		}
+
+		default:
+			throw new Error("unknown expression")
+	}
+}
+

package/s/lib/input/expression.ts

@@ -0,0 +1,44 @@
+
+export type Expression = (
+	| null
+	| number // constants for doing math.
+
+	// samplers
+	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
+	| ["accumulate", 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 | null]
+
+	// combiners
+	| ["min", ...Expression[]]
+	| ["max", ...Expression[]]
+	| ["+", ...Expression[]]
+	| ["*", ...Expression[]]
+	| ["mod", ...("shift" | "ctrl" | "meta" | "alt")[]]
+
+	// comparisons
+	| ["==", Expression, Expression]
+	| ["!=", Expression, Expression]
+	| [">", Expression, Expression]
+	| ["<", Expression, Expression]
+	| [">=", Expression, Expression]
+	| ["<=", Expression, Expression]
+
+	// transforms
+	| ["!", Expression]
+	| ["!!", Expression]
+	| ["-", 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,13 @@
+
+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 (b === null) return true
+	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,7 @@
+
+import {Input} from "../types.js"
+
+export function makeInput(): Input {
+	return {value: 0, was: 0, sum: 0}
+}
+