@benev/tact 0.1.0-1

package/s/station/station.test.ts

@@ -0,0 +1,86 @@
+
+import {Science, test, expect} from "@e280/science"
+import {SamplerDevice} from "./devices/infra/sampler.js"
+import {testConnect, testSetupAlpha, testSetupBravo} from "./testing/testing.js"
+
+export default Science.suite({
+	"sample to action value": test(async() => {
+		const {station, device, time} = testSetupAlpha()
+		expect(station.actions.basic.jump.value).is(0)
+		expect(station.actions.basic.shoot.value).is(0)
+		device.setSample("Space", 1)
+		station.poll(time.now)
+		expect(station.actions.basic.jump.value).is(1)
+		expect(station.actions.basic.shoot.value).is(0)
+		device.setSample("Space", 2)
+		device.setSample("pointer.button.left", 3)
+		station.poll(time.now)
+		expect(station.actions.basic.jump.value).is(2)
+		expect(station.actions.basic.shoot.value).is(3)
+	}),
+
+	"switchboard": Science.suite({
+		"player1 inputs work": test(async() => {
+			const {switchboard, time} = testSetupBravo()
+			const [s1, s2] = switchboard.stations
+			const d1 = testConnect(switchboard, new SamplerDevice())
+			expect(s1.actions.basic.jump.value).is(0)
+			expect(s2.actions.basic.jump.value).is(0)
+			d1.setSample("Space", 1)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(1)
+			expect(s2.actions.basic.jump.value).is(0)
+		}),
+
+		"two devices playing on separate stations": test(async() => {
+			const {switchboard, time} = testSetupBravo()
+			const [s1, s2] = switchboard.stations
+			const d1 = testConnect(switchboard, new SamplerDevice())
+			const d2 = testConnect(switchboard, new SamplerDevice())
+			d1.setSample("Space", 1)
+			d2.setSample("Space", 2)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(1)
+			expect(s2.actions.basic.jump.value).is(2)
+		}),
+
+		"player can shimmy": test(async() => {
+			const {switchboard, time} = testSetupBravo()
+			const [s1, s2] = switchboard.stations
+			const d1 = testConnect(switchboard, new SamplerDevice())
+			switchboard.shimmy(d1, 1)
+			d1.setSample("Space", 1)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(0)
+			expect(s2.actions.basic.jump.value).is(1)
+		}),
+
+		"two players can share a station": test(async() => {
+			const {switchboard, time} = testSetupBravo()
+			const [s1, s2] = switchboard.stations
+			const d1 = testConnect(switchboard, new SamplerDevice())
+			const d2 = testConnect(switchboard, new SamplerDevice())
+			switchboard.shimmy(d2, -1)
+			expect(switchboard.stationByDevice(d1)).is(switchboard.stationByDevice(d2))
+			d1.setSample("Space", 1)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(1)
+			expect(s2.actions.basic.jump.value).is(0)
+			d2.setSample("Space", 1)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(1)
+			expect(s2.actions.basic.jump.value).is(0)
+			d1.setSample("Space", 1)
+			d2.setSample("Space", 2)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(2)
+			expect(s2.actions.basic.jump.value).is(0)
+			d1.setSample("Space", 2)
+			d2.setSample("Space", 1)
+			switchboard.poll(time.now)
+			expect(s1.actions.basic.jump.value).is(2)
+			expect(s2.actions.basic.jump.value).is(0)
+		}),
+	}),
+})
+

package/s/station/station.ts

@@ -0,0 +1,47 @@
+
+import {SetG} from "@e280/stz"
+import {Resolver} from "./parts/resolver.js"
+import {Bindings, SampleMap} from "./types.js"
+import {Device} from "./devices/infra/device.js"
+import {aggregate_samples_into_map} from "./parts/routines/aggregate_samples_into_map.js"
+
+export class Station<B extends Bindings> {
+	readonly modes = new SetG<keyof B>()
+	readonly devices = new SetG<Device>()
+
+	#resolver: Resolver<B>
+	#samples: SampleMap = new Map()
+
+	constructor(bindings: B) {
+		this.#resolver = new Resolver(bindings, this.modes, this.#samples)
+	}
+
+	get actions() {
+		return this.#resolver.actions
+	}
+
+	get bindings() {
+		return this.#resolver.bindings
+	}
+
+	set bindings(bindings: B) {
+		this.#resolver.bindings = bindings
+	}
+
+	addModes(...modes: (keyof B)[]) {
+		this.modes.adds(...modes)
+		return this
+	}
+
+	addDevices(...devices: Device[]) {
+		this.devices.adds(...devices)
+		return this
+	}
+
+	poll(now: number) {
+		this.#samples.clear()
+		aggregate_samples_into_map(this.devices, this.#samples)
+		this.#resolver.poll(now)
+	}
+}
+

package/s/station/switchboard.ts

@@ -0,0 +1,107 @@
+
+import {SetG} from "@e280/stz"
+import {Scalar} from "@benev/math"
+import {Station} from "./station.js"
+import {Device} from "./devices/infra/device.js"
+import {switchboardMode, SwitchboardBindings} from "./types.js"
+import {switchboardBindings} from "./parts/switchboard-bindings.js"
+
+export class Switchboard<B extends SwitchboardBindings> {
+	static readonly mode = switchboardMode
+	static readonly bindings = switchboardBindings
+
+	readonly devices = new SetG<Device>()
+
+	constructor(public readonly stations: Station<B>[]) {
+		for (const station of stations) {
+			const fn = (delta: 1 | -1) => () => {
+				const device = this.deviceByStation(station)
+				if (device) this.shimmy(device, delta)
+			}
+			station.actions.switchboard.shimmyNext.onDown(fn(1))
+			station.actions.switchboard.shimmyPrevious.onDown(fn(-1))
+			station.modes.add(Switchboard.mode)
+		}
+	}
+
+	*[Symbol.iterator]() {
+		yield* this.stations.values()
+	}
+
+	*entries() {
+		yield* this.stations.entries()
+	}
+
+	/** poll all the stations */
+	poll(now: number) {
+		for (const station of this.stations)
+			station.poll(now)
+	}
+
+	/** check if a station has a known switchboard device assigned */
+	isActive(station: Station<B>) {
+		return !!this.deviceByStation(station)
+	}
+
+	stationByIndex(index: number) {
+		const station = this.stations.at(index)
+		if (!station) throw new Error(`station ${index} not found`)
+		return station
+	}
+
+	stationByDevice(device: Device) {
+		for (const station of this.stations) {
+			if (station.devices.has(device))
+				return station
+		}
+	}
+
+	deviceByStation(station: Station<B>) {
+		for (const device of this.devices) {
+			if (station.devices.has(device))
+				return device
+		}
+	}
+
+	/** move a player's device to the next or previous station */
+	shimmy(device: Device, indexDelta: 1 | -1) {
+		const oldIndex = this.stations.findIndex(station => station.devices.has(device))
+		const maxIndex = Math.max(0, this.stations.length - 1)
+		const newIndex = Scalar.clamp(oldIndex + indexDelta, 0, maxIndex)
+		const station = this.stationByIndex(newIndex)
+		this.connect(device, station)
+		return station
+	}
+
+	/** connect-or-assign a device to a station */
+	connect<D extends Device>(
+			device: D,
+			station: Station<B> = this.chooseLonelyStation(),
+		) {
+		this.#removeDeviceFromAllStations(device)
+		this.devices.add(device)
+		station.devices.add(device)
+		return () => this.disconnect(device)
+	}
+
+	/** unplug a player's device */
+	disconnect(device: Device) {
+		this.#removeDeviceFromAllStations(device)
+		this.devices.delete(device)
+	}
+
+	/** returns an unassigned station (otherwise the last one) */
+	chooseLonelyStation() {
+		for (const station of this.stations) {
+			if (!this.deviceByStation(station))
+				return station
+		}
+		const index = Math.max(0, this.stations.length - 1)
+		return this.stationByIndex(index)
+	}
+
+	#removeDeviceFromAllStations(device: Device) {
+		this.stations.forEach(station => station.devices.delete(device))
+	}
+}
+

package/s/station/testing/testing.ts

@@ -0,0 +1,47 @@
+
+import {Station} from "../station.js"
+import {asBindings} from "../types.js"
+import {Switchboard} from "../switchboard.js"
+import {Device} from "../devices/infra/device.js"
+import {SamplerDevice} from "../devices/infra/sampler.js"
+import {switchboardBindings} from "../parts/switchboard-bindings.js"
+
+export class TestTime {
+	frame = 0
+
+	get now() {
+		return (this.frame++) * (1000 / 60)
+	}
+}
+
+export function testBindings() {
+	return asBindings({
+		basic: {
+			jump: [{lenses: [{code: "Space"}]}],
+			shoot: [{lenses: [{code: "pointer.button.left"}]}],
+		},
+	})
+}
+
+export function testConnect<D extends Device>(switchboard: Switchboard<any>, device: D) {
+	switchboard.connect(device)
+	return device
+}
+
+export function testSetupAlpha() {
+	const time = new TestTime()
+	const device = new SamplerDevice()
+	const station = new Station(testBindings())
+		.addModes("basic")
+		.addDevices(device)
+	return {device, station, time}
+}
+
+export function testSetupBravo() {
+	const time = new TestTime()
+	const station = () => new Station(switchboardBindings(testBindings()))
+		.addModes(Switchboard.mode, "basic")
+	const switchboard = new Switchboard([station(), station(), station(), station()])
+	return {switchboard, time}
+}
+

package/s/station/types.ts

@@ -0,0 +1,72 @@
+
+import {Action} from "./parts/action.js"
+
+export type Actions<B extends Bindings> = {
+	[Mode in keyof B]: {
+		[K in keyof B[Mode]]: Action
+	}
+}
+
+export type Sample = [code: string, value: number]
+export type SampleMap = Map<string, number>
+
+export type Timing = (
+	| DirectTiming
+	| TapTiming
+	| HoldTiming
+)
+
+export type DirectTiming = {style: "direct"}
+export type TapTiming = {style: "tap", holdTime?: number}
+export type HoldTiming = {style: "hold", holdTime?: number}
+
+export type LensSettings = {
+	scale: number
+	invert: boolean
+	deadzone: number
+	timing: Timing
+}
+
+export type Lens = {
+	code: string
+	settings?: Partial<LensSettings>
+}
+
+export type LensState = {
+	lastValue: number
+	holdStart: number
+}
+
+export type Spoon = {
+	lenses: Lens[]
+	required?: Lens[]
+	forbidden?: Lens[]
+}
+
+export type Fork = Spoon[]
+
+export type Bracket = {
+	[action: string]: Spoon[]
+}
+
+export type Bindings = {
+	[mode: string]: Bracket
+}
+
+export type AsBindings<B extends Bindings> = B
+
+export function asBindings<B extends Bindings>(bindings: B) {
+	return bindings
+}
+
+export const switchboardMode = "switchboard" as const
+
+export type AsSwitchboardBindings<B extends Bindings> = {
+	[switchboardMode]: {
+		shimmyNext: Spoon[],
+		shimmyPrevious: Spoon[],
+	}
+} & B
+
+export type SwitchboardBindings = AsSwitchboardBindings<Bindings>
+

package/s/station/utils/is-pressed.ts

@@ -0,0 +1,5 @@
+
+export function isPressed(value: number) {
+	return value > 0
+}
+

package/s/station/utils/modprefix.ts

@@ -0,0 +1,16 @@
+
+export function modprefix(event: KeyboardEvent | PointerEvent | WheelEvent, code: string) {
+	const modifiers: string[] = []
+
+	if (event.ctrlKey) modifiers.push("ctrl")
+	if (event.altKey) modifiers.push("alt")
+	if (event.metaKey) modifiers.push("meta")
+	if (event.shiftKey) modifiers.push("shift")
+
+	const prefix = modifiers.length > 0
+		? [...modifiers].join("-")
+		: "x"
+
+	return `${prefix}-${code}`
+}
+

package/s/station/utils/tmax.ts

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

package/s/station/utils/tmin.ts

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

package/s/tests.test.ts

@@ -0,0 +1,8 @@
+
+import {Science} from "@e280/science"
+import station from "./station/station.test.js"
+
+await Science.run({
+	station,
+})
+

package/s/utils/evergreen.ts

@@ -0,0 +1,10 @@
+
+export function evergreen<V>(value: V, fn: () => V | null | undefined) {
+	let cached = value
+	return () => {
+		const next = fn()
+		if (next !== undefined && next !== null) cached = next
+		return cached
+	}
+}
+

package/s/utils/gamepads.ts

@@ -0,0 +1,41 @@
+
+import {Disposable, ev, MapG} from "@e280/stz"
+import {evergreen} from "./evergreen.js"
+
+/** stable reference to a gamepad, has a getter to get the latest gamepad snapshot */
+export class Pad {
+	constructor(private get: () => Gamepad) {}
+
+	get gamepad() {
+		return this.get()
+	}
+}
+
+/** track gamepad lifecycles as they connect or disconnect */
+export function gamepads(on: (pad: Pad) => () => void) {
+	const pads = new MapG<number, {pad: Pad, dispose: () => void}>()
+	return ev(window, {
+		gamepadconnected: ({gamepad}: GamepadEvent) => {
+			const get = () => navigator.getGamepads().at(gamepad.index)
+			const pad = new Pad(evergreen(gamepad, get))
+			const dispose = on(pad)
+			pads.set(gamepad.index, {pad, dispose})
+		},
+
+		gamepaddisconnected: ({gamepad}: GamepadEvent) => {
+			const result = pads.get(gamepad.index)
+			if (result) {
+				pads.delete(gamepad.index)
+				result.dispose()
+			}
+		},
+	})
+}
+
+export class Gamepads implements Disposable {
+	dispose: () => void
+	constructor(public on: (pad: Pad) => () => void) {
+		this.dispose = gamepads(on)
+	}
+}
+

package/s/utils/split-axis.ts

@@ -0,0 +1,7 @@
+
+export function splitAxis(n: number) {
+	return (n >= 0)
+		? [0, n]
+		: [Math.abs(n), 0]
+}
+

package/x/demo/main.bundle.d.ts

@@ -0,0 +1 @@
+export {};

package/x/demo/main.bundle.js

@@ -0,0 +1,11 @@
+import { $, view } from "@e280/sly";
+import { NubStick } from "../nubs/stick/view.js";
+import { StickDevice } from "../nubs/stick/device.js";
+$.register({
+    TactDemo: view.component(use => {
+        const stick = use.once(() => new StickDevice());
+        return NubStick(stick);
+    }),
+});
+console.log("tact");
+//# sourceMappingURL=main.bundle.js.map

package/x/demo/main.bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.bundle.js","sourceRoot":"","sources":["../../s/demo/main.bundle.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAE,IAAI,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAC,WAAW,EAAC,MAAM,yBAAyB,CAAA;AAEnD,CAAC,CAAC,QAAQ,CAAC;IACV,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;QAC9B,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC,CAAA;QAC/C,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAA;IACvB,CAAC,CAAC;CACF,CAAC,CAAA;AAEF,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA"}