Game Setup And Config

Game Setup and Config

How to create a Phaser.Game instance with the right GameConfig options for renderer, scaling, pixel art, FPS, and canvas placement.

Key source paths: src/core/Game.js, src/core/Config.js, src/core/typedefs/GameConfig.js, src/const.js, src/scale/const/ Related skills: ../scenes/SKILL.md, ../loading-assets/SKILL.md, ../scale-and-responsive/SKILL.md

Quick Start

The simplest possible Phaser 4 game -- a single scene with the default 1024×768 canvas:

class MyScene extends Phaser.Scene {
    preload() {
        this.load.image('logo', 'assets/logo.png');
    }

    create() {
        this.add.image(400, 300, 'logo');
    }
}

const config = {
    type: Phaser.AUTO,
    scene: MyScene
};

const game = new Phaser.Game(config);

new Phaser.Game(config) triggers the entire boot sequence: config parsing (Config), renderer creation, DOM insertion, and the game loop (TimeStep). The game waits for DOMContentLoaded before booting.

Core Concepts

Boot Sequence (src/core/Game.js)

1. new Phaser.Game(config) -- parses config into a Phaser.Core.Config instance.
2. Creates global managers: AnimationManager, TextureManager, CacheManager, InputManager, SceneManager, ScaleManager, SoundManager, TimeStep, PluginManager.
3. Waits for DOMContentLoaded, then calls boot().
4. boot() creates the renderer (CreateRenderer), adds the canvas to the DOM (AddToDOM), prints the debug header, emits BOOT.
5. Once textures are ready (TextureManager emits READY), emits READY then calls start().
6. start() begins the TimeStep loop, sets up the VisibilityHandler, calls config.postBoot.

Config Parsing (src/core/Config.js)

The Config constructor reads a flat GameConfig object and resolves defaults. Some properties can be specified at top level OR nested inside sub-objects (e.g., width can be top-level or under scale.width). The scale sub-object takes priority when both are present.

Render properties can likewise be top-level shortcuts (e.g., pixelArt: true) or nested under render.

Renderer Constants (src/const.js)

Set via config.type. Default is Phaser.AUTO.

Common Patterns

Pixel Art Game

When pixelArt is true, Config automatically sets antialias: false, antialiasGL: false, and roundPixels: true.

const config = {
    type: Phaser.AUTO,
    width: 320,
    height: 240,
    pixelArt: true,
    scale: {
        mode: Phaser.Scale.FIT,
        autoCenter: Phaser.Scale.CENTER_BOTH,
        zoom: Phaser.Scale.ZOOM_2X
    },
    scene: MyScene
};

Smooth Pixel Art (WebGL only)

Preserves blocky pixels but smooths edges between them when scaled up:

const config = {
    type: Phaser.WEBGL,
    width: 320,
    height: 240,
    smoothPixelArt: true,
    scene: MyScene
};

When smoothPixelArt is true, Config sets antialias: true, antialiasGL: true, and pixelArt: false.

Full-Window Responsive Game

const config = {
    type: Phaser.AUTO,
    scale: {
        mode: Phaser.Scale.RESIZE,
        parent: 'game-container',
        width: '100%',
        height: '100%'
    },
    scene: MyScene
};

Fixed Aspect Ratio with FIT

const config = {
    type: Phaser.AUTO,
    scale: {
        mode: Phaser.Scale.FIT,
        parent: 'game-container',
        autoCenter: Phaser.Scale.CENTER_BOTH,
        width: 1280,
        height: 720,
        min: { width: 640, height: 360 },
        max: { width: 1920, height: 1080 }
    },
    backgroundColor: '#2d2d2d',
    scene: MyScene
};

Custom FPS Limit

const config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    fps: {
        target: 60,
        limit: 30,
        forceSetTimeOut: false,
        smoothStep: true
    },
    scene: MyScene
};

Transparent Canvas Over HTML

const config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    transparent: true,
    parent: 'game-container',
    scene: MyScene
};

When transparent is true, backgroundColor is forced to 0x000000 with alpha 0.

Pre-existing Canvas Element

const canvas = document.getElementById('my-canvas');

const config = {
    type: Phaser.WEBGL,
    canvas: canvas,
    width: 800,
    height: 600,
    scene: MyScene
};

Multiple Scenes

const config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    scene: [BootScene, PreloadScene, MenuScene, GameScene],
    physics: {
        default: 'arcade',
        arcade: { gravity: { y: 300 } }
    }
};

Only the first scene starts automatically. Others start only if they have { active: true } in their scene config. See ../scenes/SKILL.md.

Boot Callbacks

const config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    callbacks: {
        preBoot: function (game) {
            // Runs before Phaser boots. Game systems not yet available.
        },
        postBoot: function (game) {
            // Runs after boot. All systems ready, game loop starting.
        }
    },
    scene: MyScene
};

Disabling Input Subsystems

const config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    input: {
        keyboard: true,
        mouse: true,
        touch: false,
        gamepad: false,
        activePointers: 1,
        windowEvents: true
    },
    disableContextMenu: true,
    scene: MyScene
};

Configuration Reference

Top-Level GameConfig Properties

scale (Phaser.Types.Core.ScaleConfig)

Scale Modes (src/scale/const/SCALE_MODE_CONST.js)

Center Modes (src/scale/const/CENTER_CONST.js)

Zoom Constants (src/scale/const/ZOOM_CONST.js)

render (Phaser.Types.Core.RenderConfig)

These can be set at the top level OR nested under render. The render sub-object takes priority.

fps (Phaser.Types.Core.FPSConfig)

Other Sub-Configs

Game Lifecycle, Pause/Resume, and Destroy

Game Lifecycle Events

Listen on game.events (or this.game.events from a Scene) for visibility and focus changes:

game.events.on('blur', () => { /* tab lost focus */ });
game.events.on('focus', () => { /* tab regained focus */ });
game.events.on('hidden', () => { /* Page Visibility API: page hidden */ });
game.events.on('visible', () => { /* Page Visibility API: page visible */ });
game.events.on('pause', () => { /* game.pause() was called */ });
game.events.on('resume', () => { /* game.resume() was called */ });

Use named constants: Phaser.Core.Events.BLUR, FOCUS, HIDDEN, VISIBLE, PAUSE, RESUME.

Pause and Resume

// Pause the entire game loop (rendering and updates stop)
game.pause();

// Resume the game loop
game.resume();

// Check if the game is currently paused
if (game.isPaused) {
    // game loop is not running
}

Destroying the Game

// Remove the canvas from the DOM and clean up
game.destroy(true);

// Full cleanup -- pass noReturn=true if you will NEVER create another Phaser instance
// This allows the framework to release additional internal references
game.destroy(true, true);

destroy(removeCanvas, noReturn) is asynchronous -- it flags the game for destruction on the next frame. Listen for Phaser.Core.Events.DESTROY to react to completion.

Global Game Members

The Game instance exposes key managers as properties, accessible from any Scene via this.game:

// Example: access the registry from any scene
this.game.registry.set('highScore', 9999);

// Example: access the scene manager
this.game.scene.start('MenuScene');

Gotchas and Common Mistakes

1. scale vs top-level config. width, height, zoom, and parent can be set at the top level or inside scale. The scale sub-object values take priority. Avoid setting both to prevent confusion.

2. Phaser.WEBGL has no fallback. Unlike AUTO, using Phaser.WEBGL directly will not fall back to Canvas if WebGL is unavailable. The game will fail silently.

3. parent: null vs parent: undefined. undefined (or omitted) appends the canvas to document.body. null means Phaser will not add the canvas to the DOM at all -- you must do it yourself.

4. transparent overrides backgroundColor. When transparent: true, the background color is forced to rgba(0,0,0,0) regardless of what you set.

5. fps.target does not enforce frame rate. It is advisory only. Use fps.limit to actually cap the frame rate. The browser's display refresh rate is always the upper bound.

6. fps.limit only slows down, never speeds up. Setting limit: 120 on a 60Hz display still results in 60 FPS.

7. DOM Container requires a parent. Setting dom.createContainer: true without providing a parent element will not work.

8. smoothPixelArt is WebGL-only. It has no effect with the Canvas renderer.

9. window.FORCE_WEBGL and window.FORCE_CANVAS. Config.js checks for these globals at the end of parsing and will override the type setting. This is intended for development/testing.

10. Game.destroy() is asynchronous. It flags the game for destruction on the next frame. Listen for the DESTROY event to react to completion. Pass noReturn: true only if you will never create another Phaser instance on the same page.

v4 Changes from v3

• Default dimensions changed: Width defaults to 1024 (was 800), height to 768 (was 600).
• EXPAND scale mode added: Phaser.Scale.EXPAND (value 6) is new -- combines RESIZE visible area behavior with FIT canvas scaling.
• Loader maxRetries default: loader.maxRetries defaults to 2 (was 0 in early v3).
• smoothPixelArt option: New WebGL-only rendering mode that smooths edges between blocky pixels.
• renderNodes config: New render.renderNodes property for custom WebGL render node registration.
• skipUnreadyShaders: New option for parallel shader compilation to prevent stutter.
• pathDetailThreshold: New config for Graphics WebGL path point combining.

Source File Map