Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
@ CONFIGURATION
ecran est une toile
dimension(ecran, 680, 520)
NB_NIV est un nombre
NB_NIV vaut 12
NOMS_NIV est un tableau
NOMS_NIV vaut ["CP", "CE1", "CE2", "CM1", "CM2", "6e", "5e", "4e", "3e", "2nde", "1re", "Terminale"]
NOMS_SALLE est un tableau
NOMS_SALLE vaut ["La bibliothèque", "Le laboratoire", "La salle du trésor", "L'observatoire", "La salle des clés"]
OBJ_X est un tableau
OBJ_X vaut [130, 270, 410, 550]
EXPOSANTS est un tableau
EXPOSANTS vaut ["⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"]
ECARTS est un tableau
ECARTS vaut [1, 2, -1, 3, -2, 10, 4, -3, 5, 20]
CHIFFRES_BAS est un tableau
CHIFFRES_BAS vaut ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"]
PAS_CP est un tableau
PAS_CP vaut [1, 2, 5, 10]
TABLES_CE1 est un tableau
TABLES_CE1 vaut [2, 5, 10]
PARTS_CM1 est un tableau
PARTS_CM1 vaut [2, 3, 4, 5, 10]
POURC_CM2 est un tableau
POURC_CM2 vaut [10, 20, 25, 50]
// triplets de Pythagore
TRI_A est un tableau
TRI_A vaut [3, 5, 8, 6]
TRI_B est un tableau
TRI_B vaut [4, 12, 15, 8]
TRI_C est un tableau
TRI_C vaut [5, 13, 17, 10]
COUL_PETITS est un tableau
COUL_PETITS vaut [#7F1D1D, #1E3A8A, #14532D, #713F12, #581C87, #0F766E]
COUL_LIVRE est un tableau
COUL_LIVRE vaut [#B91C1C, #1D4ED8, #15803D, #7C3AED]
COUL_FIOLE est un tableau
COUL_FIOLE vaut [#22C55E, #F43F5E, #3B82F6, #F59E0B]
COUL_PLANETE est un tableau
COUL_PLANETE vaut [#F97316, #38BDF8, #A3E635, #E879F9]
COUL_CLE est un tableau
COUL_CLE vaut [#FACC15, #CBD5E1, #D97706, #F59E0B]
COUL_NIV est un tableau
COUL_NIV vaut [#16A34A, #16A34A, #16A34A, #16A34A, #16A34A, #2563EB, #2563EB, #2563EB, #2563EB, #9333EA, #9333EA, #9333EA]
PENALITE est un nombre
PENALITE vaut 15
@ LA QUESTION EN COURS
qL1, qL2 est un texte
qDessin est un nombre
opts est un tableau
cand est un tableau
elimine est un tableau
pour ki de 0 à 3
opts ajoute ""
cand ajoute 0
elimine ajoute faux
fin pour
bonneIdx est un nombre
suffixe est un texte
suffixe vaut ""
@ LA PARTIE
// etat : 0 menu, 1 histoire, 2 salle, 3 chiffre trouve, 4 grande porte, 5 victoire
etat est un nombre
etat vaut 0
appActif est un booléen
appActif vaut vrai
niveau, salle est un nombre
codeSecret est un tableau
codeTape est un tableau
pour ki de 0 à 4
codeSecret ajoute 0
codeTape ajoute 0
fin pour
nbSaisis est un nombre
nbErreurs, indices, penalites est un nombre
debutChrono, tempsFinal est un nombre
etoilesFinales est un nombre
nouveauRecord est un booléen
msgTxt est un texte
msgTxt vaut ""
msgVie, msgCoul est un nombre
secousse, secObjet est un nombre
tic est un nombre
meilleurEt, meilleurTps est un tableau
pour ki de 0 à NB_NIV - 1
meilleurEt ajoute 0
meilleurTps ajoute 0
essayer
meilleurEt[ki] vaut parametre('chateaunombres', 'e' + convertir_texte(ki))
meilleurTps[ki] vaut parametre('chateaunombres', 't' + convertir_texte(ki))
attraper
meilleurEt[ki] vaut 0
meilleurTps[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
ptsEtoile est un tableau
pour ki de 0 à 19
ptsEtoile ajoute 0
fin pour
@ OUTILS DE TEXTE
procédure centrer(txt, xMil, yTxt, coul, tp)
label(ecran, xMil - label_largeur(txt, tp) / 2, yTxt, txt, coul, tp)
fin procédure
// centre un texte en reduisant sa taille s'il est trop large
procédure centrerAjuste(txt, xMil, yTxt, coul, tp, largeurMax)
t2 est un nombre
t2 vaut tp
tant que t2 > 9 et label_largeur(txt, t2) > largeurMax
t2 vaut t2 - 1
fin tant que
appelle centrer(txt, xMil, yTxt, coul, t2)
fin procédure
procédure bouton(x, y, lb, hb, txt, fond, coulTxt, tp)
rectangle_arrondi(ecran, x, y + 3, lb, hb, 12, rgba(0, 0, 0, 0.25))
rectangle_arrondi(ecran, x, y, lb, hb, 12, fond)
appelle centrer(txt, x + lb / 2, y + hb / 2 + tp * 0.38, coulTxt, tp)
fin procédure
fonction nb2txt(v)
retourne convertir_texte(v)
fin fonction
// le signe moins typographique pour les nombres negatifs
fonction nombreSigne(v)
si v < 0 alors
retourne "−" + convertir_texte(-v)
fin si
retourne convertir_texte(v)
fin fonction
// entre parentheses si negatif : (−3)
fonction nombreParenth(v)
si v < 0 alors
retourne "(−" + convertir_texte(-v) + ")"
fin si
retourne convertir_texte(v)
fin fonction
// 34 dixiemes -> "3,4"
fonction decTexte(dix)
retourne convertir_texte(arrondi_inferieur(dix / 10)) + "," + convertir_texte(dix mod 10)
fin fonction
fonction exposant(n)
t est un texte
t vaut ""
v est un nombre
v vaut n
si v < 0 alors
t vaut "⁻"
v vaut -v
fin si
si v >= 10 alors
t vaut t + EXPOSANTS[arrondi_inferieur(v / 10)]
fin si
retourne t + EXPOSANTS[v mod 10]
fin fonction
fonction calculPgcd(x, y)
u est un nombre
u vaut absolue(x)
w est un nombre
w vaut absolue(y)
tant que w > 0
r est un nombre
r vaut u mod w
u vaut w
w vaut r
fin tant que
si u = 0 alors
retourne 1
fin si
retourne u
fin fonction
// fraction simplifiee : 6/8 -> "3/4", 4/2 -> "2"
fonction fracTexte(num, den)
g est un nombre
g vaut calculPgcd(num, den)
n2 est un nombre
n2 vaut num / g
d2 est un nombre
d2 vaut den / g
si d2 < 0 alors
n2 vaut -n2
d2 vaut -d2
fin si
si d2 = 1 alors
retourne nombreSigne(n2)
fin si
retourne nombreSigne(n2) + "/" + convertir_texte(d2)
fin fonction
// " + 3" ou " − 3" pour ecrire une expression
fonction terme(v, lettre)
si v = 0 alors
retourne ""
fin si
coef est un texte
coef vaut convertir_texte(absolue(v))
si absolue(v) = 1 et lettre <> "" alors
coef vaut ""
fin si
si v > 0 alors
retourne " + " + coef + lettre
fin si
retourne " − " + coef + lettre
fin fonction
// "x" ou "3x"
fonction coefX(v)
si v = 1 alors
retourne "x"
fin si
retourne convertir_texte(v) + "x"
fin fonction
// "3x² − 2x + 5"
fonction polyTexte(c2, c1, c0)
t est un texte
t vaut convertir_texte(c2) + "x²"
si c2 = 1 alors
t vaut "x²"
fin si
retourne t + terme(c1, "x") + terme(c0, "")
fin fonction
@ LES REPONSES PROPOSEES
// melange les 4 reponses en suivant la bonne
procédure melangerReponses()
i est un nombre
pour i de 0 à 2
j est un nombre
j vaut hasard(i, 3)
tmp est un texte
tmp vaut opts[i]
opts[i] vaut opts[j]
opts[j] vaut tmp
si bonneIdx = i alors
bonneIdx vaut j
sinon si bonneIdx = j alors
bonneIdx vaut i
fin si
fin pour
fin procédure
procédure poserTextes(bon, f1, f2, f3)
opts[0] vaut bon
opts[1] vaut f1
opts[2] vaut f2
opts[3] vaut f3
bonneIdx vaut 0
appelle melangerReponses()
fin procédure
// la bonne reponse et 3 erreurs vraisemblables ; les doublons sont remplaces
procédure poserNombres(bon, e1, e2, e3, positifs)
cand[0] vaut bon
cand[1] vaut e1
cand[2] vaut e2
cand[3] vaut e3
i est un nombre
pour i de 1 à 3
k est un nombre
k vaut 0
doublon est un booléen
doublon vaut vrai
tant que doublon et k < 10
doublon vaut faux
j est un nombre
pour j de 0 à i - 1
si cand[j] = cand[i] alors
doublon vaut vrai
fin si
fin pour
si positifs et cand[i] < 0 alors
doublon vaut vrai
fin si
si doublon alors
cand[i] vaut bon + ECARTS[k]
k vaut k + 1
fin si
fin tant que
fin pour
pour i de 0 à 3
opts[i] vaut nombreSigne(cand[i]) + suffixe
fin pour
bonneIdx vaut 0
appelle melangerReponses()
fin procédure
fonction optionsUniques()
i est un nombre
j est un nombre
pour i de 0 à 2
pour j de i + 1 à 3
si opts[i] = opts[j] alors
retourne faux
fin si
fin pour
fin pour
retourne vrai
fin fonction
@ LES ENIGMES
// une question par niveau (0 = CP ... 11 = Terminale) et par salle (0 a 4)
procédure genQuestion(niv, t)
na, nb, nc, nd, nn, nk, nr, nq, ns est un nombre
qL1 vaut ""
qL2 vaut ""
qDessin vaut 0
suffixe vaut ""
positifs est un booléen
positifs vaut faux
si niv <= 4 alors
positifs vaut vrai
fin si
si niv = 0 alors
// ---------- CP ----------
si t = 0 alors
na vaut hasard(1, 9)
nb vaut hasard(1, 9)
qL1 vaut "Combien font " + nb2txt(na) + " + " + nb2txt(nb) + " ?"
appelle poserNombres(na + nb, na + nb + 1, na + nb - 1, na + nb + 2, positifs)
sinon si t = 1 alors
na vaut hasard(5, 10)
nb vaut hasard(1, na - 1)
qL1 vaut "Combien font " + nb2txt(na) + " − " + nb2txt(nb) + " ?"
appelle poserNombres(na - nb, na + nb, na - nb + 1, na - nb - 1, positifs)
sinon si t = 2 alors
nn vaut hasard(5, 12)
qDessin vaut nn
qL1 vaut "Compte les étoiles. Combien y en a-t-il ?"
appelle poserNombres(nn, nn + 1, nn - 1, nn + 2, positifs)
sinon si t = 3 alors
nk vaut PAS_CP[hasard(0, 3)]
ns vaut hasard(1, 9)
qL1 vaut "Quel nombre vient ensuite ?"
qL2 vaut nb2txt(ns) + " " + nb2txt(ns + nk) + " " + nb2txt(ns + 2 * nk) + " " + nb2txt(ns + 3 * nk) + " ?"
appelle poserNombres(ns + 4 * nk, ns + 3 * nk, ns + 4 * nk + 1, ns + 5 * nk, positifs)
sinon
na vaut hasard(10, 60)
nb vaut na - hasard(1, 9)
nc vaut na - hasard(10, 19)
nd vaut hasard(1, 9)
qL1 vaut "Quel est le plus grand nombre ?"
appelle poserTextes(nb2txt(na), nb2txt(nb), nb2txt(nc), nb2txt(nd))
fin si
sinon si niv = 1 alors
// ---------- CE1 ----------
si t = 0 alors
na vaut hasard(11, 49)
nb vaut hasard(11, 49)
qL1 vaut "Combien font " + nb2txt(na) + " + " + nb2txt(nb) + " ?"
appelle poserNombres(na + nb, na + nb + 10, na + nb - 10, na + nb + 1, positifs)
sinon si t = 1 alors
na vaut hasard(40, 99)
nb vaut hasard(11, na - 15)
qL1 vaut "Combien font " + nb2txt(na) + " − " + nb2txt(nb) + " ?"
appelle poserNombres(na - nb, na - nb + 10, na - nb - 1, na - nb + 2, positifs)
sinon si t = 2 alors
nn vaut hasard(6, 45)
qL1 vaut "Quel est le double de " + nb2txt(nn) + " ?"
appelle poserNombres(2 * nn, nn + 2, 2 * nn + 2, 2 * nn - 1, positifs)
sinon si t = 3 alors
na vaut TABLES_CE1[hasard(0, 2)]
nb vaut hasard(2, 10)
qL1 vaut "Combien font " + nb2txt(na) + " × " + nb2txt(nb) + " ?"
appelle poserNombres(na * nb, na * nb + na, na * nb - na, na + nb, positifs)
sinon
na vaut hasard(1, 4)
nb vaut hasard(1, 5)
qL1 vaut "Tu as " + nb2txt(na) + " pièces de 2 € et " + nb2txt(nb) + " pièces de 1 €."
qL2 vaut "Combien d'euros as-tu ?"
suffixe vaut " €"
appelle poserNombres(2 * na + nb, na + nb, 2 * na + nb + 1, 2 * na + 2 * nb, positifs)
fin si
sinon si niv = 2 alors
// ---------- CE2 ----------
si t = 0 alors
na vaut hasard(3, 9)
nb vaut hasard(3, 9)
qL1 vaut "Combien font " + nb2txt(na) + " × " + nb2txt(nb) + " ?"
appelle poserNombres(na * nb, na * nb + na, na * nb - nb, na + nb, positifs)
sinon si t = 1 alors
na vaut hasard(120, 480)
nb vaut hasard(110, 450)
qL1 vaut "Combien font " + nb2txt(na) + " + " + nb2txt(nb) + " ?"
appelle poserNombres(na + nb, na + nb + 100, na + nb - 10, na + nb + 1, positifs)
sinon si t = 2 alors
nk vaut hasard(2, 6)
nq vaut hasard(3, 9)
qL1 vaut "On partage " + nb2txt(nk * nq) + " bonbons entre " + nb2txt(nk) + " enfants."
qL2 vaut "Combien de bonbons pour chacun ?"
appelle poserNombres(nq, nq + 1, nq - 1, nk * nq - nk, positifs)
sinon si t = 3 alors
nn vaut 2 * hasard(10, 100)
qL1 vaut "Quelle est la moitié de " + nb2txt(nn) + " ?"
appelle poserNombres(nn / 2, nn / 2 + 1, nn / 2 + 10, nn / 2 - 10, positifs)
sinon
na vaut hasard(1, 9)
nb vaut hasard(2, 5)
qL1 vaut "Un film commence à " + nb2txt(na) + " h et dure " + nb2txt(nb) + " h."
qL2 vaut "À quelle heure finit-il ?"
suffixe vaut " h"
appelle poserNombres(na + nb, na + nb + 1, na + nb - 1, na + nb + 2, positifs)
fin si
sinon si niv = 3 alors
// ---------- CM1 ----------
si t = 0 alors
na vaut hasard(12, 35)
nb vaut hasard(3, 9)
qL1 vaut "Combien font " + nb2txt(na) + " × " + nb2txt(nb) + " ?"
appelle poserNombres(na * nb, na * nb + nb, na * nb - 10, na * nb + 10, positifs)
sinon si t = 1 alors
nb vaut hasard(3, 9)
nq vaut hasard(6, 25)
nr vaut hasard(1, nb - 1)
qL1 vaut "Dans la division de " + nb2txt(nb * nq + nr) + " par " + nb2txt(nb) + ","
qL2 vaut "quel est le quotient ?"
appelle poserNombres(nq, nq + 1, nq - 1, nr, positifs)
sinon si t = 2 alors
nk vaut PARTS_CM1[hasard(0, 4)]
na vaut hasard(3, 12)
qL1 vaut "Combien font 1/" + nb2txt(nk) + " de " + nb2txt(nk * na) + " ?"
appelle poserNombres(na, nk * na - nk, na * 2, na + nk, positifs)
sinon si t = 3 alors
na vaut hasard(6, 20)
nb vaut hasard(2, na - 1)
qL1 vaut "Un rectangle mesure " + nb2txt(na) + " cm sur " + nb2txt(nb) + " cm."
qL2 vaut "Quel est son périmètre ?"
suffixe vaut " cm"
appelle poserNombres(2 * (na + nb), na + nb, na * nb, 2 * na + nb, positifs)
sinon
na vaut hasard(11, 59)
nb vaut hasard(11, 49)
si na mod 10 = 0 alors
na vaut na + 3
fin si
si nb mod 10 = 0 alors
nb vaut nb + 4
fin si
qL1 vaut "Combien font " + decTexte(na) + " + " + decTexte(nb) + " ?"
appelle poserTextes(decTexte(na + nb), decTexte(na + nb + 10), decTexte(na + nb + 1), decTexte(na + nb - 1))
fin si
sinon si niv = 4 alors
// ---------- CM2 ----------
si t = 0 alors
na vaut POURC_CM2[hasard(0, 3)]
nn vaut 20 * hasard(1, 10)
qL1 vaut "Combien font " + nb2txt(na) + " % de " + nb2txt(nn) + " ?"
appelle poserNombres(na * nn / 100, na * nn / 50, na * nn / 100 + 10, nn - na * nn / 100, positifs)
sinon si t = 1 alors
na vaut hasard(4, 15)
nb vaut hasard(2, 9)
qL1 vaut "Un rectangle mesure " + nb2txt(na) + " cm sur " + nb2txt(nb) + " cm."
qL2 vaut "Quelle est son aire ?"
suffixe vaut " cm²"
appelle poserNombres(na * nb, 2 * (na + nb), na * nb + na, na + nb, positifs)
sinon si t = 2 alors
nk vaut hasard(2, 9)
na vaut hasard(2, 5)
nb vaut hasard(6, 12)
qL1 vaut nb2txt(na) + " cahiers coûtent " + nb2txt(na * nk) + " €."
qL2 vaut "Combien coûtent " + nb2txt(nb) + " cahiers ?"
suffixe vaut " €"
appelle poserNombres(nb * nk, nb * nk + nk, na * nk + nb, nb + nk, positifs)
sinon si t = 3 alors
na vaut hasard(12, 99)
si na mod 10 = 0 alors
na vaut na + 1
fin si
qL1 vaut "Combien font " + decTexte(na) + " × 100 ?"
appelle poserTextes(nb2txt(na * 10), nb2txt(na), nb2txt(na * 100), decTexte(na) + "00")
sinon
nk vaut hasard(2, 9)
qL1 vaut "Quelle fraction est égale à 1/2 ?"
appelle poserTextes(nb2txt(nk) + "/" + nb2txt(2 * nk), nb2txt(nk) + "/" + nb2txt(2 * nk + 1), nb2txt(nk + 1) + "/" + nb2txt(2 * nk), nb2txt(nk) + "/" + nb2txt(2 * nk - 1))
fin si
sinon si niv = 5 alors
// ---------- 6e ----------
si t = 0 alors
na vaut hasard(2, 9)
nb vaut hasard(2, 9)
nc vaut hasard(2, 9)
qL1 vaut "Combien font " + nb2txt(na) + " + " + nb2txt(nb) + " × " + nb2txt(nc) + " ?"
appelle poserNombres(na + nb * nc, (na + nb) * nc, na + nb * nc + 1, na * nb + nc, positifs)
sinon si t = 1 alors
na vaut hasard(30, 80)
nb vaut hasard(30, 80)
qL1 vaut "Un triangle a deux angles de " + nb2txt(na) + "° et " + nb2txt(nb) + "°."
qL2 vaut "Combien mesure le troisième angle ?"
suffixe vaut "°"
appelle poserNombres(180 - na - nb, 360 - na - nb, 180 - na, 190 - na - nb, positifs)
sinon si t = 2 alors
nn vaut hasard(8, 16)
na vaut hasard(1, 4)
nb vaut hasard(1, 4)
qL1 vaut "Quelle est la moyenne de " + nb2txt(nn - na) + ", " + nb2txt(nn + nb) + " et " + nb2txt(nn + na - nb) + " ?"
appelle poserNombres(nn, nn + 1, nn - 1, 3 * nn, positifs)
sinon si t = 3 alors
na vaut hasard(3, 12)
nb vaut hasard(2, 10)
si (na * nb) mod 2 = 1 alors
na vaut na + 1
fin si
qL1 vaut "Un triangle a une base de " + nb2txt(na) + " cm et une hauteur de " + nb2txt(nb) + " cm."
qL2 vaut "Quelle est son aire ?"
suffixe vaut " cm²"
appelle poserNombres(na * nb / 2, na * nb, na + nb, na * nb / 2 + na, positifs)
sinon
nb vaut hasard(3, 9)
na vaut hasard(1, nb - 1)
tant que calculPgcd(na, nb) > 1
na vaut hasard(1, nb - 1)
fin tant que
nk vaut hasard(2, 6)
qL1 vaut "Simplifie la fraction " + nb2txt(nk * na) + "/" + nb2txt(nk * nb) + "."
appelle poserTextes(nb2txt(na) + "/" + nb2txt(nb), nb2txt(nk * na) + "/" + nb2txt(nb), nb2txt(na) + "/" + nb2txt(nk * nb), nb2txt(na + 1) + "/" + nb2txt(nb + 1))
fin si
sinon si niv = 6 alors
// ---------- 5e ----------
si t = 0 alors
na vaut hasard(3, 15)
nb vaut hasard(1, 20)
si nb = na alors
nb vaut nb + 1
fin si
qL1 vaut "Combien font (−" + nb2txt(na) + ") + " + nb2txt(nb) + " ?"
appelle poserNombres(nb - na, na + nb, 0 - na - nb, na - nb, positifs)
sinon si t = 1 alors
na vaut hasard(2, 9)
nb vaut hasard(10, 20)
qL1 vaut "Combien font " + nb2txt(na) + " − " + nb2txt(nb) + " ?"
appelle poserNombres(na - nb, nb - na, 0 - na - nb, na - nb - 1, positifs)
sinon si t = 2 alors
nd vaut hasard(5, 12)
na vaut hasard(1, nd - 2)
nb vaut hasard(1, nd - 1 - na)
qL1 vaut "Combien font " + nb2txt(na) + "/" + nb2txt(nd) + " + " + nb2txt(nb) + "/" + nb2txt(nd) + " ?"
qL2 vaut "(sans simplifier)"
appelle poserTextes(nb2txt(na + nb) + "/" + nb2txt(nd), nb2txt(na + nb) + "/" + nb2txt(2 * nd), nb2txt(na + nb + 1) + "/" + nb2txt(nd), nb2txt(na * nb) + "/" + nb2txt(nd * nd))
sinon si t = 3 alors
na vaut hasard(2, 6)
nb vaut hasard(6, 12)
nc vaut hasard(1, 5)
nd vaut hasard(1, 9)
qL1 vaut "Combien font " + nb2txt(na) + " × (" + nb2txt(nb) + " − " + nb2txt(nc) + ") + " + nb2txt(nd) + " ?"
appelle poserNombres(na * (nb - nc) + nd, na * nb - nc + nd, na * (nb - nc) + nd + na, na * (nb - nc), positifs)
sinon
nn vaut 10 * hasard(2, 20)
qL1 vaut "Un jouet coûte " + nb2txt(nn) + " €. Son prix augmente de 10 %."
qL2 vaut "Quel est son nouveau prix ?"
suffixe vaut " €"
appelle poserNombres(nn + nn / 10, nn + 10, nn / 10, nn * 10, positifs)
fin si
sinon si niv = 7 alors
// ---------- 4e ----------
si t = 0 alors
na vaut hasard(2, 3)
nb vaut hasard(3, 8)
si na = 3 alors
nb vaut hasard(2, 4)
fin si
qL1 vaut "Combien vaut " + nb2txt(na) + exposant(nb) + " ?"
appelle poserNombres(puissance(na, nb), na * nb, puissance(na, nb - 1), puissance(na, nb + 1), positifs)
sinon si t = 1 alors
nn vaut hasard(-6, 9)
na vaut hasard(2, 7)
nb vaut hasard(-10, 10)
si nb = 0 alors
nb vaut 4
fin si
qL1 vaut "Résous l'équation : " + nb2txt(na) + "x" + terme(nb, "") + " = " + nombreSigne(na * nn + nb)
qL2 vaut "Que vaut x ?"
appelle poserNombres(nn, na * nn, nn + 1, 0 - nn, positifs)
sinon si t = 2 alors
nk vaut hasard(0, 3)
nr vaut hasard(1, 2)
na vaut TRI_A[nk] * nr
nb vaut TRI_B[nk] * nr
nc vaut TRI_C[nk] * nr
qL1 vaut "Un triangle rectangle a deux côtés de l'angle droit"
qL2 vaut "de " + nb2txt(na) + " cm et " + nb2txt(nb) + " cm. Longueur de l'hypoténuse ?"
suffixe vaut " cm"
appelle poserNombres(nc, na + nb, nc + 1, nc - 1, positifs)
sinon si t = 3 alors
na vaut hasard(2, 9)
nb vaut hasard(2, 9)
si hasard(0, 1) = 0 alors
qL1 vaut "Combien font (−" + nb2txt(na) + ") × (−" + nb2txt(nb) + ") ?"
appelle poserNombres(na * nb, 0 - na * nb, 0 - na - nb, na * nb + na, positifs)
sinon
qL1 vaut "Combien font (−" + nb2txt(na) + ") × " + nb2txt(nb) + " ?"
appelle poserNombres(0 - na * nb, na * nb, nb - na, 0 - na * nb - nb, positifs)
fin si
sinon
na vaut hasard(1, 5)
nb vaut hasard(2, 7)
nc vaut hasard(1, 5)
nd vaut hasard(2, 7)
qL1 vaut "Combien font " + nb2txt(na) + "/" + nb2txt(nb) + " × " + nb2txt(nc) + "/" + nb2txt(nd) + " ?"
appelle poserTextes(fracTexte(na * nc, nb * nd), fracTexte(na + nc, nb + nd), fracTexte(na * nd, nb * nc), fracTexte(na * nc, nb + nd))
fin si
sinon si niv = 8 alors
// ---------- 3e ----------
si t = 0 alors
na vaut hasard(2, 7)
nb vaut hasard(-9, 9)
nk vaut hasard(-4, 5)
qL1 vaut "Soit f(x) = " + nb2txt(na) + "x" + terme(nb, "") + "."
qL2 vaut "Combien vaut f(" + nombreSigne(nk) + ") ?"
appelle poserNombres(na * nk + nb, na + nk + nb, na * nk - nb, na * (nk + nb), positifs)
sinon si t = 1 alors
nr vaut hasard(4, 15)
qL1 vaut "Combien vaut √" + nb2txt(nr * nr) + " ?"
appelle poserNombres(nr, nr + 1, nr - 1, 2 * nr, positifs)
sinon si t = 2 alors
na vaut hasard(3, 9)
qL1 vaut "Développe (x + " + nb2txt(na) + ")²."
appelle poserTextes("x² + " + nb2txt(2 * na) + "x + " + nb2txt(na * na), "x² + " + nb2txt(na * na), "x² + " + nb2txt(na) + "x + " + nb2txt(na * na), "x² + " + nb2txt(2 * na) + "x + " + nb2txt(2 * na))
sinon si t = 3 alors
na vaut hasard(2, 6)
nk vaut hasard(2, 4)
nc vaut hasard(2, 7)
qL1 vaut "(MN) et (BC) sont parallèles. AM = " + nb2txt(na) + ", AB = " + nb2txt(na * nk) + ", AN = " + nb2txt(nc) + "."
qL2 vaut "Combien vaut AC ?"
appelle poserNombres(nc * nk, nc + na * nk - na, nc * na, na * nk, positifs)
sinon
na vaut hasard(2, 6)
nb vaut hasard(1, 6)
si nb = na alors
nb vaut na + 1
fin si
qL1 vaut "Un sac contient " + nb2txt(na) + " boules rouges et " + nb2txt(nb) + " boules vertes."
qL2 vaut "Probabilité de tirer une boule rouge ?"
appelle poserTextes(fracTexte(na, na + nb), fracTexte(na, nb), fracTexte(nb, na + nb), fracTexte(1, na + nb))
fin si
sinon si niv = 9 alors
// ---------- 2nde ----------
si t = 0 alors
na vaut hasard(1, 9)
nb vaut hasard(1, 9)
si nb = na alors
nb vaut na + 1
fin si
qL1 vaut "Résous (x − " + nb2txt(na) + ")(x + " + nb2txt(nb) + ") = 0."
appelle poserTextes(nb2txt(na) + " et −" + nb2txt(nb), "−" + nb2txt(na) + " et " + nb2txt(nb), nb2txt(na) + " et " + nb2txt(nb), "−" + nb2txt(na) + " et −" + nb2txt(nb))
sinon si t = 1 alors
na vaut hasard(1, 9)
nk vaut hasard(-5, 5)
si nk = 0 alors
nk vaut 3
fin si
qL1 vaut "Soit f(x) = x² − " + nb2txt(na) + ". Combien vaut f(" + nombreSigne(nk) + ") ?"
appelle poserNombres(nk * nk - na, 0 - nk * nk - na, 2 * nk - na, nk * nk + na, positifs)
sinon si t = 2 alors
na vaut hasard(-5, 5)
nb vaut hasard(-5, 5)
nc vaut hasard(-5, 5)
nd vaut hasard(-5, 5)
qL1 vaut "A(" + nombreSigne(na) + " ; " + nombreSigne(nb) + ") et B(" + nombreSigne(nc) + " ; " + nombreSigne(nd) + ")."
qL2 vaut "Quelles sont les coordonnées du vecteur AB ?"
appelle poserTextes("(" + nombreSigne(nc - na) + " ; " + nombreSigne(nd - nb) + ")", "(" + nombreSigne(na - nc) + " ; " + nombreSigne(nb - nd) + ")", "(" + nombreSigne(na + nc) + " ; " + nombreSigne(nb + nd) + ")", "(" + nombreSigne(nd - nb) + " ; " + nombreSigne(nc - na) + ")")
sinon si t = 3 alors
// 5 valeurs distinctes, donnees dans le desordre
na vaut hasard(1, 6)
nb vaut na + hasard(1, 4)
nc vaut nb + hasard(1, 4)
nd vaut nc + hasard(1, 4)
nn vaut nd + hasard(1, 4)
qL1 vaut "Quelle est la médiane de cette série ?"
qL2 vaut nb2txt(nd) + " ; " + nb2txt(na) + " ; " + nb2txt(nn) + " ; " + nb2txt(nc) + " ; " + nb2txt(nb)
appelle poserNombres(nc, nn, na, nb, positifs)
sinon
na vaut hasard(2, 9)
nb vaut hasard(-5, 6)
si nb = 0 ou nb = na alors
nb vaut -3
fin si
qL1 vaut "Combien font 10" + exposant(na) + " × 10" + exposant(nb) + " ?"
appelle poserTextes("10" + exposant(na + nb), "10" + exposant(na * nb), "20" + exposant(na + nb), "100" + exposant(na + nb))
fin si
sinon si niv = 10 alors
// ---------- 1re ----------
si t = 0 alors
na vaut hasard(1, 5)
nb vaut hasard(-6, 6)
nc vaut hasard(1, 9)
nk vaut hasard(-3, 3)
si nk = 0 alors
nk vaut 2
fin si
qL1 vaut "Soit f(x) = " + polyTexte(na, nb, nc) + "."
qL2 vaut "Combien vaut f'(" + nombreSigne(nk) + ") ?"
appelle poserNombres(2 * na * nk + nb, na * nk * nk + nb * nk + nc, na * nk + nb, 2 * na * nk, positifs)
sinon si t = 1 alors
nb vaut hasard(-9, 9)
nc vaut hasard(-9, 9)
si nc = 0 alors
nc vaut 2
fin si
qL1 vaut "Quel est le discriminant Δ de " + polyTexte(1, nb, nc) + " ?"
appelle poserNombres(nb * nb - 4 * nc, nb * nb + 4 * nc, nb - 4 * nc, nb * nb - 2 * nc, positifs)
sinon si t = 2 alors
na vaut hasard(1, 20)
nr vaut hasard(2, 9)
nn vaut hasard(5, 20)
qL1 vaut "Suite arithmétique : u₀ = " + nb2txt(na) + " et raison r = " + nb2txt(nr) + "."
qL2 vaut "Combien vaut u" + CHIFFRES_BAS[nn mod 10] + " ?"
si nn >= 10 alors
qL2 vaut "Combien vaut u" + CHIFFRES_BAS[arrondi_inferieur(nn / 10)] + CHIFFRES_BAS[nn mod 10] + " ?"
fin si
appelle poserNombres(na + nn * nr, na + (nn - 1) * nr, na + (nn + 1) * nr, nn * nr, positifs)
sinon si t = 3 alors
na vaut hasard(1, 5)
nq vaut hasard(2, 3)
nn vaut hasard(3, 6)
qL1 vaut "Suite géométrique : u₀ = " + nb2txt(na) + " et raison q = " + nb2txt(nq) + "."
qL2 vaut "Combien vaut u" + CHIFFRES_BAS[nn] + " ?"
appelle poserNombres(na * puissance(nq, nn), na * nq * nn, na * puissance(nq, nn - 1), na + puissance(nq, nn), positifs)
sinon
na vaut hasard(-5, 5)
nb vaut hasard(-5, 5)
nc vaut hasard(-5, 5)
nd vaut hasard(-5, 5)
qL1 vaut "u(" + nombreSigne(na) + " ; " + nombreSigne(nb) + ") et v(" + nombreSigne(nc) + " ; " + nombreSigne(nd) + ")."
qL2 vaut "Combien vaut le produit scalaire u · v ?"
appelle poserNombres(na * nc + nb * nd, na * nd + nb * nc, na * nc - nb * nd, na + nb + nc + nd, positifs)
fin si
sinon
// ---------- Terminale ----------
si t = 0 alors
nk vaut hasard(2, 9)
si hasard(0, 1) = 0 alors
qL1 vaut "Combien vaut ln(e" + exposant(nk) + ") ?"
sinon
qL1 vaut "Combien vaut exp(ln " + nb2txt(nk) + ") ?"
fin si
appelle poserNombres(nk, 1, nk * nk, 0, positifs)
sinon si t = 1 alors
na vaut hasard(2, 9)
qL1 vaut "Combien vaut l'intégrale de 0 à " + nb2txt(na) + " de 2x dx ?"
appelle poserNombres(na * na, 2 * na, 2 * na * na, na, positifs)
sinon si t = 2 alors
na vaut hasard(1, 9)
nb vaut hasard(1, 9)
nc vaut hasard(1, 9)
nd vaut hasard(1, 9)
qL1 vaut "Limite de (" + coefX(na) + " + " + nb2txt(nb) + ") / (" + coefX(nc) + " + " + nb2txt(nd) + ")"
qL2 vaut "quand x tend vers +∞ ?"
appelle poserTextes(fracTexte(na, nc), fracTexte(nb, nd), "+∞", "0")
sinon si t = 3 alors
nk vaut hasard(2, 9)
qL1 vaut "Soit f(x) = e" + exposant(nk) + "ˣ. Combien vaut f'(0) ?"
appelle poserNombres(nk, 1, 0, nk * nk, positifs)
sinon
nn vaut hasard(4, 12)
qL1 vaut "De combien de façons peut-on choisir"
qL2 vaut "2 élèves parmi " + nb2txt(nn) + " ?"
appelle poserNombres(nn * (nn - 1) / 2, nn * (nn - 1), 2 * nn, nn * nn, positifs)
fin si
fin si
fin procédure
// recommence tant que deux reponses se ressemblent
procédure preparerQuestion()
essais est un nombre
essais vaut 0
appelle genQuestion(niveau, salle)
tant que non optionsUniques() et essais < 30
appelle genQuestion(niveau, salle)
essais vaut essais + 1
fin tant que
i est un nombre
pour i de 0 à 3
elimine[i] vaut faux
fin pour
fin procédure
@ LA PARTIE : ACTIONS
procédure annoncer(txt, coul)
msgTxt vaut txt
msgVie vaut 40
msgCoul vaut coul
fin procédure
procédure commencer(niv)
niveau vaut niv
salle vaut 0
nbErreurs vaut 0
indices vaut 0
penalites vaut 0
nbSaisis vaut 0
i est un nombre
pour i de 0 à 4
codeSecret[i] vaut hasard(0, 9)
fin pour
appelle preparerQuestion()
msgVie vaut 0
etat vaut 1
fin procédure
fonction tempsEcoule()
retourne (chrono() - debutChrono) / 1000 + penalites
fin fonction
fonction texteTemps(sec)
s est un nombre
s vaut arrondi_inferieur(sec)
sc est un nombre
sc vaut s mod 60
retourne convertir_texte(arrondi_inferieur(s / 60)) + ":" + sialors(sc < 10, "0", "") + convertir_texte(sc)
fin fonction
procédure choisirObjet(i)
si non elimine[i] alors
si i = bonneIdx alors
etat vaut 3
sinon
elimine[i] vaut vrai
nbErreurs vaut nbErreurs + 1
penalites vaut penalites + PENALITE
secousse vaut 10
secObjet vaut i
appelle annoncer("Raté ! Ce n'est pas la bonne réponse : +15 s", 1)
fin si
fin si
fin procédure
procédure donnerIndice()
restants est un nombre
restants vaut 0
i est un nombre
pour i de 0 à 3
si non elimine[i] et i <> bonneIdx alors
restants vaut restants + 1
fin si
fin pour
si restants >= 2 alors
fait est un booléen
fait vaut faux
pour i de 0 à 3
si non fait et non elimine[i] et i <> bonneIdx alors
elimine[i] vaut vrai
fait vaut vrai
fin si
fin pour
indices vaut indices + 1
penalites vaut penalites + PENALITE
appelle annoncer("Indice : une mauvaise réponse est barrée (+15 s)", 2)
sinon
appelle annoncer("Plus d'indice possible ici, à toi de jouer !", 2)
fin si
fin procédure
procédure salleSuivante()
salle vaut salle + 1
msgVie vaut 0
si salle >= 5 alors
nbSaisis vaut 0
etat vaut 4
sinon
appelle preparerQuestion()
etat vaut 2
fin si
fin procédure
procédure gagner()
tempsFinal vaut tempsEcoule()
fautes est un nombre
fautes vaut nbErreurs + indices
etoilesFinales vaut 1
si fautes = 0 alors
etoilesFinales vaut 3
sinon si fautes <= 2 alors
etoilesFinales vaut 2
fin si
nouveauRecord vaut faux
si meilleurTps[niveau] = 0 ou tempsFinal < meilleurTps[niveau] alors
meilleurTps[niveau] vaut arrondi(tempsFinal)
nouveauRecord vaut vrai
fin si
si etoilesFinales > meilleurEt[niveau] alors
meilleurEt[niveau] vaut etoilesFinales
fin si
essayer
parametre('chateaunombres', 'e' + convertir_texte(niveau), meilleurEt[niveau])
parametre('chateaunombres', 't' + convertir_texte(niveau), meilleurTps[niveau])
attraper
msgVie vaut 0
fin essayer
etat vaut 5
fin procédure
procédure taperChiffre(d)
si nbSaisis < 5 alors
codeTape[nbSaisis] vaut d
nbSaisis vaut nbSaisis + 1
si nbSaisis = 5 alors
bon est un booléen
bon vaut vrai
i est un nombre
pour i de 0 à 4
si codeTape[i] <> codeSecret[i] alors
bon vaut faux
fin si
fin pour
si bon alors
appelle gagner()
sinon
nbErreurs vaut nbErreurs + 1
penalites vaut penalites + PENALITE
nbSaisis vaut 0
secousse vaut 10
appelle annoncer("Le cadenas reste fermé... Mets les chiffres dans l'ordre des salles !", 1)
fin si
fin si
fin si
fin procédure
@ DESSIN : PETITS ELEMENTS
procédure dessinerEtoile(x, y, r, coul)
k est un nombre
pour k de 0 à 9
ang est un nombre
ang vaut -pi() / 2 + k * pi() / 5
rr est un nombre
rr vaut r
si k mod 2 = 1 alors
rr vaut r * 0.45
fin si
ptsEtoile[k * 2] vaut x + cosinus(ang) * rr
ptsEtoile[k * 2 + 1] vaut y + sinus(ang) * rr
fin pour
polygone(ecran, ptsEtoile, coul)
fin procédure
procédure dessinerTorche(x, y)
rectangle(ecran, x - 4, y, 8, 34, #57381F)
rectangle(ecran, x - 8, y - 4, 16, 8, #3F3F46)
flamme est un nombre
flamme vaut (tic mod 4) * 2
ellipse(ecran, x, y - 16, 16, 22, rgba(251, 146, 60, 0.25))
polygone(ecran, x - 8, y - 4, x, y - 30 - flamme, x + 8, y - 4, #F97316)
polygone(ecran, x - 4, y - 4, x, y - 18 - flamme, x + 4, y - 4, #FDE047)
fin procédure
// la plaque qui porte une reponse
procédure plaque(x, y, lb, hb, txt, fond, coulTxt)
rectangle_arrondi(ecran, x - lb / 2, y, lb, hb, 6, rgba(0, 0, 0, 0.25))
rectangle_arrondi(ecran, x - lb / 2, y - 2, lb, hb, 6, fond)
appelle centrerAjuste(txt, x, y + hb / 2 + 5, coulTxt, 19, lb - 10)
fin procédure
@ DESSIN : LES CINQ SALLES
procédure fondSalle(s)
k est un nombre
si s = 0 alors
// la bibliotheque : boiseries et etageres
rectangle(ecran, 0, 0, 680, 520, #5B3A1E)
pour k de 0 à 7
rectangle(ecran, k * 90, 0, 4, 520, #4A2F17)
fin pour
rectangle(ecran, 0, 252, 680, 14, #8B5A2B)
rectangle(ecran, 0, 440, 680, 16, #8B5A2B)
// des petits livres sur l'etagere du haut
pour k de 0 à 33
lgL est un nombre
lgL vaut 12 + (k * 7) mod 9
hL est un nombre
hL vaut 50 + (k * 13) mod 22
rectangle(ecran, 4 + k * 20, 252 - hL, lgL, hL, COUL_PETITS[k mod 6])
fin pour
sinon si s = 1 alors
// le laboratoire : carrelage
rectangle(ecran, 0, 0, 680, 520, #134E4A)
pour k de 0 à 13
ligne(ecran, k * 52, 176, k * 52, 430, rgba(255, 255, 255, 0.07), 1)
fin pour
pour k de 0 à 5
ligne(ecran, 0, 176 + k * 52, 680, 176 + k * 52, rgba(255, 255, 255, 0.07), 1)
fin pour
rectangle(ecran, 0, 430, 680, 20, #E2E8F0)
rectangle(ecran, 0, 450, 680, 70, #334155)
sinon si s = 2 alors
// la salle du tresor : murs de pierre
rectangle(ecran, 0, 0, 680, 520, #44403C)
pour k de 0 à 9
decalP est un nombre
decalP vaut (k mod 2) * 40
j est un nombre
pour j de 0 à 8
rectangle_arrondi(ecran, j * 80 - decalP + 3, 180 + k * 30, 74, 26, 4, #57534E)
fin pour
fin pour
rectangle(ecran, 0, 420, 680, 100, #292524)
pour k de 0 à 7
ellipse(ecran, 40 + k * 90 + (k mod 3) * 9, 432 + (k mod 2) * 8, 9, 4, #EAB308)
fin pour
sinon si s = 3 alors
// l'observatoire : le ciel etoile
rectangle(ecran, 0, 0, 680, 520, #0B1026)
pour k de 0 à 59
sx est un nombre
sx vaut (k * 113) mod 680
sy est un nombre
sy vaut 180 + (k * 71) mod 250
cercle(ecran, sx, sy, 1 + (k mod 3) * 0.6, rgba(255, 255, 255, 0.35 + ((k + tic) mod 10) * 0.06))
fin pour
ellipse(ecran, 340, 470, 380, 60, #1E1B4B)
sinon
// la salle des cles : murs et torches
rectangle(ecran, 0, 0, 680, 520, #3B2F4A)
pour k de 0 à 9
decalP est un nombre
decalP vaut (k mod 2) * 45
j est un nombre
pour j de 0 à 8
rectangle(ecran, j * 90 - decalP + 2, 180 + k * 34, 86, 30, #4A3B5C)
fin pour
fin pour
rectangle(ecran, 0, 455, 680, 65, #241C2E)
appelle dessinerTorche(30, 260)
appelle dessinerTorche(650, 260)
fin si
fin procédure
procédure dessinerObjet(s, i, x)
txt est un texte
txt vaut opts[i]
si s = 0 alors
coulL est un texte
coulL vaut COUL_LIVRE[i]
rectangle_arrondi(ecran, x - 50, 272, 100, 166, 6, coulL)
rectangle(ecran, x - 50, 272, 14, 166, rgba(0, 0, 0, 0.25))
rectangle(ecran, x - 30, 286, 66, 3, #FCD34D)
rectangle(ecran, x - 30, 420, 66, 3, #FCD34D)
appelle plaque(x + 6, 330, 82, 44, txt, #FEF3C7, #3F2D20)
sinon si s = 1 alors
coulF est un texte
coulF vaut COUL_FIOLE[i]
rectangle(ecran, x - 13, 258, 26, 54, rgba(226, 232, 240, 0.55))
rectangle_arrondi(ecran, x - 16, 252, 32, 10, 3, #A16207)
cercle(ecran, x, 366, 54, rgba(226, 232, 240, 0.5))
cercle(ecran, x, 372, 46, coulF)
cercle(ecran, x - 14 + (tic mod 7) * 3, 400 - (tic * 3 + i * 9) mod 50, 4, rgba(255, 255, 255, 0.5))
cercle(ecran, x + 12, 392 - (tic * 2 + i * 13) mod 40, 3, rgba(255, 255, 255, 0.5))
ellipse(ecran, x - 22, 342, 8, 16, rgba(255, 255, 255, 0.35))
appelle plaque(x, 352, 92, 38, txt, #FFFFFF, #0F172A)
sinon si s = 2 alors
ellipse(ecran, x, 432, 62, 8, rgba(0, 0, 0, 0.35))
rectangle_arrondi(ecran, x - 56, 288, 112, 46, 16, #92400E)
rectangle(ecran, x - 54, 320, 108, 108, #78350F)
rectangle(ecran, x - 56, 318, 112, 8, #CA8A04)
rectangle(ecran, x - 40, 288, 10, 140, #CA8A04)
rectangle(ecran, x + 30, 288, 10, 140, #CA8A04)
appelle plaque(x, 352, 96, 40, txt, #FDE68A, #422006)
rectangle_arrondi(ecran, x - 8, 400, 16, 20, 4, #A16207)
cercle(ecran, x, 408, 3, #1C1917)
sinon si s = 3 alors
coulP est un texte
coulP vaut COUL_PLANETE[i]
cercle(ecran, x, 330, 58, rgba(255, 255, 255, 0.06))
cercle(ecran, x, 330, 50, coulP)
cercle(ecran, x - 16, 314, 18, rgba(255, 255, 255, 0.18))
si i = 1 alors
ellipse(ecran, x, 334, 70, 10, rgba(186, 230, 253, 0.55))
fin si
appelle plaque(x, 310, 92, 40, txt, rgba(15, 23, 42, 0.85), #F8FAFC)
sinon
coulC est un texte
coulC vaut COUL_CLE[i]
ligne(ecran, x, 200, x, 250, #78716C, 2)
cercle(ecran, x, 200, 5, #57534E)
cercle(ecran, x, 276, 28, coulC)
cercle(ecran, x, 276, 13, #3B2F4A)
rectangle(ecran, x - 7, 300, 14, 104, coulC)
rectangle(ecran, x + 7, 372, 18, 10, coulC)
rectangle(ecran, x + 7, 390, 12, 10, coulC)
appelle plaque(x, 408, 100, 38, txt, #F5F5F4, #1C1917)
fin si
si elimine[i] alors
rectangle_arrondi(ecran, x - 62, 236, 124, 214, 12, rgba(15, 15, 20, 0.55))
ligne(ecran, x - 36, 300, x + 36, 380, #EF4444, 7)
ligne(ecran, x + 36, 300, x - 36, 380, #EF4444, 7)
fin si
// le numero de l'objet (touches 1 a 4)
cercle(ecran, x - 50, 240, 13, #1E1B4B)
appelle centrer(convertir_texte(i + 1), x - 50, 246, #FDE68A, 15)
fin procédure
procédure dessinerQuestion()
rectangle_arrondi(ecran, 30, 56, 620, 122, 14, rgba(0, 0, 0, 0.3))
rectangle_arrondi(ecran, 30, 52, 620, 122, 14, #FEF3C7)
rectangle_arrondi(ecran, 38, 60, 604, 106, 10, #FFFBEB)
appelle centrerAjuste(qL1, 340, 98, #3F2D20, 21, 590)
si qDessin > 0 alors
k est un nombre
pour k de 0 à qDessin - 1
rang est un nombre
rang vaut arrondi_inferieur(k / 6)
parRang est un nombre
parRang vaut minimum(6, qDessin - rang * 6)
appelle dessinerEtoile(340 - (parRang - 1) * 22 + (k mod 6) * 44, 124 + rang * 30, 13, #F59E0B)
fin pour
sinon
appelle centrerAjuste(qL2, 340, 140, #7C2D12, 21, 590)
fin si
fin procédure
procédure dessinerHaut()
rectangle(ecran, 0, 0, 680, 44, #1E1B4B)
label(ecran, 14, 28, "Le Château des Nombres", #FDE68A, 16)
si etat = 4 alors
appelle centrer("La grande porte", 400, 28, #E0E7FF, 14)
sinon
appelle centrer("Salle " + convertir_texte(salle + 1) + "/5 · " + NOMS_SALLE[salle], 400, 28, #E0E7FF, 14)
fin si
rectangle_arrondi(ecran, 560, 8, 110, 28, 14, #312E81)
appelle centrer(NOMS_NIV[niveau] + " · " + texteTemps(tempsEcoule()), 615, 27, #FFFFFF, 13)
fin procédure
procédure dessinerBas()
rectangle(ecran, 0, 466, 680, 54, rgba(15, 12, 40, 0.92))
label(ecran, 14, 498, "Code :", #C7D2FE, 13)
i est un nombre
pour i de 0 à 4
x est un nombre
x vaut 66 + i * 50
connu est un booléen
connu vaut faux
si i < salle alors
connu vaut vrai
fin si
si etat = 3 et i = salle alors
connu vaut vrai
fin si
si connu alors
rectangle_arrondi(ecran, x, 474, 42, 38, 6, #FEF3C7)
appelle centrer(convertir_texte(codeSecret[i]), x + 21, 502, #7C2D12, 22)
sinon
rectangle_arrondi(ecran, x, 474, 42, 38, 6, #312E81)
appelle centrer("?", x + 21, 501, #6366F1, 20)
fin si
fin pour
si etat = 2 alors
appelle bouton(400, 476, 130, 34, "Indice (I)", #CA8A04, #FFFFFF, 14)
fin si
appelle bouton(546, 476, 120, 34, "Menu", #4338CA, #FFFFFF, 14)
fin procédure
procédure dessinerMessage()
si msgVie > 0 alors
coulM est un texte
coulM vaut #B91C1C
si msgCoul = 2 alors
coulM vaut #A16207
fin si
rectangle_arrondi(ecran, 90, 186, 500, 32, 16, coulM)
appelle centrerAjuste(msgTxt, 340, 208, #FFFFFF, 15, 480)
fin si
fin procédure
procédure dessinerSalle()
appelle fondSalle(salle)
i est un nombre
pour i de 0 à 3
x est un nombre
x vaut OBJ_X[i]
si secousse > 0 et secObjet = i alors
x vaut x + sinus(tic * 2.5) * 6
fin si
appelle dessinerObjet(salle, i, x)
fin pour
appelle dessinerQuestion()
appelle dessinerHaut()
appelle dessinerBas()
appelle dessinerMessage()
fin procédure
@ DESSIN : LES AUTRES ECRANS
procédure chateauNuit()
// le ciel et la silhouette du chateau
k est un nombre
pour k de 0 à 12
rectangle(ecran, 0, k * 40, 680, 41, rgba(30 + k * 4, 27 + k * 3, 75 + k * 5, 1))
fin pour
pour k de 0 à 39
cercle(ecran, (k * 97) mod 680, (k * 53) mod 300, 1 + (k mod 3) * 0.5, rgba(255, 255, 255, 0.4 + ((k + tic) mod 8) * 0.07))
fin pour
cercle(ecran, 628, 64, 30, #FEF9C3)
cercle(ecran, 640, 57, 26, rgba(30, 27, 75, 1))
rectangle(ecran, 0, 440, 680, 80, #0F0A24)
rectangle(ecran, 180, 300, 320, 150, #1A1238)
rectangle(ecran, 140, 240, 70, 210, #1A1238)
rectangle(ecran, 470, 240, 70, 210, #1A1238)
rectangle(ecran, 300, 210, 80, 100, #1A1238)
polygone(ecran, 130, 240, 175, 180, 220, 240, #1A1238)
polygone(ecran, 460, 240, 505, 180, 550, 240, #1A1238)
polygone(ecran, 290, 210, 340, 140, 390, 210, #1A1238)
pour k de 0 à 7
rectangle(ecran, 180 + k * 40, 288, 20, 14, #1A1238)
fin pour
rectangle(ecran, 160, 280, 12, 18, #FDE047)
rectangle(ecran, 500, 300, 12, 18, #FDE047)
rectangle(ecran, 334, 240, 12, 18, #FDE047)
fin procédure
// la position du bouton de chaque classe
fonction niveauX(k)
si k <= 4 alors
retourne 58 + k * 116
sinon si k <= 8 alors
retourne 116 + (k - 5) * 116
fin si
retourne 174 + (k - 9) * 116
fin fonction
fonction niveauY(k)
si k <= 4 alors
retourne 140
sinon si k <= 8 alors
retourne 260
fin si
retourne 380
fin fonction
procédure boutonNiveau(k)
x est un nombre
x vaut niveauX(k)
y est un nombre
y vaut niveauY(k)
rectangle_arrondi(ecran, x, y + 4, 100, 84, 14, rgba(0, 0, 0, 0.35))
rectangle_arrondi(ecran, x, y, 100, 84, 14, COUL_NIV[k])
appelle centrerAjuste(NOMS_NIV[k], x + 50, y + 38, #FFFFFF, 22, 90)
e est un nombre
pour e de 0 à 2
coulE est un texte
coulE vaut rgba(255, 255, 255, 0.3)
si e < meilleurEt[k] alors
coulE vaut #FDE047
fin si
appelle dessinerEtoile(x + 28 + e * 22, y + 58, 9, coulE)
fin pour
si meilleurTps[k] > 0 alors
appelle centrer(texteTemps(meilleurTps[k]), x + 50, y + 80, rgba(255, 255, 255, 0.85), 10)
fin si
fin procédure
procédure ecranMenu()
appelle chateauNuit()
rectangle(ecran, 0, 0, 680, 520, rgba(10, 8, 30, 0.45))
appelle centrer("Le Château des Nombres", 340, 62, #FDE68A, 34)
appelle centrer("Un escape game de maths : choisis ta classe !", 340, 92, #C7D2FE, 15)
appelle centrer("École", 340, 130, #86EFAC, 14)
appelle centrer("Collège", 340, 250, #93C5FD, 14)
appelle centrer("Lycée", 340, 370, #D8B4FE, 14)
k est un nombre
pour k de 0 à NB_NIV - 1
appelle boutonNiveau(k)
fin pour
fin procédure
procédure ecranHistoire()
appelle chateauNuit()
rectangle(ecran, 0, 0, 680, 520, rgba(10, 8, 30, 0.5))
rectangle_arrondi(ecran, 70, 70, 540, 380, 22, #FEF3C7)
rectangle_arrondi(ecran, 80, 80, 520, 360, 16, #FFFBEB)
appelle centrer("Enfermé dans le château !", 340, 130, #7C2D12, 28)
appelle centrer("Niveau " + NOMS_NIV[niveau], 340, 160, #A16207, 16)
label(ecran, 112, 204, "Le sorcier Mathémagus t'a enfermé dans son château.", #3F2D20, 15)
label(ecran, 112, 232, "Pour sortir, traverse ses 5 salles.", #3F2D20, 15)
label(ecran, 112, 270, "Dans chaque salle, une énigme t'attend : clique", #3F2D20, 15)
label(ecran, 112, 296, "sur l'objet qui porte la bonne réponse. Il cache", #3F2D20, 15)
label(ecran, 112, 322, "un chiffre du code de la grande porte.", #3F2D20, 15)
label(ecran, 112, 360, "Chaque erreur ou indice ajoute 15 secondes.", #B45309, 14)
appelle bouton(240, 384, 200, 46, "Entrer !", sialors(tic mod 16 < 8, #7C3AED, #6D28D9), #FFFFFF, 18)
fin procédure
procédure ecranTrouve()
rectangle(ecran, 0, 0, 680, 520, rgba(10, 8, 30, 0.55))
rectangle_arrondi(ecran, 150, 110, 380, 300, 22, #FEF3C7)
appelle centrer("Bravo !", 340, 160, #15803D, 30)
appelle centrer("La bonne réponse était : " + opts[bonneIdx], 340, 192, #3F2D20, 15)
appelle centrer("Tu trouves un petit papier caché :", 340, 222, #7C2D12, 14)
// le papier avec le chiffre secret
rectangle_arrondi(ecran, 288, 236, 104, 96, 8, rgba(0, 0, 0, 0.2))
rectangle_arrondi(ecran, 284, 232, 104, 96, 8, #FFFFFF)
ligne(ecran, 294, 252, 378, 252, #BFDBFE, 1)
appelle centrer(convertir_texte(codeSecret[salle]), 336, 306, #B91C1C, 58)
texteBouton est un texte
texteBouton vaut "Salle suivante"
si salle = 4 alors
texteBouton vaut "Vers la grande porte"
fin si
appelle bouton(230, 348, 220, 46, texteBouton, #16A34A, #FFFFFF, 16)
fin procédure
fonction toucheX(k)
retourne 430 + (k mod 3) * 66
fin fonction
fonction toucheY(k)
retourne 196 + arrondi_inferieur(k / 3) * 58
fin fonction
// les touches du clavier : 1 2 3 / 4 5 6 / 7 8 9 / effacer 0
fonction valeurTouche(k)
si k <= 8 alors
retourne k + 1
sinon si k = 10 alors
retourne 0
fin si
retourne -1
fin fonction
procédure ecranPorte()
rectangle(ecran, 0, 0, 680, 520, #2A1F14)
k est un nombre
pour k de 0 à 9
rectangle(ecran, 0, 44 + k * 44, 680, 2, #3A2A1B)
fin pour
// la grande porte
dx est un nombre
dx vaut 0
si secousse > 0 alors
dx vaut sinus(tic * 2.5) * 5
fin si
rectangle_arrondi(ecran, 60 + dx, 90, 290, 360, 30, #3F2A18)
rectangle(ecran, 74 + dx, 110, 128, 340, #7C4A21)
rectangle(ecran, 208 + dx, 110, 128, 340, #7C4A21)
pour k de 0 à 2
rectangle(ecran, 74 + dx, 150 + k * 110, 262, 12, #2D2D2D)
fin pour
// le cadenas
rectangle_arrondi(ecran, 170 + dx, 240, 70, 44, 8, #A16207)
ligne(ecran, 182 + dx, 240, 182 + dx, 222, #9CA3AF, 7)
ligne(ecran, 228 + dx, 240, 228 + dx, 222, #9CA3AF, 7)
ligne(ecran, 182 + dx, 222, 228 + dx, 222, #9CA3AF, 7)
cercle(ecran, 205 + dx, 258, 6, #1C1917)
rectangle(ecran, 202 + dx, 260, 6, 12, #1C1917)
// l'ecran du cadenas
rectangle_arrondi(ecran, 404, 70, 250, 110, 14, #0F172A)
appelle centrer("Tape le code (dans l'ordre des salles)", 529, 96, #C7D2FE, 12)
i est un nombre
pour i de 0 à 4
rectangle_arrondi(ecran, 418 + i * 46, 112, 38, 50, 6, #1E293B)
si i < nbSaisis alors
appelle centrer(convertir_texte(codeTape[i]), 437 + i * 46, 148, #4ADE80, 26)
sinon si i = nbSaisis et tic mod 10 < 5 alors
rectangle(ecran, 427 + i * 46, 152, 20, 3, #4ADE80)
fin si
fin pour
pour k de 0 à 11
v est un nombre
v vaut valeurTouche(k)
si v >= 0 alors
appelle bouton(toucheX(k), toucheY(k), 58, 48, convertir_texte(v), #334155, #FFFFFF, 20)
sinon si k = 9 alors
appelle bouton(toucheX(k), toucheY(k), 58, 48, "Effacer", #9A3412, #FFFFFF, 12)
fin si
fin pour
appelle dessinerHaut()
appelle dessinerBas()
si msgVie > 0 alors
rectangle_arrondi(ecran, 40, 420, 600, 34, 17, #B91C1C)
appelle centrerAjuste(msgTxt, 340, 443, #FFFFFF, 14, 580)
fin si
fin procédure
procédure ecranVictoire()
// le lever du soleil hors du chateau
k est un nombre
pour k de 0 à 12
rectangle(ecran, 0, k * 40, 680, 41, rgba(251 - k * 6, 191 - k * 4, 36 + k * 14, 1))
fin pour
cercle(ecran, 340, 330, 90, #FDE68A)
rectangle(ecran, 0, 330, 680, 190, #65A30D)
polygone(ecran, 300, 520, 340, 330, 380, 520, #D6B37C)
rectangle(ecran, 40, 250, 100, 90, #57534E)
polygone(ecran, 30, 250, 90, 190, 150, 250, #44403C)
rectangle_arrondi(ecran, 170, 70, 340, 330, 22, #FFFBEB)
appelle centrer("Libre !", 340, 120, #15803D, 34)
appelle centrer("Tu t'es échappé du château", 340, 150, #3F2D20, 16)
appelle centrer("Niveau " + NOMS_NIV[niveau], 340, 176, #A16207, 14)
e est un nombre
pour e de 0 à 2
coulE est un texte
coulE vaut #E7E5E4
si e < etoilesFinales alors
coulE vaut #F59E0B
fin si
appelle dessinerEtoile(280 + e * 60, 222, 24, coulE)
fin pour
appelle centrer("Temps : " + texteTemps(tempsFinal), 340, 278, #1C1917, 18)
appelle centrer(convertir_texte(nbErreurs) + " erreur" + sialors(nbErreurs > 1, "s", "") + " · " + convertir_texte(indices) + " indice" + sialors(indices > 1, "s", ""), 340, 302, #57534E, 14)
si nouveauRecord alors
appelle centrer("Nouveau record !", 340, 326, #DC2626, 15)
fin si
appelle bouton(196, 342, 136, 44, "Rejouer", #16A34A, #FFFFFF, 16)
appelle bouton(348, 342, 136, 44, "Menu", #4338CA, #FFFFFF, 16)
fin procédure
procédure dessiner()
effacer(ecran)
si etat = 0 alors
appelle ecranMenu()
sinon si etat = 1 alors
appelle ecranHistoire()
sinon si etat = 2 ou etat = 3 alors
appelle dessinerSalle()
si etat = 3 alors
appelle ecranTrouve()
fin si
sinon si etat = 4 alors
appelle ecranPorte()
sinon
appelle ecranVictoire()
fin si
fin procédure
@ LES COMMANDES
// actions : 0 clic, 1 a 9 touches 1 a 9, 10 touche 0, 11 indice
procédure lireOrdre(act, x, y)
si etat = 0 alors
si act = 0 alors
k est un nombre
pour k de 0 à NB_NIV - 1
si clique(x, y, niveauX(k), niveauY(k), 100, 84) alors
appelle commencer(k)
fin si
fin pour
fin si
sinon si etat = 1 alors
si act = 0 et clique(x, y, 240, 384, 200, 46) alors
debutChrono vaut chrono()
etat vaut 2
fin si
sinon si etat = 2 alors
si act >= 1 et act <= 4 alors
appelle choisirObjet(act - 1)
sinon si act = 11 alors
appelle donnerIndice()
sinon si act = 0 alors
si clique(x, y, 400, 476, 130, 34) alors
appelle donnerIndice()
sinon si clique(x, y, 546, 476, 120, 34) alors
etat vaut 0
sinon
i est un nombre
pour i de 0 à 3
si clique(x, y, OBJ_X[i] - 62, 236, 124, 214) alors
appelle choisirObjet(i)
fin si
fin pour
fin si
fin si
sinon si etat = 3 alors
si act = 0 et clique(x, y, 230, 348, 220, 46) alors
appelle salleSuivante()
fin si
sinon si etat = 4 alors
si act >= 1 et act <= 9 alors
appelle taperChiffre(act)
sinon si act = 10 alors
appelle taperChiffre(0)
sinon si act = 0 alors
si clique(x, y, 546, 476, 120, 34) alors
etat vaut 0
fin si
k est un nombre
pour k de 0 à 11
si clique(x, y, toucheX(k), toucheY(k), 58, 48) alors
si valeurTouche(k) >= 0 alors
appelle taperChiffre(valeurTouche(k))
sinon si k = 9 alors
nbSaisis vaut 0
fin si
fin si
fin pour
fin si
sinon si etat = 5 alors
si act = 0 alors
si clique(x, y, 196, 342, 136, 44) alors
appelle commencer(niveau)
sinon si clique(x, y, 348, 342, 136, 44) alors
etat vaut 0
fin si
fin si
fin si
fin procédure
@ LE PROCESSUS
processus Chateau()
tant que appActif
tic vaut tic + 1
nbLus est un nombre
nbLus vaut 0
tant que teteO <> queueO et nbLus < 6
appelle lireOrdre(ordres[teteO], ordX[teteO], ordY[teteO])
teteO vaut (teteO + 1) mod 32
nbLus vaut nbLus + 1
fin tant que
si msgVie > 0 alors
msgVie vaut msgVie - 1
fin si
si secousse > 0 alors
secousse vaut secousse - 1
fin si
appelle dessiner()
affiche ecran
pause 60
fin tant que
effacer(ecran)
rectangle(ecran, 0, 0, 680, 520, #1E1B4B)
appelle centrer("Le château t'attend pour une nouvelle évasion !", 340, 260, #FDE68A, 20)
affiche ecran
fin processus
@ DEMARRAGE
appelle dessiner()
affiche ecran
Chateau()
tant que appActif
interagir ecran, ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "i", "x"] dans action, sourisX, sourisY
si action = 12 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