@benev/tact 0.1.0-1

package/s/nubs/virtual-gamepad/view.ts

@@ -0,0 +1,139 @@
+
+import {html} from "lit"
+import {view} from "@e280/sly"
+import {ev, MapG} from "@e280/stz"
+
+import stylesCss from "./styles.css.js"
+
+import {NubStick} from "../stick/view.js"
+import {VirtualGamepadDevice} from "./device.js"
+import {GamepadInputs} from "./utils/gamepad-inputs.js"
+import {touchTracking} from "./utils/touch-tracking.js"
+import {preventDefaultTouchShenanigans} from "./utils/prevent-default-touch-shenanigans.js"
+
+export const VirtualGamepad = view(use => (device: VirtualGamepadDevice) => {
+	use.name("virtual-gamepad")
+	use.css(stylesCss)
+
+	const buttons = use.once(() => new Set<HTMLButtonElement>())
+	const codes = use.once(() => new MapG<HTMLButtonElement, keyof GamepadInputs>())
+
+	use.rendered.then(() => {
+		const elements = Array.from(
+			use.shadow.querySelectorAll<HTMLButtonElement>("button[x-code]")
+		)
+		for (const button of elements) {
+			const code = button.getAttribute("x-code")
+			if (code) {
+				buttons.add(button)
+				codes.set(button, code as keyof GamepadInputs)
+			}
+		}
+	})
+
+	use.mount(() => preventDefaultTouchShenanigans())
+
+	use.mount(() => touchTracking({
+		target: use.shadow,
+		buttons,
+		touchdown: button => {
+			const code = codes.require(button)
+			device.setSample(code, 1)
+		},
+		touchup: button => {
+			const code = codes.require(button)
+			device.setSample(code, 0)
+		},
+	}))
+
+	use.mount(() => ev(use.shadow, {
+		contextmenu: (e: Event) => e.preventDefault(),
+	}))
+
+	function button(code: string, label: string) {
+		return html`
+			<button x-code="${code}">${label}</button>
+		`
+	}
+
+	function renderDPad() {
+		return html`
+			<div class=pad>
+				<div>
+					${button("gamepad.left", "w")}
+				</div>
+				<div>
+					${button("gamepad.up", "n")}
+					${button("gamepad.down", "s")}
+				</div>
+				<div>
+					${button("gamepad.right", "e")}
+				</div>
+			</div>
+		`
+	}
+
+	function renderButtonPad() {
+		return html`
+			<div class=pad>
+				<div>
+					${button("gamepad.x", "x")}
+				</div>
+				<div>
+					${button("gamepad.y", "y")}
+					${button("gamepad.a", "a")}
+				</div>
+				<div>
+					${button("gamepad.b", "b")}
+				</div>
+			</div>
+		`
+	}
+
+	function renderLeftShoulder() {
+		return html`
+			<div class=shoulder>
+				${button("gamepad.trigger.left", "lt")}
+				${button("gamepad.bumper.left", "lb")}
+				${button("gamepad.stick.left.click", "lc")}
+			</div>
+		`
+	}
+
+	function renderRightShoulder() {
+		return html`
+			<div class=shoulder>
+				${button("gamepad.trigger.right", "rt")}
+				${button("gamepad.bumper.right", "rb")}
+				${button("gamepad.stick.right.click", "rc")}
+			</div>
+		`
+	}
+
+	return html`
+		<div class=upper>
+			${button("gamepad.alpha", "alpha")}
+			${button("gamepad.beta", "beta")}
+			${button("gamepad.gamma", "gamma")}
+		</div>
+
+		<div class=lower>
+			<div class="left side">
+				${renderLeftShoulder()}
+				${renderDPad()}
+				${NubStick
+					.attr("class", "stick")
+					.props(device.stickLeft)}
+			</div>
+
+			<div class="right side">
+				${renderRightShoulder()}
+				${renderButtonPad()}
+				${NubStick
+					.attr("class", "stick")
+					.props(device.stickRight)}
+			</div>
+		</div>
+	`
+})
+

package/s/station/devices/gamepad.ts

@@ -0,0 +1,81 @@
+
+import {tmax} from "../utils/tmax.js"
+import {SamplerDevice} from "./infra/sampler.js"
+import {splitAxis} from "../../utils/split-axis.js"
+import {gamepads, Pad} from "../../utils/gamepads.js"
+
+const gamepadButtonCodes = [
+	"gamepad.a",
+	"gamepad.b",
+	"gamepad.x",
+	"gamepad.y",
+	"gamepad.bumper.left",
+	"gamepad.bumper.right",
+	"gamepad.trigger.left",
+	"gamepad.trigger.right",
+	"gamepad.alpha",
+	"gamepad.beta",
+	"gamepad.stick.left.click",
+	"gamepad.stick.right.click",
+	"gamepad.up",
+	"gamepad.down",
+	"gamepad.left",
+	"gamepad.right",
+	"gamepad.gamma",
+]
+
+export class GamepadDevice extends SamplerDevice {
+	static on(fn: (device: GamepadDevice) => () => void) {
+		return gamepads(pad => fn(new this(pad)))
+	}
+
+	constructor(public pad: Pad) {
+		super()
+	}
+
+	get gamepad() {
+		return this.pad.gamepad
+	}
+
+	takeSamples() {
+		const {gamepad} = this.pad
+		this.#pollButtons(gamepad)
+		this.#pollSticks(gamepad)
+		return super.takeSamples()
+	}
+
+	#pollButtons(gamepad: Gamepad) {
+		let anyButtonValue = 0
+
+		const recordAny = (value: number) => {
+			anyButtonValue = tmax([anyButtonValue, value])
+		}
+
+		for (const [index, code] of gamepadButtonCodes.entries()) {
+			const value = gamepad.buttons.at(index)?.value ?? 0
+			recordAny(value)
+			this.setSample(code, value)
+		}
+
+		this.setSample("gamepad.any", anyButtonValue)
+	}
+
+	#pollSticks(gamepad: Gamepad) {
+		const [leftY, leftX, rightY, rightX] = gamepad.axes
+
+		const [leftUp, leftDown] = splitAxis(leftX)
+		const [leftLeft, leftRight] = splitAxis(leftY)
+		this.setSample("gamepad.stick.left.up", leftUp)
+		this.setSample("gamepad.stick.left.down", leftDown)
+		this.setSample("gamepad.stick.left.left", leftLeft)
+		this.setSample("gamepad.stick.left.right", leftRight)
+
+		const [rightUp, rightDown] = splitAxis(rightX)
+		const [rightLeft, rightRight] = splitAxis(rightY)
+		this.setSample("gamepad.stick.right.up", rightUp)
+		this.setSample("gamepad.stick.right.down", rightDown)
+		this.setSample("gamepad.stick.right.left", rightLeft)
+		this.setSample("gamepad.stick.right.right", rightRight)
+	}
+}
+

package/s/station/devices/infra/device.ts

@@ -0,0 +1,7 @@
+
+import {Sample} from "../../types.js"
+
+export abstract class Device {
+	abstract takeSamples(): Sample[]
+}
+

package/s/station/devices/infra/group.ts

@@ -0,0 +1,17 @@
+
+import {SetG} from "@e280/stz"
+import {Device} from "./device.js"
+
+export class GroupDevice extends Device {
+	devices = new SetG<Device>()
+
+	constructor(...devices: Device[]) {
+		super()
+		this.devices.adds(...devices)
+	}
+
+	takeSamples() {
+		return [...this.devices].flatMap(device => device.takeSamples())
+	}
+}
+

package/s/station/devices/infra/sampler.ts

@@ -0,0 +1,22 @@
+
+import {sub} from "@e280/stz"
+import {Device} from "./device.js"
+import {Sample, SampleMap} from "../../types.js"
+
+export class SamplerDevice extends Device {
+	on = sub<Sample>()
+	#map: SampleMap = new Map()
+
+	setSample(code: string, value: number) {
+		this.#map.set(code, value)
+		this.on.pub(code, value)
+		return this
+	}
+
+	takeSamples(): Sample[] {
+		const samples = [...this.#map]
+		this.#map.clear()
+		return samples
+	}
+}
+

package/s/station/devices/keyboard.ts

@@ -0,0 +1,53 @@
+
+import {coalesce, ev, sub} from "@e280/stz"
+import {Sample} from "../types.js"
+import {Device} from "./infra/device.js"
+import {modprefix} from "../utils/modprefix.js"
+
+export class KeyboardDevice extends Device {
+	on = sub<Sample>()
+	dispose: () => void
+	#held = new Set<string>()
+
+	constructor(target: EventTarget) {
+		super()
+
+		const down = (code: string) => {
+			this.#held.add(code)
+			this.on.pub(code, 1)
+		}
+
+		const up = (code: string) => {
+			this.#held.delete(code)
+			this.on.pub(code, 0)
+		}
+
+		this.dispose = coalesce(
+			ev(target, {
+				keydown: (event: KeyboardEvent) => {
+					if (event.repeat) return
+					down(event.code)
+					down(modprefix(event, event.code))
+				},
+				keyup: (event: KeyboardEvent) => {
+					up(event.code)
+					up(modprefix(event, event.code))
+				},
+			}),
+
+			ev(window, {
+				blur: () => {
+					for (const code of this.#held)
+						this.on.pub(code, 0)
+					this.#held.clear()
+				},
+			})
+		)
+	}
+
+	takeSamples() {
+		return [...this.#held]
+			.map(code => [code, 1] as Sample)
+	}
+}
+

package/s/station/devices/pointer.ts

@@ -0,0 +1,95 @@
+
+import {ev} from "@e280/stz"
+import {Vec2} from "@benev/math"
+import {modprefix} from "../utils/modprefix.js"
+import {SamplerDevice} from "./infra/sampler.js"
+import {splitAxis} from "../../utils/split-axis.js"
+
+export class PointerDevice extends SamplerDevice {
+	client = new Vec2(0, 0)
+	movement = new Vec2(0, 0)
+	dispose: () => void
+
+	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
+	}
+
+	constructor(target: EventTarget) {
+		super()
+
+		const dispatch = (event: PointerEvent | WheelEvent, code: string, value: number) => {
+			this.setSample(code, value)
+			this.setSample(modprefix(event, code), value)
+		}
+
+		this.dispose = ev(target, {
+			pointerdown: (event: PointerEvent) => {
+				const code = PointerDevice.buttonCode(event)
+				dispatch(event, code, 1)
+			},
+
+			pointerup: (event: PointerEvent) => {
+				const code = PointerDevice.buttonCode(event)
+				dispatch(event, 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) => {
+				for (const [code, value] of PointerDevice.wheelCodes(event))
+					dispatch(event, code, value)
+			},
+		})
+	}
+
+	takeSamples() {
+		const [x, y] = this.movement
+		const [left, right] = splitAxis(x)
+		const [down, up] = splitAxis(y)
+
+		if (x) {
+			if (x >= 0)
+				this.setSample(`pointer.move.right`, Math.abs(right))
+			else
+				this.setSample(`pointer.move.left`, Math.abs(left))
+		}
+		if (y) {
+			if (y >= 0)
+				this.setSample(`pointer.move.up`, Math.abs(up))
+			else
+				this.setSample(`pointer.move.down`, Math.abs(down))
+		}
+
+		this.movement.set_(0, 0)
+		return super.takeSamples()
+	}
+}
+

package/s/station/parts/action.ts

@@ -0,0 +1,26 @@
+
+import {sub} from "@e280/stz"
+import {isPressed} from "../utils/is-pressed.js"
+
+export class Action {
+	#value = 0
+	#previous = 0
+
+	static updateValue(action: Action, newValue: number) {
+		action.#previous = action.#value
+		action.#value = newValue
+		if (action.changed) action.on.pub(action)
+		if (action.down) action.onDown.pub(action)
+	}
+
+	readonly on = sub<[Action]>()
+	readonly onDown = sub<[Action]>()
+
+	get value() { return this.#value }
+	get previous() { return this.#previous }
+	get changed() { return this.#value !== this.#previous }
+	get pressed() { return isPressed(this.#value) }
+	get down() { return !isPressed(this.#previous) && isPressed(this.#value) }
+	get up() { return isPressed(this.#previous) && !isPressed(this.#value) }
+}
+

package/s/station/parts/defaults.ts

@@ -0,0 +1,28 @@
+
+import {LensSettings, LensState} from "../types.js"
+
+export const defaultHoldTime = 250
+
+export function defaultLensState(): LensState {
+	return {
+		lastValue: 0,
+		holdStart: 0,
+	}
+}
+
+export function defaultLensSettings(): LensSettings {
+	return {
+		scale: 1,
+		invert: false,
+		deadzone: 0.2,
+		timing: {style: "direct"},
+	}
+}
+
+export function defaultifyLensSettings(partial: Partial<LensSettings> = {}): LensSettings {
+	return {
+		...defaultLensSettings(),
+		...partial,
+	}
+}
+

package/s/station/parts/resolver.ts

@@ -0,0 +1,73 @@
+
+import {WeakMapG} from "@e280/stz"
+import {tmax} from "../utils/tmax.js"
+import {lensing_algorithm} from "./routines/lensing_algorithm.js"
+import {Actions, Bindings, Lens, LensState, SampleMap, Spoon} from "../types.js"
+import {defaultifyLensSettings, defaultLensState} from "./defaults.js"
+import {build_updatable_actions_structure} from "./routines/build_updatable_actions_structure.js"
+
+export class Resolver<B extends Bindings> {
+	actions: Actions<B>
+
+	#now = 0
+	#lenses = new WeakMapG<Lens, LensState>()
+	#updateValues: () => void
+
+	constructor(
+			public bindings: B,
+			private modes: Set<keyof B>,
+			private samples: SampleMap,
+		) {
+		this.modes = modes as Set<keyof Bindings>
+		const structure = build_updatable_actions_structure(
+			bindings,
+			this.#resolveActionValue,
+		)
+		this.actions = structure.actions
+		this.#updateValues = structure.updateValues
+	}
+
+	poll(now: number) {
+		this.#now = now
+		this.#updateValues()
+	}
+
+	#resolveActionValue = (mode: keyof B, actionKey: keyof B[keyof B]) => {
+		const fork = this.bindings[mode][actionKey]
+		const isModeActive = this.modes.has(mode)
+		if (!isModeActive) return 0
+		return tmax(fork.map(this.#resolveSpoon))
+	}
+
+	#resolveSpoon = ({lenses, required = [], forbidden = []}: Spoon) => {
+		const satisfiedRequirements = () => {
+			if (required.length === 0) return true
+			const requiredValues = required.map(this.#resolveLens)
+			return !requiredValues.some(value => value <= 0)
+		}
+
+		const satisfiedForbiddens = () => {
+			if (forbidden.length === 0) return true
+			const forbiddenValues = forbidden.map(this.#resolveLens)
+			return !forbiddenValues.some(value => value > 0)
+		}
+
+		const combineValues = () => {
+			const values = lenses.map(this.#resolveLens)
+			return tmax(values)
+		}
+
+		return (satisfiedRequirements() && satisfiedForbiddens())
+			? combineValues()
+			: 0
+	}
+
+	#resolveLens = (lens: Lens) => {
+		const {code} = lens
+		const value = this.samples.get(code) ?? 0
+		const state = this.#lenses.guarantee(lens, defaultLensState)
+		const settings = defaultifyLensSettings(lens.settings)
+		return lensing_algorithm(value, settings, state, this.#now)
+	}
+}
+

package/s/station/parts/routines/aggregate_samples_into_map.ts

@@ -0,0 +1,20 @@
+
+import {SampleMap} from "../../types.js"
+import {Device} from "../../devices/infra/device.js"
+
+export function aggregate_samples_into_map(
+		devices: Set<Device>,
+		map: SampleMap,
+	) {
+
+	for (const device of devices) {
+		for (const [code, value] of device.takeSamples()) {
+			const previous = map.get(code) ?? 0
+			if (value > previous)
+				map.set(code, value)
+		}
+	}
+
+	return map
+}
+

package/s/station/parts/routines/build_updatable_actions_structure.ts

@@ -0,0 +1,29 @@
+
+import {obMap, xub} from "@e280/stz"
+import {Action} from "../action.js"
+import {Bindings, Actions} from "../../types.js"
+
+export function build_updatable_actions_structure<B extends Bindings>(
+		bindings: B,
+		resolveActionValue: (mode: keyof B, actionKey: keyof B[keyof B]) => number,
+	) {
+
+	const updateValues = xub()
+
+	const actions = obMap(bindings, (bracket, mode) =>
+		obMap(bracket, (_, actionKey) => {
+			const action = new Action()
+			updateValues.on(() => {
+				const value = resolveActionValue(mode, actionKey)
+				Action.updateValue(action, value)
+			})
+			return action
+		})
+	) as Actions<B>
+
+	return {
+		actions,
+		updateValues: updateValues.publish,
+	}
+}
+

package/s/station/parts/routines/lensing_algorithm.ts

@@ -0,0 +1,74 @@
+
+import {pipe} from "@e280/stz"
+import {Scalar} from "@benev/math"
+import {defaultHoldTime} from "../defaults.js"
+import {isPressed} from "../../utils/is-pressed.js"
+import {LensSettings, LensState} from "../../types.js"
+
+export const lensing_algorithm = (
+		v: number,
+		settings: LensSettings,
+		state: LensState,
+		now: number,
+	) => pipe(v).line(
+
+	function deadzone(value) {
+		if (value < settings.deadzone)
+			return 0
+
+		if (value > 1)
+			return value
+
+		return Scalar.remap(
+			value,
+			settings.deadzone, 1,
+			0, 1,
+		)
+	},
+
+	function inversion(value) {
+		return settings.invert
+			? value * -1
+			: value
+	},
+
+	function scaling(value) {
+		return settings.scale * value
+	},
+
+	function timing(value) {
+		const holdTime = (
+			settings.timing.style === "direct"
+				? undefined
+				: settings.timing.holdTime
+		) ?? defaultHoldTime
+
+		const isFreshlyPressed = !isPressed(state.lastValue) && isPressed(value)
+		const isFreshlyReleased = isPressed(state.lastValue) && !isPressed(value)
+		const isHolding = (now - state.holdStart) >= holdTime
+
+		if (isFreshlyPressed)
+			state.holdStart = now
+
+		state.lastValue = value
+
+		switch (settings.timing.style) {
+			case "direct":
+				return value
+
+			case "tap":
+				return (isFreshlyReleased && !isHolding)
+					? 1
+					: 0
+
+			case "hold":
+				return (isPressed(value) && isHolding)
+					? value
+					: 0
+
+			default:
+				throw new Error(`unknown bindings timing`)
+		}
+	},
+)
+

package/s/station/parts/switchboard-bindings.ts

@@ -0,0 +1,21 @@
+
+import {Switchboard} from "../switchboard.js"
+import {AsSwitchboardBindings, Bindings} from "../types.js"
+
+export function switchboardBindings<B extends Bindings>(b: B): AsSwitchboardBindings<B> {
+	return {
+		...b,
+		[Switchboard.mode]: {
+			shimmyNext: [
+				{lenses: [{code: "BracketRight"}]},
+				{lenses: [{code: "gamepad.right"}], required: [{code: "gamepad.gamma"}]},
+				{lenses: [{code: "gamepad.bumper.right"}], required: [{code: "gamepad.gamma"}]},
+			],
+			shimmyPrevious: [
+				{lenses: [{code: "BracketLeft"}]},
+				{lenses: [{code: "gamepad.left"}], required: [{code: "gamepad.gamma"}]},
+				{lenses: [{code: "gamepad.bumper.left"}], required: [{code: "gamepad.gamma"}]},
+			],
+		},
+	}
+}