Discussion :

[Disixlis]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ):

• 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

[Cafeinoman]

Salut,

le principe de L'ECS c'est justement de ne pas créer de classe structuré pour gagner en souplesse. Donc de base, je pense que créer des structures est une mauvaise idée.

Ce que je fait personnellement pour mes projets c'est plutôt d'utiliser le pattern factory. A la place d'une structure, tu fait une factory qui génère l'entity et fait l'association entre elle et tes composants et retourne l'entity (enfin l'id pour être exact).

A la limite, tu peux passer une Map<String,Object> en paramètre pour avoir les valeurs à donner à chaque composant pour ceux qui ne sont pas constant, ou mettre les paramètres nécessaire.

Comme ça tu as des instanciation d'une ligne, et tu garde l'avantage de ne manipuler que des id, pas des structures.

Personnellement je bosse avec Zay-es, L'ECS de JMonkeyEngine. Je te conseille de jeter un oeil, le wiki du Github est plutôt pas mal fait.