Discussion :

[ju.dutot]

Bonjour,

Je suis actuellement en Master Physique et j'ai à faire, dans le cadre de mes études, un projet C++ avec un collègue. Nous avons choisi de recréer le jeux du 1000 bornes et devons utiliser au minimum une classe en .cpp .

Nous sommes actuellement bloqués dès le début, à savoir que nous ne savons pas trop comment organiser notre projet. Nous pensions créer un main.cpp, une classe carte.cpp et un carte.h.

Dans le carte.cpp se trouverait un constructeur avec un tableau de 46 cases correspondant uniquement aux cartes de vitesses (pour le moment nous ne nous occupons que de celles-ci, c'est déjà assez compliqué comme ça !lol!). A partir de ce tableau on utiliserait une fonction permettant de tirer les 7 cartes que les 2 joueurs auront en main au début.

Puis, dans les services, un permettrait de tirer une carte qui s'ajouterait à la main du joueur dont c'est le tour. Un autre permettrait au joueur de choisir une carte (parmi les 8) à jouer. Puis enfin un autre permettant de choisir ce qu'il veut faire de cette carte, à savoir la jouer (et donc ajouter au total de kilomètre du joueur) ou la jeter.

Qu'en pensez vous, que pourriez vous nous donner comme conseils?

[Trademark]

Bonjour,

Vous faites bien de vous concentrez uniquement sur les cartes de vitesse dans un premier temps. Néanmoins si vous n'avez jamais fait de programmation auparavant, il faut savoir, que même quelque chose qui semble simple comme votre projet, est en fait assez compliqué et mêle conception / programmation.

Ne vous découragez pas pour la cause, nous essayerons de vous guider au mieux

Une classe Carte devrait être constitué uniquement des caractéristiques de la carte.

Vous pourriez prévoir une classe "Pot" qui contient n cartes.

Mais aussi une classe Joueur qui contient n cartes, le nom du joueur et toutes les caractéristiques d'un joueur.

Cette "description" des classes peut être représenté graphiquement via UML. Mais c'est encore quelques choses d'autres à apprendre si vous ne connaissez pas.

Dans le constructeur du pot, vous pourriez initialiser les différents types de carte, et pour chaque carte vous donnez la quantité de cette carte.

Quand une carte va vers un joueur vous décrémentez cette quantité par exemple.

N'hésitez pas. Je ne connais pas très bien les règles, mais je pense que ça serait un bon début (sans trop compliquer les choses) que de faire comme ça.

[jblecanard]

Bonjour

Le mille bornes est une assez bonne idée, mais ce n'est en effet pas simple. Très bonne idée de ne garder que les cartes de vitesse. Le problème du mille bornes n'est en effet pas simple. Pour deux raisons :
- Les données à représenter ne sont pas triviales (un jeu de cartes à répartir entre des joueurs)
- L'évolution de la partie est régie par un assez grand nombre de règles, qui paraissent évidentes mais qu'il faut toutes retranscrire (les joueurs jouent tour par tour, peuvent tirer une carte, attaquer un autre joueur, etc). Les règles qui régissent le droit d'utiliser ou non une carte ne sont carrément pas simples à représenter. En n'utilisant que les cartes de vitesse, vous vous débarrassez déjà de cette complexité là, c'est pas mal pour des débutants.

Trademark a raison de vouloir découper en plus de classes. Pour être plus précis encore, il faut choisir les responsabilités et attribuer chacune d'entre elle à une classe. Par exemple :

- Une classe carte comme suggéré, avec éventuellement un héritage
- Une classe "Deck" pour contenir les cartes. Mais là je verrais un simple std::deque connaissant l'utilisation qui en est faite. C'est toutefois utile de l'encapsuler dans une classe, pour le remplissage initial notamment.
- Une classe joueur qui représente le joueur (les cartes en mains, le numéro dans le tour)
- Une classe Partie qui permettra de faire avancer la partie en conservant la cohérence entre tous ces objets.

Dans un premier temps, vous devez écrire l'ensemble des en-têtes de vos classes pour étudier leur cohérence et leurs interactions. Vous pouvez nous les montrer ici avant de tout implémenter pour qu'on vous donne notre avis.

[ju.dutot]

On a essayé de suivre vos conseils un peu comme on le pouvait.

On a créé 2 classes :
- une classe carte dans laquelle on utilise une fonction aléatoire pour tirer 7 cartes dans le paquet
- une classe joueur pour "donner" 7 cartes au joueur

Le problème est pour notre fonction aléatoire. Elle nous donne bien 7 cartes aléatoires que l'on arrive à afficher... Mais ce sont tout le temps les 7 mêmes cartes qui sortent.

Voilà la classe 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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
Carte::Carte() 
{
 
    int tab[46]={25,25,25,25,25,25,25,25,25,25,50,50,50,50,50,50,50,50,50,50,75,75,75,75,75,75,75,75,75,75,100,100,100,100,100,100,100,100,100,100,100,100,200,200,200,200};
 
    int a=0, b=46, p=0;
 
    int i,j;    
 
    //srand (time(NULL));
 
    //p=rand()%b;
 
    /*if(tab[p]!=0)
        {    
            ct_=tab[p];
            tab[p]=0;
        }
        
};*/
    std::random_shuffle(tab, tab + 46);
    if(tab[0]!=0)
        {    
            ct_=tab[0];
            tab[0]=0;
            std::random_shuffle(tab, tab + 46);
        }
    else
        {    ct_=tab[1];
            tab[1]=0;
            std::random_shuffle(tab, tab + 46);
        }
};

Et notre main, qui nous affiche donc toujours la même suite :

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
int main()
{    Carte a;    
    a.print();
    Carte b;
    b.print();
    Carte c;
    c.print();
    Carte d;
    d.print();
    Carte e;
    e.print();
    Carte f;
    f.print();
    Carte g;
    g.print();
 
return 0;
}

On a essayé de corriger le problème mais on a juste réussi à en créer un autre ; l'ordi nous donnait une carte aléatoire 7 fois.

[Daïmanu]

Essaie de bien mettre en place la structure de ton programme (avec les bonnes classes citées plus haut), car cela risque de compliquer l'écriture du code plus tard.

Par exemple, ce n'est pas à la classe Carte de créer 46 cartes, mais plutôt à la classe « Partie » de créer, mélanger et distribuer les « Cartes » aux « Joueurs ».

Ensuite, tu utilises la STL avec std::random_shuffle et c'est très bien , mais tant qu'à faire, utilise aussi les conteneurs std::deque<Carte> deck(46), ça permet de mélanger les cartes avec une syntaxe plus élégante std::random_shuffle(d.begin(), d.end()) sans se soucier de la taille du deck. Une fois cela réglé, l'écriture et le débogage du code sera plus aisée.

Ce problème (classique) de l'aléatoire sera je pense plus facile à résoudre si la conception est bien faite.

[Ekleog]

Pour faire simple, deux problèmes principaux avec ce code (en plus de ce qu'a exposé mon voisin du dessus) :

• Le std::random_shuffle ne nécessite pas d'être appellé plusieurs fois : il va mélanger tout le tableau au hasard. A moins que, jouant au mille bornes, tu ne re-mélanges le deck après chaque pioche ?
• Tu ne donnes pas de valeur d'initialisation. De mémoire, random_shuffle utilise rand() pour générer son aléatoire. Du coup, il faudrait mettre un std::srand(std::time(NULL));/* Possibilité de remplacer time(NULL) par une constante pour la recherche de bugs : c'est plus facile si on arrive à refaire le même ordre de deck, pour trouver les bugs ! */);Sinon, il utilise toujours la graine initiale par défaut, ce qui va forcément toujours amener à la même séquence de nombres aléatoires, et donc au même effet de random_shuffle.