Console
Clique sur « Exécuter » pour lancer le programme.
Code CoddyRun
@ CONFIGURATION
ecran est une toile
dimension(ecran, 320, 450)
// la route : 3 voies de 80 pixels
ROUTE_G est un nombre
ROUTE_G vaut 40
ROUTE_D est un nombre
ROUTE_D vaut 280
VOIE_X est un tableau
VOIE_X vaut [80, 160, 240]
HAUT_JEU est un nombre
HAUT_JEU vaut 46
BAS_JEU est un nombre
BAS_JEU vaut 400
JOUEUR_Y est un nombre
JOUEUR_Y vaut 340
MAXO est un nombre
MAXO vaut 40
MAXP est un nombre
MAXP vaut 30
VIT_DEBUT est un nombre
VIT_DEBUT vaut 7
VIT_MAX est un nombre
VIT_MAX vaut 17
coulVoiture est un tableau
coulVoiture vaut [#1E88E5, #FDD835, #43A047, #8E24AA, #FB8C00]
coulVoitureF est un tableau
coulVoitureF vaut [#0D47A1, #F9A825, #1B5E20, #4A148C, #E65100]
@ LES OBJETS SUR LA ROUTE
// type : 1 plot, 2 voiture, 3 piece
// oChg : -1 ou 1 si la voiture va changer de voie, oX0 : sa voie de depart
oA est un tableau
oT, oX, oY, oC, oV, oChg, oX0 est un tableau
pour ki de 0 à MAXO - 1
oChg ajoute 0
oX0 ajoute 0
oA ajoute faux
oT ajoute 0
oX ajoute 0
oY ajoute 0
oC ajoute 0
oV ajoute 1
fin pour
// le changement de voie se fait selon la hauteur de la voiture a l'ecran :
// clignotant a partir de Y_CLIGNO, deplacement entre Y_DEBUT_CHG et Y_FIN_CHG
Y_CLIGNO est un nombre
Y_CLIGNO vaut 40
Y_DEBUT_CHG est un nombre
Y_DEBUT_CHG vaut 120
Y_FIN_CHG est un nombre
Y_FIN_CHG vaut 210
// les voies libres de la derniere rangee
libreAvant est un tableau
libreAvant vaut [vrai, vrai, vrai]
libreNouv est un tableau
libreNouv vaut [vrai, vrai, vrai]
@ LES ETINCELLES
pA est un tableau
pX, pY, pVX, pVY, pV est un tableau
pC est un tableau
pour ki de 0 à MAXP - 1
pA ajoute faux
pX ajoute 0
pY ajoute 0
pVX ajoute 0
pVY ajoute 0
pV ajoute 0
pC ajoute #FFFFFF
fin pour
pRang est un nombre
@ LA PARTIE
// etat : 0 accueil, 1 course, 2 pause, 3 fin, 9 preparation
etat est un nombre
etat vaut 0
appActif est un booléen
appActif vaut vrai
tic est un nombre
vitesse, defile, depuisRangee, distance, pieces, score est un nombre
voie est un nombre
voie vaut 1
joueurX est un nombre
joueurX vaut 160
vies, invincible, choc est un nombre
nouveauRecord est un booléen
record est un nombre
essayer
record vaut parametre('turbo_piste', 'record')
attraper
record vaut 0
fin essayer
ordres, ordX, ordY est un tableau
pour ki de 0 à 31
ordres ajoute 0
ordX ajoute 0
ordY ajoute 0
fin pour
teteO, queueO est un nombre
action, sourisX, sourisY est un nombre
@ LE TEXTE
procédure centrer(txt, xMil, yTxt, coul, taillePolice)
label(ecran, xMil - label_largeur(txt, taillePolice) / 2, yTxt, txt, coul, taillePolice)
fin procédure
procédure bouton(x, y, l, hb, txt, fond, coulTxt, taillePolice)
rectangle_arrondi(ecran, x, y + 4, l, hb, hb / 2, rgba(0, 0, 0, 0.4))
rectangle_arrondi(ecran, x, y, l, hb, hb / 2, fond)
appelle centrer(txt, x + l / 2, y + hb / 2 + taillePolice * 0.38, coulTxt, taillePolice)
fin procédure
@ LES OBJETS
procédure ajouterObjet(t, x, y, c, v, chg)
libreO est un nombre
libreO vaut -1
ko est un nombre
pour ko de 0 à MAXO - 1
si non oA[ko] et libreO = -1 alors
libreO vaut ko
fin si
fin pour
si libreO >= 0 alors
oA[libreO] vaut vrai
oT[libreO] vaut t
oX[libreO] vaut x
oY[libreO] vaut y
oC[libreO] vaut c
oV[libreO] vaut v
oChg[libreO] vaut chg
oX0[libreO] vaut x
fin si
fin procédure
procédure etincelles(x, y, coul, nb)
ke est un nombre
pour ke de 1 à nb
angE est un nombre
angE vaut radians(hasard(0, 359))
vit est un nombre
vit vaut hasard(15, 45) / 10
pA[pRang] vaut vrai
pX[pRang] vaut x
pY[pRang] vaut y
pVX[pRang] vaut cosinus(angE) * vit
pVY[pRang] vaut sinus(angE) * vit
pV[pRang] vaut hasard(8, 16)
pC[pRang] vaut coul
pRang vaut (pRang + 1) mod MAXP
fin pour
fin procédure
// une rangee est jouable si, depuis chaque voie libre d'avant,
// on peut atteindre une voie libre en changeant d'une voie au plus
fonction rangeeJouable()
ok est un booléen
ok vaut vrai
kv est un nombre
pour kv de 0 à 2
si libreAvant[kv] alors
atteint est un booléen
atteint vaut faux
kn est un nombre
pour kn de 0 à 2
si libreNouv[kn] et absolue(kn - kv) <= 1 alors
atteint vaut vrai
fin si
fin pour
si non atteint alors
ok vaut faux
fin si
fin si
fin pour
retourne ok
fin fonction
procédure nouvelleRangee()
// combien de voies bloquees ? (deux, de plus en plus souvent)
nbBloc est un nombre
nbBloc vaut 1
si hasard(1, 100) <= minimum(60, (vitesse - VIT_DEBUT) * 8 + 10) alors
nbBloc vaut 2
fin si
essai est un nombre
essai vaut 0
trouve est un booléen
trouve vaut faux
tant que non trouve et essai < 20
essai vaut essai + 1
kv est un nombre
pour kv de 0 à 2
libreNouv[kv] vaut vrai
fin pour
b1 est un nombre
b1 vaut hasard(0, 2)
libreNouv[b1] vaut faux
si nbBloc = 2 alors
b2 est un nombre
b2 vaut (b1 + hasard(1, 2)) mod 3
libreNouv[b2] vaut faux
fin si
si rangeeJouable() alors
trouve vaut vrai
fin si
fin tant que
si non trouve alors
// on laisse tout libre
pour kv de 0 à 2
libreNouv[kv] vaut vrai
fin pour
fin si
// parfois, la seule voiture de la rangee va changer de voie
chgVoie est un nombre
chgVoie vaut -1
dirChg est un nombre
dirChg vaut 0
voitureSeule est un booléen
voitureSeule vaut faux
si nbBloc = 1 et trouve et hasard(1, 100) <= minimum(55, 25 + (vitesse - VIT_DEBUT) * 4) alors
kb est un nombre
pour kb de 0 à 2
si non libreNouv[kb] alors
chgVoie vaut kb
fin si
fin pour
// vers une voie voisine
si chgVoie = 0 alors
dirChg vaut 1
sinon si chgVoie = 2 alors
dirChg vaut -1
sinon
dirChg vaut sialors(hasard(0, 1) = 0, -1, 1)
fin si
// la voie qui reste libre tout le temps doit etre atteignable
kc est un nombre
pour kc de 0 à 2
libreNouv[kc] vaut vrai
fin pour
libreNouv[chgVoie] vaut faux
libreNouv[chgVoie + dirChg] vaut faux
si rangeeJouable() alors
voitureSeule vaut vrai
fin si
libreNouv[chgVoie + dirChg] vaut vrai
si non voitureSeule alors
chgVoie vaut -1
fin si
fin si
// on pose les obstacles et parfois une piece
pieceMise est un booléen
pieceMise vaut faux
pour kv de 0 à 2
si kv = chgVoie alors
appelle ajouterObjet(2, VOIE_X[kv], -60, hasard(0, 4), 0.9, dirChg)
sinon si non libreNouv[kv] alors
si hasard(1, 100) <= 55 alors
appelle ajouterObjet(2, VOIE_X[kv], -60, hasard(0, 4), 0.9, 0)
sinon
appelle ajouterObjet(1, VOIE_X[kv], -40, 0, 1, 0)
fin si
sinon si non pieceMise et hasard(1, 100) <= 45 et (chgVoie < 0 ou kv <> chgVoie + dirChg) alors
appelle ajouterObjet(3, VOIE_X[kv], -40, 0, 1, 0)
pieceMise vaut vrai
fin si
libreAvant[kv] vaut libreNouv[kv]
fin pour
// apres un changement de voie, le joueur peut etre dans n'importe quelle voie
si chgVoie >= 0 alors
pour kv de 0 à 2
libreAvant[kv] vaut vrai
fin pour
fin si
fin procédure
@ LA PARTIE
procédure nouvellePartie()
ko est un nombre
pour ko de 0 à MAXO - 1
oA[ko] vaut faux
fin pour
pour ko de 0 à MAXP - 1
pA[ko] vaut faux
fin pour
pour ko de 0 à 2
libreAvant[ko] vaut vrai
fin pour
vitesse vaut VIT_DEBUT
defile vaut 0
depuisRangee vaut 0
distance vaut 0
pieces vaut 0
score vaut 0
voie vaut 1
joueurX vaut VOIE_X[1]
vies vaut 3
invincible vaut 0
choc vaut 0
nouveauRecord vaut faux
etat vaut 1
fin procédure
procédure changerVoie(dv)
voie vaut limiter(voie + dv, 0, 2)
fin procédure
procédure finPartie()
si score > record alors
record vaut score
nouveauRecord vaut vrai
parametre('turbo_piste', 'record', record)
fin si
etat vaut 3
fin procédure
procédure avancer()
// la vitesse augmente doucement
vitesse vaut minimum(VIT_MAX, vitesse + 0.008)
defile vaut defile + vitesse
distance vaut distance + vitesse
score vaut arrondi_inferieur(distance / 40) + pieces * 5
// une nouvelle rangee : plus on va vite, plus elles sont espacees
depuisRangee vaut depuisRangee + vitesse
si depuisRangee >= 170 + vitesse * 9 alors
depuisRangee vaut 0
appelle nouvelleRangee()
fin si
// la voiture glisse vers sa voie
cible est un nombre
cible vaut VOIE_X[voie]
si absolue(cible - joueurX) <= 20 alors
joueurX vaut cible
sinon si cible > joueurX alors
joueurX vaut joueurX + 20
sinon
joueurX vaut joueurX - 20
fin si
si invincible > 0 alors
invincible vaut invincible - 1
fin si
si choc > 0 alors
choc vaut choc - 1
fin si
// les objets descendent et on regarde les chocs
ko est un nombre
pour ko de 0 à MAXO - 1
si oA[ko] alors
oY[ko] vaut oY[ko] + vitesse * oV[ko]
si oChg[ko] <> 0 alors
oX[ko] vaut oX0[ko] + oChg[ko] * 80 * limiter((oY[ko] - Y_DEBUT_CHG) / (Y_FIN_CHG - Y_DEBUT_CHG), 0, 1)
fin si
si oY[ko] > 500 alors
oA[ko] vaut faux
fin si
fin si
si oA[ko] alors
demiH est un nombre
demiH vaut 18
si oT[ko] = 2 alors
demiH vaut 30
sinon si oT[ko] = 3 alors
demiH vaut 12
fin si
si absolue(oX[ko] - joueurX) < 34 et absolue(oY[ko] - JOUEUR_Y) < demiH + 26 alors
si oT[ko] = 3 alors
oA[ko] vaut faux
pieces vaut pieces + 1
appelle etincelles(oX[ko], oY[ko], #FFD54F, 8)
sinon si invincible = 0 alors
oA[ko] vaut faux
vies vaut vies - 1
invincible vaut 34
choc vaut 10
appelle etincelles(joueurX, JOUEUR_Y - 20, #FF7043, 14)
appelle etincelles(joueurX, JOUEUR_Y - 20, #FFFFFF, 6)
si vies <= 0 alors
appelle finPartie()
fin si
fin si
fin si
fin si
fin pour
fin procédure
procédure animerEffets()
kp est un nombre
pour kp de 0 à MAXP - 1
si pA[kp] alors
pX[kp] vaut pX[kp] + pVX[kp]
pY[kp] vaut pY[kp] + pVY[kp]
pV[kp] vaut pV[kp] - 1
si pV[kp] <= 0 alors
pA[kp] vaut faux
fin si
fin si
fin pour
fin procédure
@ DESSIN : LE DECOR
procédure arbre(x, y)
cercle(ecran, x + 2, y + 3, 13, rgba(0, 0, 0, 0.18))
cercle(ecran, x - 6, y + 2, 9, #2E7D32)
cercle(ecran, x + 6, y + 2, 9, #2E7D32)
cercle(ecran, x, y - 6, 10, #388E3C)
cercle(ecran, x - 3, y - 8, 4, #66BB6A)
fin procédure
procédure dessinerDecor()
// l'herbe, avec des bandes qui defilent
rectangle(ecran, 0, 0, 320, 450, #4CAF50)
dec est un nombre
dec vaut defile mod 80
kb est un nombre
pour kb de -1 à 6
rectangle(ecran, 0, kb * 80 + dec, 320, 40, #43A047)
fin pour
// les arbres des deux cotes
decA est un nombre
decA vaut defile mod 110
pour kb de -1 à 5
appelle arbre(16, kb * 110 + decA + 20)
appelle arbre(304, kb * 110 + decA + 75)
fin pour
// les bordures rouges et blanches
decB est un nombre
decB vaut defile mod 48
pour kb de -1 à 11
rectangle(ecran, ROUTE_G - 12, kb * 48 + decB, 12, 24, #E53935)
rectangle(ecran, ROUTE_G - 12, kb * 48 + decB + 24, 12, 24, #FAFAFA)
rectangle(ecran, ROUTE_D, kb * 48 + decB, 12, 24, #E53935)
rectangle(ecran, ROUTE_D, kb * 48 + decB + 24, 12, 24, #FAFAFA)
fin pour
// la route et ses lignes pointillees
rectangle(ecran, ROUTE_G, 0, ROUTE_D - ROUTE_G, 450, #2B3550)
rectangle(ecran, ROUTE_G, 0, 3, 450, #FAFAFA)
rectangle(ecran, ROUTE_D - 3, 0, 3, 450, #FAFAFA)
decL est un nombre
decL vaut defile mod 60
pour kb de -1 à 9
rectangle(ecran, 118, kb * 60 + decL, 4, 30, #E8EAF6)
rectangle(ecran, 198, kb * 60 + decL, 4, 30, #E8EAF6)
fin pour
// la ligne de depart a damier, qui s'eloigne au debut
yDep est un nombre
yDep vaut 378 + distance
si yDep < 460 alors
kd est un nombre
pour kd de 0 à 19
rectangle(ecran, ROUTE_G + kd * 12, yDep, 12, 12, sialors(kd mod 2 = 0, #FAFAFA, #212121))
rectangle(ecran, ROUTE_G + kd * 12, yDep + 12, 12, 12, sialors(kd mod 2 = 1, #FAFAFA, #212121))
fin pour
fin si
fin procédure
@ DESSIN : LES VOITURES ET LES OBJETS
// une voiture vue de dessus ; avant vers le haut si versHaut
procédure voiture(x, y, coul, coulF, versHaut)
// l'ombre et les roues
rectangle_arrondi(ecran, x - 19, y - 28, 42, 62, 10, rgba(0, 0, 0, 0.25))
rectangle_arrondi(ecran, x - 22, y - 22, 7, 14, 2, #111111)
rectangle_arrondi(ecran, x + 15, y - 22, 7, 14, 2, #111111)
rectangle_arrondi(ecran, x - 22, y + 10, 7, 14, 2, #111111)
rectangle_arrondi(ecran, x + 15, y + 10, 7, 14, 2, #111111)
// la carrosserie
rectangle_arrondi(ecran, x - 18, y - 30, 36, 60, 12, coulF)
rectangle_arrondi(ecran, x - 16, y - 29, 32, 57, 11, coul)
// le pare-brise et la vitre arriere
av est un nombre
av vaut -1
si non versHaut alors
av vaut 1
fin si
rectangle_arrondi(ecran, x - 12, y + av * 12 - 6, 24, 12, 4, #1C2A3A)
rectangle_arrondi(ecran, x - 11, y - av * 14 - 4, 22, 8, 3, #1C2A3A)
// le toit
rectangle_arrondi(ecran, x - 11, y - 6 - av * 1, 22, 14, 4, coulF)
rectangle(ecran, x - 9, y - 4, 6, 2, rgba(255, 255, 255, 0.35))
// les phares a l'avant, les feux a l'arriere
cercle(ecran, x - 10, y + av * 27, 3, #FFF9C4)
cercle(ecran, x + 10, y + av * 27, 3, #FFF9C4)
rectangle(ecran, x - 13, y - av * 29 - 1, 7, 3, #B71C1C)
rectangle(ecran, x + 6, y - av * 29 - 1, 7, 3, #B71C1C)
fin procédure
procédure plot(x, y)
rectangle_arrondi(ecran, x - 16, y + 8, 32, 8, 3, #E65100)
polygone(ecran, [x - 12, y + 9, x + 12, y + 9, x + 3, y - 18, x - 3, y - 18], #FF6D00)
polygone(ecran, [x - 8, y - 1, x + 8, y - 1, x + 6, y - 6, x - 6, y - 6], #FAFAFA)
polygone(ecran, [x - 4, y - 12, x + 4, y - 12, x + 3, y - 15, x - 3, y - 15], #FAFAFA)
fin procédure
procédure piece(x, y)
l est un nombre
l vaut 11 * absolue(cosinus(radians(tic * 15)))
ellipse(ecran, x, y, maximum(2, l), 11, #F9A825)
ellipse(ecran, x, y, maximum(1, l * 0.7), 8, #FFD54F)
si l > 6 alors
rectangle(ecran, x - 1.5, y - 5, 3, 10, #F9A825)
fin si
fin procédure
procédure dessinerObjets()
ko est un nombre
pour ko de 0 à MAXO - 1
si oA[ko] alors
si oT[ko] = 1 alors
appelle plot(oX[ko], oY[ko])
sinon si oT[ko] = 2 alors
appelle voiture(oX[ko], oY[ko], coulVoiture[oC[ko]], coulVoitureF[oC[ko]], vrai)
// le clignotant, du cote ou elle va tourner
si oChg[ko] <> 0 et oY[ko] >= Y_CLIGNO et oY[ko] < Y_FIN_CHG + 20 et tic mod 6 < 3 alors
cx est un nombre
cx vaut oX[ko] + oChg[ko] * 17
cercle(ecran, cx, oY[ko] - 27, 8, rgba(255, 171, 0, 0.35))
cercle(ecran, cx, oY[ko] - 27, 4, #FFAB00)
cercle(ecran, cx, oY[ko] + 27, 8, rgba(255, 171, 0, 0.35))
cercle(ecran, cx, oY[ko] + 27, 4, #FFAB00)
fin si
sinon
appelle piece(oX[ko], oY[ko])
fin si
fin si
fin pour
fin procédure
procédure dessinerJoueur()
// la voiture clignote apres un choc
si invincible = 0 ou tic mod 4 < 2 alors
appelle voiture(joueurX, JOUEUR_Y, #E53935, #B71C1C, vrai)
si etat = 1 alors
// la fumee du pot d'echappement
cercle(ecran, joueurX - 8, JOUEUR_Y + 36 + (tic mod 3) * 3, 3 + (tic mod 3), rgba(255, 255, 255, 0.35))
fin si
fin si
// les petites fleches qui montrent ou aller
si etat = 1 et voie > 0 alors
polygone(ecran, [joueurX - 34, JOUEUR_Y, joueurX - 28, JOUEUR_Y - 6, joueurX - 28, JOUEUR_Y + 6], rgba(255, 255, 255, 0.7))
fin si
si etat = 1 et voie < 2 alors
polygone(ecran, [joueurX + 34, JOUEUR_Y, joueurX + 28, JOUEUR_Y - 6, joueurX + 28, JOUEUR_Y + 6], rgba(255, 255, 255, 0.7))
fin si
kp est un nombre
pour kp de 0 à MAXP - 1
si pA[kp] alors
cercle(ecran, pX[kp], pY[kp], 1.5 + pV[kp] * 0.2, pC[kp])
fin si
fin pour
fin procédure
@ DESSIN : L'INTERFACE
procédure coeur(x, y, plein)
coulC est un texte
coulC vaut #4E5468
si plein alors
coulC vaut #FF1744
fin si
cercle(ecran, x - 4, y - 2, 5, coulC)
cercle(ecran, x + 4, y - 2, 5, coulC)
polygone(ecran, [x - 9, y, x + 9, y, x, y + 10], coulC)
fin procédure
procédure dessinerInterface()
// le cadre lumineux
rectangle_arrondi(ecran, 4, 4, 312, 40, 10, #0D1B3E)
rectangle_arrondi(ecran, 4, 4, 312, 3, 2, #29B6F6)
appelle centrer("Score : " + convertir_texte(score), 160, 32, #FFEB3B, 20)
// le bouton pause
rectangle(ecran, 16, 15, 5, 18, #90CAF9)
rectangle(ecran, 26, 15, 5, 18, #90CAF9)
// les vies
kv est un nombre
pour kv de 0 à 2
appelle coeur(250 + kv * 22, 22, kv < vies)
fin pour
// les fleches en bas
rectangle_arrondi(ecran, 4, 404, 312, 42, 10, #0D1B3E)
rectangle_arrondi(ecran, 16, 409, 120, 32, 10, #1E3A70)
polygone(ecran, [56, 425, 74, 415, 74, 435], #E3F2FD)
rectangle(ecran, 74, 422, 22, 6, #E3F2FD)
rectangle_arrondi(ecran, 184, 409, 120, 32, 10, #1E3A70)
polygone(ecran, [264, 425, 246, 415, 246, 435], #E3F2FD)
rectangle(ecran, 224, 422, 22, 6, #E3F2FD)
appelle centrer(convertir_texte(arrondi(vitesse * 20)) + " km/h", 160, 430, #90CAF9, 11)
fin procédure
procédure voile()
rectangle(ecran, 0, 0, 320, 450, rgba(5, 10, 30, 0.7))
fin procédure
procédure ecranAccueil()
appelle voile()
rectangle_arrondi(ecran, 24, 52, 272, 344, 18, #0D1B3E)
rectangle_arrondi(ecran, 24, 52, 272, 4, 2, #29B6F6)
appelle centrer("Turbo Piste", 160, 100, #FFEB3B, 34)
appelle centrer("Évite tout, ramasse les pièces !", 160, 124, #90CAF9, 13)
appelle voiture(110, 172, #E53935, #B71C1C, vrai)
appelle plot(160, 180)
appelle piece(210, 172)
label(ecran, 46, 230, "Q / D : changer de voie", #E3F2FD, 13)
label(ecran, 46, 252, "ou les flèches en bas de l'écran", #E3F2FD, 13)
label(ecran, 46, 274, "Pièce : +5 points", #E3F2FD, 13)
label(ecran, 46, 296, "Gare aux clignotants !", #FFAB00, 13)
si record > 0 alors
appelle centrer("Record : " + convertir_texte(record), 160, 324, #FFD54F, 14)
fin si
appelle bouton(70, 338, 180, 44, "Démarrer", sialors(tic mod 16 < 8, #E53935, #FF5252), #FFFFFF, 20)
fin procédure
procédure ecranFin()
appelle voile()
rectangle_arrondi(ecran, 24, 70, 272, 300, 18, #0D1B3E)
rectangle_arrondi(ecran, 24, 70, 272, 4, 2, #FF5252)
appelle centrer("Course terminée !", 160, 118, #FF8A80, 24)
appelle centrer(convertir_texte(score), 160, 178, #FFEB3B, 44)
appelle centrer("points", 160, 200, #90CAF9, 13)
appelle centrer(convertir_texte(pieces) + " pièces · " + convertir_texte(arrondi(distance / 40)) + " m", 160, 232, #E3F2FD, 13)
si nouveauRecord alors
appelle centrer("Nouveau record !", 160, 266, #69F0AE, 18)
sinon
appelle centrer("Record : " + convertir_texte(record), 160, 266, #FFD54F, 14)
fin si
appelle bouton(70, 300, 180, 46, "Rejouer", #E53935, #FFFFFF, 20)
fin procédure
procédure dessiner()
effacer(ecran)
contour(ecran, #0)
appelle dessinerDecor()
appelle dessinerObjets()
appelle dessinerJoueur()
appelle dessinerInterface()
si etat = 0 alors
appelle ecranAccueil()
sinon si etat = 2 alors
appelle voile()
appelle centrer("Pause", 160, 210, #FFFFFF, 36)
appelle centrer("ESPACE ou clic pour repartir", 160, 242, #90CAF9, 13)
sinon si etat = 3 alors
appelle ecranFin()
fin si
fin procédure
@ LES COMMANDES
// actions : 0 clic, 1 Q, 2 D, 3 espace
procédure lireOrdre(act, x, y)
si etat = 0 ou etat = 3 alors
si act = 3 ou act = 0 alors
etat vaut 9
appelle nouvellePartie()
fin si
sinon si etat = 2 alors
si act = 3 ou act = 0 alors
etat vaut 1
fin si
sinon si etat = 1 alors
si act = 1 alors
appelle changerVoie(-1)
sinon si act = 2 alors
appelle changerVoie(1)
sinon si act = 3 alors
etat vaut 2
sinon si act = 0 alors
si y < 46 et x < 60 alors
etat vaut 2
sinon si x < 160 alors
appelle changerVoie(-1)
sinon
appelle changerVoie(1)
fin si
fin si
fin si
fin procédure
@ LE PROCESSUS
processus Course()
tant que appActif
tic vaut tic + 1
nbLus est un nombre
nbLus vaut 0
tant que teteO <> queueO et nbLus < 4
appelle lireOrdre(ordres[teteO], ordX[teteO], ordY[teteO])
teteO vaut (teteO + 1) mod 32
nbLus vaut nbLus + 1
fin tant que
si etat = 1 alors
appelle avancer()
fin si
appelle animerEffets()
si etat <> 9 alors
appelle dessiner()
affiche ecran
fin si
pause 60
fin tant que
effacer(ecran)
rectangle(ecran, 0, 0, 320, 450, #0D1B3E)
appelle centrer("À bientôt sur la piste !", 160, 230, #FFEB3B, 20)
affiche ecran
fin processus
@ DEMARRAGE
appelle nouvellePartie()
etat vaut 0
appelle dessiner()
affiche ecran
Course()
tant que appActif
interagir ecran, ["q", "d", " ", "x"] dans action, sourisX, sourisY
si action = 4 alors
appActif vaut faux
sinon si (queueO + 1) mod 32 <> teteO alors
ordres[queueO] vaut action
ordX[queueO] vaut sourisX
ordY[queueO] vaut sourisY
queueO vaut (queueO + 1) mod 32
fin si
fin tant que