Discussion :

[piotrr]

Je développe actuellement un modeste jeu de poker version texas hold'em (entièrement en java).
Bien entendu, j'ai une classe Partie dans laquelle je fais se succèder des tours de jeu (j'ai aussi une classe Tour).
J'entends par tour de jeu chaque fois qu'on redistribue les cartes et qu'on entame alors une nouvelle série de mises.
Seulement je bute carrément sur le côté algorithmique de cette phase de jeu et aussi sur le côté modelisation objet.

Je suis ouvert à toute suggestion.

Note: je tiens à m'en tenir strictement aux règles du texas hold'em

merci

[divxdede]

Je développe actuellement un modeste jeu de poker version texas hold'em (entièrement en java).
Bien entendu, j'ai une classe Partie dans laquelle je fais se succèder des tours de jeu (j'ai aussi une classe Tour).
J'entends par tour de jeu chaque fois qu'on redistribue les cartes et qu'on entame alors une nouvelle série de mises.
Seulement je bute carrément sur le côté algorithmique de cette phase de jeu et aussi sur le côté modelisation objet.

Je suis ouvert à toute suggestion.

Note: je tiens à m'en tenir strictement aux règles du texas hold'em

merci

Pour modeliser une partie, imprégne toi des régles et décrit tout les acteurs, actions pouvant survenir.

[ToTo13]

Bonjour,

il faut que tu décomposes ton environnement, ce que tu veux faire :
- Dans une partie, il y a des joueurs => class Joueur.
- Ces joueurs sont soit dans le tour ou ont abandonnés le tour => un booleen.
- Un joueur est encore dans la partie ou a été éliminé,...
- Il faut un jeu de carte => ...
- Chaque joueur reçoit deux cartes => Affecter deux cartes (différentes) aléatoirement à chaque joueur.
- Les joueurs jouent à tour de rôle, il faut donc que ta class partie connaisse les joueurs et l'ordre ... => un petit vecteur avec les joueurs encores dans le tour.

Tout ceci sont quelques une des règles simple ou font partie du déroulement d'une partie de poker... Il suffit de traduire ce qu'il se passe au für et à mesure.

[Akhan]

Salut !

J'ai développé moi aussi un poker pour jouer en réseau privé.
Pour la gestion d'un tour de jeu, une classe Partie lance une à une les différentes phases de jeu : blinds, deal, mise, flop, mise, turn, mise, river, mise, abbatage, gains, préparation nouvelle main.

Cette classe possède comme attributs :
- Les joueurs autour de la table : Une classe Joueur gère leur argent et leur état
- l'argent sur la table
- l'interface graphique
- ...

pour pouvoir facilement réaliser l'ensemble de l'application, je te conseillerais de créer des objets (plus ou moins) indépendants (joueurs, jeu de carte, interface réseau, interface graphique, partie ) , et de les faire interagir au sein d'une "superclasse" qui orchestrerait tout ça. Enfin je sais pas si c'est clair lol...

[piotrr]

Bonjour,

il faut que tu décomposes ton environnement, ce que tu veux faire :

- Ces joueurs sont soit dans le tour ou ont abandonnés le tour => un booleen.

Tout ceci sont quelques une des règles simple ou font partie du déroulement d'une partie de poker... Il suffit de traduire ce qu'il se passe au für et à mesure.

Au sein d'un round, j'utilise un statut pour chaque joueur. Ce statut peut avoir 3 valeurs: couché, suit, relance. Selon l'état du joueur. Est-ce une bonne solution? Me permet-elle de couvrir tous les cas?
Sinon pour les autres règles, j'ai déjà tout définit comme ça.

merci

[piotrr]

les différentes phases de jeu : blinds, deal, mise, flop, mise, turn, mise, river, mise, abbatage, gains, préparation nouvelle main.

Ok mais la methode mise me porte particulièrement problème. En effet il faut gèrer à la fois les relances des joueurs et également la blind de départ.


Autre chose, en quoi la phase flop diffère-t-elle de la phase turn ou encore river?

merci

[divxdede]

Ok mais la methode mise me porte particulièrement problème. En effet il faut gèrer à la fois les relances des joueurs et également la blind de départ.


Autre chose, en quoi la phase flop diffère-t-elle de la phase turn ou encore river?

merci

La mise est plus compliquée que cà en réalité:

1. Payer les antes par TOUT les joueurs (si il y en a)
2. Payer les blinds (small/big)
3. distribuer les cartes
4. Faire un tour de mise (ou terminer le 1er tour aprés les blinds)

Ce qu'il faut savoir:
Le joueur de grosse blinde à un droit de relance avant de dévoiler le flop (même si personne n'a relancé au dessus de sa grosse blinde), il peut donc ainsi "checker" ou "relancer"

Ensuite il faut gérer aussi les contraintes sur les mises au sein d'un tour
1. Mise de départ minimale dépends du mode de jeu
- limit holdem = petite mise (pre-flop,flop), grosse mide (tournant,riviere)
- pot limit = grosse blinde
- no limit = grosse blinde

2. Gérer la relance "minimum" : une relance doit être supèrieure ou égale à la derniere relance du même tour
- Exemple: quelqu'un mise 20€, je met 65€ (relance de 45€) alors qie quelqu'un veut relancer sur ma mise il devra au minimum mettre 110€ ( 65€ + 45€)

3. Gérer la relance "maximum": En pot limit on ne peut pas miser plus que ce qu'est déja misé sur le tour courant

Dans tes états de joueur (couché, suit , relance), il te faut au minimum un état "sit down" indiquant que le joueur est temporairement sortit de la table.
Il faut alors un état suplementaire mémorisant toutes les "blindes" non payées qu'il aurait du payer. Quand il reprendra la partie sur cette table, il devra payer toutes ces blindes qu'il n'avait pas payé.

De plus en "cash game" ou les tables sont libres, un nouveau joueur doit payer une taxe équivalente à la grosse blinde pour avoir le droit de s'assoire.
De plus un noueau joueur ne peut devenir d'entrée petite blinde ou grosse blinde, et devra attendre la manche suivante.

Lit les régles sur wikipedia (francais et anglais) tu trouveras tout ton bonheur.

[piotrr]

Tout d'abord je ne m'interesse qu'au No Limit Hold'em.
La partie est fermée, un joueur ne peut donc pas sortir entre temps.
je pense avoir résolu le problème de la mise de départ grâce à une méthode "mettreBlinds" qui force les deux premiers joueurs à poser leur blind.
Ensuite je fais une fonction spécifique au premier tour de jeu qui part du joueur après la grosse Blind pour terminer sur lui.
Enfin je fais des tours de mise jusqu'à ce que tout le monde ait checké ou qu'il ne reste plus qu'un joueur.
Est-ce une bonne idée?

merci

[Duc Lebowski]

Comment as-tu géré la méthode "mettreBlinds" ?

Est-ce que tu la gère au niveau de la Partie ou bien au niveau de Joueur tel que :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// dans partie :
for (Joueur j : ...)
    j.mettreBlinds();
 
// dans Joueur :
void mettreBlinds() {
    if (_statut == BIG_BLIND)
        verserDansLePot(partie.getBlindValue());
    else if (_statut == SMALL_BLIND)
        verserDansLePot(partie.getBlindValue()/2);
}

Je m'intéresse au problème car j'ai il y a quelque temps tenté de développer la même chose et me suis un peu enlisé à force d'empiler les règles...

[Akhan]

Dans mon jeu, un tour de mise est terminé si toutes les joueurs sont soit couchés, soit all-in, soit alignés sur la dernière mise.
En gros lors du tour de mise, il y a une valeur de mise qui tourne (elle commence à zéro), et chaque joueur peut soit relancer, soit se coucher. Et si tout le monde a égalé cette mise à un moment donné, le tour de mise est terminé.

Le premier tour (après le deal) fait exception, car si tous les joueurs se sont alignés sur la grosse blinde, le joueur ayant posé la grosse blinde se voit donner la possibilité de relancer, meme si il est déjà aligné sur les autres.

Une autre exception existe si un joueur se retrouve all-in sans pouvoir égaler la mise (s'il n'a pas assez de jetons), dans ce cas je considere qu'il est aligné quand meme, mais je stocke quelque part qu'il est en défaut, pour pouvoir le gérer en cas de victoire.

[Akhan]

Pour répondre à ta question piottr, les phases de mise après flop, turn, river, sont rigoureusement identiques. Le premier à parler est le joueur (non couché) à la gauche immédiate du joueur au bouton (dealer). Le tour de mise se termine lorsque tout le monde s'est aligné sur la meme mise.

Le tour de mise après le deal est différent car le premier à parler est le joueur à la gauche immédiate du joueur ayany posé la grosse blinde. Et la différence supplémentaire est que le joueur ayant posé la grosse blinde se voit donner la main, meme si tout le monde s'est aligné sur lui.

[piotrr]

Comment as-tu géré la méthode "mettreBlinds" ?

Est-ce que tu la gère au niveau de la Partie ou bien au niveau de Joueur tel que :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
// dans partie :
for (Joueur j : ...)
    j.mettreBlinds();
 
// dans Joueur :
void mettreBlinds() {
    if (_statut == BIG_BLIND)
        verserDansLePot(partie.getBlindValue());
    else if (_statut == SMALL_BLIND)
        verserDansLePot(partie.getBlindValue()/2);
}

Je m'intéresse au problème car j'ai il y a quelque temps tenté de développer la même chose et me suis un peu enlisé à force d'empiler les règles...

J'utilise ma méthode miser (au sens de checker pas de relancer) pour mettre les blinds en début de partie.

[code]

//dans Partie
j1.miser(LITTLE_BLIND)
j2.miser(BIG_BLIND)

[code]

voilà

[piotrr]

Dans mon jeu, un tour de mise est terminé si toutes les joueurs sont soit couchés, soit all-in, soit alignés sur la dernière mise.

C'est la même chose que de regarder que personne n'a relancé non?

En gros lors du tour de mise, il y a une valeur de mise qui tourne (elle commence à zéro), et chaque joueur peut soit relancer, soit se coucher. Et si tout le monde a égalé cette mise à un moment donné, le tour de mise est terminé.

Mais où est ce que tu stockes ce que un joueur a placé en un tour de mise?
Personnellement j'ai attribut "minToCheck" dans Partir qui représente le minimum que doit mettre un joueur pour checker.
Je pense que cette méthode pose problème car un joueur qui aura déjà suivi se vera demander une trop grosse mise au prochain tour...
J'aimerai bien plus de précisions sur ce point

Le premier tour (après le deal) fait exception, car si tous les joueurs se sont alignés sur la grosse blinde, le joueur ayant posé la grosse blinde se voit donner la possibilité de relancer, meme si il est déjà aligné sur les autres.

Je gère ce problème en mettant le status des petites et grosses blinds à "relancer" dès le départ

[piotrr]

Comment partager l'argent à la fin?
Sachant que j'ai un attribut dans Joueur qui permet de savoir combien un joueur a misé dans un tour.

merci

[divxdede]

Comment partager l'argent à la fin?
Sachant que j'ai un attribut dans Joueur qui permet de savoir combien un joueur a misé dans un tour.

merci

Ca ne suffit pas.
Ca ne suffit pas.
Tu dois mettre à jour à la fin de chaque tour ce que peut gagner chaque joueur en fonction des mises et conserver au sein de la partie le pot total.
A la fin tu pourras en fonction du résultat effectuer le partage comme cette exemple:

Avant la partie
====================
Joueur A ( 200 € )
Joueur B ( 1 000 € )
Joueur C ( 3 000 € )
Joueur D ( 3 000 € )
Joueur E ( 4 000 € )
====================

-------------------
Tour 1 A mise 50€
B suit 50€
C suit 50€
D suit 50€
E suit 50€

A la fin du tour 1 nous avons:
- Pot total = 5x 50€ = 250€
- A peut remporter 250€
- B peut remporter 250€
- C peut remporter 250€
- D peut remporter 250€
- E peut remporter 250€

-------------------
Tour 2 A fait All-In (soit une mise de 150€)
B relance 450€
C suit à 450€
D se couche
E suit à 450€


A la fin du tour 2 nous avons:
- Pot total = 250€ + 1 500€ = 1 750€
- A peut remporter 250€ + (150€ x 4) = 800€
- B peut remporter 250€ + 150€ + (450€ x 3) = 1 750€
- C peut remporter 250€ + 150€ + (450€ x 3) = 1 750€
- D ne peut plus rien remporter
- E peut remporter 250€ + 150€ + (450€ x 3) = 1 750€

-------------------
Tour 3 A est en All-In
B fait All-In (soit une mise de 500€)
C suit à 600€
D est couché
E suit à 600€

A la fin du tour 3 nous avons:
- Pot total = 1 750€ + 1700€ = 3 450€
- A peut remporter 800€
- B peut remporter 1 750€ + 500€ x 3 = 3 250€
- C peut remporter 1 750€ + 500€ + (600€ x 2 ) = 3 450€
- D ne peut plus rien remporter
- E peut remporter 1 750€ + 500€ + (600€ x 2 ) = 3 450€

-------------------
Tour 4 A est en All-In
B est en All-In
C fait parole
D est couché
E fait parole

A la fin du tour 4 nous avons:
- Pot total = 3 450€
- A peut remporter 800€
- B peut remporter 3 250€
- C peut remporter 3 450€
- D ne peut plus rien remporter
- E peut remporter 3 450€

==========================

Résultat de la partie:
- A gagne avec un full
- B est 2ème avec un brelan
- C est 3ème avec une double paire
- E est 4ème avec As haute

Partage de l'argent (pot de 3 450€)
- A gagne 800€
- B gagne 3 250€ - 800€ = 2 450€
- C gagne 3 450€ - 800€ - 2450€ = 200€
- D ne gagne rien
- E ne gagne rien

[piotrr]

Tu dois mettre à jour à la fin de chaque tour ce que peut gagner chaque joueur en fonction des mises et conserver au sein de la partie le pot total.
A la fin tu pourras en fonction du résultat effectuer le partage comme cette exemple:

Merci pour le conseil de conserver combien chacun peut gagner.
Mais je ne vois vraiement pas comment coder la méthode qui partagera les gains. Déjà qui derva l'appeller? Que prendra-t-elle en paramètre?

merci

[Keihilin]

Merci pour le conseil de conserver combien chacun peut gagner.

Je passerai plutôt par une classe "Pot" qui garderai une référence sur les joueurs qui y participe...

[divxdede]

Je passerai plutôt par une classe "Pot" qui garderai une référence sur les joueurs qui y participe...

Justement un pot n'est ni plus ni moins qu'une somme.
Que l'attribut stocké au sein de chaque joueur soit un nombre ou un objet "Pot" ne change rien au fait qu'il est nécessaire de savoir quel est le pot "gagnable" pour un joueur.

[Keihilin]

Certes, mais en pratique, avoir un classe "Pot" te facilitera beaucoup la phase de comparaison des mains puisqu'il te suffira de parcourir les références conservées par "Pot" pour savoir qui concourt contre qui...

Et à mon avis, un objet "Pot" ne devrait pas être un attribut de "Joueur"...

[divxdede]

Certes, mais en pratique, avoir un classe "Pot" te facilitera beaucoup la phase de comparaison des mains puisqu'il te suffira de parcourir les références conservées par "Pot" pour savoir qui concourt contre qui...

Et à mon avis, un objet "Pot" ne devrait pas être un attribut de "Joueur"...

Effectivement il ne s'agit là que de la modèlistation qui pourrait se traduire ainsi

"Partie" liée à plusieurs "Pot" générés lors des differents tours
Chaque "Pot" possédant une reference sur les joueurs autorisés à les remporter (ayant couvert se pot)

En fin de partie, on classe les joueurs en lisse en fonction de leurs mains.
Le 1er remporte tout les pots qu'il a couvert.
Si il reste des pots non distribués, on donne au 2ème les pots qui lui sont autorisés, ainsi de suite jusqu'a avoir distribué tout les pots.

Tout ca pour dire que je suis d'accord avec Keihilin, il est preferable que le pot ne soit pas un attribut du joueur, cette approche reflête mieux la réalité.