@benev/tact 0.4.0-0 → 0.4.0-2

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

@@ -1,102 +0,0 @@
-
-export type Sample = {
-	code: string
-	value: number
-}
-
-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 = RootExpression | {
-	[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 RootExpression =
-	| ["delta", Expression] // values represent an amount of change, every event is respected.
-	| Expression // values represent final state, non-changes are discarded.
-
-export type Expression = (
-	| number // constants for doing math.
-	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
-
-	// special
-	| ["pulse", string] // use current sample's value, or zero.
-
-	// 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/lib4/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/lib4/input/utils/is-down.ts

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

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

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

package/s/_archive/test.ts

@@ -1,339 +0,0 @@
-
-import {need} from "@e280/stz"
-import {distance} from "@benev/math"
-import {science, suite, test, expect} from "@e280/science"
-
-import {asBindings, Intent} from "./core/types.js"
-import {encodeIntents} from "./core/intent/encode.js"
-import {decodeIntents} from "./core/intent/decode.js"
-import {bindingsShape} from "./core/bindings/shape.js"
-import {bindingsTable} from "./core/bindings/table.js"
-import {normalizeBindings} from "./core/bindings/normalize.js"
-import {makeIntentsResolver} from "./core/resolvers/intents.js"
-import {makeActionsResolver} from "./core/resolvers/actions.js"
-
-export const exampleBindings = asBindings({
-	running: {forward: "KeyW", jump: ["and", "ShiftLeft", "Space"]},
-	gunning: {shoot: ["or", "pointer.button.left", "gamepad.trigger.right"]},
-})
-
-await science.run({
-	bindings: suite({
-		"shape": test(async() => {
-			expect(bindingsShape(exampleBindings).running.forward).ok()
-		}),
-
-		"table actions": test(async() => {
-			expect(need(bindingsTable(exampleBindings), 0).action).is("shoot")
-			expect(need(bindingsTable(exampleBindings), 1).action).deep("forward")
-			expect(need(bindingsTable(exampleBindings), 2).action).deep("jump")
-		}),
-
-		"table consistent ordering, mode": test(async() => {
-			for (const b of [
-				bindingsTable({alpha: {x: "KeyX"}, bravo: {x: "KeyX"}}),
-				bindingsTable({bravo: {x: "KeyX"}, alpha: {x: "KeyX"}}),
-			]) expect(need(b, 0).mode).deep("alpha")
-		}),
-
-		"table consistent ordering, action": test(async() => {
-			for (const b of [
-				bindingsTable({x: {alpha: "KeyA", bravo: "KeyB"}}),
-				bindingsTable({x: {bravo: "KeyB", alpha: "KeyA"}}),
-			]) expect(need(b, 0).action).deep("alpha")
-		}),
-
-		normalize: {
-			"adopts atom": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect(normalizeBindings(standard, {a: {b: "KeyW"}}).a.b).is("KeyW")
-			}),
-
-			"excludes excess action": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect("c" in normalizeBindings(standard, {a: {b: "KeyQ", c: "KeyW"}}).a).is(false)
-			}),
-
-			"excludes excess bracket": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect("c" in normalizeBindings(standard, {a: {b: "KeyQ"}, c: {d: "KeyW"}})).is(false)
-			}),
-
-			"falls back on standard atom": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect(normalizeBindings(standard, {a: {}}).a.b).is("KeyQ")
-			}),
-
-			"falls back on standard bracket": test(async() => {
-				const standard = {a: {b: "KeyQ"}}
-				expect(normalizeBindings(standard, {}).a.b).is("KeyQ")
-			}),
-
-			"complex fallback": test(async() => {
-				const standard = {a: {b: "KeyQ"}, c: {d: "KeyW"}}
-				expect(normalizeBindings(standard, {c: {d: "KeyE"}}).a.b).is("KeyQ")
-				expect(normalizeBindings(standard, {c: {d: "KeyE"}}).c.d).is("KeyE")
-			}),
-		},
-	}),
-
-	intents: suite({
-		"encoded roundtrip": test(async() => {
-			const intentsA: Intent[] = [[0, 0], [1, 1]]
-			const bytes = encodeIntents(intentsA)
-			const intentsB = decodeIntents(bytes)
-			expect(intentsB).deep(intentsA)
-		}),
-
-		"encoded six bytes": test(async() => {
-			const bytesA = encodeIntents([[0, 0]])
-			const bytesB = encodeIntents([[25, 0.7853981633974483]])
-			expect(bytesA.length).is(6)
-			expect(bytesB.length).is(6)
-		}),
-
-		"encoded float precision is acceptable": test(async() => {
-			const target = Math.PI / 4
-			const bytes = encodeIntents([[25, target]])
-			const [[,suspect]] = decodeIntents(bytes)
-			expect(distance(suspect, target) < (1 / 1_000_000)).is(true)
-		}),
-
-		"encoded billion": test(async() => {
-			const target = 1_000_000_000
-			const bytes = encodeIntents([[25, target]])
-			const [[,suspect]] = decodeIntents(bytes)
-			expect(suspect).is(target)
-		}),
-
-		"encoded negative billion": test(async() => {
-			const target = -1_000_000_000
-			const bytes = encodeIntents([[25, target]])
-			const [[,suspect]] = decodeIntents(bytes)
-			expect(suspect).is(target)
-		}),
-	}),
-
-	intentsResolver: suite({
-		"resolve samples to intents": test(async() => {
-			const resolveIntents = makeIntentsResolver(exampleBindings)
-			const intents = resolveIntents(0, [["KeyW", 1]])
-			expect(intents).deep([[1, 1]])
-		}),
-	}),
-
-	actionsResolver: suite({
-		"resolve intents to actions": test(async() => {
-			const resolveActions = makeActionsResolver(exampleBindings)
-			const actions = resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(true)
-		}),
-
-		"changing actions over time": test(async() => {
-			const resolveActions = makeActionsResolver(exampleBindings)
-			const actions = resolveActions([])
-
-			resolveActions([[1, 0]])
-			expect(actions.running.forward.value).is(0)
-			expect(actions.running.forward.down).is(false)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(true)
-			expect(actions.running.forward.changedDown).is(true)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 0]])
-			expect(actions.running.forward.value).is(0)
-			expect(actions.running.forward.down).is(false)
-			expect(actions.running.forward.changed).is(true)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(true)
-		}),
-
-		"changed expires with empty intents": test(async() => {
-			const resolveActions = makeActionsResolver(exampleBindings)
-			const actions = resolveActions([])
-
-			resolveActions([[1, 0]])
-			expect(actions.running.forward.value).is(0)
-			expect(actions.running.forward.down).is(false)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([[1, 1]])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(true)
-			expect(actions.running.forward.changedDown).is(true)
-			expect(actions.running.forward.changedUp).is(false)
-
-			resolveActions([])
-			expect(actions.running.forward.value).is(1)
-			expect(actions.running.forward.down).is(true)
-			expect(actions.running.forward.changed).is(false)
-			expect(actions.running.forward.changedDown).is(false)
-			expect(actions.running.forward.changedUp).is(false)
-		}),
-	}),
-
-	"dynamics": {
-		"just tapping": test(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(2, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(true)
-			}
-		}),
-
-		"just holding": test(async() => {
-			const bindings = asBindings({
-				alpha: {
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(11, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(true)
-			}
-		}),
-
-		"tapper works while holder exists": test.skip(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-			}
-			{
-				const intents = resolveIntents(2, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(true)
-			}
-		}),
-
-		"holder works while tapper exists": test(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(11, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.holder.down).is(true)
-			}
-		}),
-
-		"tapper and holder both work together": test.skip(async() => {
-			const bindings = asBindings({
-				alpha: {
-					tapper: ["code", "KeyE", {timing: ["tap", 10]}],
-					holder: ["code", "KeyE", {timing: ["hold", 10]}],
-				},
-			})
-			const resolveIntents = makeIntentsResolver(bindings)
-			const resolveActions = makeActionsResolver(bindings)
-			{
-				const intents = resolveIntents(0, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(1, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(2, [["KeyE", 0]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(true)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(3, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(false)
-			}
-			{
-				const intents = resolveIntents(13, [["KeyE", 1]])
-				const actions = resolveActions(intents)
-				expect(actions.alpha.tapper.down).is(false)
-				expect(actions.alpha.holder.down).is(true)
-			}
-		}),
-	},
-})
-

package/s/_archive/ui/views/desk/style.css.ts

@@ -1,70 +0,0 @@
-
-import {css} from "lit"
-export default css`
-
-.deck {
-	display: flex;
-	flex-direction: column;
-	gap: 0.5em;
-
-	> div {
-		display: flex;
-		flex-wrap: wrap;
-		gap: 0.5em;
-	}
-}
-
-.port {
-	background: grey;
-	width: 16em;
-	max-width: 100%;
-
-	header {
-		display: flex;
-		padding: 0.5em;
-
-		> span {
-			flex: 1 1 auto;
-			font-weight: bold;
-		}
-	}
-
-	strong {
-		display: block;
-		width: 100%;
-		padding: 0.2em;
-	}
-
-	.controllerlist {
-		display: flex;
-		flex-direction: column;
-		padding: 0.5em;
-		gap: 0.5em;
-	}
-}
-
-.controller {
-	display: flex;
-	flex-direction: column;
-	background: green;
-	padding: 0.5em;
-	gap: 0.5em;
-
-	.buttons {
-		display: flex;
-		flex-wrap: wrap;
-		justify-content: space-between;
-
-		> div {
-			display: flex;
-			flex-wrap: wrap;
-		}
-	}
-}
-
-button[disabled] {
-	opacity: 0.2;
-}
-
-`
-