Design Pattern Builder & Entity Component System
Bonjour à tous ! Depuis quelque mois je développe un jeu avec la méthode de conception Entity Component System. Avant pour pouvoir créer une entité et lui associer des composants il fallait faire comme cela :
Code:
1
2
3
4
5
6
7
|
// ex:Création d'un bloc
Entity e = EntityFactory.create();
this.es.put(e);
this.es.attach(this.e.id(), new CPosition(20,100));
this.es.attach(this.e.id(), new CSize(40,40));
this.es.attach(this.e.id(), new CTexture(ObjectTexture.DIRT_BLOCK)); |
où
es = EntitySystem -> Système qui gère la création/suppression d'entité et de composant associé.
es.attach -> Méthode qui permet d'associer une entité avec un ou plusieurs composants
Par la suite sont arrivé les structures d'entités qui permettent directement de créer un type de composition pour simplifier la création de certains types d’objets récurrents, par exemple :
Code:
1
2
3
4
5
|
// ex:Création d'un bloc
Entity e = EntityFactory.create();
this.es.put(e);
this.es.attach( e, new BlockStructure(20, 100, 40, 40, ObjectTexture.DIRT_BLOCK ); |
#Pour éviter les répétitions, je vais parler de "TOR" pour "Types d’Objets Récurrents"
Ayant aujourd'hui une dizaine de TOR dont :
- Un bloc
- Un item
- Une aura
- Un monstre
- Et cetera...
J'ai décidé de créer une classe mère, EntityStructure, qui peut-être prit en argument de la méthode attach. De celle-ci héritent les classes ItemStructure, BlockStructure, et cetera... Pour permettre facilement la création de nouveau TOR, j'ai aussi créé la classe EntityStructureBuilder.
Comme de longues explications sans contexte sont dures à comprendre voici un peu de code :
EntityStructure
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public class EntityStructure
{
public EntityStructure()
{
this.components = new ArrayList<Component>();
}
public EntityStructure(ArrayList<Component> components )
{
this.components = components;
}
public EntityStructure( EntityStructure es )
{
this.components = es.components();
}
public String whatDoIOwn() //debug
{
String s = new String("I have " + this.components.size() + " components :\n");
for( Component c : this.components )
s += "\t" + c.getClass().getName().substring(11) + "\n";
return s;
}
public ArrayList<Component> components()
{
return this.components;
}
protected ArrayList<Component> components;
} |
ItemStructure
Code:
1
2
3
4
5
6
7
8
9
10
11
|
public class ItemStructure extends EntityStructure
{
public ItemStructure( Vector2f size, Vector2f position, ObjectTexture ot )
{
super(new EntityStructureBuilder().addComponent(new CSize(size))
.addComponent(new CPosition(position)
.addComponent(new CTexture(ot))
.build());
}
} |
EntityStructureBuilder
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class EntityStructureBuilder
{
public EntityStructureBuilder()
{
this.components = new ArrayList<Component>();
}
public EntityStructureBuilder addComponent( Component c )
{
this.components.add(c);
return this;
}
public EntityStructure build()
{
return new EntityStructure(this.components);
}
private ArrayList<Component> components;
} |
Je peux donc facilement en 3 lignes de code créer un nouveau TOR. Bien que le code fonctionne parfaitement, je me pose quelques questions ( liste non exhaustive :D ):
- Es que c'est une bonne idée ?
- Trois constructeurs pour EntityStructure... c'est sale ?
- Y a-t-il mieux que le pattern builder pour mon cas ?
Je vous remercie de votre aide :)
