@antha/input 0.8.0 → 0.10.0

package/dist/bindings/antha-input-bindings.mod.js

@@ -65,6 +65,7 @@ export function createAnthaInputBindingsMod(options = {}) {
 const gamepadInputDeviceKeys = getEnumValues(GamepadInputDeviceKey);
 function filterRawInput(entry, binding) {
     return (entry?.direction === binding.direction &&
+        !entry.isIgnoredByConsumer &&
         (binding.gamepadBrand ? binding.gamepadBrand === entry.mapped.gamepadBrand : true));
 }
 function readPlayerBindings({ bindingsMap, activeBindingsMap, rawInputs, msSinceLastExecute, gamepadKeyMap, }) {
@@ -103,6 +104,7 @@ function readPlayerBindings({ bindingsMap, activeBindingsMap, rawInputs, msSince
                 holdDuration: {
                     milliseconds: Math.round(durationMs),
                 },
+                rawInputs: matchingInputs,
                 value,
                 actCount: previousActiveBinding?.actCount || 0,
                 lastActDuration: previousActiveBinding?.lastActDuration || {

package/dist/bindings/antha-menu-nav.mod.d.ts

@@ -1,6 +1,6 @@
 import { type AnyDuration } from 'date-vir';
 import { NavController, type NavControllerOptions } from 'device-navigation';
-import { type BindingAssignments, type PlayersActiveBindings } from './player-bindings.js';
+import { type BindingAssignments, type PlayerPosition, type PlayersActiveBindings } from './player-bindings.js';
 export { nav, navAttribute, NavController } from 'device-navigation';
 /**
  * All supported menu navigation bindings. To ignore any, simply don't allow players to bind to
@@ -87,6 +87,11 @@ export type MenuNavOptions = Readonly<Partial<{
 export type MenuNavModState = {
     /** Set to true to enable menu navigation. */
     isInMenu: boolean;
+    /**
+     * When defined, only players explicitly set to true may use menu navigation. Omit this or set
+     * to `undefined` to allow every player to run menu navigation.
+     */
+    allowedPlayerMenuNavigation: Partial<Record<PlayerPosition, boolean>> | undefined;
     /** Omit or set to `undefined` to disable menu nav. */
     menuNavOptions: Required<MenuNavOptions> | undefined;
     /** All active bindings for all players. */
@@ -102,6 +107,15 @@ export declare const defaultMenuNavOptions: Required<MenuNavOptions>;
  * @category Pre-Built Mods
  */
 export declare function createAnthaMenuNavMod(options?: Readonly<MenuNavOptions & NavControllerOptions>): import("@antha/engine").AnthaMod<NoInfer<MenuNavModState>>;
+/**
+ * Checks whether the given player may use menu navigation under the current allowlist.
+ *
+ * @category Internal
+ */
+export declare function isPlayerMenuNavigationAllowed({ allowedPlayerMenuNavigation, playerPosition, }: Readonly<{
+    allowedPlayerMenuNavigation: MenuNavModState['allowedPlayerMenuNavigation'];
+    playerPosition: PlayerPosition;
+}>): boolean;
 /**
  * The mod created by {@link createAnthaMenuNavMod}.
  *

package/dist/bindings/antha-menu-nav.mod.js

@@ -1,7 +1,7 @@
 import { defineAnthaMod } from '@antha/engine';
 import { KnownInput } from '@antha/gamepad-type';
 import { check } from '@augment-vir/assert';
-import { getObjectTypedEntries, getObjectTypedValues } from '@augment-vir/common';
+import { getObjectTypedEntries } from '@augment-vir/common';
 import { convertDuration } from 'date-vir';
 import { NavController, NavDirection, NavValue } from 'device-navigation';
 import { InputDirection } from '../raw-inputs/raw-input.js';
@@ -262,6 +262,7 @@ export function createAnthaMenuNavMod(options = {}) {
             else if (!state.isInMenu) {
                 consumeInactiveMenuActivationBindings({
                     activeBindings: state.activeBindings,
+                    allowedPlayerMenuNavigation: state.allowedPlayerMenuNavigation,
                 });
                 return;
             }
@@ -274,7 +275,13 @@ export function createAnthaMenuNavMod(options = {}) {
             const minimumDirectionalInputValue = state.menuNavOptions.minimumDirectionalInputValue;
             const bindingsToAct = {};
             const activeMenuBindings = {};
-            getObjectTypedValues(state.activeBindings).forEach((playerActiveBindings) => {
+            getObjectTypedEntries(state.activeBindings).forEach(([playerPosition, playerActiveBindings,]) => {
+                if (!isPlayerMenuNavigationAllowed({
+                    allowedPlayerMenuNavigation: state.allowedPlayerMenuNavigation,
+                    playerPosition,
+                })) {
+                    return;
+                }
                 getObjectTypedEntries(playerActiveBindings).forEach(([bindingName, activeBinding,]) => {
                     if (!check.isEnumValue(bindingName, MenuNavBinding)) {
                         return;
@@ -284,7 +291,8 @@ export function createAnthaMenuNavMod(options = {}) {
                         activeBinding.value >= minimumDirectionalInputValue) &&
                         (!activeBinding.actCount ||
                             (directionalMenuNavBindings.includes(bindingName) &&
-                                activeBinding.holdDuration.milliseconds >= repeatThreshold &&
+                                activeBinding.holdDuration.milliseconds >=
+                                    repeatThreshold &&
                                 activeBinding.holdDuration.milliseconds -
                                     activeBinding.lastActDuration.milliseconds >
                                     repeatInterval))) {
@@ -352,8 +360,14 @@ export function createAnthaMenuNavMod(options = {}) {
         },
     });
 }
-function consumeInactiveMenuActivationBindings({ activeBindings, }) {
-    getObjectTypedValues(activeBindings).forEach((playerActiveBindings) => {
+function consumeInactiveMenuActivationBindings({ activeBindings, allowedPlayerMenuNavigation, }) {
+    getObjectTypedEntries(activeBindings).forEach(([playerPosition, playerActiveBindings,]) => {
+        if (!isPlayerMenuNavigationAllowed({
+            allowedPlayerMenuNavigation,
+            playerPosition,
+        })) {
+            return;
+        }
         [
             MenuNavBinding.MenuEnter,
             MenuNavBinding.MenuExit,
@@ -367,3 +381,11 @@ function consumeInactiveMenuActivationBindings({ activeBindings, }) {
         });
     });
 }
+/**
+ * Checks whether the given player may use menu navigation under the current allowlist.
+ *
+ * @category Internal
+ */
+export function isPlayerMenuNavigationAllowed({ allowedPlayerMenuNavigation, playerPosition, }) {
+    return (allowedPlayerMenuNavigation == undefined || !!allowedPlayerMenuNavigation[playerPosition]);
+}

package/dist/bindings/player-bindings.d.ts

@@ -1,5 +1,5 @@
-import { type GamepadInputDeviceKey, type InputDeviceKey } from 'input-device-handler';
-import { type InputDirection } from '../raw-inputs/raw-input.js';
+import { InputDeviceKey, type GamepadInputDeviceKey } from 'input-device-handler';
+import { InputDirection, type RawInput } from '../raw-inputs/raw-input.js';
 /**
  * A mapping of gamepad keys that simply allows them to be interpreted as different keys. This is
  * useful for mapping a controller in any port to any other port. For example, mapping the
@@ -49,6 +49,28 @@ export type BindingAssignment = {
  * @category Internal
  */
 export type PlayerPosition = `${number}`;
+/**
+ * Shape definition for {@link BindingAssignment}.
+ *
+ * @category Internal
+ */
+export declare const bindingAssignmentShape: import("object-shape-tester").Shape<{
+    deviceKey: import("object-shape-tester").Shape<import("@sinclair/typebox").TUnion<(import("@sinclair/typebox").TLiteral<"0"> | import("@sinclair/typebox").TLiteral<"1"> | import("@sinclair/typebox").TLiteral<"2"> | import("@sinclair/typebox").TLiteral<"3"> | import("@sinclair/typebox").TLiteral<"mouse"> | import("@sinclair/typebox").TLiteral<"keyboard"> | import("@sinclair/typebox").TLiteral<"any-gamepad">)[]>>;
+    direction: import("object-shape-tester").Shape<import("@sinclair/typebox").TUnion<(import("@sinclair/typebox").TLiteral<InputDirection.Flat> | import("@sinclair/typebox").TLiteral<InputDirection.Negative> | import("@sinclair/typebox").TLiteral<InputDirection.Positive>)[]>>;
+    gamepadBrand: import("object-shape-tester").Shape<import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<string>>>;
+    inputName: import("object-shape-tester").Shape<import("@sinclair/typebox").TUnsafe<string>>;
+}>;
+/**
+ * Shape definition for {@link PlayersBindingAssignments}.
+ *
+ * @category Internal
+ */
+export declare const playersBindingAssignmentsShape: import("object-shape-tester").Shape<import("@sinclair/typebox").TUnsafe<Partial<Record<`${number}`, Partial<Record<string, {
+    gamepadBrand?: string;
+    deviceKey: "0" | "1" | "2" | "3" | "mouse" | "keyboard" | "any-gamepad";
+    inputName: string;
+    direction: InputDirection;
+}[]>>>>>>;
 /**
  * A collection of bindings for a single player. Used in `createAnthaReadBindingsMod` and
  * {@link PlayersBindingAssignments}.
@@ -69,6 +91,8 @@ export type PlayersBindingAssignments<BindingNames extends string = string> = Re
  * @category Internal
  */
 export type ActiveBinding = {
+    /** The currently active raw inputs that contribute to this binding. */
+    rawInputs: RawInput[];
     /**
      * The full duration for which the current binding has been active in its current direction.
      * When an active is first pressed, this will be 0 milliseconds.

package/dist/bindings/player-bindings.js

@@ -1,6 +1,37 @@
+import { InputDeviceKey } from 'input-device-handler';
+import { defineShape, enumShape, nonEmptyStringShape, optionalShape, recordShape, typedStringShape, } from 'object-shape-tester';
+import { InputDirection } from '../raw-inputs/raw-input.js';
 /**
  * A binding assignment device key that maps the input to _any_ connected controller.
  *
  * @category Internal
  */
 export const AnyGamepad = 'any-gamepad';
+/**
+ * Shape definition for {@link BindingAssignment}.
+ *
+ * @category Internal
+ */
+export const bindingAssignmentShape = defineShape({
+    deviceKey: enumShape({
+        ...InputDeviceKey,
+        AnyGamepad,
+    }),
+    direction: enumShape(InputDirection),
+    gamepadBrand: optionalShape(nonEmptyStringShape()),
+    inputName: nonEmptyStringShape(),
+});
+/**
+ * Shape definition for {@link PlayersBindingAssignments}.
+ *
+ * @category Internal
+ */
+export const playersBindingAssignmentsShape = recordShape({
+    keys: typedStringShape(),
+    partial: true,
+    values: recordShape({
+        keys: '',
+        partial: true,
+        values: [bindingAssignmentShape],
+    }),
+});

package/dist/raw-inputs/antha-read-raw-input.mod.d.ts

@@ -20,6 +20,7 @@ export type AnthaReadRawInputModOptions = PartialWithUndefined<{
      */
     deviceHandlerOptions: Omit<InputDeviceHandlerOptions, 'startLoopImmediately'>;
     debugRawInputs: AnthaReadRawInputModState['debugRawInputs'];
+    startRawInputConsumer: AnthaReadRawInputModState['rawInputConsumer'];
 }>;
 /**
  * All state used by and set by `createAnthaReadRawInputMod`.
@@ -29,6 +30,8 @@ export type AnthaReadRawInputModOptions = PartialWithUndefined<{
 export type AnthaReadRawInputModState = {
     deviceHandler: Pick<InputDeviceHandler, 'readAllDevices'>;
     rawInputs: RawInputs;
+    /** Identifies the part of the game that owns newly started raw inputs. */
+    rawInputConsumer: string | undefined;
     currentInputDevices: SimpleInputDevicesMap;
     /** The engine time when a timed input lock expires. */
     inputDisableEndsAt: EngineTime | undefined;
@@ -78,6 +81,7 @@ export type AnthaReadRawInputMod = ReturnType<typeof createAnthaReadRawInputMod>
  */
 export declare function readRawInputs(state: SetRequired<SelectFrom<Partial<AnthaReadRawInputModState>, {
     rawInputs: true;
+    rawInputConsumer: true;
     deviceHandler: true;
     gamepadLayouts: true;
     gamepadBrandMap: true;

package/dist/raw-inputs/antha-read-raw-input.mod.js

@@ -17,6 +17,7 @@ export function createAnthaReadRawInputMod(options = {}) {
         initState: {
             debugRawInputs: !!options.debugRawInputs,
             inputDisableEndsAt: undefined,
+            rawInputConsumer: options.startRawInputConsumer,
         },
         execute({ engine, state, msSinceLastExecute }) {
             if (state.inputDisableEndsAt != undefined &&
@@ -67,14 +68,18 @@ export function readRawInputs(state, { msSinceLastExecute, }) {
         const deviceInputs = {};
         Object.values(device.currentInputs).forEach((currentInput) => {
             const direction = calculateInputDirection(currentInput.inputValue);
-            const previousRawInput = state.rawInputs?.[deviceKey]?.[currentInput.inputName];
-            const duration = previousRawInput?.direction === direction
-                ? {
-                    milliseconds: Math.round(previousRawInput.duration.milliseconds + msSinceLastExecute),
-                }
-                : {
-                    milliseconds: 0,
-                };
+            const potentialPreviousRawInput = state.rawInputs?.[deviceKey]?.[currentInput.inputName];
+            const previousRawInput = potentialPreviousRawInput?.direction === direction
+                ? potentialPreviousRawInput
+                : undefined;
+            const consumedBy = previousRawInput
+                ? previousRawInput.consumedBy
+                : state.rawInputConsumer;
+            const duration = {
+                milliseconds: previousRawInput
+                    ? Math.round(previousRawInput.duration.milliseconds + msSinceLastExecute)
+                    : 0,
+            };
             const layout = isGamepadDeviceKey(deviceKey)
                 ? findMatchingGamepadLayout({
                     layouts: state.gamepadLayouts || defaultGamepadLayouts,
@@ -99,6 +104,7 @@ export function readRawInputs(state, { msSinceLastExecute, }) {
                 gamepadModel: model?.gamepadModel,
             });
             const rawInput = {
+                consumedBy,
                 mapped: {
                     deviceName: model?.gamepadModel || device.deviceName,
                     gamepadBrand: model?.gamepadBrand,
@@ -111,6 +117,9 @@ export function readRawInputs(state, { msSinceLastExecute, }) {
                 duration,
                 inputName: currentInput.inputName,
                 inputValue: currentInput.inputValue,
+                isIgnoredByConsumer: !!state.rawInputConsumer &&
+                    !!consumedBy &&
+                    consumedBy !== state.rawInputConsumer,
             };
             if (mappedInputName) {
                 deviceInputs[mappedInputName] = rawInput;

package/dist/raw-inputs/raw-input.d.ts

@@ -24,6 +24,10 @@ export declare function calculateInputDirection(inputValue: number): InputDirect
  * @category Internal
  */
 export type RawInput = Omit<InputValueWrapper<InputDeviceKey, any>, 'details'> & {
+    /** An identifier set by a game when it claims this input. */
+    consumedBy: string | undefined;
+    /** True when this input belongs to a different raw input consumer. */
+    isIgnoredByConsumer: boolean;
     mapped: SelectFrom<InputValueWrapper<InputDeviceKey, any>, {
         /**
          * `deviceName` is mapped by `gamepadModelMap`. If no mapping exists, this will always

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/input",
-    "version": "0.8.0",
+    "version": "0.10.0",
     "description": "An Antha mod for handling inputs.",
     "keywords": [
         "vir",
@@ -33,7 +33,7 @@
         "test:docs": "virmator docs check"
     },
     "dependencies": {
-        "@antha/gamepad-type": "^0.8.0",
+        "@antha/gamepad-type": "^0.10.0",
         "@augment-vir/assert": "^32.2.3",
         "@augment-vir/common": "^32.2.3",
         "date-vir": "^9.1.1",
@@ -51,7 +51,7 @@
         "istanbul-smart-text-reporter": "^1.1.5"
     },
     "peerDependencies": {
-        "@antha/engine": "^0.8.0",
+        "@antha/engine": "^0.10.0",
         "element-vir": ">=26"
     },
     "engines": {