angry-pixel 1.1.5 → 1.1.6

package/lib/component/Sprite.d.ts

@@ -10,8 +10,8 @@ export interface SpriteConfig {
 export declare class Sprite {
     readonly image: HTMLImageElement;
     readonly slice: Slice;
-    readonly scale: Vector2;
     readonly smooth: boolean;
+    scale?: Vector2;
     private _width;
     private _height;
     private _loaded;

package/lib/component/collider/EdgeCollider.d.ts

@@ -1,5 +1,4 @@
 import { Collider } from "./Collider";
-import { GameObject } from "../../core/GameObject";
 import { InitOptions } from "../../core/GameActor";
 import { Vector2, Rotation } from "angry-pixel-math";
 export interface EdgeColliderOptions extends InitOptions {
@@ -22,7 +21,6 @@ export declare class EdgeCollider extends Collider {
     private scaledPosition;
     private finalRotation;
     private innerPosition;
-    constructor(gameObject: GameObject, name?: string);
     protected init(config: EdgeColliderOptions): void;
     protected start(): void;
     protected update(): void;

package/lib/component/collider/PolygonCollider.d.ts

@@ -2,7 +2,6 @@ import { Collider } from "./Collider";
 import { ColliderData } from "../../physics/collision/ColliderData";
 import { RenderComponent } from "../../core/Component";
 import { InitOptions } from "../../core/GameActor";
-import { GameObject } from "../../core/GameObject";
 import { Vector2, Rotation } from "angry-pixel-math";
 export interface PolygonColliderOptions extends InitOptions {
     vertexModel: Vector2[];
@@ -24,7 +23,6 @@ export declare class PolygonCollider extends Collider {
     private scaledPosition;
     private finalRotation;
     private innerPosition;
-    constructor(gameObject: GameObject, name?: string);
     protected init(config: PolygonColliderOptions): void;
     protected start(): void;
     protected update(): void;

package/lib/component/rendering/SpriteRenderer.d.ts

@@ -15,7 +15,8 @@ export interface SpriteRendererOptions {
     layer?: string;
 }
 export declare class SpriteRenderer extends RenderComponent {
-    private renderManager;
+    private readonly renderManager;
+    private readonly spriteDefaultScale;
     sprite: Sprite;
     offset: Vector2;
     flipHorizontal: boolean;

package/lib/core/Component.d.ts

@@ -2,15 +2,15 @@ import { GameObject } from "./GameObject";
 import { Scene } from "./Scene";
 import { FrameEvent } from "./managers/IterationManager";
 import { GameActor } from "./GameActor";
-export declare type ComponentClass<T extends Component = Component> = new (gameObject: GameObject, name?: string) => T;
+import { Container } from "../utils/Container";
+export declare type ComponentClass<T extends Component = Component> = new (container: Container, gameObject: GameObject, name?: string) => T;
 export declare abstract class Component extends GameActor {
-    private readonly sceneManager;
     readonly id: string;
     readonly name: string;
     readonly gameObject: GameObject;
     readonly allowMultiple: boolean;
     private _active;
-    constructor(gameObject: GameObject, name?: string);
+    constructor(container: Container, gameObject: GameObject, name?: string);
     get active(): boolean;
     set active(active: boolean);
     /**

package/lib/core/Game.d.ts

@@ -1,31 +1,8 @@
-import { SceneClass } from "../core/managers/SceneManager";
-import { Container } from "../utils/Container";
-import { Rectangle, Vector2 } from "angry-pixel-math";
-import { CollisionMatrix } from "../physics/collision/CollisionManager";
 import { InitOptions } from "./GameActor";
-export declare const container: Container;
-export interface GameConfig {
-    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 {
-    AABB = "aabb",
-    SAT = "sat"
-}
+import { GameConfig } from "./GameConfig";
+import { SceneClass } from "./Scene";
 export declare class Game {
+    private readonly container;
     private sceneManager;
     private iterationManager;
     private _config;

package/lib/core/GameActor.d.ts

@@ -1,3 +1,4 @@
+import { Container } from "../utils/Container";
 import { GameObject, GameObjectClass } from "./GameObject";
 import { GameObjectManager } from "./managers/GameObjectManager";
 import { FrameEvent } from "./managers/IterationManager";
@@ -7,7 +8,9 @@ export interface InitOptions {
 export declare abstract class GameActor {
     protected readonly gameObjectManager: GameObjectManager;
     protected readonly updateEvent: FrameEvent;
+    protected readonly container: Container;
     private started;
+    constructor(container: Container);
     dispatch(event: FrameEvent, options?: InitOptions): void;
     /**
      * This method is called after instantiation (recommended for the creation of game objects).

package/lib/core/GameConfig.d.ts

@@ -0,0 +1,23 @@
+import { Rectangle, Vector2 } from "angry-pixel-math";
+import { CollisionMatrix } from "../physics/collision/CollisionManager";
+export declare enum CollisionMethodConfig {
+    AABB = "aabb",
+    SAT = "sat"
+}
+export interface GameConfig {
+    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;
+    };
+}

package/lib/core/GameObject.d.ts

@@ -3,8 +3,9 @@ import { Transform } from "../component/Transform";
 import { RigidBody } from "../component/RigidBody";
 import { Scene } from "./Scene";
 import { GameActor, InitOptions } from "./GameActor";
+import { Container } from "../utils/Container";
 export declare const LAYER_DEFAULT = "Default";
-export declare type GameObjectClass<T extends GameObject = GameObject> = new (name?: string, parent?: GameObject) => T;
+export declare type GameObjectClass<T extends GameObject = GameObject> = new (container: Container, name?: string, parent?: GameObject) => T;
 export declare class GameObject extends GameActor {
     readonly id: string;
     readonly name: string;
@@ -14,11 +15,10 @@ export declare class GameObject extends GameActor {
     keep: boolean;
     private _parent;
     private _active;
-    private sceneManager;
     private components;
     private activeComponentsCache;
     private activeChildrenCache;
-    constructor(name?: string, parent?: GameObject);
+    constructor(container: Container, name?: string, parent?: GameObject);
     get active(): boolean;
     set active(active: boolean);
     get parent(): GameObject | null;

package/lib/core/Scene.d.ts

@@ -1,10 +1,12 @@
 import { GameCamera } from "../gameObject/GameCamera";
+import { Container } from "../utils/Container";
 import { Game } from "./Game";
 import { GameActor } from "./GameActor";
+export declare type SceneClass = new (container: Container, name: string, game: Game) => Scene;
 export declare class Scene extends GameActor {
     readonly name: string;
     readonly game: Game;
-    constructor(name: string, game: Game);
+    constructor(container: Container, name: string, game: Game);
     get gameCamera(): GameCamera;
     protected _destroy(): void;
 }

package/lib/core/ioc/Config.d.ts

@@ -1,3 +1,3 @@
-import { GameConfig } from "../Game";
 import { Container } from "../../utils/Container";
+import { GameConfig } from "../GameConfig";
 export declare const loadDependencies: (container: Container, gameConfig: GameConfig) => void;

package/lib/core/managers/GameObjectManager.d.ts

@@ -1,7 +1,10 @@
 import { GameObject, GameObjectClass } from "../GameObject";
 import { InitOptions } from "../GameActor";
+import { Container } from "../../utils/Container";
 export declare class GameObjectManager {
+    private readonly container;
     private gameObjects;
+    constructor(container: Container);
     addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
     findGameObjects<T extends GameObject>(gameObjectClass?: GameObjectClass<T>): T[];
     findGameObjectById<T extends GameObject>(id: string): T;

package/lib/core/managers/SceneManager.d.ts

@@ -1,9 +1,10 @@
 import { Game } from "../Game";
-import { Scene } from "../Scene";
+import { Scene, SceneClass } from "../Scene";
 import { IRenderManager } from "angry-pixel-2d-renderer";
 import { InitOptions } from "../GameActor";
-export declare type SceneClass = new (name: string, game: Game) => Scene;
+import { Container } from "../../utils/Container";
 export declare class SceneManager {
+    private readonly container;
     private game;
     private renderManager?;
     private scenes;
@@ -11,7 +12,7 @@ export declare class SceneManager {
     private openingSceneName;
     private sceneToLoad;
     currentSceneName: string;
-    constructor(game: Game, renderManager?: IRenderManager);
+    constructor(container: Container, game: Game, renderManager?: IRenderManager);
     getCurrentScene<T extends Scene>(): T;
     addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     loadOpeningScene(): void;