Ce programme est une implémentation complète du jeu UNO, conçue dans l’environnement CoddyRun. Il combine logique de jeu, gestion d’interface, animations, et IA, pour offrir une expérience fluide et visuellement aboutie.
Voici une plongée détaillée dans son fonctionnement.
Configuration et variables globales
Le programme commence par définir les éléments fondamentaux du jeu :
Dimensions de la fenêtre :
LARG vaut 640
HAUT vaut 440
Couleurs des cartes (Rouge, Jaune, Vert, Bleu, Noir)
Valeurs des cartes : chiffres, +2, inversion, passe, joker, +4
Noms longs pour l’affichage :
- « Inversion », « Passe », « Joker », « +4 »
Plusieurs tableaux sont ensuite créés pour stocker :
- la pioche,
- la main du joueur,
- la main de l’IA,
- la défausse,
- les messages affichés à l’écran.
Ces structures constituent la base de données du jeu.
Création et mélange de la pioche
La procédure creerPioche() construit un paquet complet :
- 4 couleurs × 13 valeurs (avec duplication des cartes non-zéro, comme dans le vrai UNO)
- 4 jokers et 4 +4
Le mélange est effectué par 300 échanges aléatoires, garantissant une pioche imprévisible.
pa vaut hasard(0, nbCartes - 1)
Cette méthode simple mais efficace assure un brassage réaliste.
Mécaniques de base : piocher et vérifier la jouabilité
La fonction piocher(qui) ajoute une carte à la main du joueur ou de l’IA.
La fonction jouable(kc, kv) détermine si une carte peut être posée :
- même couleur
- même valeur
- joker ou +4 (toujours jouables)
si kv >= 13 alors retourne vrai
Cette logique respecte fidèlement les règles du UNO.
Interface graphique et rendu des cartes
La procédure carte() dessine chaque carte avec :
- un fond arrondi
- un symbole central
- des labels de valeur
- des couleurs dynamiques
Les cartes spéciales ont un rendu unique :
- +2, inversion, passe, joker, +4.
Le programme utilise des effets visuels : ombres, contours, ellipses, dégradés, pour un rendu moderne et lisible.
La procédure dessinerSurToile() assemble l’ensemble :
- interface du joueur
- interface de l’IA
- pioche
- défausse
- messages
- cartes jouables mises en évidence
Animations : pose et pioche
Deux animations enrichissent l’expérience :
animerPose()
Déplace une carte de la main vers la défausse avec interpolation.
animerPioche()
Anime la carte tirée depuis la pioche vers la main du joueur ou de l’IA.
Ces animations rendent le jeu plus vivant et agréable.
Intelligence artificielle
L’IA suit une stratégie simple mais efficace :
Si le joueur est en danger (=2 cartes)
- elle privilégie les cartes spéciales.
Sinon, elle joue une carte normale compatible.
- Si elle joue un joker ou +4, elle choisit la couleur où elle possède le plus de cartes.
cptC[iaCoul[tc]] vaut cptC[iaCoul[tc]] + 1
Elle gère aussi les effets :
- +2 ? le joueur pioche 2
- +4 ? le joueur pioche 4
- Passe / Inversion ? elle rejoue
L’IA peut enchaîner plusieurs tours si elle joue des cartes spéciales.
Boucle principale du jeu
La boucle :
- Affiche l’état du jeu
- Attend un clic du joueur
- Détermine si le joueur joue une carte, pioche, ou quitte
- Applique les règles
- Vérifie les conditions de victoire
Le programme gère :
- les erreurs de jeu
- les cartes jouables mises en surbrillance
- les messages dynamiques
- la fin de partie (victoire, défaite, abandon)
Écran de fin animé
Une animation finale affiche le résultat :
- « GAGNÉ ! Tu n'as plus de cartes ! »
- « PERDU ! L'IA n'a plus de cartes. »
Avec un fondu et une boîte stylisée, l’expérience se termine proprement.
Conclusion
Ce programme UNO est une réalisation complète et soignée :
- Logique fidèle au jeu original
- Interface graphique moderne
- Animations fluides
- IA cohérente et réactive
- Gestion robuste des interactions
Il constitue un excellent exemple de jeu CoddyRun mêlant programmation, design, et gameplay.
Programme :
@ CONFIGURATION ET VARIABLES
LARG est un nombre
LARG vaut 640
HAUT est un nombre
HAUT vaut 440
teintes est un tableau
teintes ajoute #ff4757
teintes ajoute #ffa502
teintes ajoute #2ed573
teintes ajoute #3742fa
teintes ajoute #2f3542
nomsCoul est un tableau
nomsCoul ajoute "Rouge"
nomsCoul ajoute "Jaune"
nomsCoul ajoute "Vert"
nomsCoul ajoute "Bleu"
nomsCoul ajoute "Noir"
nomsVal est un tableau
nomsVal ajoute "0"
nomsVal ajoute "1"
nomsVal ajoute "2"
nomsVal ajoute "3"
nomsVal ajoute "4"
nomsVal ajoute "5"
nomsVal ajoute "6"
nomsVal ajoute "7"
nomsVal ajoute "8"
nomsVal ajoute "9"
nomsVal ajoute "+2"
nomsVal ajoute "INV"
nomsVal ajoute "PAS"
nomsVal ajoute "JOK"
nomsVal ajoute "+4"
nomsLong est un tableau
nomsLong ajoute "0"
nomsLong ajoute "1"
nomsLong ajoute "2"
nomsLong ajoute "3"
nomsLong ajoute "4"
nomsLong ajoute "5"
nomsLong ajoute "6"
nomsLong ajoute "7"
nomsLong ajoute "8"
nomsLong ajoute "9"
nomsLong ajoute "+2"
nomsLong ajoute "Inversion"
nomsLong ajoute "Passe"
nomsLong ajoute "Joker"
nomsLong ajoute "+4"
piocheCoul est un tableau
piocheVal est un tableau
mainCoul est un tableau
mainVal est un tableau
iaCoul est un tableau
iaVal est un tableau
défausseCoul est un nombre
défausseVal est un nombre
msgTour est un texte
msgTour vaut "À toi ! Clique sur une carte dorée, ou sur la pioche."
msgFin est un texte
msgFin vaut ""
@ INITIALISATION DU JEU
procédure creerPioche()
vide piocheCoul
vide piocheVal
pc est un nombre
pv est un nombre
pour pc de 0 a 3
pour pv de 0 a 12
piocheCoul ajoute pc
piocheVal ajoute pv
si pv > 0 alors
piocheCoul ajoute pc
piocheVal ajoute pv
fin si
fin pour
fin pour
jj est un nombre
pour jj de 1 a 4
piocheCoul ajoute 4
piocheVal ajoute 13
piocheCoul ajoute 4
piocheVal ajoute 14
fin pour
nbCartes est un nombre
nbCartes vaut longueur(piocheCoul)
mel est un nombre
pour mel de 1 a 300
pa est un nombre
pa vaut hasard(0, nbCartes - 1)
pb est un nombre
pb vaut hasard(0, nbCartes - 1)
tmpC est un nombre
tmpC vaut piocheCoul[pa]
piocheCoul[pa] vaut piocheCoul[pb]
piocheCoul[pb] vaut tmpC
tmpV est un nombre
tmpV vaut piocheVal[pa]
piocheVal[pa] vaut piocheVal[pb]
piocheVal[pb] vaut tmpV
fin pour
fin procédure
@ MÉCANIQUES DE BASE
procédure piocher(qui)
si longueur(piocheCoul) = 0 alors
appelle creerPioche()
fin si
si longueur(piocheCoul) > 0 alors
idx est un nombre
idx vaut longueur(piocheCoul) - 1
pc est un nombre
pc vaut piocheCoul[idx]
pv est un nombre
pv vaut piocheVal[idx]
supprime piocheCoul idx
supprime piocheVal idx
si qui = 1 alors
mainCoul ajoute pc
mainVal ajoute pv
sinon
iaCoul ajoute pc
iaVal ajoute pv
fin si
fin si
fin procédure
fonction jouable(kc, kv)
si kv >= 13 alors
retourne vrai
fin si
si kc = défausseCoul alors
retourne vrai
fin si
si kv = défausseVal alors
retourne vrai
fin si
retourne faux
fin fonction
fonction espacementMain()
n est un nombre
n vaut longueur(mainCoul)
e est un nombre
e vaut 40
si n > 1 alors
si (n - 1) * 40 > LARG - 94 alors
e vaut (LARG - 94) / (n - 1)
fin si
fin si
retourne e
fin fonction
@ DESSIN ET INTERFACE
procédure carte(t, x, y, kc, kv, visible)
rectangle_arrondi(t, x + 4, y + 6, 54, 78, 10, rgba(0, 0, 0, 0.22))
rectangle_arrondi(t, x + 2, y + 3, 54, 78, 10, rgba(0, 0, 0, 0.28))
si visible alors
rectangle_arrondi(t, x, y, 54, 78, 10, #ffffff)
rectangle_arrondi(t, x + 3, y + 3, 48, 72, 8, teintes[kc])
contour(t, rgba(255, 255, 255, 0.35), 1)
ellipse(t, x + 27, y + 39, 21, 14, rgba(255, 255, 255, 0.9))
ellipse(t, x + 27, y + 39, 19, 12, teintes[kc])
ellipse(t, x + 27, y + 39, 17, 10, #ffffff)
si kv < 10 alors
label(t, x + 21, y + 46, nomsVal[kv], teintes[kc], 21)
label(t, x + 6, y + 16, nomsVal[kv], #ffffff, 11)
label(t, x + 42, y + 72, nomsVal[kv], #ffffff, 11)
sinon si kv = 10 alors
rectangle_arrondi(t, x + 17, y + 31, 10, 15, 3, teintes[kc])
contour(t, #ffffff, 1)
rectangle_arrondi(t, x + 26, y + 35, 10, 15, 3, #343a40)
contour(t, #ffffff, 1)
label(t, x + 6, y + 16, "+2", #ffffff, 11)
sinon si kv = 11 alors
ligne(t, x + 17, y + 34, x + 37, y + 34, teintes[kc], 3)
polygone(t, [x + 37, y + 34, x + 31, y + 30, x + 31, y + 38], teintes[kc])
ligne(t, x + 17, y + 44, x + 37, y + 44, teintes[kc], 3)
polygone(t, [x + 17, y + 44, x + 23, y + 40, x + 23, y + 48], teintes[kc])
label(t, x + 6, y + 16, "INV", #ffffff, 9)
sinon si kv = 12 alors
cercle(t, x + 27, y + 39, 12, teintes[kc])
cercle(t, x + 27, y + 39, 8, #ffffff)
ligne(t, x + 19, y + 31, x + 35, y + 47, teintes[kc], 3)
label(t, x + 6, y + 16, "X", #ffffff, 11)
sinon si kv = 13 alors
rectangle_arrondi(t, x + 16, y + 28, 10, 10, 3, #ff4757)
rectangle_arrondi(t, x + 28, y + 28, 10, 10, 3, #ffa502)
rectangle_arrondi(t, x + 16, y + 40, 10, 10, 3, #3742fa)
rectangle_arrondi(t, x + 28, y + 40, 10, 10, 3, #2ed573)
label(t, x + 6, y + 16, "JOKER", #ffffff, 8)
sinon
rectangle_arrondi(t, x + 16, y + 27, 9, 9, 3, #ff4757)
rectangle_arrondi(t, x + 26, y + 27, 9, 9, 3, #ffa502)
rectangle_arrondi(t, x + 16, y + 37, 9, 9, 3, #3742fa)
rectangle_arrondi(t, x + 26, y + 37, 9, 9, 3, #2ed573)
label(t, x + 19, y + 59, "+4", #2f3542, 13)
label(t, x + 6, y + 16, "+4", #ffffff, 11)
fin si
sinon
rectangle_arrondi(t, x, y, 54, 78, 10, #16213e)
contour(t, rgba(255, 255, 255, 0.18), 1)
rectangle_arrondi(t, x + 3, y + 3, 48, 72, 8, #0f3460)
ellipse(t, x + 27, y + 39, 19, 12, #e94560)
label(t, x + 14, y + 44, "UNO", #ffffff, 12)
fin si
fin procédure
procédure dessinerSurToile(t, msg, coulMsg, volCoul, volVal, volX, volY)
dimension(t, LARG, HAUT)
dégradé(t, [#20233a, #101322])
ellipse(t, 320, 220, 300, 185, rgba(88, 101, 242, 0.07))
ellipse(t, 320, 220, 220, 130, rgba(88, 101, 242, 0.09))
ellipse(t, 320, 220, 150, 88, rgba(255, 255, 255, 0.04))
rectangle(t, 0, 0, LARG, 46, rgba(0, 0, 0, 0.35))
ligne(t, 0, 46, LARG, 46, rgba(255, 255, 255, 0.08), 1)
rectangle_arrondi(t, 14, 10, 58, 26, 8, #e94560)
label(t, 25, 29, "UNO", #ffffff, 15)
label(t, 84, 28, "CoddyRun v3.3", #8b93b0, 11)
rectangle_arrondi(t, LARG - 86, 10, 68, 24, 12, rgba(233, 69, 96, 0.18))
contour(t, #e94560, 1)
label(t, LARG - 71, 27, "Quitter", #ff8fa3, 12)
nbIA est un nombre
nbIA vaut longueur(iaCoul)
rectangle_arrondi(t, 14, 56, 150, 30, 15, rgba(255, 255, 255, 0.07))
cercle(t, 30, 71, 10, #e94560)
label(t, 25, 76, "IA", #ffffff, 10)
label(t, 48, 76, convertir_texte(nbIA) + " cartes", #cbd5e1, 12)
si nbIA = 1 alors
rectangle_arrondi(t, 172, 60, 58, 22, 11, #e94560)
label(t, 182, 76, "UNO !", #ffffff, 12)
fin si
di est un nombre
pour di de 0 a nbIA - 1
ax est un nombre
ax vaut 240 + di * 18
si ax < LARG - 120 alors
rectangle_arrondi(t, ax, 58, 16, 24, 4, #0f3460)
contour(t, rgba(255, 255, 255, 0.2), 1)
fin si
fin pour
appelle carte(t, 206, 171, 4, 0, faux)
appelle carte(t, 208, 173, 4, 0, faux)
appelle carte(t, 210, 175, 4, 0, faux)
rectangle_arrondi(t, 192, 262, 92, 18, 9, rgba(0, 0, 0, 0.45))
label(t, 203, 275, "Pioche (" + convertir_texte(longueur(piocheCoul)) + ")", #a5b4fc, 11)
rectangle_arrondi(t, 344, 169, 66, 90, 12, rgba(255, 255, 255, 0.05))
contour(t, rgba(255, 255, 255, 0.14), 1)
appelle carte(t, 350, 175, défausseCoul, défausseVal, vrai)
rectangle_arrondi(t, 348, 262, 60, 18, 9, rgba(0, 0, 0, 0.45))
label(t, 356, 275, "Défausse", #a5b4fc, 11)
nbMain est un nombre
nbMain vaut longueur(mainCoul)
espM est un nombre
espM vaut espacementMain()
dj est un nombre
pour dj de 0 a nbMain - 1
jx est un nombre
jx vaut 20 + dj * espM
yc est un nombre
yc vaut HAUT - 105
si jouable(mainCoul[dj], mainVal[dj]) alors
yc vaut HAUT - 113
rectangle_arrondi(t, jx - 5, yc - 5, 64, 88, 12, rgba(255, 212, 59, 0.22))
rectangle_arrondi(t, jx - 2, yc - 2, 58, 82, 11, #ffd43b)
fin si
appelle carte(t, jx, yc, mainCoul[dj], mainVal[dj], vrai)
fin pour
rectangle_arrondi(t, LARG - 154, HAUT - 154, 142, 26, 13, rgba(255, 255, 255, 0.07))
label(t, LARG - 130, HAUT - 136, "Toi : " + convertir_texte(nbMain) + " cartes", #cbd5e1, 12)
si nbMain = 1 alors
rectangle_arrondi(t, LARG - 156, HAUT - 186, 58, 22, 11, #e94560)
label(t, LARG - 146, HAUT - 170, "UNO !", #ffffff, 12)
fin si
rectangle_arrondi(t, 12, HAUT - 154, LARG - 180, 26, 13, rgba(0, 0, 0, 0.5))
contour(t, rgba(255, 255, 255, 0.1), 1)
cercle(t, 28, HAUT - 141, 4, #ffd43b)
label(t, 40, HAUT - 136, msg, coulMsg, 13)
si volCoul >= 0 alors
appelle carte(t, volX, volY, volCoul, volVal, vrai)
fin si
fin procédure
@ ANIMATIONS DIRECTES
procédure animerPose(kc, kv, departX, departY, msg)
arrX est un nombre
arrX vaut 350
arrY est un nombre
arrY vaut 175
nbImg est un nombre
nbImg vaut 12
ka est un nombre
pour ka de 0 a nbImg
ta est un nombre
ta vaut ka / 12.0
vx est un nombre
vx vaut departX + (arrX - departX) * ta
vy est un nombre
vy vaut departY + (arrY - departY) * ta
img est une toile
appelle dessinerSurToile(img, msg, #ffffff, kc, kv, vx, vy)
affiche img
fin pour
fin procédure
procédure animerPioche(qui, msg)
depX est un nombre
depX vaut 210
depY est un nombre
depY vaut 175
arrX est un nombre
arrY est un nombre
si qui = 1 alors
arrX vaut LARG / 2
arrY vaut HAUT - 80
sinon
arrX vaut 100
arrY vaut 60
fin si
nbImg est un nombre
nbImg vaut 10
ka est un nombre
pour ka de 0 a nbImg
ta est un nombre
ta vaut ka / 10.0
vx est un nombre
vx vaut depX + (arrX - depX) * ta
vy est un nombre
vy vaut depY + (arrY - depY) * ta
img est une toile
appelle dessinerSurToile(img, msg, #ffffff, 4, 0, vx, vy)
affiche img
fin pour
fin procédure
@ LOGIQUE DE JEU ET IA
fonction choisirCouleurClic()
choixC est un nombre
choixC vaut -1
tant que choixC = -1
gc est une toile
appelle dessinerSurToile(gc, "Joker ! Clique sur la couleur de ton choix :", #ffd43b, -1, 0, 0, 0)
rectangle(gc, 0, 0, LARG, HAUT, rgba(10, 11, 20, 0.6))
rectangle_arrondi(gc, 158, 106, 324, 156, 16, #1c1f33)
contour(gc, rgba(255, 255, 255, 0.14), 1)
rectangle_arrondi(gc, 158, 106, 324, 8, 4, #e94560)
label(gc, 234, 144, "Choisis une couleur", #ffffff, 15)
rectangle_arrondi(gc, 182, 165, 60, 60, 14, teintes[0])
contour(gc, rgba(255, 255, 255, 0.3), 1)
rectangle_arrondi(gc, 254, 165, 60, 60, 14, teintes[1])
contour(gc, rgba(255, 255, 255, 0.3), 1)
rectangle_arrondi(gc, 326, 165, 60, 60, 14, teintes[2])
contour(gc, rgba(255, 255, 255, 0.3), 1)
rectangle_arrondi(gc, 398, 165, 60, 60, 14, teintes[3])
contour(gc, rgba(255, 255, 255, 0.3), 1)
label(gc, 196, 245, "Rouge", #cbd5e1, 10)
label(gc, 268, 245, "Jaune", #cbd5e1, 10)
label(gc, 344, 245, "Vert", #cbd5e1, 10)
label(gc, 414, 245, "Bleu", #cbd5e1, 10)
affiche gc
ccx est un nombre
ccy est un nombre
cliquer gc dans ccx, ccy
si ccy >= 165 et ccy < 225 alors
si ccx >= 182 et ccx < 242 alors choixC vaut 0 fin si
si ccx >= 254 et ccx < 314 alors choixC vaut 1 fin si
si ccx >= 326 et ccx < 386 alors choixC vaut 2 fin si
si ccx >= 398 et ccx < 458 alors choixC vaut 3 fin si
fin si
fin tant que
retourne choixC
fin fonction
procédure tourIA()
trouve est un nombre
trouve vaut -1
danger est un booléen
danger vaut faux
si longueur(mainCoul) <= 2 alors
danger vaut vrai
fin si
si danger alors
ta est un nombre
pour ta de 0 a longueur(iaCoul) - 1
si trouve = -1 et (iaVal[ta] >= 10) alors
si jouable(iaCoul[ta], iaVal[ta]) alors trouve vaut ta fin si
fin si
fin pour
fin si
si trouve = -1 alors
ta est un nombre
pour ta de 0 a longueur(iaCoul) - 1
si trouve = -1 et iaVal[ta] < 13 alors
si jouable(iaCoul[ta], iaVal[ta]) alors trouve vaut ta fin si
fin si
fin pour
fin si
si trouve = -1 alors
tb est un nombre
pour tb de 0 a longueur(iaCoul) - 1
si trouve = -1 alors
si jouable(iaCoul[tb], iaVal[tb]) alors trouve vaut tb fin si
fin si
fin pour
fin si
si trouve = -1 alors
appelle animerPioche(2, "L'IA piochait une carte...")
appelle piocher(2)
msgTour vaut "L'IA n'a rien pu jouer : elle a pioché. À toi !"
sinon
ic est un nombre
ic vaut iaCoul[trouve]
iv est un nombre
iv vaut iaVal[trouve]
supprime iaCoul trouve
supprime iaVal trouve
si iv >= 13 alors
cptC est un tableau
cptC ajoute 0
cptC ajoute 0
cptC ajoute 0
cptC ajoute 0
tc est un nombre
pour tc de 0 a longueur(iaCoul) - 1
si iaCoul[tc] <= 3 alors
cptC[iaCoul[tc]] vaut cptC[iaCoul[tc]] + 1
fin si
fin pour
meilleure est un nombre
meilleure vaut 0
td est un nombre
pour td de 1 a 3
si cptC[td] > cptC[meilleure] alors meilleure vaut td fin si
fin pour
si cptC[meilleure] = 0 alors
meilleure vaut hasard(0, 3)
fin si
ic vaut meilleure
fin si
appelle animerPose(ic, iv, 100, 20, "L'IA joue " + nomsCoul[ic] + " " + nomsLong[iv])
défausseCoul vaut ic
défausseVal vaut iv
msgTour vaut "L'IA joue " + nomsCoul[ic] + " " + nomsLong[iv] + ". À toi !"
si iv = 10 alors
appelle animerPioche(1, "+2 : tu pioches...")
appelle piocher(1)
appelle animerPioche(1, "+2 : tu pioches...")
appelle piocher(1)
msgTour vaut "L'IA joue un +2 : tu pioches 2 cartes et tu passes ton tour !"
fin si
si iv = 14 alors
pour k de 1 a 4
appelle animerPioche(1, "+4 : tu pioches...")
appelle piocher(1)
fin pour
msgTour vaut "L'IA joue un +4 " + nomsCoul[ic] + " : tu pioches 4 cartes et tu passes !"
fin si
si iv = 10 ou iv = 11 ou iv = 12 ou iv = 14 alors
si longueur(iaCoul) > 0 alors
appelle tourIA()
fin si
fin si
fin si
fin procédure
@ BOUCLE PRINCIPALE
appelle creerPioche()
dd est un nombre
pour dd de 1 a 7
appelle piocher(1)
appelle piocher(2)
fin pour
okDep est un booléen
okDep vaut faux
tant que non okDep
idep est un nombre
idep vaut longueur(piocheCoul) - 1
si piocheVal[idep] < 10 alors
défausseCoul vaut piocheCoul[idep]
défausseVal vaut piocheVal[idep]
okDep vaut vrai
fin si
supprime piocheCoul idep
supprime piocheVal idep
fin tant que
fini est un booléen
fini vaut faux
cx est un nombre
cy est un nombre
tant que non fini
gJeu est une toile
appelle dessinerSurToile(gJeu, msgTour, #ffffff, -1, 0, 0, 0)
affiche gJeu
cliquer gJeu dans cx, cy
choixCarte est un nombre
choixCarte vaut -1
espC est un nombre
espC vaut espacementMain()
dj est un nombre
pour dj de 0 a longueur(mainCoul) - 1
jx est un nombre
jx vaut 20 + dj * espC
si cx >= jx et cx < jx + 54 et cy >= HAUT - 116 et cy < HAUT - 27 alors
choixCarte vaut dj
fin si
fin pour
si choixCarte >= 0 alors
jc est un nombre
jc vaut mainCoul[choixCarte]
jv est un nombre
jv vaut mainVal[choixCarte]
si jouable(jc, jv) alors
posX est un nombre
posX vaut 20 + choixCarte * espC
supprime mainCoul choixCarte
supprime mainVal choixCarte
si jv >= 13 alors
jc vaut choisirCouleurClic()
fin si
appelle animerPose(jc, jv, posX, HAUT - 113, "Tu joues " + nomsCoul[jc] + " " + nomsLong[jv])
défausseCoul vaut jc
défausseVal vaut jv
si jv = 10 alors
pour k de 1 a 2
appelle animerPioche(2, "L'IA subit le +2...")
appelle piocher(2)
fin pour
fin si
si jv = 14 alors
pour k de 1 a 4
appelle animerPioche(2, "L'IA subit le +4...")
appelle piocher(2)
fin pour
fin si
si longueur(mainCoul) = 0 alors
msgFin vaut "GAGNÉ ! Tu n'as plus de cartes !"
fini vaut vrai
sinon
si jv = 10 alors
msgTour vaut "+2 ! L'IA pioche 2 cartes et passe son tour : rejoue !"
sinon si jv = 14 alors
msgTour vaut "+4 ! L'IA pioche 4 cartes et passe son tour : rejoue !"
sinon si jv = 11 ou jv = 12 alors
msgTour vaut "L'IA passe son tour : rejoue !"
sinon
appelle tourIA()
fin si
fin si
sinon
msgTour vaut "Impossible : " + nomsCoul[jc] + " " + nomsLong[jv] + " ne va pas sur " + nomsCoul[défausseCoul] + " " + nomsLong[défausseVal]
fin si
sinon si cx >= 206 et cx < 267 et cy >= 171 et cy < 256 alors
appelle animerPioche(1, "Tu piochais une carte...")
appelle piocher(1)
appelle tourIA()
sinon si cx >= LARG - 82 et cx < LARG - 14 et cy >= 10 et cy < 34 alors
msgFin vaut "Partie abandonnée."
fini vaut vrai
sinon
msgTour vaut "Clique sur une carte dorée (jouable), sur la pioche, ou sur Quitter."
fin si
si non fini alors
si longueur(iaCoul) = 0 alors
msgFin vaut "PERDU ! L'IA n'a plus de cartes."
fini vaut vrai
fin si
fin si
fin tant que
@ ÉCRAN DE FIN ANIMÉ
pour f de 0 a 15
gFin est une toile
appelle dessinerSurToile(gFin, "", #ffffff, -1, 0, 0, 0)
opac est un nombre
opac vaut limiter(f / 10.0, 0.0, 0.6)
rectangle(gFin, 0, 0, LARG, HAUT, rgba(10, 11, 20, opac))
yBox est un nombre
yBox vaut 138 + (15 - f) * 2
rectangle_arrondi(gFin, 140, yBox, 360, 144, 18, #1c1f33)
contour(gFin, rgba(255, 255, 255, 0.15), 1)
rectangle_arrondi(gFin, 140, yBox, 360, 8, 4, #e94560)
polygone(gFin, [320, yBox + 18, 324, yBox + 28, 335, yBox + 29, 327, yBox + 36, 329, yBox + 47, 320, yBox + 41, 311, yBox + 47, 313, yBox + 36, 305, yBox + 29, 316, yBox + 28], #ffd43b)
label(gFin, 168, yBox + 88, msgFin, #ffffff, 19)
affiche gFin
fin pour
CoddyRun
