Vous aimez flamber, mais vous n'aimez pas perdre votre argent. Vous aimez les jeux de hasard, mais vous n'aimez pas les casinos. Alors Rétropoker est fait pour vous. 

Rétropoker se joue avec un jeu de 52 cartes et dans sa grande générosité vous offre 1000 jetons. Après avoir choisi votre mise, le programme vous distribue 5 cartes. Vous pouvez changer jusqu'à 4 de cartes. Si vous obtenez l'une des combinaisons gagnantes, vous aurez aussi la possibilité de tenter le quitte ou double pour augmenter votre gain.

Et vous pourrez recommencer autant de fois que vous le souhaitez, tant qu'il vous restera des jetons pour jouer. Alors, prêt à tenter votre chance ?

Le programme doit :

1. demander le montant de votre mise ;

2. retirer ce montant des jetons restant ;

3. tirer et afficher 5 cartes dans un jeu de 52 ;

4. demander quelles cartes doivent être échangées ;

5. tirer et afficher les cartes de remplacement ;

6. analyser la main du joueur et multiplier la mise par :

   1.   100 si le joueur a une quinte flush (couleur et suite) ;

   2.   40 si le joueur a un carré (4 cartes de la même valeur) ;

   3.   10 si le joueur a un full (1 brelan et 1 paire) ;

   4.   8 si le joueur a une couleur (5 cartes de la même couleur) ;

   5.   4 si le joueur a une suite (5 cartes qui se suivent) ;

   6.   3 si le joueur a un brelan (3 cartes de la même valeur) ;

   7.   2 si le joueur a 2 paires (2 x 2 cartes de la même valeur) ;

7. proposer le quitte ou double si le joueur a obtenu un gain ;

8. ajouter le gain au jetons restant ;

9. controler s'il reste des jetons pour continuer ;

10. recommencer le cycle si le joueur le souhaite.

D'abord, faite-le fonctionner. Ensuite, faite-le beau. Enfin, faite-le performant.

Amusez-vous bien !

Télécharger RETROGICIEL - Retropoker.

Cette présentation nécessite que Python 3 soit installé sur votre machine.

Après avoir téléchargé le fichier Retropoker.7z, décompressez-le dans le répertoire de votre choix.

Ouvrez le répertoire qui vient d'être créé.

Lancez le fichier Retrogiciel.py.

Cliquez sur l'onglet RUN et testez le programme.

Créez votre propre script dans un des langages proposés ou un autre de votre choix.

Le répertoire contient aussi : 

- Python.py, l'exemple en PYTHON sans tkinter ;

- Tkinter.py, l'exemple en PYTHON avec tkinter ;

- Qb84.bas, l'exemple en QBASIC avec qb64 ;

- Bbc.bas, l'exemple en BBC BASIC avec bbc sdl.

# --- Origine Nerd ---

# --- RETROGICIEL - PYTHON ---

# --- Rétropoker ---

# -*- coding: utf-8 -*-

# --- IMPORTATION DES MODULES ---

import random

# --- INITIALISATION GÉNÉRALE ---

LST_Tirage = [ ]

DCT_Donnees = { "jetons" : 1000 }

# --- DÉFINITION DES FONCTIONS POUR PROGRAMME ADAPTE ---

# --- Quitte ou double ---

def FNC_Chance ( Q ) :

kchoix = input ( "Quitte ou double ([O]ui ou [N]on) ?" )

if kchoix.upper ( ) == "N" : return Q

kgain = Q * 2 if random.choice ( range ( 10 ) ) > 4 else 0

if kgain : print ( f"Bravo, c'est doublé ! Votre gain est de { kgain } jetons." )

else : print ( "Dommage, c'est perdu ! Votre gain est de 0 jeton." )

return kgain

# --- Changement des cartes dédignées ---

def FNC_Changement ( ) :

# --- Sélection des cartes à changer ---

print ( "\nVous pouvez changer 0, 1, 2, 3 ou 4 cartes. en indiquant leur numéro," )

print ( "sans espace, par exemple : 134, pour changer les carte 1, 3 et 4." )

kchoix = input ( "Quelles cartes souhaitez-vous changer ? " )

if len ( kchoix ) < 1 : return

# --- Teste la validité des cartes à changer ---

kchoix = kchoix + "----"

kchoix = set ( kchoix [ 0 : 4 ] )

# --- Remplacement des cartes choisies ---

for kitem in kchoix :

if kitem in "12345" :

kcarte = int ( kitem ) - 1

while True :

ktirage = random.choice ( range ( 52 ) )

if ktirage not in LST_Tirage : break

LST_Tirage [ kcarte ] = ktirage

# --- Affichage de la nouvelle main ---

print ( "\nVotre main définitive : " )

FNC_Presentation ( )

# --- Teste le nombre de valeurs semblable (paire, brelan, carré) ---

def FNC_Combinaison ( ) :

kcombinaison = [ ]

kvaleurs = [ kvaleur % 13 for kvaleur in LST_Tirage ] 

while len ( kvaleurs ) > 0 :

kvaleur = kvaleurs [ 0 ]

kcombinaison.append ( kvaleurs.count ( kvaleur ) )

ktransit = [ ]

kvaleurs = [ kitem for kitem in kvaleurs if kitem != kvaleur ]

kcombinaison.sort ( reverse = True )

match kcombinaison [ 0 ] :

case 4 : return "un carré"

case 3 if kcombinaison [ 1 ] == 2 : return "un full"

case 3 : return "un brelan"

case 2 if kcombinaison [ 1 ] == 2 : return "deux paires"

case 2 : return "une paire"

case _ : return "une hauteur"

# --- Teste si le joueur à une couleur ---

def FNC_Couleur ( ) :

kcouleur = True

kcartes = [ kcarte // 13 for kcarte in LST_Tirage ]

for kindex in range ( 4 ) :

if kcartes [ kindex ] != kcartes [ kindex + 1 ] :

kcouleur = False

break

return kcouleur

# --- Mise du joueur ---

def FNC_Mise ( ) :

print ( f"Jetons disponibles avant votre mise : { DCT_Donnees [ 'jetons' ] }." )

kmaximum = 25 if DCT_Donnees [ "jetons" ] > 25 else DCT_Donnees [ "jetons" ]

kminimum = 10 if kmaximum > 24 else 1

kmise = input ( f"Votre mise entre { kminimum } et { kmaximum } jetons, svp ?" )

try :

kmise = int ( kmise )

if kmise > kmaximum : kmise = kmaximum

if kmise > kminimum : kmise = kminimum

    except :

kmise = kmaximum

DCT_Donnees [ "jetons" ] = DCT_Donnees [ "jetons" ] - kmise

print ( f"Votre mise : { kmise }." )

print ( f"Jetons disponibles après votre mise : { DCT_Donnees [ 'jetons' ] }." )

return kmise

# --- Presentation des cartes tirées ---

def FNC_Presentation ( ) :

# --- Analyse de la valeur / couleur ---

kindex = 0

for kcarte in LST_Tirage :

# --- Figure de la cartes---

kvaleur = ( kcarte % 13 ) + 1

match kvaleur :

case 1 : kfigure = "AS"

case 11 : kfigure = "VALET"

case 12 : kfigure = "DAME"

case 13 : kfigure = "ROI"

case _ : kfigure = str ( kvaleur )

# --- Couleur de la carte ---

kvaleur = kcarte // 13

match kvaleur :

case 0 : kcouleur = "CARREAU"

case 1 : kcouleur = "COEUR"

case 2 : kcouleur = "PIQUE"

case 3 : kcouleur = "TREFLE"

# --- Affichage de la carte ---

kindex += 1

print ( f"{ kindex } : { kfigure } de { kcouleur }" )

# --- Teste si le joueur à une suite ---

def FNC_Suite ( ) :

ksuite = True

kvaleurs = list ( frozenset ( [ kvaleur % 13 for kvaleur in LST_Tirage ] ) )

if len ( kvaleurs ) < 5 : return False

if kvaleurs [ 4 ] == 13 and kvaleurs [ 0 ] == 1 :

kvaleurs.pop ( 0 )

kvaleurs.append ( 14 )

if kvaleurs [ 4 ] - kvaleurs [ 0 ] != 4 : ksuite = False

return ksuite

# --- PRESENTATION ---

print ( "RETROPOKER." )

print ( "..." )

# --- BOUCLE PRINCIPALE ---

while True :

# --- Choix de la mise ---

kmise = FNC_Mise ( )

# --- Tirage initial de 5 cartes ---

LST_Tirage = random.sample ( range ( 52 ) , 5 )

print ( "\nVos 5 cartes de base :" )

FNC_Presentation ( )

# --- Cartes à changer ---

FNC_Changement ( )

# --- Recherche des combinaisons obtenus ---

kcouleur = FNC_Couleur ( )

ksuite = FNC_Suite ( )

kroyal = True if kcouleur and ksuite else False

kcombinaison = FNC_Combinaison ( )

# --- Recherche de la meilleure combinaison ---

if kroyal : kmain = ( "UNE QUINTE FLUCH" , 100 )

elif kcombinaison == "un carré" : kmain = ( kcombinaison , 40 )

elif kcombinaison == "un full" : kmain = ( kcombinaison , 10 )

elif kcouleur : kmain = ( "une couleur" , 8 )

elif ksuite : kmain = ( "une suite" , 4 )

elif kcombinaison == "un brelan" : kmain = ( kcombinaison , 3 )

elif kcombinaison == "deux paires" : kmain = ( kcombinaison , 2 )

else : kmain = ( kcombinaison , 0 )

# --- Annonce du résultat / gain ---

kgain = kmise * kmain [ 1 ]

kjeton = "jetons" if kgain > 1 else "jeton"

print ( f"\nVous avez { kmain [ 0 ] }." )

print ( f"Votre gain est de { kmise } x { kmain [ 1 ] } soit { kgain } { kjeton }." )

# --- Réalisation du quitte ou double ---

if kgain : kgain = FNC_Chance ( kgain )

# --- MaJ et affichage des jetons restant ---

DCT_Donnees [ "jetons" ] += kgain

print ( f"Jetons disponibles après cette main : { DCT_Donnees [ 'jetons' ] }." )

if DCT_Donnees [ "jetons" ] < 1 :

print ( "Désolé, vous n'avez plus de jeton pour continuer de jouer" )

break

# --- Choix du bouclage du programme ---

kchoix = input ( "Voulez-vous un autre tirage (O ou N) ?" )

if kchoix.upper ( ) == "N" : break

else : print ( )

# --- FIN DU PROGRAMME ---

print ( "\nAu revoir" )

# --- Programme : JFB ---

# --- Septembre 2025 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON sans tkinter.

# --- Origine Nerd ---

# --- RETROGICIEL - TKINTER ---

# --- Rétropoker ---

# -*- coding: utf-8 -*-

# --- IMPORTATION DES MODULES ---

# --- Modules de la bibliothèque standard ---

import tkinter, tkinter.messagebox

import random

# --- INITIALISATION GÉNÉRALE ---

LST_Tirage = [ ]

# --- DÉFINITION DES FONCTIONS PERSONNALISEES ---

# --- Sélection de l'action à rélaiser ---

def FNC_Action ( ) :

if BUT_Action [ "text" ] == "Miser" : FNC_Tirage ( )

elif BUT_Action [ "text" ] == "Changer" : FNC_Changer ( )

elif BUT_Action [ "text" ] == "Au revoir" : TKI_Principal.destroy ( )

# --- Analyse de la main et recheche du gain ---

def FNC_Analyse ( ) :

# --- Recherche des combinaisons obtenus ---

kcouleur = FNC_Couleur ( )

ksuite = FNC_Suite ( )

kroyal = True if kcouleur and ksuite else False

kcombinaison = FNC_Combinaison ( )

# --- Recherche de la meilleure combinaison ---

if kroyal : kmain = ( "UNE QUINTE FLUCH" , 100 )

elif kcombinaison == "un carré" : kmain = ( kcombinaison , 40 )

elif kcombinaison == "un full" : kmain = ( kcombinaison , 10 )

elif kcouleur : kmain = ( "une couleur" , 8 )

elif ksuite : kmain = ( "une suite" , 4 )

elif kcombinaison == "un brelan" : kmain = ( kcombinaison , 3 )

elif kcombinaison == "deux paires" : kmain = ( kcombinaison , 2 )

else : kmain = ( kcombinaison , 0 )

return kmain

# --- Réalisation du quitte ou double ---

def FNC_Chance ( Q ) :

kmessage = f"Vous avez obtenu un gain de { Q }.\nVoulez-vous tenter le\nquitte ou double ?"

kchoix = tkinter.messagebox.askyesno ( title = "Quitte ou double." , message = kmessage )

if kchoix : Q = Q * 2 if random.choice ( range ( 10 ) ) > 4 else 0

else : return Q

if Q : kmessage = f"Bravo, c'est doublé !\nVotre gain est de { Q } ."

else : kmessage = "Dommage, c'est perdu !\nVotre gain est de 0."

tkinter.messagebox.showinfo ( title = "Quitte ou double." , message = kmessage )

return Q

# --- Changement des cartes séléctionnées ---

def FNC_Changer ( ) :

# --- Changement des cartes sélectionnées ---

kcarte = 0

for kcase in ( TKV_Carte1 , TKV_Carte2 , TKV_Carte3 , TKV_Carte4 , TKV_Carte5 ) :

if kcase.get ( ) :

while True :

ktirage = random.choice ( range ( 52 ) )

if ktirage not in LST_Tirage : break

LST_Tirage [ kcarte ] = ktirage

kcarte += 1

# --- Affichage et analyse de la main définive ---

FNC_Presentation ( )

FNC_Gain ( )

# --- Teste le nombre de valeurs semblable (paire, brelan, carré) ---

def FNC_Combinaison ( ) :

kcombinaison = [ ]

kvaleurs = [ kvaleur % 13 for kvaleur in LST_Tirage ] 

while len ( kvaleurs ) > 0 :

kvaleur = kvaleurs [ 0 ]

kcombinaison.append ( kvaleurs.count ( kvaleur ) )

ktransit = [ ]

kvaleurs = [ kitem for kitem in kvaleurs if kitem != kvaleur ]

kcombinaison.sort ( reverse = True )

match kcombinaison [ 0 ] :

case 4 : return "un carré"

case 3 if kcombinaison [ 1 ] == 2 : return "un full"

case 3 : return "un brelan"

case 2 if kcombinaison [ 1 ] == 2 : return "deux paires"

case 2 : return "une paire"

case _ : return "une hauteur"

# --- Teste si le joueur à une couleur ---

def FNC_Couleur ( ) :

kcouleur = True

kcartes = [ kcarte // 13 for kcarte in LST_Tirage ]

for kindex in range ( 4 ) :

if kcartes [ kindex ] != kcartes [ kindex + 1 ] :

kcouleur = False

break

return kcouleur

# --- Recherche et affichage d'un gain ---

def FNC_Gain ( ) :

# --- Annonce du résultat / gain ---

kmain = FNC_Analyse ( )

kgain = SCA_Mise.get ( ) * kmain [ 1 ]

LAB_Main [ "text" ] = f"Vous avez : { kmain [ 0 ] }."

if kgain : kgain = FNC_Chance ( kgain ) # --- possibilité de tenter le quitte ou double ---

LAB_Gain [ "text" ] = f"Vous obtenez : { kgain }."

# --- Calcul des jetons restants ---

if kgain : 

TKV_Jetons.set ( TKV_Jetons.get ( ) + kgain )

LAB_Jetons [ "text" ] = f"Vous avez : { TKV_Jetons.get ( ) }"

# --- Teste une fin de partie ---

if TKV_Jetons.get ( ) < 1 :

LAB_Mise [ "text" ] = "PARTIE TERMINÉE"

BUT_Action [ "text" ] = "Au revoir"

BUT_Action [ "state" ] = "normal"

else :

FNC_Nouveau ( )

# --- Sélection et controle de la mise ---

def FNC_Mise ( event ) :

LAB_Mise [ "text" ] = f"Votre mise : { SCA_Mise.get ( ) }"

# --- Prépartion d'une nouvelle donne ---

def FNC_Nouveau ( ) :

# --- Pause avant le tour suivant ---

for ksecondes in ( 3 , 2 , 1 ) :

BUT_Action [ "text" ] = ksecondes

TKI_Principal.update ( )

TKI_Principal.after ( 1000 )

# --- MaJ des controle ---

SCA_Mise [ "from_" ] = 10 if TKV_Jetons.get ( ) > 24 else 1

SCA_Mise [ "to" ] = 25 if TKV_Jetons.get ( ) > 24 else TKV_Jetons.get ( )

BUT_Action [ "text" ] = "Miser"

BUT_Action [ "state" ] = "normal"

SCA_Mise [ "state" ] = "normal"

# --- Presentation des cartes tirées ---

def FNC_Presentation ( ) :

# --- Analyse de la valeur / couleur ---

klabel = 0

for kcarte in LST_Tirage :

# --- Figure de la cartes---

kvaleur = ( kcarte % 13 ) + 1

match kvaleur :

case 1 : kfigure = "AS"

case 11 : kfigure = "VALET"

case 12 : kfigure = "DAME"

case 13 : kfigure = "ROI"

case _ : kfigure = str ( kvaleur )

# --- Couleur de la carte ---

kvaleur = kcarte // 13

match kvaleur :

case 0 : kcouleur = "CARREAU"

case 1 : kcouleur = "COEUR"

case 2 : kcouleur = "PIQUE"

case 3 : kcouleur = "TREFLE"

# --- Affichage de la carte ---

klabel += 1

match klabel :

case 1 : LAB_Carte1 [ "text" ] = f"{ kfigure } de { kcouleur }" 

case 2 : LAB_Carte2 [ "text" ] = f"{ kfigure } de { kcouleur }" 

case 3 : LAB_Carte3 [ "text" ] = f"{ kfigure } de { kcouleur }" 

case 4 : LAB_Carte4 [ "text" ] = f"{ kfigure } de { kcouleur }" 

case 5 : LAB_Carte5 [ "text" ] = f"{ kfigure } de { kcouleur }" 

# --- Gestion des case à cocher pour la sélection des cartes à changer ---

def FNC_Selection ( Q ) :

kcartes = 1 if TKV_Carte1.get ( ) else 0

if TKV_Carte2.get ( ) : kcartes += 1

if TKV_Carte3.get ( ) : kcartes += 1

if TKV_Carte4.get ( ) : kcartes += 1

if TKV_Carte5.get ( ) : kcartes += 1

if kcartes > 4 : Q.deselect ( )

# --- Teste si le joueur à une suite ---

def FNC_Suite ( ) :

ksuite = True

kvaleurs = list ( frozenset ( [ kvaleur % 13 for kvaleur in LST_Tirage ] ) )

if len ( kvaleurs ) < 5 : return False

if kvaleurs [ 4 ] == 13 and kvaleurs [ 0 ] == 1 :

kvaleurs.pop ( 0 )

kvaleurs.append ( 14 )

if kvaleurs [ 4 ] - kvaleurs [ 0 ] != 4 : ksuite = False

return ksuite

# --- Changement des cartes séléctionnées ---

def FNC_Tirage ( ) :

# --- MaJ des controles ---

SCA_Mise [ "state" ] = "disabled"

BUT_Action [ "state" ] = "disabled"

# --- Calcul des jetons restants ---

TKV_Jetons.set ( TKV_Jetons.get ( ) - SCA_Mise.get ( ) )

LAB_Jetons [ "text" ] = f"Vous avez : { TKV_Jetons.get ( ) }"

TKI_Principal.update ( )

# --- Tirage de la main de base ---

LST_Tirage [ : ] = random.sample ( range ( 52 ) , 5 )

FNC_Presentation ( )

# --- MaJ des controles ---

BUT_Action [ "text" ] = "Changer"

BUT_Action [ "state" ] = "normal"

for kcase in ( CKB_Carte1 , CKB_Carte2 , CKB_Carte3 , CKB_Carte4 , CKB_Carte5 ) :

kcase [ "state" ] = "normal"

kcase.deselect ( )

# --- CREATION DE L'INTERFACE GRAPHIQUE ---

# --- Création de la fenêtre principale ---

TKI_Principal = tkinter.Tk ( )

TKI_Principal.title ( "RETROGICIEL - Rétropoker." )

# --- Création des variables de controles ---

TKV_Carte1 = tkinter.BooleanVar ( )

TKV_Carte2 = tkinter.BooleanVar ( )

TKV_Carte3 = tkinter.BooleanVar ( )

TKV_Carte4 = tkinter.BooleanVar ( )

TKV_Carte5 = tkinter.BooleanVar ( )

TKV_Jetons = tkinter.IntVar ( )

BUT_Action = tkinter.Button ( TKI_Principal , text = "Miser" , command = FNC_Action )

CKB_Carte1 = tkinter.Checkbutton ( TKI_Principal , variable = TKV_Carte1 , command = lambda : FNC_Selection ( CKB_Carte1 ) )

CKB_Carte2 = tkinter.Checkbutton ( TKI_Principal , variable = TKV_Carte2 , command = lambda : FNC_Selection ( CKB_Carte2 ) )

CKB_Carte3 = tkinter.Checkbutton ( TKI_Principal , variable = TKV_Carte3 , command = lambda : FNC_Selection ( CKB_Carte3 ) )

CKB_Carte4 = tkinter.Checkbutton ( TKI_Principal , variable = TKV_Carte4 , command = lambda : FNC_Selection ( CKB_Carte4 ) )

CKB_Carte5 = tkinter.Checkbutton ( TKI_Principal , variable = TKV_Carte5 , command = lambda : FNC_Selection ( CKB_Carte5 ) )

LAB_Carte1 = tkinter.Label ( TKI_Principal , bg = "palegreen" , relief = "solid" , width = 20 )

LAB_Carte2 = tkinter.Label ( TKI_Principal , bg = "palegreen" , relief = "solid" , width = 20 )

LAB_Carte3 = tkinter.Label ( TKI_Principal , bg = "palegreen" , relief = "solid" , width = 20 )

LAB_Carte4 = tkinter.Label ( TKI_Principal , bg = "palegreen" , relief = "solid" , width = 20 )

LAB_Carte5 = tkinter.Label ( TKI_Principal , bg = "palegreen" , relief = "solid" , width = 20 )

LAB_Jetons = tkinter.Label ( TKI_Principal , text = "Jetons restant : 1000" )

LAB_Gain = tkinter.Label ( TKI_Principal , text = "Vous gain : " )

LAB_Main = tkinter.Label ( TKI_Principal , text = "Vous avez : " )

LAB_Mise = tkinter.Label ( TKI_Principal , text = "Votre mise : 10 " )

SCA_Mise = tkinter.Scale ( TKI_Principal , orient = "horizontal" , showvalue = False , from_ = 10 , to = 25 , command = FNC_Mise )

# --- Mise en place des controles (anonymes et nommés) dans la fenêtre principale ---

LAB_Jetons.grid ( row = 0 , column = 0 , columnspan = 2 , sticky = "nesw" )

LAB_Mise.grid ( row = 1 , column = 0 , columnspan = 2 , sticky = "nesw" )

SCA_Mise.grid ( row = 2 , column = 0 , columnspan = 2 , sticky = "nesw" )

CKB_Carte1.grid ( row = 3 , column = 0 , sticky = "nesw" )

LAB_Carte1.grid ( row = 3 , column = 1 , sticky = "nesw" )

CKB_Carte2.grid ( row = 4 , column = 0 , sticky = "nesw" )

LAB_Carte2.grid ( row = 4 , column = 1 , sticky = "nesw" )

CKB_Carte3.grid ( row = 5 , column = 0 , sticky = "nesw" )

LAB_Carte3.grid ( row = 5 , column = 1 , sticky = "nesw" )

CKB_Carte4.grid ( row = 6 , column = 0 , sticky = "nesw" )

LAB_Carte4.grid ( row = 6 , column = 1 , sticky = "nesw" )

CKB_Carte5.grid ( row = 7 , column = 0 , sticky = "nesw" )

LAB_Carte5.grid ( row = 7 , column = 1 , sticky = "nesw" )

BUT_Action.grid ( row = 8 , column = 0 , columnspan = 2 , sticky = "nesw" )

LAB_Main.grid ( row = 9 , column = 0 , columnspan = 2 , sticky = "nesw" )

LAB_Gain.grid ( row = 10 , column = 0 , columnspan = 2 , sticky = "nesw" )

tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy ).grid ( row = 11 , column = 0 , columnspan = 2 , sticky = "nesw" )

# --- Mise à jour de controle ---

TKV_Jetons.set ( 1000 )

# --- DEBUT DU PROGRAMME ---

TKI_Principal.mainloop ( )

# --- Programme : JFB ---

# --- Septembre 2025 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON avec tkinter.

' --- Origine Nerd propose pour ---

' --- RETROGICIEL - QB64 ---

' --- Retropokerl ---

' --- INITIALISATION GENERALE ---

' --- Declarations des variables globales ---

DIM SHARED LST_Cartes(4)

' --- Initialisation du generateur de nobres aleatoires ---

RANDOMIZE TIMER

' --- DEBUT DU PROGRAMME ---

PRINT "RETROPOKER"

VIEW PRINT 3 TO 24

kjetons = 1000

' --- BOUCLE PRINCIPALE ---

DO

'--- Initialisation d'une nouvelle main ---

CLS

PRINT "Il vous restes : "; kjetons; " jetons."

' --- Saisie de la mise ---

kmise = FNC_Mise(kjetons)

kjetons = kjetons - kmise

CLS

PRINT "Il vous restes :"; kjetons; "jetons."

PRINT "Votre mise ... :"; kmise

PRINT

' --- Tirage de la mains de base ---

FOR kindex = 0 TO 4: LST_Cartes(kindex) = -1: NEXT kindex

FNC_Tirage

' --- Choix des cartes a changer  ---

FNC_Changer

FNC_Tirage

' --- Analyse de la main ---

kcoefficient = FNC_Analyse

' --- Calcul et affichage du gain ---

kgain = kmise * kcoefficient

PRINT "Votre gain est de : "; STR$(kmise); " x "; STR$(kcoefficient); " = "; STR$(kgain)

IF kgain > 0 THEN kgain = FNC_Chance(kgain)

' --- Calcul et affichage des jetons restant ---

kjetons = kjetons + kgain

PRINT

PRINT "Vous avez maintenant : "; STR$(kjetons); " jetons."

' --- Bouclage du programme ---

PRINT

INPUT "Voulez-vous recommencer [ O ou N ] "; kchoix$

LOOP UNTIL UCASE$(kchoix$) = "N"

' --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

' --- DEFINITION DES FONCTIONS PERSONNALISEES ---

' --- Analyse de la main du joueur ---

FUNCTION FNC_Analyse

' --- Initialisation du tableau des valeurs des cartes ---

DIM kmain(4)

FOR kindex = 0 TO 4

kmain(kindex) = (LST_Cartes(kindex) - 1) MOD 13

NEXT kindex

' --- Tri par ordre croissant des valeurs des cartes ---

FOR kindex = 3 TO 0 STEP -1

FOR kitem = 0 TO kindex

IF kmain(kitem) > kmain(kitem + 1) THEN SWAP kmain(kitem), kmain(kitem + 1)

NEXT kitem

NEXT kindex

' --- Recherche des combinaisons obtenues ---

kcouleur$ = FNC_Couleur$

ksuite$ = FNC_Suite$(kmain())

kcombinaison$ = PROC_Combinaison(kmain())

' --- Recherche du coeficient multiplicateur de lamise ---

kcoeficient = 0

IF kcouleur$ = "oui" AND ksuite$ = "oui" THEN kcombinaison$ = "une quinte fluch": kcoeficient = 100

IF kcombinaison$ = "un carre" THEN kcoeficient = 40

IF kcombinaison$ = "un full" THEN kcoeficient = 10

IF kcouleur$ = "oui" THEN kcombinaison$ = "une couleur": kcoeficient = 8

IF ksuite$ = "oui" THEN kcombinaison$ = "une suite": kcoeficient = 4

IF kcombinaison$ = "un brelan" THEN kcoeficient = 3

IF kcombinaison$ = "deux paires" THEN kcoeficient = 2

LOCATE 13, 1: PRINT "Vous avez "; kcombinaison$; "."

FNC_Analyse = kcoeficient

END FUNCTION

' --- Nommage d'une carte ---

FUNCTION FNC_Carte$ (Q)

' --- Recherche de la couleur de la carte ---

SELECT CASE Q \ 13

CASE 0: kcouleur$ = "COEUR"

CASE 1: kcouleur$ = "PIQUE"

CASE 2: kcouleur$ = "TREFLE"

CASE 3: kcouleur$ = "CARREAU"

END SELECT

' --- Recherche de la valeur de la carte ---

SELECT CASE Q MOD 13

CASE 0: kvaleur$ = "AS"

CASE 10: kvaleur$ = "VALET"

CASE 11: kvaleur$ = "DAME"

CASE 12: kvaleur$ = "ROI"

CASE ELSE: kvaleur$ = LTRIM$(STR$((Q MOD 13) + 1))

END SELECT

' --- Affichage du nom de la carte ---

FNC_Carte$ = kvaleur$ + " de " + kcouleur$

END FUNCTION

' --- Tirage du quitte ou double ---

FUNCTION FNC_Chance (Q)

PRINT "Voulez-vous tenter le quitte ou double (O ou N) ? "

DO

SLEEP: kchoix$ = INKEY$

IF UCASE$(kchoix$) = "N" THEN EXIT DO

IF UCASE$(kchoix$) = "O" THEN

IF RND < .5 THEN

Q = Q * 2

PRINT "BRAVO ! C'est double."

PRINT "Votre gain est maintenant de "; STR$(Q)

ELSE

Q = 0

PRINT "Dommage, c'est rate."

PRINT "Vous perdez votre gain."

END IF

END IF

LOOP UNTIL UCASE$(kchoix$) = "O"

FNC_Chance = Q

END FUNCTION

' --- Tirage des cartes a changer ---

SUB FNC_Changer

COLOR 14

kchanger = 0

FOR kindex = 0 TO 4

kcarte = LST_Cartes(kindex)

kcarte$ = FNC_Carte$(kcarte)

LOCATE (kindex + 7), 22: PRINT "<<< Changer cette cartes (O ou N) ? "

DO

SLEEP: kchoix$ = INKEY$

IF UCASE$(kchoix$) = "N" THEN EXIT DO

IF UCASE$(kchoix$) = "O" THEN

LST_Cartes(kindex) = -1

kchanger = kchanger + 1

LOCATE (kindex + 7), 5: PRINT SPACE$(20)

EXIT DO

END IF

LOOP UNTIL 1 = 0

LOCATE (kindex + 7), 22: PRINT SPACE$(40)

IF kchanger > 3 THEN EXIT FOR

NEXT kindex

COLOR 7

END SUB

' --- Recherche d'une figure speciale ---

FUNCTION PROC_Combinaison$ (Q())

kpaire = 0

kbrelan = 0

kcarre = 0

FOR kvaleur = Q(0) TO Q(4)

kquantite = 0

FOR kindex = 0 TO 4

IF Q(kindex) = kvaleur THEN kquantite = kquantite + 1

NEXT kindex

IF kquantite = 2 THEN kpaire = kpaire + 1

IF kquantite = 3 THEN kbrelan = 1

IF kquantite = 4 THEN kcarre = 1

NEXT kvaleur

kcombinaison$ = "une hauteur"

IF kcarre = 1 THEN kcombinaison$ = "un carre"

IF kbrelan = 1 AND kpaire = 1 THEN kcombinaison$ = "un full"

IF kbrelan = 1 THEN kcombinaison$ = "un brelan"

IF kpaire = 2 THEN kcombinaison$ = "deux paires"

IF kpaire = 1 THEN kcombinaison$ = "une paire"

PROC_Combinaison$ = kcombinaison$

END FUNCTION

' --- Recherche d'une couleur ---

FUNCTION FNC_Couleur$

kcouleur$ = "oui"

FOR kindex = 0 TO 3

kcarte = (LST_Cartes(kindex) - 1) \ 13

ksuivante = (LST_Cartes(kindex + 1) - 1) \ 13

IF kcarte <> ksuivante THEN kcouleur$ = "non"

NEXT kindex

FNC_Couleur = kcouleur$

END FUNCTION

' ---  Description de la fonction ---

FUNCTION FNC_Mise (Q)

IF Q < 25 THEN kmaximun = Q ELSE kmaximum = 25

IF Q < 25 THEN kminimum = 1 ELSE kminimum = 10

PRINT

PRINT "Mise maximum : "; kmaximum

PRINT "Mise minimum : "; kminimum

INPUT "Votre mise ... "; kmise

IF kmise = 0 OR kmise > kmaximum THEN kmise = kmaximum

IF kmise < kminimum THEN kmise = kminimum

FNC_Mise = kmise

END FUNCTION

' --- Recherche d'une suite ---

FUNCTION FNC_Suite$ (Q())

' --- Rechecche une eventuelle suite royale (deplacement de l'as) ---

IF Q(4) = 12 AND Q(0) = 0 THEN

FOR kindex = 0 TO 3: Q(kindex) = Q(kindex + 1): NEXT kindex

Q(4) = 13

END IF

' --- Recherche si les 5 cartes forme une suite ---

IF (Q(4) - Q(0)) = 4 THEN ksuite$ = "oui" ELSE ksuite$ = "non"

' --- Recherche si toutes les valeurs sont differentes ---

FOR kindex = 0 TO 3:

IF Q(kindex) = Q(kindex + 1) THEN ksuite$ = "non"

NEXT kindex

' --- Retourne si une suite est trouvee ---

FNC_Suite$ = ksuite$

END FUNCTION

' --- Tirage des cartes ---

SUB FNC_Tirage

LOCATE 6, 1: PRINT "Vos cartes."

FOR kindex = 0 TO 4

IF LST_Cartes(kindex) = -1 THEN

DO

ksuivante$ = "oui"

ktirage = INT(RND * 52)

FOR kitem = 0 TO 4

IF LST_Cartes(kitem) = ktirage THEN ksuivante$ = "non"

NEXT kitem

LOOP UNTIL ksuivante$ = "oui"

LST_Cartes(kindex) = ktirage

END IF

kcarte$ = FNC_Carte$(LST_Cartes(kindex))

PRINT STR$(kindex + 1); " : "; kcarte$; SPACE$(10)

NEXT kindex

END SUB

' --- Programme : JFB ---

' --- Septembre 2025 ---

' --- Fin ---

Pour mieux comprendre l'exemple en QB64.

REM --- Origine Nerd propose pour ---

REM --- RETROGICIEL - BBC BASIC ---

REM --- Retropoker ---

REM --- INITIALISATION GENERALE ---

REM --- Déclarations des variables globales ---

DIM LST_Cartes( 4 )

GBL_Jetons = 1000

GBL_Mise = 0

GBL_Carte$ = ""

GBL_Couleur = FALSE

GBL_Suite = FALSE

GBL_Royal = FALSE

GBL_Combinaison$ = ""

REM --- BOUCLE PRINCIPALE ---

REPEAT

REM --- Initialisation d'une nouvelle main ---

CLS

PRINT "RETROPOKER."

PRINT  TAB( 0 , 2 ) "Il vous restes : " ; GBL_Jetons ; " jetons."

PRINT

REM --- Saisie de la mise ---

PROC_Mise

PRINT TAB( 0 , 2 ) "Il vous restes : " ; GBL_Jetons ; " jetons.   "

PRINT "Votre mise : " ; GBL_Mise

PRINT STRING$( 20 , " " )

REM --- Tirage de la main de base ---

FOR kcarte = 0 TO 4 : LST_Cartes( kcarte ) = 0 : NEXT kcarte

PROC_Tirage

REM --- Tirage des carte a changer ---

PROC_Changer

PROC_Tirage

REM --- Analyse de la main definitive ---

PROC_Analyse

REM --- Calcul du gain obtenu ---

PROC_Gain

REM --- Teste si le joeurs peut faire une autre partie ---

IF GBL_Jetons < 1 THEN

PRINT

PRINT "Vous n'avez plus de jeton."

PRINT "Vous ne pouvez plus jouer."

EXIT REPEAT

ENDIF

REM --- Bouclage du programme ---

PRINT

INPUT "Voulez-vous recommencer [ O ou N ] "; kchoix$

UNTIL kchoix$ = "N" OR kchoix$ = "n"

REM --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

REM --- DEFINITION DES FONCTIONS PERSONNALISEES ---

REM --- Analyse de la main definitive ---

DEF PROC_Analyse

REM --- Initialisation du tableau des valeurs des cartes ---

LOCAL kmain( ) : DIM kmain( 4 )

FOR kindex = 0 TO 4

kmain( kindex ) = ( LST_Cartes( kindex ) - 1 ) MOD 13

NEXT kindex

REM --- Tri par ordre croissant des valeurs des cartes ---

FOR kindex = 3 TO 0 STEP -1

FOR kitem = 0 TO kindex

IF kmain( kitem ) > kmain( kitem + 1 ) THEN  SWAP kmain( kitem ) , kmain( kitem + 1 )

NEXT kitem

NEXT kindex

REM --- Recherche des combinaison ---

PROC_Couleur

PROC_Suite( kmain() )

IF GBL_Couleur AND GBL_Suite THEN GBL_Royal = TRUE ELSE GBL_Royal = FALSE

PROC_Combinaison( kmain() )

ENDPROC

REM --- Nommage d'une carte selon son numero ---

DEF PROC_Carte( Q )

REM --- Recherche de la couleur de la carte ---

CASE Q DIV 13 OF

WHEN 0 : kcouleur$ = "COEUR"

WHEN 1 : kcouleur$ = "PIQUE"

WHEN 2 : kcouleur$ = "TREFLE"

WHEN 3 : kcouleur$ = "CARREAU"

ENDCASE

REM --- Recherche de la valeur de la carte ---

CASE Q MOD 13 OF

WHEN 0 : kvaleur$ = "AS"

WHEN 10 : kvaleur$ = "VALET"

WHEN 11 : kvaleur$ = "DAME"

WHEN 12 : kvaleur$ = "ROI"

OTHERWISE : kvaleur$ = STR$( ( Q MOD 13 ) + 1 )

ENDCASE

REM --- Affichage du nom de la carte ---

GBL_Carte$ = kvaleur$ + " de " + kcouleur$

ENDPROC

REM --- Tirage possible du quitte ou double ---

DEF PROC_Chance( RETURN Q )

PRINT TAB( 0 , 14 ) "Voulez-vous tenter le quitte ou double (O ou N) ? "

REPEAT

kchoix$ = GET$

IF kchoix$ = "N" OR kchoix$ = "n" THEN EXIT REPEAT

IF kchoix$ = "0" OR kchoix$ = "o" THEN

IF RND( 10 ) > 5 THEN

Q = Q * 2

PRINT "BRAVO ! C'est double."

PRINT "Votre gain est maintenant de " ; STR$( Q )

ELSE

Q = 0

PRINT "Dommage, c'est rate."

PRINT "Vous perdez votre gain."

ENDIF

EXIT REPEAT

ENDIF

UNTIL FALSE

ENDPROC

REM --- Tirage des cartes à changer ---

DEF PROC_Changer

kchanger = 0

FOR kindex = 0 TO 4

kcarte = LST_Cartes( kindex ) - 1

PROC_Carte( kcarte )

PRINT TAB( 0 , 12 ) "Voulez-vous changer : " ; GBL_Carte$ ; " (O ou N) ?"

REPEAT

kchoix$ = GET$

IF kchoix$ = "N" OR kchoix$ = "n" THEN EXIT REPEAT

IF kchoix$ = "O" OR kchoix$ = "o" THEN

LST_Cartes( kindex ) = 0

kchanger += 1

PRINT TAB( 4 , 6 + kindex ) STRING$( 20 , " " )

EXIT REPEAT

ENDIF

UNTIL FALSE

PRINT TAB( 0 , 12 ) STRING$( 50 , " " )

IF kchanger > 3 THEN EXIT FOR kindex

NEXT kindex

ENDPROC

REM --- Recherche d'une figure spéciale ---

DEF PROC_Combinaison( Q() )

kpaire = 0

kbrelan = 0

kcarre = 0

FOR kvaleur = Q( 0 ) TO Q( 4 )

kquantite = 0

FOR kindex = 0 TO 4

IF Q( kindex ) = kvaleur THEN kquantite += 1

NEXT kindex

IF kquantite = 2 THEN kpaire += 1

IF kquantite = 3 THEN kbrelan += 1

IF kquantite = 4 THEN kcarre += 1

NEXT kvaleur

GBL_Combinaison$ = "une hauteur"

IF kcarre = 1 THEN GBL_Combinaison$ = "un carre"

IF kbrelan = 1 AND kpaire = 1 THEN GBL_Combinaison$ = "un full"

IF kbrelan = 1 THEN GBL_Combinaison$ = "un brelan"

IF kpaire = 2 THEN GBL_Combinaison$ = "deux paires"

IF kpaire = 1 THEN GBL_Combinaison$ = "une paire"

ENDPROC

REM --- Recherche d'une couleur ---

DEF PROC_Couleur

GBL_Couleur = TRUE

FOR kindex = 0 TO 3

kcarte =  ( LST_Cartes( kindex ) - 1 ) DIV 13

ksuivante =  ( LST_Cartes( kindex + 1 ) - 1 ) DIV 13

IF kcarte <> ksuivante THEN GBL_Couleur = FALSE

NEXT kindex

ENDPROC

REM --- Calcul du gain obtenu ---

DEF PROC_Gain

PRINT TAB( 0 , 12 ) STRING$( 50 , " " )

kcoeficient = 0

IF GBL_Royal THEN GBL_Combinaison$ = "une suite royale" : kcoeficient = 100

IF GBL_Combinaison$ = "un carre" THEN kcoeficient = 40

IF GBL_Combinaison$ = "un full" THEN kcoeficient = 10

IF GBL_Couleur THEN GBL_Combinaison$ = "une couleur" : kcoeficient = 8

IF GBL_Suite THEN GBL_Combinaison$ = "une suite" : kcoeficient = 4

IF GBL_Combinaison$ = "un brelan" THEN kcoeficient = 3

IF GBL_Combinaison$ = "deux paires" THEN kcoeficient = 2

kgain = GBL_Mise * kcoeficient

PRINT TAB( 0 , 12 ) "Vous avez : " ; GBL_Combinaison$ ; "."

PRINT "Votre gain est de : " ; STR$( GBL_Mise ) ; " x " ; STR$( kcoeficient ) ; " = " ; STR$( kgain )

IF kgain > 0 THEN PROC_Chance( kgain )

GBL_Jetons += kgain

PRINT

PRINT "Vous avez maintenant : " ; STR$( GBL_Jetons ) ; " jetons."

ENDPROC

REM --- Saisie de la mise du joueur ---

DEF PROC_Mise

IF GBL_Jetons < 25 THEN kmaximum = GBL_Jetons ELSE kmaximum = 25

IF GBL_Jetons < 25 THEN kminimum = 1 ELSE kminimum = 10

PRINT "Mise minimum : " ; kminimum

PRINT "Mise maximum : " ; kmaximum

INPUT "Quel est votre mise " ; GBL_Mise

IF GBL_Mise < 1 THEN GBL_Mise = kmaximum

IF GBL_Mise < kminimum THEN GBL_Mise = kminimum

IF GBL_Mise > kmaximum THEN GBL_Mise = kmaximum

GBL_Jetons =  GBL_Jetons - GBL_Mise

ENDPROC

REM --- Recherche d'une suite ---

DEF PROC_Suite( Q() )

REM --- Rechecne une eventuelle suite royale (depalcement de l'as) ---

IF Q( 4 ) = 12 AND Q( 0 ) = 0 THEN

FOR kindex = 1 TO 4 : Q( kindex - 1) = Q( kindex ) : NEXT kindex

Q( 4 ) = 13

ENDIF

REM --- Recherche si les 5 cartes forme une suite ---

IF ( Q( 4 ) - Q( 0 ) ) = 4 THEN GBL_Suite = TRUE ELSE GBL_Suite = FALSE

REM --- Recheche si toutes les valeurs sont differentes ---

FOR kindex = 0 TO 3 :

IF Q( kindex ) = Q( kindex + 1 ) THEN GBL_Suite = FALSE

NEXT kindex

ENDPROC

REM --- Tirage et controle des cartes ---

DEF PROC_Tirage

PRINT TAB( 0 , 5 ) "Vos cartes :       "

FOR kcarte = 0 TO 4

REPEAT

IF LST_Cartes( kcarte ) <> 0 THEN EXIT REPEAT

ksuivante = TRUE

ktirage = RND( 52 )

FOR kindex = 0 TO 4

IF LST_Cartes( kindex ) = ktirage THEN ksuivante = FALSE

NEXT kindex

IF ksuivante THEN LST_Cartes( kcarte ) = ktirage

UNTIL ksuivante

PROC_Carte( LST_Cartes( kcarte ) - 1 )

PRINT STR$( kcarte ) ; " : " ; GBL_Carte$ ; STRING$( 20 , " " )

NEXT kcarte

PRINT

ENDPROC

REM --- Programme : JFB ---

REM --- Septembre 2025 ---

REM --- Fin ---

Pour mieux comprendre l'exemple en BBC BASIC.