CoddyRun
Ce projet de développement d’un jeu de Tic-Tac-Toe (morpion) montre comment un exercice simple peut devenir un terrain d’apprentissage riche. Le programme intègre une interface graphique, une détection de victoire, une IA basique et une boucle de rejouabilité, ce qui permet de revisiter plusieurs fondamentaux du développement.
Les points clés abordés sont les suivants :
- structuration du code,
- gestion des états,
- interaction utilisateur,
- conception d’une IA simple,
- mise en place d’un retour visuel clair.
Détection du gagnant : une logique essentielle La fonction de détection de victoire repose sur l’analyse des huit combinaisons gagnantes possibles.
La méthode consiste à :
- définir les alignements potentiels,
- extraire les indices concernés,
- comparer les valeurs du plateau.
Dès que trois symboles identiques sont alignés, la victoire est identifiée.
Cette logique est concise, lisible et facilement réutilisable.
Dessin du plateau : transformer la logique en interface
La fonction de dessin génère une grille lisible et moderne :
- fond uniforme,
- quadrillage clair,
- représentation graphique des X et O,
- rafraîchissement visuel après chaque action.
Ce rendu améliore la compréhension du joueur et renforce l’expérience globale.
Le bot “facile” : une IA simple mais pertinente
Le bot applique une stratégie en trois étapes :
- tenter de gagner si une opportunité existe,
- bloquer le joueur si nécessaire,
- jouer aléatoirement dans les autres cas.
Cette approche crée un adversaire accessible tout en introduisant une logique décisionnelle intéressante.
La boucle de jeu : une expérience fluide et continue
Le programme principal :
- initialise une nouvelle partie,
- attend les interactions du joueur,
- met à jour le plateau,
- vérifie les conditions de victoire,
- déclenche le coup du bot,
- affiche un écran de fin,
- permet de relancer une partie immédiatement.
Une structure simple, robuste et agréable à utiliser.
Conclusion
Ce projet démontre qu’un jeu classique peut devenir un excellent support pour travailler la logique algorithmique, la structuration du code, la gestion d’une interface graphique et l’intégration d’une IA basique.
Un exercice complet, formateur et facilement extensible.
Si tu veux une version plus courte, plus technique ou orientée recrutement, je peux t’en préparer une autre.
Programme :
// -----------------------------------------------------------
// FONCTION : y a-t-il un gagnant ?
// -----------------------------------------------------------
fonction gagnant(plateau)
lignes est un tableau
lignes ajoute "0,1,2"
lignes ajoute "3,4,5"
lignes ajoute "6,7,8"
lignes ajoute "0,3,6"
lignes ajoute "1,4,7"
lignes ajoute "2,5,8"
lignes ajoute "0,4,8"
lignes ajoute "2,4,6"
k est un nombre
pour k de 0 a 7
cases est un tableau
cases vaut decouper(lignes[k], ",")
x est un nombre
b est un nombre
d est un nombre
x vaut convertir_nombre(cases[0])
b vaut convertir_nombre(cases[1])
d vaut convertir_nombre(cases[2])
si plateau[x] <> "" et plateau[x] = plateau[b] et plateau[b] = plateau[d] alors
retourne plateau[x]
fin si
fin pour
retourne ""
fin fonction
// -----------------------------------------------------------
// FONCTION : dessiner le plateau (sans chiffres)
// -----------------------------------------------------------
fonction dessiner(plateau)
t est une toile
t vaut dimension(t, 300, 300)
t vaut remplir(t, "#1abc9c")
// --- Le quadrillage ---
ligne(t, 100, 0, 100, 300, "#159a80", 3)
ligne(t, 200, 0, 200, 300, "#159a80", 3)
ligne(t, 0, 100, 300, 100, "#159a80", 3)
ligne(t, 0, 200, 300, 200, "#159a80", 3)
c est un nombre
pour c de 0 a 8
marque est un texte
marque vaut plateau[c]
col est un nombre
lig est un nombre
col vaut c mod 3
lig vaut arrondi_inferieur(c / 3)
cx est un nombre
cy est un nombre
cx vaut col * 100
cy vaut lig * 100
si marque = "X" alors
ligne(t, cx + 25, cy + 25, cx + 75, cy + 75, "#3a3a3a", 10)
ligne(t, cx + 75, cy + 25, cx + 25, cy + 75, "#3a3a3a", 10)
sinon si marque = "O" alors
cercle(t, cx + 50, cy + 50, 28, "#faf3e0")
cercle(t, cx + 50, cy + 50, 18, "#1abc9c")
fin si
fin pour
affiche t
retourne t
fin fonction
// -----------------------------------------------------------
// FONCTION : créer l'écran de fin
// -----------------------------------------------------------
fonction afficher_fin(resultat)
t_fin est une toile
t_fin vaut dimension(t_fin, 300, 300)
t_fin vaut remplir(t_fin, "#1abc9c")
si resultat = "X" alors
label(t_fin, 25, 130, "?? TU AS GAGNÉ !", "#ffffff", 24)
sinon si resultat = "O" alors
label(t_fin, 20, 130, "?? LE BOT A GAGNÉ", "#ffffff", 22)
sinon
label(t_fin, 55, 130, "?? MATCH NUL", "#ffffff", 24)
fin si
label(t_fin, 50, 180, "Clique pour rejouer", "#0e6e5c", 16)
affiche t_fin
retourne t_fin
fin fonction
// -----------------------------------------------------------
// FONCTION : le bot facile (O)
// -----------------------------------------------------------
fonction coup_du_bot(plateau)
c est un nombre
libres est un tableau
pour c de 0 a 8
si plateau[c] = "" alors
libres ajoute c
fin si
fin pour
si longueur(libres) = 0 alors
retourne - 1
fin si
// Une chance sur deux (hasard 0 ou 1) de jouer intelligent, sinon il joue au hasard
chance est un nombre
chance vaut hasard(0, 1)
si chance = 1 alors
// 1. Essayer de gagner
pour c de 0 a 8
si plateau[c] = "" alors
plateau[c] vaut "O"
si gagnant(plateau) = "O" alors
plateau[c] vaut ""
retourne c
fin si
plateau[c] vaut ""
fin si
fin pour
// 2. Essayer de bloquer le joueur
pour c de 0 a 8
si plateau[c] = "" alors
plateau[c] vaut "X"
si gagnant(plateau) = "X" alors
plateau[c] vaut ""
retourne c
fin si
plateau[c] vaut ""
fin si
fin pour
fin si
// 3. Sinon, choix totalement aléatoire parmi les cases libres
index est un nombre
index vaut hasard(0, longueur(libres) - 1)
retourne libres[index]
fin fonction
// -----------------------------------------------------------
// PROGRAMME PRINCIPAL — la boucle du jeu infinie
// -----------------------------------------------------------
g est un tableau
maToile est une toile
toile_fin est une toile
fini est un booléen
coups est un nombre
x, y est un nombre
choix est un nombre
c, i, col, lig, pos est un nombre
vainqueur est un texte
// Boucle principale infinie pour rejouer
tant que vrai
// --- INITIALISATION D'UNE NOUVELLE PARTIE ---
vide g
pour i de 1 a 9
g ajoute ""
fin pour
fini vaut faux
coups vaut 0
vainqueur vaut ""
maToile vaut dessiner(g)
// --- BOUCLE D'UNE PARTIE ---
tant que non fini
cliquer maToile dans x, y
choix vaut -1
pour c de 0 a 8
col vaut c mod 3
lig vaut arrondi_inferieur(c / 3)
si clique(x, y, col * 100, lig * 100, 100, 100) alors
choix vaut c
fin si
fin pour
si choix = -1 alors
continue
fin si
si g[choix] <> "" alors
maToile vaut dessiner(g)
sinon
// 1. Le joueur joue
g[choix] vaut "X"
coups ajoute 1
maToile vaut dessiner(g)
si gagnant(g) = "X" alors
vainqueur vaut "X"
fini vaut vrai
sinon si coups = 9 alors
vainqueur vaut "NUL"
fini vaut vrai
sinon
// 2. Le bot joue
pos vaut coup_du_bot(g)
g[pos] vaut "O"
coups ajoute 1
maToile vaut dessiner(g)
si gagnant(g) = "O" alors
vainqueur vaut "O"
fini vaut vrai
sinon si coups = 9 alors
vainqueur vaut "NUL"
fini vaut vrai
fin si
fin si
fin si
fin tant que
// --- FIN DE PARTIE ---
toile_fin vaut afficher_fin(vainqueur)
cliquer toile_fin dans x, y
fin tant que
