Toolbox Aid

October 20th, 2024 10:31 PM Mr. Q Categories: JavaScript

Game design patterns provide reusable solutions to common problems in game development. They help maintain clean, organized code and can improve the overall architecture of a game. Here, we explore three popular design patterns: the Singleton pattern, the Factory pattern, and the Observer pattern.

Command Description

1. Singleton Pattern:

• Ensures a class has only one instance and provides a global access point to it.

1. Factory Pattern:

• Defines an interface for creating objects but allows subclasses to alter the type of objects that will be created.

1. Observer Pattern:

• A behavioral pattern where an object (the subject) maintains a list of dependents (observers) that are notified of state changes.

Sample Code

1. Singleton Pattern Example

class GameSettings {
    constructor() {
        if (GameSettings.instance) {
            return GameSettings.instance; // Return existing instance
        }
        this.settings = {};
        GameSettings.instance = this; // Store the instance
    }

    setSetting(key, value) {
        this.settings[key] = value;
    }

    getSetting(key) {
        return this.settings[key];
    }
}

// Usage
const settings1 = new GameSettings();
settings1.setSetting('volume', 80);
const settings2 = new GameSettings();
console.log(settings2.getSetting('volume')); // Output: 80
console.log(settings1 === settings2); // Output: true

Output

• Both settings1 and settings2 refer to the same instance, demonstrating the Singleton pattern by sharing settings between different parts of the game.

---

2. Factory Pattern Example

class Enemy {
    constructor(type) {
        this.type = type;
    }

    attack() {
        console.log(`${this.type} is attacking!`);
    }
}

class EnemyFactory {
    static createEnemy(type) {
        return new Enemy(type);
    }
}

// Usage
const goblin = EnemyFactory.createEnemy('Goblin');
const orc = EnemyFactory.createEnemy('Orc');

goblin.attack(); // Output: Goblin is attacking!
orc.attack();    // Output: Orc is attacking!

Output

• The EnemyFactory allows for easy creation of different enemy types without exposing the creation logic, promoting flexibility in adding new enemy types.

---

3. Observer Pattern Example

class GameEvent {
    constructor() {
        this.listeners = [];
    }

    subscribe(fn) {
        this.listeners.push(fn); // Add listener
    }

    unsubscribe(fn) {
        this.listeners = this.listeners.filter(listener => listener !== fn); // Remove listener
    }

    notify(data) {
        this.listeners.forEach(listener => listener(data)); // Notify all listeners
    }
}

// Usage
const scoreUpdated = new GameEvent();

function onScoreChange(score) {
    console.log(`Score updated to: ${score}`);
}

scoreUpdated.subscribe(onScoreChange);
scoreUpdated.notify(100); // Output: Score updated to: 100

Output

• The observer pattern allows different parts of the game to react to events (like score changes) without tightly coupling components.

Use Case

• Singleton Pattern:
• Ideal for managing game settings, game state, or resources where you need a single instance to avoid conflicts and maintain consistency.
• Factory Pattern:
• Useful when you need to create various game entities like enemies, items, or weapons, allowing for easy expansion by creating new subclasses.
• Observer Pattern:
• Great for implementing event systems where multiple components need to react to changes, such as updating the UI in response to score changes or health updates.

Summary

By utilizing design patterns such as Singleton, Factory, and Observer, developers can create well-structured, maintainable, and flexible game code. These patterns help manage complexity and enhance collaboration between different parts of a game, leading to a more cohesive development process.