Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
// ============================================================
// 1. REGLAGES ET DIMENSIONS
// ============================================================
nbCases est un nombre
nbCases vaut 8
cote est un nombre
cote est un nombre
cote vaut 50
xPlateau est un nombre
xPlateau vaut 25
yPlateau est un nombre
yPlateau vaut 65
largToile est un nombre
largToile vaut xPlateau * 2 + cote * nbCases
btnL est un nombre
btnL vaut 160
btnH est un nombre
btnH vaut 40
btnY est un nombre
btnY vaut yPlateau + cote * nbCases + 20
btnX est un nombre
btnX vaut largToile / 2 - btnL / 2
hautToile est un nombre
hautToile vaut btnY + btnH + 25
// ============================================================
// 2. COULEURS ET STYLE
// ============================================================
coulPion est un tableau
coulPion ajoute #000000
coulPion ajoute #1e293b
coulPion ajoute #f8fafc
libelles est un tableau
libelles ajoute "personne"
libelles ajoute "Noir"
libelles ajoute "Blanc"
// ============================================================
// 3. LES 8 DIRECTIONS (ligne, colonne)
// ============================================================
dirL est un tableau
dirC est un tableau
dirL ajoute -1
dirC ajoute -1
dirL ajoute -1
dirC ajoute 0
dirL ajoute -1
dirC ajoute 1
dirL ajoute 0
dirC ajoute -1
dirL ajoute 0
dirC ajoute 1
dirL ajoute 1
dirC ajoute -1
dirL ajoute 1
dirC ajoute 0
dirL ajoute 1
dirC ajoute 1
// ============================================================
// 4. ETAT DU JEU
// ============================================================
plateau est un tableau
jeu est une toile
joueurCourant est un nombre
joueurCourant vaut 1
dernierCoup est un nombre
dernierCoup vaut -1
message est un texte
message vaut "Clique sur une case pour jouer."
// ============================================================
// 5. LOGIQUE DU JEU (GAIN / COUPS POSSIBLES)
// ============================================================
fonction gainCoup(posTest, joueurTest)
gTotal est un nombre
gDir est un nombre
gLig est un nombre
gCol est un nombre
gLL est un nombre
gCC est un nombre
gNb est un nombre
gAdv est un nombre
gStop est un booleen
si plateau[posTest] <> 0 alors
retourne 0
fin si
gAdv vaut 3 - joueurTest
gTotal vaut 0
gLig vaut arrondi_inferieur(posTest / nbCases)
gCol vaut posTest mod nbCases
pour gDir de 0 à 7
gLL vaut gLig + dirL[gDir]
gCC vaut gCol + dirC[gDir]
gNb vaut 0
gStop vaut faux
tant que non gStop
si gLL < 0 ou gLL > 7 ou gCC < 0 ou gCC > 7 alors
gNb vaut 0
gStop vaut vrai
sinon si plateau[gLL * nbCases + gCC] = gAdv alors
gNb vaut gNb + 1
gLL vaut gLL + dirL[gDir]
gCC vaut gCC + dirC[gDir]
sinon si plateau[gLL * nbCases + gCC] = joueurTest alors
gStop vaut vrai
sinon
gNb vaut 0
gStop vaut vrai
fin si
fin tant que
gTotal vaut gTotal + gNb
fin pour
retourne gTotal
fin fonction
fonction peutJouer(joueurTeste)
pIdx est un nombre
pour pIdx de 0 à nbCases * nbCases - 1
si gainCoup(pIdx, joueurTeste) > 0 alors
retourne vrai
fin si
fin pour
retourne faux
fin fonction
fonction meilleurCoup(joueurIA)
mIdx est un nombre
mGain est un nombre
mNote est un nombre
mMeilleure est un nombre
mChoix est un nombre
mChoix vaut -1
mMeilleure vaut -9999
pour mIdx de 0 à nbCases * nbCases - 1
mGain vaut gainCoup(mIdx, joueurIA)
si mGain > 0 alors
mNote vaut hasard(1, 1000)
si mNote > mMeilleure alors
mMeilleure vaut mNote
mChoix vaut mIdx
fin si
fin si
fin pour
retourne mChoix
fin fonction
fonction nbPions(joueurCompte)
cIdx est un nombre
cTotal est un nombre
cTotal vaut 0
pour cIdx de 0 à nbCases * nbCases - 1
si plateau[cIdx] = joueurCompte alors
cTotal vaut cTotal + 1
fin si
fin pour
retourne cTotal
fin fonction
// ============================================================
// 6. DESSIN DU JEU (Interface graphique moderne & alignée)
// ============================================================
procédure dessinerJeu(ecran, avecFin)
dimension(ecran, largToile, hautToile)
effacer(ecran)
// Fond général de la fenêtre
remplir(ecran, #0f172a)
dTxt est un texte
dIdx est un nombre
dLig est un nombre
dCol est un nombre
dCx est un nombre
dCy est un nombre
dVal est un nombre
dNoir est un nombre
dBlanc est un nombre
rPion est un nombre
rPion vaut cote / 2 - 6
dNoir vaut nbPions(1)
dBlanc vaut nbPions(2)
// ---- En-tête / Tableau de score ----
rectangle_arrondi(ecran, xPlateau, 12, largToile - xPlateau * 2, 42, 10, #1e293b)
// Score Noir (Alignement vertical parfait centré sur y = 33)
cercle(ecran, xPlateau + 25, 33, 11, #334155)
cercle(ecran, xPlateau + 25, 33, 9, #1e293b)
cercle(ecran, xPlateau + 25, 33, 7, #0f172a)
label(ecran, xPlateau + 45, 37, "Noir : " + convertir_texte(dNoir), #f8fafc, 12)
// Titre central (parfaitement aligné horizontalement et verticalement)
label(ecran, largToile / 2 - label_largeur("REVERSI", 14) / 2, 37, "REVERSI", #38bdf8, 14)
// Score Blanc (Alignement à droite propre)
dTxt vaut "Blanc : " + convertir_texte(dBlanc)
label(ecran, largToile - xPlateau - 45 - label_largeur(dTxt, 12), 37, dTxt, #f8fafc, 12)
cercle(ecran, largToile - xPlateau - 25, 33, 9, #ffffff)
// ---- Ombre et contour du plateau ----
rectangle_arrondi(ecran, xPlateau - 4, yPlateau - 4, cote * nbCases + 8, cote * nbCases + 8, 12, #0284c7)
rectangle_arrondi(ecran, xPlateau - 2, yPlateau - 2, cote * nbCases + 4, cote * nbCases + 4, 10, #0f172a)
// ---- Damier moderne ----
pour dLig de 0 à nbCases - 1
pour dCol de 0 à nbCases - 1
dCx vaut xPlateau + dCol * cote
dCy vaut yPlateau + dLig * cote
si (dLig + dCol) mod 2 = 0 alors
rectangle(ecran, dCx, dCy, cote, cote, #047857)
sinon
rectangle(ecran, dCx, dCy, cote, cote, #065f46)
fin si
fin pour
fin pour
// ---- Pions et aides visuelles ----
pour dIdx de 0 à nbCases * nbCases - 1
dLig vaut arrondi_inferieur(dIdx / nbCases)
dCol vaut dIdx mod nbCases
dCx vaut xPlateau + dCol * cote + cote / 2
dCy vaut yPlateau + dLig * cote + cote / 2
dVal vaut plateau[dIdx]
si dVal = 0 alors
si joueurCourant = 1 et non avecFin alors
si gainCoup(dIdx, 1) > 0 alors
cercle(ecran, dCx, dCy, 6, rgba(16, 185, 129, 0.6))
fin si
fin si
sinon
si dIdx = dernierCoup alors
cercle(ecran, dCx, dCy, rPion + 4, #fbbf24)
fin si
cercle(ecran, dCx, dCy + 2, rPion, rgba(0, 0, 0, 0.4))
cercle(ecran, dCx, dCy, rPion, coulPion[dVal])
si dVal = 1 alors
cercle(ecran, dCx - 4, dCy - 4, 4, #475569)
sinon
cercle(ecran, dCx - 4, dCy - 4, 4, #ffffff)
fin si
fin si
fin pour
// ---- Message d'état (Centré proprement) ----
label(ecran, largToile / 2 - label_largeur(message, 12) / 2, btnY - 18, message, #e2e8f0, 12)
// ---- Bouton Nouvelle Partie (Texte parfaitement centré dans le bouton) ----
rectangle_arrondi(ecran, btnX, btnY, btnL, btnH, 8, #0284c7)
dTxt vaut "Nouvelle partie"
label(ecran, btnX + btnL / 2 - label_largeur(dTxt, 13) / 2, btnY + 25, dTxt, #ffffff, 13)
// ---- Bannière de fin de partie ----
si avecFin alors
rectangle_arrondi(ecran, xPlateau + 10, hautToile / 2 - 50, largToile - (xPlateau + 10) * 2, 100, 12, rgba(15, 23, 42, 0.95))
contour(ecran, #38bdf8, 2)
rectangle_arrondi(ecran, xPlateau + 10, hautToile / 2 - 50, largToile - (xPlateau + 10) * 2, 100, 12, rgba(15, 23, 42, 0))
contour(ecran, #0, 0)
dTxt vaut "ÉGALITÉ !"
si dNoir > dBlanc alors
dTxt vaut "VICTOIRE !"
fin si
si dBlanc > dNoir alors
dTxt vaut "L'ORDINATEUR GAGNE"
fin si
label(ecran, largToile / 2 - label_largeur(dTxt, 16) / 2, hautToile / 2 - 12, dTxt, #38bdf8, 16)
dTxt vaut convertir_texte(dNoir + dBlanc) + " pions au total : " + convertir_texte(dNoir) + " - " + convertir_texte(dBlanc)
label(ecran, largToile / 2 - label_largeur(dTxt, 11) / 2, hautToile / 2 + 18, dTxt, #cbd5e1, 11)
fin si
fin procédure
procédure dessiner(finVue)
appelle dessinerJeu(jeu, finVue)
affiche jeu
fin procédure
// ============================================================
// 7. BOUCLE PRINCIPALE DU JEU
// ============================================================
partieEnCours est un booleen
partieEnCours vaut vrai
tant que partieEnCours
vide plateau
pour idx de 0 à nbCases * nbCases - 1
plateau ajoute 0
fin pour
plateau[27] vaut 2
plateau[28] vaut 1
plateau[35] vaut 1
plateau[36] vaut 2
joueurCourant vaut 1
dernierCoup vaut -1
finPartie est un booleen
finPartie vaut faux
nouvelleDemande est un booleen
nouvelleDemande vaut faux
message vaut "À toi de jouer (pions noirs)."
tant que non finPartie et non nouvelleDemande
appelle dessiner(faux)
posJoue est un nombre
posJoue vaut -1
si non peutJouer(1) et non peutJouer(2) alors
finPartie vaut vrai
sinon si non peutJouer(joueurCourant) alors
message vaut libelles[joueurCourant] + " passe son tour."
joueurCourant vaut 3 - joueurCourant
sinon si joueurCourant = 1 alors
clicX, clicY est un nombre
cliquer jeu dans clicX, clicY
si clique(clicX, clicY, btnX, btnY, btnL, btnH) alors
nouvelleDemande vaut vrai
sinon si clique(clicX, clicY, xPlateau, yPlateau, cote * nbCases, cote * nbCases) alors
colClic est un nombre
ligClic est un nombre
colClic vaut limiter(arrondi_inferieur((clicX - xPlateau) / cote), 0, nbCases - 1)
ligClic vaut limiter(arrondi_inferieur((clicY - yPlateau) / cote), 0, nbCases - 1)
posJoue vaut ligClic * nbCases + colClic
si gainCoup(posJoue, 1) = 0 alors
message vaut "Coup invalide, choisis une case avec un point vert."
posJoue vaut -1
fin si
sinon
message vaut "Clique sur le plateau ou le bouton."
fin si
sinon
message vaut "L'ordinateur réfléchit..."
appelle dessiner(faux)
pause 600
posJoue vaut meilleurCoup(2)
fin si
si posJoue >= 0 alors
plateau[posJoue] vaut joueurCourant
fLig est un nombre
fCol est un nombre
fLig vaut arrondi_inferieur(posJoue / nbCases)
fCol vaut posJoue mod nbCases
fAdv est un nombre
fAdv vaut 3 - joueurCourant
totalRetourne est un nombre
totalRetourne vaut 0
pour fD de 0 à 7
fLL est un nombre
fCC est un nombre
fLL vaut fLig + dirL[fD]
fCC vaut fCol + dirC[fD]
fNb est un nombre
fNb vaut 0
fStop est un booleen
fStop vaut faux
tant que non fStop
si fLL < 0 ou fLL > 7 ou fCC < 0 ou fCC > 7 alors
fNb vaut 0
fStop vaut vrai
sinon si plateau[fLL * nbCases + fCC] = fAdv alors
fNb vaut fNb + 1
fLL vaut fLL + dirL[fD]
fCC vaut fCC + dirC[fD]
sinon si plateau[fLL * nbCases + fCC] = joueurCourant alors
fStop vaut vrai
sinon
fNb vaut 0
fStop vaut vrai
fin si
fin tant que
si fNb > 0 alors
pour fPas de 1 à fNb
fLL vaut fLig + dirL[fD] * fPas
fCC vaut fCol + dirC[fD] * fPas
plateau[fLL * nbCases + fCC] vaut joueurCourant
fin pour
totalRetourne vaut totalRetourne + fNb
fin si
fin pour
dernierCoup vaut posJoue
si joueurCourant = 1 alors
message vaut "Bien joué ! " + convertir_texte(totalRetourne) + " pion(s) retourné(s)."
sinon
message vaut "L'ordinateur a joué (" + convertir_texte(totalRetourne) + " pris)."
fin si
joueurCourant vaut 3 - joueurCourant
fin si
fin tant que
si finPartie alors
noirFinal est un nombre
blancFinal est un nombre
noirFinal vaut nbPions(1)
blancFinal vaut nbPions(2)
message vaut "Partie terminée !"
appelle dessiner(vrai)
rejouer est un nombre
rejouer vaut 0
choisir ["Rejouer une partie", "Quitter"] dans rejouer
si rejouer = 2 alors
partieEnCours vaut faux
fin si
fin si
fin tant que