@benev/tact 0.3.0-4 → 0.4.0-0

package/s/_archive/lib2/core/utils/data.ts

@@ -0,0 +1,50 @@
+
+const endian = false
+const sizeHash = 4
+const sizeId = 2
+const sizeValue = 4
+const sizeIntention = sizeId + sizeValue
+
+export type Intention = {id: number, value: number}
+
+export function encodeData(hash: number, intentions: Intention[]) {
+	const byteCount = sizeHash + (intentions.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 intentions) {
+		dv.setUint16(cursor, intention.id, endian)
+		cursor += sizeId
+
+		dv.setFloat32(cursor, intention.value, endian)
+		cursor += sizeValue
+	}
+
+	return buffer
+}
+
+export function decodeData(buffer: ArrayBuffer) {
+	const intentions: Intention[] = []
+	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
+
+		intentions.push({id, value})
+	}
+
+	return {hash, intentions}
+}
+

package/s/_archive/lib2/core/utils/is-down.ts

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

package/s/_archive/lib2/core/utils/is-expression.ts

@@ -0,0 +1,11 @@
+
+import {is} from "@e280/stz"
+import {Bindings, Expression} from "../types.js"
+
+export function isExpression(b: Bindings): b is Expression {
+	if (is.string(b)) return true
+	if (is.number(b)) return true
+	if (is.array(b)) return true
+	return false
+}
+

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

@@ -0,0 +1,56 @@
+
+import {isDown} from "./utils/is-down.js"
+import {decodeData} from "./data/decode.js"
+import {Inputs, Bindings, InputData} from "./types.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
+	}
+
+	resolve(...datas: InputData[]): Inputs<B> {
+		for (const input of this.#investigation.inputList) {
+			input.was = input.value
+			input.pulses = 0
+			input.change = 0
+			input.up = 0
+			input.down = 0
+			input.highest = null
+			input.lowest = null
+		}
+
+		for (const data of datas) {
+			const decoded = decodeData(data)
+
+			if (decoded.hash !== this.#investigation.hash)
+				throw new Error("intent bindings hash mismatch")
+
+
+			for (const {id, value} of decoded.intents) {
+				const input = this.#investigation.inputList[id]
+				if (!input) throw new Error(`unknown input id ${id}`)
+
+				const previous = input.value
+				input.value = value
+				input.pulses += value
+
+				if (value !== previous) input.change++
+				if (!isDown(previous) && isDown(value)) input.down++
+				if (isDown(previous) && !isDown(value)) input.up++
+
+				input.lowest = Math.min(input.lowest ?? value, value)
+				input.highest = Math.max(input.highest ?? value, value)
+			}
+		}
+
+		return this.inputs
+	}
+}
+

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

@@ -0,0 +1,99 @@
+
+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 {EvaluationContext} from "./evaluate/context.js"
+import {investigate} from "./investigate/investigate.js"
+import {Bindings, Expression, InputData, Intent, Rebindings, Source} from "./types.js"
+
+export class InputEncoder<B extends Bindings = any> {
+	#sampler
+	#bindings
+	#investigation
+	#context
+	#expressionValues = new Map<Expression, 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.rootIds = fresh.rootIds
+		this.#investigation.rootList = fresh.rootList
+		this.#investigation.rootIndex = fresh.rootIndex
+		this.#context = new EvaluationContext()
+		this.#expressionValues.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.#context.clock.update(time)
+		this.#context.phase = "samples"
+		this.#context.dt = 0
+
+		for (const sample of samples) {
+			this.#context.sampleValues.set(sample.code, sample.value)
+
+			for (const root of this.#investigation.rootIndex.get(sample.code) ?? []) {
+				const intent = this.#makeIntent(root, sample.mode === "pulse")
+				if (intent) yield intent
+			}
+
+			if (sample.mode === "pulse")
+				this.#context.sampleValues.set(sample.code, 0)
+		}
+
+		this.#context.phase = "holdy"
+		for (const root of this.#context.holdyRoots) {
+			const intent = this.#makeIntent(root)
+			if (intent) yield intent
+		}
+
+		this.#context.phase = "dt"
+		this.#context.dt = this.#context.clock.since / 1000
+		for (const root of this.#context.dtRoots) {
+			const intent = this.#makeIntent(root, true)
+			if (intent) yield intent
+		}
+	}
+
+	#init() {
+		for (const root of this.#investigation.rootList)
+			evaluate(this.#context, root, root)
+	}
+
+	#makeIntent(root: Expression, force = false) {
+		const value = evaluate(this.#context, root, root)
+		const was = this.#expressionValues.get(root)
+		if (force || value !== was) {
+			this.#expressionValues.set(root, value)
+			const id = got(this.#investigation.rootIds.get(root))
+			return <Intent>{id, value}
+		}
+	}
+
+	dispose() {
+		return this.#sampler.dispose()
+	}
+}
+

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

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

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

@@ -0,0 +1,142 @@
+
+import {remap} from "@benev/math"
+import {arraylimit, guarantee, isNumber, isString} 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,
+		root: Expression,
+		expression: Expression,
+	): number {
+
+	const e = (expression: Expression) => evaluate(context, root, expression)
+
+	if (isNumber(expression))
+		return expression
+
+	else if (isString(expression))
+		return context.sampleValues.get(expression) ?? 0
+
+	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": {
+			context.dtRoots.add(root)
+			return context.dt
+		}
+
+		case "held": {
+			context.holdyRoots.add(root)
+
+			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/lib3/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/lib3/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/_archive/lib3/input/investigate/investigate.ts

@@ -0,0 +1,42 @@
+
+import {obMap} from "@e280/stz"
+import {makeInput} from "./make-input.js"
+import {hashBindings} from "./hash-bindings.js"
+import {isExpression} from "./is-expression.js"
+import {Bindings, Expression, Input, Inputs} from "../types.js"
+import {makeRootIndex as makeRootIndex} from "./root-index.js"
+
+export function investigate<B extends Bindings>(bindings: B) {
+	const hash = hashBindings(bindings)
+	const inputList: Input[] = []
+	const rootList: Expression[] = []
+	const rootIds = new Map<Expression, number>()
+
+	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>
+	const rootIndex = makeRootIndex(rootList)
+
+	for (const [id, root] of rootList.entries())
+		rootIds.set(root, id)
+
+	return {
+		hash,
+		inputs,
+		inputList,
+		rootList,
+		rootIndex,
+		rootIds,
+	}
+}
+

package/s/_archive/lib3/input/investigate/is-expression.ts

@@ -0,0 +1,11 @@
+
+import {isArray, isNumber, isString} from "@e280/stz"
+import {Bindings, Expression} from "../types.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/_archive/lib3/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/lib3/input/investigate/root-index.ts

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

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

@@ -0,0 +1,20 @@
+
+import {Intent} from "./types.js"
+import {InputEncoder} from "./encoder.js"
+import {encodeData} from "./data/encode.js"
+
+export class InputMixer {
+	encoders = new Set<InputEncoder<any>>()
+	constructor(private hash: number) {}
+
+	encode(time = performance.now()) {
+		const intents: Intent[] = []
+
+		for (const encoder of this.encoders)
+			for (const intent of encoder.evaluate(time))
+				intents.push(intent)
+
+		return encodeData(this.hash, intents)
+	}
+}
+

package/s/_archive/lib3/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, mode: "sticky"})
+		}
+	}
+
+	#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)
+		}
+	}
+}
+