@benev/tact 0.4.0-0 → 0.4.0-2

package/s/lib/input/data/intent/encode.ts

@@ -0,0 +1,25 @@
+
+import {Intent} from "./types.js"
+import {endian} from "../endian.js"
+import {sizeHash, sizeId, sizeIntent, sizeValue} from "./sizes.js"
+
+export function encodeIntents(hash: number, intents: Intent[]) {
+	const byteCount = sizeHash + (intents.length * sizeIntent)
+	const buffer = new ArrayBuffer(byteCount)
+	const dv = new DataView(buffer)
+	let cursor = 0
+
+	dv.setUint32(cursor, hash, endian)
+	cursor += sizeHash
+
+	for (const intent of intents) {
+		dv.setUint16(cursor, intent.id, endian)
+		cursor += sizeId
+
+		dv.setFloat32(cursor, intent.value, endian)
+		cursor += sizeValue
+	}
+
+	return buffer
+}
+

package/s/{_archive/lib3/input/data/params.ts → lib/input/data/intent/sizes.ts}

@@ -1,7 +1,6 @@
 
-export const endian = false
 export const sizeHash = 4
 export const sizeId = 2
 export const sizeValue = 4
-export const sizeIntention = sizeId + sizeValue
+export const sizeIntent = sizeId + sizeValue
 

package/s/lib/input/data/intent/types.ts

@@ -0,0 +1,6 @@
+
+export type Intent = {
+	id: number
+	value: number
+}
+

package/s/lib/input/data/parcel/decode.ts

@@ -0,0 +1,32 @@
+
+import {Parcel} from "./types.js"
+import {endian} from "../endian.js"
+import {sizeHeader, sizeLength, sizePlayerId} from "./sizes.js"
+
+export function decodeParcels(buffer: ArrayBuffer): Parcel[] {
+	const view = new DataView(buffer)
+	const parcels: Parcel[] = []
+	let cursor = 0
+
+	while (cursor < buffer.byteLength) {
+		if (buffer.byteLength - cursor < sizeHeader)
+			throw new Error("truncated header")
+
+		const playerId = view.getUint32(cursor, endian)
+		cursor += sizePlayerId
+
+		const length = view.getUint32(cursor, endian)
+		cursor += sizeLength
+
+		if (length > buffer.byteLength - cursor)
+			throw new Error("truncated data")
+
+		const intents = buffer.slice(cursor, cursor + length)
+		cursor += length
+
+		parcels.push({playerId: playerId, intents})
+	}
+
+	return parcels
+}
+

package/s/lib/input/data/parcel/encode.ts

@@ -0,0 +1,30 @@
+
+import {Parcel} from "./types.js"
+import {endian} from "../endian.js"
+
+export function encodeParcels(parcels: Parcel[]): ArrayBuffer {
+	const sizeHeader = 8
+	const size = parcels.reduce(
+		(total, {intents}) => total + sizeHeader + intents.byteLength,
+		0,
+	)
+
+	const buffer = new ArrayBuffer(size)
+	const view = new DataView(buffer)
+	const bytes = new Uint8Array(buffer)
+	let cursor = 0
+
+	for (const {playerId, intents} of parcels) {
+		view.setUint32(cursor, playerId, endian)
+		cursor += 4
+
+		view.setUint32(cursor, intents.byteLength, endian)
+		cursor += 4
+
+		bytes.set(new Uint8Array(intents), cursor)
+		cursor += intents.byteLength
+	}
+
+	return buffer
+}
+

package/s/lib/input/data/parcel/sizes.ts

@@ -0,0 +1,5 @@
+
+export const sizeLength = 4
+export const sizePlayerId = 4
+export const sizeHeader = sizePlayerId + sizeLength
+

package/s/lib/input/data/parcel/types.ts

@@ -0,0 +1,8 @@
+
+import {PlayerId} from "../../../ui/deck/types.js"
+
+export type Parcel = {
+	playerId: PlayerId
+	intents: ArrayBuffer
+}
+

package/s/lib/input/data/test.ts

@@ -0,0 +1,23 @@
+
+import {hex} from "@e280/stz"
+import {expect, suite, test} from "@e280/science"
+
+import {Parcel} from "./parcel/types.js"
+import {encodeParcels} from "./parcel/encode.js"
+import {decodeParcels} from "./parcel/decode.js"
+
+export default suite({
+	parcel: suite({
+		"roundtrip": test(async() => {
+			const dataA = hex.random(16)
+			const dataB = hex.random(32)
+			const parcels = [
+				{playerId: 0, intents: hex.toBytes(dataA).buffer},
+				{playerId: 1, intents: hex.toBytes(dataB).buffer},
+			] as Parcel[]
+			expect(decodeParcels(encodeParcels(parcels)))
+				.deep(parcels)
+		}),
+	}),
+})
+

package/s/lib/input/decoder.ts

@@ -1,6 +1,6 @@
 
-import {decodeData} from "./data/decode.js"
-import {Inputs, Bindings, InputData} from "./types.js"
+import {Inputs, Bindings} from "./types.js"
+import {decodeIntents} from "./data/intent/decode.js"
 import {investigate} from "./investigate/investigate.js"
 
 export class InputDecoder<B extends Bindings> {
@@ -14,24 +14,30 @@ export class InputDecoder<B extends Bindings> {
 		return this.#investigation.inputs
 	}
 
-	decode(...datas: InputData[]): Inputs<B> {
-		for (const input of this.#investigation.inputList) {
+	decode(...buffers: ArrayBuffer[]): Inputs<B> {
+		const inputs = this.#investigation.inputList
+
+		for (const input of inputs) {
 			input.was = input.value
-			input.delta = 0
+			input.sum = 0
 		}
 
-		for (const data of datas) {
-			const decoded = decodeData(data)
+		for (const buffer of buffers) {
+			const decoded = decodeIntents(buffer)
 
 			if (decoded.hash !== this.#investigation.hash)
 				throw new Error("intent bindings hash mismatch")
 
+			for (const input of inputs)
+				input.value = 0
+
 			for (const {id, value} of decoded.intents) {
-				const input = this.#investigation.inputList[id]
-				if (!input) throw new Error(`unknown input id ${id}`)
+				const input = inputs[id]
 				input.value = value
-				input.delta = input.value - input.was
 			}
+
+			for (const input of inputs)
+				input.sum += input.value
 		}
 
 		return this.inputs

package/s/lib/input/evaluate/context.ts

@@ -10,8 +10,7 @@ export class EvaluationContext {
 	latestValues = new Map<string, number>()
 	previousValues = new Map<string, number>()
 
-	accumulated = new Map<object, number>()
-	holding = new WeakMap<object, {start: number}>()
-	tapping = new WeakMap<object, {events: number[]}>()
+	holding = new Map<object, {start: number}>()
+	tapping = new Map<object, {events: number[]}>()
 }
 

package/s/lib/input/evaluate/evaluate.ts

@@ -1,6 +1,6 @@
 
 import {remap} from "@benev/math"
-import {arraylimit, guarantee, isNumber, isString} from "@e280/stz"
+import {arraylimit, guarantee, isHappy, isNumber, isString} from "@e280/stz"
 
 import {isDown} from "../utils/is-down.js"
 import {EvaluationContext} from "./context.js"
@@ -8,27 +8,31 @@ import type {Expression} from "../expression.js"
 
 export function evaluate(
 		context: EvaluationContext,
-		id: number,
 		expression: Expression,
 	): number {
 
-	const e = (expression: Expression) => evaluate(context, id, expression)
+	const e = (expression: Expression) => evaluate(context, expression)
+
+	if (expression === null)
+		return 0
 
 	if (isNumber(expression))
 		return expression
 
-	else if (isString(expression))
-		return context.latestValues.get(expression) ?? 0
+	else if (isString(expression)) {
+		const latest = context.latestValues.get(expression) ?? 0
+		return context.recentSamples
+			.filter(s => s.code === expression)
+			.reduce(
+				(peak, s) => Math.abs(s.value) > Math.abs(peak)
+					? s.value
+					: peak,
+				latest,
+			)
+	}
 
 	else switch (expression[0]) {
 		case "accumulate": {
-			const subexpression = expression[1]
-			const total = (context.accumulated.get(expression) ?? 0) + e(subexpression)
-			context.accumulated.set(expression, total)
-			return total
-		}
-
-		case "sum": {
 			const code = expression[1]
 			let x = 0
 			for (const sample of context.recentSamples) {
@@ -80,7 +84,7 @@ export function evaluate(
 			const [, condition, yes, no] = expression
 			return e(condition)
 				? e(yes)
-				: (no ? e(no) : 0)
+				: (isHappy(no) ? e(no) : 0)
 		}
 
 		case "min":
@@ -123,6 +127,14 @@ export function evaluate(
 		case "!!":
 			return +(e(expression[1]) !== 0)
 
+		case "-": {
+			const [, first, ...rest] = expression
+			if (rest.length === 0) return -e(first)
+			let value = e(first)
+			for (const neg of rest) value -= e(neg)
+			return value
+		}
+
 		case "clamp": {
 			const [, min, max, expr] = expression
 			const value = e(expr)
@@ -136,8 +148,8 @@ export function evaluate(
 		}
 
 		case "remap": {
-			const [, a, b, c, d, expr] = expression
-			return remap(e(expr), e(a), e(b), e(c), e(d))
+			const [a, b, c, d, value] = expression.slice(1).map(e)
+			return remap(value, a, b, c, d)
 		}
 
 		case "dt":
@@ -192,6 +204,24 @@ export function evaluate(
 			return 0
 		}
 
+		case "mod": {
+			const [, ...modifiers] = expression
+			const down = (code: string) =>
+				isDown(context.latestValues.get(code) ?? 0)
+
+			const shift = down("ShiftLeft") || down("ShiftRight")
+			const ctrl = down("ControlLeft") || down("ControlRight")
+			const alt = down("AltLeft") || down("AltRight")
+			const meta = down("MetaLeft") || down("MetaRight")
+
+			if (modifiers.includes("shift") !== shift) return 0
+			if (modifiers.includes("ctrl") !== ctrl) return 0
+			if (modifiers.includes("alt") !== alt) return 0
+			if (modifiers.includes("meta") !== meta) return 0
+
+			return 1
+		}
+
 		default:
 			throw new Error("unknown expression")
 	}

package/s/lib/input/expression.ts

@@ -1,26 +1,25 @@
 
 export type Expression = (
+	| null
 	| number // constants for doing math.
 
-	// special
-	| ["accumulate", Expression] // add each frame's result to a running total.
-
 	// samplers
 	| string // use last-known sample value for a code like "KeyW", "pointer.move.up".
-	| ["sum", string] // sum values this frame.
+	| ["accumulate", string] // sum values this frame.
 	| ["up", string] // count releases this frame.
 	| ["down", string] // count presses this frame.
 	| ["was", string] // get previously known value from before this frame.
 	| ["since", string] // get change in value since previous frame.
 
 	// logic
-	| ["if", condition: Expression, yes: Expression, no?: Expression]
+	| ["if", condition: Expression, yes: Expression, no?: Expression | null]
 
 	// combiners
 	| ["min", ...Expression[]]
 	| ["max", ...Expression[]]
 	| ["+", ...Expression[]]
 	| ["*", ...Expression[]]
+	| ["mod", ...("shift" | "ctrl" | "meta" | "alt")[]]
 
 	// comparisons
 	| ["==", Expression, Expression]
@@ -33,6 +32,7 @@ export type Expression = (
 	// transforms
 	| ["!", Expression]
 	| ["!!", Expression]
+	| ["-", Expression, ...Expression[]]
 	| ["clamp", low: Expression | null, high: Expression | null, subject: Expression]
 	| ["remap", inLow: Expression, inHigh: Expression, outLow: Expression, outHigh: Expression, subject: Expression]
 

package/s/lib/input/investigate/is-expression.ts

@@ -4,6 +4,7 @@ import type {Bindings} from "../types.js"
 import type {Expression} from "../expression.js"
 
 export function isExpression(b: Bindings): b is Expression {
+	if (b === null) return true
 	if (isString(b)) return true
 	if (isNumber(b)) return true
 	if (isArray(b)) return true

package/s/lib/input/investigate/make-input.ts

@@ -2,10 +2,6 @@
 import {Input} from "../types.js"
 
 export function makeInput(): Input {
-	return {
-		value: 0,
-		was: 0,
-		delta: 0,
-	}
+	return {value: 0, was: 0, sum: 0}
 }
 

package/s/lib/input/sources/gamepad.ts

@@ -1,7 +1,6 @@
 
 import {PlainSource} from "./plain.js"
 import {Pad} from "../utils/pad/pad.js"
-import {splitAxis} from "../utils/split-axis.js"
 
 export class GamepadSource extends PlainSource {
 	#values = new Map<string, number>()
@@ -34,21 +33,16 @@ export class GamepadSource extends PlainSource {
 
 		for (const [index, button] of gamepad.buttons.entries()) {
 			const value = button.value
-			const i = index + 1
-			this.#publish(`gamepad.button.${i}`, value)
+			this.#publish(`gamepad.${index + 1}`, value)
 			any = Math.max(any, value)
 		}
 
-		this.#publish("gamepad.button.any", any)
+		this.#publish("gamepad.any", any >= 0.9 ? 1 : 0)
 	}
 
 	#pollAxes(gamepad: Gamepad) {
 		for (const [index, value] of gamepad.axes.entries()) {
-			const i = index + 1
-			const [pos, neg] = splitAxis(value)
-			this.#publish(`gamepad.axis.${i}`, value)
-			this.#publish(`gamepad.axis.${i}.neg`, neg)
-			this.#publish(`gamepad.axis.${i}.pos`, pos)
+			this.#publish(`gamepad.axis.${index + 1}`, value)
 		}
 	}
 }

package/s/lib/input/sources/pointer.ts

@@ -2,7 +2,6 @@
 import {ev} from "@e280/stz"
 import {Vec2} from "@benev/math"
 import {PlainSource} from "./plain.js"
-import {splitAxis} from "../utils/split-axis.js"
 import {mouseButton} from "../utils/mouse-button.js"
 
 export class PointerSource extends PlainSource {
@@ -26,30 +25,13 @@ export class PointerSource extends PlainSource {
 
 		pointermove: ({clientX, clientY, movementX, movementY}: PointerEvent) => {
 			this.client.set_(clientX, clientY)
-
-			const [xPos, xNeg] = splitAxis(movementX)
-			const [yPos, yNeg] = splitAxis(movementY)
-
 			if (movementX) this.onSample.publish({code: "pointer.x", value: movementX})
-			if (xPos) this.onSample.publish({code: "pointer.x.pos", value: xPos})
-			if (xNeg) this.onSample.publish({code: "pointer.x.neg", value: xNeg})
-
 			if (movementY) this.onSample.publish({code: "pointer.y", value: movementY})
-			if (yPos) this.onSample.publish({code: "pointer.y.pos", value: yPos})
-			if (yNeg) this.onSample.publish({code: "pointer.y.neg", value: yNeg})
 		},
 
 		wheel: ({deltaX, deltaY}: WheelEvent) => {
-			const [xPos, xNeg] = splitAxis(deltaX)
-			const [yPos, yNeg] = splitAxis(deltaY)
-
 			if (deltaX) this.onSample.publish({code: "pointer.wheel.x", value: deltaX})
-			if (xPos) this.onSample.publish({code: "pointer.wheel.x.pos", value: xPos})
-			if (xNeg) this.onSample.publish({code: "pointer.wheel.x.neg", value: xNeg})
-
 			if (deltaY) this.onSample.publish({code: "pointer.wheel.y", value: deltaY})
-			if (yPos) this.onSample.publish({code: "pointer.wheel.y.pos", value: yPos})
-			if (yNeg) this.onSample.publish({code: "pointer.wheel.y.neg", value: yNeg})
 		},
 	}
 }

package/s/lib/input/test.ts

@@ -0,0 +1,194 @@
+
+import {expect, suite, test} from "@e280/science"
+
+import {asBindings} from "./types.js"
+import {Controller} from "./controller.js"
+import {PlainSource} from "./sources/plain.js"
+import {quickbind} from "./testing/quickbind.js"
+
+import parcel from "./data/test.js"
+
+export default suite({
+	parcel,
+
+	"roundtrip": test(async() => {
+		const {sample, solve} = quickbind("KeyE")
+
+		sample({code: "KeyE", value: 0})
+		expect(solve().value).is(0)
+
+		sample({code: "KeyE", value: 1})
+		const inputs = solve()
+		expect(inputs.value).is(1)
+		expect(inputs.was).is(0)
+	}),
+
+	"update bindings": test(async() => {
+		const {sample, solve, controller} = quickbind("KeyA")
+
+		sample({code: "KeyA", value: 1})
+		expect(solve().value).is(1)
+
+		sample({code: "KeyA", value: 0})
+		expect(solve().value).is(0)
+
+		controller.bindings = "KeyB"
+		expect(controller.bindings).is("KeyB")
+		sample({code: "KeyA", value: 1})
+		expect(solve().value).is(0)
+
+		sample({code: "KeyA", value: 0})
+		sample({code: "KeyB", value: 1})
+		expect(solve().value).is(1)
+	}),
+
+	"incompatible bindings throws an error": test(async() => {
+		const {controller} = quickbind({alpha: "KeyA"})
+		expect(() => controller.bindings = <any>{bravo: "KeyA"}).throws()
+	}),
+
+	"rapid transitions": test(async() => {
+		const {sample, solve} = quickbind({
+			key: "KeyE",
+			downs: ["down", "KeyE"],
+			ups: ["up", "KeyE"],
+		})
+
+		for (const value of [1, 0, 1, 0, 1])
+			sample({code: "KeyE", value})
+
+		let inputs = solve()
+		expect(inputs.key.value).is(1)
+		expect(inputs.downs.value).is(3)
+		expect(inputs.ups.value).is(2)
+
+		inputs = solve()
+		expect(inputs.key.value).is(1)
+		expect(inputs.downs.value).is(0)
+		expect(inputs.ups.value).is(0)
+	}),
+
+	"quick tap controller-level": test(async() => {
+		const {sample, solve, inputs} = quickbind("KeyE")
+
+		solve()
+		expect(inputs.sum).is(0)
+
+		for (const value of [0, 1, 0])
+			sample({code: "KeyE", value})
+
+		solve()
+		expect(inputs.sum).is(1)
+
+		solve()
+		expect(inputs.sum).is(0)
+	}),
+
+	"quick tap decoder-level": test(async() => {
+		const {sample, solve, controller, decoder, inputs} = quickbind("KeyE")
+
+		solve()
+		expect(inputs.sum).is(0)
+		const datas: ArrayBuffer[] = []
+
+		for (const value of [0, 1, 0]) {
+			sample({code: "KeyE", value})
+			datas.push(controller.encode())
+		}
+
+		decoder.decode(...datas)
+		expect(inputs.sum).is(1)
+
+		solve()
+		expect(inputs.sum).is(0)
+	}),
+
+	"double tap in one frame": test(async() => {
+		const {sample, solve} = quickbind(
+			["taps", 2, 300, ["down", "KeyE"]]
+		)
+
+		for (const value of [1, 0, 1, 0])
+			sample({code: "KeyE", value})
+
+		expect(solve(100).value).is(1)
+		expect(solve(200).value).is(0)
+	}),
+
+	"held across empty frames": test(async() => {
+		const {sample, solve} = quickbind(
+			["held", 300, "KeyE"]
+		)
+
+		solve(0)
+		sample({code: "KeyE", value: 1})
+
+		expect(solve(100).value).is(0)
+		expect(solve(399).value).is(0)
+		expect(solve(400).value).is(1)
+		expect(solve(500).value).is(1)
+
+		sample({code: "KeyE", value: 0})
+		expect(solve(501).value).is(0)
+
+		sample({code: "KeyE", value: 1})
+		expect(solve(600).value).is(0)
+		expect(solve(900).value).is(1)
+	}),
+
+	"taps and holds coexist": test(async() => {
+		const {sample, solve} = quickbind({
+			tapper: ["taps", 1, 10, ["down", "KeyE"]],
+			holder: ["held", 10, "KeyE"],
+		})
+
+		solve(0)
+
+		sample({code: "KeyE", value: 1})
+		expect(solve(1).tapper.value).is(1)
+
+		sample({code: "KeyE", value: 0})
+		const released = solve(2)
+		expect(released.tapper.value).is(0)
+		expect(released.holder.value).is(0)
+
+		sample({code: "KeyE", value: 1})
+		const pressed = solve(3)
+		expect(pressed.tapper.value).is(1)
+		expect(pressed.holder.value).is(0)
+
+		const holding = solve(13)
+		expect(holding.tapper.value).is(0)
+		expect(holding.holder.value).is(1)
+	}),
+
+	"independent controller consumers": test(async() => {
+		const source = new PlainSource()
+		const bindings = asBindings({
+			downs: ["down", "KeyE"],
+			ups: ["up", "KeyE"],
+		})
+
+		const fast = new Controller({source, bindings})
+		const slow = new Controller({source, bindings})
+
+		source.onSample.publish({code: "KeyE", value: 1})
+		expect([...fast.evaluate(1)]).deep([
+			{id: 0, value: 1},
+		])
+
+		source.onSample.publish({code: "KeyE", value: 0})
+		expect([...fast.evaluate(2)]).deep([
+			{id: 1, value: 1},
+		])
+
+		expect([...slow.evaluate(20)]).deep([
+			{id: 0, value: 1},
+			{id: 1, value: 1},
+		])
+
+		fast.dispose()
+		slow.dispose()
+	}),
+})
+

package/s/lib/input/testing/quickbind.ts

@@ -1,20 +1,21 @@
 
 import {InputDecoder} from "../decoder.js"
-import {InputEncoder} from "../encoder.js"
+import {Controller} from "../controller.js"
 import {Bindings, Sample} from "../types.js"
 import {PlainSource} from "../sources/plain.js"
 
 export function quickbind<B extends Bindings>(b: B) {
 	const source = new PlainSource()
-	const encoder = new InputEncoder(source, b)
-	const decoder = new InputDecoder(encoder.bindings)
+	const controller = new Controller({source, bindings: b})
+	const decoder = new InputDecoder(controller.bindings)
+	const {inputs} = decoder
 
 	const sample = (...samples: Sample[]) =>
 		samples.forEach(s => source.onSample.publish(s))
 
 	const solve = (time?: number) =>
-		decoder.decode(encoder.encode(time))
+		decoder.decode(controller.encode(time))
 
-	return {source, encoder, decoder, sample, solve}
+	return {source, controller, decoder, sample, solve, inputs}
 }