The Game class

The Game class is the main entry point for creating and managing a game instance in Angry Pixel Engine.
It acts as the central coordinator that manages:

Scenes.
Entities.
Components.
Managers (rendering, physics, input, etc.).

It also provides methods to configure the game, add scenes and dependencies, and control the execution cycle (game loop).

Constructor

new Game(config: GameConfig)

The constructor receives a GameConfig object where you can define:

The HTML node where the game will be rendered (containerNode).
Dimensions (width and height).
Optional: physics settings, colors, collision methods, etc.

Basic example

const game = new Game({
    containerNode: document.getElementById("app"),
    width: 1920,
    height: 1080,
});

game.addScene(MainScene, "MainScene", true);
game.start();

Advanced example

const game = new Game({
    containerNode: document.getElementById("app"),
    width: 1920,
    height: 1080,
    debugEnabled: false,
    canvasColor: "#000000",
    physicsFramerate: 180,
    collisions: {
        collisionMatrix: [
            ["layer1", "layer2"],
            ["layer1", "layer3"],
        ],
        collisionMethod: CollisionMethods.SAT,
        collisionBroadPhaseMethod: BroadPhaseMethods.SpartialGrid,
    },
});

game.addScene(MainScene, "MainScene", true);
game.start();

GameConfig details

The GameConfig object allows you to customize how the game initializes.
Here are all the available properties:

Property	Type	Description
`containerNode`	HTMLElement	HTML node where the game will be rendered. Required.
`width`	number	Game width in pixels. Required.
`height`	number	Game height in pixels. Required.
`debug`	object (optional)	Debug options. Allows showing colliders, mouse position, and other data during execution.
`debug.colliders`	boolean	Show colliders.
`debug.mousePosition`	boolean	Show mouse position.
`debug.collidersColor`	string	Color of the colliders. Default: `#00FF00` (green).
`debug.textColor`	string	Color of debug texts. Default: `#00FF00`.
`debug.textPosition`	string	Position of debug text: `"top-left"`, `"top-right"`, `"bottom-left"` or `"bottom-right"`.
`canvasColor`	string	Background color of the canvas. Default: `#000000` (black).
`physicsFramerate`	number	Physics execution framerate. Allowed values: `60`, `120`, `180` or `240`. Default: `180`.
`headless`	boolean	Enables headless mode. Disables input and rendering (ideal for game servers).
`dependencies`	Array	List of external dependencies to be injected through dependency injection.
`collisions`	object (optional)	Collision configuration options.
`collisions.collisionMethod`	CollisionMethods	Collision detection method: `SAT` or `ABB`. Default: `SAT`.
`collisions.collisionMatrix`	Array	Matrix that defines which layers can collide with each other.
`collisions.collisionBroadPhaseMethod`	BroadPhaseMethods	Broad phase method: `QuadTree` or `SpartialGrid`. Default: `SpartialGrid`.

Note: If some options are not specified, the engine will use recommended default values.

Methods

`addScene(sceneType, name, openingScene = false)`

Adds a new scene to the game.

sceneType: the scene class.
name: name to identify the scene.
openingScene: if true, this will be the opening scene when the game starts.

Example:

game.addScene(MainScene, "MainScene", true);

`addDependencyType(dependencyType, name?)`

Adds a class to be used as a dependency.

dependencyType: the dependency class.
name: the name of the dependency (optional if the class uses the injectable decorator).

Example:

game.addDependencyType(MyCustomService);

`addDependencyInstance(dependencyInstance, name)`

Adds a specific instance to be used as a dependency.

dependencyInstance: the instance to use.
name: the name of the dependency.

Example:

game.addDependencyInstance(myDatabaseInstance, "Database");

`start()`

Starts the game and begins the update cycle (game loop).

game.start();

`stop()`

Stops the game’s update cycle.

game.stop();

Properties

`running`

Returns true if the game is currently running.

if (game.running) {
    console.log("The game is running");
}

Summary

The Game class is responsible for:

✅ Initializing configuration and dependencies.
✅ Managing scenes.
✅ Controlling the game’s lifecycle (start and stop).
✅ Providing a central point to customize the engine’s behavior.

Note: Internally, Game uses dependency injection to initialize and connect all game systems.