Attaquer l'ennemi le plus éloigné à portée (Tower Defense)

Dans l'article précédent, j'ai montré comment suivre efficacement l'ennemi le plus éloigné à l'aide d'un tas maximum. Dans cet article, nous verrons comment intégrer cela dans une mécanique de jeu.

Approche événementielle

L'implémentation existante utilise une architecture basée sur les événements. Pour cet article, nous nous concentrerons sur les événements Enemy. Ces événements déclencheront des actions dérivées.

Chaque ennemi peut vivre divers événements. Vous trouverez ci-dessous un exemple de cycle de vie que l'ennemi peut traverser :

Pour l'article, je m'intéresse aux deux événements :

• EnemyMoved : tiré lorsque la position d'un ennemi change.
• EnemyRemoved* : tiré lorsqu'un ennemi est retiré du jeu (par exemple vaincu).

(* Je prévois d'ajuster les noms des événements à l'avenir puisqu'un ennemi peut être supprimé pour différentes raisons.)

Plan

J'ai créé un diagramme de modèle d'événement pour visualiser comment différents événements interagissent. Cela aide à comprendre comment les choses se connectent.

Pour chaque événement, j'ai une commande qui le déclenche. (Ainsi, un événement est le résultat d'une commande.) Dans certains cas, à la suite d'un événement, nous devrons mettre à jour les données (les notes autocollantes vertes le décrivent). Une combinaison des trois ensemble est une tranche verticale.

Je me concentrerai sur le post-it vert "Ennemis à portée de la tour".

Mise en œuvre

L'objectif est pour nous de mettre à jour les ennemis disponibles chaque fois qu'un ennemi est à portée de la tour et de les supprimer sinon.

Nous travaillerons avec une classe tour. Dans cette classe, nous avons une variable pour stocker les ennemis.

export class Tower implements ITower {
    public enemies = new MaxHeap()

    constructor(id: number, coords: Coordinate) {
        this.id = id
        this.coords = coords

        // listeners will go here...
    }

Placer les écouteurs d'événements dans la classe Tour centralise la logique, réduisant ainsi le besoin de maintenir des mappages entre les tours et les ennemis. Bien que cela ajoute une certaine complexité à la classe, cela garantit une meilleure encapsulation et simplifie le débogage, ce qui est une direction plus facile à prendre pour le moment.

Action : Ajouter des ennemis à portée

Test : Ajout d'un ennemi

Tout d'abord, nous allons écrire un test pour vérifier qu'un ennemi à portée est ajouté au tas d'ennemis de la tour :

it('should add an enemy to the tower when enemy is within range', () => {
    const tower = new Tower(1, { col: 0, row: 1 });
    const enemy = new TinyEnemy();
    enemy.currentPosition = { col: 0, row: 1 };

    triggerEnemyMovedEvent(enemy);

    expect(tower.enemies.length()).toBe(1);
});

Implémentation : ajout d'un ennemi

Voici l’implémentation correspondante :

window.addEventListener("enemyMoved", event => {
    const enemy: Enemy = event.detail.enemy;

    if (enemyWithinRange(this, enemy)) {
        this.enemies.insertOrUpdate(enemy.id, enemy.distanceTraveled);
    }
});

Chaque fois que ennemisMoved est déclenché, nous vérifierons si un ennemi doit être ajouté au tas. J'ai déjà la fonction EnemyWithinRange, il s'agit d'ajouter l'appel insertOrUpdate.

Action : empêcher l'ajout d'ennemis hors de portée

Test : ignorer les ennemis hors de portée

Ensuite, nous veillons à ce que les ennemis hors de portée de la tour ne soient pas ajoutés :

export class Tower implements ITower {
    public enemies = new MaxHeap()

    constructor(id: number, coords: Coordinate) {
        this.id = id
        this.coords = coords

        // listeners will go here...
    }

Implémentation : ignorer les ennemis hors de portée

Ce scénario est déjà couvert par notre vérification précédente utilisant ennemisWithinRange, donc aucun code supplémentaire n'est requis.

Action : Retirer les ennemis hors de portée

Test : Supprimer un ennemi hors de portée

Nous testons maintenant que les ennemis quittant la portée sont retirés de la visibilité de la tour :

it('should add an enemy to the tower when enemy is within range', () => {
    const tower = new Tower(1, { col: 0, row: 1 });
    const enemy = new TinyEnemy();
    enemy.currentPosition = { col: 0, row: 1 };

    triggerEnemyMovedEvent(enemy);

    expect(tower.enemies.length()).toBe(1);
});

Mise en œuvre : supprimer un ennemi hors de portée

window.addEventListener("enemyMoved", event => {
    const enemy: Enemy = event.detail.enemy;

    if (enemyWithinRange(this, enemy)) {
        this.enemies.insertOrUpdate(enemy.id, enemy.distanceTraveled);
    }
});

Si l'ennemi était à portée, nous pouvons le supprimer.

Action : Retirer un ennemi du jeu

Test : Gestion de l'événement "ennemiRemoved"

Enfin, nous veillons à ce que les ennemis retirés du jeu soient également retirés du tas de la tour :

it('should not add an enemy to the tower if enemy is out of range', () => {
    const tower = new Tower(1, { col: 0, row: 1 });
    const enemy = new TinyEnemy();
    enemy.currentPosition = { col: 0, row: 99 };

    triggerEnemyMovedEvent(enemy);

    expect(tower.enemies.length()).toBe(0);
});

Implémentation : Gestion de l'ennemiSupprimé

it('should remove an enemy from the tower when it moves out of range', () => {
    const tower = new Tower(1, { col: 0, row: 1 });
    const enemy = new TinyEnemy();
    enemy.currentPosition = { col: 0, row: 1 };

    // enemy within range
    triggerEnemyMovedEvent(enemy);
    expect(tower.enemies.length()).toBe(1);

    // enemy outside of the range
    enemy.currentPosition = { col: 0, row: 99 };
    triggerEnemyMovedEvent(enemy);

    expect(tower.enemies.length()).toBe(0);
});

Chaque fois qu'un événement est déclenché, si l'ennemi est à portée, nous pouvons le supprimer.

Conclusion

En combinant une approche basée sur les événements avec un tas maximum, nous avons obtenu un moyen efficace pour les tours de prioriser les ennemis de manière dynamique. La mise en œuvre s'intègre parfaitement au système d'événements du jeu, garantissant des mises à jour et une réactivité en temps réel.

De plus, en matière de tests, l'utilisation d'une approche basée sur les événements élimine le besoin de lier le code interne aux tests. Ce qui rend les tests moins fragiles. Nous pouvons refactoriser le code derrière le comportement comme nous le souhaitons, et tant que les événements/écouteurs sont correctement configurés, les tests devraient quand même réussir.

Cette mise en œuvre peut désormais ouvrir la voie à :

• Ajout d'une fonctionnalité d'attaque (maintenant que nous savons qui attaquer)
• Échanger la façon dont les données des ennemis sont stockées

N'hésitez pas à adapter cette approche pour vos propres jeux de tower defense.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!