La Plage aux Secrets

CoddyRun Le code, en toute simplicité
La Plage aux Secrets Prêt
Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
@ CONFIGURATION
ecran est une toile
dimension(ecran, 640, 520)

COLS est un nombre
COLS vaut 7
RANGS est un nombre
RANGS vaut 8
CASE est un nombre
CASE vaut 48
PX est un nombre
PX vaut 16
PY est un nombre
PY vaut 60
NIV_OBJ est un nombre
NIV_OBJ vaut 6
ENERGIE_MAX est un nombre
ENERGIE_MAX vaut 50

@ LES TROIS FAMILLES D'OBJETS (6 niveaux chacune)
chaineNom est un tableau
chaineNom vaut ["Mer", "Jardin", "Snack"]
objEmo est un tableau
objEmo vaut ["🐚", "🦀", "🐙", "🐠", "🐬", "🐳", "🌱", "🌿", "🌼", "🌺", "💐", "🌴", "🍓", "🍌", "🍍", "🥥", "🍹", "🍦"]
objNom est un tableau
objNom vaut ["Coquillage", "Crabe", "Poulpe", "Poisson", "Dauphin", "Baleine", "Pousse", "Feuillage", "Marguerite", "Hibiscus", "Bouquet", "Palmier", "Fraise", "Banane", "Ananas", "Noix de coco", "Cocktail", "Glace"]
coulChaine est un tableau
coulChaine ajoute #B3E5FC
coulChaine ajoute #C8E6C9
coulChaine ajoute #FFE0B2
genEmo est un tableau
genEmo vaut ["🎣", "🌳", "🧺"]
genNom est un tableau
genNom vaut ["Canne à pêche", "Arbre", "Panier"]

@ LES HABITANTS ET LEURS POTINS
persoEmo est un tableau
persoEmo vaut ["👵", "👨", "👧"]
persoNom est un tableau
persoNom vaut ["Mamie Rose", "Léo", "Lili"]
potins est un tableau
potins vaut ["Mamie Rose : « Le facteur parle tout seul aux mouettes... »", "Léo : « J'ai pêché une botte ce matin. Encore ! »", "Lili : « Le marchand de glaces est amoureux de la fleuriste ! »", "Mamie Rose : « De mon temps, la plage était pleine de monde ! »", "Léo : « Les crabes ont volé mon sandwich... »", "Lili : « J'ai trouvé une bouteille avec un message dedans ! »", "Mamie Rose : « Le vieux phare me rend nostalgique. »", "Léo : « Il paraît qu'un trésor dort sous le sable... »"]

@ LA RENOVATION DE LA PLAGE (et l'histoire du mystere)
etapeNom est un tableau
etapeNom vaut ["Nettoyer le sable", "Planter des palmiers", "Installer des parasols", "Ouvrir le bar de plage", "Réparer le ponton", "Rallumer le phare"]
etapeCout est un tableau
etapeCout vaut [3, 6, 9, 12, 15, 20]
etapeHistoire est un tableau
etapeHistoire vaut ["Mamie Rose : « Depuis que le phare s'est éteint, plus personne ne vient... »", "Léo : « J'ai vu une lumière bouger près du vieux ponton, la nuit ! »", "Lili : « Quelqu'un a enterré une vieille carte sous un parasol... »", "Mamie Rose : « Cette carte... c'est celle de l'ancien gardien du phare ! »", "Léo : « Au bout du ponton, une croix est gravée dans le bois ! »", "Le phare brille à nouveau... et révèle le trésor caché du gardien !"]

@ LE PLATEAU
// typeCase : 0 libre, 1 buisson (bloque), 2 generateur
typeCase est un tableau
chaine est un tableau
niv est un tableau
genChaine est un tableau
popCase est un tableau

@ LES COMMANDES (3 a la fois)
cmdChaine est un tableau
cmdNiv est un tableau
cmdPerso est un tableau

@ ETAT DU JEU
// etat : 0 titre, 1 jeu, 2 aide, 3 histoire, 4 victoire
etat est un nombre
etat vaut 0
appActif est un booléen
appActif vaut vrai
energie, pieces, etoiles, etape, sel, tic, chronoEnergie, commandesLivrees est un nombre
message, texteHistoire est un texte
action, ptX, ptY est un nombre
ecranRetour est un nombre
ecranRetour vaut 0
popTxt, popX, popY, popT est un tableau


@ OUTILS
fonction emoObjet(ch, nv)
  retourne objEmo[ch * NIV_OBJ + nv - 1]
fin fonction

fonction nomObjet(ch, nv)
  retourne objNom[ch * NIV_OBJ + nv - 1]
fin fonction

fonction caseX(k)
  retourne PX + (k mod COLS) * CASE
fin fonction

fonction caseY(k)
  retourne PY + arrondi_inferieur(k / COLS) * CASE
fin fonction

procédure ajouterPop(txt, x, y)
  popTxt ajoute txt
  popX ajoute x
  popY ajoute y
  popT ajoute 20
fin procédure

procédure centrer(txt, cx, ty, coul, taillePolice)
  label(ecran, cx - label_largeur(txt, taillePolice) / 2, ty, txt, coul, taillePolice)
fin procédure

// une commande au hasard, de plus en plus exigeante
procédure nouvelleCommande(kc)
  nivMax est un nombre
  nivMax vaut minimum(2 + arrondi_inferieur(commandesLivrees / 3), NIV_OBJ)
  cmdChaine[kc] vaut hasard(0, 2)
  cmdNiv[kc] vaut hasard(maximum(2, nivMax - 2), nivMax)
  cmdPerso[kc] vaut hasard(0, 2)
fin procédure

fonction recompensePieces(nv)
  retourne nv * nv * 5
fin fonction

fonction recompenseEtoiles(nv)
  retourne nv
fin fonction


@ NOUVELLE PARTIE
procédure nouvellePartie()
  vide typeCase
  vide chaine
  vide niv
  vide genChaine
  vide popCase
  kz est un nombre
  pour kz de 0 à COLS * RANGS - 1
    typeCase ajoute 0
    chaine ajoute -1
    niv ajoute 0
    genChaine ajoute -1
    popCase ajoute 0
  fin pour
  // les trois generateurs, en bas du plateau
  typeCase[7 * COLS + 1] vaut 2
  genChaine[7 * COLS + 1] vaut 0
  typeCase[7 * COLS + 3] vaut 2
  genChaine[7 * COLS + 3] vaut 1
  typeCase[7 * COLS + 5] vaut 2
  genChaine[7 * COLS + 5] vaut 2
  // les buissons envahissent le haut de la plage
  pour kz de 0 à 4 * COLS - 1
    si kz >= 3 * COLS alors
      si hasard(0, 1) = 0 alors
        typeCase[kz] vaut 1
      fin si
    sinon
      typeCase[kz] vaut 1
    fin si
  fin pour
  // quelques objets caches sous les buissons
  pour kz de 0 à 4 * COLS - 1
    si typeCase[kz] = 1 et hasard(0, 3) = 0 alors
      chaine[kz] vaut hasard(0, 2)
      niv[kz] vaut hasard(1, 3)
    fin si
  fin pour
  vide cmdChaine
  vide cmdNiv
  vide cmdPerso
  pour kz de 0 à 2
    cmdChaine ajoute 0
    cmdNiv ajoute 2
    cmdPerso ajoute kz
    appelle nouvelleCommande(kz)
  fin pour
  vide popTxt
  vide popX
  vide popY
  vide popT
  energie vaut 40
  pieces vaut 20
  etoiles vaut 0
  etape vaut 0
  sel vaut -1
  chronoEnergie vaut 0
  commandesLivrees vaut 0
  message vaut "Clique sur un générateur (🎣 🌳 🧺) pour obtenir des objets !"
fin procédure


@ LES ACTIONS
// un generateur produit un objet de niveau 1 sur la case libre la plus proche
procédure produire(kg)
  si energie <= 0 alors
    message vaut "Plus d'énergie ! Attends un peu, ou achètes-en avec tes pièces."
  sinon
    meilleure est un nombre
    meilleure vaut -1
    meilleureDist est un nombre
    meilleureDist vaut 999
    kz est un nombre
    pour kz de 0 à COLS * RANGS - 1
      si typeCase[kz] = 0 et chaine[kz] < 0 alors
        dist est un nombre
        dist vaut absolue(kz mod COLS - kg mod COLS) + absolue(arrondi_inferieur(kz / COLS) - arrondi_inferieur(kg / COLS))
        si dist < meilleureDist alors
          meilleureDist vaut dist
          meilleure vaut kz
        fin si
      fin si
    fin pour
    si meilleure < 0 alors
      message vaut "Le plateau est plein : fusionne ou vends des objets (V)."
    sinon
      energie soustrait 1
      chaine[meilleure] vaut genChaine[kg]
      niv[meilleure] vaut 1
      popCase[meilleure] vaut 6
      message vaut genNom[genChaine[kg]] + " : un " + nomObjet(genChaine[kg], 1) + " !"
    fin si
  fin si
fin procédure

// une fusion debroussaille les cases voisines
procédure debroussailler(kc)
  kd est un nombre
  pour kd de 0 à 3
    vx est un nombre
    vx vaut kc mod COLS
    vy est un nombre
    vy vaut arrondi_inferieur(kc / COLS)
    si kd = 0 alors
      vx vaut vx - 1
    sinon si kd = 1 alors
      vx vaut vx + 1
    sinon si kd = 2 alors
      vy vaut vy - 1
    sinon
      vy vaut vy + 1
    fin si
    si vx >= 0 et vx < COLS et vy >= 0 et vy < RANGS alors
      si typeCase[vy * COLS + vx] = 1 alors
        typeCase[vy * COLS + vx] vaut 0
        popCase[vy * COLS + vx] vaut 6
        si chaine[vy * COLS + vx] >= 0 alors
          appelle ajouterPop("Trouvé !", caseX(vy * COLS + vx), caseY(vy * COLS + vx) + 10)
        fin si
      fin si
    fin si
  fin pour
fin procédure

procédure cliquerCase(kc)
  si typeCase[kc] = 2 alors
    sel vaut -1
    appelle produire(kc)
  sinon si typeCase[kc] = 1 alors
    message vaut "Un buisson ! Fusionne des objets juste à côté pour le dégager."
  sinon si sel < 0 alors
    si chaine[kc] >= 0 alors
      sel vaut kc
      message vaut nomObjet(chaine[kc], niv[kc]) + " (niveau " + convertir_texte(niv[kc]) + ") : clique où le poser, ou sur son jumeau !"
    fin si
  sinon si kc = sel alors
    sel vaut -1
  sinon si chaine[kc] < 0 alors
    // deplacer l'objet sur une case vide
    chaine[kc] vaut chaine[sel]
    niv[kc] vaut niv[sel]
    chaine[sel] vaut -1
    niv[sel] vaut 0
    sel vaut -1
  sinon si chaine[kc] = chaine[sel] et niv[kc] = niv[sel] et niv[kc] < NIV_OBJ alors
    // FUSION !
    niv[kc] vaut niv[kc] + 1
    chaine[sel] vaut -1
    niv[sel] vaut 0
    popCase[kc] vaut 8
    appelle debroussailler(kc)
    appelle ajouterPop(emoObjet(chaine[kc], niv[kc]), caseX(kc) + 14, caseY(kc))
    message vaut "Fusion ! Tu obtiens : " + nomObjet(chaine[kc], niv[kc]) + "."
    si niv[kc] = NIV_OBJ alors
      message vaut "INCROYABLE : " + nomObjet(chaine[kc], niv[kc]) + ", le plus bel objet de la famille " + chaineNom[chaine[kc]] + " !"
    fin si
    sel vaut -1
  sinon
    // deux objets differents : on les echange
    tmpC est un nombre
    tmpC vaut chaine[kc]
    tmpN est un nombre
    tmpN vaut niv[kc]
    chaine[kc] vaut chaine[sel]
    niv[kc] vaut niv[sel]
    chaine[sel] vaut tmpC
    niv[sel] vaut tmpN
    sel vaut -1
  fin si
fin procédure

procédure livrer(kc)
  trouve est un nombre
  trouve vaut -1
  kz est un nombre
  pour kz de 0 à COLS * RANGS - 1
    si trouve < 0 et typeCase[kz] = 0 alors
      si chaine[kz] = cmdChaine[kc] et niv[kz] = cmdNiv[kc] alors
        trouve vaut kz
      fin si
    fin si
  fin pour
  si trouve < 0 alors
    message vaut persoNom[cmdPerso[kc]] + " attend : " + nomObjet(cmdChaine[kc], cmdNiv[kc]) + " " + emoObjet(cmdChaine[kc], cmdNiv[kc])
  sinon
    gainP est un nombre
    gainP vaut recompensePieces(cmdNiv[kc])
    gainE est un nombre
    gainE vaut recompenseEtoiles(cmdNiv[kc])
    pieces vaut pieces + gainP
    etoiles vaut etoiles + gainE
    chaine[trouve] vaut -1
    niv[trouve] vaut 0
    si sel = trouve alors
      sel vaut -1
    fin si
    commandesLivrees ajoute 1
    appelle ajouterPop("+" + convertir_texte(gainP) + " 💰  +" + convertir_texte(gainE) + " ⭐", 440, 290 + kc * 62)
    message vaut potins[hasard(0, longueur(potins) - 1)]
    appelle nouvelleCommande(kc)
  fin si
fin procédure

procédure renover()
  si etape >= 6 alors
    message vaut "La plage est entièrement rénovée !"
  sinon si etoiles < etapeCout[etape] alors
    message vaut "Il faut " + convertir_texte(etapeCout[etape]) + " ⭐ pour : " + etapeNom[etape] + "."
  sinon
    etoiles vaut etoiles - etapeCout[etape]
    texteHistoire vaut etapeHistoire[etape]
    etape ajoute 1
    si etape >= 6 alors
      etat vaut 4
    sinon
      etat vaut 3
    fin si
  fin si
fin procédure

procédure vendre()
  si sel < 0 alors
    message vaut "Sélectionne d'abord un objet à vendre."
  sinon
    gain est un nombre
    gain vaut niv[sel] * 3
    pieces vaut pieces + gain
    message vaut nomObjet(chaine[sel], niv[sel]) + " vendu : +" + convertir_texte(gain) + " pièces."
    chaine[sel] vaut -1
    niv[sel] vaut 0
    sel vaut -1
  fin si
fin procédure

procédure acheterEnergie()
  si pieces < 30 alors
    message vaut "Il faut 30 pièces pour acheter 25 énergie."
  sinon si energie >= ENERGIE_MAX alors
    message vaut "Ton énergie est déjà au maximum."
  sinon
    pieces vaut pieces - 30
    energie vaut minimum(ENERGIE_MAX, energie + 25)
    message vaut "+25 ⚡ énergie !"
  fin si
fin procédure


@ DESSIN : LE PLATEAU
procédure dessinerBuisson(x, y, k)
  rectangle_arrondi(ecran, x + 2, y + 2, CASE - 4, CASE - 4, 10, #D7C49E)
  cercle(ecran, x + CASE * 0.33, y + CASE * 0.56, CASE * 0.26, #2E7D32)
  cercle(ecran, x + CASE * 0.67, y + CASE * 0.56, CASE * 0.26, #388E3C)
  cercle(ecran, x + CASE * 0.5, y + CASE * 0.34, CASE * 0.26, #43A047)
  cercle(ecran, x + CASE * 0.41, y + CASE * 0.41, 3, #81C784)
  cercle(ecran, x + CASE * 0.63, y + CASE * 0.3, 3, #81C784)
  si chaine[k] >= 0 alors
    label(ecran, x + CASE * 0.66, y + CASE * 0.9, "?", #FFF59D, 13)
  fin si
fin procédure

procédure dessinerPlateau()
  rectangle_arrondi(ecran, PX - 6, PY - 6, COLS * CASE + 12, RANGS * CASE + 12, 14, #C8A96E)
  kz est un nombre
  pour kz de 0 à COLS * RANGS - 1
    x est un nombre
    x vaut caseX(kz)
    y est un nombre
    y vaut caseY(kz)
    si typeCase[kz] = 1 alors
      appelle dessinerBuisson(x, y, kz)
    sinon
      si (kz + arrondi_inferieur(kz / COLS)) mod 2 = 0 alors
        rectangle_arrondi(ecran, x + 2, y + 2, CASE - 4, CASE - 4, 10, #F5E6C4)
      sinon
        rectangle_arrondi(ecran, x + 2, y + 2, CASE - 4, CASE - 4, 10, #EFDDB4)
      fin si
      si typeCase[kz] = 2 alors
        // un generateur qui brille
        halo est un nombre
        halo vaut sialors(tic mod 16 < 8, 3, 0)
        rectangle_arrondi(ecran, x + 4 - halo, y + 4 - halo, CASE - 8 + halo * 2, CASE - 8 + halo * 2, 12, rgba(255, 213, 79, 0.45))
        rectangle_arrondi(ecran, x + 5, y + 5, CASE - 10, CASE - 10, 10, #FFF8E1)
        appelle centrer(genEmo[genChaine[kz]], x + CASE / 2, y + CASE * 0.68, #000000, 22)
        cercle(ecran, x + CASE - 10, y + 10, 7, #FFB300)
        appelle centrer("⚡", x + CASE - 10, y + 14, #000000, 9)
      sinon si chaine[kz] >= 0 alors
        // un objet : il grossit un instant quand il apparait ou fusionne
        gros est un nombre
        gros vaut popCase[kz] * 1.5
        si kz = sel alors
          contour(ecran, #FF7043, 3)
        fin si
        rectangle_arrondi(ecran, x + 5 - gros / 2, y + 5 - gros / 2, CASE - 10 + gros, CASE - 10 + gros, 10, coulChaine[chaine[kz]])
        contour(ecran, #0)
        appelle centrer(emoObjet(chaine[kz], niv[kz]), x + CASE / 2, y + CASE * 0.66 + gros / 4, #000000, 21 + gros)
        // le niveau en petit
        cercle(ecran, x + 12, y + CASE - 12, 7, rgba(0, 0, 0, 0.25))
        appelle centrer(convertir_texte(niv[kz]), x + 12, y + CASE - 8, #FFFFFF, 9)
      fin si
    fin si
  fin pour
fin procédure


@ DESSIN : LA PLAGE A RENOVER
procédure dessinerPlage()
  bx est un nombre
  bx vaut 410
  by est un nombre
  by vaut 54
  // ciel, mer et sable
  rectangle_arrondi(ecran, bx, by, 218, 150, 12, #81D4FA)
  rectangle(ecran, bx, by + 70, 218, 30, #29B6F6)
  vague est un nombre
  vague vaut (tic mod 30) / 3
  ligne(ecran, bx + 10 + vague, by + 80, bx + 40 + vague, by + 80, rgba(255, 255, 255, 0.7), 2)
  ligne(ecran, bx + 120 - vague, by + 90, bx + 150 - vague, by + 90, rgba(255, 255, 255, 0.7), 2)
  rectangle_arrondi(ecran, bx, by + 96, 218, 54, 12, #F6D58E)
  si etape < 1 alors
    // des dechets et des algues partout
    cercle(ecran, bx + 30, by + 120, 5, #6D4C41)
    cercle(ecran, bx + 90, by + 132, 6, #5D4037)
    cercle(ecran, bx + 160, by + 115, 4, #6D4C41)
    ellipse(ecran, bx + 60, by + 110, 10, 3, #558B2F)
    ellipse(ecran, bx + 190, by + 138, 12, 3, #558B2F)
  fin si
  si etape >= 2 alors
    // les palmiers
    ligne(ecran, bx + 24, by + 132, bx + 30, by + 92, #8D6E63, 4)
    ellipse(ecran, bx + 22, by + 90, 14, 5, #43A047)
    ellipse(ecran, bx + 38, by + 92, 13, 4, #388E3C)
    ligne(ecran, bx + 196, by + 134, bx + 190, by + 96, #8D6E63, 4)
    ellipse(ecran, bx + 182, by + 94, 13, 4, #43A047)
    ellipse(ecran, bx + 198, by + 92, 14, 5, #388E3C)
  fin si
  si etape >= 3 alors
    // les parasols
    ligne(ecran, bx + 70, by + 140, bx + 70, by + 116, #ECEFF1, 2)
    triangle(ecran, bx + 56, by + 118, bx + 84, by + 118, bx + 70, by + 106, #E53935)
    ligne(ecran, bx + 130, by + 142, bx + 130, by + 118, #ECEFF1, 2)
    triangle(ecran, bx + 116, by + 120, bx + 144, by + 120, bx + 130, by + 108, #FDD835)
  fin si
  si etape >= 4 alors
    // le bar de plage
    rectangle(ecran, bx + 92, by + 120, 26, 18, #A1887F)
    triangle(ecran, bx + 88, by + 121, bx + 122, by + 121, bx + 105, by + 108, #6D4C41)
    rectangle(ecran, bx + 99, by + 126, 12, 6, #FFE082)
  fin si
  si etape >= 5 alors
    // le ponton
    rectangle(ecran, bx + 150, by + 84, 60, 6, #8D6E63)
    ligne(ecran, bx + 160, by + 90, bx + 160, by + 100, #6D4C41, 2)
    ligne(ecran, bx + 200, by + 90, bx + 200, by + 100, #6D4C41, 2)
  fin si
  // le phare, eteint puis rallume
  rectangle(ecran, bx + 188, by + 30, 14, 50, #FAFAFA)
  rectangle(ecran, bx + 188, by + 44, 14, 8, #E53935)
  rectangle(ecran, bx + 188, by + 62, 14, 8, #E53935)
  triangle(ecran, bx + 185, by + 30, bx + 205, by + 30, bx + 195, by + 18, #E53935)
  si etape >= 6 alors
    cercle(ecran, bx + 195, by + 26, 6, #FFF59D)
    polygone(ecran, [bx + 195, by + 26, bx + 120, by + 8, bx + 120, by + 40], rgba(255, 245, 157, 0.35))
  sinon
    cercle(ecran, bx + 195, by + 26, 4, #78909C)
  fin si
  // la prochaine renovation
  si etape < 6 alors
    rectangle_arrondi(ecran, bx, by + 156, 218, 40, 10, rgba(255, 255, 255, 0.85))
    label(ecran, bx + 10, by + 173, "Étape " + convertir_texte(etape + 1) + "/6 : " + etapeNom[etape], #5D4037, 11)
    si etoiles >= etapeCout[etape] alors
      rectangle_arrondi(ecran, bx + 120, by + 177, 92, 16, 8, #43A047)
      label(ecran, bx + 126, by + 189, "R : rénover", #FFFFFF, 10)
    sinon
      label(ecran, bx + 10, by + 190, convertir_texte(etoiles) + " / " + convertir_texte(etapeCout[etape]) + " ⭐", #8D6E63, 11)
    fin si
  fin si
fin procédure


@ DESSIN : LES COMMANDES ET L'INTERFACE
procédure dessinerCommandes()
  label(ecran, 410, 263, "COMMANDES", #5D4037, 11)
  kc est un nombre
  pour kc de 0 à 2
    cy est un nombre
    cy vaut 268 + kc * 62
    // la commande peut-elle etre livree ?
    dispo est un booléen
    dispo vaut faux
    kz est un nombre
    pour kz de 0 à COLS * RANGS - 1
      si typeCase[kz] = 0 alors
        si chaine[kz] = cmdChaine[kc] et niv[kz] = cmdNiv[kc] alors
          dispo vaut vrai
        fin si
      fin si
    fin pour
    si dispo alors
      contour(ecran, #43A047, 3)
    sinon
      contour(ecran, rgba(0, 0, 0, 0.1), 1)
    fin si
    rectangle_arrondi(ecran, 410, cy, 218, 56, 12, #FFFDF7)
    contour(ecran, #0)
    label(ecran, 418, cy + 28, persoEmo[cmdPerso[kc]], #000000, 20)
    label(ecran, 448, cy + 15, persoNom[cmdPerso[kc]], #8D6E63, 10)
    rectangle_arrondi(ecran, 448, cy + 21, 30, 30, 8, coulChaine[cmdChaine[kc]])
    appelle centrer(emoObjet(cmdChaine[kc], cmdNiv[kc]), 463, cy + 43, #000000, 18)
    label(ecran, 484, cy + 34, nomObjet(cmdChaine[kc], cmdNiv[kc]), #5D4037, 11)
    label(ecran, 484, cy + 49, "+" + convertir_texte(recompensePieces(cmdNiv[kc])) + " 💰 +" + convertir_texte(recompenseEtoiles(cmdNiv[kc])) + " ⭐", #8D6E63, 10)
    si dispo alors
      rectangle_arrondi(ecran, 572, cy + 6, 50, 20, 10, #43A047)
      label(ecran, 578, cy + 20, "Livrer", #FFFFFF, 10)
    fin si
  fin pour
fin procédure

procédure dessinerInterface()
  // en haut
  rectangle(ecran, 0, 0, 640, 52, #FFB74D)
  label(ecran, 16, 33, "LA PLAGE AUX SECRETS", #FFFFFF, 18)
  rectangle_arrondi(ecran, 270, 12, 116, 28, 14, rgba(255, 255, 255, 0.4))
  label(ecran, 278, 32, "⚡ " + convertir_texte(energie) + "/" + convertir_texte(ENERGIE_MAX), #5D4037, 14)
  si energie < ENERGIE_MAX alors
    rectangle(ecran, 278, 37, 100 * chronoEnergie / 50, 2, #FF6F00)
  fin si
  rectangle_arrondi(ecran, 394, 12, 110, 28, 14, rgba(255, 255, 255, 0.4))
  label(ecran, 402, 32, "💰 " + convertir_texte(pieces), #5D4037, 14)
  rectangle_arrondi(ecran, 512, 12, 116, 28, 14, rgba(255, 255, 255, 0.4))
  label(ecran, 520, 32, "⭐ " + convertir_texte(etoiles), #5D4037, 14)

  // en bas
  rectangle(ecran, 0, 456, 640, 64, #FFE0B2)
  label(ecran, 16, 474, message, #5D4037, 12)
  rectangle_arrondi(ecran, 16, 484, 130, 28, 12, #EF6C00)
  label(ecran, 26, 503, "V : vendre l'objet", #FFFFFF, 12)
  rectangle_arrondi(ecran, 156, 484, 170, 28, 12, #FFA000)
  label(ecran, 166, 503, "E : +25 ⚡ (30 💰)", #FFFFFF, 12)
  rectangle_arrondi(ecran, 336, 484, 90, 28, 12, #8D6E63)
  label(ecran, 350, 503, "H : aide", #FFFFFF, 12)
  label(ecran, 440, 503, "Commandes : 1 2 3", #8D6E63, 11)

  // les petits textes qui s'envolent
  si longueur(popT) > 0 alors
    kp est un nombre
    pour kp de 0 à longueur(popT) - 1
      label(ecran, popX[kp], popY[kp], popTxt[kp], #E65100, 15)
    fin pour
  fin si
fin procédure

procédure dessinerJeu()
  effacer(ecran)
  contour(ecran, #0)
  dégradé(ecran, [#FFF3E0, #FFE0B2])
  appelle dessinerPlateau()
  appelle dessinerPlage()
  appelle dessinerCommandes()
  appelle dessinerInterface()
fin procédure

procédure dessinerTitre()
  effacer(ecran)
  contour(ecran, #0)
  dégradé(ecran, [#4FC3F7, #B3E5FC, #FFE0B2])
  rectangle(ecran, 0, 360, 640, 160, #F6D58E)
  rectangle(ecran, 0, 330, 640, 34, #29B6F6)
  vague est un nombre
  vague vaut (tic mod 40) / 2
  ligne(ecran, 40 + vague, 344, 120 + vague, 344, rgba(255, 255, 255, 0.7), 3)
  ligne(ecran, 380 - vague, 352, 470 - vague, 352, rgba(255, 255, 255, 0.7), 3)
  cercle(ecran, 540, 90, 34, #FFEE58)
  // le vieux phare eteint
  rectangle(ecran, 560, 200, 34, 130, #FAFAFA)
  rectangle(ecran, 560, 236, 34, 18, #E53935)
  rectangle(ecran, 560, 280, 34, 18, #E53935)
  triangle(ecran, 552, 200, 602, 200, 577, 172, #E53935)
  rectangle_arrondi(ecran, 90, 110, 400, 210, 20, rgba(255, 255, 255, 0.9))
  appelle centrer("LA PLAGE", 290, 165, #EF6C00, 36)
  appelle centrer("AUX SECRETS", 290, 205, #EF6C00, 36)
  appelle centrer("Fusionne, livre, rénove... et perce le mystère du phare !", 290, 234, #8D6E63, 13)
  appelle centrer("ESPACE : jouer      H : aide      X : quitter", 290, 280, #43A047, 15)
  // quelques objets qui dansent
  kd est un nombre
  pour kd de 0 à 5
    saut est un nombre
    saut vaut sialors((tic + kd * 4) mod 16 < 8, 0, 6)
    label(ecran, 80 + kd * 90, 440 - saut, objEmo[kd * 3], #000000, 34)
  fin pour
fin procédure

procédure dessinerAide()
  effacer(ecran)
  contour(ecran, #0)
  dégradé(ecran, [#FFF3E0, #FFE0B2])
  label(ecran, 30, 50, "COMMENT JOUER", #EF6C00, 26)
  label(ecran, 30, 92, "1. Clique sur un GÉNÉRATEUR (🎣 🌳 🧺) : il fabrique un objet (coût : 1 ⚡).", #5D4037, 13)
  label(ecran, 30, 118, "2. Clique sur un objet, puis sur son JUMEAU : ils fusionnent en un objet plus beau !", #5D4037, 13)
  label(ecran, 30, 144, "    Sur une case vide : tu le déplaces. Sur un autre objet : tu les échanges.", #8D6E63, 12)
  label(ecran, 30, 170, "3. Une fusion à côté d'un BUISSON le fait disparaître... et révèle parfois un objet !", #5D4037, 13)
  label(ecran, 30, 196, "4. LIVRE les commandes des habitants (touches 1, 2, 3 ou bouton Livrer).", #5D4037, 13)
  label(ecran, 30, 222, "5. Avec les ⭐, RÉNOVE la plage (touche R) et découvre l'histoire du phare.", #5D4037, 13)
  label(ecran, 30, 262, "L'énergie ⚡ remonte toute seule. Tu peux aussi en acheter (E) ou vendre un objet (V).", #EF6C00, 12)
  label(ecran, 30, 298, "LES TROIS FAMILLES", #EF6C00, 15)
  kf est un nombre
  pour kf de 0 à 2
    ly est un nombre
    ly vaut 334 + kf * 50
    label(ecran, 30, ly, genEmo[kf] + "  " + chaineNom[kf] + " :", #5D4037, 14)
    kn est un nombre
    pour kn de 1 à NIV_OBJ
      rectangle_arrondi(ecran, 140 + (kn - 1) * 76, ly - 26, 40, 40, 8, coulChaine[kf])
      label(ecran, 148 + (kn - 1) * 76, ly + 2, emoObjet(kf, kn), #000000, 22)
      si kn < NIV_OBJ alors
        label(ecran, 186 + (kn - 1) * 76, ly - 2, "→", #8D6E63, 16)
      fin si
    fin pour
  fin pour
  appelle centrer("ESPACE ou H : retour", 320, 500, #8D6E63, 14)
fin procédure

procédure dessinerHistoire()
  appelle dessinerJeu()
  rectangle(ecran, 0, 0, 640, 520, rgba(62, 39, 35, 0.6))
  rectangle_arrondi(ecran, 60, 190, 520, 200, 18, #FFFDF7)
  appelle centrer("✨ " + etapeNom[etape - 1] + " : c'est fait ! ✨", 320, 232, #43A047, 18)
  label(ecran, 84, 280, texteHistoire, #5D4037, 13)
  appelle centrer("La plage reprend vie... (" + convertir_texte(etape) + " / 6)", 320, 320, #8D6E63, 13)
  appelle centrer("ESPACE : continuer", 320, 362, #EF6C00, 15)
fin procédure

procédure dessinerVictoire()
  appelle dessinerJeu()
  rectangle(ecran, 0, 0, 640, 520, rgba(13, 27, 62, 0.55))
  rectangle_arrondi(ecran, 60, 160, 520, 260, 18, #FFFDF7)
  appelle centrer("🏝️ LE MYSTÈRE EST RÉSOLU ! 🏝️", 320, 210, #EF6C00, 22)
  label(ecran, 84, 256, texteHistoire, #5D4037, 13)
  appelle centrer("La plage est plus belle que jamais.", 320, 300, #8D6E63, 14)
  appelle centrer("Commandes livrées : " + convertir_texte(commandesLivrees), 320, 326, #8D6E63, 14)
  appelle centrer("💎 💰 💎", 320, 366, #000000, 28)
  appelle centrer("ESPACE : continuer à jouer      X : menu", 320, 400, #43A047, 14)
fin procédure


@ LE PROCESSUS : la plage vit
processus VieDeLaPlage()
  tant que appActif
    tic ajoute 1
    si etat = 1 alors
      // l'energie remonte toute seule
      si energie < ENERGIE_MAX alors
        chronoEnergie ajoute 1
        si chronoEnergie >= 50 alors
          chronoEnergie vaut 0
          energie ajoute 1
        fin si
      fin si
      kz est un nombre
      pour kz de 0 à COLS * RANGS - 1
        si popCase[kz] > 0 alors
          popCase[kz] vaut popCase[kz] - 1
        fin si
      fin pour
      nbP est un nombre
      nbP vaut longueur(popT)
      si nbP > 0 alors
        pour kz de nbP - 1 à 0 pas -1
          popT[kz] vaut popT[kz] - 1
          popY[kz] vaut popY[kz] - 1
          si popT[kz] <= 0 alors
            popTxt supprime kz
            popX supprime kz
            popY supprime kz
            popT supprime kz
          fin si
        fin pour
      fin si
      appelle dessinerJeu()
    sinon si etat = 0 alors
      appelle dessinerTitre()
    sinon si etat = 2 alors
      appelle dessinerAide()
    sinon si etat = 3 alors
      appelle dessinerHistoire()
    sinon si etat = 4 alors
      appelle dessinerVictoire()
    fin si
    affiche ecran
    pause 100
  fin tant que
fin processus


@ DEMARRAGE
appelle nouvellePartie()
VieDeLaPlage()

tant que appActif
  si etat = 0 alors
    interagir ecran, [" ", "h", "x"] dans action, ptX, ptY
    si action = 1 ou action = 0 alors
      etat vaut 9
      appelle nouvellePartie()
      etat vaut 1
    sinon si action = 2 alors
      ecranRetour vaut 0
      etat vaut 2
    sinon si action = 3 alors
      appActif vaut faux
    fin si

  sinon si etat = 1 alors
    interagir ecran, ["v", "e", "r", "h", "1", "2", "3", "x"] dans action, ptX, ptY
    si action = 0 alors
      // un clic sur le plateau
      si ptX >= PX et ptX < PX + COLS * CASE et ptY >= PY et ptY < PY + RANGS * CASE alors
        appelle cliquerCase(arrondi_inferieur((ptY - PY) / CASE) * COLS + arrondi_inferieur((ptX - PX) / CASE))
      sinon si clique(ptX, ptY, 410, 210, 218, 40) alors
        appelle renover()
      sinon si clique(ptX, ptY, 16, 484, 130, 28) alors
        appelle vendre()
      sinon si clique(ptX, ptY, 156, 484, 170, 28) alors
        appelle acheterEnergie()
      sinon si clique(ptX, ptY, 336, 484, 90, 28) alors
        ecranRetour vaut 1
        etat vaut 2
      sinon
        kc est un nombre
        pour kc de 0 à 2
          si clique(ptX, ptY, 410, 268 + kc * 62, 218, 56) alors
            appelle livrer(kc)
          fin si
        fin pour
      fin si
    sinon si action = 1 alors
      appelle vendre()
    sinon si action = 2 alors
      appelle acheterEnergie()
    sinon si action = 3 alors
      appelle renover()
    sinon si action = 4 alors
      ecranRetour vaut 1
      etat vaut 2
    sinon si action >= 5 et action <= 7 alors
      appelle livrer(action - 5)
    sinon si action = 8 alors
      etat vaut 0
    fin si

  sinon si etat = 2 alors
    interagir ecran, [" ", "h"] dans action, ptX, ptY
    etat vaut ecranRetour

  sinon si etat = 3 alors
    interagir ecran, [" "] dans action, ptX, ptY
    etat vaut 1

  sinon si etat = 4 alors
    interagir ecran, [" ", "x"] dans action, ptX, ptY
    si action = 2 alors
      etat vaut 0
    sinon
      etat vaut 1
    fin si
  fin si
fin tant que

effacer(ecran)
dégradé(ecran, [#4FC3F7, #FFE0B2])
label(ecran, 320 - label_largeur("À bientôt sur la plage ! 🏝️", 28) / 2, 300, "À bientôt sur la plage ! 🏝️", #FFFFFF, 28)
affiche ecran