Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
@ CONFIGURATION
ecran est une toile
LARG_E est un nombre
LARG_E vaut 720
HAUT_E est un nombre
HAUT_E vaut 500
dimension(ecran, LARG_E, HAUT_E)
// position du surfeur a l'ecran
SURF_X est un nombre
SURF_X vaut 250
// vitesse de depart (pixels par seconde) ; 20 pixels = 1 metre
VITESSE_BASE est un nombre
VITESSE_BASE vaut 260
GRAVITE est un nombre
GRAVITE vaut 1500
ELAN_SAUT est un nombre
ELAN_SAUT vaut 560
// l'avance sur le requin, en pixels
AVANCE_MAX est un nombre
AVANCE_MAX vaut 200
AVANCE_FATALE est un nombre
AVANCE_FATALE vaut 20
PERTE_CHOC est un nombre
PERTE_CHOC vaut 50
// les obstacles : 0 buche, 1 rocher, 2 bouee, 3 mouette
OBS_LARGEUR est un tableau
OBS_LARGEUR vaut [46, 38, 28, 40]
// zone dangereuse de chaque obstacle, en hauteur au-dessus de la vague
OBS_BAS est un tableau
OBS_BAS vaut [0, 0, 0, 72]
OBS_HAUT est un tableau
OBS_HAUT vaut [18, 30, 40, 104]
CIEL est un tableau
CIEL vaut [#FDE7B2, #FDDCA0, #FCCF90, #FBC184, #FAB47A, #F9A870]
@ LE JEU
// etat : 0 accueil, 1 partie, 2 perdu
etat est un nombre
etat vaut 0
appActif est un booléen
appActif vaut vrai
dernierTemps, tic, tempsJeu est un nombre
// le surfeur : posX = distance parcourue (pixels), saut = hauteur au-dessus de la vague
posX, saut, elanY, vitesse, ralenti, avance est un nombre
enLAir est un booléen
dernierChoc, nbEtoiles, score, record est un nombre
nouveauRecord est un booléen
essayer
record vaut parametre('glisseinfinie', 'record')
attraper
record vaut 0
fin essayer
// les obstacles (obsEtat : 0 libre, 1 en place, 2 deja touche)
obsX, obsType, obsEtat est un tableau
pour kc de 0 à 11
obsX ajoute 0
obsType ajoute 0
obsEtat ajoute 0
fin pour
// les etoiles de mer (etoH = hauteur au-dessus de la vague)
etoX, etoH, etoActif est un tableau
pour kc de 0 à 23
etoX ajoute 0
etoH ajoute 0
etoActif ajoute 0
fin pour
prochainX est un nombre
// la hauteur de la vague tous les 24 pixels, calculee a chaque image
yTab est un tableau
pour kc de 0 à 30
yTab ajoute 0
fin pour
nuageX, nuageY est un tableau
pour kc de 0 à 4
nuageX ajoute kc * 170 + hasard(0, 60)
nuageY ajoute 60 + hasard(0, 70)
fin pour
// la souris
appuye, etaitAppuye, clicSouris, vuAppuye, attendRelache est un booléen
finTampon est un nombre
@ OUTILS
procédure centrer(txt, xMil, ty, coul, tp)
label(ecran, xMil - label_largeur(txt, tp) / 2, ty, txt, coul, tp)
fin procédure
// la hauteur a l'ecran de la surface de l'eau, pour une distance wx
fonction yVague(wx)
retourne 318 + 24 * sinus(wx * 0.0062) + 8 * sinus(wx * 0.017 + 1)
fin fonction
// la position a l'ecran d'un point situe a la distance wx
fonction xEcran(wx)
retourne SURF_X + wx - posX
fin fonction
fonction multiplicateur()
retourne 1 + minimum(posX / 20 / 1200, 1.3)
fin fonction
@ LES OBSTACLES ET LES ETOILES
procédure ajouterObstacle(wx, genre)
k, libre est un nombre
libre vaut -1
pour k de 0 à 11
si obsEtat[k] = 0 alors
libre vaut k
fin si
fin pour
si libre >= 0 alors
obsX[libre] vaut wx
obsType[libre] vaut genre
obsEtat[libre] vaut 1
fin si
fin procédure
procédure ajouterEtoile(wx, h)
k, libre est un nombre
libre vaut -1
pour k de 0 à 23
si etoActif[k] = 0 alors
libre vaut k
fin si
fin pour
si libre >= 0 alors
etoX[libre] vaut wx
etoH[libre] vaut h
etoActif[libre] vaut 1
fin si
fin procédure
// place le prochain groupe d'obstacles et d'etoiles, puis choisit l'ecart suivant
procédure placerGroupe()
motif, k est un nombre
motif vaut hasard(0, 9)
si motif <= 3 alors
// un obstacle seul, avec un arc d'etoiles au-dessus
appelle ajouterObstacle(prochainX, hasard(0, 2))
appelle ajouterEtoile(prochainX - 52, 62)
appelle ajouterEtoile(prochainX, 92)
appelle ajouterEtoile(prochainX + 52, 62)
sinon si motif <= 5 alors
// une mouette : il faut rester en bas, la ou sont les etoiles
appelle ajouterObstacle(prochainX, 3)
pour k de 0 à 2
appelle ajouterEtoile(prochainX - 40 + k * 40, 22)
fin pour
sinon si motif <= 7 alors
// deux buches a franchir d'un seul saut
appelle ajouterObstacle(prochainX - 38, 0)
appelle ajouterObstacle(prochainX + 38, 0)
appelle ajouterEtoile(prochainX, 96)
sinon
// un moment de repos avec une ligne d'etoiles
pour k de 0 à 3
appelle ajouterEtoile(prochainX - 60 + k * 40, 22)
fin pour
fin si
// l'ecart depend de la vitesse : il laisse toujours le temps de reagir
prochainX vaut prochainX + vitesse * hasard(115, 190) / 100
fin procédure
procédure nouvellePartie()
k est un nombre
posX vaut 0
saut vaut 0
elanY vaut 0
enLAir vaut faux
vitesse vaut VITESSE_BASE
ralenti vaut 1
avance vaut AVANCE_MAX
dernierChoc vaut -10
tempsJeu vaut 0
nbEtoiles vaut 0
score vaut 0
nouveauRecord vaut faux
pour k de 0 à 11
obsEtat[k] vaut 0
fin pour
pour k de 0 à 23
etoActif[k] vaut 0
fin pour
prochainX vaut 900
attendRelache vaut vrai
finTampon vaut 0
etat vaut 1
fin procédure
procédure finDePartie()
etat vaut 2
si score > record alors
record vaut score
nouveauRecord vaut vrai
essayer
parametre('glisseinfinie', 'record', record)
attraper
tic vaut tic
fin essayer
fin si
fin procédure
@ LA PARTIE
procédure avancer(dt, veutSauter)
k, genre, ecart est un nombre
tempsJeu vaut tempsJeu + dt
// la vitesse monte avec la distance ; un choc la fait chuter un moment
ralenti vaut minimum(1, ralenti + dt * 0.25)
vitesse vaut VITESSE_BASE * multiplicateur() * ralenti
posX vaut posX + vitesse * dt
// le saut
si veutSauter et non enLAir alors
elanY vaut ELAN_SAUT
enLAir vaut vrai
fin si
si enLAir alors
elanY vaut elanY - GRAVITE * dt
saut vaut saut + elanY * dt
si saut <= 0 alors
saut vaut 0
elanY vaut 0
enLAir vaut faux
fin si
fin si
// le requin : il se rapproche a chaque choc, puis on reprend peu a peu de l'avance
si tempsJeu - dernierChoc > 1.5 alors
avance vaut minimum(AVANCE_MAX, avance + 10 * dt)
fin si
// les obstacles
pour k de 0 à 11
si obsEtat[k] > 0 alors
genre vaut obsType[k]
ecart vaut absolue(obsX[k] - posX)
si obsX[k] < posX - 400 alors
obsEtat[k] vaut 0
sinon si obsEtat[k] = 1 et ecart < OBS_LARGEUR[genre] / 2 + 12 alors
si saut < OBS_HAUT[genre] et saut + 50 > OBS_BAS[genre] et tempsJeu - dernierChoc > 1 alors
obsEtat[k] vaut 2
dernierChoc vaut tempsJeu
ralenti vaut 0.45
avance vaut avance - PERTE_CHOC
fin si
fin si
fin si
fin pour
// les etoiles de mer
pour k de 0 à 23
si etoActif[k] = 1 alors
si etoX[k] < posX - 400 alors
etoActif[k] vaut 0
sinon si absolue(etoX[k] - posX) < 26 et etoH[k] > saut - 16 et etoH[k] < saut + 62 alors
etoActif[k] vaut 0
nbEtoiles vaut nbEtoiles + 1
fin si
fin si
fin pour
si prochainX < posX + 800 alors
appelle placerGroupe()
fin si
score vaut arrondi_inferieur(posX / 20) * 3 + nbEtoiles * 50
si avance <= AVANCE_FATALE alors
appelle finDePartie()
fin si
fin procédure
@ LES DESSINS
procédure dessinerDecor()
k, x est un nombre
pour k de 0 à 5
rectangle(ecran, 0, k * 60, LARG_E, 60, CIEL[k])
fin pour
// le soleil et ses halos
cercle(ecran, 520, 120, 78, rgba(255, 255, 255, 0.12))
cercle(ecran, 520, 120, 58, rgba(255, 255, 255, 0.16))
cercle(ecran, 520, 120, 38, #FFE27A)
// les nuages
pour k de 0 à 4
x vaut arrondi(nuageX[k] - posX * 0.03 + 90000) mod 900 - 100
ellipse(ecran, x, nuageY[k], 44, 13, rgba(255, 255, 255, 0.75))
ellipse(ecran, x + 26, nuageY[k] - 9, 28, 12, rgba(255, 255, 255, 0.75))
fin pour
// les iles au loin, avec leurs palmiers
pour k de 0 à 2
x vaut arrondi(k * 420 - posX * 0.08 + 90000) mod 1260 - 300
ellipse(ecran, x + 150, 300, 170, 60 + k * 14, #1F6F8B)
ellipse(ecran, x + 250, 306, 120, 44, #17566E)
ligne(ecran, x + 120, 250 - k * 12, x + 128, 196 - k * 12, #0F3D4F, 4)
ligne(ecran, x + 128, 196 - k * 12, x + 100, 204 - k * 12, #0F3D4F, 4)
ligne(ecran, x + 128, 196 - k * 12, x + 156, 204 - k * 12, #0F3D4F, 4)
ligne(ecran, x + 128, 196 - k * 12, x + 112, 184 - k * 12, #0F3D4F, 4)
ligne(ecran, x + 128, 196 - k * 12, x + 146, 184 - k * 12, #0F3D4F, 4)
fin pour
fin procédure
// le requin, dont seuls l'aileron et la tete depassent de l'eau
procédure dessinerRequin()
x, y, gueule est un nombre
x vaut SURF_X - avance - 10
y vaut yVague(posX - avance - 10) - 14 + 4 * sinus(tic * 0.2)
gueule vaut 4 + 10 * limiter((AVANCE_MAX - avance) / 150, 0, 1) + 3 * sinus(tic * 0.4)
// l'aileron
polygone(ecran, x - 46, y + 6, x - 30, y - 44, x - 8, y + 6, #64748B)
polygone(ecran, x - 40, y + 6, x - 30, y - 30, x - 20, y + 6, #94A3B8)
// la tete
polygone(ecran, x - 70, y + 30, x - 20, y - 6, x + 44, y + 2 - gueule, x + 10, y + 30, #64748B)
polygone(ecran, x - 10, y + 30, x + 40, y + 12 + gueule, x + 4, y + 40, #94A3B8)
cercle(ecran, x + 8, y + 2, 4, #0F172A)
// les dents
polygone(ecran, x + 18, y + 5 - gueule * 0.6, x + 24, y + 14 - gueule * 0.5, x + 30, y + 4 - gueule * 0.8, #FFFFFF)
polygone(ecran, x + 30, y + 4 - gueule * 0.8, x + 35, y + 12 - gueule * 0.7, x + 40, y + 3 - gueule, #FFFFFF)
fin procédure
procédure dessinerMer()
k, x est un nombre
pour k de 0 à 30
yTab[k] vaut yVague(posX - SURF_X + k * 24)
fin pour
pour k de 0 à 29
x vaut k * 24
polygone(ecran, x, yTab[k], x + 25, yTab[k + 1], x + 25, HAUT_E, x, HAUT_E, #1D4ED8)
fin pour
rectangle(ecran, 0, 410, LARG_E, 90, rgba(15, 23, 80, 0.35))
rectangle(ecran, 0, 455, LARG_E, 45, rgba(15, 23, 80, 0.35))
// l'ecume et les reflets
pour k de 0 à 29
x vaut k * 24
ligne(ecran, x, yTab[k] + 1, x + 24, yTab[k + 1] + 1, #E0F2FE, 4)
ligne(ecran, x, yTab[k] + 34, x + 24, yTab[k + 1] + 34, rgba(255, 255, 255, 0.14), 2)
ligne(ecran, x, yTab[k] + 70, x + 24, yTab[k + 1] + 70, rgba(255, 255, 255, 0.09), 2)
fin pour
fin procédure
procédure dessinerObstacle(x, y, genre, touche)
aile est un nombre
si genre = 0 alors
rectangle_arrondi(ecran, x - 23, y - 12, 46, 18, 8, #92400E)
rectangle_arrondi(ecran, x - 23, y - 12, 12, 18, 6, #D6A26B)
ligne(ecran, x - 6, y - 6, x + 14, y - 6, #78350F, 2)
sinon si genre = 1 alors
polygone(ecran, x - 19, y + 6, x - 12, y - 20, x + 4, y - 30, x + 17, y - 14, x + 19, y + 6, #475569)
polygone(ecran, x - 12, y - 20, x + 4, y - 30, x + 2, y - 12, #64748B)
sinon si genre = 2 alors
rectangle_arrondi(ecran, x - 14, y - 22, 28, 28, 10, #DC2626)
rectangle(ecran, x - 14, y - 12, 28, 7, #FFFFFF)
rectangle(ecran, x - 2, y - 40, 4, 18, #1F2937)
cercle(ecran, x, y - 42, 5, #FACC15)
sinon
// la mouette vole a hauteur de saut
aile vaut 10 * sinus(tic * 0.5)
ellipse(ecran, x, y - 88, 14, 7, #F8FAFC)
polygone(ecran, x - 4, y - 90, x - 22, y - 96 - aile, x + 2, y - 92, #E2E8F0)
polygone(ecran, x + 4, y - 90, x + 22, y - 96 - aile, x - 2, y - 92, #CBD5E1)
polygone(ecran, x - 13, y - 90, x - 24, y - 87, x - 13, y - 85, #F59E0B)
cercle(ecran, x - 9, y - 90, 2, #0F172A)
fin si
si touche alors
cercle(ecran, x, y - 10, 26, rgba(255, 255, 255, 0.35))
fin si
fin procédure
procédure dessinerEtoile(x, y)
cercle(ecran, x, y, 13, rgba(253, 224, 71, 0.35))
polygone(ecran, x, y - 11, x + 3, y - 3, x + 11, y - 3, x + 5, y + 2, x + 7, y + 10, x, y + 5, x - 7, y + 10, x - 5, y + 2, x - 11, y - 3, x - 3, y - 3, #F59E0B)
cercle(ecran, x, y, 3, #FEF3C7)
fin procédure
procédure dessinerObjets()
k, x est un nombre
pour k de 0 à 11
si obsEtat[k] > 0 alors
x vaut xEcran(obsX[k])
si x > -60 et x < LARG_E + 60 alors
si obsEtat[k] = 2 alors
appelle dessinerObstacle(x, yVague(obsX[k]), obsType[k], vrai)
sinon
appelle dessinerObstacle(x, yVague(obsX[k]), obsType[k], faux)
fin si
fin si
fin si
fin pour
pour k de 0 à 23
si etoActif[k] = 1 alors
x vaut xEcran(etoX[k])
si x > -30 et x < LARG_E + 30 alors
appelle dessinerEtoile(x, yVague(etoX[k]) - etoH[k] - 6 + 3 * sinus(tic * 0.2 + k))
fin si
fin si
fin pour
fin procédure
procédure dessinerSurfeur()
x, y, pente, depuis, k est un nombre
x vaut SURF_X
y vaut yVague(posX) - saut
// la planche suit la pente de la vague, ou se cabre pendant le saut
pente vaut (yVague(posX + 26) - yVague(posX - 26)) / 2
si enLAir alors
pente vaut 0 - elanY * 0.02
fin si
depuis vaut tempsJeu - dernierChoc
// apres un choc, le surfeur clignote
si depuis > 1 ou tic mod 4 < 2 alors
ligne(ecran, x - 28, y - pente - 2, x + 30, y + pente - 2, #B91C1C, 7)
ligne(ecran, x - 24, y - pente - 3, x + 26, y + pente - 3, #F87171, 3)
// les jambes
ligne(ecran, x - 8, y - 6, x - 4, y - 24, #F2C49B, 5)
ligne(ecran, x + 10, y - 6, x + 4, y - 24, #F2C49B, 5)
// le short et le torse
rectangle_arrondi(ecran, x - 8, y - 32, 16, 12, 4, #EA580C)
rectangle_arrondi(ecran, x - 7, y - 48, 14, 18, 5, #F2C49B)
// les bras en equilibre
ligne(ecran, x - 6, y - 44, x - 22, y - 38 - saut * 0.05, #F2C49B, 4)
ligne(ecran, x + 6, y - 44, x + 22, y - 40 - saut * 0.05, #F2C49B, 4)
// la tete
cercle(ecran, x + 1, y - 56, 8, #F2C49B)
polygone(ecran, x - 8, y - 58, x - 4, y - 66, x + 8, y - 65, x + 9, y - 58, x, y - 61, #1F2937)
cercle(ecran, x + 5, y - 56, 1.5, #1F2937)
fin si
// les gerbes d'eau
si non enLAir alors
pour k de 0 à 3
cercle(ecran, x - 30 - k * 9, y + 2 - ((tic * 3 + k * 5) mod 14), 4 - k * 0.7, rgba(255, 255, 255, 0.8 - k * 0.15))
fin pour
fin si
si depuis < 0.5 alors
pour k de 0 à 5
cercle(ecran, x - 20 + k * 9, y - 10 - depuis * 120 + k * k * 2, 5 - depuis * 8, rgba(255, 255, 255, 0.9))
fin pour
fin si
fin procédure
procédure pastille(x, lb, titre, valeur, sousTitre)
rectangle_arrondi(ecran, x, 10, lb, 58, 10, rgba(12, 44, 84, 0.88))
label(ecran, x + 12, 26, titre, #93C5FD, 10)
label(ecran, x + 12, 46, valeur, #FFFFFF, 18)
label(ecran, x + 12, 61, sousTitre, #BFDBFE, 10)
fin procédure
procédure dessinerInterface()
part est un nombre
appelle pastille(10, 118, "SCORE", convertir_texte(score), convertir_texte(nbEtoiles) + " étoiles de mer")
appelle pastille(136, 118, "DISTANCE", convertir_texte(arrondi_inferieur(posX / 20)) + " m", "Vitesse " + convertir_texte(arrondi(multiplicateur() * ralenti * 10) / 10) + "x")
appelle pastille(592, 118, "RECORD", convertir_texte(maximum(record, score)), "Meilleure glisse")
// l'avance sur le requin
part vaut limiter((avance - AVANCE_FATALE) / (AVANCE_MAX - AVANCE_FATALE), 0, 1)
label(ecran, 250, 468, "AVANCE SUR LE REQUIN", #E0F2FE, 10)
rectangle_arrondi(ecran, 250, 474, 220, 10, 5, rgba(255, 255, 255, 0.25))
si part > 0.6 alors
rectangle_arrondi(ecran, 250, 474, maximum(10, 220 * part), 10, 5, #34D399)
sinon si part > 0.3 alors
rectangle_arrondi(ecran, 250, 474, maximum(10, 220 * part), 10, 5, #FBBF24)
sinon
rectangle_arrondi(ecran, 250, 474, maximum(10, 220 * part), 10, 5, #F87171)
fin si
si part <= 0.3 alors
label(ecran, 480, 484, "Danger !", #FECACA, 12)
sinon si tempsJeu - dernierChoc < 1.5 alors
label(ecran, 480, 484, "Ralenti...", #FDE68A, 12)
sinon
label(ecran, 480, 484, "Belle glisse", #A7F3D0, 12)
fin si
si tempsJeu < 3 alors
appelle centrer("Espace, flèche Haut ou clic pour sauter", LARG_E / 2, 110, #0C2C54, 18)
fin si
fin procédure
procédure dessinerAccueil()
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(12, 44, 84, 0.45))
rectangle_arrondi(ecran, 130, 70, 460, 330, 20, rgba(12, 44, 84, 0.92))
appelle centrer("Glisse Infinie", 360, 130, #FDE68A, 42)
appelle centrer("Le défi de surf sans fin", 360, 160, #BFDBFE, 15)
appelle centrer("Saute par-dessus les bûches, les rochers et les bouées.", 360, 202, #FFFFFF, 14)
appelle centrer("Reste en bas quand une mouette passe.", 360, 226, #FFFFFF, 14)
appelle centrer("Ramasse les étoiles de mer pour gonfler ton score.", 360, 250, #FFFFFF, 14)
appelle centrer("Chaque choc te ralentit... et le requin se rapproche !", 360, 274, #FECACA, 14)
rectangle_arrondi(ecran, 260, 304, 200, 50, 14, #F59E0B)
appelle centrer("Surfer", 360, 337, #0C2C54, 20)
appelle centrer("Espace, flèche Haut ou clic : sauter X : quitter", 360, 384, #93C5FD, 12)
fin procédure
procédure dessinerPerdu()
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(12, 44, 84, 0.5))
rectangle_arrondi(ecran, 170, 110, 380, 270, 20, rgba(12, 44, 84, 0.94))
appelle centrer("Le requin t'a rattrapé !", 360, 160, #FECACA, 24)
appelle centrer("Score : " + convertir_texte(score), 360, 204, #FFFFFF, 22)
appelle centrer(convertir_texte(arrondi_inferieur(posX / 20)) + " m " + convertir_texte(nbEtoiles) + " étoiles de mer", 360, 234, #BFDBFE, 14)
si nouveauRecord alors
appelle centrer("Nouveau record !", 360, 266, #FDE68A, 18)
sinon
appelle centrer("Record : " + convertir_texte(record), 360, 266, #93C5FD, 15)
fin si
rectangle_arrondi(ecran, 260, 296, 200, 50, 14, #F59E0B)
appelle centrer("Rejouer", 360, 329, #0C2C54, 20)
fin procédure
procédure dessiner()
effacer(ecran)
contour(ecran, #0)
appelle dessinerDecor()
appelle dessinerRequin()
appelle dessinerMer()
appelle dessinerObjets()
appelle dessinerSurfeur()
si etat = 0 alors
appelle dessinerAccueil()
sinon
appelle dessinerInterface()
si etat = 2 alors
appelle dessinerPerdu()
fin si
fin si
fin procédure
@ LES COMMANDES
// un tour de jeu : dt est le temps ecoule en secondes
procédure tourDeJeu(dt)
debut, veutSauter, lancer est un booléen
tic vaut tic + 1
appuye vaut souris_appuyée(ecran)
clicSouris vaut souris_clic(ecran)
debut vaut faux
si appuye alors
vuAppuye vaut vrai
si non etaitAppuye alors
debut vaut vrai
fin si
sinon
attendRelache vaut faux
fin si
// si le bouton maintenu n'est pas vu, un simple clic compte quand meme
si clicSouris et non vuAppuye alors
debut vaut vrai
finTampon vaut chrono() + 130
fin si
etaitAppuye vaut appuye
si etat = 1 alors
veutSauter vaut faux
si touche_enfoncée('espace') ou touche_enfoncée('haut') alors
veutSauter vaut vrai
fin si
si appuye et non attendRelache alors
veutSauter vaut vrai
fin si
si chrono() < finTampon alors
veutSauter vaut vrai
fin si
appelle avancer(dt, veutSauter)
sinon
lancer vaut debut
si touche_pressée('espace') ou touche_pressée('haut') alors
lancer vaut vrai
fin si
si lancer alors
appelle nouvellePartie()
fin si
fin si
si touche_pressée('x') ou touche_pressée('échap') alors
appActif vaut faux
fin si
fin procédure
@ DEMARRAGE
maintenantMs est un nombre
avance vaut AVANCE_MAX
dernierChoc vaut -10
dernierTemps vaut chrono()
tant que appActif
maintenantMs vaut chrono()
appelle tourDeJeu(limiter((maintenantMs - dernierTemps) / 1000, 0, 0.05))
dernierTemps vaut maintenantMs
appelle dessiner()
affiche ecran
pause 30
fin tant que
effacer(ecran)
remplir(ecran, #0C2C54)
appelle centrer("À bientôt sur les vagues de Glisse Infinie !", LARG_E / 2, HAUT_E / 2, #FDE68A, 22)
affiche ecran