PHP Design Patterns Game : The Adapter Pattern

Welcome to our series of articles on PHP Design Patterns Games! In this article, we’ll be exploring the Adapter Pattern. This structural pattern allows incompatible interfaces to work together by wrapping the interface of an existing class with a new interface. The Adapter Pattern can be useful in situations where you want to reuse existing code, but its interface doesn’t match the requirements of your current project.

In the context of game development, the Adapter Pattern can be used to make different game systems work together seamlessly. For example, let’s say you want to integrate a third-party library for handling input in your game. However, the library’s interface doesn’t match the input system used in your game. You can use the Adapter Pattern to create a wrapper class that maps the library’s interface to your game’s input system.

In this article, we’ll demonstrate how to use the Adapter Pattern in PHP to create an adapter that allows a game to work with different types of controllers, such as keyboard and joystick controllers. By the end of this article, you’ll have a solid understanding of how to use the Adapter Pattern to make different interfaces work together in your games.

Adapter Pattern

The Adapter pattern is a structural design pattern that allows incompatible interfaces to work together. In a game context, this pattern could be used to adapt different types of game controllers to work with a game that only supports a specific type of controller interface.

Let’s say we have a Game class that expects a controller object that implements a Controller interface:

interface Controller {
    public function up();
    public function down();
    public function left();
    public function right();
    public function action();
}

class Game {
    private $controller;

    public function __construct(Controller $controller) {
        $this->controller = $controller;
    }

    public function play() {
        $this->controller->up();
        $this->controller->down();
        $this->controller->left();
        $this->controller->right();
        $this->controller->action();
    }
}

Now let’s say we have two different types of controllers: a KeyboardController that implements the Controller interface, and a GamepadController that has a different interface:

class KeyboardController implements Controller {
    public function up() {
        echo "KeyboardController: up\n";
    }

    public function down() {
        echo "KeyboardController: down\n";
    }

    public function left() {
        echo "KeyboardController: left\n";
    }

    public function right() {
        echo "KeyboardController: right\n";
    }

    public function action() {
        echo "KeyboardController: action\n";
    }
}

class GamepadController {
    public function dpadUp() {
        echo "GamepadController: dpadUp\n";
    }

    public function dpadDown() {
        echo "GamepadController: dpadDown\n";
    }

    public function dpadLeft() {
        echo "GamepadController: dpadLeft\n";
    }

    public function dpadRight() {
        echo "GamepadController: dpadRight\n";
    }

    public function buttonA() {
        echo "GamepadController: buttonA\n";
    }

    public function buttonB() {
        echo "GamepadController: buttonB\n";
    }
}

Since the Game class expects a Controller interface, we need to adapt the GamepadController to work with it. We can do this by creating an adapter class that implements the Controller interface and has a GamepadController object as a member:

class GamepadControllerAdapter implements Controller {
    private $gamepadController;

    public function __construct(GamepadController $gamepadController) {
        $this->gamepadController = $gamepadController;
    }

    public function up() {
        $this->gamepadController->dpadUp();
    }

    public function down() {
        $this->gamepadController->dpadDown();
    }

    public function left() {
        $this->gamepadController->dpadLeft();
    }

    public function right() {
        $this->gamepadController->dpadRight();
    }

    public function action() {
        $this->gamepadController->buttonA();
    }
}

Now we can create a Game object with a KeyboardController and a Game object with a GamepadControllerAdapter:

$keyboardController = new KeyboardController();
$game = new Game($keyboardController);
$game->play();

$gamepadController = new GamepadController();
$gamepadControllerAdapter = new GamepadControllerAdapter($gamepadController);
$game2 = new Game($gamepadControllerAdapter);
$game2->play();

This example demonstrates how the Adapter pattern can be used to adapt an incompatible interface to work with an existing interface.

In conclusion, the Adapter pattern provides a flexible and powerful way to make different interfaces work together seamlessly. By encapsulating the interface of an existing object within an Adapter object, the Adapter pattern allows us to use that object with other objects that would otherwise be incompatible. This makes it possible to integrate different components and systems, even if they were not designed to work together.

The Adapter pattern helps to increase the flexibility and modularity of your code, making it easier to maintain and extend over time. By applying the Adapter pattern, you can improve the reusability and interoperability of your software, which can help to reduce development costs and increase productivity. Overall, the Adapter pattern is a valuable tool for any software developer who wants to create robust and scalable applications that can adapt to changing requirements and environments.