@benev/tact 0.4.0-0 → 0.4.0-10

package/s/_archive/lib3/input/sources/pointer.ts

@@ -1,58 +0,0 @@
-
-import {ev} from "@e280/stz"
-import {Vec2} from "@benev/math"
-import {PlainSource} from "./plain.js"
-import {splitAxis} from "../utils/split-axis.js"
-import {mouseButton} from "../utils/mouse-button.js"
-
-export class PointerSource extends PlainSource {
-	client = new Vec2()
-
-	constructor(target: EventTarget = window) {
-		super()
-		this.dispose.schedule(
-			ev(target, this.#listeners)
-		)
-	}
-
-	#publishSticky(code: string, value: number) {
-		this.onSample.publish({code, value, mode: "sticky"})
-	}
-
-	#publishPulse(code: string, value: number) {
-		this.onSample.publish({code, value, mode: "pulse"})
-	}
-
-	#listeners = {
-		pointerdown: (event: PointerEvent) => {
-			this.#publishSticky(mouseButton(event.button), 1)
-		},
-
-		pointerup: (event: PointerEvent) => {
-			this.#publishSticky(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.#publishPulse("pointer.move.left", left)
-			if (right) this.#publishPulse("pointer.move.right", right)
-			if (up) this.#publishPulse("pointer.move.up", up)
-			if (down) this.#publishPulse("pointer.move.down", down)
-		},
-
-		wheel: (event: WheelEvent) => {
-			const [right, left] = splitAxis(event.deltaX)
-			const [down, up] = splitAxis(event.deltaY)
-
-			if (left) this.#publishPulse("pointer.wheel.left", left)
-			if (right) this.#publishPulse("pointer.wheel.right", right)
-			if (up) this.#publishPulse("pointer.wheel.up", up)
-			if (down) this.#publishPulse("pointer.wheel.down", down)
-		},
-	}
-}
-

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

@@ -1,24 +0,0 @@
-
-import {Source} from "../types.js"
-import {PlainSource} from "./plain.js"
-
-export class Sources extends PlainSource {
-	#array
-
-	constructor(...sources: Source[]) {
-		super()
-
-		this.#array = sources
-
-		for (const source of sources)
-			this.dispose.schedule(
-				source.onSample(sample => this.onSample.publish(sample))
-			)
-	}
-
-	poll() {
-		for (const source of this.#array)
-			source.poll?.()
-	}
-}
-

package/s/_archive/lib3/input/sources/stick.ts

@@ -1,29 +0,0 @@
-
-import {Vec2, Xy} from "@benev/math"
-import {Sample} from "../types.js"
-import {PlainSource} from "./plain.js"
-import {splitVector} from "../utils/split-axis.js"
-
-export class StickSource extends PlainSource {
-	samples: Sample[] = []
-	vector = Vec2.zero()
-
-	constructor(public channel = "stick") {
-		super()
-	}
-
-	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) {
-		this.onSample.publish({code, value, mode: "sticky"})
-	}
-}
-

package/s/_archive/lib3/input/testing/quickbind.ts

@@ -1,20 +0,0 @@
-
-import {InputDecoder} from "../decoder.js"
-import {InputEncoder} from "../encoder.js"
-import {Bindings, Sample} from "../types.js"
-import {PlainSource} from "../sources/plain.js"
-
-export function quickbind<B extends Bindings>(b: B) {
-	const source = new PlainSource()
-	const encoder = new InputEncoder(source, b)
-	const decoder = new InputDecoder(encoder.bindings)
-
-	const sample = (...samples: Sample[]) =>
-		samples.forEach(s => source.onSample.publish(s))
-
-	const solve = (time?: number) =>
-		decoder.resolve(encoder.encode(time))
-
-	return {source, encoder, decoder, sample, solve}
-}
-

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

@@ -1,96 +0,0 @@
-
-export type Sample = {
-	code: string
-	value: number
-	mode: "sticky" | "pulse"
-}
-
-export type Source = {
-	readonly onSample: (fn: (sample: Sample) => void) => () => void
-	readonly dispose: () => void
-	readonly poll?: () => void
-}
-
-export type Intent = {id: number, value: number}
-
-export type InputData = ArrayBuffer
-
-export type Input = {
-
-	/** latest-known value. */
-	value: number
-
-	/** previously-known value. */
-	was: number
-
-	/** sum of values in batch. */
-	pulses: number
-
-	/** number of times this value has changed in this batch. */
-	change: number
-
-	/** number of changes to up in this batch. */
-	up: number
-
-	/** number of changes to down in this batch. */
-	down: number
-
-	/** lowest value in batch. */
-	lowest: number | null
-
-	/** highest value in batch. */
-	highest: number | null
-}
-
-export type Inputs<B extends Bindings = any> = (
-	B extends Expression
-		? Input
-		: B extends {[key: string]: Bindings}
-			? {[K in keyof B]: Inputs<B[K]>}
-			: never
-)
-
-export type Bindings = Expression | {
-	[key: string]: Bindings
-}
-
-export const asBindings = <B extends Bindings>(bindings: B) => (bindings as any as Rebindings<B>)
-
-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", low: Expression | null, high: Expression | null, Expression]
-	| ["remap", inLow: Expression, inHigh: Expression, outLow: Expression, outHigh: Expression, Expression]
-
-	// temporal
-	| ["dt"] // delta time in seconds since last resolve, used for stick sensitivity
-	| ["taps", taps: number, ms: number, Expression]
-	| ["held", ms: number, Expression]
-)
-

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

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

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

@@ -1,28 +0,0 @@
-
-import {arraylimit} from "@e280/stz"
-import {Sample, Source} from "../types.js"
-
-const limit = 1024
-
-export class Sampler {
-	readonly dispose
-	#source
-	#samples: Sample[] = []
-
-	constructor(source: Source) {
-		this.#source = source
-		this.dispose = source.onSample(sample => {
-			this.#samples.push(sample)
-			if (this.#samples.length > limit) console.warn(`tact sampler exceeded limit ${limit}`)
-			this.#samples = arraylimit(this.#samples, limit)
-		})
-	}
-
-	take() {
-		this.#source.poll?.()
-		const samples = this.#samples
-		this.#samples = []
-		return samples
-	}
-}
-

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

@@ -1,100 +0,0 @@
-
-import {expect, run, suite, test} from "@e280/science"
-import {quickbind} from "./input/testing/quickbind.js"
-
-await run({
-	input: suite({
-		"roundtrip": test(async() => {
-			const {sample, solve} = quickbind("KeyE")
-
-			sample({code: "KeyE", value: 0, mode: "sticky"})
-			expect(solve().value).is(0)
-
-			sample({code: "KeyE", value: 1, mode: "sticky"})
-			const inputs = solve()
-
-			expect(inputs.value).is(1)
-			expect(inputs.was).is(0)
-			expect(inputs.change).is(1)
-		}),
-
-		"encoder dedupes sticky samples": test(async() => {
-			const {sample, encoder} = quickbind("KeyE")
-			sample({code: "KeyE", value: 0, mode: "sticky"})
-			sample({code: "KeyE", value: 1, mode: "sticky"})
-			sample({code: "KeyE", value: 1, mode: "sticky"})
-			const intents = [...encoder.evaluate(2)]
-			expect(intents.length).is(2)
-		}),
-
-		"pulse accumulation": test(async() => {
-			const {sample, solve} = quickbind("pointer.up")
-			sample({mode: "pulse", code: "pointer.up", value: 2})
-			sample({mode: "pulse", code: "pointer.up", value: 3})
-			expect(solve().pulses).is(5)
-			expect(solve().pulses).is(0)
-		}),
-
-		"sticky persists": test(async() => {
-			const {sample, solve} = quickbind(["*", "ShiftLeft", "pointer.up"])
-			sample({mode: "sticky", code: "ShiftLeft", value: 1})
-			solve()
-			sample({mode: "pulse", code: "pointer.up", value: 5})
-			sample({mode: "pulse", code: "pointer.up", value: 3})
-			expect(solve().pulses).is(8)
-		}),
-
-		"pulses don't linger": test(async() => {
-			const {sample, solve} = quickbind(["max", "pointer.up", "gamepad.up"])
-			sample({mode: "pulse", code: "pointer.up", value: 5})
-			sample({mode: "sticky", code: "gamepad.up", value: 2})
-			expect(solve().pulses).is(7)
-		}),
-
-		"pointer and joystick coexist": test(async() => {
-			const {sample, solve} = quickbind(["+", "pointer.up", ["*", ["dt"], "gamepad.up"]])
-			solve(0)
-			sample({mode: "pulse", code: "pointer.up", value: 1})
-			sample({mode: "sticky", code: "gamepad.up", value: 1})
-			sample({mode: "pulse", code: "pointer.up", value: 1})
-			expect(solve(1000).pulses).is(3)
-			expect(solve(2000).pulses).is(1)
-		}),
-
-		"rapid transitions": test(async() => {
-			const {sample, solve} = quickbind("KeyE")
-
-			for (const value of [1, 0, 1])
-				sample({mode: "sticky", code: "KeyE", value})
-
-			const input = solve()
-			expect(input.value).is(1)
-			expect(input.down).is(2)
-			expect(input.up).is(1)
-			expect(input.change).is(3)
-		}),
-
-		"taps and holds don't interfere": test(async() => {
-			const {sample, solve} = quickbind({
-				tapper: ["taps", 1, 10, "KeyE"],
-				holder: ["held", 10, "KeyE"],
-			})
-
-			sample({mode: "sticky", code: "KeyE", value: 0})
-			expect(solve(0).tapper.down).is(0)
-
-			sample({mode: "sticky", code: "KeyE", value: 1})
-			expect(solve(1).tapper.down).is(1)
-
-			sample({mode: "sticky", code: "KeyE", value: 0})
-			const released = solve(2)
-			expect(released.tapper.down).is(0)
-			expect(released.holder.down).is(0)
-
-			sample({mode: "sticky", code: "KeyE", value: 1})
-			expect(solve(3).holder.down).is(0)
-			expect(solve(13).holder.down).is(1)
-		}),
-	}),
-})
-

package/s/_archive/lib4/input/data/decode.ts

@@ -1,25 +0,0 @@
-
-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/lib4/input/data/encode.ts

@@ -1,24 +0,0 @@
-
-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/lib4/input/data/params.ts

@@ -1,7 +0,0 @@
-
-export const endian = false
-export const sizeHash = 4
-export const sizeId = 2
-export const sizeValue = 4
-export const sizeIntention = sizeId + sizeValue
-

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

@@ -1,100 +0,0 @@
-
-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 {isDeltaRoot} from "./investigate/is.js"
-import {EvaluationContext} from "./evaluate/context.js"
-import {investigate} from "./investigate/investigate.js"
-import {Bindings, InputData, Rebindings, RootExpression, Source} from "./types.js"
-
-export class InputEncoder<B extends Bindings = any> {
-	#sampler
-	#bindings
-	#investigation
-	#context
-	#processedIds = new Set<number>()
-	#expressionResults = new Map<number, 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.rootList = fresh.rootList
-		this.#investigation.rootIndex = fresh.rootIndex
-		this.#context = new EvaluationContext()
-		this.#expressionResults.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.#processedIds.clear()
-		this.#context.clock.update(time)
-		this.#context.currentSample = undefined
-		this.#context.dt = this.#context.clock.since
-
-		// evaluate expressions for each sample in order
-		for (const sample of samples) {
-			this.#context.currentSample = sample
-			this.#context.sampleValues.set(sample.code, sample.value)
-			const relevantRoots = got(this.#investigation.rootIndex.get(sample.code))
-
-			for (const {id, root} of relevantRoots) {
-				yield* this.#evaluateRootExpression(id, root)
-			}
-		}
-
-		// make sure 'held' expressions get evaluated every time
-		this.#context.currentSample = undefined
-		for (const id of this.#context.holdyRoots) {
-			if (!this.#processedIds.has(id))
-				yield* this.#evaluateRootExpression(id, this.#investigation.rootList[id])
-		}
-	}
-
-	*#evaluateRootExpression(id: number, root: RootExpression) {
-		const value = evaluate(this.#context, id, root, root)
-		this.#processedIds.add(id)
-
-		if (isDeltaRoot(root)) {
-			if (value !== 0)
-				yield {id, value}
-		}
-		else {
-			const was = this.#expressionResults.get(id)
-			if (value !== was) {
-				this.#expressionResults.set(id, value)
-				yield {id, value}
-			}
-		}
-	}
-
-	#init() {
-		for (const [id, root] of this.#investigation.rootList.entries())
-			evaluate(this.#context, id, root, root)
-	}
-
-	dispose() {
-		return this.#sampler.dispose()
-	}
-}
-

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

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