dualsense-ts 2.1.39 → 2.2.1

package/src/elements/analog.ts

@@ -1,8 +1,11 @@
 import { Axis } from "./axis";
 import { Momentary } from "./momentary";
 import { Input, InputParams } from "../input";
-import { Radians, Degrees, Magnitude } from "../math";
+import { Radians, Degrees, Magnitude, Force } from "../math";
 
+/**
+ * Configuration for an analog joystick and its basic inputs.
+ */
 export interface AnalogParams extends InputParams {
   button?: InputParams;
   x?: InputParams;
@@ -21,65 +24,100 @@ export interface AnalogParams extends InputParams {
 export class Analog extends Input<Analog> {
   public readonly state: Analog = this;
 
+  /**
+   * The left/right position of the input.
+   */
   public readonly x: Axis;
+  /**
+   * The up/down position of the input.
+   */
   public readonly y: Axis;
+  /**
+   * Button triggered by pressing the stick.
+   */
   public readonly button: Momentary;
 
   constructor(params?: AnalogParams) {
     super(params);
+    const { button, x, y, threshold } = params || {};
 
-    this.button = new Momentary(
-      params?.button || { icon: "3", name: "Button" }
-    );
+    this.button = new Momentary(button || { icon: "3", name: "Button" });
     this.x = new Axis(
-      params?.x || { icon: "↔", name: "X", threshold: (1 / 128) * 3 }
+      x || { icon: "↔", name: "X", threshold: threshold || 0.07 }
     );
     this.y = new Axis(
-      params?.y || { icon: "↕", name: "Y", threshold: (1 / 128) * 3 }
+      y || { icon: "↕", name: "Y", threshold: threshold || 0.07 }
     );
   }
 
-  // Returns true if the stick is away from the idle position, or the button is pressed.
+  /**
+   * Returns true if the stick is away from the idle position, or the button is pressed.
+   */
   public get active(): boolean {
-    return this.magnitude > this.threshold || this.button.active;
+    return this.x.active || this.y.active || this.button.active;
   }
 
-  // Returns a direction and magnitude representing the stick's position.
-  public get vector(): { direction: number; magnitude: number } {
+  /**
+   * Returns a direction and magnitude representing the stick's position.
+   */
+  public get vector(): { direction: Radians; magnitude: Magnitude } {
     return { direction: this.direction, magnitude: this.magnitude };
   }
 
-  // Returns the magnitude of the stick's position.
+  /**
+   * Returns an force from the stick's position.
+   */
+  public get force(): Force {
+    return this.active
+      ? Math.max(Math.min(Math.hypot(this.x.state, this.y.state), 1), -1)
+      : 0;
+  }
+
+  /**
+   * Returns a magnitude from the stick's position.
+   */
   public get magnitude(): Magnitude {
-    return Math.min(Math.abs(Math.hypot(this.x.state, this.y.state)), 1);
+    return Math.abs(this.force);
   }
 
-  // Returns the angle related to the stick's position in radians.
+  /**
+   * Returns the stick's angle in radians.
+   */
   public get direction(): Radians {
     return Math.atan2(this.y.state, this.x.state);
   }
 
-  // Alias for `.direction`
+  /**
+   * Alias for `.direction`
+   */
   public get radians(): Radians {
     return this.direction;
   }
 
-  // Alias for `.direction`
+  /**
+   * Alias for `.direction`
+   */
   public get angle(): Radians {
     return this.direction;
   }
 
-  // Alias for `.direction` converted to degrees.
+  /**
+   * Alias for `.direction` converted to degrees.
+   */
   public get directionDegrees(): Degrees {
     return (this.direction * 180) / Math.PI;
   }
 
-  // Alias for `.directionDegrees`.
+  /**
+   * Alias for `.directionDegrees`.
+   */
   public get degrees(): Degrees {
     return this.directionDegrees;
   }
 
-  // Alias for `.directionDegrees`.
+  /**
+   * Alias for `.directionDegrees`.
+   */
   public get angleDegrees(): Degrees {
     return this.directionDegrees;
   }

package/src/elements/axis.spec.ts

@@ -1,7 +1,38 @@
 import { Axis } from "./axis";
+import { InputSet } from "../input";
 
 describe("Axis", () => {
   it("should construct", () => {
     expect(new Axis()).toBeInstanceOf(Axis);
   });
+
+  it("should implement `active`", () => {
+    const axis = new Axis({ threshold: (1 / 128) * 10 });
+    expect(axis.active).toEqual(false);
+    axis[InputSet](1);
+    expect(axis.active).toEqual(true);
+    axis[InputSet](0);
+    expect(axis.active).toEqual(false);
+    axis[InputSet](-1);
+    expect(axis.active).toEqual(true);
+    axis[InputSet](0);
+    expect(axis.active).toEqual(false);
+    axis[InputSet]((1 / 128) * 2);
+    expect(axis.active).toEqual(false);
+  });
+
+  it("should implement `force`", () => {
+    const axis = new Axis({ threshold: (1 / 128) * 10 });
+    expect(axis.force).toEqual(0);
+    axis[InputSet](1);
+    expect(axis.force).toEqual(1);
+    axis[InputSet](0);
+    expect(axis.force).toEqual(0);
+    axis[InputSet](-1);
+    expect(axis.force).toEqual(-1);
+    axis[InputSet](0);
+    expect(axis.force).toEqual(0);
+    axis[InputSet]((1 / 128) * 2);
+    expect(axis.force).toEqual(0);
+  });
 });

package/src/elements/axis.ts

@@ -5,14 +5,14 @@ export class Axis extends Input<Force> {
   public state: Force = 0;
 
   public get active(): boolean {
-    return this.magnitude > this.threshold;
+    return Math.abs(this.state) > this.threshold;
   }
 
   public get force(): Force {
-    return this.state;
+    return this.active ? this.state : 0;
   }
 
   public get magnitude(): Magnitude {
-    return Math.abs(this.state);
+    return Math.abs(this.force);
   }
 }

package/src/elements/unisense.ts

@@ -33,7 +33,7 @@ export class Unisense extends Input<Unisense> {
       params?.bumper || { icon: "1", name: "Bumper" }
     );
     this.analog = new Analog(
-      params?.analog || { icon: "⨁", name: "Analog", threshold: (1 / 128) * 3 }
+      params?.analog || { icon: "⨁", name: "Analog", threshold: 0.07 }
     );
     this.haptic = new Haptic();
   }

package/src/input.ts

@@ -57,19 +57,29 @@ export abstract class Input<Type>
 {
   public readonly id: symbol;
 
-  // Timestamp of the last received input that changed the state.
+  /**
+   * Timestamp of the last received input that changed the state.
+   */
   public lastChange: number = Date.now();
 
-  // Timestamp of the last received input, even if it didn't change the state.
+  /**
+   * Timestamp of the last received input, even if it didn't change the state.
+   */
   public lastInput: number = Date.now();
 
-  // For numeric inputs, ignore state changes smaller than this threshold.
+  /**
+   * For numeric inputs, ignore state changes smaller than this threshold.
+   */
   public threshold: number = 0;
 
-  // Provide the type and default value for the input.
+  /**
+   * Provide the type and default value for the input.
+   */
   public abstract state: Type;
 
-  // Implement a function that returns true if the user is actively engaged with the input.
+  /**
+   * Implement a function that returns true if the user is actively engaged with the input.
+   */
   public abstract get active(): boolean;
 
   /**
@@ -124,7 +134,9 @@ export abstract class Input<Type>
     });
   }
 
-  // Optionally, implement a function that returns true if the provided state is worth an event
+  /**
+   * Optionally, implement a function that returns true if the provided state is worth an event
+   */
   [InputChanged]: (state: Type, newState: Type) => boolean;
 
   // TODO Support params for nested inputs
@@ -150,13 +162,19 @@ export abstract class Input<Type>
     return this.toString();
   }
 
-  // A name for this input
+  /**
+   * The name of this input.
+   */
   readonly [InputName]: string;
 
-  // A short name for this input
+  /**
+   * A short name for this input
+   */
   readonly [InputIcon]: string;
 
-  // The Input's parent, if any
+  /**
+   * The Input's parent, if any
+   */
   [InputParent]?: Input<unknown>;
 
   [InputChildless]: boolean = true;