@benev/tact 0.4.0-0 → 0.4.0-2

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

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

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

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

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

@@ -1,11 +0,0 @@
-
-export type Sample = {
-	code: string
-	value: number
-}
-
-export type Source = {
-	readonly samples: Sample[]
-	dispose?: () => void
-}
-

package/s/_archive/lib/sampling/utils/add-sample.ts

@@ -1,12 +0,0 @@
-
-import {Sample} from "../types.js"
-
-const maxSamples = 1024
-
-export function addSample(samples: Sample[], code: string, value: number) {
-	samples.push({code, value})
-
-	while (samples.length > maxSamples)
-		samples.shift()
-}
-

package/s/_archive/lib/test.ts

@@ -1,57 +0,0 @@
-
-import {expect, run, suite, test} from "@e280/science"
-import {Resolver} from "./bindings/resolver.js"
-import {ExampleSource} from "./sampling/sources/example.js"
-
-await run({
-	resolver: suite({
-		"resolver update bindings": test(async() => {
-			const resolver = new Resolver({forward: ["max", "KeyW", "ArrowUp"]})
-			resolver.bindings = {forward: "KeyW"}
-			expect(resolver).ok()
-		}),
-
-		"multiple resolvers coexist": test(async() => {
-			const source = new ExampleSource()
-			source.samples = [
-				{code: "KeyW", value: 0},
-				{code: "KeyW", value: 1},
-			]
-			const resolverA = new Resolver({forward: "KeyW"})
-			const resolverB = new Resolver({forward: "KeyW"})
-			resolverA.resolveActions(resolverA.resolveIntent(source.samples, 1))
-			resolverB.resolveActions(resolverB.resolveIntent(source.samples, 1))
-			expect(resolverA.actions.forward.value).is(1)
-			expect(resolverB.actions.forward.value).is(1)
-
-			source.samples.push({code: "KeyW", value: 0})
-
-			resolverA.resolveActions(resolverA.resolveIntent(source.samples, 2))
-			expect(resolverA.actions.forward.value).is(0)
-
-			resolverB.resolveActions(resolverB.resolveIntent(source.samples, 2))
-			expect(resolverB.actions.forward.value).is(0)
-		}),
-
-		"samples to actions": test(async() => {
-			const resolver = new Resolver({forward: "KeyW"})
-			const {forward} = resolver.actions
-			const source = new ExampleSource()
-			source.samples = [
-				{code: "KeyW", value: 0},
-				{code: "KeyW", value: 1},
-			]
-
-			resolver.resolveActions(resolver.resolveIntent(source.samples, 3))
-			expect(forward).deep({value: 1, previous: 0, change: 1, down: 1, up: 0, lowest: 0, highest: 1})
-
-			resolver.resolveActions(resolver.resolveIntent(source.samples, 4))
-			expect(forward).deep({value: 1, previous: 1, change: 0, down: 0, up: 0, lowest: 1, highest: 1})
-
-			source.samples.push({code: "KeyW", value: 0})
-			resolver.resolveActions(resolver.resolveIntent(source.samples, 6))
-			expect(forward).deep({value: 0, previous: 1, change: 1, down: 0, up: 1, lowest: 0, highest: 1})
-		}),
-	}),
-})
-

package/s/_archive/lib/utils/backwards.ts

@@ -1,6 +0,0 @@
-
-export function* backwards<X>(items: X[]) {
-	for (let i = items.length - 1; i >= 0; i--)
-		yield items[i]
-}
-

package/s/_archive/lib/utils/evergreen.ts

@@ -1,10 +0,0 @@
-
-export function evergreen<V>(value: V, fn: () => V | null | undefined) {
-	let cached = value
-	return () => {
-		const next = fn()
-		if (next !== undefined && next !== null) cached = next
-		return cached
-	}
-}
-

package/s/_archive/lib/utils/mouse-button.ts

@@ -1,10 +0,0 @@
-
-export function mouseButton(button: number) {
-	switch (button) {
-		case 0: return "pointer.button.left"
-		case 1: return "pointer.button.middle"
-		case 2: return "pointer.button.right"
-		default: return `pointer.button.${button + 1}`
-	}
-}
-

package/s/_archive/lib/utils/pad/on-pad.ts

@@ -1,50 +0,0 @@
-
-import {ev} from "@e280/stz"
-import {Pad} from "./pad.js"
-import {evergreen} from "../../utils/evergreen.js"
-
-/** listen for gamepads coming and going */
-export function onPad(fn: (pad: Pad) => () => void) {
-	const known = new Map<number, {pad: Pad, dispose: () => void}>()
-
-	function refresh() {
-		addNew()
-		deleteOld()
-	}
-
-	function addNew() {
-		for (const gamepad of navigator.getGamepads()) {
-			if (gamepad?.connected && !known.has(gamepad.index)) {
-				const get = () => navigator.getGamepads()[gamepad.index]
-				const pad = new Pad(evergreen(gamepad, get))
-				const dispose = fn(pad)
-				known.set(gamepad.index, {pad, dispose})
-			}
-		}
-	}
-
-	function deleteOld() {
-		for (const [index, {pad, dispose}] of known) {
-			const gamepad = navigator.getGamepads()[pad.gamepad.index]
-			if (!gamepad?.connected) {
-				dispose()
-				known.delete(index)
-			}
-		}
-	}
-
-	refresh()
-
-	const unlisten = ev(window, {
-		gamepadconnected: refresh,
-		gamepaddisconnected: refresh,
-	})
-
-	return () => {
-		unlisten()
-		for (const {dispose} of known.values())
-			dispose()
-		known.clear()
-	}
-}
-

package/s/_archive/lib/utils/pad/pad.ts

@@ -1,10 +0,0 @@
-
-/** stable reference to a gamepad, has a getter to get the latest gamepad snapshot */
-export class Pad {
-	constructor(private get: () => Gamepad) {}
-
-	get gamepad() {
-		return this.get()
-	}
-}
-

package/s/_archive/lib/utils/split-axis.ts

@@ -1,15 +0,0 @@
-
-import {Xy} from "@benev/math"
-
-export function splitAxis(n: number) {
-	return (n >= 0)
-		? [n, 0]
-		: [0, Math.abs(n)]
-}
-
-export function splitVector(vector: Xy) {
-	const [right, left] = splitAxis(vector.x)
-	const [down, up] = splitAxis(vector.y)
-	return {up, down, left, right}
-}
-

package/s/_archive/lib2/core/decoder/decoder.ts

@@ -1,34 +0,0 @@
-
-import {decodeData} from "../utils/data.js"
-import {updateInput} from "./utils/update-input.js"
-import {Inputs, Bindings, InputData} from "../types.js"
-import {investigate} from "../encoder/parts/investigate.js"
-
-export class InputDecoder<B extends Bindings> {
-	#investigation
-
-	constructor(bindings: B) {
-		this.#investigation = investigate(bindings)
-	}
-
-	get inputs() {
-		return this.#investigation.inputs
-	}
-
-	resolve(data: InputData): Inputs<B> {
-		const {hash, inputList} = this.#investigation
-		const decoded = decodeData(data)
-
-		if (decoded.hash !== hash)
-			throw new Error("intent bindings hash mismatch")
-
-		for (const {id, value} of decoded.intentions) {
-			const input = inputList[id]
-			if (!input) throw new Error(`unknown action id ${id}`)
-			updateInput(input, value)
-		}
-
-		return this.inputs
-	}
-}
-

package/s/_archive/lib2/core/decoder/utils/update-input.ts

@@ -1,21 +0,0 @@
-
-import {Input} from "../../types.js"
-import {isDown} from "../../utils/is-down.js"
-
-export function updateInput(input: Input, value: number) {
-	const previous = input.value
-
-	input.value = value
-	input.lowest = Math.min(input.lowest, value)
-	input.highest = Math.max(input.highest, value)
-
-	if (value !== previous)
-		input.change = 1
-
-	if (!isDown(previous) && isDown(value))
-		input.down = 1
-
-	if (isDown(previous) && !isDown(value))
-		input.up = 1
-}
-

package/s/_archive/lib2/core/encoder/encoder.ts

@@ -1,60 +0,0 @@
-
-import {deep} from "@e280/stz"
-import {Sampler} from "./parts/sampler.js"
-import {evaluate} from "./evaluate/evaluate.js"
-import {investigate} from "./parts/investigate.js"
-import {encodeData, Intention} from "../utils/data.js"
-import {EvaluationContext} from "./evaluate/context.js"
-import {Bindings, InputData, Rebindings, Source} from "../types.js"
-
-export class InputEncoder<B extends Bindings> {
-	#sampler
-	#bindings
-	#investigation
-	#context
-
-	constructor(source: Source, bindings: B) {
-		this.#bindings = deep.freeze(deep.clone(bindings)) as any as Rebindings<B>
-		this.#investigation = investigate(this.#bindings)
-		this.#sampler = new Sampler(source)
-		this.#context = new EvaluationContext()
-	}
-
-	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.expressionList = fresh.expressionList
-	}
-
-	encode(): InputData {
-		this.#context.start()
-		const intentions: Intention[] = []
-		const samples = this.#sampler.take()
-
-		for (const sample of samples) {
-			this.#context.update(sample)
-
-			const indexed = this.#investigation.expressionIndex.get(sample.code)
-			const expressions = [...indexed ?? []]
-
-			for (const {id, expression} of expressions) {
-				const value = evaluate(this.#context, expression)
-				intentions.push({id, value})
-			}
-		}
-
-		return encodeData(this.#investigation.hash, intentions)
-	}
-
-	dispose() {
-		return this.#sampler.dispose()
-	}
-}
-

package/s/_archive/lib2/core/encoder/evaluate/context.ts

@@ -1,22 +0,0 @@
-
-import {Sample} from "../../types.js"
-
-export class EvaluationContext {
-	sample!: Sample
-	since = 0
-	last: number | undefined
-
-	held = new WeakMap<object, {start: number}>()
-	tapped = new WeakMap<object, {previous: number, events: number[]}>()
-	accumulations = new Map<object, {value: number}>()
-
-	start() {
-		this.accumulations.clear()
-	}
-
-	update(sample: Sample) {
-		this.since = sample.time - (this.last ?? sample.time)
-		this.last = sample.time
-	}
-}
-

package/s/_archive/lib2/core/encoder/evaluate/evaluate.ts

@@ -1,144 +0,0 @@
-
-import {remap} from "@benev/math"
-import {arraylimit, guarantee, is} 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,
-		expression: Expression,
-	): number {
-
-	const e = (expression: Expression) => evaluate(context, expression)
-
-	if (is.number(expression))
-		return expression
-
-	else if (is.string(expression))
-		return context.sample.value
-
-	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":
-			return context.since / 1000
-
-		case "accumulate": {
-			const [, subexpression] = expression
-			const accumulation = guarantee(context.accumulations, expression, () => ({value: 0}))
-			accumulation.value += e(subexpression)
-			return accumulation.value
-		}
-
-		case "held": {
-			const [, ms, subexpression] = expression
-			const down = isDown(e(subexpression))
-			let held = context.held.get(expression)
-
-			if (down && !held) {
-				held = {start: context.sample.time}
-				context.held.set(expression, held)
-			}
-
-			if (!down && held) {
-				held = undefined
-				context.held.delete(expression)
-			}
-
-			if (held) {
-				const timeHeld = context.sample.time - held.start
-				if (timeHeld >= ms)
-					return 1
-			}
-
-			return 0
-		}
-
-		case "tapped": {
-			const [, ms, n, subexpression] = expression
-			const value = e(subexpression)
-			const tapped = guarantee(context.tapped, expression, () => ({
-				previous: 0,
-				events: [],
-			}))
-
-			const nowDown = isDown(value)
-			const wasDown = isDown(tapped.previous)
-			tapped.previous = value
-
-			if (nowDown && !wasDown) {
-				tapped.events.push(context.sample.time)
-				tapped.events = arraylimit(
-					tapped.events.filter(time => time >= (context.sample.time - ms)),
-					1024,
-				)
-				if (tapped.events.length >= n) {
-					tapped.events = []
-					return 1
-				}
-			}
-
-			return 0
-		}
-
-		default:
-			throw new Error("unknown expression")
-	}
-}
-

package/s/_archive/lib2/core/encoder/parts/expression-index.ts

@@ -1,27 +0,0 @@
-
-import {guarantee, is} from "@e280/stz"
-import {Expression} from "../../types.js"
-
-export function makeExpressionIndex(expressionlist: Expression[]) {
-	type Code = string
-	type Info = {id: number, expression: Expression}
-	const expressionIndex = new Map<Code, Set<Info>>()
-
-	function recurse(info: {id: number, expression: Expression}, e: Expression) {
-		if (is.string(e)) {
-			guarantee(expressionIndex, e, () => new Set())
-				.add(info)
-		}
-		else if (is.array(e)) {
-			for (const sub of e.slice(1))
-				if (sub !== null)
-					recurse(info, sub)
-		}
-	}
-
-	for (const [id, expression] of expressionlist.entries())
-		recurse({id, expression}, expression)
-
-	return expressionIndex
-}
-

package/s/_archive/lib2/core/encoder/parts/hash-bindings.ts

@@ -1,22 +0,0 @@
-
-import {hash32} from "@e280/stz"
-import {Bindings} from "../../types.js"
-import {isExpression} from "../../utils/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/lib2/core/encoder/parts/investigate.ts

@@ -1,50 +0,0 @@
-
-import {obMap} from "@e280/stz"
-import {hashBindings} from "./hash-bindings.js"
-import {isExpression} from "../../utils/is-expression.js"
-import {makeExpressionIndex} from "./expression-index.js"
-import {Bindings, Expression, Input, Inputs} from "../../types.js"
-
-export function investigate<B extends Bindings>(bindings: B) {
-	const hash = hashBindings(bindings)
-	const inputList: Input[] = []
-	const expressionList: Expression[] = []
-
-	function makeInputs(b: Bindings): unknown {
-		if (isExpression(b)) {
-			const input = makeInput()
-			inputList.push(input)
-			expressionList.push(b)
-			return input
-		}
-		else {
-			return obMap(b, makeInputs)
-		}
-	}
-
-	const inputs = makeInputs(bindings) as Inputs<B>
-	const expressionIndex = makeExpressionIndex(expressionList)
-
-	return {
-		hash,
-		inputs,
-		inputList,
-		expressionList,
-		expressionIndex,
-	}
-}
-
-function makeInput(): Input {
-	return {
-		value: 0,
-		previous: 0,
-
-		change: 0,
-		down: 0,
-		up: 0,
-
-		lowest: 0,
-		highest: 0,
-	}
-}
-