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 520
dimension(ecran, LARG_E, HAUT_E)
// un losange de 64 par 32 pixels, et 22 pixels par etage de mur
DEMI_L est un nombre
DEMI_L vaut 32
DEMI_H est un nombre
DEMI_H vaut 16
ETAGE est un nombre
ETAGE vaut 22
PLAN_L est un nombre
PLAN_L vaut 72
PLAN_H est un nombre
PLAN_H vaut 72
VIT_JOUEUR est un nombre
VIT_JOUEUR vaut 3.6
RAYON est un nombre
RAYON vaut 0.32
PORTEE_ACTION est un nombre
PORTEE_ACTION vaut 1.7
// les personnages sont dessines au-dessus de leur case : la visee en tient compte
VISEE_HAUT est un nombre
VISEE_HAUT vaut 24
@ LES CASES
// 0 espace, 1 sol metal, 2 sol grille, 3 muret, 4 mur, 5 vitre, 6 sol energie,
// 7 porte verrouillee, 8 sol de porte, 9 sol serre, 10 sol fonderie,
// 11 sol archives, 12 teleporteur, 13 caisse, 14 terminal, 15 pilier,
// 16 sol reacteur, 17 barriere
SOLIDE est un tableau
SOLIDE vaut [1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1]
HAUTEUR est un tableau
HAUTEUR vaut [0, 0, 0, 1, 2, 2, 0, 2, 0, 0, 0, 0, 0, 1, 1, 3, 0, 2]
// la couleur du dessus, puis des faces gauche et droite
DESSUS est un tableau
DESSUS vaut [#0A0F1E, #2C3A52, #334259, #46587A, #4A5D80, #6FD3F2, #2A4C6E, #8A6A2E, #35465F, #2F5E45, #5C3A2A, #24405F, #3B2F6B, #7A5A2A, #2E4A6B, #3A4A66, #4A3A6B, #7A2E4E]
GAUCHE est un tableau
GAUCHE vaut [#060A14, #1C2638, #212C3E, #2C3850, #2E3C56, #3E8CA8, #1A3048, #5A451E, #212D3F, #1D3B2B, #3A241A, #16293D, #251D44, #4E3A1B, #1D3044, #252F42, #2F2545, #4E1E33]
DROITE est un tableau
DROITE vaut [#080C18, #243049, #2A364B, #394764, #3C4C69, #55AFCE, #223E5B, #6F5626, #2B3A50, #264D38, #4A2F22, #1D3450, #2F2557, #64491F, #263D59, #303E57, #3C2F59, #64253F]
// les traits lumineux sur certaines cases
NEON est un tableau
NEON vaut [#0A0F1E, #3E5E86, #4A6A93, #46587A, #4A5D80, #9BE8FF, #4FD8FF, #FFB020, #3E5E86, #58D08A, #FF8A3C, #58A8FF, #B07CFF, #FFC84A, #5ED8FF, #4A5D80, #C08AFF, #FF5A8A]
@ LA STATION
plan est un tableau
pour kc de 0 à PLAN_L * PLAN_H - 1
plan ajoute 0
fin pour
// les etoiles du fond
etoC, etoR, etoT est un tableau
pour kc de 0 à 59
etoC ajoute hasard(0, 719)
etoR ajoute hasard(0, 519)
etoT ajoute hasard(5, 18) / 10
fin pour
@ LE JOUEUR
posC, posR, viseC, viseR, regC, regR est un nombre
bouclier, bouclierMax, coque, coqueMax, energie, energieMax est un nombre
credits, xp, niveau, arme, degatsBonus est un nombre
armePrise est un tableau
armePrise vaut [1, 0, 0]
noyaux, cartes est un nombre
finTir, finEclair, finInvul, finTouche est un nombre
reculC, reculR est un nombre
// les 3 secteurs : carte trouvee, noyau pris
secteurCarte est un tableau
secteurCarte vaut [0, 0, 0]
secteurNoyau est un tableau
secteurNoyau vaut [0, 0, 0]
NOM_SECTEUR est un tableau
NOM_SECTEUR vaut ["Serre", "Fonderie", "Archives"]
@ LES ARMES
NOM_ARME est un tableau
NOM_ARME vaut ["Blaster", "Disperseur", "Rail"]
CADENCE est un tableau
CADENCE vaut [230, 620, 820]
DEGATS_ARME est un tableau
DEGATS_ARME vaut [3, 3, 11]
COUT_ENERGIE est un tableau
COUT_ENERGIE vaut [6, 16, 26]
VIT_TIR est un tableau
VIT_TIR vaut [15, 12, 24]
PORTEE_TIR est un tableau
PORTEE_TIR vaut [0.75, 0.42, 1.25]
@ LES ENNEMIS
// 0 drone, 1 tourelle, 2 sentinelle, 3 rodeur, 4 gardien
ENN_VIE est un tableau
ENN_VIE vaut [6, 10, 14, 18, 150]
ENN_VIT est un tableau
ENN_VIT vaut [2.6, 0, 1.7, 3.2, 1.3]
ENN_RAYON est un tableau
ENN_RAYON vaut [0.34, 0.42, 0.40, 0.44, 0.85]
ENN_XP est un tableau
ENN_XP vaut [8, 14, 18, 24, 300]
ENN_CREDIT est un tableau
ENN_CREDIT vaut [4, 7, 9, 12, 120]
// 0 contact, 1 tir
ENN_TYPE est un tableau
ENN_TYPE vaut [0, 1, 1, 0, 1]
ENN_VUE est un tableau
ENN_VUE vaut [9, 11, 10, 11, 14]
ENN_DEGATS est un tableau
ENN_DEGATS vaut [6, 7, 8, 11, 14]
NOM_ENN est un tableau
NOM_ENN vaut ["Drone", "Tourelle", "Sentinelle", "Rôdeur", "Gardien"]
ennC, ennR, ennGenre, ennVie, ennEtat est un tableau
ennDC, ennDR, ennMinuteur, ennGele, ennRecharge est un tableau
pour kc de 0 à 59
ennC ajoute 0
ennR ajoute 0
ennGenre ajoute 0
ennVie ajoute 0
ennEtat ajoute 0
ennDC ajoute 0
ennDR ajoute 0
ennMinuteur ajoute 0
ennGele ajoute 0
ennRecharge ajoute 0
fin pour
nbEnnemis est un nombre
@ LES TIRS
// tirQui : 0 le joueur, 1 un ennemi
tirC, tirR, tirDC, tirDR, tirVie, tirActif, tirQui, tirDeg, tirGenre est un tableau
pour kc de 0 à 59
tirC ajoute 0
tirR ajoute 0
tirDC ajoute 0
tirDR ajoute 0
tirVie ajoute 0
tirActif ajoute 0
tirQui ajoute 0
tirDeg ajoute 0
tirGenre ajoute 0
fin pour
@ LES OBJETS
// les caisses et les bornes sont des cases ; voici les objets a ramasser
// 0 credits, 1 energie, 2 bouclier
objC, objR, objGenre, objActif est un tableau
pour kc de 0 à 39
objC ajoute 0
objR ajoute 0
objGenre ajoute 0
objActif ajoute 0
fin pour
// les points d'interet : 0 noyau, 1 carte d'acces, 2 terminal, 3 atelier,
// 4 porte de secteur, 5 teleporteur, 6 coeur du reacteur
ptC, ptR, ptGenre, ptEtat, ptSecteur est un tableau
pour kc de 0 à 23
ptC ajoute 0
ptR ajoute 0
ptGenre ajoute 0
ptEtat ajoute 0
ptSecteur ajoute 0
fin pour
nbPoints est un nombre
@ LES PARTICULES
parX, parY, parVX, parVY, parVie, parGenre est un tableau
pour kc de 0 à 39
parX ajoute 0
parY ajoute 0
parVX ajoute 0
parVY ajoute 0
parVie ajoute 0
parGenre ajoute 0
fin pour
suivantePar est un nombre
@ LA PARTIE
// etat : 0 accueil, 1 jeu, 2 dialogue, 3 carte, 4 atelier, 5 objectifs,
// 6 perdu, 7 victoire
etat est un nombre
etat vaut 0
appActif est un booléen
appActif vaut vrai
dernierTemps, tic, tempsJeu, camX, camY, camBX, camBY, secousse est un nombre
msgTxt est un texte
msgFin est un nombre
dlgNom, dlgL1, dlgL2 est un texte
record est un nombre
essayer
record vaut parametre('helion', 'noyaux')
attraper
record vaut 0
fin essayer
sourisXC, sourisYC est un nombre
appuye, etaitAppuye, clicSouris, vuAppuye est un booléen
dronesAbattus, caissesOuvertes, primeDrones, primeCaisses est un nombre
alerte 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
procédure annoncer(txt)
msgTxt vaut txt
msgFin vaut chrono() + 3000
fin procédure
fonction ecrX(c, r)
retourne (c - r) * DEMI_L - camX + LARG_E / 2
fin fonction
fonction ecrY(c, r)
retourne (c + r) * DEMI_H - camY + HAUT_E / 2
fin fonction
fonction caseEn(c, r)
si c < 0 ou c >= PLAN_L ou r < 0 ou r >= PLAN_H alors
retourne 0
fin si
retourne plan[c * PLAN_H + r]
fin fonction
procédure poser(c, r, t)
si c >= 0 et c < PLAN_L et r >= 0 et r < PLAN_H alors
plan[c * PLAN_H + r] vaut t
fin si
fin procédure
fonction murEn(c, r)
si SOLIDE[caseEn(arrondi_inferieur(c), arrondi_inferieur(r))] = 1 alors
retourne vrai
fin si
retourne faux
fin fonction
// un disque de rayon s touche-t-il un mur ?
fonction bloque(c, r, s)
si murEn(c - s, r - s) ou murEn(c + s, r - s) alors
retourne vrai
fin si
si murEn(c - s, r + s) ou murEn(c + s, r + s) alors
retourne vrai
fin si
retourne faux
fin fonction
fonction ecart(c1, r1, c2, r2)
retourne hypotenuse(c2 - c1, r2 - r1)
fin fonction
procédure emettre(x, y, vx, vy, genre)
parX[suivantePar] vaut x
parY[suivantePar] vaut y
parVX[suivantePar] vaut vx
parVY[suivantePar] vaut vy
parVie[suivantePar] vaut 1
parGenre[suivantePar] vaut genre
suivantePar vaut (suivantePar + 1) mod 40
fin procédure
procédure remplirZone(c1, r1, c2, r2, t)
c, r est un nombre
pour c de c1 à c2
pour r de r1 à r2
appelle poser(c, r, t)
fin pour
fin pour
fin procédure
procédure cadre(c1, r1, c2, r2, t)
c, r est un nombre
pour c de c1 à c2
appelle poser(c, r1, t)
appelle poser(c, r2, t)
fin pour
pour r de r1 à r2
appelle poser(c1, r, t)
appelle poser(c2, r, t)
fin pour
fin procédure
// un couloir en L, large de 3 cases
procédure couloir(c1, r1, c2, r2, sol)
c, r, depuis, jusque est un nombre
depuis vaut minimum(c1, c2)
jusque vaut maximum(c1, c2)
pour c de depuis à jusque
pour r de r1 - 1 à r1 + 1
appelle poser(c, r, sol)
fin pour
fin pour
depuis vaut minimum(r1, r2)
jusque vaut maximum(r1, r2)
pour r de depuis à jusque
pour c de c2 - 1 à c2 + 1
appelle poser(c, r, sol)
fin pour
fin pour
fin procédure
// une salle : du sol, des murs autour, et une ouverture par cote demande
procédure salle(c1, r1, c2, r2, sol)
appelle remplirZone(c1, r1, c2, r2, sol)
appelle cadre(c1, r1, c2, r2, 4)
fin procédure
@ LA CREATION DE LA STATION
// la destination de chaque pastille de teleportation du noyau central
DEST_C est un tableau
DEST_C vaut [55, 37, 17, 37]
DEST_R est un tableau
DEST_R vaut [37, 55, 37, 24]
NOM_DEST est un tableau
NOM_DEST vaut ["Serre", "Fonderie", "Archives", "Réacteur"]
procédure placerEnnemi(c, r, genre)
si nbEnnemis <= 59 et SOLIDE[caseEn(c, r)] = 0 alors
ennC[nbEnnemis] vaut c + 0.5
ennR[nbEnnemis] vaut r + 0.5
ennGenre[nbEnnemis] vaut genre
ennVie[nbEnnemis] vaut ENN_VIE[genre]
ennEtat[nbEnnemis] vaut 1
ennDC[nbEnnemis] vaut 0
ennDR[nbEnnemis] vaut 1
ennMinuteur[nbEnnemis] vaut 0
ennGele[nbEnnemis] vaut 0
ennRecharge[nbEnnemis] vaut hasard(50, 150) / 100
nbEnnemis vaut nbEnnemis + 1
fin si
fin procédure
procédure placerPoint(c, r, genre, sect)
si nbPoints <= 23 alors
ptC[nbPoints] vaut c
ptR[nbPoints] vaut r
ptGenre[nbPoints] vaut genre
ptEtat[nbPoints] vaut 0
ptSecteur[nbPoints] vaut sect
nbPoints vaut nbPoints + 1
fin si
fin procédure
// quelques caisses, jamais sur un point d'interet ni juste a cote
procédure semerCaisses(c1, r1, c2, r2, nb)
k, j, c, r est un nombre
libre est un booléen
pour k de 1 à nb
c vaut hasard(c1, c2)
r vaut hasard(r1, r2)
libre vaut faux
si SOLIDE[caseEn(c, r)] = 0 alors
libre vaut vrai
fin si
pour j de 0 à nbPoints - 1
si absolue(ptC[j] - c) <= 1 et absolue(ptR[j] - r) <= 1 alors
libre vaut faux
fin si
fin pour
si libre alors
appelle poser(c, r, 13)
fin si
fin pour
fin procédure
procédure creerStation()
c, r, k est un nombre
pour c de 0 à PLAN_L - 1
pour r de 0 à PLAN_H - 1
appelle poser(c, r, 0)
fin pour
fin pour
// le noyau central
appelle salle(29, 29, 45, 45, 1)
appelle remplirZone(36, 30, 38, 44, 6)
appelle remplirZone(30, 36, 44, 38, 6)
appelle poser(32, 32, 15)
appelle poser(42, 32, 15)
appelle poser(32, 42, 15)
appelle poser(42, 42, 15)
appelle poser(34, 31, 14)
appelle poser(40, 40, 14)
// les quatre pastilles de teleportation
appelle poser(31, 31, 12)
appelle poser(43, 31, 12)
appelle poser(31, 43, 12)
appelle poser(43, 43, 12)
appelle placerPoint(31, 31, 5, 0)
appelle placerPoint(43, 31, 5, 1)
appelle placerPoint(31, 43, 5, 2)
appelle placerPoint(43, 43, 5, 3)
appelle placerPoint(34, 31, 3, 0)
appelle placerPoint(40, 40, 2, 9)
// les quatre secteurs
appelle salle(50, 26, 69, 48, 9)
appelle salle(26, 50, 48, 69, 10)
appelle salle(2, 26, 21, 48, 11)
appelle salle(28, 3, 46, 21, 16)
// les couloirs qui relient tout
appelle couloir(45, 37, 51, 37, 2)
appelle couloir(37, 45, 37, 51, 2)
appelle couloir(29, 37, 21, 37, 2)
appelle couloir(37, 29, 37, 21, 2)
// la barriere d'energie devant le reacteur
pour c de 36 à 38
appelle poser(c, 23, 17)
fin pour
// --- la Serre : vegetation et chambre forte a l'est ---
pour k de 0 à 14
appelle poser(53 + (k mod 5) * 4, 29 + arrondi_inferieur(k / 5) * 6, 15)
fin pour
appelle remplirZone(57, 40, 63, 46, 6)
appelle salle(63, 30, 68, 36, 9)
appelle poser(63, 33, 7)
appelle placerPoint(63, 33, 4, 0)
appelle placerPoint(66, 33, 0, 0)
appelle placerPoint(55, 45, 1, 0)
appelle placerPoint(52, 28, 2, 0)
appelle poser(52, 28, 14)
appelle semerCaisses(51, 27, 68, 47, 7)
// --- la Fonderie : cuves et chambre forte au sud ---
pour k de 0 à 11
appelle poser(29 + (k mod 4) * 5, 53 + arrondi_inferieur(k / 4) * 5, 15)
fin pour
appelle remplirZone(38, 56, 46, 62, 6)
appelle salle(29, 62, 35, 68, 10)
appelle poser(32, 62, 7)
appelle placerPoint(32, 62, 4, 1)
appelle placerPoint(32, 65, 0, 1)
appelle placerPoint(45, 66, 1, 1)
appelle placerPoint(28, 52, 2, 1)
appelle poser(28, 52, 14)
appelle semerCaisses(27, 51, 47, 68, 7)
// --- les Archives : rayonnages et chambre forte a l'ouest ---
pour k de 0 à 17
appelle poser(5 + (k mod 6) * 3, 30 + arrondi_inferieur(k / 6) * 6, 3)
fin pour
appelle remplirZone(8, 40, 16, 44, 6)
appelle salle(3, 30, 9, 36, 11)
appelle poser(9, 33, 7)
appelle placerPoint(9, 33, 4, 2)
appelle placerPoint(5, 33, 0, 2)
appelle placerPoint(17, 45, 1, 2)
appelle placerPoint(19, 28, 2, 2)
appelle poser(19, 28, 14)
appelle semerCaisses(3, 27, 20, 47, 7)
// --- le Reacteur ---
appelle remplirZone(34, 6, 40, 12, 6)
appelle poser(31, 6, 15)
appelle poser(43, 6, 15)
appelle poser(31, 18, 15)
appelle poser(43, 18, 15)
appelle placerPoint(37, 8, 6, 3)
// --- les ennemis ---
pour k de 0 à 5
appelle placerEnnemi(52 + k * 3, 31 + (k mod 3) * 5, 0)
appelle placerEnnemi(5 + k * 3, 31 + (k mod 3) * 5, 0)
fin pour
pour k de 0 à 2
appelle placerEnnemi(55 + k * 4, 42 + k, 2)
appelle placerEnnemi(31 + k * 5, 55 + k * 3, 3)
appelle placerEnnemi(40 + k * 2, 64 - k * 3, 2)
appelle placerEnnemi(7 + k * 4, 43 - k, 2)
fin pour
appelle placerEnnemi(66, 28, 1)
appelle placerEnnemi(66, 46, 1)
appelle placerEnnemi(61, 32, 1)
appelle placerEnnemi(28, 67, 1)
appelle placerEnnemi(46, 53, 1)
appelle placerEnnemi(33, 66, 1)
appelle placerEnnemi(4, 46, 1)
appelle placerEnnemi(19, 32, 1)
appelle placerEnnemi(6, 34, 1)
appelle placerEnnemi(44, 55, 3)
appelle placerEnnemi(30, 60, 3)
appelle placerEnnemi(47, 68, 3)
// les couloirs
appelle placerEnnemi(48, 37, 0)
appelle placerEnnemi(24, 37, 0)
appelle placerEnnemi(37, 48, 0)
// le reacteur
pour k de 0 à 3
appelle placerEnnemi(31 + k * 4, 16 - k * 2, 2)
fin pour
appelle placerEnnemi(37, 11, 4)
fin procédure
procédure nouvellePartie()
k est un nombre
nbEnnemis vaut 0
nbPoints vaut 0
appelle creerStation()
posC vaut 37.5
posR vaut 40.5
regC vaut 0
regR vaut -1
viseC vaut posC
viseR vaut posR - 3
bouclierMax vaut 40
bouclier vaut 40
coqueMax vaut 6
coque vaut 6
energieMax vaut 100
energie vaut 100
credits vaut 0
xp vaut 0
niveau vaut 1
arme vaut 0
degatsBonus vaut 0
armePrise[0] vaut 1
armePrise[1] vaut 0
armePrise[2] vaut 0
noyaux vaut 0
cartes vaut 0
dronesAbattus vaut 0
caissesOuvertes vaut 0
primeDrones vaut 0
primeCaisses vaut 0
alerte vaut 0
finTir vaut 0
finEclair vaut 0
finInvul vaut 0
finTouche vaut 0
reculC vaut 0
reculR vaut 0
tempsJeu vaut 0
msgFin vaut 0
secousse vaut 0
pour k de 0 à 2
secteurCarte[k] vaut 0
secteurNoyau[k] vaut 0
fin pour
pour k de 0 à 59
tirActif[k] vaut 0
fin pour
pour k de 0 à 39
objActif[k] vaut 0
parVie[k] vaut 0
fin pour
camBX vaut (posC - posR) * DEMI_L
camBY vaut (posC + posR) * DEMI_H
camX vaut camBX
camY vaut camBY
etat vaut 1
fin procédure
@ L'EXPERIENCE
SEUIL_XP est un tableau
SEUIL_XP vaut [0, 70, 170, 320, 520, 800, 1200]
procédure gagnerXp(gain)
xp vaut xp + gain
si niveau < 6 alors
si xp >= SEUIL_XP[niveau] alors
niveau vaut niveau + 1
bouclierMax vaut bouclierMax + 14
bouclier vaut bouclierMax
energieMax vaut energieMax + 10
energie vaut energieMax
si (niveau mod 2) = 0 alors
degatsBonus vaut degatsBonus + 1
fin si
appelle annoncer("Niveau " + convertir_texte(niveau) + " : bouclier et énergie renforcés !")
fin si
fin si
fin procédure
@ LES OBJETS AU SOL
procédure lacherObjet(c, r, genre)
k, libre est un nombre
libre vaut -1
pour k de 0 à 39
si objActif[k] = 0 alors
libre vaut k
fin si
fin pour
si libre >= 0 alors
objC[libre] vaut c
objR[libre] vaut r
objGenre[libre] vaut genre
objActif[libre] vaut 1
fin si
fin procédure
procédure ramasserObjets()
k est un nombre
pour k de 0 à 39
si objActif[k] = 1 alors
si ecart(objC[k], objR[k], posC, posR) < 0.8 alors
objActif[k] vaut 0
si objGenre[k] = 0 alors
credits vaut credits + 6
sinon si objGenre[k] = 1 alors
energie vaut minimum(energieMax, energie + 30)
sinon
bouclier vaut minimum(bouclierMax, bouclier + 20)
fin si
fin si
fin si
fin pour
fin procédure
@ LE COMBAT
procédure blesserJoueur(deg, dc, dr)
si chrono() >= finInvul alors
finTouche vaut chrono()
secousse vaut 1
si bouclier > 0 alors
bouclier vaut maximum(0, bouclier - deg)
finInvul vaut chrono() + 260
sinon
coque vaut coque - 1
finInvul vaut chrono() + 900
reculC vaut dc
reculR vaut dr
si coque <= 0 alors
etat vaut 6
fin si
fin si
fin si
fin procédure
procédure tuerEnnemi(k)
genre est un nombre
genre vaut ennGenre[k]
ennEtat[k] vaut 0
credits vaut credits + ENN_CREDIT[genre]
appelle gagnerXp(ENN_XP[genre])
si genre = 0 alors
dronesAbattus vaut dronesAbattus + 1
fin si
si genre = 4 alors
etat vaut 7
fin si
si (k mod 3) = 0 alors
appelle lacherObjet(ennC[k], ennR[k], 1)
sinon si (k mod 5) = 0 alors
appelle lacherObjet(ennC[k], ennR[k], 2)
fin si
fin procédure
procédure creerTir(c, r, dc, dr, qui, deg, genre, vit, duree)
k, libre est un nombre
libre vaut -1
pour k de 0 à 59
si tirActif[k] = 0 alors
libre vaut k
fin si
fin pour
si libre >= 0 alors
tirC[libre] vaut c
tirR[libre] vaut r
tirDC[libre] vaut dc * vit
tirDR[libre] vaut dr * vit
tirVie[libre] vaut duree
tirActif[libre] vaut 1
tirQui[libre] vaut qui
tirDeg[libre] vaut deg
tirGenre[libre] vaut genre
fin si
fin procédure
procédure tirer()
deg, ecartT est un nombre
si chrono() >= finTir et energie >= COUT_ENERGIE[arme] alors
finTir vaut chrono() + CADENCE[arme]
finEclair vaut chrono() + 90
energie vaut energie - COUT_ENERGIE[arme]
deg vaut DEGATS_ARME[arme] + degatsBonus
si arme = 1 alors
// le disperseur envoie trois projectiles en eventail
appelle creerTir(posC + regC * 0.5, posR + regR * 0.5, regC, regR, 0, deg, 1, VIT_TIR[1], PORTEE_TIR[1])
ecartT vaut 0.26
appelle creerTir(posC + regC * 0.5, posR + regR * 0.5, regC - regR * ecartT, regR + regC * ecartT, 0, deg, 1, VIT_TIR[1], PORTEE_TIR[1])
appelle creerTir(posC + regC * 0.5, posR + regR * 0.5, regC + regR * ecartT, regR - regC * ecartT, 0, deg, 1, VIT_TIR[1], PORTEE_TIR[1])
sinon
appelle creerTir(posC + regC * 0.5, posR + regR * 0.5, regC, regR, 0, deg, arme, VIT_TIR[arme], PORTEE_TIR[arme])
fin si
reculC vaut reculC - regC * 0.5
reculR vaut reculR - regR * 0.5
appelle emettre(ecrX(posC, posR) + regC * 14, ecrY(posC, posR) - 18, hasard(-30, 30), -40, 0)
fin si
fin procédure
// un tir d'ennemi, dirige vers le joueur
procédure tirerEnnemi(k)
d, dc, dr est un nombre
d vaut ecart(ennC[k], ennR[k], posC, posR)
si d > 0.2 alors
dc vaut (posC - ennC[k]) / d
dr vaut (posR - ennR[k]) / d
appelle creerTir(ennC[k] + dc * 0.5, ennR[k] + dr * 0.5, dc, dr, 1, ENN_DEGATS[ennGenre[k]], 3, 9, 1.3)
fin si
fin procédure
procédure casserCaisse(c, r)
caissesOuvertes vaut caissesOuvertes + 1
appelle poser(c, r, 1)
credits vaut credits + hasard(8, 18)
si (c + r) mod 3 = 0 alors
appelle lacherObjet(c + 0.5, r + 0.5, 1)
sinon si (c + r) mod 4 = 0 alors
appelle lacherObjet(c + 0.5, r + 0.5, 2)
fin si
fin procédure
// les tirs avancent en deux demi-pas pour ne rien traverser
procédure majTirs(dt)
k, j, ip, demi, nc, nr, d, x, y est un nombre
touche est un booléen
pour k de 0 à 59
si tirActif[k] = 1 alors
pour demi de 0 à 1
si tirActif[k] = 1 alors
touche vaut faux
nc vaut tirC[k] + tirDC[k] * dt / 2
nr vaut tirR[k] + tirDR[k] * dt / 2
si tirQui[k] = 0 alors
pour j de 0 à nbEnnemis - 1
si ennEtat[j] = 1 et non touche alors
si ecart(ennC[j], ennR[j], nc, nr) < ENN_RAYON[ennGenre[j]] + 0.3 alors
touche vaut vrai
ennVie[j] vaut ennVie[j] - tirDeg[k]
ennGele[j] vaut 0.22
x vaut ecrX(nc, nr)
y vaut ecrY(nc, nr) - 14
pour ip de 0 à 3
appelle emettre(x, y, hasard(-130, 130), hasard(-150, -20), 1)
fin pour
si ennVie[j] <= 0 alors
appelle tuerEnnemi(j)
fin si
fin si
fin si
fin pour
sinon
si ecart(posC, posR, nc, nr) < RAYON + 0.2 et chrono() >= finInvul alors
touche vaut vrai
appelle blesserJoueur(tirDeg[k], tirDC[k] / 20, tirDR[k] / 20)
fin si
fin si
si non touche alors
si caseEn(arrondi_inferieur(nc), arrondi_inferieur(nr)) = 13 et tirQui[k] = 0 alors
appelle casserCaisse(arrondi_inferieur(nc), arrondi_inferieur(nr))
touche vaut vrai
sinon si murEn(nc, nr) alors
touche vaut vrai
fin si
si touche alors
x vaut ecrX(nc, nr)
y vaut ecrY(nc, nr) - 12
pour j de 0 à 2
appelle emettre(x, y, hasard(-90, 90), hasard(-110, -10), 1)
fin pour
fin si
fin si
si touche alors
tirActif[k] vaut 0
sinon
tirC[k] vaut nc
tirR[k] vaut nr
fin si
fin si
fin pour
tirVie[k] vaut tirVie[k] - dt
si tirVie[k] <= 0 alors
tirActif[k] vaut 0
fin si
fin si
fin pour
fin procédure
@ LES DEPLACEMENTS
procédure bougerJoueur(dt)
dc, dr, lg, nc, nr, mx, my est un nombre
dc vaut 0
dr vaut 0
si touche_enfoncée('droite') ou touche_enfoncée('d') alors
dc vaut dc + 1
dr vaut dr - 1
fin si
si touche_enfoncée('gauche') ou touche_enfoncée('q') alors
dc vaut dc - 1
dr vaut dr + 1
fin si
si touche_enfoncée('haut') ou touche_enfoncée('z') alors
dc vaut dc - 1
dr vaut dr - 1
fin si
si touche_enfoncée('bas') ou touche_enfoncée('s') alors
dc vaut dc + 1
dr vaut dr + 1
fin si
si dc <> 0 ou dr <> 0 alors
lg vaut hypotenuse(dc, dr)
dc vaut dc / lg
dr vaut dr / lg
regC vaut dc
regR vaut dr
fin si
// la visee suit la souris
si sourisXC >= 0 et sourisYC >= 0 alors
mx vaut sourisXC - LARG_E / 2 + camX
my vaut sourisYC - HAUT_E / 2 + camY + VISEE_HAUT
viseC vaut mx / (DEMI_L * 2) + my / (DEMI_H * 2)
viseR vaut my / (DEMI_H * 2) - mx / (DEMI_L * 2)
lg vaut ecart(posC, posR, viseC, viseR)
si lg > 0.25 alors
regC vaut (viseC - posC) / lg
regR vaut (viseR - posR) / lg
fin si
fin si
nc vaut posC + dc * VIT_JOUEUR * dt + reculC * 4 * dt
si non bloque(nc, posR, RAYON) alors
posC vaut nc
fin si
nr vaut posR + dr * VIT_JOUEUR * dt + reculR * 4 * dt
si non bloque(posC, nr, RAYON) alors
posR vaut nr
fin si
reculC vaut reculC * 0.86
reculR vaut reculR * 0.86
// l'energie et le bouclier se rechargent
energie vaut minimum(energieMax, energie + 22 * dt)
si chrono() - finTouche > 3500 alors
bouclier vaut minimum(bouclierMax, bouclier + 11 * dt)
fin si
// la camera suit en douceur
camBX vaut camBX + ((posC - posR) * DEMI_L - camBX) * minimum(1, dt * 8)
camBY vaut camBY + ((posC + posR) * DEMI_H - camBY) * minimum(1, dt * 8)
camX vaut camBX + hasard(-100, 100) / 100 * secousse * 6
camY vaut camBY + hasard(-100, 100) / 100 * secousse * 6
si secousse > 0 alors
secousse vaut maximum(0, secousse - dt * 3)
fin si
si dc <> 0 ou dr <> 0 alors
si tic mod 9 = 0 alors
appelle emettre(ecrX(posC, posR), ecrY(posC, posR) + 2, hasard(-20, 20), -20, 0)
fin si
fin si
fin procédure
procédure bougerEnnemis(dt)
k, d, s, nc, nr, vit, genre est un nombre
pour k de 0 à nbEnnemis - 1
si ennEtat[k] = 1 alors
genre vaut ennGenre[k]
s vaut ENN_RAYON[genre]
vit vaut ENN_VIT[genre]
d vaut ecart(ennC[k], ennR[k], posC, posR)
si ennGele[k] > 0 alors
ennGele[k] vaut ennGele[k] - dt
fin si
si d < ENN_VUE[genre] alors
si alerte < 1 alors
alerte vaut 1
fin si
si d > 0.3 alors
ennDC[k] vaut (posC - ennC[k]) / d
ennDR[k] vaut (posR - ennR[k]) / d
fin si
// les tireurs gardent leurs distances
si ENN_TYPE[genre] = 1 alors
ennRecharge[k] vaut ennRecharge[k] - dt
si ennRecharge[k] <= 0 alors
ennRecharge[k] vaut 1.3 + hasard(0, 90) / 100
appelle tirerEnnemi(k)
fin si
si d < 4 alors
ennDC[k] vaut 0 - ennDC[k]
ennDR[k] vaut 0 - ennDR[k]
fin si
fin si
sinon
ennMinuteur[k] vaut ennMinuteur[k] - dt
si ennMinuteur[k] <= 0 alors
ennMinuteur[k] vaut 1.4 + hasard(0, 180) / 100
ennDC[k] vaut hasard(-100, 100) / 100
ennDR[k] vaut hasard(-100, 100) / 100
fin si
vit vaut vit * 0.45
fin si
si vit > 0 alors
nc vaut ennC[k] + ennDC[k] * vit * dt
si non bloque(nc, ennR[k], s) alors
ennC[k] vaut nc
sinon
ennDC[k] vaut 0 - ennDC[k]
ennMinuteur[k] vaut 0.4
fin si
nr vaut ennR[k] + ennDR[k] * vit * dt
si non bloque(ennC[k], nr, s) alors
ennR[k] vaut nr
sinon
ennDR[k] vaut 0 - ennDR[k]
ennMinuteur[k] vaut 0.4
fin si
fin si
// le contact avec le joueur
si ENN_TYPE[genre] = 0 alors
si ecart(ennC[k], ennR[k], posC, posR) < s + RAYON + 0.1 alors
appelle blesserJoueur(ENN_DEGATS[genre], (posC - ennC[k]) * 2, (posR - ennR[k]) * 2)
fin si
fin si
fin si
fin pour
fin procédure
@ LES INTERACTIONS
procédure parlerTerminal(sect)
dlgNom vaut "Terminal de la station"
si sect = 9 alors
dlgNom vaut "Terminal d'accueil"
dlgL1 vaut "Bienvenue sur Hélion. Trois secteurs, trois noyaux d'énergie."
dlgL2 vaut "Rapporte-les et la barrière du Réacteur tombera."
sinon si sect = 0 alors
dlgL1 vaut "Secteur Serre : la chambre forte est tout à l'est."
dlgL2 vaut "Sa carte d'accès est restée au sud, près des cuves."
sinon si sect = 1 alors
dlgL1 vaut "Secteur Fonderie : la chambre forte est au sud-ouest."
dlgL2 vaut "La carte d'accès a été emportée vers l'angle sud-est."
sinon
dlgL1 vaut "Secteur Archives : la chambre forte est au nord-ouest."
dlgL2 vaut "La carte d'accès a glissé au sud-est des rayonnages."
fin si
etat vaut 2
fin procédure
procédure prendreNoyau(k)
sect est un nombre
sect vaut ptSecteur[k]
ptEtat[k] vaut 1
secteurNoyau[sect] vaut 1
noyaux vaut noyaux + 1
appelle gagnerXp(90)
si noyaux > record alors
record vaut noyaux
essayer
parametre('helion', 'noyaux', record)
attraper
tic vaut tic
fin essayer
fin si
si noyaux >= 3 alors
appelle poser(36, 23, 2)
appelle poser(37, 23, 2)
appelle poser(38, 23, 2)
appelle annoncer("Trois noyaux ! La barrière du Réacteur vient de tomber.")
sinon
appelle annoncer("Noyau de " + NOM_SECTEUR[sect] + " récupéré (" + convertir_texte(noyaux) + " sur 3).")
fin si
fin procédure
procédure ouvrirPorte(k)
sect est un nombre
sect vaut ptSecteur[k]
si secteurCarte[sect] = 1 alors
appelle poser(ptC[k], ptR[k], 8)
ptEtat[k] vaut 1
appelle annoncer("Carte acceptée : la chambre forte s'ouvre.")
sinon
appelle annoncer("Chambre forte verrouillée. Trouve la carte d'accès de " + NOM_SECTEUR[sect] + ".")
fin si
fin procédure
procédure agir()
k, genre, sect est un nombre
fait est un booléen
fait vaut faux
pour k de 0 à nbPoints - 1
si non fait alors
si ecart(ptC[k] + 0.5, ptR[k] + 0.5, posC, posR) < PORTEE_ACTION alors
genre vaut ptGenre[k]
sect vaut ptSecteur[k]
si genre = 0 et ptEtat[k] = 0 alors
appelle prendreNoyau(k)
fait vaut vrai
sinon si genre = 1 et ptEtat[k] = 0 alors
ptEtat[k] vaut 1
secteurCarte[sect] vaut 1
cartes vaut cartes + 1
appelle annoncer("Carte d'accès de " + NOM_SECTEUR[sect] + " récupérée.")
fait vaut vrai
sinon si genre = 2 alors
appelle parlerTerminal(sect)
fait vaut vrai
sinon si genre = 3 alors
etat vaut 4
fait vaut vrai
sinon si genre = 4 et ptEtat[k] = 0 alors
appelle ouvrirPorte(k)
fait vaut vrai
sinon si genre = 5 alors
posC vaut DEST_C[sect] + 0.5
posR vaut DEST_R[sect] + 0.5
camBX vaut (posC - posR) * DEMI_L
camBY vaut (posC + posR) * DEMI_H
appelle annoncer("Téléportation : " + NOM_DEST[sect])
fait vaut vrai
sinon si genre = 6 alors
dlgNom vaut "Coeur du Réacteur"
dlgL1 vaut "Le coeur bat encore. Le Gardien veille juste à côté."
dlgL2 vaut "Abats-le et la station sera de nouveau à nous."
etat vaut 2
fait vaut vrai
fin si
fin si
fin si
fin pour
si non fait alors
appelle annoncer("Rien à activer ici.")
fin si
fin procédure
@ L'ATELIER
NOM_ACHAT est un tableau
NOM_ACHAT vaut ["Réparer la coque", "Disperseur", "Rail magnétique", "Bouclier renforcé", "Surcharge de tir"]
DETAIL_ACHAT est un tableau
DETAIL_ACHAT vaut ["Remet la coque au maximum", "Tir en éventail, parfait de près", "Tir lourd et très rapide", "+ 25 de bouclier maximum", "+ 2 de dégâts sur toutes les armes"]
PRIX_ACHAT est un tableau
PRIX_ACHAT vaut [45, 130, 240, 170, 210]
fonction achatPossible(k)
ok est un booléen
ok vaut faux
si credits >= PRIX_ACHAT[k] alors
ok vaut vrai
si k = 1 et armePrise[1] = 1 alors
ok vaut faux
fin si
si k = 2 et armePrise[2] = 1 alors
ok vaut faux
fin si
si k = 0 et coque >= coqueMax alors
ok vaut faux
fin si
fin si
retourne ok
fin fonction
procédure acheter(k)
si non achatPossible(k) alors
appelle annoncer("Impossible : crédits insuffisants ou déjà obtenu.")
sinon
credits vaut credits - PRIX_ACHAT[k]
si k = 0 alors
coque vaut coqueMax
appelle annoncer("Coque réparée.")
sinon si k = 1 alors
armePrise[1] vaut 1
arme vaut 1
appelle annoncer("Disperseur installé : touche 2.")
sinon si k = 2 alors
armePrise[2] vaut 1
arme vaut 2
appelle annoncer("Rail magnétique installé : touche 3.")
sinon si k = 3 alors
bouclierMax vaut bouclierMax + 25
bouclier vaut bouclierMax
appelle annoncer("Bouclier renforcé.")
sinon
degatsBonus vaut degatsBonus + 2
appelle annoncer("Surcharge : tes tirs font plus mal.")
fin si
fin si
fin procédure
procédure majPrimes()
si primeDrones = 0 et dronesAbattus >= 12 alors
primeDrones vaut 1
credits vaut credits + 150
appelle annoncer("Contrat rempli : 12 drones abattus, 150 crédits versés.")
fin si
si primeCaisses = 0 et caissesOuvertes >= 10 alors
primeCaisses vaut 1
credits vaut credits + 120
appelle annoncer("Contrat rempli : 10 caisses fouillées, 120 crédits versés.")
fin si
fin procédure
@ LES DESSINS
procédure dessinerFond()
k, x, y est un nombre
remplir(ecran, #060A18)
// deux nebuleuses lointaines
cercle(ecran, 140 - camX * 0.01, 120 - camY * 0.01, 150, rgba(60, 30, 110, 0.18))
cercle(ecran, 600 - camX * 0.012, 400 - camY * 0.012, 180, rgba(16, 70, 110, 0.16))
pour k de 0 à 59
x vaut (etoC[k] - camX * 0.03 + 7200) mod 720
y vaut (etoR[k] - camY * 0.03 + 5200) mod 520
cercle(ecran, x, y, etoT[k], rgba(220, 235, 255, 0.55))
fin pour
fin procédure
// un losange de sol, ou un bloc avec ses deux faces
procédure dessinerCase(t, x, y)
h, hp est un nombre
h vaut HAUTEUR[t]
si h = 0 alors
polygone(ecran, x, y - DEMI_H, x + DEMI_L, y, x, y + DEMI_H, x - DEMI_L, y, DESSUS[t])
ligne(ecran, x - DEMI_L, y, x, y - DEMI_H, NEON[t], 1)
si t = 6 ou t = 12 alors
polygone(ecran, x, y - 9, x + 18, y, x, y + 9, x - 18, y, rgba(120, 230, 255, 0.22))
fin si
sinon
hp vaut h * ETAGE
polygone(ecran, x - DEMI_L, y, x, y + DEMI_H, x, y + DEMI_H - hp, x - DEMI_L, y - hp, GAUCHE[t])
polygone(ecran, x + DEMI_L, y, x, y + DEMI_H, x, y + DEMI_H - hp, x + DEMI_L, y - hp, DROITE[t])
polygone(ecran, x, y - DEMI_H - hp, x + DEMI_L, y - hp, x, y + DEMI_H - hp, x - DEMI_L, y - hp, DESSUS[t])
ligne(ecran, x - DEMI_L, y - hp, x, y - DEMI_H - hp, NEON[t], 1)
ligne(ecran, x + DEMI_L, y - hp, x, y - DEMI_H - hp, NEON[t], 1)
si t = 7 ou t = 17 alors
rectangle(ecran, x - 14, y - hp + 2, 28, hp - 6, rgba(255, 120, 60, 0.35))
fin si
fin si
fin procédure
procédure dessinerPointAu(k, x, y)
genre, f est un nombre
genre vaut ptGenre[k]
f vaut 4 * sinus(tic * 0.08 + k)
si genre = 0 et ptEtat[k] = 0 alors
cercle(ecran, x, y - 24 + f, 17, rgba(120, 230, 255, 0.20))
polygone(ecran, x, y - 40 + f, x + 11, y - 24 + f, x, y - 8 + f, x - 11, y - 24 + f, #4FD8FF)
polygone(ecran, x, y - 35 + f, x + 6, y - 24 + f, x, y - 13 + f, x - 6, y - 24 + f, #E8FBFF)
sinon si genre = 1 et ptEtat[k] = 0 alors
cercle(ecran, x, y - 20 + f, 14, rgba(255, 200, 70, 0.18))
rectangle_arrondi(ecran, x - 10, y - 26 + f, 20, 13, 3, #FFC84A)
rectangle(ecran, x - 7, y - 23 + f, 9, 3, #7A4A10)
rectangle(ecran, x - 7, y - 18 + f, 14, 2, #7A4A10)
sinon si genre = 2 alors
rectangle_arrondi(ecran, x - 13, y - 40, 26, 30, 4, #223450)
rectangle_arrondi(ecran, x - 10, y - 37, 20, 18, 3, #4FD8FF)
rectangle(ecran, x - 7, y - 33 + (tic mod 18), 14, 2, rgba(255, 255, 255, 0.5))
sinon si genre = 3 alors
rectangle_arrondi(ecran, x - 16, y - 44, 32, 36, 5, #2E4160)
rectangle_arrondi(ecran, x - 12, y - 40, 24, 16, 3, #FFC84A)
polygone(ecran, x - 7, y - 20, x + 7, y - 20, x + 4, y - 10, x - 4, y - 10, #94A3B8)
cercle(ecran, x, y - 32, 5, #FFF3C4)
sinon si genre = 5 alors
cercle(ecran, x, y, 22 + 3 * sinus(tic * 0.1), rgba(120, 230, 255, 0.12))
polygone(ecran, x, y - 7, x + 20, y + 3, x, y + 13, x - 20, y + 3, rgba(120, 230, 255, 0.35))
polygone(ecran, x, y - 2, x + 11, y + 3, x, y + 8, x - 11, y + 3, #9BE8FF)
sinon si genre = 6 alors
cercle(ecran, x, y - 30, 26 + 4 * sinus(tic * 0.06), rgba(200, 120, 255, 0.18))
cercle(ecran, x, y - 30, 17, #6B3AA8)
cercle(ecran, x, y - 30, 11, #C08AFF)
cercle(ecran, x, y - 30, 5, #FFFFFF)
fin si
fin procédure
procédure dessinerEnnemiAu(k, x, y)
genre, f, s, v est un nombre
genre vaut ennGenre[k]
f vaut 3 * sinus(tic * 0.12 + k)
ellipse(ecran, x, y + 4, 14, 6, rgba(0, 0, 0, 0.35))
si genre = 0 alors
cercle(ecran, x, y - 22 + f, 11, #2A3B57)
cercle(ecran, x, y - 22 + f, 8, #D14B4B)
cercle(ecran, x, y - 22 + f, 3.5, #FFE2A8)
ligne(ecran, x - 15, y - 26 + f, x + 15, y - 26 + f, #7A8CA8, 3)
cercle(ecran, x - 15, y - 26 + f, 3, #9BE8FF)
cercle(ecran, x + 15, y - 26 + f, 3, #9BE8FF)
sinon si genre = 1 alors
polygone(ecran, x - 16, y, x, y + 8, x + 16, y, x, y - 8, #2A3B57)
rectangle_arrondi(ecran, x - 11, y - 20, 22, 18, 5, #3C5172)
cercle(ecran, x, y - 16, 6, #FF6B4A)
rectangle(ecran, x - 3, y - 30, 6, 12, #7A8CA8)
cercle(ecran, x, y - 30, 4, #FFB020)
sinon si genre = 2 alors
rectangle(ecran, x - 7, y - 14, 5, 15, #2A3B57)
rectangle(ecran, x + 3, y - 14, 5, 15, #2A3B57)
rectangle_arrondi(ecran, x - 11, y - 34, 22, 22, 5, #44608A)
rectangle_arrondi(ecran, x - 8, y - 31, 16, 9, 3, #FF8A3C)
cercle(ecran, x, y - 42 + f * 0.4, 8, #3C5172)
cercle(ecran, x, y - 42 + f * 0.4, 4, #FF6B4A)
rectangle(ecran, x + 9, y - 30, 14, 5, #7A8CA8)
sinon si genre = 3 alors
ligne(ecran, x - 12, y - 2, x - 5, y - 16, #2A3B57, 3)
ligne(ecran, x + 12, y - 2, x + 5, y - 16, #2A3B57, 3)
ligne(ecran, x - 9, y + 2, x - 3, y - 14, #2A3B57, 3)
ligne(ecran, x + 9, y + 2, x + 3, y - 14, #2A3B57, 3)
ellipse(ecran, x, y - 22 + f, 15, 11, #6B2E8A)
ellipse(ecran, x, y - 25 + f, 9, 6, #A855F7)
cercle(ecran, x - 5, y - 23 + f, 2.5, #FDE047)
cercle(ecran, x + 5, y - 23 + f, 2.5, #FDE047)
sinon
v vaut ennVie[k] / ENN_VIE[4]
ellipse(ecran, x, y + 6, 34, 13, rgba(0, 0, 0, 0.45))
cercle(ecran, x, y - 38, 48, rgba(255, 60, 110, 0.10))
rectangle_arrondi(ecran, x - 19, y - 22, 12, 26, 4, #2A3B57)
rectangle_arrondi(ecran, x + 7, y - 22, 12, 26, 4, #2A3B57)
rectangle_arrondi(ecran, x - 24, y - 20, 48, 12, 5, #5A6C8C)
rectangle_arrondi(ecran, x - 29, y - 60, 58, 44, 11, #38475F)
rectangle_arrondi(ecran, x - 25, y - 56, 50, 40, 9, #6B7E9E)
rectangle_arrondi(ecran, x - 21, y - 52, 42, 15, 6, #93A6C4)
rectangle(ecran, x - 21, y - 30, 42, 5, rgba(20, 28, 44, 0.5))
cercle(ecran, x, y - 36 + f * 0.3, 16, rgba(255, 60, 110, 0.35))
cercle(ecran, x, y - 36 + f * 0.3, 11, #B4214A)
cercle(ecran, x, y - 36 + f * 0.3, 8, #FF3A6A)
cercle(ecran, x - 2, y - 39 + f * 0.3, 3, #FFE2E8)
rectangle_arrondi(ecran, x - 44, y - 64, 20, 9, 3, #7A8CA8)
rectangle_arrondi(ecran, x + 24, y - 64, 20, 9, 3, #7A8CA8)
cercle(ecran, x - 44, y - 60, 4, #FF8A3C)
cercle(ecran, x + 44, y - 60, 4, #FF8A3C)
// la jauge de vie du gardien
rectangle_arrondi(ecran, x - 30, y - 74, 60, 7, 3, rgba(10, 14, 30, 0.8))
rectangle_arrondi(ecran, x - 29, y - 73, 58 * v, 5, 2, #FF5A8A)
fin si
si ennGele[k] > 0 alors
cercle(ecran, x, y - 24, 22, rgba(255, 255, 255, ennGele[k] * 2))
fin si
fin procédure
procédure dessinerJoueurAu(x, y)
px, py, qx, qy, part, bx, by est un nombre
ellipse(ecran, x, y + 4, 13, 6, rgba(0, 0, 0, 0.38))
si chrono() >= finInvul ou tic mod 4 < 2 alors
// le halo du bouclier
si bouclier > 0 alors
cercle(ecran, x, y - 20, 23, rgba(90, 200, 255, 0.10))
fin si
// les jambes et le torse
rectangle(ecran, x - 7, y - 14, 5, 15, #1E2A40)
rectangle(ecran, x + 2, y - 14, 5, 15, #1E2A40)
rectangle_arrondi(ecran, x - 10, y - 36, 20, 24, 7, #14536B)
rectangle_arrondi(ecran, x - 10, y - 36, 20, 10, 7, #1C7E9E)
rectangle(ecran, x - 4, y - 28, 8, 4, #4FD8FF)
// le casque et la visiere
cercle(ecran, x, y - 43, 9.5, #1E2A40)
cercle(ecran, x, y - 43, 8, #DCE7F5)
polygone(ecran, x - 7, y - 46, x + 7, y - 46, x + 6, y - 39, x - 6, y - 39, #2BA8D8)
// l'arme, pointee vers la visee
px vaut (viseC - posC)
py vaut (viseR - posR)
bx vaut (px - py) * 0.7
by vaut (px + py) * 0.35
part vaut hypotenuse(bx, by)
si part < 0.2 alors
bx vaut 1
by vaut 0
part vaut 1
fin si
bx vaut bx / part
by vaut by / part
qx vaut 0 - by
qy vaut bx
px vaut x + bx * 9
py vaut y - 24 + by * 9
polygone(ecran, px - qx * 4, py - qy * 4, px + bx * 20 - qx * 4, py + by * 20 - qy * 4, px + bx * 20 + qx * 4, py + by * 20 + qy * 4, px + qx * 4, py + qy * 4, #475569)
ligne(ecran, px - qx * 1.5, py - qy * 1.5, px + bx * 18 - qx * 1.5, py + by * 18 - qy * 1.5, rgba(255, 255, 255, 0.35), 2)
si chrono() < finEclair alors
part vaut (finEclair - chrono()) / 90
cercle(ecran, px + bx * 22, py + by * 22, 12 * part, rgba(100, 220, 255, 0.4))
cercle(ecran, px + bx * 22, py + by * 22, 5 * part, #FFFFFF)
fin si
fin si
fin procédure
@ L'ORDRE DE DESSIN
// les entites visibles, rangees par profondeur (c + r)
visK, visS, visT est un tableau
pour kc de 0 à 47
visK ajoute 0
visS ajoute 0
visT ajoute 0
fin pour
nbVis est un nombre
cibleC, cibleR est un nombre
cibleNom est un texte
procédure ajouterVisible(k, s, genre)
si nbVis <= 47 alors
visK[nbVis] vaut k
visS[nbVis] vaut s
visT[nbVis] vaut genre
nbVis vaut nbVis + 1
fin si
fin procédure
procédure prepaVisible()
k, x, y est un nombre
nbVis vaut 0
pour k de 0 à nbEnnemis - 1
si ennEtat[k] = 1 alors
x vaut ecrX(ennC[k], ennR[k])
y vaut ecrY(ennC[k], ennR[k])
si x > -70 et x < LARG_E + 70 et y > -90 et y < HAUT_E + 70 alors
appelle ajouterVisible(k, arrondi_inferieur(ennC[k] + ennR[k]), 0)
fin si
fin si
fin pour
pour k de 0 à nbPoints - 1
si ptGenre[k] <> 4 alors
x vaut ecrX(ptC[k] + 0.5, ptR[k] + 0.5)
y vaut ecrY(ptC[k] + 0.5, ptR[k] + 0.5)
si x > -70 et x < LARG_E + 70 et y > -90 et y < HAUT_E + 70 alors
appelle ajouterVisible(k, ptC[k] + ptR[k], 1)
fin si
fin si
fin pour
appelle ajouterVisible(0, arrondi_inferieur(posC + posR), 2)
fin procédure
procédure dessinerVisibles(s)
j, k, x, y est un nombre
pour j de 0 à nbVis - 1
si visS[j] = s alors
k vaut visK[j]
si visT[j] = 0 alors
x vaut ecrX(ennC[k], ennR[k])
y vaut ecrY(ennC[k], ennR[k])
appelle dessinerEnnemiAu(k, x, y)
sinon si visT[j] = 1 alors
x vaut ecrX(ptC[k] + 0.5, ptR[k] + 0.5)
y vaut ecrY(ptC[k] + 0.5, ptR[k] + 0.5)
appelle dessinerPointAu(k, x, y)
sinon
appelle dessinerJoueurAu(ecrX(posC, posR), ecrY(posC, posR))
fin si
fin si
fin pour
fin procédure
// phase 0 : les sols, tous a plat. phase 1 : les reliefs et les personnages,
// du fond vers l'avant, pour que rien ne coupe les pieds du heros.
procédure parcourirPlan(phase)
s, d, c, r, s0, s1, d0, d1, t, h est un nombre
s0 vaut maximum(0, arrondi_inferieur((camY - HAUT_E / 2 - 110) / DEMI_H))
s1 vaut minimum(PLAN_L + PLAN_H - 2, arrondi_superieur((camY + HAUT_E / 2 + 50) / DEMI_H))
d0 vaut arrondi_inferieur((camX - LARG_E / 2 - 70) / DEMI_L)
d1 vaut arrondi_superieur((camX + LARG_E / 2 + 70) / DEMI_L)
pour s de s0 à s1
d vaut d0
si absolue(s - d) mod 2 = 1 alors
d vaut d + 1
fin si
tant que d <= d1
c vaut (s + d) / 2
r vaut (s - d) / 2
si c >= 0 et c < PLAN_L et r >= 0 et r < PLAN_H alors
t vaut plan[c * PLAN_H + r]
si t > 0 alors
h vaut HAUTEUR[t]
si (phase = 0 et h = 0) ou (phase = 1 et h > 0) alors
appelle dessinerCase(t, (c - r) * DEMI_L - camX + LARG_E / 2, (c + r) * DEMI_H - camY + HAUT_E / 2)
fin si
fin si
fin si
d vaut d + 2
fin tant que
si phase = 1 alors
appelle dessinerVisibles(s)
fin si
fin pour
fin procédure
procédure dessinerScene()
appelle prepaVisible()
appelle parcourirPlan(0)
appelle parcourirPlan(1)
fin procédure
procédure dessinerObjetsSol()
k, x, y, f est un nombre
pour k de 0 à 39
si objActif[k] = 1 alors
x vaut ecrX(objC[k], objR[k])
f vaut 3 * sinus(tic * 0.16 + k)
y vaut ecrY(objC[k], objR[k]) - 12 + f
si x > -20 et x < LARG_E + 20 et y > -20 et y < HAUT_E + 20 alors
si objGenre[k] = 0 alors
cercle(ecran, x, y, 9, rgba(255, 200, 70, 0.22))
cercle(ecran, x, y, 6, #B4821E)
cercle(ecran, x, y, 4, #FFC84A)
sinon si objGenre[k] = 1 alors
cercle(ecran, x, y, 10, rgba(80, 220, 255, 0.22))
polygone(ecran, x - 3, y - 8, x + 5, y - 1, x + 1, y - 1, x + 3, y + 8, x - 5, y + 1, x - 1, y + 1, #4FD8FF)
sinon
cercle(ecran, x, y, 10, rgba(120, 255, 190, 0.22))
polygone(ecran, x, y - 8, x + 7, y - 3, x + 7, y + 3, x, y + 8, x - 7, y + 3, x - 7, y - 3, #4ADE80)
fin si
fin si
fin si
fin pour
fin procédure
procédure dessinerTirs()
k, x, y, dx, dy, lg est un nombre
pour k de 0 à 59
si tirActif[k] = 1 alors
x vaut ecrX(tirC[k], tirR[k])
y vaut ecrY(tirC[k], tirR[k]) - 20
si x > -40 et x < LARG_E + 40 et y > -40 et y < HAUT_E + 40 alors
dx vaut (tirDC[k] - tirDR[k]) * DEMI_L
dy vaut (tirDC[k] + tirDR[k]) * DEMI_H
lg vaut hypotenuse(dx, dy)
si lg < 1 alors
lg vaut 1
fin si
dx vaut dx / lg
dy vaut dy / lg
si tirQui[k] = 1 alors
ligne(ecran, x - dx * 18, y - dy * 18, x, y, rgba(255, 110, 90, 0.25), 7)
ligne(ecran, x - dx * 12, y - dy * 12, x, y, #FF6B4A, 4)
cercle(ecran, x, y, 3, #FFE2A8)
sinon si tirGenre[k] = 2 alors
ligne(ecran, x - dx * 46, y - dy * 46, x, y, rgba(190, 120, 255, 0.25), 9)
ligne(ecran, x - dx * 34, y - dy * 34, x, y, #C08AFF, 5)
cercle(ecran, x, y, 4, #FFFFFF)
sinon
ligne(ecran, x - dx * 22, y - dy * 22, x, y, rgba(100, 220, 255, 0.25), 7)
ligne(ecran, x - dx * 15, y - dy * 15, x, y, #4FD8FF, 4)
cercle(ecran, x, y, 2.6, #EAFBFF)
fin si
fin si
fin si
fin pour
fin procédure
procédure dessinerParticules()
k, opa, s est un nombre
pour k de 0 à 39
si parVie[k] > 0 alors
opa vaut parVie[k]
si parGenre[k] = 0 alors
cercle(ecran, parX[k], parY[k], 2 + 4 * (1 - opa), rgba(170, 200, 230, opa * 0.35))
sinon
s vaut 2 + 4 * opa
rectangle(ecran, parX[k] - s / 2, parY[k] - s / 2, s, s, rgba(190, 240, 255, opa))
fin si
fin si
fin pour
fin procédure
procédure majParticules(dt)
k est un nombre
pour k de 0 à 39
si parVie[k] > 0 alors
parX[k] vaut parX[k] + parVX[k] * dt
parY[k] vaut parY[k] + parVY[k] * dt
parVY[k] vaut parVY[k] + 150 * dt
parVie[k] vaut parVie[k] - dt * 1.8
fin si
fin pour
fin procédure
procédure dessinerAmbiance()
k, d est un nombre
// une lueur froide, puis la vignette
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(40, 90, 160, 0.05))
si chrono() - finTouche < 400 alors
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(255, 60, 60, 0.12))
fin si
pour k de 0 à 4
d vaut k * 11
rectangle(ecran, 0, d, LARG_E, 11, rgba(4, 8, 20, 0.055))
rectangle(ecran, 0, HAUT_E - d - 11, LARG_E, 11, rgba(4, 8, 20, 0.055))
rectangle(ecran, d, 0, 11, HAUT_E, rgba(4, 8, 20, 0.05))
rectangle(ecran, LARG_E - d - 11, 0, 11, HAUT_E, rgba(4, 8, 20, 0.05))
fin pour
fin procédure
@ L'INTERFACE
procédure panneau(x, y, lb, hb)
rectangle_arrondi(ecran, x, y + 3, lb, hb, 12, rgba(2, 6, 18, 0.35))
rectangle_arrondi(ecran, x, y, lb, hb, 12, rgba(12, 22, 42, 0.80))
rectangle_arrondi(ecran, x + 2, y + 2, lb - 4, 3, 2, rgba(120, 200, 255, 0.18))
fin procédure
procédure jauge(x, y, lb, hb, part, coul)
rectangle_arrondi(ecran, x, y, lb, hb, hb / 2, rgba(2, 6, 18, 0.65))
si part > 0.02 alors
rectangle_arrondi(ecran, x + 1, y + 1, (lb - 2) * part, hb - 2, (hb - 2) / 2, coul)
fin si
fin procédure
// la cible de la boussole : carte, noyau, puis le Reacteur
procédure chercherCible()
k, d, meilleur, sect est un nombre
meilleur vaut 999999
cibleC vaut 37
cibleR vaut 11
cibleNom vaut "Le Gardien"
si noyaux < 3 alors
cibleNom vaut "Objectif"
pour k de 0 à nbPoints - 1
sect vaut ptSecteur[k]
si ptEtat[k] = 0 et sect < 3 alors
si ptGenre[k] = 1 ou (ptGenre[k] = 0 et secteurCarte[sect] = 1) alors
d vaut ecart(ptC[k], ptR[k], posC, posR)
si d < meilleur alors
meilleur vaut d
cibleC vaut ptC[k]
cibleR vaut ptR[k]
si ptGenre[k] = 1 alors
cibleNom vaut "Carte " + NOM_SECTEUR[sect]
sinon
cibleNom vaut "Noyau " + NOM_SECTEUR[sect]
fin si
fin si
fin si
fin si
fin pour
fin si
fin procédure
procédure dessinerBoussole()
d, dx, dy, qx, qy, cx, cy, ex, ey est un nombre
appelle chercherCible()
cx vaut 296
cy vaut 42
ex vaut (cibleC - cibleR) * DEMI_L - (posC - posR) * DEMI_L
ey vaut (cibleC + cibleR) * DEMI_H - (posC + posR) * DEMI_H
d vaut hypotenuse(ex, ey)
si d < 1 alors
d vaut 1
fin si
dx vaut ex / d
dy vaut ey / d
qx vaut 0 - dy
qy vaut dx
cercle(ecran, cx, cy, 15, rgba(255, 255, 255, 0.08))
polygone(ecran, cx + dx * 13, cy + dy * 13, cx - dx * 7 + qx * 8, cy - dy * 7 + qy * 8, cx - dx * 3, cy - dy * 3, cx - dx * 7 - qx * 8, cy - dy * 7 - qy * 8, #4FD8FF)
label(ecran, 284, 26, "OBJECTIF", #5E88B8, 10)
label(ecran, 320, 42, cibleNom, #E6F3FF, 13)
label(ecran, 320, 58, convertir_texte(arrondi(ecart(cibleC, cibleR, posC, posR))) + " cases", #7FA8CC, 11)
fin procédure
procédure dessinerMire()
x, y est un nombre
si sourisXC >= 0 et sourisYC >= 0 alors
x vaut sourisXC
y vaut sourisYC
cercle(ecran, x, y, 12, rgba(80, 220, 255, 0.14))
cercle(ecran, x, y, 8, rgba(8, 16, 32, 0.35))
cercle(ecran, x, y, 6.5, rgba(120, 230, 255, 0.6))
ligne(ecran, x - 14, y, x - 6, y, #4FD8FF, 2)
ligne(ecran, x + 6, y, x + 14, y, #4FD8FF, 2)
ligne(ecran, x, y - 14, x, y - 6, #4FD8FF, 2)
ligne(ecran, x, y + 6, x, y + 14, #4FD8FF, 2)
cercle(ecran, x, y, 1.6, #FFFFFF)
fin si
fin procédure
procédure dessinerInterface()
k, x, part, suiv, prec est un nombre
// a gauche : bouclier, coque, energie
appelle panneau(10, 10, 252, 58)
label(ecran, 24, 26, "BOUCLIER", #5E88B8, 10)
appelle jauge(24, 30, 140, 9, bouclier / bouclierMax, #4FD8FF)
pour k de 0 à coqueMax - 1
si k < coque alors
polygone(ecran, 180 + k * 12, 28, 186 + k * 12, 32, 180 + k * 12, 36, 174 + k * 12, 32, #4ADE80)
sinon
polygone(ecran, 180 + k * 12, 28, 186 + k * 12, 32, 180 + k * 12, 36, 174 + k * 12, 32, rgba(255, 255, 255, 0.14))
fin si
fin pour
label(ecran, 24, 52, "ÉNERGIE", #5E88B8, 10)
appelle jauge(74, 45, 90, 7, energie / energieMax, #FFC84A)
label(ecran, 180, 56, NOM_ARME[arme], #E6F3FF, 12)
// au centre : la boussole
appelle panneau(272, 10, 176, 58)
appelle dessinerBoussole()
// a droite : noyaux, credits, niveau
appelle panneau(458, 10, 252, 58)
pour k de 0 à 2
x vaut 480 + k * 26
si k < noyaux alors
polygone(ecran, x, 20, x + 9, 32, x, 44, x - 9, 32, #4FD8FF)
polygone(ecran, x, 25, x + 5, 32, x, 39, x - 5, 32, #EAFBFF)
sinon
polygone(ecran, x, 20, x + 9, 32, x, 44, x - 9, 32, rgba(255, 255, 255, 0.12))
fin si
fin pour
cercle(ecran, 560, 26, 7, #B4821E)
cercle(ecran, 560, 26, 5, #FFC84A)
label(ecran, 572, 32, convertir_texte(credits), #FFFFFF, 15)
label(ecran, 560, 56, "Niveau " + convertir_texte(niveau), #E6F3FF, 12)
prec vaut SEUIL_XP[niveau - 1]
suiv vaut SEUIL_XP[niveau]
part vaut 1
si niveau < 6 alors
part vaut (xp - prec) / (suiv - prec)
fin si
appelle jauge(628, 46, 68, 7, limiter(part, 0, 1), #A855F7)
label(ecran, 628, 32, "XP", #5E88B8, 10)
// en bas a gauche : les armes
appelle panneau(10, 452, 236, 56)
pour k de 0 à 2
x vaut 20 + k * 76
si k = arme alors
rectangle_arrondi(ecran, x, 458, 70, 44, 9, rgba(79, 216, 255, 0.22))
rectangle_arrondi(ecran, x, 458, 70, 44, 9, rgba(79, 216, 255, 0.12))
fin si
rectangle_arrondi(ecran, x + 2, 460, 66, 40, 8, rgba(10, 18, 34, 0.5))
si armePrise[k] = 1 alors
label(ecran, x + 8, 478, convertir_texte(k + 1), #4FD8FF, 13)
label(ecran, x + 20, 478, NOM_ARME[k], #E6F3FF, 11)
rectangle(ecran, x + 10, 486, 50, 3, rgba(120, 200, 255, 0.35))
sinon
label(ecran, x + 8, 478, convertir_texte(k + 1), #3E5E86, 13)
label(ecran, x + 20, 478, "verrouillé", #3E5E86, 11)
fin si
fin pour
label(ecran, 258, 474, "E agir", #7FA8CC, 11)
label(ecran, 258, 492, "J objectifs", #7FA8CC, 11)
label(ecran, 322, 474, "M carte", #7FA8CC, 11)
label(ecran, 322, 492, "X quitter", #7FA8CC, 11)
appelle dessinerMire()
si chrono() < msgFin alors
x vaut label_largeur(msgTxt, 14) + 46
appelle panneau(LARG_E / 2 - x / 2, 416, x, 34)
rectangle_arrondi(ecran, LARG_E / 2 - x / 2 + 12, 424, 4, 18, 2, #4FD8FF)
label(ecran, LARG_E / 2 - x / 2 + 26, 438, msgTxt, #E6F3FF, 14)
fin si
fin procédure
procédure dessinerDialogue()
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(4, 8, 22, 0.35))
appelle panneau(56, 338, 608, 130)
rectangle_arrondi(ecran, 72, 322, label_largeur(dlgNom, 15) + 32, 30, 10, #1C7E9E)
appelle centrer(dlgNom, 88 + label_largeur(dlgNom, 15) / 2, 343, #FFFFFF, 15)
label(ecran, 80, 394, dlgL1, #E6F3FF, 14)
label(ecran, 80, 420, dlgL2, #9FC2E0, 14)
label(ecran, 80, 452, "E ou Échap pour fermer", #4A6E96, 12)
fin procédure
procédure dessinerAtelier()
k, y est un nombre
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(4, 8, 22, 0.72))
appelle panneau(94, 24, 532, 472)
appelle centrer("ATELIER DE LA STATION", LARG_E / 2, 62, #FFC84A, 20)
cercle(ecran, 440, 86, 8, #B4821E)
cercle(ecran, 440, 86, 6, #FFC84A)
label(ecran, 454, 92, convertir_texte(credits) + " crédits", #FFFFFF, 15)
pour k de 0 à 4
y vaut 110 + k * 68
rectangle_arrondi(ecran, 112, y, 496, 58, 10, rgba(10, 18, 34, 0.6))
rectangle_arrondi(ecran, 112, y, 5, 58, 2, #4FD8FF)
label(ecran, 132, y + 24, convertir_texte(k + 1) + ". " + NOM_ACHAT[k], #E6F3FF, 15)
label(ecran, 132, y + 44, DETAIL_ACHAT[k], #7FA8CC, 12)
label(ecran, 400, y + 24, convertir_texte(PRIX_ACHAT[k]) + " cr.", #FFC84A, 14)
si achatPossible(k) alors
rectangle_arrondi(ecran, 480, y + 12, 112, 34, 9, #1C7E9E)
appelle centrer("Acheter", 536, y + 34, #FFFFFF, 14)
sinon
rectangle_arrondi(ecran, 480, y + 12, 112, 34, 9, rgba(255, 255, 255, 0.07))
appelle centrer("Indisponible", 536, y + 34, #4A6E96, 13)
fin si
fin pour
appelle centrer("Clique, ou tape le numéro. Échap : fermer", LARG_E / 2, 478, #7FA8CC, 12)
fin procédure
procédure dessinerObjectifs()
k, y, faits est un nombre
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(4, 8, 22, 0.72))
appelle panneau(104, 54, 512, 412)
appelle centrer("OBJECTIFS", LARG_E / 2, 96, #4FD8FF, 20)
pour k de 0 à 4
y vaut 124 + k * 62
rectangle_arrondi(ecran, 124, y, 472, 52, 10, rgba(10, 18, 34, 0.6))
faits vaut 0
si k = 0 alors
faits vaut noyaux
label(ecran, 170, y + 24, "Rapporter les 3 noyaux d'énergie", #E6F3FF, 15)
label(ecran, 170, y + 42, convertir_texte(noyaux) + " sur 3 récupérés", #7FA8CC, 12)
sinon si k = 1 alors
si noyaux >= 3 alors
faits vaut 3
fin si
label(ecran, 170, y + 24, "Faire tomber la barrière du Réacteur", #E6F3FF, 15)
label(ecran, 170, y + 42, "Elle cède dès que les 3 noyaux sont réunis", #7FA8CC, 12)
sinon si k = 2 alors
label(ecran, 170, y + 24, "Détruire le Gardien du Réacteur", #E6F3FF, 15)
label(ecran, 170, y + 42, "Tout au nord de la station", #7FA8CC, 12)
sinon si k = 3 alors
faits vaut dronesAbattus
label(ecran, 170, y + 24, "Contrat : abattre 12 drones", #E6F3FF, 15)
label(ecran, 170, y + 42, convertir_texte(dronesAbattus) + " sur 12 prime 150 crédits", #7FA8CC, 12)
sinon
faits vaut caissesOuvertes
label(ecran, 170, y + 24, "Contrat : fouiller 10 caisses", #E6F3FF, 15)
label(ecran, 170, y + 42, convertir_texte(caissesOuvertes) + " sur 10 prime 120 crédits", #7FA8CC, 12)
fin si
si (k <= 1 et faits >= 3) ou (k = 3 et faits >= 12) ou (k = 4 et faits >= 10) alors
cercle(ecran, 148, y + 26, 13, #166534)
ligne(ecran, 141, y + 26, 146, y + 32, #4ADE80, 3)
ligne(ecran, 146, y + 32, 156, y + 20, #4ADE80, 3)
sinon
cercle(ecran, 148, y + 26, 13, rgba(255, 255, 255, 0.10))
cercle(ecran, 148, y + 26, 10, rgba(10, 18, 34, 0.8))
fin si
fin pour
appelle centrer("J ou Échap : fermer", LARG_E / 2, 446, #7FA8CC, 12)
fin procédure
procédure dessinerCarte()
c, r, t, x, y, k, p est un nombre
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(4, 8, 22, 0.78))
appelle panneau(176, 18, 368, 484)
appelle centrer("PLAN DE LA STATION", LARG_E / 2, 56, #4FD8FF, 18)
rectangle_arrondi(ecran, 192, 70, 336, 336, 8, rgba(2, 6, 18, 0.7))
pour c de 0 à 35
pour r de 0 à 35
t vaut plan[(c * 2) * PLAN_H + r * 2]
si t > 0 alors
x vaut 196 + c * 9
y vaut 74 + r * 9
si t = 4 ou t = 5 ou t = 15 ou t = 3 alors
rectangle(ecran, x, y, 9, 9, #3A4C6B)
sinon si t = 7 ou t = 17 alors
rectangle(ecran, x, y, 9, 9, #C06A2E)
sinon si t = 9 alors
rectangle(ecran, x, y, 9, 9, #2F5E45)
sinon si t = 10 alors
rectangle(ecran, x, y, 9, 9, #5C3A2A)
sinon si t = 11 alors
rectangle(ecran, x, y, 9, 9, #24405F)
sinon si t = 16 alors
rectangle(ecran, x, y, 9, 9, #4A3A6B)
sinon si t = 13 alors
rectangle(ecran, x, y, 9, 9, #7A5A2A)
sinon
rectangle(ecran, x, y, 9, 9, #2C3A52)
fin si
fin si
fin pour
fin pour
pour k de 0 à nbPoints - 1
x vaut 196 + ptC[k] * 4.5
y vaut 74 + ptR[k] * 4.5
si ptEtat[k] = 0 et ptGenre[k] = 0 alors
cercle(ecran, x, y, 5, #4FD8FF)
sinon si ptEtat[k] = 0 et ptGenre[k] = 1 alors
cercle(ecran, x, y, 5, #FFC84A)
sinon si ptGenre[k] = 3 alors
cercle(ecran, x, y, 4, #4ADE80)
fin si
fin pour
p vaut 3 * absolue(sinus(tic * 0.12))
cercle(ecran, 196 + posC * 4.5, 74 + posR * 4.5, 7 + p, rgba(255, 90, 138, 0.3))
cercle(ecran, 196 + posC * 4.5, 74 + posR * 4.5, 4, #FF5A8A)
label(ecran, 200, 432, "Bleu : noyau Jaune : carte d'accès", #9FC2E0, 12)
label(ecran, 200, 454, "Vert : atelier Rose : toi", #9FC2E0, 12)
appelle centrer("M ou Échap : fermer", LARG_E / 2, 484, #7FA8CC, 12)
fin procédure
procédure dessinerAccueil()
k, f est un nombre
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(4, 8, 22, 0.62))
appelle panneau(104, 40, 512, 440)
rectangle_arrondi(ecran, 104, 40, 512, 104, 12, rgba(20, 83, 107, 0.55))
appelle centrer("HÉLION", LARG_E / 2, 104, #4FD8FF, 48)
appelle centrer("station orbitale · action isométrique", LARG_E / 2, 130, #9FC2E0, 14)
pour k de 0 à 2
f vaut 3 * sinus(tic * 0.08 + k)
polygone(ecran, 312 + k * 48, 166 + f, 324 + k * 48, 184 + f, 312 + k * 48, 202 + f, 300 + k * 48, 184 + f, #4FD8FF)
polygone(ecran, 312 + k * 48, 173 + f, 319 + k * 48, 184 + f, 312 + k * 48, 195 + f, 305 + k * 48, 184 + f, #EAFBFF)
fin pour
label(ecran, 150, 240, "La station est tombée aux mains des machines.", #E6F3FF, 15)
label(ecran, 150, 264, "Explore librement la Serre, la Fonderie et les Archives,", #E6F3FF, 15)
label(ecran, 150, 288, "rapporte les 3 noyaux, puis affronte le Gardien.", #E6F3FF, 15)
rectangle(ecran, 150, 306, 420, 1, rgba(120, 200, 255, 0.16))
label(ecran, 150, 332, "Flèches ou Z Q S D : se déplacer", #9FC2E0, 14)
label(ecran, 150, 356, "Clic de la souris : tirer (la visée suit le pointeur)", #9FC2E0, 14)
label(ecran, 150, 380, "1 2 3 : changer d'arme E : agir", #9FC2E0, 14)
label(ecran, 150, 404, "J : objectifs M : carte X : quitter", #9FC2E0, 14)
rectangle_arrondi(ecran, 258, 424, 204, 46, 12, #1C7E9E)
rectangle_arrondi(ecran, 260, 426, 200, 4, 2, rgba(255, 255, 255, 0.3))
appelle centrer("EMBARQUER", LARG_E / 2, 453, #FFFFFF, 17)
fin procédure
procédure dessinerFin()
rectangle(ecran, 0, 0, LARG_E, HAUT_E, rgba(4, 8, 22, 0.7))
appelle panneau(156, 128, 408, 264)
si etat = 7 alors
rectangle_arrondi(ecran, 156, 128, 408, 76, 12, rgba(20, 83, 107, 0.6))
appelle centrer("LE GARDIEN EST TOMBÉ", LARG_E / 2, 176, #4FD8FF, 22)
appelle centrer("Hélion est de nouveau à nous.", LARG_E / 2, 236, #E6F3FF, 15)
sinon
rectangle_arrondi(ecran, 156, 128, 408, 76, 12, rgba(136, 19, 55, 0.55))
appelle centrer("COQUE DÉTRUITE", LARG_E / 2, 176, #FCA5A5, 22)
appelle centrer("La station garde ses secrets.", LARG_E / 2, 236, #E6F3FF, 15)
fin si
appelle centrer("Noyaux " + convertir_texte(noyaux) + " / 3 Niveau " + convertir_texte(niveau) + " " + convertir_texte(credits) + " crédits", LARG_E / 2, 268, #9FC2E0, 14)
appelle centrer("Meilleur résultat : " + convertir_texte(record) + " noyaux", LARG_E / 2, 294, #7FA8CC, 12)
rectangle_arrondi(ecran, 258, 316, 204, 46, 12, #1C7E9E)
appelle centrer("REJOUER", LARG_E / 2, 345, #FFFFFF, 17)
fin procédure
procédure dessiner()
effacer(ecran)
contour(ecran, #0)
appelle dessinerFond()
appelle dessinerScene()
appelle dessinerObjetsSol()
appelle dessinerTirs()
appelle dessinerParticules()
appelle dessinerAmbiance()
si etat = 0 alors
appelle dessinerAccueil()
sinon
appelle dessinerInterface()
si etat = 2 alors
appelle dessinerDialogue()
sinon si etat = 3 alors
appelle dessinerCarte()
sinon si etat = 4 alors
appelle dessinerAtelier()
sinon si etat = 5 alors
appelle dessinerObjectifs()
sinon si etat >= 6 alors
appelle dessinerFin()
fin si
fin si
fin procédure
@ LES COMMANDES
procédure choisirArme(k)
si armePrise[k] = 1 alors
arme vaut k
sinon
appelle annoncer(NOM_ARME[k] + " : à acheter à l'atelier du noyau central.")
fin si
fin procédure
procédure cliquerAtelier(x, y)
k est un nombre
pour k de 0 à 4
si clique(x, y, 480, 122 + k * 68, 112, 34) alors
appelle acheter(k)
fin si
fin pour
si non clique(x, y, 94, 24, 532, 472) alors
etat vaut 1
fin si
fin procédure
procédure tourDeJeu(dt)
debut, lancer est un booléen
tic vaut tic + 1
sourisXC vaut souris_x(ecran)
sourisYC vaut souris_y(ecran)
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
fin si
si clicSouris et non vuAppuye alors
debut vaut vrai
fin si
etaitAppuye vaut appuye
si etat = 0 alors
lancer vaut debut
si touche_pressée('espace') ou touche_pressée('entrée') alors
lancer vaut vrai
fin si
si lancer alors
appelle nouvellePartie()
fin si
sinon si etat = 1 alors
tempsJeu vaut tempsJeu + dt
appelle bougerJoueur(dt)
appelle bougerEnnemis(dt)
appelle majTirs(dt)
appelle majParticules(dt)
appelle ramasserObjets()
appelle majPrimes()
si appuye ou touche_enfoncée('espace') alors
appelle tirer()
fin si
si touche_pressée('e') alors
appelle agir()
fin si
si touche_pressée('j') alors
etat vaut 5
fin si
si touche_pressée('m') alors
etat vaut 3
fin si
si touche_pressée('1') alors
appelle choisirArme(0)
fin si
si touche_pressée('2') alors
appelle choisirArme(1)
fin si
si touche_pressée('3') alors
appelle choisirArme(2)
fin si
sinon si etat = 2 alors
si touche_pressée('e') ou touche_pressée('échap') alors
etat vaut 1
fin si
sinon si etat = 3 alors
si touche_pressée('m') ou touche_pressée('échap') alors
etat vaut 1
fin si
sinon si etat = 4 alors
si touche_pressée('échap') ou touche_pressée('e') alors
etat vaut 1
fin si
si touche_pressée('1') alors
appelle acheter(0)
fin si
si touche_pressée('2') alors
appelle acheter(1)
fin si
si touche_pressée('3') alors
appelle acheter(2)
fin si
si touche_pressée('4') alors
appelle acheter(3)
fin si
si touche_pressée('5') alors
appelle acheter(4)
fin si
si debut alors
appelle cliquerAtelier(sourisXC, sourisYC)
fin si
sinon si etat = 5 alors
si touche_pressée('j') ou touche_pressée('échap') alors
etat vaut 1
fin si
sinon
lancer vaut debut
si touche_pressée('espace') alors
lancer vaut vrai
fin si
si lancer alors
appelle nouvellePartie()
fin si
fin si
si touche_pressée('x') alors
appActif vaut faux
fin si
fin procédure
@ DEMARRAGE
maintenantMs est un nombre
appelle nouvellePartie()
etat vaut 0
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, #060A18)
appelle centrer("Hélion t'attend, pilote.", LARG_E / 2, HAUT_E / 2, #4FD8FF, 22)
affiche ecran