Discussion :

[Hemir]

Bonjour,
(voir http://www.developpez.net/forums/d15...rents-joueurs/ si vous voulez tout le contexte mais tout ne me semble pas utile là)

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 Carte(int noCarte, string typeCarte)
public Carte(int noCarte, string typeCarte, string couleur)
//1 constructeur pour les cartes couleur
//1 pour les autre
 
class Pioche
{        
    Carte bleu = new Carte(1, "couleur", "bleu");
    Carte jaune = new Carte(2, "couleur", "Jaune");
    Carte marron = new Carte(3, "couleur", "marron");
    Carte orange = new Carte(4, "couleur", "orange");
    Carte rouge = new Carte(5, "couleur", "rouge");
    Carte vert = new Carte(6, "couleur", "vert");
    Carte violet = new Carte(7, "couleur", "violet"); // 9 carte pour chaque couleur
    Carte plus2 = new Carte(8, "+2"); // 10 carte 
    Carte  joker = new Carte(9, "joker"); // 3 carte
    Carte derniereManche = new Carte(10, "fin"); //1
 
}

Donc ma pioche sera composé de carte , mais je ne sais pas quel collection sera le plus adapté sachant que quand un joueur pioche une carte elle disparaît de la pioche pour allée dans des Rangé donc une autre collection, d'une autres classe avec d'autre restriction .
dois-je creer les 77 cartes en dur ? je sais pas trop comment spécifier qu'il y a par exemple 9 cartes bleu

[jopopmk]

Salut,

pourrait-on avoir les règles du jeu ? Parce que ça me parait un poil obscure, du coup difficile pour moi de t'orienter.

[Hemir]

important: une rangé est composé de 0 à 3 carte.
quand la carte dernière manche est tirée c'est la dernière manche.

le but c'est d'avoir le plus de carte de la même couleurs pour cumuler les point (voir tableau des score)
on obtient des cartes qu'en ramassant les rangée
quand on décide de piocher une carte on doit la poser dans une rangée

des que toute les rangée sont pleine (3 carte) il n'y a plus le choix il faut ramassé une rangé

il y a autant de rangé que de joueur


pb annexe: les joker qui pourront valoir ce que l'utilisateur préfère, la carte dernièrement manche qui n'est pas placé aléatoirement dans la pioche
celui qui commence la 2nd manche est le joueur qui ramasse la dernière rangée.

c'est tout ce que j'avais noté d'important

[egautier18]

Salut,

Pour le type de collection je pense qu'une list of de carte est le plus simple pour facilement trouver/supprimer/ajouter.

il t'en faudra plusieurs je pense.
- une globale, pour la pioche.
- une par rangée, pour quand le joueur en pioche une et la pose.
- une par joueur, pour quand il ramasse une rangé.

en fonction des actions, tu les supprimes de la liste d'ou tu la prends (pioche ou rangée) pour les ajouter aux rangées ou aux joueurs.

Pour ton objet carte, je ne ferai pas plusieurs constructeur et mettrais des enums
enum typeCarte
avec "couleur", "joker", "+2"..
enum couleur (dans lequel tu pourras mettre "aucune", pour les cartes +2 par exemple)
avec bleu, rouge ....

En espérant que cela t'aide.
A+

[Hemir]

Pour ton objet carte, je ne ferai pas plusieurs constructeur et mettrais des enums
enum typeCarte
avec "couleur", "joker", "+2"..
enum couleur (dans lequel tu pourras mettre "aucune", pour les cartes +2 par exemple)
avec bleu, rouge ....

les enums ça m'apporte quels avantages ?

Pour le type de collection je pense qu'une list of de carte est le plus simple pour facilement trouver/supprimer/ajouter.

il t'en faudra plusieurs je pense.
- une globale, pour la pioche.
- une par rangée, pour quand le joueur en pioche une et la pose.
- une par joueur, pour quand il ramasse une rangé.

en fonction des actions, tu les supprimes de la liste d'ou tu la prends (pioche ou rangée) pour les ajouter aux rangées ou aux joueurs.

qu'entend-tu par une globale ?

donc je cree une list<Carte> dans ma classe joueur,et une dans ma classe rangée avec une propriete qui dit qu'il ne peut prendre que 3 cartes

[egautier18]

L'avantage des enums est que c'est évolutif, que tu ne risquera pas les fautes de frappes sur l'ajout d'une carte et l'intellisense les reconnais et te les proposeras (faciliter de code). Après c'était juste une proposition qui ne fait pas avancer le jeux.

Par "globale" je voulais juste signifier le fait qu'au point de départ elle contient toute les cartes.

A+

[jopopmk]

La méthode de egautier (se rapprochant le plus du monde "physique" ) semble effectivement la plus simple à appréhender (peut-être pas la plus optimisée, mais tu codes pas un pilote automatique d'avion non plus ). T'en es où de ton modèle ?

[Hemir]

La méthode de egautier (se rapprochant le plus du monde "physique" ) semble effectivement la plus simple à appréhender (peut-être pas la plus optimisée, mais tu codes pas un pilote automatique d'avion non plus ). T'en es où de ton modèle ?

mon modèle ?

si on parle d'un schéma papier de comment je vais implémenter mes formulaire,j'en ai un complet mais fouillis un peu, quelque partie su lequel je sais que j'aurais du mal a implémenter.
EDIT: en fait je sais tout ce qui s'affiche et comment mais pas forcement qu'est-ce que je fais en 1er niveau code

si on parle de ce que j'ai codé jusqu’à maintenant, ma classe Jeu est finie , et j'ai implémenter le fait que les joueur choisissent une couleurs.

[jopopmk]

Nop, je parle de tes classes, leurs membres, leurs méthodes, les liens qui les relient ...
En fait les interfaces ne devraient intervenir qu'après ce travail.

[Hemir]

Nop, je parle de tes classes, leurs membres, leurs méthodes, les liens qui les relient ...
En fait les interfaces ne devraient intervenir qu'après ce travail.

re,

j'ai pas fait de diagramme de classes, je pensait le faire a la fin puisque c'est demandé dans le compte rendu...
mais le soucis c'est que j'avancais un peu dans un brouillard.
la je m'approche de la fin donc j'ai une vision d'ensemble mais je pense pas que j'aurait pu en faire un complet des le depart...

[jopopmk]

Je parle pas de faire un diagramme, juste de coder tes classes. D'ailleurs tu peux faire ton modèle en plusieurs volées, revenant dessus à chaque fois que tu te rends compte que t'as pas pensé à un truc. Tu pourras faire ton diagramme a posteriori (s'il s'agit d'un logiciel pro ou d'un devoir, sinon ...).

[Hemir]

Je parle pas de faire un diagramme, juste de coder tes classes. D'ailleurs tu peux faire ton modèle en plusieurs volées, revenant dessus à chaque fois que tu te rends compte que t'as pas pensé à un truc. Tu pourras faire ton diagramme a posteriori (s'il s'agit d'un logiciel pro ou d'un devoir, sinon ...).

hmmm

eh bien j'ai codé ma classe Joueur , est j'ai fini ma classe Jeu en suivant le modèle singleton,

Code Jeu :

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
public sealed class Jeu  
{
    public List<Joueur> lstJoueur = new List<Joueur>();
    public Joueur tour=null;
 
    private static Jeu listJoueur = null;
    private static readonly object padlock = new object();
    public string Affiche()
    {
        int nbJoueur = Jeu.Instance.lstJoueur.Count();
        string ren = "";
        for (int i = 0; i < nbJoueur; i++)
        {
            ren = ren + " " + Jeu.Instance.lstJoueur[i].PseudoJoueur;
        }
        return ren;
    }
 
    public Joueur Change() //a reoganise pour enlever le try catch
    {
        int nbJoueur = this.lstJoueur.Count();
        if (tour == null)
        {
            tour =this.lstJoueur[0];
        }
        else if(tour==this.lstJoueur[0])
        {
            tour=this.lstJoueur[1];
 
        }
        else if (tour==this.lstJoueur[1])
        {
            tour=this.lstJoueur[2];
        }
        else if (tour == this.lstJoueur[2] && nbJoueur==3)
        {
            tour=this.lstJoueur[0];
        }
        else if(nbJoueur>3 && tour==this.lstJoueur[2])
        {           
            tour=this.lstJoueur[3];
        }
 
        else if (nbJoueur == 4 && tour==this.lstJoueur[3])
        {                                
                tour=this.lstJoueur[0];
        }
 
        else if (nbJoueur == 5 && tour == this.lstJoueur[3])
        {
            tour = this.lstJoueur[4];                
        }
        else if (tour == this.lstJoueur[4])
        {
            tour = this.lstJoueur[0];
        }
 
        return tour;
    } //la methode change renvoie le joueur dont c'est le tour, on suit l'ordre 1,2,3 (si 4 joueur),4, sinon 1 etc
 
    public void AfterChange(int i)
    {
        this.lstJoueur[i]=tour;
    }
 
    public bool Verifjoue()
    {
        bool joue = false;
        if (tour.PremCouleur != null)
        {
            joue = true;
        }            
        return joue;
    }
 
    public int ToutCouleur()
    {
        int joue = 0;
        int nbJoueur = this.lstJoueur.Count();
 
        for (int i = 0; i <=nbJoueur-1;i++ ) 
        {
            if (this.lstJoueur[i].PremCouleur!=null)
            {
                joue = joue+1 ; //s'il y a 4 joueur et que les 4 ont joué joue sera egale a 4 a la fin
            }
        }
        return joue;
    }
 
    Jeu()
    {            
    }
 
    public static Jeu Instance //modele singleton
    {
        get
        {
            lock (padlock)
            {
                if (listJoueur == null)
                {
                    listJoueur = new Jeu();
                }
                return listJoueur;
            }
        }
    }
}

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
public class Joueur
{
    private int nbJoueur;       
    private bool tour;
    private int noJoueur;       
    private string pseudoJoueur;
    private string premCouleur;
 
    public int NoJoueur
    {
        get { return noJoueur; }
        set { noJoueur = value; }
    }
    public int NbJoueur
    {
        get { return nbJoueur; }
        set { nbJoueur = value; }
    }
    public bool Tour
    {
        get { return tour; }
        set { tour = value; }
    }            
    public string PseudoJoueur
    {
        get { return pseudoJoueur; }
        set { pseudoJoueur = value; }
    }
    public string PremCouleur
    {
        get { return premCouleur; }
        set { premCouleur = value; }
    }
 
 
    public Joueur()
    { 
    }
    public Joueur(int nbJoueur, string pseudoJoueur,int noJoueur )
    {
        this.nbJoueur = nbJoueur;
        this.pseudoJoueur = pseudoJoueur;
        this.noJoueur = noJoueur;
    }        
}

Je suis en conception, de ma classe carte, rangé
et je dois modifié ma classe jeu pour qu'il ai une liste des cartes qu'il possede

[Hemir]

par contre je vois pas du tout comment crée mon constructeur,mais vraiment le flou total...
et je sais pas ou cherché non plus...

Code :

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

1
2
3
4
5
6
7
public enum typeCarte {couleur, joker, plus2, dernManche}
public enum couleur {bleu, jaune, maron, orange, rouge, vert, violet, aucun}
 
public Carte(typeCarte t, couleur c)
{
 
}

[jopopmk]

Bon, je vais pas revenir sur ton découpage (encore à l'étape conceptuelle vu que t'as que 2 classes), par contre quand je vois ta fonction Change() je grince des dents . Tu pourrais peut-être passer par une liste chaînée pour tes joueurs, ce serait plus propre (mais tu peux aussi faire plus propre en conservant une simple liste). Tes noms de méthodes/attributs ne sont pas non plus très à mon goût, mais ça ça ne regarde que toi

[ebastien]

Bonjour,

Je suis d'accord avec jopopmk. La méthode Change() pique un peu les yeux. Avec une liste chainée ce serait plus propre ou bien avec une liste simple, ça peut se coder comme ça (à tester):

Code :

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

1
2
3
4
public Joueur Change() 
{
   return lstJoueur.ElementAt((lstJoueur.IndexOf(tour) + 1) % (lstJoueur.Count));
}

Idem pour la méthode ToutCouleur() (si j'ai bien compris le but) :

Code :

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

1
2
3
4
public int ToutCouleur()
{
   return lstJoueur.Count(Joueur => Joueur.PremCouleur != null);           
}

[Hemir]

par contre quand je vois ta fonction Change() je grince des dents . Tu pourrais peut-être passer par une liste chaînée pour tes joueurs, ce serait plus propre (mais tu peux aussi faire plus propre en conservant une simple liste).

comment ??
sinon jvais voir pour la liste chainée #IhaveTime

Tes noms de méthodes/attributs ne sont pas non plus très à mon goût, mais ça ça ne regarde que toi

oui mais il y a quelqu'un qui va passer sur le code, Donc c'est mieux si c'est plus explicite donc je changerai les nom et commenterais.

[jopopmk]

comment ??

ebastien t'a montré une méthode très élégante

Pour ton constructeur je vois pas bien le souci. Tu déclares deux attributs dans ta classe Carte de type typeCarte et couleur, puis tu leur assignes les valeurs passées en paramètre de ton constructeur.

[Hemir]

Pour ton constructeur je vois pas bien le souci. Tu déclares deux attributs dans ta classe Carte de type typeCarte et couleur, puis tu leur assignes les valeurs passées en paramètre de ton constructeur.

je sais pas ce qui m'avait perturbé

ebastien t'a montré une méthode très élégante

j'avais écrit le message , mais je l'ai posté au moins 1 heure après , sans rafraîchir donc j'avais pas vu son message

[Hemir]

Idem pour la méthode ToutCouleur() (si j'ai bien compris le but) :

Code :

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

1
2
3
4
public int ToutCouleur()
{
   return lstJoueur.Count(Joueur => Joueur.PremCouleur != null);           
}

oui c’était ça le but, (compter le nombre de joueur qui ont la propriété premCouleur différent de null)

Bonjour,
Je suis d'accord avec jopopmk. La méthode Change() pique un peu les yeux. Avec une liste chainée ce serait plus propre ou bien avec une liste simple, ça peut se coder comme ça (à tester):

Code :

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

1
2
3
4
public Joueur Change() 
{
   return lstJoueur.ElementAt((lstJoueur.IndexOf(tour) + 1) % (lstJoueur.Count));
}

je suis pas sur d'avoir tout compris..
ElementAt renvoie l’élément qui est à l'index ,
on cherche l'index de tour, mais tour n'est pas dans ma liste , ou bien il va chercher l'objet qui lui correspond ?
l'operation avec le modulo % ...

sans faire comme ça j'avais une erreur car parfois tour etait == null...
donc ça fait ce que je veux...

Code :

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

1
2
tour = lstJoueur.ElementAt((lstJoueur.IndexOf(tour) + 1) % (lstJoueur.Count));
            return tour;

mes bouton événement bouton son comme ça j'aurais du vous le mettre au debut

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
private void btBleu_Click(object sender, EventArgs e)
{
    if (Jeu.Instance.Verifjoue() == false) //false il n'a pas choisis de couleur de depart, s'il a deja choisi il ne peut plus jouer
    {
        lab[tour.NoJoueur - 1].Text = tour.PseudoJoueur + " bleu"; // affichage dans des label
        tour.PremCouleur = "bleu"; //on met la propriete premCouleur sur tour
        Jeu.Instance.AfterChange(tour.NoJoueur - 1); // on met a jour dans la liste (voir afterChange)
        tour = Jeu.Instance.Change(); //on change de joueur               
        btBleu.Enabled = false; // on desactive le bouton
        if (Jeu.Instance.ToutCouleur() == nbJoueur) // si tout le monde a joué
        {
            lbConsigneCouleur.Text = ("cliquez sur la fleche verte"); // label de consigne 
        }
        else
        {
            lbConsigneCouleur.Text = ("c'est au tour du J" + tour.NoJoueur + "  " + tour.PseudoJoueur + " de jouer");
        }
    }
}

[jopopmk]

Alors déjà "tour" c'est pas folichon comme nom, perso ça me parle pas pour un sou.
Voilà un exemple un peu plus complet et qui devrait t'aider à mieux comprendre :

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
// ma liste de joueurs
public List<Player> Players = new List<Player>();
// le joueur qui doit jouer
public Player CurrentPlayer = null;
// la fonction d'initialisation (en dur, pour toi ça se fera via ton interface)
public void InitPlayers() {
	this.Players.Add(new Player("jean"));
	this.Players.Add(new Player("charles"));
	this.Players.Add(new Player("kevin"));
	this.Players.Add(new Player("andré"));
	this.Players.Add(new Player("pierre"));
	// le joueur courant est initialisé sur le premier
	this.CurrentPlayer = this.Players[0];
}
// la fonction qui passe au joueur suivant
public void ChangePlayer() {
	// Players.IndexOf(CurrentPlayer) te renvoie un chiffre entre 0 et 4 (dans mon exemple à 5 joueurs)
	// on fait donc +1 pour avoir le suivant
	// l'utilisation du % (modulo) va nous permettre de repasser vers 0 si jamais on obtient Players.Count (qui est égal à 5)
	CurrentPlayer = Players[(Players.IndexOf(CurrentPlayer) + 1) % Players.Count];
}