Discussion :

[lola26]

Bonjour à tous,

J'ai commencé à développer un jeu de cartes basé sur yugioh! Je veux savoir comment l'optimiser avant d'aller plus loin. Donc, après avoir recherché des modèles de conception, je pense à deux choix, mais je ne sais pas quel est le meilleur. Avant cela, pour expliquer le jeu :
Nous avons différents types de cartes :
->MAGIE
-> Piège
-> Monstre
->-> monstre de main deck
-> -> mostre du extra deck
>->->Lien
>->->Pendule
....

J'ai également trois types de decks lorsque je joue :
-> Deck principal (accepte les sorts, les pièges et les monstres principaux)
-> Extra deck (accepte les monstres qui sont lien, pendule...)
-> Side (accepte tout, il sert si vous souhaitez changer certaines cartes de votre main/extra entre les matchs)

Donc l'autre problème, c'est de trouver le meilleur moyen de faire le lien entre la carte et son deck afin de savoir si j'accepte ou non d'ajouter la carte au deck

OPTION 1 : utilisez le décorateur comme design pattern :
Le truc c'est que je vais créer plein de classes pour parfois rien. Par exemple, un monstre lien a 1 attribut de plus et n'a pas de points de def. Un pendule peut se transformer en spell card...

OPTION 2:
Créez une seule classe avec tous les attributs.

J'espère que mon problème est clair, merci à tous pour votre aide

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
public class Card extends javafx.scene.image.ImageView implements Serializable {
	private int id;
	private String name;
	private String type; //SpellCard, TrapCard, FusionMonster, SynchroMonster, Tuner monster, Pendulum monster
	private String desc; 
	private String race;
	private String image;
	private String imageSmall;
	private Player owner;
	private Limit limit = Limit.NO_LIMITED; 
	private Face face = Face.UP; 
 
	/**
         * This constructor is used to generate a card from data formatted as JSon
         * @param card  its type is JsonNode
         */
	public Card(JsonNode card, Player owner)
	{
		id = card.path("id").asInt();
		name = card.path("name").asText();
		type = card.path("type").asText();
		desc = card.path("desc").asText();
		race = card.path("race").asText();
		image = card.path("card_images").get(0).path("image_url").asText();
		imageSmall = card.path("card_images").get(0).path("image_url_small").asText();		
		this.owner = owner;
 
		setCardImage();
	}
 
	/**
         * This constructor is used to generate a card from data exported from database 
         * @param cardInfo its type is ResultSet
         */
	public Card(ResultSet cardInfos, Player owner)
	{
		try {
			id = cardInfos.getInt("id");
			name = cardInfos.getString("name");
			type = cardInfos.getString("type");
			desc = cardInfos.getString("desc");
			race = cardInfos.getString("race");
			image = cardInfos.getString("image");
			imageSmall = cardInfos.getString("imageSmall");
			this.owner = owner;
 
			setCardImage();
		} 
		catch (SQLException e) 
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	/**
         * This constructor is used to generate a card manually
         * @param id  card id
         * @param name card name
         * @param desc card description
         * @param race card race 
         * @param image card images list formatted as csv (;)
         */
	public Card(int id, String name, String type, String desc, String race, String image, String imageSmall, Player owner) 
	{
		this.id =  id;
		this.name = name;
		this.type = type;
		this.desc = desc;
		this.race = race;
		this.image = image;
		this.imageSmall = imageSmall;
		this.owner = owner;
		setCardImage();
	}
 
	//setters and getters 
}

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
public class MonsterCard extends Card {
	private int atk;
	private int def;
	private int level;
	private String attribute;
	private Position mode;
 
	/**
         * This constructor is used to generate a monster card from data formated as Json
         * @param card its type is JsonNode
         * @param owner player 
         */
	public MonsterCard(JsonNode card, Player owner) {
		super(card, owner);
 
		this.atk =  card.path("atk").asInt();
		this.def = card.path("def").asInt();
		this.level = card.path("level").asInt();
		this.attribute = card.path("attribute").asText();
	}
 
	/**
         * This constructor is used to generate a monster card from data exported from database 
         * @param cardInfos its type is ResultSet
         */
	public MonsterCard(ResultSet cardInfos, Player owner) {
		super(cardInfos, owner);
 
		try {
			this.atk = cardInfos.getInt("atk");
			this.def = cardInfos.getInt("def");
			this.level = cardInfos.getInt("level");
			this.attribute = cardInfos.getString("attribute");	
		}
		catch (SQLException e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	/**
         * @param id
         * @param name
         * @param type
         * @param desc
         * @param race
         * @param image
         * @param imageSmall
         * @param owner
         */
	public MonsterCard(int id, String name, String type, String desc, String race, String image, String imageSmall,
			Player owner) {
		super(id, name, type, desc, race, image, imageSmall, owner);
 
	}
        //getter and setter

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
 
public  class SpellCard extends Card{
 
	public SpellCard(int id, String name, String type, String desc, String race, String image, String imageSmall, Player owner) {
		super(id, name, type, desc, race, image, image, owner);
	}
 
	public SpellCard(JsonNode card, Player owner) {
		super(card, owner);
	}
 
	public SpellCard(ResultSet cardInfos, Player owner) {
		super(cardInfos, owner);
	}
 
        //getter and setter
}

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
 
public class TrapCard extends Card{
 
	/**
         * @param id
         * @param name
         * @param type
         * @param desc
         * @param race
         * @param image
         * @param owner
         */
	public TrapCard(int id, String name, String type, String desc, String race, String image, String imageSmall, Player owner) {
		super(id, name, type, desc, race, image, imageSmall, owner);
		// TODO Auto-generated constructor stub
	}
 
         //getter and setter
}

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
public class Deck implements Serializable{
 
	private List<Card> cardList ;	
 
	private DeckType type;
 
	public Deck(DeckType type)
	{
		cardList = new ArrayList<Card>(type.getMinCard());
 
		this.type = type;
	}
 
 
	public boolean checkNbCard()
	{
 
		//size of the deck 
		int size = cardList.size() ;
 
		return (size >= getMinCard()&& size <= getMaxCard());
	}
 
	public boolean checkCardCopies()
	{
		//count each card occurrences
		 Map<String,Long> occurrenceMap = cardList.stream().collect(Collectors.groupingBy(card -> card.getName(),Collectors.counting()));
 
		 return (cardList.stream().filter(card -> card.getLIMIT().getNbCopies()< occurrenceMap.get(card.getName())).count() > 0);
	}
 
	public boolean isValid()
	{
		return (checkNbCard() && checkCardCopies());
	}
 
	public void addCard(Card card)
	{
		cardList.add(card);
	}
 
	public void removeCard(Card card)
	{
		cardList.remove(card);
	}
 
	public void clearDeck()
	{
		cardList.clear();	
	}
	//getter and setter
}

[seroze]

Bonjour,
Désolé mais ton problème n'est pas vraiment clair.

Pour faire le lien entre la carte et son deck, moi je ferai simple :
Dans la classe Card, je déclarerai des variables :

boolean acceptDeckPrincipal = false;
boolean acceptExtraDeck = false;

et dans les constructeurs de la classe MonsterCard (et les autres en fonction de leur type) je ferai un :
acceptDeckPrincipal = true;

Pour l'OPTION 1 : utilisez le décorateur comme design pattern :
Je ne vois pas pourquoi. Eventuellement pour lier un sort à un monstre mais ce n'est pas le problème décrit ici.

Pour l'OPTION 2:Créez une seule classe avec tous les attributs.
Alors là je ne vois vraiment pas pourquoi. Ta structure me semble correcte.

[lola26]

rebonjour,
oui mon post n'était pas clair et je n'ai pas su où l'éditer. Je reprends de 0. Le but du jeu yugioh! c'est de réduire les points de l'adversaire à 0. Pour cela, j'ai trois grands types de cartes : magie, piège et monstre. Pour chaque type, il y a plusieurs sous-catégories .

Mon soucis en fait c'est que j'ai des cartes pièges par exemple qui leur effet c'est de les transformer en monstre. Du coup un piège peut se comporter comme un monstre et avoir finalement des points d'attaques, de défenses..., et aussi on a des cartes( des monstres catégories pendules)qui peuvent se comporter soit comme un monstre( prendre une autre catégorie de monstre en plus ) ou une magie selon ou on la met dans le terrain (zone magie, ou zone monstre)

Au début j'ai pensé à faire un mixte de factory/decorteur pour me faciliter le travail , et respecter les principes SOLID, car connaissant le jeu, ils rajouteront de nouveaux types de monstre, à la base, on avait pas d'extra Deck et tous ces nouveaux types. On avait que effet, normal. Mais finalement étant donné qu'il y a plusieurs types, je me retrouve avec plusieurs classes dans mon architecture... Et en plus de ça, ca ne règle pas le problème qu,une carte peut changer de type. C'est pour cela que l'autre option que j'envisage c'est de mettre tous les attributs dans une seule classe et utiliser plusieurs enums, ce qui rend la classe très flexible. Cependant, je pense que ça ne respectera pas les principes SOLID. Car si j'ai besoin de rajouter un nouveau type de monstre, je serai obligé de modifier la classe monstre pour ajouter les nouveaux attributs et les fonctions.

J'espère que mon problème est plus clair

Et finalement pour le lien deck/carte, j'ai trouvé une solution trés simple qui consitre a rajouter un tag à une carte (EXTRA, MAIN) et comme ca je vérifie juste que le tag est de même type que le deck

[gervais.b]

Le truc c'est que je vais créer plein de classes pour parfois rien

C'est possible oui. Mais quel est le problème ?

Apparemment il y à pas mal de règles dans votre jeu et des "contraintes" sur les types. Alors pourquoi ne pas modéliser tout celà de la façon la plus claire qui soit; le code ?

Vous dites que le Deck principal accepte les sorts, les pièges et les monstres principaux:

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
 
class MainDeck {
 
  public void add(Spell spell) {
    // ...
  }
 
  public void add(Trap trap) {
    // ...
  }
 
  public void add(MainMonster monster) {
    // ...
  }
 
}

Vous dites aussi que pendule peut se transfomer en sort:

Code :

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

1
2
3
4
5
6
7
8
 
class Pendulum {
 
  public Spell toSpell() {
    // ...
  }
 
}

Ca fait peut-être "beaucoup" de classes. Mais, ça rends impossible les états invalides et ça rends explicite les règles métiers.

Au final, pas sur qu'une seule classe Deck avec des validations pour svaoir si le type accepte l'une ou l'autre carte soit plus efficace..

[seroze]

Je ne connaissais pas le Yugioh. Après avoir vu quelques vidéos explicatives je me rends compte que c'est un jeu de cartes un peu comme Magic The Gathering. Je m'étais intéressé à cela et j'étais arrivé à la conclusion qu'il est impossible de créer un code générique pour ces cartes de jeu. Chaque carte possède des particularités qui peuvent tout remettre en cause. Il faudra donc coder chaque carte séparément. Quelques monstres simples pourraient avoir un code commun, mais beaucoup sont trop spécifiques. Eventuellement, il serait possible de créer un langage de programmation interne au jeu pour rajouter du code spécifique à chaque carte. Je me rappelle par exemple d'avoir vu une carte "Araignée" qui était un monstre qui créait un nouveau monstre bébé araignée à chaque tour.
Pour revenir au Yugioh, le deck est une liste de cartes ordonnées, il faut donc faire comme Lola26 avec une seule méthode Add(Card card).
Pour le pendulum, et autres cartes multifonctions, il faudra surement utiliser la composition :
Classe Pendulum {
Card PositionMonstre;
Card PositionSort
}

Pour la partie SOLID, il y a déjà des choses qui sont à mon avis mal positionnées.
La classe Card ne devrai pas contenir la propriété owner, ni la propriété face. La propriété limite, je ne pense pas qu'elle doive en faire partie aussi.
La classe MonsterCard ne devrait peu être pas contenir la propriété Position mode, ce sera plutôt une responsabilité de la case du jeu de savoir comment est utilisé la carte (attaque ou défense)

Cela dit, Je pense que ce serait mieux d'être un peu plus modeste et limiter l'implémentation du jeu à des comportement plus simples sans chercher à coder absolument toutes les cartes. Par la suite il sera encore possible de créer une nouvelle version acceptant plus de comportements spécifiques.

[lola26]

merci pour ta réponse, en effet , c'est un peu comme magic. Finalement je vais suivre ton conseil et me concentrer finalement que sur le main deck même si ca sera un peu compliqué pour moi de me retenir, étant donné que j'aime tout faire en même temps ^^.

Voilà ce que j'ai jusqu'à aujourd'hui



et j'ai également créer une classe factory pour faciliter la création

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 CardFactory {
 
	public static Card getCard(ResultSet cardinfos, String type)
	{
		Card card = switch(type)
		{
			case "FUSION" -> new FusionMonster(cardinfos, Game.getInstance().getMainPlayer());
			case "RITUAL" -> new RitualMonster(cardinfos, Game.getInstance().getMainPlayer());
			case "PENDULUM" -> new PendulumMonster(cardinfos, Game.getInstance().getMainPlayer());
			case "SPELL" -> new SpellCard(cardinfos, Game.getInstance().getMainPlayer());
			case "TRAP" -> new TrapCard(cardinfos, Game.getInstance().getMainPlayer());
			case "SYNCHRO" -> new SynchroMonster(cardinfos, Game.getInstance().getMainPlayer());
			case "XYZ" -> new XyzMonster(cardinfos, Game.getInstance().getMainPlayer());
			case "LINK" -> new LinkMonster(cardinfos, Game.getInstance().getMainPlayer());
			default -> new ClassicMonster(cardinfos, Game.getInstance().getMainPlayer());
		};
 
		return card;
	}
}

et pourquoi la card ne devrait pas contenir le owner ? dans un duel j'ai besoin de savoir à qui appartient la carte car des fois il arrive que un joueur prenne le controle d'un monster et qu'il devient le sien. des fois il y a meme des parties en équipe. et la limite, c'est pour savoir le nombre de copies de la carte que le deck peut avoir (3, 2,1 ou 0 ) selon la liste de banne officielle.

[seroze]

Pourquoi la card ne devrait pas contenir le owner ?
C'est en te lisant que je me suis renseigné sur le principe SOLID.
Donc pour satisfaire le S de Solid (Single responsibility principle = Responsabilité unique), j'aurai tendance à penser que ce n'est pas à la carte de connaitre son owner, mais plutôt au plateau de jeu de savoir à qui appartiennent les cartes.
Et la limite ?
Toujours avec le S de SOLID, je penserai que la carte ne définit pas la limite, ce sont les règles qui doivent connaitre la limite des cartes.

Cela établit, il n'y a pas de mal à déroger aux règles SOLID sauf si elles sont imposées.

En ce qui concerne le schéma, je n'aurais pas crée de classes Extra et Main.
Pour savoir dans quel deck se range la carte, il suffit d'utiliser un tag.
Utiliser des classes pour cela t'obligeras à utiliser un test avec instanceOf pour pouvoir ranger les cartes dans le bon deck.
De plus, j'aurai préféré garder la voie de l'héritage pour des comportements vraiment utiles. Dans ton schéma, on ne peut pas savoir si TRAP ou SPELL seront pour le Main ou l'Extra. Si vraiment il faut une solution orientée objet à la place d'un simple tag, j'aurais alors plutôt utilisé des interfaces pour distinguer Extra de Main.

[lola26]

D'accord, je comprends mieux, c'est vrai que je n'ai pas encore pensé à la partie duel , je suis plutôt sur la création de deck. J'ai peur d'attaquer au parseur de cartes lol, et aux priorités des effets de cartes .

Et concernant les Spell et Trap card, ils sont forcement dans le main, il y a que les monstres qui ont cette particularité d'être dans l'extra deck. pour la class monstre, j'ai ajouté un attribute deckAllowed (String). tous ceux qui héritent de extra, auront deckAllowed = "EXTRA" et les autres deckAllowed = MAIN (je pense c'est la notion de tag dont tu parlais). J'ai fait de l'héritage pour juste ne pas avoir du code type "if instanceof() == xyz, deckAllowed = EXTRA", c'est fait automatiquement lors de l'instanciation.

Et si je reprends ton idée, je crée une interface pour chaque type de monstre , default value pour allowedDeck ?

C'est vraiment un projet personnel, donc il y a aucune règle à respecter. J'essaye de me forcer avec les principes SOLID à cause de l'école. Et ce me projet j'ai envie de le bien faire. Mais des fois, le mieux est l'ennemi du bien, si je dois enfreindre une règle de SOLID pour le bien du projet, pourquoi pas...D'un côté c'est vrai, que c'est un gros projet ambitieux pour une seule personne, je me suis mise dessus pour améliorer mes compétences car il y a beaucoup de sujets de devs intéressants à voir (base de données, parseur de texte, programmation évènementiel).

Pourquoi la card ne devrait pas contenir le owner ?
C'est en te lisant que je me suis renseigné sur le principe SOLID.
Donc pour satisfaire le S de Solid (Single responsibility principle = Responsabilité unique), j'aurai tendance à penser que ce n'est pas à la carte de connaitre son owner, mais plutôt au plateau de jeu de savoir à qui appartiennent les cartes.
Et la limite ?
Toujours avec le S de SOLID, je penserai que la carte ne définit pas la limite, ce sont les règles qui doivent connaitre la limite des cartes.

Cela établit, il n'y a pas de mal à déroger aux règles SOLID sauf si elles sont imposées.

En ce qui concerne le schéma, je n'aurais pas crée de classes Extra et Main.
Pour savoir dans quel deck se range la carte, il suffit d'utiliser un tag.
Utiliser des classes pour cela t'obligeras à utiliser un test avec instanceOf pour pouvoir ranger les cartes dans le bon deck.
De plus, j'aurai préféré garder la voie de l'héritage pour des comportements vraiment utiles. Dans ton schéma, on ne peut pas savoir si TRAP ou SPELL seront pour le Main ou l'Extra. Si vraiment il faut une solution orientée objet à la place d'un simple tag, j'aurais alors plutôt utilisé des interfaces pour distinguer Extra de Main.