@benev/tact 0.2.0 → 0.3.0-1

package/s/test.ts

@@ -0,0 +1,339 @@
+
+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/ui/views/desk/style.css.ts

@@ -0,0 +1,70 @@
+
+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;
+}
+
+`
+

package/s/ui/views/desk/view.ts

@@ -0,0 +1,122 @@
+
+import {html} from "lit"
+import {clamp} from "@benev/math"
+import {Content, shadow, useCss, useName} from "@e280/sly"
+
+import styleCss from "./style.css.js"
+import {Deck} from "../../../deck/deck.js"
+import {Port} from "../../../deck/port.js"
+import {Controller} from "../../../deck/controller.js"
+
+export type DeskOptions = {
+	getControllerLabel?: (controller: Controller) => Content | undefined
+}
+
+export const DeskView = shadow((deck: Deck, options: DeskOptions = {}) => {
+	useName("desk")
+	useCss(styleCss)
+
+	function shimmy(controller: Controller, offset: number) {
+		const ports = deck.ports
+		const info = deck.queryController(controller)
+		const portIndex = ports.indexOf(info.port!)
+		const newIndex = clamp(portIndex + offset, 0, ports.length - 1)
+		const newPort = ports.at(newIndex)
+		if (newPort)
+			newPort.plug(controller)
+	}
+
+	function PortView(port: Port, portIndex: number) {
+		return html`
+			<div class=port>
+				<header>
+					<span>P${portIndex + 1}</span>
+					<div class=buttons>
+						<button @click=${() => deck.deletePort(port)}>🚫</button>
+					</div>
+				</header>
+				<div class=controllerlist>
+					${port.controllers.map(ControllerView)}
+				</div>
+			</div>
+		`
+	}
+
+	function UnassignedView(controllers: Controller[]) {
+		return html`
+			<div class=port>
+				<header>
+					<span>unassigned</span>
+				</header>
+				<div class=controllerlist>
+					${controllers.map(ControllerView)}
+				</div>
+			</div>
+		`
+	}
+
+
+	function ControllerView(controller: Controller) {
+		const {port, profileKey} = deck.queryController(controller)
+
+		async function onChange(event: Event) {
+			const element = event.currentTarget as HTMLSelectElement
+			const profileKey = element.value
+			await deck.assignControllerProfile(controller, profileKey)
+		}
+
+		function plugIn(controller: Controller) {
+			const p1 = deck.ports.at(0) ?? deck.createPort()
+			p1.plug(controller)
+		}
+
+		return html`
+			<div class=controller>
+				<span>${options.getControllerLabel?.(controller) ?? controller.handle}</span>
+
+				<div class=buttons>
+					<div>
+						${port
+							? html`
+								<button @click=${() => shimmy(controller, -1)} ?disabled=${deck.ports.indexOf(port) === 0}>👈</button>
+								<button @click=${() => port.unplug(controller)}>⏏️</button>
+								<button @click=${() => shimmy(controller, 1)} ?disabled=${deck.ports.indexOf(port) === (deck.ports.length - 1)}>👉</button>
+							`
+							: html`
+								<button @click=${() => plugIn(controller)}>🔌</button>
+							`}
+					</div>
+					<select @change=${onChange}>
+						${deck.profiles.all.map(([pk, profile]) => html`
+							<option
+								.value=${pk}
+								.selected=${pk === profileKey}>
+								${profile.label}
+							</option>
+						`)}
+					</select>
+				</div>
+			</div>
+		`
+	}
+
+	const {unassignedControllers} = deck
+
+	return html`
+		<div class=deck>
+			<div>
+				${deck.ports.map(PortView)}
+				<div>
+					<button @click=${() => deck.createPort()}>✨add port</button>
+				</div>
+			</div>
+
+			<div>
+				${unassignedControllers.length > 0
+					? UnassignedView(unassignedControllers)
+					: null}
+			</div>
+		</div>
+	`
+})
+

package/s/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/utils/do-async.ts

@@ -0,0 +1,5 @@
+
+export async function doAsync<Ret>(fn: () => Promise<Ret>) {
+	return fn()
+}
+

package/s/utils/freeze-clone.ts

@@ -0,0 +1,7 @@
+
+import {deep} from "@e280/stz"
+
+export function freezeClone<X>(x: X): X {
+	return deep.freeze(deep.clone(x))
+}
+

package/s/utils/identifier.ts

@@ -0,0 +1,30 @@
+
+import {guarantee, is, need} from "@e280/stz"
+
+export class Identifier<Item> {
+	#nextId = 0
+	#ids = new Map<Item, number>()
+	#items = new Map<number, Item>()
+
+	id(item: Item) {
+		const id = guarantee(this.#ids, item, () => {
+			const freshId = this.#nextId++
+			this.#items.set(freshId, item)
+			return freshId
+		})
+		return id
+	}
+
+	need(id: number) {
+		return need(this.#items, id)
+	}
+
+	delete(item: Item) {
+		const id = this.#ids.get(item)
+		if (is.happy(id)) {
+			this.#ids.delete(item)
+			this.#items.delete(id)
+		}
+	}
+}
+

package/s/utils/insert.ts

@@ -0,0 +1,6 @@
+
+export function insert<K, V>(map: Map<K, V>, entries: [K, V][]) {
+	for (const [key, value] of entries)
+		map.set(key, value)
+}
+

package/s/utils/is-down.ts

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

package/s/utils/make-id.ts

@@ -0,0 +1,7 @@
+
+import {hex} from "@e280/stz"
+
+export function makeId() {
+	return hex.random(16)
+}
+

package/s/utils/remap.ts

@@ -0,0 +1,7 @@
+
+export function remap<K, V>(entries: [K, V][], fn?: (map: Map<K, V>) => void) {
+	const map = new Map(entries)
+	fn?.(map)
+	return [...map.entries()]
+}
+

package/s/utils/shift-limit.ts

@@ -0,0 +1,9 @@
+
+/** limit the length of an array by trimming off the beginning until it's within the limit */
+export function shiftLimit<X>(limit: number, array: X[]) {
+	while (array.length > limit)
+		array.shift()
+
+	return array
+}
+

package/s/utils/sort-by-key.ts

@@ -0,0 +1,7 @@
+
+export function sortByKey<X extends [key: string, unknown]>([a]: X, [b]: X) {
+	return (a === b)
+		? 0
+		: (a < b) ? -1 : 1
+}
+

package/s/utils/tmax.ts

@@ -0,0 +1,7 @@
+
+export function tmax(values: number[]) {
+	return values.length > 0
+		? Math.max(...values)
+		: 0
+}
+

package/s/utils/tmin.ts

@@ -0,0 +1,7 @@
+
+export function tmin(values: number[]) {
+	return values.length > 0
+		? Math.min(...values)
+		: 0
+}
+