Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
@ CONFIGURATION
ecran est une toile
dimension(ecran, 640, 550)
MAXSLOT est un nombre
MAXSLOT vaut 60
MAXSYM est un nombre
MAXSYM vaut 8
NB_NIVEAUX est un nombre
NB_NIVEAUX vaut 16
// les chiffres en allumettes : un bit par baton
// a 1 haut, b 2 haut droite, c 4 bas droite, d 8 bas, e 16 bas gauche, f 32 haut gauche, g 64 milieu
MASQUES est un tableau
MASQUES vaut [63, 6, 91, 79, 102, 109, 125, 7, 127, 111]
PUIS est un tableau
PUIS vaut [1, 2, 4, 8, 16, 32, 64]
@ LES NIVEAUX
// type : "<" plus petit que, ">" plus grand que, "M" le plus grand possible,
// "m" le plus petit possible, "e" egalite a corriger
nivTexte est un tableau
nivTexte vaut ["731", "737", "467", "961", "6+8=0", "5+3=3", "857", "767", "2+4=9", "9-0=5", "938", "9+3=17", "3+9=15", "551", "962", "8-1=3"]
nivType est un tableau
nivType vaut ["<", ">", "<", ">", "e", "e", "M", "m", "e", "e", "M", "e", "e", "M", "m", "e"]
nivParam est un tableau
nivParam vaut [731, 737, 467, 961, 0, 0, 997, 187, 0, 0, 999, 0, 0, 941, 282, 0]
nivCoups est un tableau
nivCoups vaut [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2]
nivNbSol est un tableau
nivNbSol vaut [3, 2, 1, 1, 1, 1, 7, 4, 1, 1, 11, 1, 1, 11, 31, 1]
// l'indice : symbole, baton de depart, symbole, baton d'arrivee (pour chaque allumette)
nivIndice est un tableau
nivIndice vaut ["0,0,2,0", "1,1,1,5", "1,6,1,1", "1,4,1,1", "1,1,0,1", "1,1,0,4", "0,4,1,1", "0,0,1,1", "4,1,4,4", "0,1,1,1", "2,4,1,5", "5,0,0,4", "5,2,5,1,5,5,5,4", "1,0,0,1,1,3,1,1", "0,2,0,4,0,5,1,1", "0,4,2,0,4,2,4,4"]
@ LES SYMBOLES ET LES PLACES D'ALLUMETTES
// symType : "D" chiffre, "O" plus ou moins, "E" egal
symType est un tableau
symX est un tableau
pour ki de 0 à MAXSYM - 1
symType ajoute "D"
symX ajoute 0
fin pour
nbSym est un nombre
// chaque place : son symbole, son numero de baton, ses extremites, allumette ou non
slSym, slSeg, slX1, slY1, slX2, slY2 est un tableau
slOn, slDebut est un tableau
pour ki de 0 à MAXSLOT - 1
slSym ajoute 0
slSeg ajoute 0
slX1 ajoute 0
slY1 ajoute 0
slX2 ajoute 0
slY2 ajoute 0
slOn ajoute faux
slDebut ajoute faux
fin pour
nbSlot est un nombre
echelle est un nombre
// l'historique des deplacements (pour annuler)
histDe, histVers est un tableau
pour ki de 0 à 19
histDe ajoute 0
histVers ajoute 0
fin pour
nbHist est un nombre
@ LA PARTIE
// etat : 0 accueil, 1 jeu, 2 reussi, 3 choix du niveau, 9 preparation
etat est un nombre
etat vaut 0
appActif est un booléen
appActif vaut vrai
tic est un nombre
niveau, choisi, deplaces est un nombre
choisi vaut -1
indiceVu est un booléen
indiceEtape est un nombre
indiceEtape vaut -1
msgTxt est un texte
msgT est un nombre
coulMsg est un texte
coulMsg vaut #37474F
resultat est un texte
etoiles est un nombre
meilleur est un tableau
pour ki de 0 à NB_NIVEAUX - 1
meilleur ajoute 0
essayer
meilleur[ki] vaut parametre('allumettes', 'n' + convertir_texte(ki + 1))
attraper
meilleur[ki] vaut 0
fin essayer
fin pour
ordres, ordX, ordY est un tableau
pour ki de 0 à 31
ordres ajoute 0
ordX ajoute 0
ordY ajoute 0
fin pour
teteO, queueO est un nombre
action, sourisX, sourisY est un nombre
@ LE TEXTE
procédure centrer(txt, xMil, yTxt, coul, taillePolice)
label(ecran, xMil - label_largeur(txt, taillePolice) / 2, yTxt, txt, coul, taillePolice)
fin procédure
procédure bouton(x, y, l, hb, txt, fond, coulTxt, taillePolice)
rectangle_arrondi(ecran, x, y + 3, l, hb, 10, rgba(0, 0, 0, 0.2))
rectangle_arrondi(ecran, x, y, l, hb, 10, fond)
appelle centrer(txt, x + l / 2, y + hb / 2 + taillePolice * 0.38, coulTxt, taillePolice)
fin procédure
procédure montrerMsg(txt, coul)
msgTxt vaut txt
coulMsg vaut coul
msgT vaut 60
fin procédure
@ CONSTRUIRE UN NIVEAU
procédure ajouterSlot(s, seg, x1, y1, x2, y2, allume)
slSym[nbSlot] vaut s
slSeg[nbSlot] vaut seg
slX1[nbSlot] vaut x1
slY1[nbSlot] vaut y1
slX2[nbSlot] vaut x2
slY2[nbSlot] vaut y2
slOn[nbSlot] vaut allume
slDebut[nbSlot] vaut allume
nbSlot vaut nbSlot + 1
fin procédure
// le baton seg est-il present dans le masque m ?
fonction aBaton(m, seg)
si arrondi_inferieur(m / PUIS[seg]) mod 2 = 1 alors
retourne vrai
fin si
retourne faux
fin fonction
procédure chargerNiveau(n)
niveau vaut n
txt est un texte
txt vaut nivTexte[n]
nbSym vaut longueur(txt)
// la largeur totale, pour tout centrer
total est un nombre
total vaut 0
ks est un nombre
pour ks de 0 à nbSym - 1
ch est un texte
ch vaut copier(txt, ks + 1, 1)
si ch = "+" ou ch = "-" alors
symType[ks] vaut "O"
sinon si ch = "=" alors
symType[ks] vaut "E"
sinon
symType[ks] vaut "D"
fin si
si symType[ks] = "D" alors
total vaut total + 120
sinon
total vaut total + 105
fin si
fin pour
echelle vaut minimum(1, 600 / total)
LB est un nombre
LB vaut 84 * echelle
x est un nombre
x vaut 320 - total * echelle / 2
y0 est un nombre
y0 vaut 268 - LB
nbSlot vaut 0
pour ks de 0 à nbSym - 1
ch est un texte
ch vaut copier(txt, ks + 1, 1)
symX[ks] vaut x
si symType[ks] = "D" alors
m est un nombre
m vaut MASQUES[convertir_nombre(ch)]
xg est un nombre
xg vaut x + 18 * echelle
appelle ajouterSlot(ks, 0, xg, y0, xg + LB, y0, aBaton(m, 0))
appelle ajouterSlot(ks, 1, xg + LB, y0, xg + LB, y0 + LB, aBaton(m, 1))
appelle ajouterSlot(ks, 2, xg + LB, y0 + LB, xg + LB, y0 + 2 * LB, aBaton(m, 2))
appelle ajouterSlot(ks, 3, xg, y0 + 2 * LB, xg + LB, y0 + 2 * LB, aBaton(m, 3))
appelle ajouterSlot(ks, 4, xg, y0 + LB, xg, y0 + 2 * LB, aBaton(m, 4))
appelle ajouterSlot(ks, 5, xg, y0, xg, y0 + LB, aBaton(m, 5))
appelle ajouterSlot(ks, 6, xg, y0 + LB, xg + LB, y0 + LB, aBaton(m, 6))
x vaut x + 120 * echelle
sinon si symType[ks] = "O" alors
xg est un nombre
xg vaut x + 10 * echelle
appelle ajouterSlot(ks, 0, xg, y0 + LB, xg + LB, y0 + LB, vrai)
si ch = "+" alors
appelle ajouterSlot(ks, 1, xg + LB / 2, y0 + LB / 2, xg + LB / 2, y0 + LB * 1.5, vrai)
sinon
appelle ajouterSlot(ks, 1, xg + LB / 2, y0 + LB / 2, xg + LB / 2, y0 + LB * 1.5, faux)
fin si
x vaut x + 105 * echelle
sinon
xg est un nombre
xg vaut x + 10 * echelle
appelle ajouterSlot(ks, 0, xg, y0 + LB - 18 * echelle, xg + LB, y0 + LB - 18 * echelle, vrai)
appelle ajouterSlot(ks, 1, xg, y0 + LB + 18 * echelle, xg + LB, y0 + LB + 18 * echelle, vrai)
x vaut x + 105 * echelle
fin si
fin pour
choisi vaut -1
deplaces vaut 0
nbHist vaut 0
indiceVu vaut faux
indiceEtape vaut -1
msgT vaut 0
etat vaut 1
fin procédure
@ LIRE CE QUI EST ECRIT AVEC LES ALLUMETTES
fonction masqueSymbole(s)
m est un nombre
m vaut 0
kl est un nombre
pour kl de 0 à nbSlot - 1
si slSym[kl] = s et slOn[kl] alors
m vaut m + PUIS[slSeg[kl]]
fin si
fin pour
retourne m
fin fonction
// le texte forme (avec "?" pour un symbole qui ne veut rien dire)
fonction texteForme()
txt est un texte
txt vaut ""
ks est un nombre
pour ks de 0 à nbSym - 1
m est un nombre
m vaut masqueSymbole(ks)
car est un texte
car vaut "?"
si symType[ks] = "D" alors
kd est un nombre
pour kd de 0 à 9
si MASQUES[kd] = m alors
car vaut convertir_texte(kd)
fin si
fin pour
sinon si symType[ks] = "O" alors
si m = 1 alors
car vaut "-"
sinon si m = 3 alors
car vaut "+"
fin si
sinon
si m = 3 alors
car vaut "="
fin si
fin si
txt vaut txt + car
fin pour
retourne txt
fin fonction
// un nombre ecrit ne doit pas commencer par 0 (sauf 0 tout seul)
fonction nombreCorrect(nb)
si longueur(nb) = 0 alors
retourne faux
fin si
si longueur(nb) > 1 et copier(nb, 1, 1) = "0" alors
retourne faux
fin si
retourne vrai
fin fonction
// le defi est-il reussi ?
fonction defiReussi()
txt est un texte
txt vaut texteForme()
si contient(txt, "?") alors
retourne faux
fin si
typ est un texte
typ vaut nivType[niveau]
si typ = "e" alors
// une egalite : nombre, signe, nombre, egal, nombre
g est un texte
g vaut ""
d est un texte
d vaut ""
r est un texte
r vaut ""
op est un texte
op vaut ""
partie est un nombre
partie vaut 0
kc est un nombre
pour kc de 1 à longueur(txt)
ch est un texte
ch vaut copier(txt, kc, 1)
si ch = "+" ou ch = "-" alors
op vaut ch
partie vaut 1
sinon si ch = "=" alors
partie vaut 2
sinon si partie = 0 alors
g vaut g + ch
sinon si partie = 1 alors
d vaut d + ch
sinon
r vaut r + ch
fin si
fin pour
si non nombreCorrect(g) ou non nombreCorrect(d) ou non nombreCorrect(r) alors
retourne faux
fin si
calc est un nombre
si op = "+" alors
calc vaut convertir_nombre(g) + convertir_nombre(d)
sinon
calc vaut convertir_nombre(g) - convertir_nombre(d)
fin si
si calc = convertir_nombre(r) alors
retourne vrai
fin si
retourne faux
fin si
si non nombreCorrect(txt) alors
retourne faux
fin si
v est un nombre
v vaut convertir_nombre(txt)
ok est un booléen
ok vaut faux
si typ = "<" alors
si v < nivParam[niveau] alors
ok vaut vrai
fin si
sinon si typ = ">" alors
si v > nivParam[niveau] alors
ok vaut vrai
fin si
sinon si v = nivParam[niveau] alors
ok vaut vrai
fin si
retourne ok
fin fonction
@ DEPLACER LES ALLUMETTES
fonction compterDeplaces()
n est un nombre
n vaut 0
kl est un nombre
pour kl de 0 à nbSlot - 1
si slOn[kl] <> slDebut[kl] alors
n vaut n + 1
fin si
fin pour
retourne n / 2
fin fonction
// la place la plus proche du point clique (-1 si trop loin)
fonction slotSous(x, y)
meil est un nombre
meil vaut -1
dMin est un nombre
dMin vaut 16 * echelle + 6
kl est un nombre
pour kl de 0 à nbSlot - 1
// la distance du point au baton
vx est un nombre
vx vaut slX2[kl] - slX1[kl]
vy est un nombre
vy vaut slY2[kl] - slY1[kl]
t est un nombre
t vaut limiter(((x - slX1[kl]) * vx + (y - slY1[kl]) * vy) / (vx * vx + vy * vy), 0, 1)
px est un nombre
px vaut slX1[kl] + vx * t - x
py est un nombre
py vaut slY1[kl] + vy * t - y
d est un nombre
d vaut racine(px * px + py * py)
si d < dMin alors
dMin vaut d
meil vaut kl
fin si
fin pour
retourne meil
fin fonction
procédure verifier()
deplaces vaut compterDeplaces()
// reussi avec au plus le nombre d'allumettes permis ?
si deplaces >= 1 et defiReussi() alors
resultat vaut texteForme()
etoiles vaut 3
si indiceVu alors
etoiles vaut 2
fin si
si etoiles > meilleur[niveau] alors
meilleur[niveau] vaut etoiles
parametre('allumettes', 'n' + convertir_texte(niveau + 1), etoiles)
fin si
etat vaut 2
sinon si deplaces = nivCoups[niveau] alors
si contient(texteForme(), "?") alors
appelle montrerMsg("Ces allumettes ne forment pas des chiffres… Annule (A) et réessaie", #C62828)
sinon
appelle montrerMsg(texteForme() + " : ce n'est pas encore ça ! Annule (A) et réessaie", #C62828)
fin si
fin si
fin procédure
procédure cliquerSlot(k)
si choisi < 0 alors
si slOn[k] alors
choisi vaut k
fin si
sinon si k = choisi alors
choisi vaut -1
sinon si slOn[k] alors
choisi vaut k
sinon
// on pose l'allumette ici
slOn[choisi] vaut faux
slOn[k] vaut vrai
si compterDeplaces() > nivCoups[niveau] alors
// trop d'allumettes deplacees : on refuse
slOn[choisi] vaut vrai
slOn[k] vaut faux
appelle montrerMsg("Tu ne peux déplacer que " + convertir_texte(nivCoups[niveau]) + " allumette" + sialors(nivCoups[niveau] > 1, "s", "") + " !", #C62828)
sinon
si nbHist < 20 alors
histDe[nbHist] vaut choisi
histVers[nbHist] vaut k
nbHist vaut nbHist + 1
fin si
choisi vaut -1
si indiceEtape >= 0 alors
indiceEtape vaut indiceEtape + 1
si indiceEtape >= nivCoups[niveau] alors
indiceEtape vaut -1
fin si
fin si
appelle verifier()
fin si
fin si
fin procédure
procédure annuler()
si nbHist > 0 alors
nbHist vaut nbHist - 1
slOn[histVers[nbHist]] vaut faux
slOn[histDe[nbHist]] vaut vrai
choisi vaut -1
deplaces vaut compterDeplaces()
msgT vaut 0
fin si
fin procédure
// la place qui correspond a un symbole et un baton
fonction slotDe(s, seg)
trouve est un nombre
trouve vaut -1
kl est un nombre
pour kl de 0 à nbSlot - 1
si slSym[kl] = s et slSeg[kl] = seg alors
trouve vaut kl
fin si
fin pour
retourne trouve
fin fonction
fonction indiceNombre(rang)
morceaux est un tableau
morceaux vaut decouper(nivIndice[niveau], ",")
retourne convertir_nombre(morceaux[rang])
fin fonction
procédure donnerIndice()
appelle chargerNiveau(niveau)
indiceVu vaut vrai
indiceEtape vaut 0
appelle montrerMsg("Indice : déplace l'allumette qui brille vers la place jaune", #E65100)
fin procédure
@ DESSIN
// une allumette entre deux points (la tete rouge en haut ou a gauche)
procédure allumette(x1, y1, x2, y2, levee, brille)
EPA est un nombre
EPA vaut 11 * echelle
ox est un nombre
ox vaut 0
oy est un nombre
oy vaut 0
si levee alors
ox vaut -3
oy vaut -6
fin si
// un petit espace aux extremites pour bien voir chaque allumette
dx est un nombre
dx vaut x2 - x1
dy est un nombre
dy vaut y2 - y1
lg est un nombre
lg vaut racine(dx * dx + dy * dy)
ux est un nombre
ux vaut dx / lg
uy est un nombre
uy vaut dy / lg
ax est un nombre
ax vaut x1 + ux * 5 * echelle + ox
ay est un nombre
ay vaut y1 + uy * 5 * echelle + oy
bx est un nombre
bx vaut x2 - ux * 5 * echelle + ox
by est un nombre
by vaut y2 - uy * 5 * echelle + oy
si brille alors
ligne(ecran, ax, ay, bx, by, rgba(255, 193, 7, 0.55), EPA * 2.4)
fin si
// l'ombre puis le bois
ligne(ecran, ax + 3, ay + 4, bx + 3, by + 4, rgba(0, 0, 0, sialors(levee, 0.25, 0.14)), EPA)
ligne(ecran, ax, ay, bx, by, #D9A65A, EPA)
ligne(ecran, ax - uy * EPA * 0.2, ay + ux * EPA * 0.2, bx - uy * EPA * 0.2, by + ux * EPA * 0.2, #EBC587, EPA * 0.45)
// la tete rouge
cercle(ecran, ax + ux * EPA * 0.4, ay + uy * EPA * 0.4, EPA * 0.82, #B71C1C)
cercle(ecran, ax + ux * EPA * 0.4 - 1, ay + uy * EPA * 0.4 - 1, EPA * 0.66, #E53935)
cercle(ecran, ax + ux * EPA * 0.4 - EPA * 0.25, ay + uy * EPA * 0.4 - EPA * 0.25, EPA * 0.2, #FFCDD2)
fin procédure
procédure dessinerAllumettes()
// les indices
hDe est un nombre
hDe vaut -1
hVers est un nombre
hVers vaut -1
si indiceEtape >= 0 alors
hDe vaut slotDe(indiceNombre(indiceEtape * 4), indiceNombre(indiceEtape * 4 + 1))
hVers vaut slotDe(indiceNombre(indiceEtape * 4 + 2), indiceNombre(indiceEtape * 4 + 3))
fin si
kl est un nombre
// d'abord les places vides
pour kl de 0 à nbSlot - 1
si non slOn[kl] alors
coulV est un texte
coulV vaut rgba(0, 0, 0, 0.06)
si choisi >= 0 alors
coulV vaut rgba(255, 179, 0, 0.28)
fin si
si kl = hVers et tic mod 10 < 6 alors
coulV vaut rgba(255, 179, 0, 0.75)
fin si
ligne(ecran, slX1[kl], slY1[kl], slX2[kl], slY2[kl], coulV, 9 * echelle)
fin si
fin pour
// puis les allumettes
pour kl de 0 à nbSlot - 1
si slOn[kl] alors
levee est un booléen
levee vaut faux
si kl = choisi alors
levee vaut vrai
fin si
brille est un booléen
brille vaut levee
si kl = hDe et tic mod 10 < 6 alors
brille vaut vrai
fin si
appelle allumette(slX1[kl], slY1[kl], slX2[kl], slY2[kl], levee, brille)
fin si
fin pour
fin procédure
fonction texteDefi()
typ est un texte
typ vaut nivType[niveau]
si typ = "<" alors
retourne "Forme un nombre plus petit que " + convertir_texte(nivParam[niveau])
sinon si typ = ">" alors
retourne "Forme un nombre plus grand que " + convertir_texte(nivParam[niveau])
sinon si typ = "M" alors
retourne "Forme le plus grand nombre possible"
sinon si typ = "m" alors
retourne "Forme le plus petit nombre possible"
fin si
retourne "Corrige l'égalité pour qu'elle soit juste"
fin fonction
procédure dessinerJeu()
// le mur clair et le titre
rectangle(ecran, 0, 0, 640, 550, #F1EEE8)
rectangle(ecran, 0, 0, 640, 46, #263238)
label(ecran, 18, 31, "Allumettes Malignes", #FFFFFF, 18)
appelle centrer("Niveau " + convertir_texte(niveau + 1) + " / " + convertir_texte(NB_NIVEAUX), 440, 30, #B0BEC5, 14)
appelle centrer("I : indice", 586, 30, #FFD54F, 12)
appelle centrer(texteDefi(), 320, 92, #263238, 22)
n est un nombre
n vaut nivCoups[niveau]
appelle centrer("en déplaçant seulement " + convertir_texte(n) + " allumette" + sialors(n > 1, "s", ""), 320, 122, #8D6E63, 17)
// un petit trait decoratif
rectangle(ecran, 220, 134, 90, 3, #C9A15B)
cercle(ecran, 320, 135.5, 4, #C9A15B)
rectangle(ecran, 330, 134, 90, 3, #C9A15B)
appelle dessinerAllumettes()
// le compteur et le message
appelle centrer("Allumettes déplacées : " + convertir_texte(deplaces) + " / " + convertir_texte(n), 320, 432, #546E7A, 14)
si msgT > 0 alors
appelle centrer(msgTxt, 320, 458, coulMsg, 13)
fin si
appelle bouton(40, 482, 130, 44, "Annuler (A)", #546E7A, #FFFFFF, 14)
appelle bouton(185, 482, 150, 44, "Recommencer (R)", #546E7A, #FFFFFF, 14)
appelle bouton(350, 482, 120, 44, "Indice (I)", #F9A825, #263238, 14)
appelle bouton(485, 482, 115, 44, "Niveaux", #263238, #FFFFFF, 14)
fin procédure
procédure etoile(cx, cy, r, pleine)
polygone(ecran, [cx, cy - r, cx + r * 0.29, cy - r * 0.4, cx + r * 0.95, cy - r * 0.31, cx + r * 0.47, cy + r * 0.15, cx + r * 0.59, cy + r * 0.81, cx, cy + r * 0.5, cx - r * 0.59, cy + r * 0.81, cx - r * 0.47, cy + r * 0.15, cx - r * 0.95, cy - r * 0.31, cx - r * 0.29, cy - r * 0.4], sialors(pleine, #FFB300, #CFD8DC))
fin procédure
procédure voile()
rectangle(ecran, 0, 0, 640, 550, rgba(38, 50, 56, 0.72))
fin procédure
procédure ecranAccueil()
appelle voile()
rectangle_arrondi(ecran, 90, 60, 460, 430, 22, #F1EEE8)
appelle centrer("Allumettes Malignes", 320, 120, #263238, 34)
appelle centrer("Déplace une seule allumette… et réfléchis bien !", 320, 152, #8D6E63, 15)
// un petit 7 en allumettes
echelle vaut 0.8
appelle allumette(250, 190, 317, 190, faux, faux)
appelle allumette(317, 190, 317, 257, faux, faux)
appelle allumette(317, 257, 317, 324, faux, faux)
appelle allumette(360, 190, 360, 257, vrai, vrai)
label(ecran, 390, 236, "?", #C9A15B, 40)
label(ecran, 130, 370, "Clique une allumette pour la prendre,", #37474F, 15)
label(ecran, 130, 394, "puis clique la place où tu veux la poser.", #37474F, 15)
appelle bouton(220, 420, 200, 48, "Jouer", sialors(tic mod 16 < 8, #C62828, #E53935), #FFFFFF, 20)
fin procédure
procédure ecranNiveaux()
rectangle(ecran, 0, 0, 640, 550, #F1EEE8)
rectangle(ecran, 0, 0, 640, 46, #263238)
label(ecran, 18, 31, "Allumettes Malignes", #FFFFFF, 18)
appelle centrer("Choisis un niveau", 320, 88, #263238, 24)
k est un nombre
pour k de 0 à NB_NIVEAUX - 1
x est un nombre
x vaut 70 + (k mod 4) * 130
y est un nombre
y vaut 110 + arrondi_inferieur(k / 4) * 106
debloque est un booléen
debloque vaut vrai
si k > 0 alors
si meilleur[k - 1] = 0 alors
debloque vaut faux
fin si
fin si
si debloque alors
rectangle_arrondi(ecran, x, y + 3, 112, 92, 14, rgba(0, 0, 0, 0.15))
rectangle_arrondi(ecran, x, y, 112, 92, 14, #FFFFFF)
appelle centrer(convertir_texte(k + 1), x + 56, y + 42, #263238, 28)
appelle centrer(nivTexte[k], x + 56, y + 62, #8D6E63, 12)
ke est un nombre
pour ke de 0 à 2
appelle etoile(x + 34 + ke * 22, y + 78, 8, ke < meilleur[k])
fin pour
sinon
rectangle_arrondi(ecran, x, y, 112, 92, 14, #DCD7CE)
rectangle_arrondi(ecran, x + 42, y + 42, 28, 24, 4, #A1887F)
cercle(ecran, x + 56, y + 40, 10, #A1887F)
cercle(ecran, x + 56, y + 40, 6, #DCD7CE)
rectangle(ecran, x + 42, y + 40, 28, 6, #A1887F)
fin si
fin pour
fin procédure
procédure ecranReussi()
appelle voile()
rectangle_arrondi(ecran, 130, 130, 380, 290, 22, #FFFFFF)
appelle centrer("Bravo !", 320, 184, #2E7D32, 34)
typ est un texte
typ vaut nivType[niveau]
phrase est un texte
si typ = "<" alors
phrase vaut resultat + " est plus petit que " + convertir_texte(nivParam[niveau])
sinon si typ = ">" alors
phrase vaut resultat + " est plus grand que " + convertir_texte(nivParam[niveau])
sinon si typ = "M" alors
phrase vaut resultat + " est le plus grand possible"
sinon si typ = "m" alors
phrase vaut resultat + " est le plus petit possible"
sinon
phrase vaut resultat + " est juste !"
fin si
appelle centrer(phrase, 320, 222, #263238, 18)
si typ <> "M" et typ <> "m" et nivNbSol[niveau] > 1 alors
appelle centrer("Il y avait " + convertir_texte(nivNbSol[niveau]) + " solutions possibles", 320, 248, #8D6E63, 13)
fin si
ke est un nombre
pour ke de 0 à 2
appelle etoile(270 + ke * 50, 290, 20, ke < etoiles)
fin pour
si indiceVu alors
appelle centrer("(avec un indice)", 320, 330, #8D6E63, 12)
fin si
si niveau < NB_NIVEAUX - 1 alors
appelle bouton(160, 350, 150, 46, "Rejouer", #546E7A, #FFFFFF, 16)
appelle bouton(330, 350, 150, 46, "Suivant", #2E7D32, #FFFFFF, 16)
sinon
appelle bouton(160, 350, 150, 46, "Rejouer", #546E7A, #FFFFFF, 16)
appelle bouton(330, 350, 150, 46, "Niveaux", #2E7D32, #FFFFFF, 16)
fin si
fin procédure
procédure dessiner()
effacer(ecran)
contour(ecran, #0)
si etat = 3 alors
appelle ecranNiveaux()
sinon
appelle dessinerJeu()
si etat = 0 alors
appelle ecranAccueil()
sinon si etat = 2 alors
appelle ecranReussi()
fin si
fin si
fin procédure
@ LES COMMANDES
// actions : 0 clic, 1 A annuler, 2 R recommencer, 3 I indice
procédure lireOrdre(act, x, y)
si etat = 0 alors
si act = 0 alors
etat vaut 3
fin si
sinon si etat = 3 alors
si act = 0 alors
col est un nombre
col vaut arrondi_inferieur((x - 70) / 130)
rangee est un nombre
rangee vaut arrondi_inferieur((y - 110) / 106)
si col >= 0 et col <= 3 et rangee >= 0 et rangee <= 3 alors
n est un nombre
n vaut rangee * 4 + col
ok est un booléen
ok vaut vrai
si n > 0 alors
si meilleur[n - 1] = 0 alors
ok vaut faux
fin si
fin si
si ok alors
etat vaut 9
appelle chargerNiveau(n)
fin si
fin si
fin si
sinon si etat = 2 alors
si act = 0 alors
si clique(x, y, 160, 350, 150, 46) alors
etat vaut 9
appelle chargerNiveau(niveau)
sinon si clique(x, y, 330, 350, 150, 46) alors
si niveau < NB_NIVEAUX - 1 alors
etat vaut 9
appelle chargerNiveau(niveau + 1)
sinon
etat vaut 3
fin si
fin si
sinon si act = 2 alors
etat vaut 9
appelle chargerNiveau(niveau)
fin si
sinon si etat = 1 alors
si act = 1 alors
appelle annuler()
sinon si act = 2 alors
appelle chargerNiveau(niveau)
sinon si act = 3 alors
appelle donnerIndice()
sinon si act = 0 alors
si clique(x, y, 40, 482, 130, 44) alors
appelle annuler()
sinon si clique(x, y, 185, 482, 150, 44) alors
appelle chargerNiveau(niveau)
sinon si clique(x, y, 350, 482, 120, 44) alors
appelle donnerIndice()
sinon si clique(x, y, 485, 482, 115, 44) alors
etat vaut 3
sinon
k est un nombre
k vaut slotSous(x, y)
si k >= 0 alors
appelle cliquerSlot(k)
sinon
choisi vaut -1
fin si
fin si
fin si
fin si
fin procédure
@ LE PROCESSUS
processus Jeu()
tant que appActif
tic vaut tic + 1
nbLus est un nombre
nbLus vaut 0
tant que teteO <> queueO et nbLus < 4
appelle lireOrdre(ordres[teteO], ordX[teteO], ordY[teteO])
teteO vaut (teteO + 1) mod 32
nbLus vaut nbLus + 1
fin tant que
si msgT > 0 alors
msgT vaut msgT - 1
fin si
si etat <> 9 alors
appelle dessiner()
affiche ecran
fin si
pause 60
fin tant que
effacer(ecran)
rectangle(ecran, 0, 0, 640, 550, #263238)
appelle centrer("À bientôt pour d'autres allumettes !", 320, 280, #FFD54F, 22)
affiche ecran
fin processus
@ DEMARRAGE
appelle chargerNiveau(0)
etat vaut 0
appelle dessiner()
affiche ecran
Jeu()
tant que appActif
interagir ecran, ["a", "r", "i", "x"] dans action, sourisX, sourisY
si action = 4 alors
appActif vaut faux
sinon si (queueO + 1) mod 32 <> teteO alors
ordres[queueO] vaut action
ordX[queueO] vaut sourisX
ordY[queueO] vaut sourisY
queueO vaut (queueO + 1) mod 32
fin si
fin tant que