@benev/tact 0.3.0-4 → 0.4.0-0

package/s/_archive/lib/bindings/types.ts

@@ -0,0 +1,67 @@
+
+export type Intent = ArrayBuffer
+
+/** schema and dsl for controls and keybinds. */
+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", a: Expression | null, b: Expression | null, Expression]
+	| ["remap", [a: Expression, b: Expression], [c: Expression, d: Expression], Expression]
+
+	// temporal
+	| ["dt"] // delta time in seconds since last resolve, used for stick sensitivity
+	| ["accumulate", string] // sum all values of this expression since last resolve
+	| ["tapped", ms: number, taps: number, Expression]
+	| ["held", ms: number, Expression]
+)
+
+export type Action = {
+	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 Actions<B extends Bindings = any> = (
+	B extends Expression
+		? Action
+		: B extends {[key: string]: Bindings}
+			? {[K in keyof B]: Actions<B[K]>}
+			: never
+)
+

package/s/_archive/lib/bindings/utils/action-resolver.ts

@@ -0,0 +1,51 @@
+
+import {isDown} from "./is-down.js"
+import {Action, Intent} from "../types.js"
+import {decodeIntent} from "./intent-coding.js"
+
+export class ActionResolver {
+	resolve(hash: number, actions: Action[], intent: Intent) {
+		const decoded = decodeIntent(intent)
+
+		if (decoded.hash !== hash)
+			throw new Error("intent bindings hash mismatch")
+
+		for (const action of actions) {
+			action.previous = action.value
+
+			action.change = 0
+			action.down = 0
+			action.up = 0
+
+			action.lowest = action.value
+			action.highest = action.value
+		}
+
+		for (const {id, value} of decoded.intentions) {
+			const action = actions[id]
+
+			if (!action)
+				throw new Error(`unknown action id ${id}`)
+
+			this.#apply(action, value)
+		}
+	}
+
+	#apply(action: Action, value: number) {
+		const previous = action.value
+
+		action.value = value
+		action.lowest = Math.min(action.lowest, value)
+		action.highest = Math.max(action.highest, value)
+
+		if (value !== previous)
+			action.change = 1
+
+		if (!isDown(previous) && isDown(value))
+			action.down = 1
+
+		if (isDown(previous) && !isDown(value))
+			action.up = 1
+	}
+}
+

package/s/_archive/lib/bindings/utils/evaluator.ts

@@ -0,0 +1,162 @@
+
+import {remap} from "@benev/math"
+import {guarantee} from "@e280/stz"
+import {isDown} from "./is-down.js"
+import {Expression} from "../types.js"
+import {Sample} from "../../sampling/types.js"
+
+export class Evaluator {
+	#now = 0
+	#last: number | undefined
+	#since = 0
+	#samples: Sample[] = []
+	#values = new Map<string, number>()
+	#held = new WeakMap<object, {start: number}>()
+	#tapped = new WeakMap<object, {previous: number, events: number[]}>()
+
+	update(now: number, samples: Sample[]) {
+		this.#now = now
+		this.#since = this.#last === undefined
+			? 0
+			: now - this.#last
+		this.#last = now
+		this.#samples = samples
+		for (const sample of samples)
+			this.#values.set(sample.code, sample.value)
+	}
+
+	evaluate = (exp: Expression): number => {
+		const e = this.evaluate.bind(this)
+
+		if (typeof exp === "number")
+			return exp
+
+		else if (typeof exp === "string")
+			return this.#values.get(exp) ?? 0
+
+		else switch (exp[0]) {
+			case "min":
+				return Math.min(...exp.slice(1).map(e))
+
+			case "max":
+				return Math.max(...exp.slice(1).map(e))
+
+			case "+":
+				return exp.slice(1)
+					.map(e)
+					.reduce((p, c) => p + c, 0)
+
+			case "*":
+				return exp.slice(1)
+					.map(e)
+					.reduce((p, c) => p * c, 1)
+
+			case "!":
+				return +(e(exp[1]) === 0)
+
+			case "!!":
+				return +(e(exp[1]) !== 0)
+
+			case "==":
+				return +(e(exp[1]) === e(exp[2]))
+
+			case "!=":
+				return +(e(exp[1]) !== e(exp[2]))
+
+			case ">":
+				return +(e(exp[1]) > e(exp[2]))
+
+			case "<":
+				return +(e(exp[1]) < e(exp[2]))
+
+			case ">=":
+				return +(e(exp[1]) >= e(exp[2]))
+
+			case "<=":
+				return +(e(exp[1]) <= e(exp[2]))
+
+			case "clamp": {
+				const [, min, max, expr] = exp
+				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] = exp
+				return remap(e(expr), e(a), e(b), e(c), e(d))
+			}
+
+			case "dt":
+				return this.#since / 1000
+
+			case "accumulate": {
+				const [, subexpression] = exp
+				let total = 0
+				for (const sample of this.#samples)
+					if (sample.code === subexpression)
+						total += sample.value
+				return total
+			}
+
+			case "held": {
+				const [, ms, subexpression] = exp
+				const down = isDown(e(subexpression))
+				let held = this.#held.get(exp)
+
+				if (down && !held) {
+					held = {start: this.#now}
+					this.#held.set(exp, held)
+				}
+
+				if (!down && held) {
+					held = undefined
+					this.#held.delete(exp)
+				}
+
+				if (held) {
+					const timeHeld = this.#now - held.start
+					if (timeHeld >= ms)
+						return 1
+				}
+
+				return 0
+			}
+
+			case "tapped": {
+				const [, ms, n, subexpression] = exp
+				const value = e(subexpression)
+				const tapped = guarantee(this.#tapped, exp, () => ({
+					previous: 0,
+					events: [],
+				}))
+
+				const nowDown = isDown(value)
+				const wasDown = isDown(tapped.previous)
+				tapped.previous = value
+
+				if (nowDown && !wasDown) {
+					tapped.events.push(this.#now)
+					tapped.events = tapped.events.filter(time => time >= (this.#now - ms))
+					while (tapped.events.length > 1024)
+						tapped.events.shift()
+					if (tapped.events.length >= n) {
+						tapped.events = []
+						return 1
+					}
+				}
+
+				return 0
+			}
+
+			default:
+				throw new Error("unknown expression")
+		}
+	}
+}
+

package/s/_archive/lib/bindings/utils/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/lib/bindings/utils/intent-coding.ts

@@ -0,0 +1,50 @@
+
+const endian = false
+const sizeHash = 4
+const sizeId = 2
+const sizeValue = 4
+const sizeIntention = sizeId + sizeValue
+
+type Intention = {id: number, value: number}
+
+export function encodeIntent(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 decodeIntent(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/lib/bindings/utils/intent-resolver.ts

@@ -0,0 +1,52 @@
+
+import {Evaluator} from "./evaluator.js"
+import {Sample} from "../../sampling/types.js"
+import {Expression, Intent} from "../types.js"
+import {encodeIntent} from "./intent-coding.js"
+
+export class IntentResolver {
+	#seen: Sample | undefined
+	#evaluator = new Evaluator()
+	#previousEvaluationResults: number[] | undefined
+
+	/** compute bindings dsl against sample history, producing intent bytes that are good for netcode. */
+	resolve(hash: number, expressionlist: Expression[], samples: Sample[], now: number): Intent {
+		const evaluator = this.#evaluator
+		const intentions: {id: number, value: number}[] = []
+
+		// initialize previous with zeros
+		if (!this.#previousEvaluationResults)
+			this.#previousEvaluationResults = expressionlist.map(() => 0)
+
+		// update evaluator
+		evaluator.update(now, this.#selectFresh(samples))
+
+		// evaluate, and save values that changed
+		for (const [id, expression] of expressionlist.entries()) {
+			const previous = this.#previousEvaluationResults[id]
+			const current = evaluator.evaluate(expression)
+			this.#previousEvaluationResults[id] = current
+			if (current !== previous)
+				intentions.push({id, value: current})
+		}
+
+		return encodeIntent(hash, intentions)
+	}
+
+	#selectFresh(samples: Sample[]) {
+		if (this.#seen) {
+			const index = samples.indexOf(this.#seen)
+
+			if (index === -1)
+				throw new Error("sample history gap")
+
+			samples = samples.slice(index + 1)
+		}
+
+		if (samples.length)
+			this.#seen = samples.at(-1)
+
+		return samples
+	}
+}
+

package/s/_archive/lib/bindings/utils/investigate.ts

@@ -0,0 +1,47 @@
+
+import {obMap} from "@e280/stz"
+import {isExpression} from "./is-expression.js"
+import {hashBindings} from "./hash-bindings.js"
+import {Action, Actions, Bindings, Expression} from "../types.js"
+
+export function investigateBindings<B extends Bindings>(bindings: B) {
+	const hash = hashBindings(bindings)
+	const expressionlist: Expression[] = []
+	const actionlist: Action[] = []
+
+	function makeActions(b: Bindings): unknown {
+		if (isExpression(b)) {
+			const action = makeAction()
+			expressionlist.push(b)
+			actionlist.push(action)
+			return action
+		}
+		else {
+			return obMap(b, makeActions)
+		}
+	}
+
+	const actions = makeActions(bindings) as Actions<B>
+
+	return {
+		hash,
+		actions,
+		expressionlist,
+		actionlist,
+	}
+}
+
+function makeAction(): Action {
+	return {
+		value: 0,
+		previous: 0,
+
+		change: 0,
+		down: 0,
+		up: 0,
+
+		lowest: 0,
+		highest: 0,
+	}
+}
+

package/s/_archive/lib/bindings/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/lib/index.ts

@@ -0,0 +1,12 @@
+
+export * from "./sampling/sources/gamepad.js"
+export * from "./sampling/sources/keyboard.js"
+export * from "./sampling/sources/pointer.js"
+export * from "./sampling/sources/stick.js"
+export * from "./sampling/sources/sources.js"
+export * from "./sampling/types.js"
+
+export * from "./utils/pad/on-pad.js"
+export * from "./utils/pad/pad.js"
+export * from "./utils/split-axis.js"
+

package/s/_archive/lib/sampling/sources/example.ts

@@ -0,0 +1,7 @@
+
+import {Sample, Source} from "../types.js"
+
+export class ExampleSource implements Source {
+	samples: Sample[] = []
+}
+

package/s/_archive/lib/sampling/sources/gamepad.ts

@@ -0,0 +1,63 @@
+
+import {Pad} from "../../utils/pad/pad.js"
+import {Sample, Source} from "../types.js"
+import {addSample} from "../utils/add-sample.js"
+import {splitAxis} from "../../utils/split-axis.js"
+
+export class GamepadSource implements Source {
+	#samples: Sample[] = []
+	#values = new Map<string, number>()
+
+	constructor(public pad: Pad) {}
+
+	get samples() {
+		this.#poll()
+		return this.#samples
+	}
+
+	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)
+			addSample(this.#samples, 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/lib/sampling/sources/keyboard.ts

@@ -0,0 +1,52 @@
+
+import {disposer, ev} from "@e280/stz"
+import {Sample, Source} from "../types.js"
+import {addSample} from "../utils/add-sample.js"
+
+export class KeyboardSource implements Source {
+	samples: Sample[] = []
+	dispose = disposer()
+	#down = new Set<string>()
+
+	constructor(target: EventTarget = window) {
+		this.dispose.schedule(ev(target, this.#targetListeners))
+		this.dispose.schedule(ev(window, this.#windowListeners))
+	}
+
+	#publish(code: string, value: number) {
+		addSample(this.samples, code, value)
+	}
+
+	#targetListeners = {
+		keydown: (event: KeyboardEvent) => {
+			if (event.repeat) return
+
+			if (this.#down.size === 0)
+				this.#publish("keyboard.any", 1)
+
+			this.#publish(event.code, 1)
+			this.#down.add(event.code)
+		},
+
+		keyup: (event: KeyboardEvent) => {
+			this.#publish(event.code, 0)
+			this.#down.delete(event.code)
+
+			if (this.#down.size === 0)
+				this.#publish("keyboard.any", 0)
+		},
+	}
+
+	#windowListeners = {
+		blur: () => {
+			for (const code of this.#down)
+				this.#publish(code, 0)
+
+			if (this.#down.size)
+				this.#publish("keyboard.any", 0)
+
+			this.#down.clear()
+		},
+	}
+}
+

package/s/_archive/lib/sampling/sources/pointer.ts

@@ -0,0 +1,56 @@
+
+import {Vec2} from "@benev/math"
+import {disposer, ev} from "@e280/stz"
+import {Sample, Source} from "../types.js"
+import {addSample} from "../utils/add-sample.js"
+import {splitAxis} from "../../utils/split-axis.js"
+import {mouseButton} from "../../utils/mouse-button.js"
+
+export class PointerSource implements Source {
+	samples: Sample[] = []
+	dispose = disposer()
+	client = new Vec2()
+
+	constructor(target: EventTarget = window) {
+		this.dispose.schedule(
+			ev(target, this.#listeners)
+		)
+	}
+
+	#publish(code: string, value: number) {
+		addSample(this.samples, code, value)
+	}
+
+	#listeners = {
+		pointerdown: (event: PointerEvent) => {
+			this.#publish(mouseButton(event.button), 1)
+		},
+
+		pointerup: (event: PointerEvent) => {
+			this.#publish(mouseButton(event.button), 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.#publish("pointer.move.left", left)
+			if (right) this.#publish("pointer.move.right", right)
+			if (up) this.#publish("pointer.move.up", up)
+			if (down) this.#publish("pointer.move.down", down)
+		},
+
+		wheel: (event: WheelEvent) => {
+			const [right, left] = splitAxis(event.deltaX)
+			const [down, up] = splitAxis(event.deltaY)
+
+			if (left) this.#publish("pointer.wheel.left", left)
+			if (right) this.#publish("pointer.wheel.right", right)
+			if (up) this.#publish("pointer.wheel.up", up)
+			if (down) this.#publish("pointer.wheel.down", down)
+		},
+	}
+}
+

package/s/_archive/lib/sampling/sources/sources.ts

@@ -0,0 +1,13 @@
+
+import {Source} from "../types.js"
+
+export class Sources extends Set<Source> {
+	get samples() {
+		return [...this].flatMap(source => source.samples)
+	}
+
+	dispose() {
+		return [...this].forEach(source => source.dispose?.())
+	}
+}
+

package/s/_archive/lib/sampling/sources/stick.ts

@@ -0,0 +1,27 @@
+
+import {Vec2, Xy} from "@benev/math"
+import {Sample, Source} from "../types.js"
+import {addSample} from "../utils/add-sample.js"
+import {splitVector} from "../../utils/split-axis.js"
+
+export class StickSource implements Source {
+	samples: Sample[] = []
+	vector = Vec2.zero()
+
+	constructor(public channel = "stick") {}
+
+	set(vector: Xy) {
+		this.vector.set_(vector.x, vector.y)
+		const {up, down, left, right} = splitVector(this.vector)
+		this.#publish(`${this.channel}.up`, up)
+		this.#publish(`${this.channel}.down`, down)
+		this.#publish(`${this.channel}.left`, left)
+		this.#publish(`${this.channel}.right`, right)
+		return this
+	}
+
+	#publish(code: string, value: number) {
+		addSample(this.samples, code, value)
+	}
+}
+