@benev/tact 0.1.0-2 → 0.1.0-4

package/s/core/{controllers → devices}/standard/pointer.ts

@@ -1,32 +1,26 @@
 
-import {ev} from "@e280/stz"
 import {Vec2} from "@benev/math"
-import {modprefix} from "../utils/modprefix.js"
+import {disposer, ev} from "@e280/stz"
+import {SamplerDevice} from "../infra/sampler.js"
 import {splitAxis} from "../../../utils/split-axis.js"
-import {SamplerController} from "../infra/sampler.js"
 
-export class PointerController extends SamplerController {
+export class PointerDevice extends SamplerDevice {
 	client = new Vec2(0, 0)
 	movement = new Vec2(0, 0)
-	dispose: () => void
+	dispose = disposer()
 
 	constructor(target: EventTarget = window) {
 		super()
 
-		const dispatch = (event: PointerEvent | WheelEvent, code: string, value: number) => {
-			this.setSample(code, value)
-			this.setSample(modprefix(event, code), value)
-		}
-
-		this.dispose = ev(target, {
+		this.dispose.schedule(ev(target, {
 			pointerdown: (event: PointerEvent) => {
-				const code = PointerController.buttonCode(event)
-				dispatch(event, code, 1)
+				const code = PointerDevice.buttonCode(event)
+				this.setSample(code, 1)
 			},
 
 			pointerup: (event: PointerEvent) => {
-				const code = PointerController.buttonCode(event)
-				dispatch(event, code, 0)
+				const code = PointerDevice.buttonCode(event)
+				this.setSample(code, 0)
 			},
 
 			pointermove: (event: PointerEvent) => {
@@ -37,10 +31,10 @@ export class PointerController extends SamplerController {
 			},
 
 			wheel: (event: WheelEvent) => {
-				for (const [code, value] of PointerController.wheelCodes(event))
-					dispatch(event, code, value)
+				for (const [code, value] of PointerDevice.wheelCodes(event))
+					this.setSample(code, value)
 			},
-		})
+		}))
 	}
 
 	static buttonCode(event: PointerEvent) {
@@ -70,7 +64,12 @@ export class PointerController extends SamplerController {
 		return movements
 	}
 
-	takeSamples() {
+	samples() {
+		this.#specialPreProcessing()
+		return super.samples()
+	}
+
+	#specialPreProcessing() {
 		const [x, y] = this.movement
 		const [left, right] = splitAxis(x)
 		const [down, up] = splitAxis(y)
@@ -89,7 +88,6 @@ export class PointerController extends SamplerController {
 		}
 
 		this.movement.set_(0, 0)
-		return super.takeSamples()
 	}
 }
 

package/s/core/devices/standard/primary.ts

@@ -0,0 +1,20 @@
+
+import {VpadDevice} from "./vpad.js"
+import {PointerDevice} from "./pointer.js"
+import {KeyboardDevice} from "./keyboard.js"
+import {GroupDevice} from "../infra/group.js"
+
+export class PrimaryDevice extends GroupDevice {
+	keyboard = new KeyboardDevice()
+	pointer = new PointerDevice()
+	vpad = new VpadDevice()
+
+	constructor() {
+		super()
+		this.devices
+			.add(this.keyboard)
+			.add(this.pointer)
+			.add(this.vpad)
+	}
+}
+

package/s/core/devices/standard/stick.ts

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

package/s/core/{controllers/standard/virtual-gamepad.ts → devices/standard/vpad.ts}

@@ -1,25 +1,25 @@
 
-import {StickController} from "./stick.js"
-import {SamplerController} from "../infra/sampler.js"
+import {StickDevice} from "./stick.js"
+import {SamplerDevice} from "../infra/sampler.js"
 
-export class VirtualGamepadController extends SamplerController {
-	stickLeft = new StickController()
-	stickRight = new StickController()
+export class VpadDevice extends SamplerDevice {
+	stickLeft = new StickDevice()
+	stickRight = new StickDevice()
 
-	takeSamples() {
-		const left = this.stickLeft.breakdown()
+	samples() {
+		const left = this.stickLeft.$breakdown()
 		this.setSample("gamepad.stick.left.up", left.up)
 		this.setSample("gamepad.stick.left.down", left.down)
 		this.setSample("gamepad.stick.left.left", left.left)
 		this.setSample("gamepad.stick.left.right", left.right)
 
-		const right = this.stickRight.breakdown()
+		const right = this.stickRight.$breakdown()
 		this.setSample("gamepad.stick.right.up", right.up)
 		this.setSample("gamepad.stick.right.down", right.down)
 		this.setSample("gamepad.stick.right.left", right.left)
 		this.setSample("gamepad.stick.right.right", right.right)
 
-		return super.takeSamples()
+		return super.samples()
 	}
 }
 

package/s/core/{controllers → devices}/types.ts

@@ -1,4 +1,3 @@
 
 export type Sample = [code: string, value: number]
-export type SampleMap = Map<string, number>
 

package/s/core/hub/hub.ts

@@ -1,48 +1,40 @@
 
-import {SetG} from "@e280/stz"
 import {Scalar} from "@benev/math"
-import {Port} from "../port/port.js"
-import {hubBindings} from "./bindings.js"
-import {Controller} from "../controllers/controller.js"
-import {hubMode, HubBindings} from "../bindings/types.js"
+import {debounce, MapG, sub} from "@e280/stz"
+import {Port} from "./port.js"
+import {Device} from "../devices/device.js"
+import {Bindings} from "../bindings/types.js"
+import {Connected} from "./parts/connected.js"
+import {MetaBindings, metaMode} from "./types.js"
+import {makeMetaBindings} from "./meta-bindings.js"
 
-export class Hub<B extends HubBindings> {
-	static readonly mode = hubMode
-	static readonly bindings = hubBindings
+export class Hub<B extends Bindings, MB extends MetaBindings = any> {
 
-	readonly controllers = new SetG<Controller>()
+	/** event fires whenever a device changes ports. */
+	readonly on = sub()
 
-	constructor(public readonly ports: Port<B>[]) {
-		for (const port of ports) {
-			port.modes.add(Hub.mode)
-		}
-	}
+	/** all devices known to this hub */
+	#connected = new MapG<Device, Connected>()
 
-	*[Symbol.iterator]() {
-		yield* this.ports.values()
-	}
+	metaPort: Port<MB>
 
-	*entries() {
-		yield* this.ports.entries()
-	}
+	constructor(
 
-	/** poll all the ports, and actuate hub bindings for shimmying */
-	poll(now: number = Date.now()) {
-		return this.ports.map(port => {
-			const actions = port.poll(now)
-			const fn = (delta: 1 | -1) => {
-				const controller = this.controllerByPort(port)
-				if (controller) this.shimmy(controller, delta)
-			}
-			if (actions[hubMode].shimmyNext.down) fn(1)
-			if (actions[hubMode].shimmyPrevious.down) fn(-1)
-			return actions
-		})
+			/** available ports that devices can be assigned to. */
+			public readonly ports: Port<B>[],
+
+			/** special bindings for devices to shimmy between ports. */
+			public metaBindings = makeMetaBindings() as MB,
+		) {
+
+		this.metaPort = new Port<MB>(metaBindings)
 	}
 
-	/** check if a port has a known switchboard controller assigned */
-	isPlugged(port: Port<B>) {
-		return !!this.controllerByPort(port)
+	/** poll every device, providing actions for each port, and internally handling meta actions. */
+	poll(now = Date.now()) {
+		this.#resolveMetaPort(now)
+		this.#actuateMetaActions(now)
+		return this.#resolvePorts(now)
 	}
 
 	portByIndex(index: number) {
@@ -51,52 +43,76 @@ export class Hub<B extends HubBindings> {
 		return port
 	}
 
-	portByController(controller: Controller) {
+	portByDevice(device: Device) {
 		for (const port of this.ports) {
-			if (port.controllers.has(controller))
+			if (port.devices.has(device))
 				return port
 		}
 	}
 
-	controllerByPort(port: Port<B>) {
-		for (const controller of this.controllers) {
-			if (port.controllers.has(controller))
-				return controller
-		}
-	}
-
-	/** move a player's controller to the next or previous port */
-	shimmy(controller: Controller, indexDelta: 1 | -1) {
-		const oldIndex = this.ports.findIndex(port => port.controllers.has(controller))
+	/** move a player's device to the next or previous port */
+	shimmy(device: Device, indexDelta: 1 | -1) {
+		const oldIndex = this.ports.findIndex(port => port.devices.has(device))
 		const maxIndex = Math.max(0, this.ports.length - 1)
 		const newIndex = Scalar.clamp(oldIndex + indexDelta, 0, maxIndex)
 		const port = this.portByIndex(newIndex)
-		this.plug(controller, port)
+		this.reassign(device, port)
 		return port
 	}
 
-	/** plug a controller into a port */
-	plug = (controller: Controller, port: Port<B> = this.getLonelyPort()) => {
-		this.unplug(controller)
-		this.controllers.add(controller)
-		port.controllers.add(controller)
-		return () => this.unplug(controller)
+	reassign(device: Device, port = this.getLonelyPort()) {
+		this.ports.forEach(port => port.devices.delete(device))
+		port.devices.add(device)
+		this.#dispatchChange()
+	}
+
+	/** unplug a device */
+	unplug(device: Device) {
+		this.ports.forEach(port => port.devices.delete(device))
+		this.#connected.delete(device)
+		this.#dispatchChange()
 	}
 
-	/** unplug a controller */
-	unplug(controller: Controller) {
-		this.ports.forEach(port => port.controllers.delete(controller))
-		this.controllers.delete(controller)
+	/** plug a device into a port */
+	plug = (device: Device, port = this.getLonelyPort()) => {
+		this.unplug(device)
+		this.#connected.set(device, new Connected(device, this.metaBindings))
+		port.devices.add(device)
+		this.#dispatchChange()
+		return () => this.unplug(device)
 	}
 
 	/** returns an unplugged port (otherwise the last one) */
 	getLonelyPort() {
+		let smallest = this.ports.at(0)!
 		for (const port of this.ports) {
-			if (!this.controllerByPort(port))
-				return port
+			if (port.devices.size < smallest.devices.size)
+				smallest = port
+		}
+		return smallest
+	}
+
+	#dispatchChange = debounce(0, () => this.on.publish())
+
+	#resolveMetaPort(now: number) {
+		this.metaPort.devices.clear()
+		this.metaPort.devices.adds(...this.#connected.keys())
+		this.metaPort.resolve(now)
+	}
+
+	#actuateMetaActions(now: number) {
+		for (const connected of this.#connected.values()) {
+			const actions = connected.metaPort.resolve(now)
+			if (actions[metaMode].shimmyNext.down) this.shimmy(connected.device, 1)
+			if (actions[metaMode].shimmyPrevious.down) this.shimmy(connected.device, -1)
 		}
-		const index = Math.max(0, this.ports.length - 1)
-		return this.portByIndex(index)
+	}
+
+	#resolvePorts(now: number) {
+		return this.ports.map(port => {
+			port.resolve(now)
+			return port
+		})
 	}
 }
 

package/s/core/hub/meta-bindings.ts

@@ -0,0 +1,23 @@
+
+import {MetaBindings, metaMode} from "./types.js"
+
+export const makeMetaBindings = (): MetaBindings => ({
+	[metaMode]: {
+		revealOverlay: ["or",
+			"Backslash",
+			"gamepad.beta",
+			"gamepad.gamma",
+		],
+		shimmyNext: ["or",
+			"BracketRight",
+			["and", ["or", "gamepad.beta", "gamepad.gamma"], "gamepad.right"],
+			["and", ["or", "gamepad.beta", "gamepad.gamma"], "gamepad.bumper.right"],
+		],
+		shimmyPrevious: ["or",
+			"BracketLeft",
+			["and", ["or", "gamepad.beta", "gamepad.gamma"], "gamepad.left"],
+			["and", ["or", "gamepad.beta", "gamepad.gamma"], "gamepad.bumper.left"],
+		],
+	},
+})
+

package/s/core/hub/parts/connected.ts

@@ -0,0 +1,15 @@
+
+import {Port} from "../port.js"
+import {MetaBindings} from "../types.js"
+import {Device} from "../../devices/device.js"
+import {makeMetaBindings} from "../meta-bindings.js"
+
+export class Connected {
+	metaPort: Port<MetaBindings>
+
+	constructor(public device: Device, metaB = makeMetaBindings()) {
+		this.metaPort = new Port(metaB)
+		this.metaPort.devices.add(device)
+	}
+}
+

package/s/core/hub/port.ts

@@ -0,0 +1,26 @@
+
+import {SetG} from "@e280/stz"
+import {Bindings} from "../bindings/types.js"
+import {Resolver} from "../bindings/resolver.js"
+import {SampleMap} from "../bindings/sample-map.js"
+import {GroupDevice} from "../devices/infra/group.js"
+
+export class Port<B extends Bindings> extends Resolver<B> {
+	#group = new GroupDevice()
+
+	readonly devices = this.#group.devices
+	readonly modes = new SetG<keyof B>()
+
+	constructor(bindings: B) {
+		super(bindings)
+
+		// start with all modes enabled by default
+		this.modes.adds(...Object.keys(bindings))
+	}
+
+	resolve(now = Date.now()) {
+		const sampleMap = new SampleMap(this.#group.samples())
+		return super.resolve(now, this.modes, sampleMap)
+	}
+}
+

package/s/core/hub/types.ts

@@ -0,0 +1,13 @@
+
+import {AsBindings, Atom} from "../bindings/types.js"
+
+export const metaMode = "meta" as const
+
+export type MetaBindings = AsBindings<{
+	[metaMode]: {
+		revealOverlay: Atom
+		shimmyNext: Atom
+		shimmyPrevious: Atom
+	}
+}>
+

package/s/core/index.ts

@@ -1,19 +1,19 @@
 
+export * from "./bindings/action.js"
+export * from "./bindings/resolver.js"
+export * from "./bindings/sample-map.js"
 export * from "./bindings/types.js"
 
-export * as controllers from "./controllers/standard/index.js"
-export * from "./controllers/infra/group.js"
-export * from "./controllers/infra/sampler.js"
-export * from "./controllers/standard/index.js"
-export * from "./controllers/utils/modprefix.js"
-export * from "./controllers/controller.js"
-export * from "./controllers/types.js"
+export * from "./devices/infra/group.js"
+export * from "./devices/infra/sampler.js"
+export * from "./devices/standard/index.js"
+export * as devices from "./devices/standard/index.js"
+export * from "./devices/auto-gamepads.js"
+export * from "./devices/device.js"
+export * from "./devices/types.js"
 
-export * from "./hub/auto-gamepads.js"
-export * from "./hub/bindings.js"
 export * from "./hub/hub.js"
-
-export * from "./port/action.js"
-export * from "./port/port.js"
-export * from "./port/types.js"
+export * from "./hub/meta-bindings.js"
+export * from "./hub/port.js"
+export * from "./hub/types.js"
 

package/s/core/testing/testing.ts

@@ -1,10 +1,11 @@
 
 import {Hub} from "../hub/hub.js"
-import {Port} from "../port/port.js"
+import {Port} from "../hub/port.js"
+import {Device} from "../devices/device.js"
 import {asBindings} from "../bindings/types.js"
-import {hubBindings} from "../hub/bindings.js"
-import {Controller} from "../controllers/controller.js"
-import {SamplerController} from "../controllers/infra/sampler.js"
+import {Resolver} from "../bindings/resolver.js"
+import {SampleMap} from "../bindings/sample-map.js"
+import {SamplerDevice} from "../devices/infra/sampler.js"
 
 export class TestTime {
 	frame = 0
@@ -17,34 +18,38 @@ export class TestTime {
 export function testBindings() {
 	return asBindings({
 		basic: {
-			jump: [{lenses: [{code: "Space"}]}],
-			shoot: [{lenses: [{code: "pointer.button.left"}]}],
+			jump: "Space",
+			shoot: "pointer.button.left",
 		},
 	})
 }
 
-export function testConnect<C extends Controller>(switchboard: Hub<any>, controller: C) {
-	switchboard.plug(controller)
-	return controller
+export function testPlug<C extends Device>(hub: Hub<any>, device: C) {
+	hub.plug(device)
+	return device
 }
 
 export function testSetupAlpha() {
 	const time = new TestTime()
-	const controller = new SamplerController()
-	const port = new Port(testBindings())
-	port.modes.add("basic")
-	port.controllers.add(controller)
-	return {controller, port, time}
+	const device = new SamplerDevice()
+	const resolver = new Resolver(testBindings())
+	const modes = new Set(Object.keys(resolver.bindings))
+	const resolve = () => resolver.resolve(
+		time.now,
+		modes as any,
+		new SampleMap(device.samples())
+	)
+	return {device, resolver, resolve, time}
 }
 
 export function testSetupBravo() {
 	const time = new TestTime()
 	const port = () => {
-		const port = new Port(hubBindings(testBindings()))
-		port.modes.adds(Hub.mode, "basic")
+		const port = new Port(testBindings())
+		port.modes.adds("basic")
 		return port
 	}
 	const hub = new Hub([port(), port(), port(), port()])
-	return {hub: hub, time}
+	return {hub, time}
 }
 

package/s/deck/deck.ts

@@ -0,0 +1,77 @@
+
+import {Kv} from "@e280/kv"
+import {disposer, ob, range} from "@e280/stz"
+
+import {Db} from "./parts/db.js"
+import {Hub} from "../core/hub/hub.js"
+import {Port} from "../core/hub/port.js"
+import {Bindings} from "../core/bindings/types.js"
+import {mergeBindings} from "./parts/merge-bindings.js"
+import {MetaBindings, metaMode} from "../core/hub/types.js"
+import {autoGamepads} from "../core/devices/auto-gamepads.js"
+import {DeckOverlay} from "./views/deck-overlay/component.js"
+import {makeMetaBindings} from "../core/hub/meta-bindings.js"
+import {DeviceSkins} from "./parts/device-skins/device-skin.js"
+import {OverlayVisibility} from "./parts/overlay-visibility.js"
+import {PrimaryDevice} from "../core/devices/standard/primary.js"
+import { dom } from "@e280/sly"
+
+export type DeckOptions<B extends Bindings, MB extends MetaBindings = any> = {
+	kv: Kv
+	bindings: B
+	portCount: number
+	metaBindings?: MB
+}
+
+export class Deck<B extends Bindings, MB extends MetaBindings = any> {
+	static async load<B extends Bindings, MB extends MetaBindings = any>(options: DeckOptions<B, MB>) {
+		const db = await Db.load(options.kv.store("catalog"))
+
+		const ports = range(options.portCount)
+			.map(index => db.$catalog().getProfileForPort(index))
+			.map(profile => mergeBindings(options.bindings, profile?.bindings))
+			.map(bindings => new Port<B>(bindings as B))
+
+		const hub = new Hub<B>(
+			ports,
+			db.$catalog().metaBindings
+				?? options.metaBindings
+				?? makeMetaBindings(),
+		)
+
+		return new this(hub, db)
+	}
+
+	dispose = disposer()
+	deviceSkins = new DeviceSkins()
+	overlayVisibility: OverlayVisibility
+	primaryDevice = new PrimaryDevice()
+
+	views = ob({DeckOverlay}).map(fn => fn(this))
+	components = ob(this.views).map(v => v.component().props(_c => []))
+
+	registerComponents() {
+		dom.register(this.components)
+	}
+
+	constructor(
+			public hub: Hub<B, MB>,
+			public db: Db,
+		) {
+
+		this.overlayVisibility = new OverlayVisibility(hub, this.deviceSkins)
+
+		// meta reveal overlay
+		this.dispose.schedule(
+			hub.metaPort.actions[metaMode].revealOverlay.on(action => {
+				if (action.pressed)
+					this.overlayVisibility.bump()
+			})
+		)
+	}
+
+	get catalog() {
+		return this.db.$catalog()
+	}
+}
+

package/s/deck/index.ts

@@ -0,0 +1,14 @@
+
+export * from "./parts/device-skins/device-icons.js"
+export * from "./parts/device-skins/device-skin.js"
+export * from "./parts/catalog.js"
+export * from "./parts/db.js"
+export * from "./parts/local-storage-kv.js"
+export * from "./parts/merge-bindings.js"
+export * from "./parts/overlay-visibility.js"
+
+export * from "./views/deck-overlay/component.js"
+export * from "./views/deck-overlay/style.css.js"
+
+export * from "./deck.js"
+