@benev/tact 0.3.0-5 → 0.4.0-0

package/s/_archive/lib4/input/utils/pad/on-pad.ts

@@ -0,0 +1,50 @@
+
+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/lib4/input/utils/pad/pad.ts

@@ -0,0 +1,10 @@
+
+/** 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/lib4/input/utils/sampler.ts

@@ -0,0 +1,28 @@
+
+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/lib4/input/utils/split-axis.ts

@@ -0,0 +1,15 @@
+
+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/lib4/test.ts

@@ -0,0 +1,12 @@
+
+import {expect, run, suite, test} from "@e280/science"
+
+await run({
+	input: suite({
+		"roundtrip": test(async() => {
+			//...
+			expect(true).ok()
+		}),
+	}),
+})
+

package/s/_archive/utils/circular-clamp.ts

@@ -1,10 +1,10 @@
 
-import {Scalar, Vec2, Xy} from "@benev/math"
+import {remap, Vec2, Xy} from "@benev/math"
 
 export function circularClamp(vector: Xy, range: Vec2) {
 	const v = Vec2.from(vector)
 	const distance = v.distance_(0, 0)
-	const modifiedDistance = Scalar.remap(
+	const modifiedDistance = remap(
 		distance,
 		range.x, range.y,
 		0, 1,

package/s/_archive/utils/is-down.ts

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

package/s/demo/demo-app/element.ts

@@ -2,15 +2,13 @@
 import {html} from "lit"
 import {shadowElement, useCss} from "@e280/sly"
 import styleCss from "./style.css.js"
-import {Deck} from "../../deck/deck.js"
-import {DeskOptions, DeskView} from "../../ui/views/desk/view.js"
 
-export const setupDemoApp = (deck: Deck, options: DeskOptions = {}) => shadowElement(() => {
+export const setupDemoApp = () => shadowElement(() => {
 	useCss(styleCss)
 
 	return html`
 		<div class=plate>
-			${DeskView(deck, options)}
+			coming soon, lol
 		</div>
 	`
 })

package/s/demo/main.bundle.ts

@@ -1,71 +1,8 @@
 
-import {Content, dom} from "@e280/sly"
-import {LocalStore} from "@e280/strata"
-
-import {Deck} from "../deck/deck.js"
-import {DeckState} from "../deck/types.js"
-import {asBindings} from "../core/types.js"
-import {Devices} from "../device/devices.js"
-import {onPad} from "../device/pad/on-pad.js"
-import {Controller} from "../deck/controller.js"
-import {PointerDevice} from "../device/pointer.js"
-import {GamepadDevice} from "../device/gamepad.js"
+import {dom} from "@e280/sly"
 import {setupDemoApp} from "./demo-app/element.js"
-import {KeyboardDevice} from "../device/keyboard.js"
-
-const bindings = asBindings({
-	play: {
-		action: ["or", "Space", "pointer.button.left", "gamepad.button.1"],
-		up: ["or", "KeyW", "gamepad.axis.2.pos"],
-		down: ["or", "KeyS", "gamepad.axis.2.neg"],
-		left: ["or", "KeyA", "gamepad.axis.1.pos"],
-		right: ["or", "KeyD", "gamepad.axis.1.neg"],
-	},
-})
-
-const store = new LocalStore<DeckState>("tactDeck")
-
-const deck = new Deck({
-	store,
-	stockProfiles: {
-		standard: {label: "📜standard", bindings},
-		micro: {label: "🦠micro", bindings: asBindings<typeof bindings>({
-			play: {
-				action: ["or", "Space", "pointer.button.left", "gamepad.button.1"],
-				up: ["or", "KeyW", "gamepad.axis.2.pos"],
-				down: ["or", "KeyS", "gamepad.axis.2.neg"],
-				left: ["or", "KeyA", "gamepad.axis.1.pos"],
-				right: ["or", "KeyD", "gamepad.axis.1.neg"],
-			},
-		})},
-	},
-})
-
-await deck.load()
-store.onStorageEvent(() => deck.load())
-
-const port = deck.createPort()
-const controller = deck.createController("primary", "standard", new Devices(
-	new KeyboardDevice(),
-	new PointerDevice(),
-))
-
-port.plug(controller)
-
-const labels = new Map<Controller, Content>()
-	.set(controller, "⌨️🖱keyboard+mouse")
-
-onPad(pad => {
-	const handle = `(${pad.gamepad.index + 1}) ${pad.gamepad.id}`
-	const controller = deck.createController(handle, "standard", new GamepadDevice(pad))
-	labels.set(controller, `🎮${handle}`)
-	port.plug(controller)
-	return () => deck.deleteController(controller)
-})
 
 dom.register({
-	DemoApp: setupDemoApp(deck, {
-		getControllerLabel: labels.get.bind(labels),
-	}),
+	DemoApp: setupDemoApp(),
 })
 

package/s/gamepad/gamepad-app/element.ts

@@ -5,29 +5,32 @@ import {RMap, RSet} from "@e280/strata"
 import {shadowElement, useCss, useMount, useOnce} from "@e280/sly"
 
 import styleCss from "./style.css.js"
-import {onPad} from "../../device/pad/on-pad.js"
-import {GamepadDevice} from "../../device/gamepad.js"
+
+import {onPad} from "../../lib/input/utils/pad/on-pad.js"
+import {GamepadSource} from "../../lib/input/sources/gamepad.js"
 
 export const GamepadApp = shadowElement(() => {
 	useCss(styleCss)
 
 	const connected = useOnce(() => new RSet<{
-		device: GamepadDevice
+		source: GamepadSource
 		samples: RMap<string, number>
 	}>())
 
 	useMount(() => onPad(pad => {
-		const device = new GamepadDevice(pad)
-		const connectee = {device, samples: new RMap<string, number>()}
+		const source = new GamepadSource(pad)
+		const connectee = {source, samples: new RMap<string, number>()}
+		const stop = source.onSample(sample => connectee.samples.set(sample.code, sample.value))
 		connected.add(connectee)
-		return () => connected.delete(connectee)
+		return () => {
+			stop()
+			connected.delete(connectee)
+		}
 	}))
 
 	useMount(() => cycle(async() => {
-		for (const conn of connected) {
-			for (const [code, value] of conn.device.samples())
-				conn.samples.set(code, value)
-		}
+		for (const conn of connected)
+			conn.source.poll()
 		await nap(1000 / 60)
 	}))
 
@@ -40,7 +43,7 @@ export const GamepadApp = shadowElement(() => {
 
 	return html`
 		<div class=plate>
-			${connected.size > 0 ? [...connected].map(({samples, device: {gamepad}}) => html`
+			${connected.size > 0 ? [...connected].map(({samples, source: {gamepad}}) => html`
 				<div class=device>
 					<h2>🎮 ${gamepad.id}</h2>
 					<div class=stats>

package/s/lib/index.ts

@@ -0,0 +1,18 @@
+
+export * from "./input/investigate/is-compatible.js"
+
+export * from "./input/sources/gamepad.js"
+export * from "./input/sources/keyboard.js"
+export * from "./input/sources/plain.js"
+export * from "./input/sources/pointer.js"
+export * from "./input/sources/sources.js"
+export * from "./input/sources/stick.js"
+
+export * from "./input/utils/pad/on-pad.js"
+export * from "./input/utils/pad/pad.js"
+export * from "./input/utils/is-down.js"
+
+export * from "./input/encoder.js"
+export * from "./input/decoder.js"
+export * from "./input/types.js"
+

package/s/lib/input/data/decode.ts

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

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

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

package/s/lib/input/decoder.ts

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

package/s/lib/input/encoder.ts

@@ -0,0 +1,64 @@
+
+import {deepFreeze} from "@e280/stz"
+import {Sampler} from "./utils/sampler.js"
+import {encodeData} from "./data/encode.js"
+import {evaluate} from "./evaluate/evaluate.js"
+import {EvaluationContext} from "./evaluate/context.js"
+import {investigate} from "./investigate/investigate.js"
+import {Bindings, InputData, Intent, Rebindings, Source} from "./types.js"
+
+export class InputEncoder<B extends Bindings = any> {
+	#sampler
+	#bindings
+	#investigation
+	#context
+
+	constructor(source: Source, bindings: B) {
+		this.#bindings = deepFreeze(structuredClone(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 bindings = deepFreeze(structuredClone(b)) as Rebindings<B>
+		const fresh = investigate(bindings)
+
+		if (fresh.hash !== this.#investigation.hash)
+			throw new Error("incompatible bindings")
+
+		this.#bindings = bindings
+		this.#investigation.rootList = fresh.rootList
+		this.#context = new EvaluationContext()
+	}
+
+	encode(time = performance.now()): InputData {
+		return encodeData(this.#investigation.hash, [...this.evaluate(time)])
+	}
+
+	*evaluate(time = performance.now()) {
+		const samples = this.#sampler.take()
+
+		this.#context.clock.update(time)
+		this.#context.recentSamples = samples
+		this.#context.dt = this.#context.clock.since / 1000
+
+		for (const {code, value} of samples)
+			this.#context.latestValues.set(code, value)
+
+		for (const [id, expression] of this.#investigation.rootList.entries())
+			yield {id, value: evaluate(this.#context, id, expression)} as Intent
+
+		for (const {code, value} of samples)
+			this.#context.previousValues.set(code, value)
+	}
+
+	dispose() {
+		return this.#sampler.dispose()
+	}
+}
+

package/s/lib/input/evaluate/context.ts

@@ -0,0 +1,17 @@
+
+import {Sample} from "../types.js"
+import {Clock} from "../utils/clock.js"
+
+export class EvaluationContext {
+	dt = 0
+	clock = new Clock()
+
+	recentSamples: Sample[] = []
+	latestValues = new Map<string, number>()
+	previousValues = new Map<string, number>()
+
+	accumulated = new Map<object, number>()
+	holding = new WeakMap<object, {start: number}>()
+	tapping = new WeakMap<object, {events: number[]}>()
+}
+

package/s/lib/input/evaluate/evaluate.ts

@@ -0,0 +1,199 @@
+
+import {remap} from "@benev/math"
+import {arraylimit, guarantee, isNumber, isString} from "@e280/stz"
+
+import {isDown} from "../utils/is-down.js"
+import {EvaluationContext} from "./context.js"
+import type {Expression} from "../expression.js"
+
+export function evaluate(
+		context: EvaluationContext,
+		id: number,
+		expression: Expression,
+	): number {
+
+	const e = (expression: Expression) => evaluate(context, id, expression)
+
+	if (isNumber(expression))
+		return expression
+
+	else if (isString(expression))
+		return context.latestValues.get(expression) ?? 0
+
+	else switch (expression[0]) {
+		case "accumulate": {
+			const subexpression = expression[1]
+			const total = (context.accumulated.get(expression) ?? 0) + e(subexpression)
+			context.accumulated.set(expression, total)
+			return total
+		}
+
+		case "sum": {
+			const code = expression[1]
+			let x = 0
+			for (const sample of context.recentSamples) {
+				if (sample.code === code)
+					x += sample.value
+			}
+			return x
+		}
+
+		case "up": {
+			const code = expression[1]
+			let ups = 0
+			let was = context.previousValues.get(code) ?? 0
+			for (const sample of context.recentSamples) {
+				if (sample.code !== code) continue
+				if (isDown(was) && !isDown(sample.value))
+					ups++
+				was = sample.value
+			}
+			return ups
+		}
+
+		case "down": {
+			const code = expression[1]
+			let downs = 0
+			let was = context.previousValues.get(code) ?? 0
+			for (const sample of context.recentSamples) {
+				if (sample.code !== code) continue
+				if (!isDown(was) && isDown(sample.value))
+					downs++
+				was = sample.value
+			}
+			return downs
+		}
+
+		case "was": {
+			const code = expression[1]
+			return context.previousValues.get(code) ?? 0
+		}
+
+		case "since": {
+			const code = expression[1]
+			const was = context.previousValues.get(code) ?? 0
+			const latest = context.latestValues.get(code) ?? 0
+			return latest - was
+		}
+
+		case "if": {
+			const [, condition, yes, no] = expression
+			return e(condition)
+				? e(yes)
+				: (no ? e(no) : 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]) === 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 "!":
+			return +(e(expression[1]) === 0)
+
+		case "!!":
+			return +(e(expression[1]) !== 0)
+
+		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.dt
+
+		case "held": {
+			const [, ms, subexpression] = expression
+			const down = isDown(e(subexpression))
+			let held = context.holding.get(expression)
+
+			if (down && !held) {
+				held = {start: context.clock.time}
+				context.holding.set(expression, held)
+			}
+
+			if (!down && held) {
+				held = undefined
+				context.holding.delete(expression)
+			}
+
+			if (held) {
+				const timeHeld = context.clock.time - held.start
+				if (timeHeld >= ms)
+					return 1
+			}
+
+			return 0
+		}
+
+		case "taps": {
+			const [, taps, ms, subexpression] = expression
+			const presses = e(subexpression)
+			const now = context.clock.time
+
+			const tapped = guarantee(context.tapping, expression, () => ({
+				events: [] as number[],
+			}))
+
+			for (let i = 0; i < presses; i++)
+				tapped.events.push(now)
+
+			tapped.events = arraylimit(
+				tapped.events.filter(time => time >= now - ms),
+				128,
+			)
+
+			if (tapped.events.length >= taps) {
+				tapped.events = []
+				return 1
+			}
+
+			return 0
+		}
+
+		default:
+			throw new Error("unknown expression")
+	}
+}
+