@benev/tact 0.1.0-3 → 0.1.0-4

package/s/core/core.test.ts

@@ -1,88 +1,100 @@
 
 import {Science, test, expect} from "@e280/science"
-import {SamplerController} from "./controllers/infra/sampler.js"
-import {testConnect, testSetupAlpha, testSetupBravo} from "./testing/testing.js"
+import {metaMode} from "./hub/types.js"
+import {SamplerDevice} from "./devices/infra/sampler.js"
+import {testPlug, testSetupAlpha, testSetupBravo} from "./testing/testing.js"
 
 export default Science.suite({
 	"sample to action value": test(async() => {
-		const {port, controller, time} = testSetupAlpha()
+		const {time, device, resolve} = testSetupAlpha()
 		{
-			controller.setSample("Space", 1)
-			const actions = port.poll(time.now)
+			time.frame = 1
+			device.setSample("Space", 1)
+			const actions = resolve()
 			expect(actions.basic.jump.value).is(1)
 			expect(actions.basic.shoot.value).is(0)
 		}
 		{
-			controller.setSample("Space", 2)
-			controller.setSample("pointer.button.left", 3)
-			const actions = port.poll(time.now)
+			time.frame = 2
+			device.setSample("Space", 2)
+			device.setSample("pointer.button.left", 3)
+			const actions = resolve()
 			expect(actions.basic.jump.value).is(2)
 			expect(actions.basic.shoot.value).is(3)
 		}
 	}),
 
 	"hub": Science.suite({
-		"controller inputs work": test(async() => {
+		"device inputs work": test(async() => {
 			const {hub, time} = testSetupBravo()
-			const c1 = testConnect(hub, new SamplerController())
-			c1.setSample("Space", 1)
+			const d1 = testPlug(hub, new SamplerDevice())
+			d1.setSample("Space", 1)
 			const [p1, p2] = hub.poll(time.now)
-			expect(p1.basic.jump.value).is(1)
-			expect(p2.basic.jump.value).is(0)
+			expect(p1.actions.basic.jump.value).is(1)
+			expect(p2.actions.basic.jump.value).is(0)
+		}),
+
+		"reveal overlay works": test(async() => {
+			const {hub, time} = testSetupBravo()
+			const d1 = testPlug(hub, new SamplerDevice())
+			d1.setSample("Backslash", 1)
+			hub.poll(time.now)
+			expect(hub.metaPort.actions[metaMode].revealOverlay.value)
+				.is(1)
 		}),
 
-		"two controllers playing on separate ports": test(async() => {
+		"two devices playing on separate ports": test(async() => {
 			const {hub, time} = testSetupBravo()
-			const c1 = testConnect(hub, new SamplerController())
-			const c2 = testConnect(hub, new SamplerController())
+			const c1 = testPlug(hub, new SamplerDevice())
+			const c2 = testPlug(hub, new SamplerDevice())
 			c1.setSample("Space", 1)
 			c2.setSample("Space", 2)
 			const [p1, p2] = hub.poll(time.now)
-			expect(p1.basic.jump.value).is(1)
-			expect(p2.basic.jump.value).is(2)
+			expect(p1.actions.basic.jump.value).is(1)
+			expect(p2.actions.basic.jump.value).is(2)
 		}),
 
-		"controller can shimmy": test(async() => {
+		"device can shimmy": test(async() => {
 			const {hub, time} = testSetupBravo()
-			const c1 = testConnect(hub, new SamplerController())
+			const c1 = testPlug(hub, new SamplerDevice())
 			hub.shimmy(c1, 1)
 			c1.setSample("Space", 1)
 			const [p1, p2] = hub.poll(time.now)
-			expect(p1.basic.jump.value).is(0)
-			expect(p2.basic.jump.value).is(1)
+			expect(p1.actions.basic.jump.value).is(0)
+			expect(p2.actions.basic.jump.value).is(1)
 		}),
 
-		"two controllers can share a port": test(async() => {
+		"two devices can share a port": test(async() => {
 			const {hub, time} = testSetupBravo()
-			const c1 = testConnect(hub, new SamplerController())
-			const c2 = testConnect(hub, new SamplerController())
+			const c1 = testPlug(hub, new SamplerDevice())
+			const c2 = testPlug(hub, new SamplerDevice())
 			hub.shimmy(c2, -1)
-			expect(hub.portByController(c1)).is(hub.portByController(c2))
+			expect(hub.portByDevice(c1)).is(hub.portByDevice(c2))
 			{
 				c1.setSample("Space", 1)
 				const [p1, p2] = hub.poll(time.now)
-				expect(p1.basic.jump.value).is(1)
-				expect(p2.basic.jump.value).is(0)
+				expect(p1.actions.basic.jump.value).is(1)
+				expect(p2.actions.basic.jump.value).is(0)
 			}
 			{
 				c2.setSample("Space", 1)
 				const [p1, p2] = hub.poll(time.now)
-				expect(p1.basic.jump.value).is(1)
-				expect(p2.basic.jump.value).is(0)
+				expect(p1.actions.basic.jump.value).is(1)
+				expect(p2.actions.basic.jump.value).is(0)
 			}
 			{
 				c1.setSample("Space", 1)
 				c2.setSample("Space", 2)
 				const [p1, p2] = hub.poll(time.now)
-				expect(p1.basic.jump.value).is(2)
-				expect(p2.basic.jump.value).is(0)
+				expect(p1.actions.basic.jump.value).is(2)
+				expect(p2.actions.basic.jump.value).is(0)
 			}
 			{
 				c1.setSample("Space", 2)
 				c2.setSample("Space", 1)
 				const [p1, p2] = hub.poll(time.now)
-				expect(p1.basic.jump.value).is(2)
-				expect(p2.basic.jump.value).is(0)
+				expect(p1.actions.basic.jump.value).is(2)
+				expect(p2.actions.basic.jump.value).is(0)
 			}
 		}),
 	}),

package/s/core/devices/auto-gamepads.ts

@@ -0,0 +1,8 @@
+
+import {gamepads} from "../../utils/gamepads.js"
+import {GamepadDevice} from "./standard/gamepad.js"
+
+export function autoGamepads(fn: (device: GamepadDevice) => () => void) {
+	return gamepads(pad => fn(new GamepadDevice(pad)))
+}
+

package/s/core/devices/device.ts

@@ -0,0 +1,12 @@
+
+import {Sample} from "./types.js"
+
+export abstract class Device {
+	abstract samples(): Iterable<Sample>
+
+	;*[Symbol.iterator]() {
+		for (const sample of this.samples())
+			yield sample
+	}
+}
+

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

@@ -0,0 +1,24 @@
+
+import {SetG} from "@e280/stz"
+import {Device} from "../device.js"
+import {SampleMap} from "../../bindings/sample-map.js"
+
+export class GroupDevice extends Device {
+	devices = new SetG<Device>()
+	#sampleMap = new SampleMap()
+
+	constructor(...devices: Device[]) {
+		super()
+		this.devices.adds(...devices)
+	}
+
+	;*samples() {
+		this.#sampleMap.zero()
+		for (const device of this.devices) {
+			for (const sample of device.samples())
+				this.#sampleMap.mergeSample(sample)
+		}
+		yield* this.#sampleMap.entries()
+	}
+}
+

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

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

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

@@ -0,0 +1,83 @@
+
+import {Vec2} from "@benev/math"
+import {Pad} from "../../../utils/gamepads.js"
+import {SamplerDevice} from "../infra/sampler.js"
+import {splitVector} from "../../../utils/split-axis.js"
+import {circularClamp} from "../../../utils/circular-clamp.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 {
+	range = new Vec2(0.2, 0.9)
+
+	constructor(public pad: Pad) {
+		super()
+	}
+
+	get gamepad() {
+		return this.pad.gamepad
+	}
+
+	samples() {
+		this.#pollButtons(this.pad.gamepad)
+		this.#pollSticks(this.pad.gamepad)
+		return super.samples()
+	}
+
+	#pollButtons(gamepad: Gamepad) {
+		let anyButtonValue = 0
+
+		const recordAny = (value: number) => {
+			anyButtonValue = Math.max(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 [leftX, leftY, rightX, rightY] = gamepad.axes
+
+		const stickLeft = splitVector(
+			circularClamp(new Vec2(leftX, leftY), this.range)
+		)
+
+		const stickRight = splitVector(
+			circularClamp(new Vec2(rightX, rightY), this.range)
+		)
+
+		this.setSample("gamepad.stick.left.up", stickLeft.up)
+		this.setSample("gamepad.stick.left.down", stickLeft.down)
+		this.setSample("gamepad.stick.left.left", stickLeft.left)
+		this.setSample("gamepad.stick.left.right", stickLeft.right)
+
+		this.setSample("gamepad.stick.right.up", stickRight.up)
+		this.setSample("gamepad.stick.right.down", stickRight.down)
+		this.setSample("gamepad.stick.right.left", stickRight.left)
+		this.setSample("gamepad.stick.right.right", stickRight.right)
+	}
+}
+

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

@@ -2,6 +2,7 @@
 export * from "./gamepad.js"
 export * from "./keyboard.js"
 export * from "./pointer.js"
+export * from "./primary.js"
 export * from "./stick.js"
-export * from "./virtual-gamepad.js"
+export * from "./vpad.js"
 

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

@@ -0,0 +1,31 @@
+
+import {disposer, ev} from "@e280/stz"
+import {SamplerDevice} from "../infra/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)
+		},
+		keyup: (event: KeyboardEvent) => {
+			if (event.repeat) return null
+			this.setSample(event.code, 0)
+		},
+	}
+
+	#windowListeners = {
+		blur: () => {
+			this.sampleMap.zero()
+		},
+	}
+}
+

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

@@ -1,25 +1,25 @@
 
-import {ev} from "@e280/stz"
 import {Vec2} from "@benev/math"
+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()
 
-		this.dispose = ev(target, {
+		this.dispose.schedule(ev(target, {
 			pointerdown: (event: PointerEvent) => {
-				const code = PointerController.buttonCode(event)
+				const code = PointerDevice.buttonCode(event)
 				this.setSample(code, 1)
 			},
 
 			pointerup: (event: PointerEvent) => {
-				const code = PointerController.buttonCode(event)
+				const code = PointerDevice.buttonCode(event)
 				this.setSample(code, 0)
 			},
 
@@ -31,10 +31,10 @@ export class PointerController extends SamplerController {
 			},
 
 			wheel: (event: WheelEvent) => {
-				for (const [code, value] of PointerController.wheelCodes(event))
+				for (const [code, value] of PointerDevice.wheelCodes(event))
 					this.setSample(code, value)
 			},
-		})
+		}))
 	}
 
 	static buttonCode(event: PointerEvent) {
@@ -64,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)
@@ -83,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 {HubFriendlyBindings, hubMode} from "./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 HubFriendlyBindings> {
-	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 HubFriendlyBindings> {
 		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
+		})
 	}
 }