angry-pixel 1.1.1 → 1.1.3

package/lib/core/Component.d.ts

@@ -1,130 +1,85 @@
-import { GameObjectFactory, GameObjectManager } from "./managers/GameObjectManager";
 import { GameObject } from "./GameObject";
 import { Scene } from "./Scene";
 import { FrameEvent } from "./managers/IterationManager";
-export declare abstract class Component {
-    private sceneManager;
-    protected gameObjectManager: GameObjectManager;
+import { GameActor } from "./GameActor";
+export declare type ComponentClass<T extends Component = Component> = new (gameObject: GameObject, name?: string) => T;
+export declare abstract class Component extends GameActor {
+    private readonly sceneManager;
     readonly id: string;
-    type: string;
-    name: string;
-    gameObject: GameObject;
-    allowMultiple: boolean;
+    readonly name: string;
+    readonly gameObject: GameObject;
+    readonly allowMultiple: boolean;
     private _active;
-    private started;
-    protected get updateEvent(): FrameEvent;
+    constructor(gameObject: GameObject, name?: string);
     get active(): boolean;
-    setActive(active: boolean): void;
-    dispatch(event: FrameEvent): void;
-    /**
-     * This method is called only once.
-     * Recommended for GameObject cration.
-     */
-    protected init(): void;
-    /**
-     * This method is called only once.
-     */
-    protected start(): void;
-    /**
-     * This method is called on every frame.
-     */
-    protected update(): void;
-    /**
-     * This method is called before the component is destroyed.
-     */
-    protected destroy(): void;
+    set active(active: boolean);
     /**
      * This method is called when the active state changes.
      */
-    protected activeStateChange(): void;
+    protected onActiveChange(): void;
     /**
      * @returns The current loaded scene
      */
     protected getCurrentScene<T extends Scene>(): T;
     /**
-     * @param gameObjectFactory The factory function for the game object
-     * @param name The name of the game object, this must not be used by another game object
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
-    /**
-     * @param name The name of the component to find
-     * @returns The found component
-     */
-    protected getComponentByName<T extends Component>(name: string): T;
-    /**
-     * @param type The type of the component to find
-     * @returns The found component
+     * @returns The GameObject to which this component is attached
      */
-    protected getComponentByType<T extends Component>(type: string): T;
+    protected getGameObject<T extends GameObject>(): T;
     /**
-     * @param type The type of the components to find
+     * Returns all the components in the game object.
      * @returns The found components
      */
-    protected getComponentsByType<T extends Component>(type: string): T[];
-    /**
-     * @param name The name of the game object to find
-     * @returns The found game object
-     */
-    protected findGameObjectByName<T extends GameObject>(name: string): T;
+    getComponents(): Component[];
     /**
-     * @param tag The tag of the game objects to find
-     * @returns The found game objects
+     * Returns all the components for the given class in the game object.
+     * @param componentClass The class of the components
+     * @returns The found components
      */
-    protected findGameObjectsByTag(tag: string): GameObject[];
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
     /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
      */
-    protected findGameObjectByTag<T extends GameObject>(tag: string): T;
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
     /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
      */
-    protected destroyGameObjectByName(name: string): void;
+    getComponent<T extends Component>(name: string): T;
     /**
-     * Destroy the game objects
-     * @param gameObject The game object to destory
+     * Returns TRUE if the game object has a component for the given class, or FALSE otherwise
+     * @param componentClass The class of the component to find
+     * @returns boolean
      */
-    protected destroyGameObject(gameObject: GameObject): void;
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
     /**
      * @param name The name of the component to find
-     * @returns TRUE or FALSE
-     */
-    hasComponentOfName(name: string): boolean;
-    /**
-     * @param type The type of the component to find
-     * @returns TRUE or FALSE
-     */
-    hasComponentOfType(type: string): boolean;
-    /**
-     * @param name The name of the component to remove
-     */
-    removeComponentByName(name: string): void;
-    /**
-     * @param type The tyepe of the component to remove
+     * @returns boolean
      */
-    removeComponentByType(type: string): void;
-    private _destroy;
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): void;
+    protected _destroy(): void;
 }
 export declare abstract class EngineComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class ColliderComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class PhysicsComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class TransformComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class PreRenderComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class CameraComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class RenderComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }

package/lib/core/Game.d.ts

@@ -1,21 +1,25 @@
-import { SceneConstructor as SceneFactory } from "../core/managers/SceneManager";
+import { SceneClass } from "../core/managers/SceneManager";
 import { Container } from "../utils/Container";
 import { Rectangle } from "../math/Rectangle";
 import { Vector2 } from "../math/Vector2";
+import { CollisionMatrix } from "../physics/collision/CollisionManager";
+import { InitOptions } from "./GameActor";
 export declare const container: Container;
 export interface GameConfig {
-    containerNode: HTMLElement | null;
+    containerNode?: HTMLElement | null;
     gameWidth?: number;
     gameHeight?: number;
     debugEnabled?: boolean;
     canvasColor?: string;
     physicsFramerate?: number;
     spriteDefaultScale?: Vector2 | null;
+    headless?: boolean;
     collisions?: {
         method?: CollisionMethodConfig;
         quadTreeBounds?: Rectangle | null;
         quadMaxLevel?: number;
         collidersPerQuad?: number;
+        collisionMatrix?: CollisionMatrix;
     };
 }
 export declare enum CollisionMethodConfig {
@@ -24,12 +28,8 @@ export declare enum CollisionMethodConfig {
 }
 export declare class Game {
     private sceneManager;
-    private renderManager;
     private iterationManager;
     private _config;
-    private _running;
-    private _stop;
-    private frameRequestId;
     constructor(config: GameConfig);
     private setupManagers;
     /**
@@ -43,11 +43,12 @@ export declare class Game {
     /**
      * Add a scene to the game
      *
+     * @param sceneClass the class of the scene
      * @param name The name of the scene
-     * @param sceneFactory The factory funciton for the escene
-     * @param openingScene If this is the opening scene, set TRUE, FALSE instead
+     * @param options [optional] This options will be passed to the init method
+     * @param openingScene [default FALSE] If this is the opening scene, set TRUE, FALSE instead
      */
-    addScene(name: string, sceneFactory: SceneFactory, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     /**
      * Run the game
      */
@@ -56,14 +57,12 @@ export declare class Game {
      * Stop the game
      */
     stop(): void;
-    private gameLoop;
     /**
-     * Pauses the game loop
+     * Pauses the game
      */
-    pauseLoop(): void;
+    pause(): void;
     /**
-     * Resumes the paused game loop
+     * Resumes the paused game
      */
-    resumeLoop(): void;
-    private requestAnimationFrame;
+    resume(): void;
 }

package/lib/core/GameActor.d.ts

@@ -0,0 +1,95 @@
+import { GameObject, GameObjectClass } from "./GameObject";
+import { GameObjectManager } from "./managers/GameObjectManager";
+import { FrameEvent } from "./managers/IterationManager";
+export interface InitOptions {
+    [key: string]: any;
+}
+export declare abstract class GameActor {
+    protected readonly gameObjectManager: GameObjectManager;
+    protected readonly updateEvent: FrameEvent;
+    private started;
+    dispatch(event: FrameEvent, options?: InitOptions): void;
+    /**
+     * This method is called after instantiation (recommended for the creation of game objects).
+     */
+    protected init?(options?: InitOptions): void;
+    /**
+     * This method is called only once on the first available frame.
+     */
+    protected start?(): void;
+    /**
+     * This method is called on every frame.
+     */
+    protected update?(): void;
+    /**
+     * This method is called before destruction.
+     */
+    protected onDestroy?(): void;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @param name The name of the game object
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, name: string): T;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @param options This options will be passed to the init method
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options: InitOptions): T;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @param options [optional] This options will be passed to the init method
+     * @param name [optional] The name of the game object
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions | string, name?: string): T;
+    /**
+     * Returns all the game objects in the scene.
+     * @returns The found game objects
+     */
+    protected findGameObjects(): GameObject[];
+    /**
+     * Returns a collection of found game objects for the given class
+     * @param gameObjectClass The game object class to find
+     * @returns The found game objects
+     */
+    protected findGameObjects<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T[];
+    /**
+     * Returns the first game object found for the given class, or undefined otherwise.
+     * @param gameObjectClass The game object class to find
+     * @returns The found game object
+     */
+    protected findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    /**
+     * Returns the first game object found for the given name, or undefined otherwise.
+     * @param name The name of the game object to find
+     * @returns The found game object
+     */
+    protected findGameObject<T extends GameObject>(name: string): T;
+    /**
+     * Returns a collection of game objects found for the given tag
+     * @param tag The tag of the game objects to find
+     * @returns The found game objects
+     */
+    protected findGameObjectsByTag<T extends GameObject>(tag: string): T[];
+    /**
+     * Destroy the given game object
+     * @param gameObject The game object to destory
+     */
+    protected destroyGameObject(gameObject: GameObject): void;
+    protected abstract _destroy(): void;
+}

package/lib/core/GameObject.d.ts

@@ -1,133 +1,124 @@
-import { Component } from "./Component";
+import { Component, ComponentClass } from "./Component";
 import { Transform } from "../component/Transform";
 import { RigidBody } from "../component/RigidBody";
-import { GameObjectFactory } from "../core/managers/GameObjectManager";
 import { Scene } from "./Scene";
-import { FrameEvent } from "./managers/IterationManager";
+import { GameActor, InitOptions } from "./GameActor";
 export declare const LAYER_DEFAULT = "Default";
-export declare type ComponentFactory = () => Component;
-export declare class GameObject {
+export declare type GameObjectClass<T extends GameObject = GameObject> = new (name?: string, parent?: GameObject) => T;
+export declare class GameObject extends GameActor {
     readonly id: string;
-    name: string;
+    readonly name: string;
     tag: string;
     layer: string;
     ui: boolean;
     keep: boolean;
-    private _active;
     private _parent;
-    private started;
+    private _active;
     private sceneManager;
-    private gameObjectManager;
     private components;
-    constructor();
+    private activeComponentsCache;
+    private activeChildrenCache;
+    constructor(name?: string, parent?: GameObject);
     get active(): boolean;
-    setActive(active: boolean): void;
-    get transform(): Transform;
-    get rigidBody(): RigidBody;
+    set active(active: boolean);
     get parent(): GameObject | null;
     set parent(parent: GameObject | null);
-    dispatch(event: FrameEvent): void;
-    /**
-     * This method is called only once.
-     * Recommended for GameObject cration.
-     */
-    protected init(): void;
-    /**
-     * This method is called only once.
-     */
-    protected start(): void;
-    /**
-     * This method is called on every frame.
-     */
-    protected update(): void;
+    private updateComponentsActiveStatus;
+    private updateChildrenActiveStatus;
+    get transform(): Transform;
+    get rigidBody(): RigidBody;
     /**
-     * This method is called before the object is destroyed.
+     * This method is called when the active state changes.
      */
-    protected destroy(): void;
+    protected onActiveChange(): void;
     /**
      * @returns The current loaded scene
      */
     protected getCurrentScene<T extends Scene>(): T;
     /**
-     * @param gameObjectFactory The factory function for the game object
-     * @param name The name of the game object, this must not be used by another game object
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
-    /**
-     * @param name The name of the game object to find
-     * @returns The found game object
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @returns The added component
      */
-    protected findGameObjectByName<T extends GameObject>(name: string): T;
+    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>): ComponentType;
     /**
-     * @param tag The tag of the game objects to find
-     * @returns The found game objects
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options The options passed to the init method of the component
+     * @returns The added component
      */
-    protected findGameObjectsByTag(tag: string): GameObject[];
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType): ComponentType;
     /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param name The name of the component
+     * @returns The added component
      */
-    protected findGameObjectByTag<T extends GameObject>(tag: string): T;
+    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>, name: string): ComponentType;
     /**
-     * Add a components to the game obejct
-     *
-     * @param componentFactory The factory function for the component
-     * @param name (optional) The name of the component, this must not be used by another component
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options The options passed to the init method of the component
+     * @param name The name of the component
      * @returns The added component
      */
-    addComponent<T extends Component>(componentFactory: ComponentFactory, name?: string | null): T;
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType, name: string): ComponentType;
     private checkMultipleComponent;
     /**
-     * @returns All the added components
+     * Returns all the components in the game object.
+     * @returns The found components
      */
     getComponents(): Component[];
     /**
-     * @param name The name of the component to find
-     * @returns The found component
-     */
-    getComponentByName<T extends Component>(name: string): T;
-    /**
-     * @param type The type of the component to find
-     * @returns The found component
-     */
-    getComponentByType<T extends Component>(type: string): T;
-    /**
-     * @param type The type of the components to find
+     * Returns all the components for the given class in the game object.
+     * @param componentClass The class of the components
      * @returns The found components
      */
-    getComponentsByType<T extends Component>(type: string): T[];
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
     /**
-     * @param name The name of the component to find
-     * @returns TRUE or FALSE
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
      */
-    hasComponentOfName(name: string): boolean;
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
     /**
-     * @param type The type of the component to find
-     * @returns TRUE or FALSE
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
      */
-    hasComponentOfType(type: string): boolean;
+    getComponent<T extends Component>(name: string): T;
     /**
-     * @param name The name of the component to remove
+     * Returns TRUE if the game object has a component for the given class, or FALSE otherwise
+     * @param componentClass The class of the component to find
+     * @returns boolean
      */
-    removeComponentByName(name: string): void;
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
     /**
-     * @param type The tyepe of the component to remove
+     * @param name The name of the component to find
+     * @returns boolean
      */
-    removeComponentByType(type: string): void;
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): void;
     /**
      * Add a child game object.
-     *
-     * @param gameObjectFactory The factory of the child game object
-     * @param name The name of the child game object, this must not be used by another game object
+     * @param gameObjectClass The class of the child game object
+     * @param options [optional] This options will be passed to the init method
+     * @param name [optional] The name of the game object
      * @returns The added child game object
      */
-    addChild<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
+    addChild<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
     /**
      * @returns The children game objects
      */
-    getChildren(): GameObject[];
+    getChildren<T extends GameObject>(): T[];
+    /**
+     * Returns the first child found for the given class, or undefined otherwise.
+     * @param gameObjectClass The class of the child game object to find
+     * @returns The found child game object
+     */
+    getChild<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
     /**
+     * Returns the first child found for the given name, or undefined otherwise.
      * @param name The name of the child game object to find
      * @returns The found child game object
      */
@@ -136,16 +127,6 @@ export declare class GameObject {
      * Destroy all the children game objects
      */
     destroyChildren(): void;
-    /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
-     */
-    destroyGameObjectByName(name: string): void;
-    /**
-     * Destroy the game objects
-     * @param gameObject The game object to destory
-     */
-    destroyGameObject(gameObject: GameObject): void;
-    private _destroy;
+    protected _destroy(): void;
     private destroyComponents;
 }

package/lib/core/Scene.d.ts

@@ -1,69 +1,10 @@
 import { GameCamera } from "../gameObject/GameCamera";
 import { Game } from "./Game";
-import { GameObject } from "./GameObject";
-import { GameObjectFactory } from "../core/managers/GameObjectManager";
-import { FrameEvent } from "./managers/IterationManager";
-export declare const GAME_CAMERA_ID = "GameCamera";
-export declare class Scene {
-    private readonly gameObjectManager;
-    game: Game;
-    name: string;
-    private started;
-    constructor();
+import { GameActor } from "./GameActor";
+export declare class Scene extends GameActor {
+    readonly name: string;
+    readonly game: Game;
+    constructor(name: string, game: Game);
     get gameCamera(): GameCamera;
-    dispatch(event: FrameEvent): void;
-    /**
-     * This method is called only once.
-     * Recommended for GameObject cration.
-     */
-    protected init(): void;
-    /**
-     * This method is called only once.
-     */
-    protected start(): void;
-    /**
-     * This method is called on every frame.
-     */
-    protected update(): void;
-    /**
-     * This method is called before the scene is destroyed.
-     */
-    protected destroy(): void;
-    /**
-     * @param gameObjectFactory The factory function for the game object
-     * @param name The name of the game object, this must not be used by another game object
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
-    /**
-     * @returns The all the loaded game objects
-     */
-    protected getGameObjects(): GameObject[];
-    /**
-     * @param name The name of the game object to find
-     * @returns The found game object
-     */
-    protected findGameObjectByName<T extends GameObject>(name: string): T;
-    /**
-     * @param tag The tag of the game objects to find
-     * @returns The found game objects
-     */
-    protected findGameObjectsByTag(tag: string): GameObject[];
-    /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
-     */
-    protected findGameObjectByTag<T extends GameObject>(tag: string): T;
-    /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
-     */
-    protected destroyGameObjectByName(name: string): void;
-    /**
-     * Destroy the game objects
-     *
-     * @param gameObject The game object to destory
-     */
-    protected destroyGameObject(gameObject: GameObject): void;
-    private _destroy;
+    protected _destroy(): void;
 }