Question sur un rappel d’intitulé d'un jeu de carte.

Version imprimable

14/03/2011, 23h18
marc027

Question sur un rappel d’intitulé d'un jeu de carte.

Bonsoir,

Excusez moi de vous dérangez mais je suis en première année d'informatique et nous avons un projet à réaliser : une réalisation en java d'un jeu de whisy (jeu de carte dérivé du whist).
En fait mon problème est le suivant, je dois générer un jeu de carte dans un tableau, jusque la tout va bien par contre on dois mélanger les cartes en effection un nombre prédéfini de permutation entre des cartes aléatoires mais j'ai peur de perdre l'information sur le contenu après la permutation. Alors si vous pouviez m'expliquer comment je pourrais faire pour stocker les informations (7 coeur, As pique , ....) ça me serait très utile.

Cordialement
15/03/2011, 13h10
hwoarang

Salut,

Tu peux utiliser tout simplement un nombre unique qui correspond à une carte. Par exemple 1 => As coeur, 2 => 2 de coeur ... 13 => Roi de coeur, 14 => As de carreau, 15 => 2 de carreau...

Sinon, tu peux aussi utiliser une classe avec valeur/famille.

Je ne connais pas le whist mais ce sont les regles qui definiront quelle methode est la plus adaptée (cad les combinaisons gagnantes, ce qu'il faut faire à chaque tour...).
15/03/2011, 14h01
tchize_

Créez un classe "Carte" qui regroupe ces information (famille et valeur). Utiliser une valeur entière pour représenter une Carte, c'est contraire aux principes d'encapsulation objets, donc ne le faite pas.

Pour le mélange, pour informations, si c'est permis dans l'exercice, il existe la méthode Arrays.shuffle() qui mélange correctement un tableau.
15/03/2011, 16h35
hwoarang

Citation:

Envoyé par tchize_

Utiliser une valeur entière pour représenter une Carte, c'est contraire aux principes d'encapsulation objets, donc ne le faite pas.

Ca m'avait bien arrangé pour trouver les combinaisons gagnantes d'un petit jeu en C que j'avais fait il y a quelques années :roll: Ca peut servir, meme si c'est pas le plus objet :D
15/03/2011, 16h39
thelvin

À la limite si on est prêt à faire ça, on peut faire un enum à la place.

Et si comme moi on a pas envie d'énumérer toutes les cartes, on peut faire une classe qui ressemble à un enum et qui sera super efficace dans un HashMap, un HashSet, et garde ses propriétés d'objets.
15/03/2011, 17h29
tchize_

la enum c'est un peu exagéré, j'ai pas trop voir des enum de 52 éléments de long. A ce rythme là, on aurait pu faire de la classe Byte un enum aussi :aie:. Maintenant je préfère l'enum de loin au int, il est propre, il est juste chiant à écrire ;)
15/03/2011, 17h51
thelvin

Le int aussi il faut les énumérer tous de toute façon, alors la différence, hein.

Mais bon, c'était l'exemple extrême. Rien n'empêche de faire un truc semblable à Byte justement : tous les instancier, mais pas se faire chier à les énumérer. On énumère seulement les 4 couleurs et 13 valeurs, et on instancie chaque combinaison.
15/03/2011, 23h07
marc027

Merci

Merci à vous trois, c'est vrai que mon idée première était d'attribuer un nombre à chaque carte mais pour gérer les cartes par la suite il est effectivement plus simple de crée une class.
:)

Bonne continuation
Cordialement

PS : Pour info, en première année on ne peut pas utiliser les bibliothèques java, déja quand j'utilise la méthode clone() je suis déja à la limite de la légalité :mouarf:
16/03/2011, 14h06
hwoarang

Citation:

Envoyé par marc027

Pour info, en première année on ne peut pas utiliser les bibliothèques java, déja quand j'utilise la méthode clone() je suis déja à la limite de la légalité :mouarf:

Euh clone ca ne vient pas d'une librairie, c'est un membre herité de Object (comme equals ou toString). Si tu n'as pas le droit d'utiliser ca...

Pourquoi ne pas faire le plus logique et le plus simple : utiliser une variable temporaire et permuter les cartes 2 à 2 ?
Code:

1 2 3 4 5 6 7 pour chaque permutation faire indice1 <- nombre aléatoire indice2 <- nomber aléatoire /* vérifier qu'il soit différent du premier */ temp <- liste[indice1] liste[indice1] = liste[indice2] liste[indice2] = temp fin pour

16/03/2011, 22h53
marc027

Oui c'est ce que je vais faire après pour mélanger mes cartes mais il faut quand même que je génère les cartes avant de les placer dans un tableau et faire une structure c'est effectivement ce qui semble le plus adéquat.
17/03/2011, 09h09
Loceka

Ah pardon j'avais cru que le problème était par rapport aux permutations.
Alors sinon oui, le plus simple est de faire une classe "carte" et d'utiliser une ArrayList (la plus "simple" des listes donc la plus optimale en complexité) pour stocker les éléments.
L'avantage d'utiliser une liste et non un simple tableau de Carte[] est qu'il est possible d'utiliser des méthodes de recherches toutes faites (contains() par exemple). Bien entendu il faudra au préalable avoir correctement défini la méthode equals() de ta classe Carte.
24/07/2011, 18h53
marc027

Je vous tient au courant

Bonjour,

La moindre des choses était quand même de vous tenir au courant.

J'ai réussi à faire la permutation selon le procéder très simple de permutation de deux cartes par deux cartes prises au hasard. Au début j'ai rencontré un problème de réservation mémoire qui me posait pas mal de soucis. La mémoire était écrasée à chaque tour ce qui empêchais de jouer une partie. Mais en modifiant l'algorithme j'ai pu m'en sortir.

Au final, il n'est resté que quelques problèmes du genre, le joueur peut jouer deux fois la même carte (il n'y avait pas de contrôle sur le fait qu'il possédait encore la carte ou non) mais j'ai eu 19 donc aucune raison de me plaindre :roll:

Merci à vous tous pour votre aide

Bonne continuation

Moi, ce que j'aurais fais déjà, c'est bien 32 enums correspondant à 32 cartes.

Mais disons que tu pars sur un objet Carte finalement, qui devrait ressembler à ça :

D'abord une enum pour les couleurs, y en a que 4...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public enum CouleurDeCarteEnum {
 
	COEUR("Coeur"), PIQUE("Pique"), CARREAU("Carreau"), TREFLE("Trefle");
 
	private final String label;
 
	CouleurDeCarteEnum(String label) {
		this.label = label;
	}
 
	public String getLabel() {
		return label;
	}
}

Ensuite une enum pour les valeurs :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public enum ValeurDeCarteEnum {
 
	SEPT("Sept", 7), HUIT("Huit", 8), NEUF("Neuf", 9), DIX("Dix", 10), VALET("Valet", 11), DAME("Dame", 12), ROI("Roi", 13), As("As", 14);
 
	private final int valeur;
	private final String label;
 
	ValeurDeCarteEnum(String label, int valeur) {
		this.label = label;
		this.valeur = valeur;
	}
 
	public String getLabel() {
		return label;
	}
 
	public int getValeur() {
		return valeur;
	}
 
}

Ensuite pour tes objets, on commence par une interface, c'est la moindre des choses...

Code:

1
2
3
4
5
6
7
 
public interface Carte {
 
	CouleurDeCarteEnum getCouleur();
 
	ValeurDeCarteEnum getValeur();
}

Et puis une implémentation de base :

Code:

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
 
public class DefaultCarte implements Carte {
 
	private CouleurDeCarteEnum couleur;
 
	private ValeurDeCarteEnum valeur;
 
	public DefaultCarte(CouleurDeCarteEnum couleur, ValeurDeCarteEnum valeur) {
		this.couleur = couleur;
		this.valeur = valeur;
	}
 
	public CouleurDeCarteEnum getCouleur() {
		return couleur;
	}
 
	public ValeurDeCarteEnum getValeur() {
		return valeur;
	}
 
	@Override
	public String toString() {
		return "Carte (" + valeur.getLabel() + " de " + couleur.getLabel() + ")";
	}
}

Ensuite, je pense que le plus simple est d'abord de générer un jeu trié :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class Jeu {
 
	public static void main(String[] args) {
		final List<Carte> jeuTrie = new ArrayList<Carte>(32);
		for (CouleurDeCarteEnum couleur : CouleurDeCarteEnum.values()) {
			for (ValeurDeCarteEnum valeur : ValeurDeCarteEnum.values()) {
				Carte carte = new DefaultCarte(couleur, valeur);
				jeuTrie.add(carte);
			}
		}
 
		for (Carte carte : jeuTrie) {
			System.out.println(carte);
		}
 
	}
 
}

Ensuite, pour constituer ton jeu mélangé, tu peux piocher au hasard dans le jeu trié...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
	public static void main(String[] args) {
		...
 
		System.out.println("*******************");
 
		final List<Carte> jeuMelange = new ArrayList<Carte>(32);
 
		final Random rand = new Random();
		for(int i = 32; 0 < i; i--) {
			final int position = rand.nextInt(i);
			final Carte carte = jeuTrie.remove(position);
			jeuMelange.add(carte);
		}
 
		for (Carte carte : jeuMelange) {
			System.out.println(carte);
		}
 
	}

Ca devrait te donner quelque chose comme ça :

Code:

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
 
Carte (Sept de Coeur)
Carte (Huit de Coeur)
Carte (Neuf de Coeur)
Carte (Dix de Coeur)
Carte (Valet de Coeur)
Carte (Dame de Coeur)
Carte (Roi de Coeur)
Carte (As de Coeur)
Carte (Sept de Pique)
Carte (Huit de Pique)
Carte (Neuf de Pique)
Carte (Dix de Pique)
Carte (Valet de Pique)
Carte (Dame de Pique)
Carte (Roi de Pique)
Carte (As de Pique)
Carte (Sept de Carreau)
Carte (Huit de Carreau)
Carte (Neuf de Carreau)
Carte (Dix de Carreau)
Carte (Valet de Carreau)
Carte (Dame de Carreau)
Carte (Roi de Carreau)
Carte (As de Carreau)
Carte (Sept de Trefle)
Carte (Huit de Trefle)
Carte (Neuf de Trefle)
Carte (Dix de Trefle)
Carte (Valet de Trefle)
Carte (Dame de Trefle)
Carte (Roi de Trefle)
Carte (As de Trefle)
*******************
Carte (Sept de Trefle)
Carte (Dame de Trefle)
Carte (Dame de Carreau)
Carte (Sept de Carreau)
Carte (Dix de Pique)
Carte (Neuf de Carreau)
Carte (Dix de Coeur)
Carte (Huit de Coeur)
Carte (Neuf de Trefle)
Carte (Huit de Pique)
Carte (Dix de Trefle)
Carte (As de Coeur)
Carte (Sept de Coeur)
Carte (Roi de Pique)
Carte (As de Pique)
Carte (Dame de Coeur)
Carte (Neuf de Coeur)
Carte (Sept de Pique)
Carte (Roi de Trefle)
Carte (Valet de Pique)
Carte (Dix de Carreau)
Carte (Neuf de Pique)
Carte (Huit de Carreau)
Carte (As de Trefle)
Carte (As de Carreau)
Carte (Roi de Carreau)
Carte (Valet de Trefle)
Carte (Valet de Coeur)
Carte (Huit de Trefle)
Carte (Dame de Pique)
Carte (Valet de Carreau)
Carte (Roi de Coeur)