@benev/tact 0.3.0-5 → 0.4.0-1

package/s/device/gamepad.ts

@@ -1,42 +0,0 @@
-
-import {Pad} from "./pad/pad.js"
-import {SamplerDevice} from "./sampler.js"
-import {splitAxis} from "../utils/split-axis.js"
-
-export class GamepadDevice extends SamplerDevice {
-	constructor(public pad: Pad) {
-		super()
-	}
-
-	get gamepad() {
-		return this.pad.gamepad
-	}
-
-	*samples() {
-		this.#pollButtons(this.pad.gamepad)
-		this.#pollSticks(this.pad.gamepad)
-		yield* super.samples()
-	}
-
-	#pollButtons(gamepad: Gamepad) {
-		let anyButtonValue = 0
-		for (const [index, button] of gamepad.buttons.entries()) {
-			const i = index + 1
-			const value = button.value
-			anyButtonValue = Math.max(anyButtonValue, value)
-			this.setSample(`gamepad.button.${i}`, value)
-		}
-		this.setSample("gamepad.button.any", anyButtonValue)
-	}
-
-	#pollSticks(gamepad: Gamepad) {
-		for (const [index, axis] of gamepad.axes.entries()) {
-			const i = index + 1
-			this.setSample(`gamepad.axis.${i}`, axis)
-			const [neg, pos] = splitAxis(axis)
-			this.setSample(`gamepad.axis.${i}.neg`, neg)
-			this.setSample(`gamepad.axis.${i}.pos`, pos)
-		}
-	}
-}
-

package/s/device/keyboard.ts

@@ -1,33 +0,0 @@
-
-import {disposer, ev} from "@e280/stz"
-import {SamplerDevice} from "./sampler.js"
-
-export class KeyboardDevice extends SamplerDevice {
-	dispose = disposer()
-
-	constructor(target: EventTarget = window) {
-		super()
-		this.dispose.schedule(ev(target, this.#targetListeners))
-		this.dispose.schedule(ev(window, this.#windowListeners))
-	}
-
-	#targetListeners = {
-		keydown: (event: KeyboardEvent) => {
-			if (event.repeat) return null
-			this.setSample(event.code, 1)
-			this.setSample("keyboard.any", 1)
-		},
-		keyup: (event: KeyboardEvent) => {
-			if (event.repeat) return null
-			this.setSample(event.code, 0)
-			this.setSample("keyboard.any", 0)
-		},
-	}
-
-	#windowListeners = {
-		blur: () => {
-			this.zero()
-		},
-	}
-}
-

package/s/device/pointer.ts

@@ -1,89 +0,0 @@
-
-import {Vec2} from "@benev/math"
-import {disposer, ev} from "@e280/stz"
-import {SamplerDevice} from "./sampler.js"
-import {splitAxis} from "../utils/split-axis.js"
-
-export class PointerDevice extends SamplerDevice {
-	client = new Vec2()
-	movement = new Vec2()
-	dispose = disposer()
-
-	constructor(target: EventTarget = window) {
-		super()
-
-		this.dispose.schedule(ev(target, {
-			pointerdown: (event: PointerEvent) => {
-				const code = PointerDevice.buttonCode(event)
-				this.setSample(code, 1)
-			},
-
-			pointerup: (event: PointerEvent) => {
-				const code = PointerDevice.buttonCode(event)
-				this.setSample(code, 0)
-			},
-
-			pointermove: (event: PointerEvent) => {
-				this.client.x = event.clientX
-				this.client.y = event.clientY
-				this.movement.x += event.movementX
-				this.movement.y += event.movementY
-			},
-
-			wheel: (event: WheelEvent) => {
-				this.sampleMap.set("pointer.wheel.right", 0)
-				this.sampleMap.set("pointer.wheel.left", 0)
-				this.sampleMap.set("pointer.wheel.up", 0)
-				this.sampleMap.set("pointer.wheel.down", 0)
-				for (const [code, value] of PointerDevice.wheelCodes(event))
-					this.setSample(code, value)
-			},
-		}))
-	}
-
-	static buttonCode(event: PointerEvent) {
-		switch (event.button) {
-			case 0: return "pointer.button.left"
-			case 1: return "pointer.button.middle"
-			case 2: return "pointer.button.right"
-			default: return `pointer.button.${event.button + 1}`
-		}
-	}
-
-	static wheelCodes(event: WheelEvent) {
-		const movements: [string, number][] = []
-
-		if (event.deltaX)
-			movements.push([
-				event.deltaX > 0 ? "pointer.wheel.right" : "pointer.wheel.left",
-				event.deltaX,
-			])
-
-		if (event.deltaY)
-			movements.push([
-				event.deltaY > 0 ? "pointer.wheel.down" : "pointer.wheel.up",
-				event.deltaY,
-			])
-
-		return movements
-	}
-
-	*samples() {
-		this.#specialPreProcessing()
-		yield* super.samples()
-	}
-
-	#specialPreProcessing() {
-		const {x, y} = this.movement
-		const [right, left] = splitAxis(x)
-		const [down, up] = splitAxis(y)
-
-		this.setSample("pointer.move.left", left)
-		this.setSample("pointer.move.right", right)
-		this.setSample("pointer.move.up", up)
-		this.setSample("pointer.move.down", down)
-
-		this.movement.set_(0, 0)
-	}
-}
-

package/s/device/sampler.ts

@@ -1,25 +0,0 @@
-
-import {sub} from "@e280/stz"
-import {Device, Sample} from "../core/types.js"
-import {SampleMap} from "../core/parts/sample-map.js"
-
-export class SamplerDevice implements Device {
-	on = sub<Sample>()
-	sampleMap = new SampleMap()
-
-	setSample(code: string, value: number) {
-		this.sampleMap.set(code, value)
-		this.on.pub(code, value)
-		return this
-	}
-
-	zero() {
-		for (const code of this.sampleMap.keys())
-			this.setSample(code, 0)
-	}
-
-	*samples() {
-		yield* this.sampleMap
-	}
-}
-

package/s/device/stick.ts

@@ -1,24 +0,0 @@
-
-import {Vec2} from "@benev/math"
-import {derived, signal} from "@e280/strata"
-import {Device, Sample} from "../core/types.js"
-import {splitVector} from "../utils/split-axis.js"
-
-export class StickDevice implements Device {
-	$vector = signal(Vec2.zero())
-	$breakdown = derived(() => splitVector(this.$vector()))
-
-	constructor(public channel = "stick") {}
-
-	samples() {
-		const {channel} = this
-		const {up, down, left, right} = this.$breakdown()
-		return [
-			[`${channel}.up`, up],
-			[`${channel}.down`, down],
-			[`${channel}.left`, left],
-			[`${channel}.right`, right],
-		] as Sample[]
-	}
-}
-

package/s/index-ui.ts

@@ -1,3 +0,0 @@
-
-export * from "./ui/views/desk/view.js"
-

package/s/index.ts

@@ -1,31 +0,0 @@
-
-export * from "./core/atom/types.js"
-export * from "./core/bindings/normalize.js"
-export * from "./core/bindings/shape.js"
-export * from "./core/bindings/table.js"
-export * from "./core/intent/bucket.js"
-export * from "./core/intent/decode.js"
-export * from "./core/intent/encode.js"
-export * from "./core/intent/merge.js"
-export * from "./core/parts/action.js"
-export * from "./core/parts/sample-map.js"
-export * from "./core/resolvers/actions.js"
-export * from "./core/resolvers/intents.js"
-export * from "./core/types.js"
-
-export * from "./device/pad/pad.js"
-export * from "./device/pad/on-pad.js"
-export * from "./device/devices.js"
-export * from "./device/gamepad.js"
-export * from "./device/keyboard.js"
-export * from "./device/pointer.js"
-export * from "./device/sampler.js"
-export * from "./device/stick.js"
-
-export * from "./deck/parts/profiles.js"
-export * from "./deck/parts/settings.js"
-export * from "./deck/controller.js"
-export * from "./deck/deck.js"
-export * from "./deck/port.js"
-export * from "./deck/types.js"
-

package/s/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/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;
-}
-
-`
-