Entités
Les entités (représentées par la classe abstraite Entity
) sont tous les éléments qui peuvent se tenir sur le terrain et interagir avec. Cet ensemble est découpé en deux sous-parties : les entités vivantes (LivingEntity
) et les projectiles (Projectile
). Pour représenter l'ensemble des entités, nous avons décidé de ne pas avoir un ensemble de classes héritant des classes que nous avons actuellement, mais plutôt de donner un type d'entité (EntityType
) en attribut de ces classes. Ainsi, un simple Guerrier Humain et Saroumane sont deux entités de type LivingEntity
ayant simplement de différent à la création leur type d'entité. Ces types d'entités sont subdivisés en deux sous-types : les types d'entités vivantes (LivingEntityType
) et les types de projectiles (ProjectileType
). Ce sont des énumérations qui regroupent les caractéristiques des entités de leur type.
Cette classe est la base de tout ce qui concerne les entités. Elle possède énormément d'attributs que ses enfants peuvent exploiter, allant du plus général (le type d'entité) au plus particulier (liste de modificateurs d'attribut), dans le but de simplifier au maximum la définition de sous-classes ajoutant des caractéristiques.
Cette interface est implémentée par les deux énumérations de type d'entités, et apporte des accesseurs et des mutateurs sur les données associées, ainsi que des méthodes statiques permettant la récupération d'un type à partir d'une donnée.
Ces deux classes héritent donc de Entity
et profitent de sa complétude (Location
, Hitbox
, AttributeModifier
, Level
, etc...) pour apporter leurs caractéristiques le plus simplement possible.
L'idée derrière cette classe est d'apporter un notion de points de vie, et la possibilité de mourir (bien que la notion d'existence soit déjà gérée par la classe Entity
étant donné que les projectiles peuvent aussi disparaitre). Elle possède également une notion de bouclier, qui peut encaisser des dégâts ou être ignoré. Les entités vivantes peuvent enfin avoir plusieurs "états" matérialisés par leurs flags
.
Il existe également à travers l'une des méthodes de cette classe une notion de DamageCause
(celle de Damageable
étant déjà représentée par la classe LivingEntity
elle-même) qui sont simplement les entités et les causes externes, dont deux sont définies dans cette classe.
Excepté la classe Entity
, toutes ces sources de dégâts sont des singletons. On ne peut donc pas les instancier et leur instance se récupère via la méthode statique getInstance()
.
La classe Entity
implémente l'interface DamageCause
, étant donné que toutes les entités peuvent attaquer (certaines n'infligent aucun dégât, mais peuvent tout de même attaquer et déclencher leurs capacités d'attaque, comme la Tour du Mordor).
Cette classe est définie dans LivingEntity
et est un singleton. En effet, il n'existe qu'une seule instance capable d'attaquer, infligeant des dégâts fixes. Ceci est plus à but informatif pour la victime (elle peut savoir si les dégâts qu'elle a subit sont des dégâts directs ou des dégâts de feu ou de poison par exemple).
Cette classe est très similaire à TickDamageCause
. Définie également dans LivingEntity
et comme singleton, elle dénote les dégâts (mortels) découlant de la disparition d'une entité (lorsque le niveau est arrêté ou que l'unité est vendue par exemple). L'attaque de son unique instance ignore le bouclier de sa cible et inflige autant de dégât qu'elle a de vie, tuant ainsi à 100% de chance.
Cette classe (similaire aux deux précédente) est définie dans Level
et représente les dégâts dus au fait que l'unité attaquante a atteint la fin du niveau et doit ainsi disparaître. Tout comme la DispawnDamageCause
, son attaque est mortelle à 100%.
Cette énumération (qui implémente EntityType
) liste toutes les entités vivantes de notre jeu. Chaque type d'entité possède un camp (EntitySide
) et un sous-type (SubType
, défini dans l'énumération). De plus, ils ont des données qui sont chargées depuis le fichier game_data/entities.yml
dans la méthode YAMLLoader.loadEntityData();
Cette énumération est très simple, et ne contient que deux valeurs : ATTACKER
& DEFENDER
. Ces valeurs déterminent la nature première d'une entité, et la méthode isEnemy()
va les comparer (deux unités de camp différents sont ennemies, sinon alliées).
Ce sont les sous-types possibles pour les entités vivantes. Ces valeurs déterminent le caractère de l'entité, et son rôle. Les valeurs sont : CLASSIC
(entités lambda), SPECIAL
(entité particulières comme les portes), HERO
& BOSS
.
Il existe deux sous-classes qui héritent de LivingEntity
: Hero
& Door
. Ces classes sont particulières car elles apportent des comportements supplémentaires à ces deux entités.
Les héros sont définis à travers cette classe, qui gère la notion d'amélioration des statistiques, d'utilisation de pouvoir spécial, et de réapparition au bout d'un certain temps après la mort.
Les portes ont de particulier leur capacité à bloquer physiquement leur ennemis ainsi que d'avoir des points de vie au cas par cas.
Cette classe représente les projectiles, de manière globale. Ils sont définis avec un type, une source LivingEntity
, une Location
cible, une vitesse et éventuellement un angle de déviation.
Ce sont les différents types de projectiles qui existent. Mis à part leur données, les types sont complètement vierges et leur réelle spécification dépend de leur source.
Voici le diagramme de classe correspondant à cette hiérarchie complète :
Ce Wiki correspond au projet de S2 de BOT Télio, POMMERY Jules et SZANTO Théo sur un Tower Defense
. Plus d'infos ici.