@benev/tact 0.4.0-0 → 0.4.0-10

package/s/lib/input/{encoder.ts → controller.ts}

@@ -1,22 +1,23 @@
 
 import {deepFreeze} from "@e280/stz"
 import {Sampler} from "./utils/sampler.js"
-import {encodeData} from "./data/encode.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"
-import {Bindings, InputData, Intent, Rebindings, Source} from "./types.js"
 
-export class InputEncoder<B extends Bindings = any> {
+export class Controller<B extends Bindings = any> {
 	#sampler
-	#bindings
+	#bindings: Rebindings<B>
 	#investigation
 	#context
 
-	constructor(source: Source, bindings: B) {
-		this.#bindings = deepFreeze(structuredClone(bindings)) as any as Rebindings<B>
+	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(source)
+		this.#sampler = new Sampler(options.source)
 		this.#context = new EvaluationContext()
 	}
 
@@ -27,17 +28,13 @@ export class InputEncoder<B extends Bindings = any> {
 	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 !== this.#investigation.hash)
+		if (fresh.hash !== goodHash)
 			throw new Error("incompatible bindings")
 
 		this.#bindings = bindings
 		this.#investigation.rootList = fresh.rootList
-		this.#context = new EvaluationContext()
-	}
-
-	encode(time = performance.now()): InputData {
-		return encodeData(this.#investigation.hash, [...this.evaluate(time)])
 	}
 
 	*evaluate(time = performance.now()) {
@@ -50,13 +47,27 @@ export class InputEncoder<B extends Bindings = any> {
 		for (const {code, value} of samples)
 			this.#context.latestValues.set(code, value)
 
-		for (const [id, expression] of this.#investigation.rootList.entries())
-			yield {id, value: evaluate(this.#context, id, expression)} as Intent
+		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.minihash,
+			[...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/{decode.ts → intent/decode.ts}

@@ -1,13 +1,14 @@
 
-import {Intent} from "../types.js"
-import {endian, sizeHash, sizeId, sizeValue} from "./params.js"
+import {Intent} from "./types.js"
+import {endian} from "../endian.js"
+import {sizeHash, sizeId, sizeValue} from "./sizes.js"
 
-export function decodeData(buffer: ArrayBuffer) {
+export function decodeIntents(buffer: ArrayBuffer) {
 	const intents: Intent[] = []
 	const dv = new DataView(buffer)
 	let cursor = 0
 
-	const hash = dv.getUint32(cursor, endian)
+	const minihash = dv.getUint32(cursor, endian)
 	cursor += sizeHash
 
 	while (cursor < buffer.byteLength) {
@@ -20,6 +21,6 @@ export function decodeData(buffer: ArrayBuffer) {
 		intents.push({id, value})
 	}
 
-	return {hash, intents}
+	return {minihash, 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(minihash: 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, minihash, 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/minihash.ts

@@ -0,0 +1,5 @@
+
+export function minihash(hash: string) {
+	return Number.parseInt(hash.slice(0, 8), 16)
+}
+

package/s/{_archive/lib3/input/data/params.ts → lib/input/data/intent/sizes.ts}

@@ -1,7 +1,6 @@
 
-export const endian = false
 export const sizeHash = 4
 export const sizeId = 2
 export const sizeValue = 4
-export const sizeIntention = sizeId + sizeValue
+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

@@ -1,9 +1,9 @@
 
-import {decodeData} from "./data/decode.js"
-import {Inputs, Bindings, InputData} from "./types.js"
+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> {
+export class Decoder<B extends Bindings> {
 	#investigation
 
 	constructor(bindings: B) {
@@ -14,24 +14,30 @@ export class InputDecoder<B extends Bindings> {
 		return this.#investigation.inputs
 	}
 
-	decode(...datas: InputData[]): Inputs<B> {
-		for (const input of this.#investigation.inputList) {
+	decode(...buffers: ArrayBuffer[]): Inputs<B> {
+		const inputs = this.#investigation.inputList
+
+		for (const input of inputs) {
 			input.was = input.value
-			input.delta = 0
+			input.sum = 0
 		}
 
-		for (const data of datas) {
-			const decoded = decodeData(data)
+		for (const buffer of buffers) {
+			const decoded = decodeIntents(buffer)
 
-			if (decoded.hash !== this.#investigation.hash)
+			if (decoded.minihash !== this.#investigation.minihash)
 				throw new Error("intent bindings hash mismatch")
 
+			for (const input of inputs)
+				input.value = 0
+
 			for (const {id, value} of decoded.intents) {
-				const input = this.#investigation.inputList[id]
-				if (!input) throw new Error(`unknown input id ${id}`)
+				const input = inputs[id]
 				input.value = value
-				input.delta = input.value - input.was
 			}
+
+			for (const input of inputs)
+				input.sum += input.value
 		}
 
 		return this.inputs

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

@@ -10,8 +10,11 @@ export class EvaluationContext {
 	latestValues = new Map<string, number>()
 	previousValues = new Map<string, number>()
 
-	accumulated = new Map<object, number>()
-	holding = new WeakMap<object, {start: number}>()
-	tapping = new WeakMap<object, {events: number[]}>()
+	holding = new Map<object, {start: number}>()
+	tapping = new Map<object, {
+		wasDown: boolean
+		startedAt: number | null
+		count: number
+	}>()
 }
 

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

@@ -1,6 +1,6 @@
 
 import {remap} from "@benev/math"
-import {arraylimit, guarantee, isNumber, isString} from "@e280/stz"
+import {guarantee, isHappy, isNumber, isString} from "@e280/stz"
 
 import {isDown} from "../utils/is-down.js"
 import {EvaluationContext} from "./context.js"
@@ -8,27 +8,31 @@ import type {Expression} from "../expression.js"
 
 export function evaluate(
 		context: EvaluationContext,
-		id: number,
 		expression: Expression,
 	): number {
 
-	const e = (expression: Expression) => evaluate(context, id, expression)
+	const e = (expression: Expression) => evaluate(context, expression)
+
+	if (expression === null)
+		return 0
 
 	if (isNumber(expression))
 		return expression
 
-	else if (isString(expression))
-		return context.latestValues.get(expression) ?? 0
+	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 subexpression = expression[1]
-			const total = (context.accumulated.get(expression) ?? 0) + e(subexpression)
-			context.accumulated.set(expression, total)
-			return total
-		}
-
-		case "sum": {
 			const code = expression[1]
 			let x = 0
 			for (const sample of context.recentSamples) {
@@ -80,7 +84,7 @@ export function evaluate(
 			const [, condition, yes, no] = expression
 			return e(condition)
 				? e(yes)
-				: (no ? e(no) : 0)
+				: (isHappy(no) ? e(no) : 0)
 		}
 
 		case "min":
@@ -123,6 +127,14 @@ export function evaluate(
 		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)
@@ -136,8 +148,8 @@ export function evaluate(
 		}
 
 		case "remap": {
-			const [, a, b, c, d, expr] = expression
-			return remap(e(expr), e(a), e(b), e(c), e(d))
+			const [a, b, c, d, value] = expression.slice(1).map(e)
+			return remap(value, a, b, c, d)
 		}
 
 		case "dt":
@@ -169,27 +181,58 @@ export function evaluate(
 
 		case "taps": {
 			const [, taps, ms, subexpression] = expression
-			const presses = e(subexpression)
+			const down = isDown(e(subexpression))
 			const now = context.clock.time
 
-			const tapped = guarantee(context.tapping, expression, () => ({
-				events: [] as number[],
+			const state = guarantee(context.tapping, expression, () => ({
+				wasDown: false,
+				startedAt: null as number | null,
+				count: 0,
 			}))
 
-			for (let i = 0; i < presses; i++)
-				tapped.events.push(now)
+			const pressed = down && !state.wasDown
+			const released = !down && state.wasDown
 
-			tapped.events = arraylimit(
-				tapped.events.filter(time => time >= now - ms),
-				128,
-			)
+			if (state.startedAt !== null && now - state.startedAt >= ms) {
+				state.startedAt = null
+				state.count = 0
+			}
 
-			if (tapped.events.length >= taps) {
-				tapped.events = []
-				return 1
+			let result = 0
+
+			if (pressed && state.startedAt === null)
+				state.startedAt = now
+
+			if (released && state.startedAt !== null) {
+				state.count++
+
+				if (state.count === taps) {
+					result = 1
+					state.count = 0
+					state.startedAt = null
+				}
 			}
 
-			return 0
+			state.wasDown = down
+			return result
+		}
+
+		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:

package/s/lib/input/expression.ts

@@ -1,26 +1,25 @@
 
 export type Expression = (
+	| null
 	| number // constants for doing math.
 
-	// special
-	| ["accumulate", Expression] // add each frame's result to a running total.
-
 	// samplers
 	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
-	| ["sum", string] // sum values this frame.
+	| ["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]
+	| ["if", condition: Expression, yes: Expression, no?: Expression | null]
 
 	// combiners
 	| ["min", ...Expression[]]
 	| ["max", ...Expression[]]
 	| ["+", ...Expression[]]
 	| ["*", ...Expression[]]
+	| ["mod", ...("shift" | "ctrl" | "meta" | "alt")[]]
 
 	// comparisons
 	| ["==", Expression, Expression]
@@ -33,6 +32,7 @@ export type 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]
 

package/s/lib/input/investigate/hash-bindings.ts

@@ -1,6 +1,7 @@
 
-import {hash32} from "@e280/stz"
+import {hex} from "@e280/stz"
 import {Bindings} from "../types.js"
+import {hash} from "../../utils/hash.js"
 import {isExpression} from "./is-expression.js"
 
 export function hashBindings(bindings: Bindings) {
@@ -8,7 +9,7 @@ export function hashBindings(bindings: Bindings) {
 
 	function recurse(b: Bindings, path: string[]) {
 		if (isExpression(b)) {
-			paths.push(path.join("."))
+			paths.push(JSON.stringify(path))
 		}
 		else {
 			for (const [key, value] of Object.entries(b))
@@ -17,6 +18,7 @@ export function hashBindings(bindings: Bindings) {
 	}
 
 	recurse(bindings, ["b"])
-	return hash32(...paths)
+	paths.sort()
+	return hex(hash("tact/bindings/v1", ...paths).slice(16))
 }
 

package/s/lib/input/investigate/investigate.ts

@@ -5,31 +5,46 @@ import {Expression} from "../expression.js"
 import {hashBindings} from "./hash-bindings.js"
 import {isExpression} from "./is-expression.js"
 import {Bindings, Input, Inputs} from "../types.js"
+import {minihash} from "../data/intent/minihash.js"
 
 export function investigate<B extends Bindings>(bindings: B) {
 	const hash = hashBindings(bindings)
-	const inputList: Input[] = []
-	const rootList: Expression[] = []
 
-	function makeInputs(b: Bindings): unknown {
+	const leaves: {
+		path: string
+		input: Input
+		expression: Expression
+	}[] = []
+
+	function makeInputs(b: Bindings, path: string[]): unknown {
 		if (isExpression(b)) {
 			const input = makeInput()
-			inputList.push(input)
-			rootList.push(b)
+			leaves.push({
+				path: JSON.stringify(path),
+				input,
+				expression: b,
+			})
 			return input
 		}
 		else {
-			return obmap(b, makeInputs)
+			return obmap(b, (value, key) =>
+				makeInputs(value, [...path, key as string])
+			)
 		}
 	}
 
-	const inputs = makeInputs(bindings) as Inputs<B>
+	const inputs = makeInputs(bindings, ["b"]) as Inputs<B>
+
+	leaves.sort((a, b) =>
+		a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+	)
 
 	return {
 		hash,
+		minihash: minihash(hash),
 		inputs,
-		inputList,
-		rootList,
+		inputList: leaves.map(l => l.input),
+		rootList: leaves.map(l => l.expression),
 	}
 }
 

package/s/lib/input/investigate/is-expression.ts

@@ -4,6 +4,7 @@ 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

package/s/lib/input/investigate/make-input.ts

@@ -2,10 +2,6 @@
 import {Input} from "../types.js"
 
 export function makeInput(): Input {
-	return {
-		value: 0,
-		was: 0,
-		delta: 0,
-	}
+	return {value: 0, was: 0, sum: 0}
 }
 

package/s/lib/input/sources/gamepad.ts

@@ -1,7 +1,6 @@
 
 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>()
@@ -34,21 +33,16 @@ export class GamepadSource extends PlainSource {
 
 		for (const [index, button] of gamepad.buttons.entries()) {
 			const value = button.value
-			const i = index + 1
-			this.#publish(`gamepad.button.${i}`, value)
+			this.#publish(`gamepad.${index + 1}`, value)
 			any = Math.max(any, value)
 		}
 
-		this.#publish("gamepad.button.any", any)
+		this.#publish("gamepad.any", any >= 0.9 ? 1 : 0)
 	}
 
 	#pollAxes(gamepad: Gamepad) {
 		for (const [index, value] of gamepad.axes.entries()) {
-			const i = index + 1
-			const [pos, neg] = splitAxis(value)
-			this.#publish(`gamepad.axis.${i}`, value)
-			this.#publish(`gamepad.axis.${i}.neg`, neg)
-			this.#publish(`gamepad.axis.${i}.pos`, pos)
+			this.#publish(`gamepad.axis.${index + 1}`, value)
 		}
 	}
 }