La bataille est un jeu de cartes très simple et populaire. Chaque joueur possède un talon de cartes face cachée. À chaque tour, les joueurs retournent simultanément la première carte de leur talon. Le joueur ayant la carte de valeur la plus élevée remporte le pli et ajoute les cartes gagnées sous son talon. Si les deux cartes ont la même valeur, il y a bataille. Les joueurs placent alors une autre carte face cachée sur celle qu’ils viennent de jouer, puis la suivante est posée normalement pour départager le pli. La partie se termine lorsqu’un joueur récupère toutes les cartes du jeu.

Faire une partie de bataille contre la machine présente peu d’intérêt ludique, mais ce jeu constitue un excellent support pour comprendre la logique d’un programme informatique. À ce titre, il représente un exercice intéressant permettant de mettre en pratique plusieurs notions fondamentales de programmation tout en s’appuyant sur un jeu simple et familier.

Une partie de bataille repose en effet sur une succession d’actions logiques : poser une carte, comparer les deux valeurs, déterminer un gagnant et gérer le cas particulier de l’égalité (la bataille), notamment lorsque l’un des joueurs ne possède plus suffisamment de cartes. Ce défi vous aidera à comprendre comment transformer des règles réelles en algorithme.

Le programme doit :

1. demander si l'utilisateur veut les cartes rouges ou noires pour débuter ;

2. distribuer 26 cartes, les rouges ou les noires, au joueur ;

3. distribuer 26 cartes restantes à l'ordinateur ;

4. mélanger les 2 talons ;

5. oter et mémoriser la première carte de chaque talon ;

6. afficher les 2 cartes posées pour le pli ;

7. comparer les valeurs des 2 cartes ;

   1. placer les 2 cartes sous le talon du gagnant ou ;

   2. faire une bataille, et si besoin ;

   3. gérer le cas où un joueur n’a plus assez de cartes ;

8. vérifier si un des participants a toutes les cartes ;

   1. faire le tour suivant ou ;

   2. déclarer un gagnant.

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

Amusez-vous bien !

Télécharger RETROGICIEL - Bataille.

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

Après avoir téléchargé le fichier Bataille.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 ---

# --- Bataille ---

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

# --- IMPORTATION DES MODULES ---

import random

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

LST_Humain = [ ]

LST_Machine = [ ]

TPL_Valeurs = tuple ( [ "10" if kvaleur == "X" else kvaleur for kvaleur in "23456789XVDRA" ] )

TPL_Couleurs = ( "\u2665" , "\u2666" , "\u2660" , "\u2663" )

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

# --- Analyse et Affichage les cartes posées ---

def FNC_Analyse ( Qhumain , Qmachine ) :

# --- La carte du joueur ---

kcouleur , khumain = divmod ( Qhumain , 13 )

kvaleur = TPL_Valeurs [ khumain ]

ksymbole = TPL_Couleurs [ kcouleur ]

kcarteH = TPL_Valeurs [ khumain ] + TPL_Couleurs [ kcouleur ]

# --- La carte de la machine ---

kcouleur , kmachine = divmod ( Qmachine , 13 )

kvaleur = TPL_Valeurs [ kmachine ]

ksymbole = TPL_Couleurs [ kcouleur ]

kcarteM = TPL_Valeurs [ kmachine ] + TPL_Couleurs [ kcouleur ]

# --- Affichage des cartes posées ---

print ( "Humain : " + kcarteH + " \u2B7E " + kcarteM + " : Machine." )

return khumain , kmachine

# --- Préparation d'une bataille ---

def FNC_Bataille ( Q ) :

# --- Verifie que le joueur a assez de cartes ---

if len ( LST_Humain ) == 0 :

kcarte = LST_Machine.pop ( random.randint ( 10 , 30 ) )

LST_Humain.append ( kcarte )

if len ( LST_Humain ) == 1 :

kcarte = LST_Machine.pop ( random.randint ( 10 , 30 ) )

LST_Humain.append ( kcarte )

# --- Verifie que la machine a assez de cartes ---

if len ( LST_Machine ) == 0 :

kcarte = LST_Humain.pop ( random.randint ( 10 , 30 ) )

LST_Machine.append ( kcarte )

if len ( LST_Machine ) == 1 :

kcarte = LST_Humain.pop ( random.randint ( 10 , 30 ) )

LST_Machine.append ( kcarte )

# --- Place (et montre) les cartes à retourner ---

kcarte_H = LST_Humain.pop ( 0 )

kcarte_M = LST_Machine.pop ( 0 )

khumain , kmachine = FNC_Analyse ( kcarte_H , kcarte_M )

Q.extend ( [ kcarte_H , kcarte_M ] )

FNC_Tour ( Q )

# --- Distribution et mélange des 2 talons de cartes ---

def FNC_Debut ( ) :

print ( "\nVoulez-vous débuter avec les cartes rouges ou noires ?" )

while True :

kchoix = input ( "Votre choix ( R ou N ) ... ").upper ( )

if kchoix in "RN" and kchoix != "" : break

if kchoix == "R" :

LST_Humain [ : ] = [ kvaleur for kvaleur in range ( 26 ) ]

LST_Machine [ : ] = [ kvaleur + 26 for kvaleur in range ( 26 ) ]    

else :

LST_Humain [ : ] = [ kvaleur + 26 for kvaleur in range ( 26 ) ]

LST_Machine [ : ] = [ kvaleur for kvaleur in range ( 26 ) ]

random.shuffle ( LST_Humain )

random.shuffle ( LST_Humain )

# --- Mains à jouer ( tour simple ou avec bataille ) ---

def FNC_Tour ( Q ) :

kcarte_H = LST_Humain.pop ( 0 )

kcarte_M = LST_Machine.pop ( 0 )

Q.extend ( [ kcarte_H , kcarte_M ] )

random.shuffle ( Q )

khumain , kmachine = FNC_Analyse ( kcarte_H , kcarte_M )

if khumain > kmachine :

LST_Humain.extend ( Q )

print ( "Vous gagnez ce tour !" )

return

elif khumain < kmachine :

LST_Machine.extend ( Q )

print ( "Vous perdez ce tour !" )

return

else :

print ( "BATAILLE !" )

FNC_Bataille ( Q )

# --- PRESENTATION ---

print ( "Et si nous faisons une petite" )

print ( "bataille pour passer le temps ?" )

# --- BOUCLE PRINCIPALE ---

while True :

# --- Initialisation d'une partie ---

FNC_Debut ( )

ktour = 1

# --- Déroulement de la partie ---

while True :

print ( f"\nTOUR : { ktour } ... " )

FNC_Tour ( [ ] )

print ( f"Vous avez maintenant { len ( LST_Humain ) } / 52 cartes." )

if len ( LST_Humain ) == 0 :

print ( "\n\nVous n'avez plus de carte, c'est perdu.\n\n" )

break

if len ( LST_Machine ) == 0 :

print ( "\n\nVous n'avez pris toutes les cartes ...\nC'est GAGNE !\n\n" )

break

ksuite = input ( "Appuyez sur entrer pour le tour suivant ..." )

ktour += 1

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

kchoix = input ( "Voulez-vous faire une autre partie (O ou N) ?" )

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

# --- FIN DU PROGRAMME ---

print ( "Au revoir" )

# --- Programme : JFB ---

# --- Février 2026 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON sans tkinter.

# --- Origine Nerd ---

# --- RETROGICIEL - TKINTER ---

# --- Bataille ---

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

# --- IMPORTATION DES MODULES ---

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

import tkinter

import random

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

LST_Humain = [ ]

LST_Machine = [ ]

TPL_Valeurs = tuple ( [ "10" if kvaleur == "X" else kvaleur for kvaleur in "23456789XVDRA" ] )

TPL_Couleurs = ( "\u2665" , "\u2666" , "\u2660" , "\u2663" )

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

# --- Analyse et Affichage les cartes posées ---

def FNC_Analyse ( Qhumain , Qmachine ) :

# --- La carte du joueur ---

kcouleur , khumain = divmod ( Qhumain , 13 )

kvaleur = TPL_Valeurs [ khumain ]

ksymbole = TPL_Couleurs [ kcouleur ]

LAB_Humain [ "fg" ] = "red" if kcouleur < 2 else "black"

LAB_Humain [ "text" ] = TPL_Valeurs [ khumain ] + "\n" + TPL_Couleurs [ kcouleur ]

# --- La carte de la machine ---

kcouleur , kmachine = divmod ( Qmachine , 13 )

kvaleur = TPL_Valeurs [ kmachine ]

ksymbole = TPL_Couleurs [ kcouleur ]

LAB_Machine [ "fg" ] = "red" if kcouleur < 2 else "black"

LAB_Machine [ "text" ] = TPL_Valeurs [ kmachine ] + "\n" + TPL_Couleurs [ kcouleur ]

# --- Fin de l'analyse ---

return khumain , kmachine

# --- Préparation d'une bataille ---

def FNC_Bataille ( Q ) :

# --- Verifie que le joueur a assez de cartes ---

if len ( LST_Humain ) == 0 :

kcarte = LST_Machine.pop ( random.randint ( 10 , 30 ) )

LST_Humain.append ( kcarte )

if len ( LST_Humain ) == 1 :

kcarte = LST_Machine.pop ( random.randint ( 10 , 30 ) )

LST_Humain.append ( kcarte )

# --- Verifie que la machine a assez de cartes ---

if len ( LST_Machine ) == 0 :

kcarte = LST_Humain.pop ( random.randint ( 10 , 30 ) )

LST_Machine.append ( kcarte )

if len ( LST_Machine ) == 1 :

kcarte = LST_Humain.pop ( random.randint ( 10 , 30 ) )

LST_Machine.append ( kcarte )

# --- Place (et montre) les cartes à retourner ---

kcarte_H = LST_Humain.pop ( 0 )

kcarte_M = LST_Machine.pop ( 0 )

khumain , kmachine = FNC_Analyse ( kcarte_H , kcarte_M )

kmessage = "cartes au pot : "

kmessage += "\n" + LAB_Humain [ "text" ] [ 0 ] + LAB_Humain [ "text" ] [ -1 ]

kmessage += " et " + LAB_Machine [ "text" ] [ 0 ] + LAB_Machine [ "text" ] [ -1 ]

tkinter.messagebox.showinfo ( title = "BATAILLE !" , message = kmessage )

Q.extend ( [ kcarte_H , kcarte_M ] )

FNC_Tour ( Q )

# --- Distribution et mélange des 2 talons de cartes ---

def FNC_Debut ( ) :

kmessage = "\nVoulez-vous débuter avec les cartes rouges ?"

kchoix = tkinter.messagebox.askyesno ( title = "Bataille ..." , message = kmessage , icon = "question")

if kchoix :

LST_Humain [ : ] = [ kvaleur for kvaleur in range ( 26 ) ]

LST_Machine [ : ] = [ kvaleur + 26 for kvaleur in range ( 26 ) ]    

else :

LST_Humain [ : ] = [ kvaleur + 26 for kvaleur in range ( 26 ) ]

LST_Machine [ : ] = [ kvaleur for kvaleur in range ( 26 ) ]

random.shuffle ( LST_Humain )

random.shuffle ( LST_Humain )

# --- Mains à jouer ( tour simple ou avec bataille ) ---

def FNC_Tour ( Q ) :

kcarte_H = LST_Humain.pop ( 0 )

kcarte_M = LST_Machine.pop ( 0 )

Q.extend ( [ kcarte_H , kcarte_M ] )

random.shuffle ( Q )

khumain , kmachine = FNC_Analyse ( kcarte_H , kcarte_M )

if khumain > kmachine :

LST_Humain.extend ( Q )

LAB_Resultat [ "background" ] = "palegreen"

LAB_Resultat [ "text" ] = "Vous gagnez ce tour !"

elif khumain < kmachine :

LST_Machine.extend ( Q )

LAB_Resultat [ "background" ] = "orchid"

LAB_Resultat [ "text" ] = "Vous perdez ce tour !"

else :

tkinter.messagebox.showinfo ( title = "BATAILLE !" , message = "BATAILLE !!!" )

FNC_Bataille ( Q )

LAB_Cartes [ "text" ] = f"Vous avez { len ( LST_Humain ) } / 52 cartes."

FNC_Terminer ( )

# --- Recherche un gagnant ---

def FNC_Terminer ( ) :

kgagnant = ""

if len ( LST_Humain ) == 0 :

kgagnant = "machine"

kmessage = "Vous n'avez plus de carte ...\nc'est perdu."

LAB_Resultat [ "background" ] = "red"

LAB_Resultat [ "foreground" ] = "yellow"

LAB_Resultat [ "text" ] = "P E R D U"

if len ( LST_Machine ) == 0 :

kgagnant = "humain"

kmessage = "Vous n'avez pris toutes les cartes ...\nC'est GAGNE !"

LAB_Resultat [ "background" ] = "yellow"

LAB_Resultat [ "foreground" ] = "red"

LAB_Resultat [ "text" ] = "G A G N E"

if kgagnant != "" :

BUT_Suivant [ "state" ] = "disabled"

tkinter.messagebox.showinfo ( title = "Partie terminée ..." , message = "kmessage au pot ..." )

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

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

TKI_Principal = tkinter.Tk ( )

TKI_Principal.title ( "RETROGICIEL - Bataille" )

# --- Création des controles nommées ---

LAB_Humain = tkinter.Label ( TKI_Principal , text = "H\nU" , font = ( None , 36 ) , relief = "solid" , bg = "white" , width = 4 )

LAB_Machine = tkinter.Label ( TKI_Principal , text = " M \nA" , font = ( None , 36 ) , relief = "solid" , bg = "white" , width = 4 )

LAB_Resultat = tkinter.Label ( TKI_Principal , text = "..." , font = ( None , 14 ) )

LAB_Cartes = tkinter.Label ( TKI_Principal , text = "Vous avez 26 / 52 cartes." )

BUT_Suivant = tkinter.Button ( TKI_Principal , text = "Suivante" , command = lambda : FNC_Tour ( [ ] ) )

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

tkinter.Label ( TKI_Principal , text = "Humain" ).grid ( row = 0 , column = 0 , sticky = "nesw" )

tkinter.Label ( TKI_Principal , text = "Machine" ).grid ( row = 0 , column = 1 , sticky = "nesw" )

LAB_Humain.grid ( row = 1 , column = 0 , padx = 5 , pady = 5 , sticky = "nesw" )

LAB_Machine.grid ( row = 1 , column = 1 , padx = 5 , pady = 5 , sticky = "nesw" )

LAB_Resultat.grid ( row = 2 , column = 0 , columnspan = 2 , padx = 5 , pady = 5 , sticky = "nesw" )

LAB_Cartes.grid ( row = 3 , column = 0 , columnspan = 2 , padx = 5 , pady = 5 , sticky = "nesw" )

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

tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy ).grid ( row = 4 , column = 1 , sticky = "nesw" )

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

FNC_Debut ( )

FNC_Tour ( [ ] )

# --- DEBUT DU PROGRAMME ---

TKI_Principal.mainloop ( )

# --- Programme : JFB ---

# --- Février 2026 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON avec tkinter.

' --- Origine Nerd propose pour ---

' --- RETROGICIEL - QB64 ---

' --- Bataille ---

' --- INITIALISATION GENERALE ---

' --- Declarations des variables globales ---

DIM SHARED LST_Humain(51) AS INTEGER

DIM SHARED LST_Machine(51) AS INTEGER

DIM SHARED LST_Reservees(51) AS INTEGER

' --- Initialisation des nombres al�atoires ---

RANDOMIZE TIMER

' --- DEBUT DU PROGRAMME ---

PRINT "JOUONS A LA BATAILLE."

PRINT

' --- BOUCLE PRINCIPALE ---

DO

' --- Initialisation des talons de cartes ---

ktour = 0

FOR kcarte = 0 TO 51

LST_Humain(kcarte) = -1

LST_Machine(kcarte) = -1

LST_Reservees(kcarte) = -1

NEXT kcarte

INPUT "Voulez-vous commencer avec les cartes rouges (O ou N) ? ", kchoix$

IF UCASE$(kchoix$) = "N" THEN FNC_Melange 0, "machine" ELSE FNC_Melange 0, "humain"

' --- Deroulement de la partie ---

DO

ktour = ktour + 1

khumain = LST_Humain(0): LST_Humain(0) = -1

kmachine = LST_Machine(0): LST_Machine(0) = -1

FNC_Talons

FNC_Affichage ktour, khumain, kmachine

FNC_Analyse khumain, kmachine

IF LST_Humain(0) = -1 OR LST_Machine(0) = -1 THEN EXIT DO

FOR kcarte = 0 TO 51

IF LST_Humain(kcarte) = -1 THEN EXIT FOR

NEXT kcarte

LOCATE 10, 27: PRINT "Vous avez "; STR$(kcarte); " / 52 cartes. "

LOCATE 12, 22: INPUT "Appuyez sur return pour continuer ...", kpause$

LOOP UNTIL 1 < 0

' --- Partie terminee ---

IF LST_Humain(0) = -1 THEN

LOCATE 10, 27: PRINT "Vous n'avez plus de carte."

LOCATE 11, 25: PRINT "VOUS AVEZ PERDU CETTE PARTIE !"

ELSE

LOCATE 10, 27: PRINT "Vous avez toutes les cartes."

LOCATE 11, 25: PRINT "VOUS AVEZ GAGNEE CETTE PARTIE !"

END IF

' --- Bouclage du programme ---

LOCATE 13, 24: INPUT "Voulez-vous recommencer [ O ou N ] "; kchoix$

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

' --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

' --- DEFINITION DES FONCTIONS PERSONNALISEES ---

' --- Calcul de la couleur des cartes ---

FUNCTION FNC_Couleur$ (Q)

SELECT CASE Q \ 13

CASE 0: FNC_Couleur$ = "Coeur"

CASE 1: FNC_Couleur$ = "Carreau"

CASE 2: FNC_Couleur$ = "Trefle"

CASE 3: FNC_Couleur$ = "Pique"

END SELECT

END FUNCTION

' --- Calcul de la valeur des cartes ---

FUNCTION FNC_Valeur$ (Q)

SELECT CASE Q MOD 13

CASE 9: FNC_Valeur$ = "VALET"

CASE 10: FNC_Valeur$ = "DAME"

CASE 11: FNC_Valeur$ = "ROI"

CASE 12: FNC_Valeur$ = "AS"

CASE ELSE: FNC_Valeur$ = STR$((Q MOD 13) + 2)

END SELECT

END FUNCTION

' --- Affichage des cartes ---

SUB FNC_Affichage (Qtour, Qhumain, Qmachine)

CLS

LOCATE 1, 30: PRINT "JOUONS A LA BATAILLE."

LOCATE 2, 35: PRINT "Tour : "; Qtour

khumain$ = FNC_Valeur$(Qhumain) + " de " + FNC_Couleur$(Qhumain)

kmachine$ = FNC_Valeur$(Qmachine) + " de " + FNC_Couleur$(Qmachine)

LOCATE 5, 28: PRINT "HUMAIN"

LOCATE 5, 47: PRINT "MACHINE"

LOCATE 6, 30 - (LEN(khumain$) / 2): PRINT khumain$

LOCATE 6, 50 - (LEN(kmachine$) / 2): PRINT kmachine$

END SUB

' --- Recherche du gagnant de la main en cour ---

SUB FNC_Analyse (Qhumain, Qmachine)

' --- L'humain gagne ---

IF (Qhumain MOD 13) > (Qmachine MOD 13) THEN

LOCATE 8, 28: PRINT "Vous gagnez cette main."

FNC_Gagnant "humain", Qhumain, Qmachine

END IF

' --- L'humain perd ---

IF (Qhumain MOD 13) < (Qmachine MOD 13) THEN

LOCATE 8, 28: PRINT "La machine vous bat."

FNC_Gagnant "machine", Qmachine, Qhumain

END IF

' --- Bataille, valeurs des cartes egales  ---

IF (Qhumain MOD 13) = (Qmachine MOD 13) THEN

LOCATE 8, 28: PRINT "BATAILLE !"

FNC_Bataille Qhumain, Qmachine

END IF

END SUB

' --- Bataille - pose speciale ---

SUB FNC_Bataille (Qcarte1, Qcarte2)

' --- Ajoute des cartes au talon de humain si besoin ---

IF LST_Humain(0) = -1 THEN

ktirage = INT(RND * 15) + 5

LST_Humain(0) = LST_Machine(ktirage)

LST_Machine(ktirage) = -1

END IF

IF LST_Humain(1) = -1 THEN

ktirage = INT(RND * 15) + 30

LST_Humain(1) = LST_Machine(ktirage)

LST_Machine(ktirage) = -1

END IF

' --- Ajoute des cartes au talon de machine si besoin ---

IF LST_Machine(0) = -1 THEN

ktirage = INT(RND * 15) + 5

LST_Machine(0) = LST_Humain(ktirage)

LST_Humain(ktirage) = -1

END IF

IF LST_Machine(1) = -1 THEN

ktirage = INT(RND * 15) + 30

LST_Machine(1) = LST_Humain(ktirage)

LST_Humain(ktirage) = -1

END IF

' --- Pose (affichage) des cartes cachees ---

FOR kcarte = 0 TO 51

IF LST_Reservees(kcarte) = -1 THEN EXIT FOR

NEXT kcarte

LST_Reservees(kcarte) = Qcarte1

LST_Reservees(kcarte + 1) = Qcarte2

khumain = LST_Humain(0): LST_Humain(0) = -1: LST_Reservees(kcarte + 2) = khumain

kmachine = LST_Machine(0): LST_Machine(0) = -1: LST_Reservees(kcarte + 3) = kmachine

khumain$ = FNC_Valeur$(khumain) + " de " + FNC_Couleur$(khumain)

kmachine$ = FNC_Valeur$(kmachine) + " de " + FNC_Couleur$(kmachine)

FNC_Talons

LOCATE 15, 1: PRINT "CARTES RETOURNNES : "; khumain$; " et "; kmachine$

END SUB

' --- Ajout des cartes au talon du gagnant ---

SUB FNC_Gagnant (Qgagnant$, Qcarte1, Qcarte2)

' --- Ajout des cartes de la main au talon du gagnant ---

FOR kindex = 0 TO 51

IF Qgagnant$ = "humain" AND LST_Humain(kindex) = -1 THEN

LST_Humain(kindex) = Qcarte1

LST_Humain(kindex + 1) = Qcarte2

kitem = kindex + 2

EXIT FOR

END IF

IF Qgagnant$ = "machine" AND LST_Machine(kindex) = -1 THEN

LST_Machine(kindex) = Qcarte1

LST_Machine(kindex + 1) = Qcarte2

kitem = kindex + 2

EXIT FOR

END IF

NEXT kindex

' --- Ajout eventuel des cartes de la reserve (bataille) ---

FOR kreservee = 0 TO 51

IF LST_Reservees(kreservee) = -1 THEN EXIT FOR

IF Qgagnant$ = "humain" THEN LST_Humain(kitem + kreservee) = LST_Reservees(kreservee)

IF Qgagnant$ = "machine" THEN LST_Machine(kitem + kreservee) = LST_Reservees(kreservee)

LST_Reservees(kreservee) = -1

NEXT kreservee

END SUB

' ---  Melange initiale et aleatoire des talons de cartes ---

SUB FNC_Melange (Qdebut, Qtalon$)

' --- Initialisation des cartes du talon virtuel ---

DIM ksuite(25) AS INTEGER

FOR kindex = 0 TO 25: ksuite(kindex) = kindex: NEXT kindex

' --- Melange d'un des deux talons de jeu ---

FOR kvaleur = 0 TO 25

DO

kindex = INT(RND * 26)

kcarte = ksuite(kindex)

LOOP UNTIL kcarte < 26

ksuite(kindex) = 100

kcarte = kindex + Qdebut

IF Qtalon$ = "humain" THEN LST_Humain(kvaleur) = kcarte ELSE LST_Machine(kvaleur) = kcarte

NEXT kvaleur

' --- Rappel de la procedure pour melanger les cartes noires ---

IF Qdebut = 0 THEN

IF Qtalon$ = "humain" THEN ktalon$ = "machine" ELSE ktalon$ = "humain"

FNC_Melange 26, ktalon$

END IF

END SUB

' --- Actualisation des talons (deplacement des cartes posees) ---

SUB FNC_Talons

FOR kcarte = 0 TO 50

IF LST_Humain(kcarte) = -1 THEN SWAP LST_Humain(kcarte), LST_Humain(kcarte + 1)

IF LST_Machine(kcarte) = -1 THEN SWAP LST_Machine(kcarte), LST_Machine(kcarte + 1)

NEXT kcarte

END SUB

' --- Programme : JFB ---

' --- Fevrier ---

' --- Fin ---

Pour mieux comprendre l'exemple en QB64.

REM --- Origine Nerd propose pour ---

REM --- RETROGICIEL - BBC BASIC ---

REM --- Bataille ---

REM --- INITIALISATION GENERALE ---

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

DIM LST_Humain(51)

DIM LST_Machine(51)

DIM LST_Reservees(51)

REM --- DEBUT DU PROGRAMME ---

PRINT "JOUONS A LA BATAILLE."

PRINT

REM --- BOUCLE PRINCIPALE ---

REPEAT

REM --- Initialisation des talons de cartes ---

ktour = 0

FOR kcarte = 0 TO 51

LST_Humain(kcarte) = -1

LST_Machine(kcarte) = -1

LST_Reservees(kcarte) = -1

NEXT kcarte

INPUT "Voulez-vous commencer avec les cartes rouges (O ou N) ? " kchoix$

IF kchoix$ = "N" OR kchoix$ = "n" THEN PROC_Melange( 0 , "machine" ) ELSE PROC_Melange( 0, "humain" )

REM --- Deroulement de la partie ---

REPEAT

ktour = ktour + 1

khumain = LST_Humain(0): LST_Humain(0) = -1

kmachine = LST_Machine(0): LST_Machine(0) = -1

PROC_Talons

PROC_Affichage( ktour , khumain , kmachine )

PROC_Analyse( khumain , kmachine )

IF LST_Humain(0) = -1 OR LST_Machine(0) = -1 THEN EXIT REPEAT

FOR kcarte = 0 TO 51

IF LST_Humain(kcarte) = -1 THEN EXIT FOR

NEXT kcarte

PRINT TAB( 27 , 10 ) "Vous avez "; STR$(kcarte); " / 52 cartes. "

INPUT TAB( 22 , 12 ) "Appuyez sur return pour continuer ..." kpause$

UNTIL 1 < 0

REM --- Partie terminee ---

IF LST_Humain(0) = -1 THEN

PRINT TAB( 27 , 10 ) "Vous n'avez plus de carte."

PRINT TAB( 25 , 11 ) "VOUS AVEZ PERDU CETTE PARTIE !"

ELSE

PRINT TAB( 27 , 10 ) "Vous avez toutes les cartes."

PRINT TAB( 25 , 11 ) "VOUS AVEZ GAGNEE CETTE PARTIE !"

ENDIF

REM --- Bouclage du programme ---

PRINT ""

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

UNTIL kchoix$ = "C" OR kchoix$ = "c"

REM --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

REM --- DEFINITION DES FONCTIONS PERSONNALISEES ---

REM --- Calcul de la couleur des cartes ---

DEF FN_Couleur$( Q )

CASE Q DIV 13 OF

WHEN 0 : = "Coeur"

WHEN 1 : = "Carreau"

WHEN 2 : = "Trefle"

WHEN 3 : = "Pique"

ENDCASE

= "ERREUR DE COULEUR !"

REM --- Calcul de la valeur des cartes ---

DEF FN_Valeur$( Q )

CASE Q MOD 13 OF

WHEN 9 : = "VALET"

WHEN 10 : = "DAME"

WHEN 11 : = "ROI"

WHEN 12 : = "AS"

OTHERWISE : = STR$((Q MOD 13) + 2)

ENDCASE

= "ERREUR DE VALEUR !"

REM --- Affichage des cartes ---

DEF PROC_Affichage( Qtour , Qhumain , Qmachine )

CLS

PRINT TAB( 30 , 1 ) "JOUONS A LA BATAILLE."

PRINT TAB( 35 , 2 ) "Tour : "; Qtour

khumain$ = FN_Valeur$( Qhumain ) + " de " + FN_Couleur$( Qhumain )

kmachine$ = FN_Valeur$( Qmachine ) + " de " + FN_Couleur$( Qmachine )

PRINT TAB( 27 , 5 ) "HUMAIN"

PRINT TAB( 46 , 5 ) "MACHINE"

PRINT TAB( 30 - (LEN(khumain$) / 2) , 6 ) khumain$

PRINT TAB( 50 - (LEN(kmachine$) / 2) , 6 ) kmachine$

ENDPROC

REM --- Recherche du gagnant de la main en cour ---

DEF PROC_Analyse( Qhumain , Qmachine )

REM --- L'humain gagne ---

IF ( Qhumain MOD 13 ) > ( Qmachine MOD 13 ) THEN

PRINT TAB( 27 , 8 )  "Vous gagnez cette main."

PROC_Gagnant( "humain" , Qhumain , Qmachine )

ENDIF

REM --- L'humain perd ---

IF ( Qhumain MOD 13 ) < ( Qmachine MOD 13 ) THEN

PRINT TAB( 29 , 8 ) "La machine vous bat."

PROC_Gagnant( "machine" , Qmachine , Qhumain )

ENDIF

REM --- Bataille, valeurs des cartes egales  ---

IF ( Qhumain MOD 13 ) = ( Qmachine MOD 13 ) THEN

PRINT TAB( 35 , 8 ) "BATAILLE !"

  PROC_Bataille( Qhumain , Qmachine )

ENDIF

ENDPROC

REM --- Bataille - pose speciale ---

DEF PROC_Bataille( Qcarte1 , Qcarte2 )

REM --- Ajoute des cartes au talon de humain si besoin ---

IF LST_Humain( 0 ) = -1 THEN

ktirage = RND( 15 ) + 5

LST_Humain( 0 ) = LST_Machine( ktirage )

LST_Machine( ktirage ) = -1

ENDIF

IF LST_Humain( 1 ) = -1 THEN

ktirage = RND( 15 ) + 30

LST_Humain( 1 ) = LST_Machine( ktirage )

LST_Machine( ktirage ) = -1

ENDIF

REM --- Ajoute des cartes au talon de machine si besoin ---

IF LST_Machine( 0 ) = -1 THEN

ktirage = RND( 15 ) + 5

LST_Machine( 0 ) = LST_Humain( ktirage )

LST_Humain( ktirage ) = -1

ENDIF

IF LST_Machine( 1 ) = -1 THEN

ktirage = RND( 15 ) + 30

LST_Machine( 1 ) = LST_Humain( ktirage )

LST_Humain( ktirage ) = -1

ENDIF

REM --- Pose (affichage) des cartes cachees ---

FOR kcarte = 0 TO 51

IF LST_Reservees( kcarte ) = -1 THEN EXIT FOR

NEXT kcarte

LST_Reservees( kcarte ) = Qcarte1

LST_Reservees( kcarte + 1 ) = Qcarte2

khumain = LST_Humain( 0 ) : LST_Humain( 0 ) = -1 : LST_Reservees( kcarte + 2 ) = khumain

kmachine = LST_Machine( 0 ) : LST_Machine( 0 ) = -1 : LST_Reservees( kcarte + 3 ) = kmachine

khumain$ = FN_Valeur$( khumain ) + " de " + FN_Couleur$( khumain )

kmachine$ = FN_Valeur$( kmachine ) + " de " + FN_Couleur$( kmachine )

PROC_Talons

PRINT TAB( 0 , 15 ) "CARTES RETOURNNES : "; khumain$; " et "; kmachine$

ENDPROC

REM --- Ajout des cartes au talon du gagnant ---

DEF PROC_Gagnant( Qgagnant$ , Qcarte1 , Qcarte2 )

REM --- Ajout des cartes de la main au talon du gagnant ---

FOR kindex = 0 TO 51

IF Qgagnant$ = "humain" AND LST_Humain( kindex ) = -1 THEN

LST_Humain( kindex ) = Qcarte1

LST_Humain( kindex + 1 ) = Qcarte2

kitem = kindex + 2

EXIT FOR

ENDIF

IF Qgagnant$ = "machine" AND LST_Machine( kindex ) = -1 THEN

LST_Machine( kindex ) = Qcarte1

LST_Machine( kindex + 1 ) = Qcarte2

kitem = kindex + 2

EXIT FOR

ENDIF

NEXT kindex

REM --- Ajout eventuel des cartes de la reserve (bataille) ---

FOR kreservee = 0 TO 51

IF LST_Reservees( kreservee ) = -1 THEN EXIT FOR

IF Qgagnant$ = "humain" THEN LST_Humain( kitem + kreservee ) = LST_Reservees( kreservee )

IF Qgagnant$ = "machine" THEN LST_Machine( kitem + kreservee ) = LST_Reservees( kreservee )

LST_Reservees( kreservee ) = -1

NEXT kreservee

ENDPROC

REM ---  Melange initiale et aleatoire des talons de cartes ---

DEF PROC_Melange(Qdebut, Qtalon$)

REM --- Initialisation des cartes du talon virtuel ---

LOCAL ksuite( ) : DIM ksuite(25)

FOR kindex = 0 TO 25: ksuite(kindex) = kindex: NEXT kindex

REM' --- Melange d'un des deux talons de jeu ---

FOR kvaleur = 0 TO 25

REPEAT

kindex = RND(26) - 1

kcarte = ksuite(kindex)

UNTIL kcarte < 26

ksuite(kindex) = 100

kcarte = kindex + Qdebut

IF Qtalon$ = "humain" THEN LST_Humain(kvaleur) = kcarte ELSE LST_Machine(kvaleur) = kcarte

NEXT kvaleur

REM --- Rappelle de la procedure pour melanger les cartes noires ---

IF Qdebut = 0 THEN

IF Qtalon$ = "humain" THEN ktalon$ = "machine" ELSE ktalon$ = "humain"

PROC_Melange( 26   , ktalon$ )

ENDIF

ENDPROC

REM --- Actualisation des talons (deplacement des cartes posees) ---

DEF PROC_Talons

FOR kcarte = 0 TO 50

IF LST_Humain(kcarte) = -1 THEN SWAP LST_Humain(kcarte), LST_Humain(kcarte + 1)

IF LST_Machine(kcarte) = -1 THEN SWAP LST_Machine(kcarte), LST_Machine(kcarte + 1)

NEXT kcarte

ENDPROC

REM --- Programme : JFB ---

REM --- Fevrier 2026 ---

REM --- Fin ---

Pour mieux comprendre l'exemple en BBC BASIC.