introduction
Les systèmes à composants d'entité sont une technique architecturale orientée objet.
Il n'y a pas de consensus universel sur ce que signifie le terme, de même que la programmation orientée objet. Cependant, il est clair que les systèmes à composants d'entité sont spécifiquement conçus comme une alternative architecturale à l' héritage . Hiérarchies d'héritage sont naturels pour exprimer ce qu'est un objet est , mais dans certains types de logiciels (comme les jeux), vous préférez exprimer ce qu'un objet fait .
Il s'agit d'un modèle d'objet différent de celui des «classes et héritage» auquel vous êtes probablement habitué à travailler en C ++ ou Java. Les entités sont aussi expressives que les classes, tout comme les prototypes comme en JavaScript ou Self - tous ces systèmes peuvent être implémentés les uns par rapport aux autres.
Exemples
Le mot Let qui Playerest une entité Position, Velocityet des KeyboardControlledcomposants qui font les choses évidentes.
entity Player:
Position
Velocity
KeyboardControlled
Nous savons qu'il Positionfaut être affecté par Velocityet Velocitypar KeyboardControlled. La question est de savoir comment nous aimerions modéliser ces effets.
Entités, composants et systèmes
Supposons que les composants n'aient aucune référence l'un à l'autre; un Physicssystème externe traverse tous les Velocitycomposants et met à jour l' Positionentité correspondante; un Inputsystème traverse tous les KeyboardControlledcomposants et met à jour le Velocity.
Player
+--------------------+
| Position | \
| | Physics
/ | Velocity | /
Input | |
\ | KeyboardControlled |
+--------------------+
Cela répond aux critères:
Les systèmes sont désormais responsables de la gestion des événements et de la mise en œuvre du comportement décrit par les composants. Ils sont également chargés de gérer les interactions entre les entités, telles que les collisions.
Entités et composants
Cependant, supposons que les composants n'ont des références les uns aux autres. Maintenant, l'entité est simplement un constructeur qui crée certains composants, les lie et gère leur durée de vie:
class Player:
construct():
this.p = Position()
this.v = Velocity(this.p)
this.c = KeyboardControlled(this.v)
L'entité peut désormais envoyer des événements d'entrée et de mise à jour directement à ses composants. Velocityrépondrait aux mises à jour et KeyboardControlledrépondrait aux commentaires. Cela répond toujours à nos critères:
Ici, les interactions entre composants sont explicites, et non imposées de l'extérieur par un système. Les données décrivant un comportement (quelle est la quantité de vitesse?) Et le code qui le décrète (quelle est la vitesse?) Sont couplées, mais de manière naturelle. Les données peuvent être considérées comme des paramètres du comportement. Et certains composants n'agissent pas du tout - a Positionest le comportement d' être dans un endroit .
Les interactions peuvent être gérées au niveau de l'entité («quand une Playercollision avec un Enemy…») ou au niveau des composants individuels («lorsqu'une entité avec Lifeentre en collision avec une entité avec Strength…»).
Composants
Quelle est la raison pour laquelle l'entité existe? S'il s'agit simplement d'un constructeur, nous pouvons le remplacer par une fonction renvoyant un ensemble de composants. Si nous voulons plus tard interroger des entités par leur type, nous pouvons tout aussi bien avoir un Tagcomposant qui nous permet de faire exactement cela:
function Player():
t = Tag("Player")
p = Position()
v = Velocity(p)
c = KeyboardControlled(v)
return {t, p, v, c}
Les interactions doivent maintenant être gérées par des requêtes abstraites, découplant complètement les événements des types d'entités. Il n'y a plus de types d'entités à interroger - les Tagdonnées arbitraires sont probablement mieux utilisées pour le débogage que la logique de jeu.
Conclusion
Les entités ne sont pas des fonctions, des règles, des acteurs ou des combinateurs de flux de données. Ce sont des noms qui modélisent des phénomènes concrets - en d'autres termes, ce sont des objets. C'est comme le dit Wikipedia - les systèmes à composants d'entité sont un modèle d'architecture logicielle pour la modélisation d'objets généraux.