@benev/tact 0.4.0-0 → 0.4.0-10

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()
-		},
-	}
-}
-

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
-	}
-}
-