@benev/tact 0.4.0-0 → 0.4.0-1

package/s/_archive/device/stick.ts

@@ -1,24 +0,0 @@
-
-import {Vec2} from "@benev/math"
-import {derived, signal} from "@e280/strata"
-import {Device, Sample} from "../core/types.js"
-import {splitVector} from "../utils/split-axis.js"
-
-export class StickDevice implements Device {
-	$vector = signal(Vec2.zero())
-	$breakdown = derived(() => splitVector(this.$vector()))
-
-	constructor(public channel = "stick") {}
-
-	samples() {
-		const {channel} = this
-		const {up, down, left, right} = this.$breakdown()
-		return [
-			[`${channel}.up`, up],
-			[`${channel}.down`, down],
-			[`${channel}.left`, left],
-			[`${channel}.right`, right],
-		] as Sample[]
-	}
-}
-

package/s/_archive/index-ui.ts

@@ -1,3 +0,0 @@
-
-export * from "./ui/views/desk/view.js"
-

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

@@ -1,61 +0,0 @@
-
-import {deep} from "@e280/stz"
-import {Sample} from "../sampling/types.js"
-import {IntentResolver} from "./utils/intent-resolver.js"
-import {ActionResolver} from "./utils/action-resolver.js"
-import {investigateBindings} from "./utils/investigate.js"
-import {Actions, Bindings, Rebindings, Intent} from "./types.js"
-
-export class Resolver<B extends Bindings> {
-	#bindings
-	#hash
-	#actionlist
-	#expressionlist
-
-	#intentResolver = new IntentResolver()
-	#actionResolver = new ActionResolver()
-
-	readonly actions
-
-	constructor(bindings: B) {
-		const investigation = investigateBindings(bindings)
-		this.#bindings = deep.freeze(bindings) as any as Rebindings<B>
-		this.#hash = investigation.hash
-		this.actions = investigation.actions
-		this.#actionlist = investigation.actionlist
-		this.#expressionlist = investigation.expressionlist
-	}
-
-	get bindings() {
-		return this.#bindings
-	}
-
-	set bindings(bindings: Rebindings<B>) {
-		const investigation = investigateBindings(bindings)
-
-		if (investigation.hash !== this.#hash)
-			throw new Error("newly set bindings are not compatible, hash mismatch")
-
-		this.#bindings = deep.freeze(bindings)
-		this.#expressionlist = investigation.expressionlist
-	}
-
-	resolveIntent(samples: Sample[], now = performance.now()): Intent {
-		return this.#intentResolver.resolve(
-			this.#hash,
-			this.#expressionlist,
-			samples,
-			now,
-		)
-	}
-
-	resolveActions(intent: Intent): Actions<B> {
-		this.#actionResolver.resolve(
-			this.#hash,
-			this.#actionlist,
-			intent,
-		)
-		return this.actions
-	}
-}
-

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

@@ -1,67 +0,0 @@
-
-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

@@ -1,51 +0,0 @@
-
-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

@@ -1,162 +0,0 @@
-
-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

@@ -1,22 +0,0 @@
-
-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

@@ -1,50 +0,0 @@
-
-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

@@ -1,52 +0,0 @@
-
-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

@@ -1,47 +0,0 @@
-
-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-down.ts

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

package/s/_archive/lib/bindings/utils/is-expression.ts

@@ -1,11 +0,0 @@
-
-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

@@ -1,12 +0,0 @@
-
-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

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

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

@@ -1,63 +0,0 @@
-
-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

@@ -1,52 +0,0 @@
-
-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()
-		},
-	}
-}
-