angry-pixel 1.2.2 → 1.2.4

package/lib/input/GamepadController.d.ts

@@ -1,14 +1,56 @@
 import { Vector2 } from "angry-pixel-math";
+/**
+ * Manages the connected gamepads
+ * @public
+ * @category Input
+ * @example
+ * ```js
+ * // get all connected gamepads
+ * const gamepads = this.inputManager.gamepad.getGamepads();
+ *
+ * // get the first connected gamepad
+ * const gamepad = this.inputManager.gamepad.getGamepad(0);
+ * ```
+ */
 export declare class GamepadController {
     private readonly gamepads;
+    /** @private */
     constructor();
-    getGamepad(index: number): GamepadData;
+    /**
+     * Returns a gamepad by its numerical index, or null if it does not exist.
+     * @param index The gamepad index to find
+     * @returns The found gamepad or NULL
+     */
+    getGamepad(index: number): GamepadData | null;
+    /**
+     * Retruns all connected gamepads.
+     * @returns An array of gamepads
+     */
+    getGamepads(): GamepadData[];
     private eventHandler;
     private gamepadConnected;
     private gamepadDisconected;
+    /** @private */
     update(): void;
-    private getGamepads;
+    private getGamepadsFromBrowser;
 }
+/**
+ * Represents a connected gamepad and has the information of all its buttons and axes.
+ * @public
+ * @category Input
+ * @example
+ * ```js
+ * const gamepad = this.inputManager.gamepad.getGamepad(0);
+ *
+ * if (gamepad.dpadAxes.x > 1) {
+ *   // if the depad x-axis is pressed to the right, do some action
+ * }
+ *
+ * if (gamepad.rightFace) {
+ *   // if the right face button is pressed, do some action
+ * }
+ * ```
+ */
 export declare class GamepadData {
     private _gamepad;
     private readonly buttons;
@@ -17,35 +59,167 @@ export declare class GamepadData {
     private readonly _leftStickAxes;
     private readonly _rightStickAxes;
     private _vibrating;
+    /** @private */
     updateFromGamepad(gamepad: Gamepad): void;
+    /**
+     * The gamepad id
+     * @readonly
+     */
     get id(): string;
+    /**
+     * TRUE if the gamepad is connected
+     * @readonly
+     */
     get connected(): boolean;
+    /**
+     * Checks if a button is being pressed.
+     * @param index the button index
+     * @returns TRUE if the button is pressed, FALSE instead
+     * @see [Gamepad: buttons property](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad/buttons)
+     */
     getButtonPressed(index: number): boolean;
+    /**
+     * Returns the value of an axis by its index
+     * @param index The axis index:
+     * - 0: Left stick horizontal axix
+     * - 1: Left stick vertical axix
+     * - 2: Right stick horizontal axix
+     * - 3: Right stick vertical axix
+     * @returns The axis value
+     * @see [Gamepad: axes property](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad/axes)
+     */
     getAxis(index: number): number;
+    /**
+     * The values of the d-pad axes represented as a xy vector
+     * @readonly
+     */
     get dpadAxes(): Vector2;
+    /**
+     * The values of the left stick axes represented as a xy vector
+     * @readonly
+     */
     get leftStickAxes(): Vector2;
+    /**
+     * The values of the right stick axes represented as a xy vector
+     * @readonly
+     */
     get rightStickAxes(): Vector2;
+    /**
+     * TRUE if d-pad up is pressed
+     * @readonly
+     */
     get dpadUp(): boolean;
+    /**
+     * TRUE if d-pad down is pressed
+     * @readonly
+     */
     get dpadDown(): boolean;
+    /**
+     * TRUE if d-pad left is pressed
+     * @readonly
+     */
     get dpadLeft(): boolean;
+    /**
+     * TRUE if d-pad right is pressed
+     * @readonly
+     */
     get dpadRight(): boolean;
+    /**
+     * TRUE if bottom face button is pressed (Dual Shock: X. Xbox: A. Nintendo: B)
+     * @readonly
+     */
     get bottomFace(): boolean;
+    /**
+     * TRUE if right face button is pressed (Dual Shock: Square. Xbox: X. Nintendo: Y)
+     * @readonly
+     */
     get rightFace(): boolean;
+    /**
+     * TRUE if left face button is pressed (Dual Shock: Circle. Xbox: B. Nintendo: A)
+     * @readonly
+     */
     get leftFace(): boolean;
+    /**
+     * TRUE if top face button is pressed (Dual Shock: Triangle. Xbox: Y. Nintendo: X)
+     * @readonly
+     */
     get topFace(): boolean;
+    /**
+     * TRUE if left shoulder button is pressed (Dual Shock: L1. Xbox: LB. Nintendo: L)
+     * @readonly
+     */
     get leftShoulder(): boolean;
+    /**
+     * TRUE if right shoulder button is pressed (Dual Shock: R1. Xbox: RB. Nintendo: R)
+     * @readonly
+     */
     get rightShoulder(): boolean;
+    /**
+     * TRUE if left trigger button is pressed (Dual Shock: L2. Xbox: LT. Nintendo: ZL)
+     * @readonly
+     */
     get leftTrigger(): boolean;
+    /**
+     * TRUE if right trigger button is pressed (Dual Shock: R2. Xbox: RT. Nintendo: ZR)
+     * @readonly
+     */
     get rightTrigger(): boolean;
+    /**
+     * TRUE if back button is pressed (a.k.a. select button)
+     * @readonly
+     */
     get back(): boolean;
+    /**
+     * TRUE if start button is pressed (a.k.a. options button)
+     * @readonly
+     */
     get start(): boolean;
+    /**
+     * TRUE if left stick button is pressed
+     * @readonly
+     */
     get leftStickButton(): boolean;
+    /**
+     * TRUE if right stick button is pressed
+     * @readonly
+     */
     get rightStickButton(): boolean;
+    /**
+     * Left stick horizontal axes value
+     * @readonly
+     */
     get leftStickHorizontal(): number;
+    /**
+     * Left stick vertical axes value
+     * @readonly
+     */
     get leftStickVertical(): number;
+    /**
+     * Right stick horizontal axes value
+     * @readonly
+     */
     get rightStickHorizontal(): number;
+    /**
+     * Right stick vertical axes value
+     * @readonly
+     */
     get rightStickVertical(): number;
+    /**
+     * TRUE if any button is pressed
+     * @readonly
+     */
     get anyButtonPressed(): boolean;
+    /**
+     * TRUE if the vibration is on
+     * @readonly
+     */
     get vibrating(): boolean;
+    /**
+     * Turns on the gamepad vibration
+     * @param duration The duration of the effect in milliseconds
+     * @param weakMagnitude Rumble intensity of the high-frequency (weak) rumble motors, normalized to the range between 0.0 and 1.0
+     * @param strongMagnitude Rumble intensity of the low-frequency (strong) rumble motors, normalized to the range between 0.0 and 1.0
+     * @param startDelay The delay in milliseconds before the effect is started
+     */
     vibrate(duration?: number, weakMagnitude?: number, strongMagnitude?: number, startDelay?: number): void;
 }

package/lib/input/InputManager.d.ts

@@ -2,13 +2,31 @@ import { MouseController } from "./MouseController";
 import { KeyboardController } from "./KeyboardController";
 import { GamepadController } from "./GamepadController";
 import { TouchController } from "./TouchController";
+/**
+ * Manages the input sources: Keyboard, Mouse, Gamepad, Touch.
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * const mouseController = this.inputManager.mouse;
+ * const keyboardController = this.inputManager.keyboard;
+ * const gamepadController = this.inputManager.gamepad;
+ * const touchController = this.inputManager.touch;
+ * ```
+ */
 export interface IInputManager {
+    /** Manages mouse information. */
     mouse: MouseController;
+    /** Manages keyboard information. */
     keyboard: KeyboardController;
+    /** Manages gamepads information. */
     gamepad: GamepadController;
+    /** Manages toush information. */
     touch: TouchController;
+    /** @private */
     update(): void;
 }
+/** @private */
 export declare class InputManager implements IInputManager {
     mouse: MouseController;
     keyboard: KeyboardController;

package/lib/input/KeyboardController.d.ts

@@ -1,12 +1,81 @@
+/**
+ * Manages keyboard interaction. It uses the **code** property of the **js keyboard event**.
+ * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+ * @public
+ * @category Input
+ * @example
+ * ```js
+ * const keyboard = this.inputManager.keyboard;
+ *
+ * if (keyboard.isPressed("ArrowRight")) {
+ *   // if the right arrow key is pressed, do some action
+ * }
+ *
+ * if (keyboard.orPressed("Enter", "Space")) {
+ *   // if the enter key or space key are pressed, do some action
+ * }
+ *
+ * if (keyboard.andPressed("ControlLeft", "KeyC")) {
+ *   // if the left control key and the letter C key are pressed, do some action
+ * }
+ * ```
+ */
 export declare class KeyboardController {
-    pressedKeys: string[];
+    /**
+     * The current pressed keys
+     * @readonly
+     */
+    readonly pressedKeys: string[];
     private keyMap;
+    /** @private */
     constructor(canvas: HTMLCanvasElement);
     private eventHandler;
+    /**
+     * Returns TRUE if the given key is being pressed.
+     * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+     * @param keyCode The code of the key to check
+     * @returns TRUE true for pressed, FALSE instead
+     */
     isPressed(keyCode: string): boolean;
+    /**
+     * Returns TRUE if one of the given keys is being pressed.
+     * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+     * @param keyCodes The codes of the keys to check
+     * @returns TRUE for pressed, FALSE instead
+     */
     orPressed(keyCodes: string[]): boolean;
+    /**
+     * Returns TRUE if all the given keys are being pressed.
+     * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+     * @param keyCodes The codes of the keys to check
+     * @returns TRUE for pressed, FALSE instead
+     */
     andPressed(keyCodes: string[]): boolean;
+    /**
+     * This method accepts two parameters that will be returned depending on whether the key is pressed or not.
+     * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+     * @param keyCode The code of the key to check
+     * @param returnTrue The value to return if the key is pressed
+     * @param returnFalse The value to return if the key is not pressed
+     * @returns The returnTrue for pressed or the returnFalse instead
+     */
     isPressedReturn<T>(keyCode: string, returnTrue: T, returnFalse: T): T;
+    /**
+     * This method accepts two parameters that will be returned depending on whether one of the given keys is being pressed.
+     * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+     * @param keyCodes The codes of the keys to check
+     * @param returnTrue The value to return if the key is pressed
+     * @param returnFalse The value to return if the key is not pressed
+     * @returns The returnTrue for pressed or the returnFalse instead
+     */
     orPressedReturn<T>(keyCodes: string[], returnTrue: T, returnFalse: T): T;
+    /**
+     * This method accepts two parameters that will be returned depending on whether all the given keys are being pressed.
+     * @see [KeyboardEvent: code property](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+     * @param keyCodes The codes of the keys to check
+     * @param returnTrue The value to return if the key is pressed
+     * @param returnFalse The value to return if the key is not pressed
+     * @returns The returnTrue for pressed or the returnFalse instead
+     */
     andPressedReturn<T>(keyCodes: string[], returnTrue: T, returnFalse: T): T;
 }

package/lib/input/MouseController.d.ts

@@ -1,4 +1,17 @@
 import { Vector2 } from "angry-pixel-math";
+/**
+ * Manages mouse interaction
+ * @public
+ * @category Input
+ * @example
+ * ```js
+ * const mouse = this.inputManager.mouse;
+ *
+ * if (mouse.positionInViewport.y < 0 && mouse.leftButtonPressed()) {
+ *   // if the mouse pointer is below the middle of the screen and left click, do something
+ * }
+ * ```
+ */
 export declare class MouseController {
     private _leftButtonPressed;
     private _scrollButtonPressed;
@@ -7,12 +20,34 @@ export declare class MouseController {
     private _hasMoved;
     private lastPositionInViewport;
     private canvas;
+    /** @private */
     constructor(canvas: HTMLCanvasElement);
+    /**
+     * TRUE if the left button is being pressed
+     * @readonly
+     */
     get leftButtonPressed(): boolean;
+    /**
+     * TRUE if the scroll button is being pressed
+     * @readonly
+     */
     get scrollButtonPressed(): boolean;
+    /**
+     * TRUE if the right button is beign pressed
+     * @readonly
+     */
     get rightButtonPressed(): boolean;
+    /**
+     * The position of the pointer in the screen view port
+     * @readonly
+     */
     get positionInViewport(): Vector2;
+    /**
+     * TRUE if the mouse moved during the last frame
+     * @readonly
+     */
     get hasMoved(): boolean;
+    /** @private */
     update(): void;
     private setup;
     private updateButtonDown;

package/lib/input/TouchController.d.ts

@@ -1,13 +1,45 @@
 import { Vector2 } from "angry-pixel-math";
+/**
+ * The information about one interaction with the screen
+ * @public
+ * @category Input
+ */
+export interface TouchInteraction {
+    /** The interaction position on the screen */
+    positionInViewport: Vector2;
+    /** The area of the interaction represented as a radius of the ellipse */
+    radius: Vector2;
+}
+/**
+ * Manages the touch screen interaction.
+ * @public
+ * @category Input
+ * @example
+ * ```js
+ * const touch = this.inputController.touch;
+ *
+ * if (touch.touching) {
+ *   const interaction = touch.interactions[0];
+ * }
+ *
+ * ```
+ */
 export declare class TouchController {
     private canvas;
     private _touching;
-    private _positionInViewport;
-    private _radius;
+    private _interactions;
+    /** @private */
     constructor(canvas: HTMLCanvasElement);
-    get positionInViewport(): Vector2;
+    /**
+     * TRUE if there is an interaction with the screen
+     * @readonly
+     */
     get touching(): boolean;
-    get radius(): Vector2;
+    /**
+     * The information about the interactions with the screen
+     * @readonly
+     */
+    get interactions(): TouchInteraction[];
     private eventHandler;
     private updatePosition;
 }

package/lib/utils/Container.d.ts

@@ -1,4 +1,5 @@
 type constructor = () => unknown;
+/** @private */
 export declare class Container {
     private instances;
     private constructors;

package/lib/utils/Exception.d.ts

@@ -1,4 +1,5 @@
 export declare const exceptionName = "AngryPixelException";
+/** @private */
 export declare class Exception extends Error {
     constructor(message: string);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "angry-pixel",
-    "version": "1.2.2",
+    "version": "1.2.4",
     "description": "Lightweight 2D game engine made with TypeScript.",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -12,7 +12,8 @@
         "lint": "eslint . --ext .ts",
         "lint-and-fix": "eslint . --ext .ts --fix",
         "prettier-format": "prettier --write \"src/**/*.{ts,js,css,html}\"",
-        "prettier-check": "prettier --check \"src/**/*.{ts,js,css,html}\""
+        "prettier-check": "prettier --check \"src/**/*.{ts,js,css,html}\"",
+        "docs": "typedoc"
     },
     "repository": {
         "type": "git",
@@ -38,14 +39,17 @@
     "devDependencies": {
         "@rollup/plugin-commonjs": "^19.0.0",
         "@rollup/plugin-node-resolve": "^13.0.0",
-        "@typescript-eslint/eslint-plugin": "^5.50.0",
-        "@typescript-eslint/parser": "^5.50.0",
-        "eslint": "^8.45.0",
+        "@types/node": "^20.8.9",
+        "@typescript-eslint/eslint-plugin": "^6.10.0",
+        "@typescript-eslint/parser": "^6.10.0",
+        "eslint": "^8.53.0",
         "prettier": "^2.1.2",
         "rollup": "^2.49.0",
         "rollup-plugin-terser": "^7.0.2",
         "rollup-plugin-typescript2": "^0.35.0",
         "tslib": "^2.6.1",
+        "typedoc": "^0.25.3",
+        "typedoc-plugin-markdown": "^3.16.0",
         "typescript": "^5.1.6"
     },
     "dependencies": {

package/typedoc.json

@@ -0,0 +1,13 @@
+{
+    "$schema": "https://typedoc.org/schema.json",
+    "name": "Angry Pixel Engine",
+    "entryPoints": ["./src/index.ts"],
+    "out": "api-docs",
+    "excludePrivate": true,
+    "excludeInternal": true,
+    "navigation": {
+        "includeCategories": true
+    },
+    "categoryOrder": ["Core", "Components", "Managers", "Game Objects", "Input"],
+    "defaultCategory": "Core"
+}