Discussion :

[morin21]

Bonjour a tous,

Voila j'écris ici parce que j'ai un problème, il n'est pas vraiment de codage mais plutôt de raisonnement.
J'ai un TP a faire dont le principe est de faire un jeu de carte type Magic, des cartes de différent type par exemple : Dragon, Elfe, Orc ...etc.
Ces cartes peuvent soit attaquer soit soigner.
Il y a deux joueur, chaqu'un d'entre eux ont un deck de 32 cartes. Ils pioche 7 cartes au premier tour.
Et a chaque tour, ils peuvent posé une carte chaqu'un.

Le but du TP est de travaillé les héritages et les interfaces.
Voici donc mon idée de départ :


Seulement j'ai un problème, Les decks des joueurs, les mains, l'emplacement des cartes sur le plateau et les cimetières je les ai fait avec des ArrayList qui contient des objets de type Carte.

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
 
// je crée une ArrayList qui représente les cartes dans la main du joueur
ArrayList <Carte> mainJoueur = new ArrayList<Carte>();
 
// ma carte dragon_tenebreux, je souhaiterais qu'elle soit Guerrier
Guerrier dragon_tenebreux = new Dragon("Dragon des ténèbres", 5, 3);
 
// ma carte dragon_ciel, je souhaiterais qu'elle soit Healer
Healer dragon_ciel = new Dragon("Dragon du ciel", 2, 4);
 
// je veux ajouté le dragon_tenebreux dans la main du joueur
mainJoueur.add(dragon_tenebreux);
 
// idem pour dragon_ciel
mainJoueur.add(dragon_ciel);

Seulement j'ai une erreur, mes deux dragons ne sont pas de type Carte mais de type Guerrier ou Healer et donc je ne peux pas les ajouter a mes ArrayList.
J'ai lu des cours sur les héritages, les interfaces et le design pattern mais j'avoue ne pas avoir trouvé comment résoudre mon problème.

Je cherche une solution pour que mes cartes aient soit attaquer() soit soigner en fonction de l'interface choisi mais j'aimerais qu'elles soient également de type Carte.

Quelqu'un a une idée pour m'aider ??

Merci a tous.

[joel.drigo]

Salut,

Ton problème est que l'interface Healer ou Guerrier n'est pas une extension de classe Carte (elles ne pourraient pas l'être : une interface ne peut étendre une classe).

Pourquoi ne pas typer dans la bonne classe :

Code :

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

1
2
3
4
Dragon dragon_tenebreux = new Dragon("Dragon des ténèbres", 5, 3);
 
// ma carte dragon_ciel, je souhaiterais qu'elle soit Healer
Dragon dragon_ciel = new Dragon("Dragon du ciel", 2, 4);

Ainsi, si ta classe Dragon étend bien la classe Carte, tu pourras mettre ces deux instances dans une ArrayList<Carte>.

Ensuite, pour pouvoir appeler les méthodes soigner() et attaquer() sur les instances de l'ArrayList, il te faudra caster vers ces interfaces : par exemple, pour la carte 4

Code :

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

1
2
3
4
Carte carte4 = mainJoueur.get(4);
if( carte4 instanceof Healer ) {
    ((Healer)carte4).soigner();
}

Si tu veux pouvoir typer tes instances en Healer et Guerrier tout en pouvant les ajouter dans une List<Carte>, tu peux aussi faire une interface commune Carte, qu'une abstraction AbstractCarte implémentera, et que tes deux interfaces étendront. Ainsi, en paramétrant la liste avec cette interface commune, tu pourras ajouter tes instances typés Guerrier ou Healer.

Code :

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

public interface Carte {} // défnit n'importe quelle carte

Code :

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

public interface Guerrier extends Carte {} // définit une carte de type guerrier

Code :

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

public interface Healer extends Carte {} // défnit une carte de type soigneur

Code :

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

public abstract class AbstractCarte implements Carte {} // la base de n'importe quelle carte

Code :

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

public class Dragon extends AbstractCarte implements Guerrier, Healer {} // le dragon est à la fois guerrier et soigneur

Code :

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

public class Nain extends AbstractCarte implements Guerrier {} // le nain est seulement guerrier

[hwoarang]

Tu peux, comme le suggeres joel, tester le type de carte mais je ne le recommande pas. L'interet de l'heritage est justement d'eviter ce genre de chose (meme si c'est tres souvent utilisé) et vu que tu maitrises tout le code, tu peux t'en passer.
Tout d'abord, il est normal que toutes tes cartes dérivent d'une meme classe et c'est quelque chose qu'il faut conserver. Dans ton exemple, Healer et Guerrier devraient deriver de Carte.

Pour ce genre de problématique, tu as 2 solutions. C'est le fonctionnement que tu souhaites qui va definir ce que tu veux choisir. La grande question, c'est "est ce qu'une creature qui serait attaquant + soigneur peut faire les 2 dans un meme tour ou pas ?"
Si non (ou pas toujours), le plus simple, c'est de créer une fonction "void action()" dans Carte. Les cartes qui peuvent faire plusieurs actions etendraient cette fonction et feraient les 2 ou pas en fonction du type de carte. Tu obtiens le meilleur découplage puisque c'est la carte elle meme qui sait ce qu'elle doit faire.
Si tu attends un comportement indépendant attaquant et soigneur, tu peux créer une liste de Soigneurs et une liste d'attaquants sur le plateau. A chaque tour, tu parcoureras la liste de Soigneur et la liste d'attaquant et tu appeleras leurs fonctions respectives. Si tu choisis cette solution, la question que tu vas te poser, c'est "comment ajouter mes cartes aux bonnes listes ?". La réponse est simple, il suffit de creer une fonction dans carte "void poserSurPlateau(Plateau plateau)". Ensuite, si la carte est un Soigneur, elle s'ajoutera à la liste globale + Soigneur. Si elle est attaquant, elle se s'ajoutera à la liste globale + attaquant. Si elle est les 2, elle s'ajoutera aux 3 listes.

[mr.m.r]

Bonjour morin21,

je te préviens tout de suite, bien que je développe depuis pas mal de temps, je suis débutant en Java. Je te donne mes idées mais attends quelles soient validés ou non par des initiés.

Pour ton histoire de List, je ne vois pas le problème. Si ta classe Dragon hérite de Carte tu peux faire sans problème :

Code :

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

mainJoueur.add(new Dragon("Dragon des ténèbres", 5, 3));

C'est le principe même de l'héritage, "Dragon est une Carte.


Pour l'interface, je ne l'aurait pas implémentée comme tu l'as fais.

Premièrement, j'aurai crée une interface Action que j'aurai implémenté dans Carte

Code :

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

1
2
3
public interface Action {
     public abstract void action();
}

Code :

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

1
2
3
4
5
6
7
8
 
protected Action action = new DefaultAction();
 
...
 
public void actionCarte(){
    this.action.action();
}

Puis je créerai deux ou trois classes implémentant l'interface Action : DefaultAction, HealerAction, GuerrierAction...

Code :

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

1
2
3
4
5
public class GuerrierAction implements Action{
    public void action(){
        //ton code spécifique au guerrier
    }
}

Puis selon tes besoins, tu implémentes la classe Action qui t'intéresse.

En espérant avoir été assez clair et que cela puisse t'aider.

Cordialement, Mr.M.R

[morin21]

Bonsoir,

Tout d'abord merci a vous tous pour vos réponses.
Vos messages m'ont vraiment beaucoup aider, et j'ai pu résoudre mon problème !
Un grand merci a vous tous.
J'ai eu également quelques difficulté pour savoir a quel interface ma carte appartient, pour la stocker en fonction. Mais j'ai réussi.

Je passe le post en résolu, et une fois mon projet terminé je ne manquerais pas de partager le code.

Encore une fois merci a vous tous !