Laboratoire fou

CoddyRun Le code, en toute simplicité
Laboratoire fou Prêt
Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
@ CONFIGURATION
ecran est une toile
dimension(ecran, 560, 550)

PLAFOND est un nombre
PLAFOND vaut 1000000000000000
SEUIL_NOBEL est un nombre
SEUIL_NOBEL vaut 1000000
SUFFIXES est un tableau
SUFFIXES vaut ["k", "M", "Md", "Bn", "Bd", "Tn", "Td", "Qn", "Qd"]
FIOLE_X est un nombre
FIOLE_X vaut 145
FIOLE_Y est un nombre
FIOLE_Y vaut 300
PANNEAU_X est un nombre
PANNEAU_X vaut 290

@ LES MACHINES
NB_M est un nombre
NB_M vaut 7
NOMS_M est un tableau
NOMS_M vaut ["Bec Bunsen", "Alambic", "Centrifugeuse", "Robot assistant", "Bobine Tesla", "Réacteur à plasma", "Cloneur moléculaire"]
PRIX_M est un tableau
PRIX_M vaut [15, 100, 1100, 12000, 130000, 1400000, 20000000]
PROD_M est un tableau
PROD_M vaut [0.1, 1, 8, 47, 260, 1400, 7800]
COUL_M est un tableau
COUL_M vaut [#F97316, #38BDF8, #A3E635, #94A3B8, #A78BFA, #F472B6, #2DD4BF]
possedes, nivMachine est un tableau
debloque est un tableau
pour ki de 0 à NB_M - 1
  possedes ajoute 0
  nivMachine ajoute 0
  debloque ajoute faux
fin pour

@ L'ARBRE DES RECHERCHES
// type : 0 debloque une machine, 1 machine x2, 2 clic x2,
//        3 production x1,5 ou x2, 4 recherches 2 fois plus rapides, 5 bulles dorees
NB_R est un nombre
NB_R vaut 16
rNom est un tableau
rNom vaut ["Chimie de base", "Distillation", "Gants isolants", "Catalyseur", "Physique rotative", "Lunettes de génie", "Alambic doré", "Robotique", "Bulles d'or", "Mécanique fine", "Électricité folle", "Doigts atomiques", "Robots jumeaux", "Fusion contrôlée", "Génie absolu", "Clonage"]
rType est un tableau
rType vaut [1, 0, 2, 3, 0, 4, 1, 0, 5, 1, 0, 2, 1, 0, 3, 0]
rCible est un tableau
rCible vaut [0, 1, 0, 0, 2, 0, 1, 3, 0, 2, 4, 0, 3, 5, 0, 6]
rParent est un tableau
rParent vaut [-1, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
rCout est un tableau
rCout vaut [30, 80, 150, 400, 900, 2000, 3000, 10000, 25000, 40000, 120000, 300000, 500000, 2000000, 5000000, 20000000]
rDuree est un tableau
rDuree vaut [8, 15, 20, 30, 40, 45, 60, 90, 90, 120, 150, 180, 180, 240, 300, 360]
rCol est un tableau
rCol vaut [1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
rRang est un tableau
rRang vaut [0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5]
rFait est un tableau
pour ki de 0 à NB_R - 1
  rFait ajoute faux
fin pour
rechEnCours est un nombre
rechEnCours vaut -1
rechReste est un nombre
rechChoisie est un nombre
rechChoisie vaut 0
// effets des recherches
nivClic, nivGlobal, vitesseRech, freqBulle est un nombre

@ LA PARTIE
molecules, totalPartie, totalTout, nobels est un nombre
reaction est un nombre
quantite est un nombre
quantite vaut 1
onglet est un nombre
// etat : 1 jeu, 4 confirmer le Nobel, 5 retour, 6 accueil, 7 ceremonie
etat est un nombre
etat vaut 6
appActif est un booléen
appActif vaut vrai
tic est un nombre
derniereMesure est un nombre
sauveAttente est un nombre
sauveAttente vaut 15
horodatage est un nombre
gainAbsence, dureeAbsence est un nombre
ceremonie, nobelsGagnes est un nombre
choc est un nombre
// la bulle doree
bulleAttente est un nombre
bulleAttente vaut 40
bulleVie, bulleX0 est un nombre
msgTxt est un texte
msgTxt vaut ""
msgVie est un nombre
// bulles de la fiole, textes qui s'envolent, eclaboussures
buX, buY, buR, buV est un tableau
pour ki de 0 à 13
  buX ajoute FIOLE_X - 30 + hasard(0, 60)
  buY ajoute FIOLE_Y + hasard(-10, 40)
  buR ajoute hasard(2, 6)
  buV ajoute hasard(15, 40)
fin pour
ftX, ftY, ftVie, ftTxt est un tableau
pour ki de 0 à 11
  ftX ajoute 0
  ftY ajoute 0
  ftVie ajoute 0
  ftTxt ajoute ""
fin pour
ftProchain est un nombre
gtX, gtY, gtVX, gtVY, gtVie est un tableau
pour ki de 0 à 29
  gtX ajoute 0
  gtY ajoute 0
  gtVX ajoute 0
  gtVY ajoute 0
  gtVie ajoute 0
fin pour
gtProchain est un nombre
ptsEtoile est un tableau
pour ki de 0 à 19
  ptsEtoile ajoute 0
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 aDroite(txt, xFin, yTxt, coul, taillePolice)
  label(ecran, xFin - label_largeur(txt, taillePolice), 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.3))
  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

fonction nombreTexte(v)
  si v < 1000 alors
    retourne convertir_texte(arrondi_inferieur(v))
  fin si
  w est un nombre
  w vaut v
  e est un nombre
  e vaut 0
  tant que w >= 1000 et e < 9
    w vaut w / 1000
    e vaut e + 1
  fin tant que
  t est un texte
  si w < 10 alors
    t vaut convertir_texte(arrondi_inferieur(w * 100) / 100)
  sinon si w < 100 alors
    t vaut convertir_texte(arrondi_inferieur(w * 10) / 10)
  sinon
    t vaut convertir_texte(arrondi_inferieur(w))
  fin si
  retourne remplacer(t, ".", ",") + " " + SUFFIXES[e - 1]
fin fonction

fonction nombreProd(v)
  si v < 100 alors
    retourne remplacer(convertir_texte(arrondi_inferieur(v * 10) / 10), ".", ",")
  fin si
  retourne nombreTexte(v)
fin fonction

fonction dureeTexte(sec)
  s est un nombre
  s vaut arrondi_inferieur(limiter(sec, 0, 100000000))
  si s < 60 alors
    retourne convertir_texte(s) + " s"
  fin si
  hh est un nombre
  hh vaut arrondi_inferieur(s / 3600)
  mi est un nombre
  mi vaut arrondi_inferieur((s mod 3600) / 60)
  si hh = 0 alors
    retourne convertir_texte(mi) + " min"
  fin si
  retourne convertir_texte(hh) + " h " + convertir_texte(mi) + " min"
fin fonction

// 75 -> "1:15"
fonction minuteur(sec)
  s est un nombre
  s vaut arrondi_superieur(limiter(sec, 0, 100000))
  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

@ LA PRODUCTION
// x * y avec y >= 1, sans jamais depasser le plafond
fonction mulSur(x, y)
  si x > PLAFOND / y alors
    retourne PLAFOND
  fin si
  retourne x * y
fin fonction

fonction bonusNobel()
  retourne 1 + nobels * 0.15
fin fonction

fonction multGlobal()
  m est un nombre
  m vaut 1
  si rFait[3] alors
    m vaut m * 1.5
  fin si
  si rFait[14] alors
    m vaut m * 2
  fin si
  retourne mulSur(m, bonusNobel())
fin fonction

fonction prodMachine(p)
  base est un nombre
  base vaut PROD_M[p] * possedes[p] * puissance(2, nivMachine[p])
  retourne mulSur(base, multGlobal())
fin fonction

fonction prodSec()
  s est un nombre
  s vaut 0
  p est un nombre
  pour p de 0 à NB_M - 1
    s vaut minimum(s + prodMachine(p), PLAFOND)
  fin pour
  si reaction > 0 alors
    s vaut minimum(s, PLAFOND / 7) * 7
  fin si
  retourne s
fin fonction

fonction valeurClic()
  v est un nombre
  v vaut mulSur(puissance(2, nivClic), bonusNobel())
  si rFait[11] alors
    v vaut v + prodSec() * 0.02
  fin si
  retourne minimum(v, PLAFOND)
fin fonction

// prix de n machines de type p (PLAFOND quand c'est hors de portee)
fonction prix(p, n)
  si possedes[p] > 220 alors
    retourne PLAFOND
  fin si
  unite est un nombre
  unite vaut puissance(1.15, possedes[p])
  si unite > PLAFOND / PRIX_M[p] alors
    retourne PLAFOND
  fin si
  unite vaut unite * PRIX_M[p]
  facteur est un nombre
  facteur vaut (puissance(1.15, n) - 1) / 0.15
  si unite > PLAFOND / facteur alors
    retourne PLAFOND
  fin si
  retourne minimum(arrondi_superieur(unite * facteur), PLAFOND)
fin fonction

fonction nobelsGagnables()
  retourne arrondi_inferieur(racine(totalPartie / SEUIL_NOBEL))
fin fonction

@ LES RECHERCHES
procédure recalculerEffets()
  k est un nombre
  pour k de 0 à NB_M - 1
    nivMachine[k] vaut 0
    debloque[k] vaut faux
  fin pour
  debloque[0] vaut vrai
  nivClic vaut 0
  vitesseRech vaut 1
  freqBulle vaut 1
  pour k de 0 à NB_R - 1
    si rFait[k] alors
      si rType[k] = 0 alors
        debloque[rCible[k]] vaut vrai
      sinon si rType[k] = 1 alors
        nivMachine[rCible[k]] vaut nivMachine[rCible[k]] + 1
      sinon si rType[k] = 2 alors
        nivClic vaut nivClic + 1
      sinon si rType[k] = 4 alors
        vitesseRech vaut 2
      sinon si rType[k] = 5 alors
        freqBulle vaut 2
      fin si
    fin si
  fin pour
fin procédure

// 0 : faite, 1 : en cours, 2 : disponible, 3 : verrouillee
fonction etatRech(k)
  si rFait[k] alors
    retourne 0
  fin si
  si rechEnCours = k alors
    retourne 1
  fin si
  si rParent[k] = -1 alors
    retourne 2
  fin si
  si rFait[rParent[k]] alors
    retourne 2
  fin si
  retourne 3
fin fonction

fonction texteEffet(k)
  si rType[k] = 0 alors
    retourne "Débloque : " + NOMS_M[rCible[k]]
  sinon si rType[k] = 1 alors
    retourne NOMS_M[rCible[k]] + " : production x2"
  sinon si rType[k] = 2 alors
    si k = 11 alors
      retourne "Clic x2 et +2 % de la production"
    fin si
    retourne "Clic x2"
  sinon si rType[k] = 3 alors
    si k = 3 alors
      retourne "Toute la production x1,5"
    fin si
    retourne "Toute la production x2"
  sinon si rType[k] = 4 alors
    retourne "Recherches 2 fois plus rapides"
  fin si
  retourne "Bulles dorées 2 fois plus fréquentes"
fin fonction

fonction nbRechDispo()
  n est un nombre
  n vaut 0
  k est un nombre
  pour k de 0 à NB_R - 1
    si etatRech(k) = 2 et molecules >= rCout[k] alors
      n vaut n + 1
    fin si
  fin pour
  retourne n
fin fonction

@ SAUVEGARDE
procédure lireHorloge()
  horodatage vaut 0
  essayer
    an est un nombre
    an vaut annee_de(maintenant())
    mo est un nombre
    mo vaut mois_de(maintenant())
    jo est un nombre
    jo vaut jour_de(maintenant())
    hr est un nombre
    hr vaut heure_de(maintenant())
    mn est un nombre
    mn vaut minute_de(maintenant())
    sd est un nombre
    sd vaut seconde_de(maintenant())
    valide est un booléen
    valide vaut vrai
    si an < 2000 ou an > 2200 ou mo < 1 ou mo > 12 ou jo < 1 ou jo > 31 alors
      valide vaut faux
    fin si
    si hr < 0 ou hr > 23 ou mn < 0 ou mn > 59 ou sd < 0 ou sd > 59 alors
      valide vaut faux
    fin si
    si valide alors
      horodatage vaut (((an - 2000) * 12 + mo) * 31 + jo) * 86400 + hr * 3600 + mn * 60 + sd
    fin si
  attraper
    horodatage vaut 0
  fin essayer
fin procédure

procédure sauverPartie()
  appelle lireHorloge()
  marques est un texte
  marques vaut ""
  k est un nombre
  pour k de 0 à NB_R - 1
    si rFait[k] alors
      marques vaut marques + "1"
    sinon
      marques vaut marques + "0"
    fin si
  fin pour
  essayer
    parametre('laboratoirefou', 'molecules', molecules)
    parametre('laboratoirefou', 'totalPartie', totalPartie)
    parametre('laboratoirefou', 'totalTout', totalTout)
    parametre('laboratoirefou', 'nobels', nobels)
    parametre('laboratoirefou', 'recherches', marques)
    parametre('laboratoirefou', 'rechEnCours', rechEnCours)
    parametre('laboratoirefou', 'rechReste', rechReste)
    parametre('laboratoirefou', 'horloge', horodatage)
    pour k de 0 à NB_M - 1
      parametre('laboratoirefou', 'm' + convertir_texte(k), possedes[k])
    fin pour
  attraper
    msgVie vaut 0
  fin essayer
fin procédure

procédure charger()
  essayer
    molecules vaut parametre('laboratoirefou', 'molecules')
    totalPartie vaut parametre('laboratoirefou', 'totalPartie')
    totalTout vaut parametre('laboratoirefou', 'totalTout')
    nobels vaut parametre('laboratoirefou', 'nobels')
    k est un nombre
    pour k de 0 à NB_M - 1
      possedes[k] vaut parametre('laboratoirefou', 'm' + convertir_texte(k))
    fin pour
    marques est un texte
    marques vaut parametre('laboratoirefou', 'recherches')
    pour k de 0 à NB_R - 1
      si copier(marques, k + 1, 1) = "1" alors
        rFait[k] vaut vrai
      fin si
    fin pour
    rechEnCours vaut limiter(parametre('laboratoirefou', 'rechEnCours'), -1, NB_R - 1)
    rechReste vaut parametre('laboratoirefou', 'rechReste')
    etat vaut 1
  attraper
    etat vaut 6
  fin essayer
  appelle recalculerEffets()
  si etat = 1 alors
    ancien est un nombre
    ancien vaut 0
    essayer
      ancien vaut parametre('laboratoirefou', 'horloge')
    attraper
      ancien vaut 0
    fin essayer
    si ancien < 0 ou ancien > 1000000000000 alors
      ancien vaut 0
    fin si
    appelle lireHorloge()
    // le labo a travaille pendant l'absence (a moitie, 8 heures au plus)
    si ancien > 0 et horodatage > ancien + 60 et horodatage < ancien + 5184000 alors
      dureeAbsence vaut horodatage - ancien
      gainAbsence vaut minimum(prodSec(), PLAFOND / 14400) * minimum(dureeAbsence, 28800) * 0.5
      molecules vaut minimum(molecules + gainAbsence, PLAFOND)
      totalPartie vaut minimum(totalPartie + gainAbsence, PLAFOND)
      totalTout vaut minimum(totalTout + gainAbsence, PLAFOND)
      // la recherche en cours a avance aussi
      si rechEnCours >= 0 alors
        rechReste vaut maximum(0.5, rechReste - dureeAbsence)
      fin si
      si gainAbsence >= 1 alors
        etat vaut 5
      fin si
    fin si
  fin si
fin procédure

@ LES ACTIONS
procédure annoncer(txt)
  msgTxt vaut txt
  msgVie vaut 3
fin procédure

procédure gagner(v)
  w est un nombre
  w vaut minimum(v, PLAFOND)
  molecules vaut minimum(molecules + w, PLAFOND)
  totalPartie vaut minimum(totalPartie + w, PLAFOND)
  totalTout vaut minimum(totalTout + w, PLAFOND)
fin procédure

procédure lancerTexte(x, y, txt)
  ftX[ftProchain] vaut x
  ftY[ftProchain] vaut y
  ftVie[ftProchain] vaut 1
  ftTxt[ftProchain] vaut txt
  ftProchain vaut (ftProchain + 1) mod 12
fin procédure

procédure lancerGoutte(x, y)
  gtX[gtProchain] vaut x
  gtY[gtProchain] vaut y
  gtVX[gtProchain] vaut hasard(-50, 50) / 10
  gtVY[gtProchain] vaut hasard(-70, -20) / 10
  gtVie[gtProchain] vaut 1
  gtProchain vaut (gtProchain + 1) mod 30
fin procédure

procédure acheterMachine(p)
  cout est un nombre
  cout vaut prix(p, quantite)
  si debloque[p] et cout < PLAFOND et molecules >= cout alors
    molecules vaut molecules - cout
    possedes[p] vaut possedes[p] + quantite
  fin si
fin procédure

procédure lancerRecherche(k)
  si rechEnCours = -1 et etatRech(k) = 2 et molecules >= rCout[k] alors
    molecules vaut molecules - rCout[k]
    rechEnCours vaut k
    rechReste vaut rDuree[k] / vitesseRech
    appelle annoncer("Recherche lancée : " + rNom[k])
  fin si
fin procédure

procédure finirRecherche()
  rFait[rechEnCours] vaut vrai
  appelle annoncer("Eurêka ! " + texteEffet(rechEnCours))
  rechEnCours vaut -1
  rechReste vaut 0
  appelle recalculerEffets()
fin procédure

procédure cliquerFiole(x, y)
  v est un nombre
  v vaut valeurClic()
  appelle gagner(v)
  choc vaut 1
  appelle lancerTexte(x, y - 12, "+" + nombreProd(v))
  ke est un nombre
  pour ke de 0 à 2
    appelle lancerGoutte(x, y)
  fin pour
  // chaque clic fait avancer la recherche en cours
  si rechEnCours >= 0 alors
    rechReste vaut rechReste - 0.25
  fin si
fin procédure

fonction bulleX()
  retourne bulleX0 + sinus(bulleVie * 1.3) * 26
fin fonction

fonction bulleY()
  retourne 100 + bulleVie * 30
fin fonction

procédure attraperBulle()
  bx est un nombre
  bx vaut bulleX()
  by est un nombre
  by vaut bulleY()
  si hasard(0, 1) = 0 ou prodSec() < 1 alors
    gain est un nombre
    gain vaut minimum(molecules * 0.15, minimum(prodSec(), PLAFOND / 900) * 900) + 50
    appelle gagner(gain)
    appelle annoncer("Bulle dorée : +" + nombreTexte(gain) + " molécules !")
    appelle lancerTexte(bx, by, "+" + nombreTexte(gain))
  sinon
    reaction vaut 30
    appelle annoncer("Réaction en chaîne : production x7 pendant 30 s !")
  fin si
  ke est un nombre
  pour ke de 0 à 7
    appelle lancerGoutte(bx, by)
  fin pour
  bulleVie vaut 0
fin procédure

procédure recevoirNobel()
  nobelsGagnes vaut nobelsGagnables()
  nobels vaut nobels + nobelsGagnes
  molecules vaut 0
  totalPartie vaut 0
  reaction vaut 0
  k est un nombre
  pour k de 0 à NB_M - 1
    possedes[k] vaut 0
  fin pour
  pour k de 0 à NB_R - 1
    rFait[k] vaut faux
  fin pour
  rechEnCours vaut -1
  rechReste vaut 0
  rechChoisie vaut 0
  appelle recalculerEffets()
  onglet vaut 0
  ceremonie vaut 2.5
  etat vaut 7
  appelle sauverPartie()
fin procédure

@ LE TEMPS QUI PASSE
procédure avancer(dt)
  appelle gagner(prodSec() * dt)
  si rechEnCours >= 0 alors
    rechReste vaut rechReste - dt
    si rechReste <= 0 alors
      appelle finirRecherche()
    fin si
  fin si
  si reaction > 0 alors
    reaction vaut reaction - dt
  fin si
  si bulleVie > 0 alors
    bulleVie vaut bulleVie - dt
  sinon
    bulleAttente vaut bulleAttente - dt * freqBulle
    si bulleAttente <= 0 alors
      bulleVie vaut 11
      bulleX0 vaut hasard(50, 240)
      bulleAttente vaut hasard(60, 120)
    fin si
  fin si
  si msgVie > 0 alors
    msgVie vaut msgVie - dt
  fin si
  si ceremonie > 0 alors
    ceremonie vaut ceremonie - dt
    si ceremonie <= 0 et etat = 7 alors
      etat vaut 1
      appelle annoncer("Un nouveau laboratoire t'attend !")
    fin si
  fin si
  choc vaut choc * 0.6
  k est un nombre
  // les bulles qui montent dans la fiole
  pour k de 0 à 13
    buY[k] vaut buY[k] - buV[k] * dt * (1 + minimum(possedes[0], 20) * 0.05)
    si buY[k] < FIOLE_Y - 20 alors
      buY[k] vaut FIOLE_Y + 50
      buX[k] vaut FIOLE_X - 40 + hasard(0, 80)
    fin si
  fin pour
  pour k de 0 à 11
    si ftVie[k] > 0 alors
      ftVie[k] vaut ftVie[k] - dt * 1.2
      ftY[k] vaut ftY[k] - dt * 45
    fin si
  fin pour
  pour k de 0 à 29
    si gtVie[k] > 0 alors
      gtVie[k] vaut gtVie[k] - dt * 1.5
      gtX[k] vaut gtX[k] + gtVX[k] * dt * 16
      gtY[k] vaut gtY[k] + gtVY[k] * dt * 16
      gtVY[k] vaut gtVY[k] + dt * 12
    fin si
  fin pour
fin procédure

@ DESSIN DES PETITS OBJETS
procédure dessinerMolecule(x, y, s)
  ligne(ecran, x - 7 * s, y + 4 * s, x, y, #E2E8F0, 2 * s)
  ligne(ecran, x + 7 * s, y + 4 * s, x, y, #E2E8F0, 2 * s)
  cercle(ecran, x, y, 5 * s, #22C55E)
  cercle(ecran, x - 7 * s, y + 4 * s, 3.5 * s, #F8FAFC)
  cercle(ecran, x + 7 * s, y + 4 * s, 3.5 * s, #F8FAFC)
  cercle(ecran, x - 1.5 * s, y - 1.5 * s, 1.8 * s, #BBF7D0)
fin procédure

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 dessinerNobel(x, y, r)
  cercle(ecran, x, y, r, #B45309)
  cercle(ecran, x, y, r * 0.85, #F59E0B)
  cercle(ecran, x, y, r * 0.6, #FCD34D)
  appelle dessinerEtoile(x, y, r * 0.45, #B45309)
fin procédure

procédure dessinerIcone(p, cx, cy, cache)
  c est un texte
  c vaut COUL_M[p]
  gris est un texte
  gris vaut #CBD5E1
  si cache alors
    c vaut #334155
    gris vaut #334155
  fin si
  si p = 0 alors
    rectangle(ecran, cx - 3, cy - 2, 6, 12, gris)
    rectangle_arrondi(ecran, cx - 9, cy + 9, 18, 5, 2, gris)
    polygone(ecran, cx - 5, cy - 3, cx, cy - 17, cx + 5, cy - 3, c)
    polygone(ecran, cx - 2, cy - 3, cx, cy - 10, cx + 2, cy - 3, #FDE68A)
  sinon si p = 1 alors
    cercle(ecran, cx - 3, cy + 4, 10, gris)
    cercle(ecran, cx - 3, cy + 6, 7, c)
    rectangle(ecran, cx - 5, cy - 12, 4, 8, gris)
    ligne(ecran, cx - 3, cy - 11, cx + 13, cy - 3, gris, 2.5)
    cercle(ecran, cx + 13, cy - 1, 2, c)
  sinon si p = 2 alors
    rectangle_arrondi(ecran, cx - 11, cy - 8, 22, 20, 5, gris)
    ellipse(ecran, cx, cy - 8, 11, 4, c)
    ellipse(ecran, cx, cy - 8, 6, 2, #0F172A)
    ligne(ecran, cx - 15, cy + 2, cx - 13, cy - 4, c, 1.5)
    ligne(ecran, cx + 15, cy + 2, cx + 13, cy - 4, c, 1.5)
  sinon si p = 3 alors
    ligne(ecran, cx, cy - 12, cx, cy - 16, gris, 2)
    cercle(ecran, cx, cy - 17, 2.5, #F87171)
    rectangle_arrondi(ecran, cx - 11, cy - 11, 22, 16, 5, c)
    rectangle(ecran, cx - 7, cy - 7, 14, 6, #0F172A)
    cercle(ecran, cx - 3, cy - 4, 1.8, #22D3EE)
    cercle(ecran, cx + 3, cy - 4, 1.8, #22D3EE)
    rectangle(ecran, cx - 6, cy + 6, 12, 7, gris)
  sinon si p = 4 alors
    rectangle(ecran, cx - 3, cy - 6, 6, 18, gris)
    k est un nombre
    pour k de 0 à 4
      ellipse(ecran, cx, cy - 4 + k * 3.5, 7, 1.6, #B45309)
    fin pour
    cercle(ecran, cx, cy - 11, 5, c)
    ligne(ecran, cx + 4, cy - 13, cx + 12, cy - 17, #FEF08A, 1.5)
    ligne(ecran, cx - 4, cy - 13, cx - 12, cy - 9, #FEF08A, 1.5)
  sinon si p = 5 alors
    ellipse(ecran, cx, cy, 15, 5, c)
    cercle(ecran, cx, cy, 8, gris)
    cercle(ecran, cx, cy, 5, c)
    cercle(ecran, cx - 1.5, cy - 1.5, 2, #FFFFFF)
    ellipse(ecran, cx, cy + 2, 15, 3, rgba(244, 114, 182, 0.6))
  sinon
    rectangle_arrondi(ecran, cx - 15, cy - 11, 12, 22, 5, gris)
    rectangle_arrondi(ecran, cx + 3, cy - 11, 12, 22, 5, gris)
    rectangle_arrondi(ecran, cx - 13, cy - 8, 8, 14, 3, c)
    rectangle_arrondi(ecran, cx + 5, cy - 8, 8, 14, 3, c)
    ligne(ecran, cx - 3, cy, cx + 3, cy, #FEF08A, 2)
  fin si
fin procédure

@ DESSIN DU LABO
procédure dessinerLabo()
  rectangle(ecran, 0, 0, PANNEAU_X, 550, #123B3E)
  // le carrelage
  k est un nombre
  pour k de 0 à 9
    ligne(ecran, k * 32, 96, k * 32, 410, rgba(255, 255, 255, 0.05), 1)
  fin pour
  pour k de 0 à 9
    ligne(ecran, 0, 96 + k * 32, PANNEAU_X, 96 + k * 32, rgba(255, 255, 255, 0.05), 1)
  fin pour
  // l'etagere et ses bocaux
  rectangle(ecran, 14, 150, 262, 6, #7C4A1E)
  rectangle(ecran, 14, 156, 262, 3, #5B3413)
  rectangle_arrondi(ecran, 26, 118, 22, 32, 5, rgba(186, 230, 253, 0.35))
  rectangle_arrondi(ecran, 29, 130, 16, 18, 3, #F472B6)
  rectangle_arrondi(ecran, 58, 126, 18, 24, 4, rgba(186, 230, 253, 0.35))
  rectangle_arrondi(ecran, 61, 134, 12, 14, 3, #A3E635)
  cercle(ecran, 222, 136, 13, rgba(186, 230, 253, 0.35))
  cercle(ecran, 222, 139, 9, #FB923C)
  rectangle(ecran, 218, 118, 8, 8, rgba(186, 230, 253, 0.35))
  rectangle_arrondi(ecran, 246, 112, 18, 38, 4, rgba(186, 230, 253, 0.35))
  rectangle_arrondi(ecran, 249, 128, 12, 20, 3, #38BDF8)
  // un tableau noir avec une formule
  rectangle_arrondi(ecran, 92, 104, 104, 40, 4, #7C4A1E)
  rectangle(ecran, 96, 108, 96, 32, #1E293B)
  label(ecran, 103, 129, "E = mc", #E2E8F0, 13)
  label(ecran, 150, 122, "2", #E2E8F0, 9)
  label(ecran, 160, 129, "+ ?", #FDE047, 13)
  // la paillasse
  rectangle(ecran, 0, 392, PANNEAU_X, 18, #E2E8F0)
  rectangle(ecran, 0, 410, PANNEAU_X, 140, #334155)
  // les machines posees sur la paillasse
  si possedes[1] > 0 alors
    appelle dessinerIcone(1, 24, 376, faux)
  fin si
  si possedes[2] > 0 alors
    appelle dessinerIcone(2, 230, 378, faux)
  fin si
  si possedes[3] > 0 alors
    appelle dessinerIcone(3, 252, 230, faux)
    ligne(ecran, 252, 244, 232 + sinus(tic * 0.2) * 6, 268, #94A3B8, 3)
  fin si
  si possedes[4] > 0 alors
    appelle dessinerIcone(4, 34, 230, faux)
    si tic mod 8 < 3 alors
      ligne(ecran, 34, 219, 52, 200 + hasard(0, 10), #FEF08A, 1.5)
      ligne(ecran, 52, 205, 70, 214, #FEF08A, 1.5)
    fin si
  fin si
  si possedes[5] > 0 alors
    cercle(ecran, 64, 378, 16, rgba(244, 114, 182, 0.15 + (tic mod 6) * 0.03))
    appelle dessinerIcone(5, 64, 378, faux)
  fin si
  si possedes[6] > 0 alors
    appelle dessinerIcone(6, 266, 378, faux)
  fin si
fin procédure

procédure dessinerFiole()
  ech est un nombre
  ech vaut 1 - choc * 0.05
  fx est un nombre
  fx vaut FIOLE_X
  fy est un nombre
  fy vaut FIOLE_Y
  // la couleur du liquide change doucement
  teinte est un nombre
  teinte vaut arrondi_inferieur(tic / 40) mod 4
  liquide est un texte
  liquide vaut #22C55E
  si teinte = 1 alors
    liquide vaut #A855F7
  sinon si teinte = 2 alors
    liquide vaut #06B6D4
  sinon si teinte = 3 alors
    liquide vaut #F43F5E
  fin si
  // le bec bunsen sous la fiole
  si possedes[0] > 0 alors
    rectangle(ecran, fx - 6, fy + 72, 12, 18, #94A3B8)
    polygone(ecran, fx - 10, fy + 72, fx, fy + 54 - (tic mod 3) * 3, fx + 10, fy + 72, #F97316)
    polygone(ecran, fx - 5, fy + 72, fx, fy + 62, fx + 5, fy + 72, #FDE68A)
  fin si
  // le halo
  cercle(ecran, fx, fy + 10, 82 * ech, rgba(255, 255, 255, 0.04))
  // le verre : un col et un ventre
  polygone(ecran, fx - 14 * ech, fy - 78 * ech, fx + 14 * ech, fy - 78 * ech, fx + 14 * ech, fy - 30 * ech, fx + 62 * ech, fy + 52 * ech, fx - 62 * ech, fy + 52 * ech, fx - 14 * ech, fy - 30 * ech, rgba(224, 242, 254, 0.35))
  // le liquide
  polygone(ecran, fx - 36 * ech, fy + 6 * ech, fx + 36 * ech, fy + 6 * ech, fx + 58 * ech, fy + 48 * ech, fx - 58 * ech, fy + 48 * ech, liquide)
  ellipse(ecran, fx, fy + 6 * ech, 36 * ech, 5 * ech, rgba(255, 255, 255, 0.3))
  k est un nombre
  pour k de 0 à 13
    si buY[k] > fy + 6 alors
      cercle(ecran, buX[k] * ech + fx * (1 - ech), buY[k], buR[k], rgba(255, 255, 255, 0.45))
    fin si
  fin pour
  // le reflet et le bouchon
  polygone(ecran, fx - 9 * ech, fy - 72 * ech, fx - 5 * ech, fy - 72 * ech, fx - 5 * ech, fy - 32 * ech, fx - 40 * ech, fy + 30 * ech, fx - 46 * ech, fy + 30 * ech, fx - 9 * ech, fy - 32 * ech, rgba(255, 255, 255, 0.35))
  rectangle_arrondi(ecran, fx - 17 * ech, fy - 86 * ech, 34 * ech, 10 * ech, 3, #A16207)
  // la vapeur
  pour k de 0 à 3
    vy est un nombre
    vy vaut (tic * 2 + k * 18) mod 70
    cercle(ecran, fx + sinus((tic + k * 20) * 0.1) * 8, fy - 92 - vy, 5 + vy * 0.12, rgba(255, 255, 255, 0.25 - vy * 0.0035))
  fin pour
  rectangle_arrondi(ecran, fx - 62, fy + 52, 124, 6, 3, #CBD5E1)
fin procédure

procédure dessinerBulle()
  si bulleVie > 0 alors
    bx est un nombre
    bx vaut bulleX()
    by est un nombre
    by vaut bulleY()
    cercle(ecran, bx, by, 21, rgba(253, 224, 71, 0.25 + (tic mod 6) * 0.04))
    cercle(ecran, bx, by, 15, rgba(250, 204, 21, 0.85))
    cercle(ecran, bx - 5, by - 5, 5, #FEF9C3)
    cercle(ecran, bx + 6, by + 6, 2, rgba(255, 255, 255, 0.7))
  fin si
fin procédure

procédure dessinerGauche()
  appelle dessinerLabo()
  appelle dessinerFiole()
  appelle dessinerBulle()
  k est un nombre
  pour k de 0 à 29
    si gtVie[k] > 0 alors
      cercle(ecran, gtX[k], gtY[k], 1.5 + gtVie[k] * 2.5, rgba(134, 239, 172, gtVie[k]))
    fin si
  fin pour
  pour k de 0 à 11
    si ftVie[k] > 0 alors
      appelle centrer(ftTxt[k], ftX[k] + 1, ftY[k] + 1, rgba(0, 0, 0, 0.5 * limiter(ftVie[k], 0, 1)), 16)
      appelle centrer(ftTxt[k], ftX[k], ftY[k], rgba(255, 255, 255, limiter(ftVie[k], 0, 1)), 16)
    fin si
  fin pour
  // le compteur
  rectangle_arrondi(ecran, 14, 10, 262, 76, 16, rgba(2, 20, 22, 0.8))
  txt est un texte
  txt vaut nombreTexte(molecules)
  lt est un nombre
  lt vaut label_largeur(txt, 26)
  appelle dessinerMolecule(145 - lt / 2 - 16, 40, 1.2)
  label(ecran, 145 - lt / 2 + 4, 50, txt, #F8FAFC, 26)
  coulProd est un texte
  coulProd vaut #94A3B8
  si reaction > 0 alors
    coulProd vaut #FACC15
  fin si
  appelle centrer("molécules · " + nombreProd(prodSec()) + " par seconde", 145, 74, coulProd, 12)
  // la recherche en cours
  rectangle_arrondi(ecran, 14, 418, 262, 40, 10, #1E293B)
  si rechEnCours >= 0 alors
    part est un nombre
    part vaut 1 - limiter(rechReste / (rDuree[rechEnCours] / vitesseRech), 0, 1)
    rectangle_arrondi(ecran, 14, 418, 262 * part, 40, 10, rgba(168, 85, 247, 0.45))
    label(ecran, 24, 434, rNom[rechEnCours], #F1F5F9, 12)
    appelle aDroite(minuteur(rechReste), 266, 434, #E9D5FF, 12)
    label(ecran, 24, 451, "clique la fiole pour accélérer !", #C4B5FD, 10)
  sinon si nbRechDispo() > 0 alors
    appelle centrer("Une recherche peut être lancée !", 145, 443, sialors(tic mod 16 < 8, #FDE047, #FACC15), 13)
  sinon
    appelle centrer("Aucune recherche en cours", 145, 443, #64748B, 12)
  fin si
  si reaction > 0 alors
    rectangle_arrondi(ecran, 40, 96, 210, 20, 10, rgba(250, 204, 21, 0.2))
    rectangle_arrondi(ecran, 40, 96, 210 * limiter(reaction / 30, 0, 1), 20, 10, rgba(250, 204, 21, 0.55))
    appelle centrer("Réaction en chaîne x7 · " + convertir_texte(arrondi_superieur(reaction)) + " s", 145, 111, #FEF9C3, 11)
  sinon si msgVie > 0 alors
    rectangle_arrondi(ecran, 14, 94, 262, 22, 11, rgba(2, 20, 22, 0.8 * limiter(msgVie, 0, 1)))
    appelle centrer(msgTxt, 145, 110, rgba(254, 249, 195, limiter(msgVie, 0, 1)), 11)
  sinon si totalTout < 30 alors
    appelle centrer("Clique sur la fiole !", 145, 112, rgba(134, 239, 172, 0.6 + (tic mod 10) * 0.04), 14)
  fin si
  // le prix Nobel
  gainN est un nombre
  gainN vaut nobelsGagnables()
  si gainN >= 1 alors
    appelle bouton(20, 470, 250, 36, "Recevoir le prix Nobel : +" + convertir_texte(gainN), sialors(tic mod 16 < 8, #B45309, #92400E), #FFFFFF, 13)
  sinon
    appelle bouton(20, 470, 250, 36, "Prix Nobel dès " + nombreTexte(SEUIL_NOBEL) + " molécules", #1E293B, #64748B, 12)
  fin si
  appelle dessinerNobel(30, 528, 9)
  label(ecran, 46, 533, convertir_texte(nobels) + " prix Nobel · production +" + convertir_texte(nobels * 15) + " %", #CBD5E1, 12)
fin procédure

@ DESSIN DE LA BOUTIQUE
procédure dessinerOnglets()
  fond1 est un texte
  fond1 vaut #1E293B
  fond2 est un texte
  fond2 vaut #1E293B
  si onglet = 0 alors
    fond1 vaut #059669
  sinon
    fond2 vaut #7C3AED
  fin si
  appelle bouton(300, 10, 118, 32, "Machines", fond1, #FFFFFF, 13)
  appelle bouton(426, 10, 124, 32, "Recherches", fond2, #FFFFFF, 13)
  n est un nombre
  n vaut nbRechDispo()
  si n > 0 et rechEnCours = -1 alors
    cercle(ecran, 546, 12, 10, #22C55E)
    appelle centrer(convertir_texte(n), 546, 16, #FFFFFF, 11)
  fin si
fin procédure

procédure dessinerMachines()
  p est un nombre
  pour p de 0 à NB_M - 1
    y est un nombre
    y vaut 52 + p * 60
    visible est un booléen
    visible vaut debloque[p]
    cout est un nombre
    cout vaut prix(p, quantite)
    assez est un booléen
    assez vaut faux
    si visible et cout < PLAFOND et molecules >= cout alors
      assez vaut vrai
    fin si
    fondR est un texte
    fondR vaut #13222B
    si assez alors
      fondR vaut #134E4A
    fin si
    rectangle_arrondi(ecran, 298, y, 254, 54, 10, fondR)
    rectangle_arrondi(ecran, 302, y + 5, 44, 44, 8, #0B1A1F)
    cache est un booléen
    cache vaut vrai
    si visible alors
      cache vaut faux
    fin si
    appelle dessinerIcone(p, 324, y + 27, cache)
    si visible alors
      label(ecran, 354, y + 21, NOMS_M[p], #F1F5F9, 13)
      appelle dessinerMolecule(360, y + 37, 0.55)
      si cout >= PLAFOND alors
        label(ecran, 370, y + 42, "hors de portée", #64748B, 12)
      sinon
        coulPrix est un texte
        coulPrix vaut #F87171
        si assez alors
          coulPrix vaut #4ADE80
        fin si
        txtQ est un texte
        txtQ vaut ""
        si quantite > 1 alors
          txtQ vaut "  (x" + convertir_texte(quantite) + ")"
        fin si
        label(ecran, 370, y + 42, nombreTexte(cout) + txtQ, coulPrix, 12)
      fin si
      appelle aDroite(convertir_texte(possedes[p]), 546, y + 30, rgba(241, 245, 249, 0.45), 22)
      si possedes[p] > 0 alors
        appelle aDroite("+" + nombreProd(prodMachine(p)) + "/s", 546, y + 46, #64748B, 9)
      fin si
    sinon
      label(ecran, 354, y + 24, "???", #475569, 15)
      label(ecran, 354, y + 42, "à découvrir dans les recherches", #3F5468, 10)
    fin si
  fin pour
  label(ecran, 302, 497, "Acheter", #94A3B8, 12)
  q est un nombre
  pour q de 0 à 2
    valQ est un nombre
    valQ vaut puissance(10, q)
    fondQ est un texte
    fondQ vaut #1E293B
    si quantite = valQ alors
      fondQ vaut #059669
    fin si
    appelle bouton(360 + q * 64, 478, 56, 28, "x" + convertir_texte(valQ), fondQ, #FFFFFF, 12)
  fin pour
fin procédure

fonction noeudX(k)
  retourne 335 + rCol[k] * 90
fin fonction

fonction noeudY(k)
  retourne 82 + rRang[k] * 60
fin fonction

procédure dessinerSymbole(k, cx, cy, coul)
  t est un nombre
  t vaut rType[k]
  si t = 0 alors
    // un cadenas ouvert
    rectangle_arrondi(ecran, cx - 7, cy - 2, 14, 11, 2, coul)
    ligne(ecran, cx - 4, cy - 2, cx - 4, cy - 8, coul, 2)
    ligne(ecran, cx - 4, cy - 8, cx + 4, cy - 8, coul, 2)
    ligne(ecran, cx + 4, cy - 8, cx + 4, cy - 6, coul, 2)
  sinon si t = 1 alors
    appelle centrer("x2", cx, cy + 5, coul, 14)
  sinon si t = 2 alors
    polygone(ecran, cx - 5, cy - 9, cx + 6, cy + 1, cx + 1, cy + 2, cx + 4, cy + 8, cx + 1, cy + 9, cx - 2, cy + 3, cx - 5, cy + 6, coul)
  sinon si t = 3 alors
    appelle dessinerEtoile(cx, cy, 9, coul)
  sinon si t = 4 alors
    cercle(ecran, cx, cy, 9, coul)
    cercle(ecran, cx, cy, 7, #0F172A)
    ligne(ecran, cx, cy, cx, cy - 5, coul, 1.8)
    ligne(ecran, cx, cy, cx + 4, cy + 1, coul, 1.8)
  sinon
    cercle(ecran, cx, cy, 8, coul)
    cercle(ecran, cx - 2.5, cy - 2.5, 2.5, #0F172A)
  fin si
fin procédure

procédure dessinerRecherches()
  k est un nombre
  // les liens de l'arbre
  pour k de 0 à NB_R - 1
    si rParent[k] >= 0 alors
      coulL est un texte
      coulL vaut #334155
      si rFait[rParent[k]] alors
        coulL vaut #7C3AED
      fin si
      ligne(ecran, noeudX(rParent[k]), noeudY(rParent[k]), noeudX(k), noeudY(k), coulL, 3)
    fin si
  fin pour
  // les noeuds
  pour k de 0 à NB_R - 1
    cx est un nombre
    cx vaut noeudX(k)
    cy est un nombre
    cy vaut noeudY(k)
    e est un nombre
    e vaut etatRech(k)
    si k = rechChoisie alors
      cercle(ecran, cx, cy, 24, rgba(253, 224, 71, 0.5 + (tic mod 8) * 0.05))
    fin si
    si e = 0 alors
      cercle(ecran, cx, cy, 19, #7C3AED)
      appelle dessinerSymbole(k, cx, cy, #F5F3FF)
    sinon si e = 1 alors
      cercle(ecran, cx, cy, 19, #4C1D95)
      part est un nombre
      part vaut 1 - limiter(rechReste / (rDuree[k] / vitesseRech), 0, 1)
      cercle(ecran, cx, cy, 15, #4C1D95)
      // 12 petites lampes autour du noeud s'allument au fil de la recherche
      kl est un nombre
      pour kl de 0 à 11
        coulLampe est un texte
        coulLampe vaut #312E81
        si kl < arrondi_inferieur(part * 12) alors
          coulLampe vaut #E9D5FF
        fin si
        cercle(ecran, cx + cosinus(-pi() / 2 + kl * pi() / 6) * 23, cy + sinus(-pi() / 2 + kl * pi() / 6) * 23, 2.2, coulLampe)
      fin pour
      appelle dessinerSymbole(k, cx, cy, #E9D5FF)
    sinon si e = 2 alors
      coulN est un texte
      coulN vaut #1E293B
      si molecules >= rCout[k] alors
        coulN vaut #14532D
      fin si
      cercle(ecran, cx, cy, 19, #A78BFA)
      cercle(ecran, cx, cy, 16, coulN)
      appelle dessinerSymbole(k, cx, cy, #E9D5FF)
    sinon
      cercle(ecran, cx, cy, 19, #1E293B)
      appelle dessinerSymbole(k, cx, cy, #475569)
    fin si
    lgN est un nombre
    lgN vaut label_largeur(rNom[k], 9)
    rectangle_arrondi(ecran, cx - lgN / 2 - 3, cy + 22, lgN + 6, 12, 4, #0B1A1F)
    appelle centrer(rNom[k], cx, cy + 31, sialors(e = 3, #475569, #CBD5E1), 9)
  fin pour
  // la fiche de la recherche choisie
  rectangle_arrondi(ecran, 298, 446, 254, 96, 12, #1E1B4B)
  rc est un nombre
  rc vaut rechChoisie
  label(ecran, 308, 466, rNom[rc], #F5F3FF, 14)
  label(ecran, 308, 484, texteEffet(rc), #C4B5FD, 11)
  er est un nombre
  er vaut etatRech(rc)
  si er = 0 alors
    label(ecran, 308, 520, "Découverte terminée", #4ADE80, 12)
  sinon si er = 1 alors
    label(ecran, 308, 520, "En cours · " + minuteur(rechReste), #E9D5FF, 12)
  sinon si er = 3 alors
    label(ecran, 308, 506, "Découvre d'abord :", #64748B, 11)
    label(ecran, 308, 522, rNom[rParent[rc]], #94A3B8, 11)
  sinon
    appelle dessinerMolecule(314, 504, 0.55)
    coulP est un texte
    coulP vaut #F87171
    si molecules >= rCout[rc] alors
      coulP vaut #4ADE80
    fin si
    label(ecran, 324, 509, nombreTexte(rCout[rc]), coulP, 12)
    label(ecran, 308, 528, "durée " + minuteur(rDuree[rc] / vitesseRech), #94A3B8, 11)
    peut est un booléen
    peut vaut faux
    si rechEnCours = -1 et molecules >= rCout[rc] alors
      peut vaut vrai
    fin si
    si peut alors
      appelle bouton(440, 496, 104, 34, "Lancer", sialors(tic mod 16 < 8, #7C3AED, #6D28D9), #FFFFFF, 13)
    sinon si rechEnCours >= 0 alors
      appelle bouton(440, 496, 104, 34, "Labo occupé", #334155, #94A3B8, 11)
    sinon
      appelle bouton(440, 496, 104, 34, "Lancer", #334155, #94A3B8, 13)
    fin si
  fin si
fin procédure

procédure dessinerBoutique()
  rectangle(ecran, PANNEAU_X, 0, 270, 550, #0B1A1F)
  ligne(ecran, PANNEAU_X, 0, PANNEAU_X, 550, #1F4E4A, 2)
  appelle dessinerOnglets()
  si onglet = 0 alors
    appelle dessinerMachines()
    appelle centrer("Total fabriqué : " + nombreTexte(totalTout), 425, 535, #475569, 11)
  sinon
    appelle dessinerRecherches()
  fin si
fin procédure

@ LES FENETRES
procédure voile()
  rectangle(ecran, 0, 0, 560, 550, rgba(2, 12, 14, 0.75))
fin procédure

procédure fenetre(y, hf)
  rectangle_arrondi(ecran, 50, y + 4, 460, hf, 20, rgba(0, 0, 0, 0.4))
  rectangle_arrondi(ecran, 50, y, 460, hf, 20, #0F2A2E)
  rectangle_arrondi(ecran, 50, y, 460, 6, 3, #22C55E)
fin procédure

procédure ecranAccueil()
  appelle voile()
  appelle fenetre(64, 420)
  appelle dessinerMolecule(112, 112, 1.5)
  appelle dessinerMolecule(448, 112, 1.5)
  appelle centrer("Laboratoire Fou", 280, 124, #F8FAFC, 32)
  appelle centrer("Deviens le plus grand savant de l'univers", 280, 150, #86EFAC, 14)
  label(ecran, 84, 192, "Clique sur la grande fiole pour fabriquer des molécules.", #E2E8F0, 13)
  label(ecran, 84, 222, "Achète des machines : elles travaillent toutes seules.", #E2E8F0, 13)
  label(ecran, 84, 252, "Lance des recherches dans l'arbre des découvertes :", #E2E8F0, 13)
  label(ecran, 84, 270, "nouvelles machines, production doublée...", #E2E8F0, 13)
  label(ecran, 84, 288, "Chaque clic sur la fiole accélère la recherche !", #E2E8F0, 13)
  label(ecran, 84, 318, "Attrape les bulles dorées pour un gros bonus.", #E2E8F0, 13)
  label(ecran, 84, 348, "Le prix Nobel recommence la partie, mais chaque", #E2E8F0, 13)
  label(ecran, 84, 366, "prix ajoute 15 % à toute ta production.", #E2E8F0, 13)
  cercle(ecran, 70, 188, 3.5, #22C55E)
  cercle(ecran, 70, 218, 3.5, #22C55E)
  cercle(ecran, 70, 248, 3.5, #A78BFA)
  cercle(ecran, 70, 314, 3.5, #FACC15)
  cercle(ecran, 70, 344, 3.5, #F59E0B)
  appelle bouton(190, 404, 180, 50, "Au travail !", sialors(tic mod 16 < 8, #059669, #047857), #FFFFFF, 18)
fin procédure

procédure ecranRetour()
  appelle voile()
  appelle fenetre(140, 270)
  appelle centrer("Bon retour, professeur !", 280, 192, #F8FAFC, 24)
  appelle centrer("Pendant ton absence (" + dureeTexte(dureeAbsence) + "),", 280, 226, #94A3B8, 13)
  appelle centrer("ton labo a fabriqué", 280, 246, #94A3B8, 13)
  appelle dessinerMolecule(166, 284, 1.4)
  appelle centrer("+" + nombreTexte(gainAbsence), 290, 294, #86EFAC, 30)
  appelle bouton(200, 330, 160, 46, "Récupérer", #059669, #FFFFFF, 16)
fin procédure

procédure ecranNobel()
  appelle voile()
  appelle fenetre(110, 330)
  appelle dessinerNobel(280, 168, 24)
  appelle centrer("Recevoir le prix Nobel", 280, 222, #F8FAFC, 24)
  gainN est un nombre
  gainN vaut nobelsGagnables()
  appelle centrer("Tu gagnes +" + convertir_texte(gainN) + " prix Nobel : ta production passera à +" + convertir_texte((nobels + gainN) * 15) + " %.", 280, 256, #E2E8F0, 13)
  appelle centrer("Tes molécules, machines et recherches", 280, 290, #FCA5A5, 13)
  appelle centrer("repartent à zéro.", 280, 308, #FCA5A5, 13)
  appelle bouton(110, 360, 160, 46, "Pas encore", #1E293B, #FFFFFF, 15)
  appelle bouton(290, 360, 160, 46, "Accepter !", #B45309, #FFFFFF, 15)
fin procédure

procédure ecranCeremonie()
  rectangle(ecran, 0, 0, 560, 550, #1C1917)
  // les projecteurs et les confettis
  polygone(ecran, 120, 0, 200, 0, 300, 420, 220, 420, rgba(253, 230, 138, 0.08))
  polygone(ecran, 360, 0, 440, 0, 340, 420, 260, 420, rgba(253, 230, 138, 0.08))
  k est un nombre
  pour k de 0 à 39
    cx est un nombre
    cx vaut (k * 73) mod 560
    cy est un nombre
    cy vaut (k * 37 + tic * (4 + k mod 5)) mod 550
    rectangle(ecran, cx, cy, 5, 8, COUL_M[k mod NB_M])
  fin pour
  rectangle(ecran, 160, 400, 240, 20, #7C2D12)
  appelle dessinerNobel(280, 280, 60)
  appelle centrer("Prix Nobel de chimie !", 280, 170, #FDE68A, 28)
  appelle centrer("+" + convertir_texte(nobelsGagnes) + " prix Nobel", 280, 380, #FFFFFF, 18)
fin procédure

procédure dessiner()
  effacer(ecran)
  contour(ecran, #0)
  si etat = 7 alors
    appelle ecranCeremonie()
  sinon
    appelle dessinerGauche()
    appelle dessinerBoutique()
    si etat = 6 alors
      appelle ecranAccueil()
    sinon si etat = 5 alors
      appelle ecranRetour()
    sinon si etat = 4 alors
      appelle ecranNobel()
    fin si
  fin si
fin procédure

@ LES COMMANDES
procédure clicPanneau(x, y)
  si clique(x, y, 300, 10, 118, 32) alors
    onglet vaut 0
  sinon si clique(x, y, 426, 10, 124, 32) alors
    onglet vaut 1
  sinon si onglet = 0 alors
    si clique(x, y, 360, 478, 184, 28) alors
      quantite vaut puissance(10, limiter(arrondi_inferieur((x - 360) / 64), 0, 2))
    sinon si y >= 52 et y < 52 + NB_M * 60 alors
      rang est un nombre
      rang vaut arrondi_inferieur((y - 52) / 60)
      appelle acheterMachine(rang)
    fin si
  sinon
    si clique(x, y, 440, 496, 104, 34) alors
      appelle lancerRecherche(rechChoisie)
    sinon
      // choisir le noeud le plus proche
      k est un nombre
      pour k de 0 à NB_R - 1
        si hypotenuse(x - noeudX(k), y - noeudY(k)) < 24 alors
          rechChoisie vaut k
        fin si
      fin pour
    fin si
  fin si
fin procédure

procédure clicLabo(x, y)
  surBulle est un booléen
  surBulle vaut faux
  si bulleVie > 0 alors
    si hypotenuse(x - bulleX(), y - bulleY()) < 26 alors
      surBulle vaut vrai
    fin si
  fin si
  si surBulle alors
    appelle attraperBulle()
  sinon si x > FIOLE_X - 64 et x < FIOLE_X + 64 et y > FIOLE_Y - 90 et y < FIOLE_Y + 60 alors
    appelle cliquerFiole(x, y)
  sinon si clique(x, y, 20, 470, 250, 36) alors
    si nobelsGagnables() >= 1 alors
      etat vaut 4
    sinon
      appelle annoncer("Fabrique " + nombreTexte(SEUIL_NOBEL) + " molécules pour le Nobel !")
    fin si
  fin si
fin procédure

procédure lireOrdre(act, x, y)
  si etat = 6 alors
    si act = 0 et clique(x, y, 190, 404, 180, 50) alors
      etat vaut 1
    fin si
  sinon si etat = 5 alors
    si act = 0 et clique(x, y, 200, 330, 160, 46) alors
      etat vaut 1
    fin si
  sinon si etat = 4 alors
    si act = 0 alors
      si clique(x, y, 110, 360, 160, 46) alors
        etat vaut 1
      sinon si clique(x, y, 290, 360, 160, 46) alors
        appelle recevoirNobel()
      fin si
    fin si
  sinon si etat = 1 alors
    si act = 1 alors
      onglet vaut 0
    sinon si act = 2 alors
      onglet vaut 1
    sinon si act = 0 alors
      si x >= PANNEAU_X alors
        appelle clicPanneau(x, y)
      sinon
        appelle clicLabo(x, y)
      fin si
    fin si
  fin si
fin procédure

@ LE PROCESSUS
processus Experience()
  derniereMesure vaut chrono()
  tant que appActif
    tic vaut tic + 1
    nbLus est un nombre
    nbLus vaut 0
    tant que teteO <> queueO et nbLus < 8
      appelle lireOrdre(ordres[teteO], ordX[teteO], ordY[teteO])
      teteO vaut (teteO + 1) mod 32
      nbLus vaut nbLus + 1
    fin tant que
    instant est un nombre
    instant vaut chrono()
    dt est un nombre
    dt vaut limiter((instant - derniereMesure) / 1000, 0, 0.5)
    derniereMesure vaut instant
    si etat = 1 ou etat = 7 alors
      appelle avancer(dt)
      sauveAttente vaut sauveAttente - dt
      si sauveAttente <= 0 alors
        appelle sauverPartie()
        sauveAttente vaut 15
      fin si
    fin si
    appelle dessiner()
    affiche ecran
    pause 60
  fin tant que
  appelle sauverPartie()
  effacer(ecran)
  rectangle(ecran, 0, 0, 560, 550, #0F2A2E)
  appelle centrer("Partie sauvegardée : ton labo continue de travailler !", 280, 280, #86EFAC, 16)
  affiche ecran
fin processus

@ DEMARRAGE
appelle charger()
appelle dessiner()
affiche ecran
Experience()

tant que appActif
  interagir ecran, ["m", "r", "x"] dans action, sourisX, sourisY
  si action = 3 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