PHP Design Patterns Recreation : The Technique Sample

Welcome to our new collection of articles, PHP Design Patterns Video games! On this article, we are going to discover the Technique Sample, which is a behavioral design sample that allows an object, known as the context, to vary its habits dynamically by choosing an appropriate algorithm from a gaggle of algorithms. This permits the context to differ its habits with out the necessity to change its implementation. We’ll display methods to use the Technique Sample to implement completely different methods in a sport the place the participant can select from completely different characters with completely different talents.

Technique Sample

The Technique sample is a behavioral sample that enables objects to vary their habits dynamically at runtime by encapsulating a household of algorithms and making them interchangeable. In different phrases, it allows the number of an algorithm at runtime relying on the context.

Let’s contemplate a easy sport the place the participant can select from completely different characters with completely different talents. For instance, we’ve got a knight, a wizard, and an archer. Every character has a novel set of talents that can be utilized through the sport.

To implement the Technique sample on this sport, we will create an interface known as CharacterAbility that defines a typical methodology known as useAbility(). This methodology will probably be carried out in a different way for every character class that we’ve got. Right here’s an instance of the CharacterAbility interface:

interface CharacterAbility {
    public perform useAbility();
}

Subsequent, we will create completely different character courses, every implementing the CharacterAbility interface with their very own implementation of the useAbility() methodology. For instance, we will create the Knight class as follows:

class Knight implements CharacterAbility {
    public perform useAbility() {
        // Implement the knight's potential right here
    }
}

Equally, we will create the Wizard and Archer courses with their very own implementation of the useAbility() methodology.

Now, let’s say the participant has chosen a personality, and we have to use their potential through the sport. We will create a Recreation class that can obtain the chosen character as a parameter and use their potential through the sport. Nevertheless, we don’t need to hardcode the power contained in the Recreation class as a result of we need to make it interchangeable. That is the place the Technique sample is available in.

We will create one other interface known as AbilityStrategy that can outline the useAbility() methodology, which takes the character object as a parameter. This interface will probably be carried out by completely different technique courses, every representing a particular potential of the character. For instance, we will create the KnightAbilityStrategy class as follows:

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

Equally, we will create the WizardAbilityStrategy and ArcherAbilityStrategy courses with their very own implementation of the useAbility() methodology.

Lastly, within the Recreation class, we will set the power technique based mostly on the chosen character. For instance:

class Recreation {
    non-public $abilityStrategy;
    
    public perform 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 perform useAbility() {
        $this->abilityStrategy->useAbility($character);
    }
}

Now, each time the participant selects a personality, we will set the power technique accordingly utilizing the setAbilityStrategy() methodology, and the useAbility() methodology will name the proper potential based mostly on the chosen character. This manner, we will make the talents interchangeable with out modifying the Recreation class.

In conclusion, the Technique sample permits us to encapsulate completely different algorithms or behaviors and make them interchangeable at runtime, with out affecting the shopper code. This makes our code extra versatile and maintainable, and it’s significantly helpful in video games the place completely different characters have completely different talents that can be utilized in numerous contexts.