PHP Design Patterns Game : The Strategy Pattern

Welcome to our new series of articles, PHP Design Patterns Games! In this article, we will explore the Strategy Pattern, which is a behavioral design pattern that enables an object, called the context, to change its behavior dynamically by selecting a suitable algorithm from a group of algorithms. This allows the context to vary its behavior without the need to change its implementation. We will demonstrate how to use the Strategy Pattern to implement different strategies in a game where the player can choose from different characters with different abilities.

Strategy Pattern

The Strategy pattern is a behavioral pattern that allows objects to change their behavior dynamically at runtime by encapsulating a family of algorithms and making them interchangeable. In other words, it enables the selection of an algorithm at runtime depending on the context.

Let’s consider a simple game where the player can choose from different characters with different abilities. For example, we have a knight, a wizard, and an archer. Each character has a unique set of abilities that can be used during the game.

To implement the Strategy pattern in this game, we can create an interface called CharacterAbility that defines a common method called useAbility(). This method will be implemented differently for each character class that we have. Here’s an example of the CharacterAbility interface:

interface CharacterAbility {
    public function useAbility();
}

Next, we can create different character classes, each implementing the CharacterAbility interface with their own implementation of the useAbility() method. For example, we can create the Knight class as follows:

class Knight implements CharacterAbility {
    public function useAbility() {
        // Implement the knight's ability here
    }
}

Similarly, we can create the Wizard and Archer classes with their own implementation of the useAbility() method.

Now, let’s say the player has selected a character, and we need to use their ability during the game. We can create a Game class that will receive the selected character as a parameter and use their ability during the game. However, we don’t want to hardcode the ability inside the Game class because we want to make it interchangeable. This is where the Strategy pattern comes in.

We can create another interface called AbilityStrategy that will define the useAbility() method, which takes the character object as a parameter. This interface will be implemented by different strategy classes, each representing a specific ability of the character. For example, we can create the KnightAbilityStrategy class as follows:

class KnightAbilityStrategy implements AbilityStrategy {
    public function useAbility($character) {
        $character->useAbility(); // Use the knight's ability
    }
}

Similarly, we can create the WizardAbilityStrategy and ArcherAbilityStrategy classes with their own implementation of the useAbility() method.

Finally, in the Game class, we can set the ability strategy based on the selected character. For example:

class Game {
    private $abilityStrategy;
    
    public function setAbilityStrategy($character) {
        if ($character instanceof Knight) {
            $this->abilityStrategy = new KnightAbilityStrategy();
        } else if ($character instanceof Wizard) {
            $this->abilityStrategy = new WizardAbilityStrategy();
        } else if ($character instanceof Archer) {
            $this->abilityStrategy = new ArcherAbilityStrategy();
        }
    }
    
    public function useAbility() {
        $this->abilityStrategy->useAbility($character);
    }
}

Now, whenever the player selects a character, we can set the ability strategy accordingly using the setAbilityStrategy() method, and the useAbility() method will call the correct ability based on the selected character. This way, we can make the abilities interchangeable without modifying the Game class.

In conclusion, the Strategy pattern allows us to encapsulate different algorithms or behaviors and make them interchangeable at runtime, without affecting the client code. This makes our code more flexible and maintainable, and it is particularly useful in games where different characters have different abilities that can be used in different contexts.