Ligne de Front

CoddyRun
Le code, en toute simplicité
Ligne de Front Prêt
Console
Clique sur « Exécuter » pour lancer le programme.
Aucune exécutionCtrl+Entrée : exécuter · Échap : arrêter
Code CoddyRun
@ Réglages
NB_UNITES est un nombre
NB_UNITES vaut 60
NB_PROJ est un nombre
NB_PROJ vaut 100
X_BASE_J est un nombre
X_BASE_J vaut 44
X_BASE_E est un nombre
X_BASE_E vaut 600
AXE_Y est un nombre
AXE_Y vaut 200
PV_BASE est un nombre
PV_BASE vaut 1000

@ État
ecran est une toile
dimension(ecran, 640, 480)

// genre : 1 = archer, 2 = fusilier, 3 = tank
uCamp est un tableau
uGenre est un tableau
uX est un tableau
uY est un tableau
uPV est un tableau
uCD est un tableau
uAct est un tableau

pAct est un tableau
pX est un tableau
pY est un tableau
pCible est un tableau
pCamp est un tableau
pDegat est un tableau
pGenre est un tableau

pieces, baseJ, baseE, etat est un nombre
spawnE, tics, revenu est un nombre
niveauRevenu, coutRevenu, vague, ennemisVague, delaiSpawn est un nombre
typeE est un nombre
tr1, tr2, tr3, tr4, resetTraite est un nombre
proI, proJ, proC, proD, proMin, proCible, proDist est un nombre
proK, proL, cibX, cibY, cibleValide, distX, distY, distTotale est un nombre

ach1, ach2, ach3, ach4, resetDemande est un nombre
enJeu est un booleen
action, ptX, ptY est un nombre

ach1 vaut 0
ach2 vaut 0
ach3 vaut 0
ach4 vaut 0
resetDemande vaut 0
tr1 vaut 0
tr2 vaut 0
tr3 vaut 0
tr4 vaut 0
resetTraite vaut 0
enJeu vaut vrai

pour proI de 0 à NB_UNITES - 1
  uCamp ajoute 0
  uGenre ajoute 1
  uX ajoute 0
  uY ajoute 0
  uPV ajoute 0
  uCD ajoute 0
  uAct ajoute 0
fin pour

pour proI de 0 à NB_PROJ - 1
  pAct ajoute 0
  pX ajoute 0
  pY ajoute 0
  pCible ajoute 0
  pCamp ajoute 0
  pDegat ajoute 0
  pGenre ajoute 0
fin pour


@ Caractéristiques des unités
fonction coutUnite(g)
  si g = 1 alors
    retourne 10
  sinon si g = 2 alors
    retourne 100
  sinon si g = 3 alors
    retourne 500
  fin si
  retourne coutRevenu
fin fonction

fonction pvUnite(g)
  si g = 1 alors
    retourne 24
  sinon si g = 2 alors
    retourne 46
  fin si
  retourne 240
fin fonction

fonction degatUnite(g)
  si g = 1 alors
    retourne 6
  sinon si g = 2 alors
    retourne 12
  fin si
  retourne 26
fin fonction

fonction porteeUnite(g)
  si g = 1 alors
    retourne 60
  sinon si g = 2 alors
    retourne 110
  fin si
  retourne 44
fin fonction

fonction vitesseUnite(g)
  si g = 1 alors
    retourne 14
  sinon si g = 2 alors
    retourne 9
  fin si
  retourne 6
fin fonction

fonction cadenceUnite(g)
  si g = 1 alors
    retourne 22
  sinon si g = 2 alors
    retourne 18
  fin si
  retourne 26
fin fonction

fonction nomUnite(g)
  si g = 1 alors
    retourne "ARCHER"
  sinon si g = 2 alors
    retourne "FUSILIER"
  sinon si g = 3 alors
    retourne "TANK"
  fin si
  retourne "MINE N." + convertir_texte(niveauRevenu)
fin fonction


@ Partie
procédure creerUnite(camp, g)
  proI vaut 0
  proJ vaut -1
  pour proI de 0 à NB_UNITES - 1
    si uAct[proI] = 0 et proJ < 0 alors
      proJ vaut proI
    fin si
  fin pour
  si proJ >= 0 alors
    uAct[proJ] vaut 1
    uCamp[proJ] vaut camp
    uGenre[proJ] vaut g
    uPV[proJ] vaut pvUnite(g)
    uCD[proJ] vaut 0
    uY[proJ] vaut AXE_Y - 12 + hasard(24)
    si camp = 0 alors
      uX[proJ] vaut X_BASE_J + 30
    sinon
      uX[proJ] vaut X_BASE_E - 30
    fin si
  fin si
fin procédure

procédure creerProjectile(camp, genre, deX, deY, cible, degats)
  proK vaut 0
  proL vaut -1
  pour proK de 0 à NB_PROJ - 1
    si pAct[proK] = 0 et proL < 0 alors
      proL vaut proK
    fin si
  fin pour
  si proL >= 0 alors
    pAct[proL] vaut 1
    pCamp[proL] vaut camp
    pGenre[proL] vaut genre
    pX[proL] vaut deX
    pY[proL] vaut deY
    pCible[proL] vaut cible
    pDegat[proL] vaut degats
  fin si
fin procédure

procédure nouvellePartie()
  pieces vaut 40
  revenu vaut 9
  niveauRevenu vaut 1
  coutRevenu vaut 50
  vague vaut 1
  ennemisVague vaut 3
  baseJ vaut PV_BASE
  baseE vaut PV_BASE
  spawnE vaut 60
  delaiSpawn vaut 45
  etat vaut 0
  tics vaut 0
  pour proI de 0 à NB_UNITES - 1
    uAct[proI] vaut 0
  fin pour
  pour proI de 0 à NB_PROJ - 1
    pAct[proI] vaut 0
  fin pour
fin procédure


@ Dessin
procédure dessinerUnite(g2, idx)
  posX2 est un nombre
  posY2 est un nombre
  sens est un nombre
  teinte est un texte
  teinteF est un texte
  posX2 vaut uX[idx]
  posY2 vaut uY[idx]
  
  si uGenre[idx] = 3 alors
    ellipse(g2, posX2 - 2, posY2 + 10, 24, 8, rgba(0, 0, 0, 0.4))
  sinon
    ellipse(g2, posX2 - 2, posY2 + 2, 12, 4, rgba(0, 0, 0, 0.4))
  fin si

  si uCamp[idx] = 0 alors
    teinte vaut rgb(58, 122, 204)
    teinteF vaut rgb(36, 84, 148)
    sens vaut 1
  sinon
    teinte vaut rgb(214, 60, 60)
    teinteF vaut rgb(150, 30, 30)
    sens vaut -1
  fin si
  
  si uGenre[idx] = 3 alors
    contour(g2, #1A2A1A, 3)
    rectangle_arrondi(g2, posX2 - 20, posY2 - 6, 40, 16, 7, teinteF)
    rectangle_arrondi(g2, posX2 - 16, posY2 - 18, 30, 13, 5, teinte)
    si sens = 1 alors
      rectangle_arrondi(g2, posX2 + 12, posY2 - 15, 24, 6, 3, teinteF)
    sinon
      rectangle_arrondi(g2, posX2 - 36, posY2 - 15, 24, 6, 3, teinteF)
    fin si
    contour(g2, #0)
    cercle(g2, posX2 - 12, posY2 + 2, 5, #2A2A2A)
    cercle(g2, posX2 - 12, posY2 + 2, 2, #777777)
    cercle(g2, posX2, posY2 + 2, 5, #2A2A2A)
    cercle(g2, posX2, posY2 + 2, 2, #777777)
    cercle(g2, posX2 + 12, posY2 + 2, 5, #2A2A2A)
    cercle(g2, posX2 + 12, posY2 + 2, 2, #777777)
  sinon
    contour(g2, #1A2A1A, 3)
    rectangle_arrondi(g2, posX2 - 6, posY2 - 8, 12, 18, 4, teinte)
    cercle(g2, posX2, posY2 - 14, 7, #F2C8A0)
    rectangle_arrondi(g2, posX2 - 8, posY2 - 20, 16, 7, 3, teinteF)
    si uGenre[idx] = 1 alors
      // Arc (Archer)
      si sens = 1 alors
        rectangle_arrondi(g2, posX2 + 6, posY2 - 16, 4, 16, 2, #5C3A21)
      sinon
        rectangle_arrondi(g2, posX2 - 10, posY2 - 16, 4, 16, 2, #5C3A21)
      fin si
    sinon
      // Fusil
      si sens = 1 alors
        rectangle_arrondi(g2, posX2 + 4, posY2 - 6, 22, 5, 2, #3A3A42)
      sinon
        rectangle_arrondi(g2, posX2 - 26, posY2 - 6, 22, 5, 2, #3A3A42)
      fin si
    fin si
    contour(g2, #0)
  fin si
  
  si uPV[idx] < pvUnite(uGenre[idx]) alors
    rectangle(g2, posX2 - 12, posY2 - 32, 24, 4, #4A2A2A)
    rectangle(g2, posX2 - 12, posY2 - 32, 24 * uPV[idx] / pvUnite(uGenre[idx]), 4, #5CE05C)
  fin si
fin procédure

procédure carte(g2, cx, g, touche)
  rectangle_arrondi(g2, cx + 4, 360, 132, 112, 14, rgba(0, 0, 0, 0.3))
  
  contour(g2, #1A3A5A, 3)
  si pieces >= coutUnite(g) alors
    rectangle_arrondi(g2, cx, 356, 132, 112, 14, #3FA9E8)
    rectangle_arrondi(g2, cx + 8, 364, 116, 64, 10, #BFE4F7)
  sinon
    rectangle_arrondi(g2, cx, 356, 132, 112, 14, #7A8A96)
    rectangle_arrondi(g2, cx + 8, 364, 116, 64, 10, #A0B0BC)
  fin si
  contour(g2, #0)
  
  // Le texte est remonté un peu plus haut (Y=376)
  label(g2, cx + 12, 376, touche + "  " + nomUnite(g), #10405F, 11)
  
  // Les dessins sont remontés pour être mieux centrés
  si g = 4 alors
    contour(g2, #1A2A1A, 3)
    cercle(g2, cx + 66, 400, 16, #F2B01E)
    cercle(g2, cx + 66, 400, 10, #FFD96B)
    rectangle(g2, cx + 60, 398, 12, 4, #FFFFFF)
    rectangle(g2, cx + 64, 394, 4, 12, #FFFFFF)
    contour(g2, #0)
  sinon si g = 3 alors
    contour(g2, #1A2A1A, 3)
    rectangle_arrondi(g2, cx + 44, 406, 44, 16, 7, #24548C)
    rectangle_arrondi(g2, cx + 48, 396, 32, 12, 5, #3A7ACC)
    rectangle_arrondi(g2, cx + 80, 398, 22, 6, 3, #24548C)
    contour(g2, #0)
  sinon
    contour(g2, #1A2A1A, 3)
    rectangle_arrondi(g2, cx + 58, 402, 14, 20, 4, #3A7ACC)
    cercle(g2, cx + 65, 396, 8, #F2C8A0)
    rectangle_arrondi(g2, cx + 56, 388, 18, 8, 3, #24548C)
    si g = 1 alors
      rectangle_arrondi(g2, cx + 70, 390, 6, 18, 3, #5C3A21)
    sinon
      rectangle_arrondi(g2, cx + 72, 406, 22, 6, 2, #3A3A42)
    fin si
    contour(g2, #0)
  fin si
  
  contour(g2, #1A3A5A, 3)
  rectangle_arrondi(g2, cx + 24, 434, 84, 26, 12, #FFFFFF)
  contour(g2, #0)
  cercle(g2, cx + 40, 447, 9, #F2B01E)
  cercle(g2, cx + 40, 447, 5, #FFD96B)
  label(g2, cx + 54, 454, convertir_texte(coutUnite(g)), #2A3A4A, 15)
fin procédure

procédure dessinerTout()
  effacer(ecran)
  
  dégradé(ecran, [#6CB4EE, #E0F7FA])
  
  polygone(ecran, -40, 160, 100, 70, 260, 160, #8CA3B0)
  polygone(ecran, 180, 160, 360, 50, 540, 160, #A0B5C0)
  polygone(ecran, 460, 160, 600, 90, 720, 160, #8CA3B0)

  rectangle(ecran, 0, 160, 640, 320, #5CA83E)
  rectangle(ecran, 0, 160, 640, 8, #4D8F33)
  
  rectangle(ecran, 0, AXE_Y - 30, 640, 60, #C2A066)
  rectangle(ecran, 0, AXE_Y - 32, 640, 4, #9E804F)
  rectangle(ecran, 0, AXE_Y + 30, 640, 4, #9E804F)

  ellipse(ecran, X_BASE_J, AXE_Y + 30, 50, 14, rgba(0, 0, 0, 0.5))
  ellipse(ecran, X_BASE_E, AXE_Y + 30, 50, 14, rgba(0, 0, 0, 0.5))

  contour(ecran, #1A2A1A, 4)
  rectangle_arrondi(ecran, X_BASE_J - 34, AXE_Y - 66, 60, 86, 8, #3A7ACC)
  rectangle_arrondi(ecran, X_BASE_J - 26, AXE_Y - 82, 44, 20, 6, #24548C)
  rectangle(ecran, X_BASE_J - 10, AXE_Y - 95, 20, 15, #1A3A5A)
  
  rectangle_arrondi(ecran, X_BASE_E - 26, AXE_Y - 66, 60, 86, 8, #B83A3A)
  rectangle_arrondi(ecran, X_BASE_E - 18, AXE_Y - 82, 44, 20, 6, #802020)
  rectangle(ecran, X_BASE_E - 2, AXE_Y - 95, 20, 15, #4A1010)
  contour(ecran, #0)

  rectangle_arrondi(ecran, 18, 20, 200, 22, 11, rgba(42, 42, 42, 0.7))
  rectangle_arrondi(ecran, 20, 22, limiter(196 * baseJ / PV_BASE, 0, 196), 18, 9, #3FA9E8)
  rectangle_arrondi(ecran, 422, 20, 200, 22, 11, rgba(42, 42, 42, 0.7))
  rectangle_arrondi(ecran, 424, 22, limiter(196 * baseE / PV_BASE, 0, 196), 18, 9, #E83F3F)
  label(ecran, 24, 14, "VOTRE BASE " + convertir_texte(arrondi(baseJ)), #FFFFFF, 12)
  label(ecran, 428, 14, "BASE ENNEMIE " + convertir_texte(arrondi(baseE)), #FFFFFF, 12)

  rectangle_arrondi(ecran, 250, 70, 140, 30, 10, rgba(42, 42, 42, 0.7))
  si ennemisVague > 0 alors
    label(ecran, 286.18, 90.58, "VAGUE " + convertir_texte(vague), #FFFFFF, 16)
  sinon
    label(ecran, 270, 90, "EN ATTENTE...", #F2B01E, 14)
  fin si

  pour proI de 0 à NB_UNITES - 1
    si uAct[proI] = 1 alors
      appelle dessinerUnite(ecran, proI)
    fin si
  fin pour

  pour proI de 0 à NB_PROJ - 1
    si pAct[proI] = 1 alors
      si pGenre[proI] = 1 alors
        cercle(ecran, pX[proI], pY[proI], 3, #E8DCC0)
      sinon si pGenre[proI] = 2 alors
        cercle(ecran, pX[proI], pY[proI], 2, #F2B01E)
      sinon
        cercle(ecran, pX[proI], pY[proI], 5, #1A1A1A)
        cercle(ecran, pX[proI], pY[proI], 2, #E83F3F)
      fin si
    fin si
  fin pour

  contour(ecran, #1A3A5A, 3)
  rectangle_arrondi(ecran, 248, 14, 144, 38, 14, #FFFFFF)
  contour(ecran, #0)
  cercle(ecran, 278, 33, 14, #F2B01E)
  cercle(ecran, 278, 33, 10, #FFD96B)
  label(ecran, 298, 41, convertir_texte(arrondi(pieces)), #2A3A4A, 22)

  appelle carte(ecran, 22, 1, "1")
  appelle carte(ecran, 176, 2, "2")
  appelle carte(ecran, 330, 3, "3")
  appelle carte(ecran, 484, 4, "4")

  si etat <> 0 alors
    rectangle_arrondi(ecran, 130, 110, 380, 130, 16, rgba(0, 0, 0, 0.6))
    contour(ecran, #1A2A1A, 4)
    rectangle_arrondi(ecran, 140, 120, 360, 110, 16, #FFFFFF)
    contour(ecran, #0)
    si etat = 1 alors
      label(ecran, 224, 170, "VICTOIRE !", #3A9A3A, 30)
    sinon
      label(ecran, 236, 170, "DÉFAITE", #D14545, 30)
    fin si
    label(ecran, 190, 206, "'n' pour une nouvelle bataille", #6A7A8A, 15)
  fin si
  affiche ecran
fin procédure


@ Moteur (processus parallèle)
processus MoteurJeu()
  tant que enJeu
    tics vaut tics + 1

    si resetTraite < resetDemande alors
      resetTraite vaut resetTraite + 1
      appelle nouvellePartie()
    fin si
    
    si tr1 < ach1 alors
      tr1 vaut tr1 + 1
      si etat = 0 et pieces >= coutUnite(1) alors
        pieces vaut pieces - coutUnite(1)
        appelle creerUnite(0, 1)
      fin si
    fin si
    si tr2 < ach2 alors
      tr2 vaut tr2 + 1
      si etat = 0 et pieces >= coutUnite(2) alors
        pieces vaut pieces - coutUnite(2)
        appelle creerUnite(0, 2)
      fin si
    fin si
    si tr3 < ach3 alors
      tr3 vaut tr3 + 1
      si etat = 0 et pieces >= coutUnite(3) alors
        pieces vaut pieces - coutUnite(3)
        appelle creerUnite(0, 3)
      fin si
    fin si
    si tr4 < ach4 alors
      tr4 vaut tr4 + 1
      si etat = 0 et pieces >= coutRevenu alors
        pieces vaut pieces - coutRevenu
        niveauRevenu vaut niveauRevenu + 1
        revenu vaut revenu + 8
        coutRevenu vaut coutRevenu + 40 + (niveauRevenu * 10)
      fin si
    fin si

    si etat = 0 alors
      pieces vaut pieces + revenu / 16

      spawnE vaut spawnE - 1
      si spawnE <= 0 alors
        si ennemisVague > 0 alors
          ennemisVague vaut ennemisVague - 1
          typeE vaut 1
          
          si vague >= 4 et hasard(10) < (vague - 2) alors
            typeE vaut 3
          sinon si vague >= 2 et hasard(10) < vague alors
            typeE vaut 2
          fin si
          
          appelle creerUnite(1, typeE)
          delaiSpawn vaut limiter(45 - vague * 2, 10, 45)
          spawnE vaut delaiSpawn
        sinon
          vague vaut vague + 1
          ennemisVague vaut 3 + vague * 2
          spawnE vaut 180 
        fin si
      fin si

      // Mouvements et attaques des unités
      pour proI de 0 à NB_UNITES - 1
        si uAct[proI] = 1 alors
          proCible vaut -1
          proMin vaut 9999
          pour proJ de 0 à NB_UNITES - 1
            si uAct[proJ] = 1 et uCamp[proJ] <> uCamp[proI] alors
              proD vaut absolue(uX[proJ] - uX[proI])
              si proD < proMin alors
                proMin vaut proD
                proCible vaut proJ
              fin si
            fin si
          fin pour
          si uCamp[proI] = 0 alors
            proDist vaut X_BASE_E - uX[proI]
          sinon
            proDist vaut uX[proI] - X_BASE_J
          fin si

          si proCible >= 0 et proMin <= porteeUnite(uGenre[proI]) alors
            uCD[proI] vaut uCD[proI] - 1
            si uCD[proI] <= 0 alors
              uCD[proI] vaut cadenceUnite(uGenre[proI])
              appelle creerProjectile(uCamp[proI], uGenre[proI], uX[proI], uY[proI] - 10, proCible, degatUnite(uGenre[proI]))
            fin si
          sinon si proDist <= porteeUnite(uGenre[proI]) alors
            uCD[proI] vaut uCD[proI] - 1
            si uCD[proI] <= 0 alors
              uCD[proI] vaut cadenceUnite(uGenre[proI])
              si uCamp[proI] = 0 alors
                appelle creerProjectile(0, uGenre[proI], uX[proI], uY[proI] - 10, -1, degatUnite(uGenre[proI]))
              sinon
                appelle creerProjectile(1, uGenre[proI], uX[proI], uY[proI] - 10, -2, degatUnite(uGenre[proI]))
              fin si
            fin si
          sinon
            si uCamp[proI] = 0 alors
              uX[proI] vaut uX[proI] + vitesseUnite(uGenre[proI]) / 10
            sinon
              uX[proI] vaut uX[proI] - vitesseUnite(uGenre[proI]) / 10
            fin si
          fin si
        fin si
      fin pour

      // Gestion de la physique des projectiles
      pour proI de 0 à NB_PROJ - 1
        si pAct[proI] = 1 alors
          cibX vaut 0
          cibY vaut 0
          cibleValide vaut 1

          si pCible[proI] >= 0 alors
            si uAct[pCible[proI]] = 1 alors
              cibX vaut uX[pCible[proI]]
              cibY vaut uY[pCible[proI]] - 10
            sinon
              cibleValide vaut 0
            fin si
          sinon si pCible[proI] = -1 alors
            cibX vaut X_BASE_E - 20
            cibY vaut AXE_Y - 40
          sinon si pCible[proI] = -2 alors
            cibX vaut X_BASE_J + 20
            cibY vaut AXE_Y - 40
          fin si

          si cibleValide = 1 alors
            distX vaut cibX - pX[proI]
            distY vaut cibY - pY[proI]
            distTotale vaut absolue(distX) + absolue(distY)
            
            si distTotale < 20 alors
              pAct[proI] vaut 0
              si pCible[proI] >= 0 alors
                uPV[pCible[proI]] vaut uPV[pCible[proI]] - pDegat[proI]
                si uPV[pCible[proI]] <= 0 alors
                  uAct[pCible[proI]] vaut 0
                  si pCamp[proI] = 0 alors
                    pieces vaut pieces + 7 + coutUnite(uGenre[pCible[proI]]) / 14
                  fin si
                fin si
              sinon si pCible[proI] = -1 alors
                baseE vaut baseE - pDegat[proI]
              sinon si pCible[proI] = -2 alors
                baseJ vaut baseJ - pDegat[proI]
              fin si
            sinon
              pX[proI] vaut pX[proI] + (distX * 25) / distTotale
              pY[proI] vaut pY[proI] + (distY * 25) / distTotale
            fin si
          sinon
            pAct[proI] vaut 0
          fin si
        fin si
      fin pour

      si baseE <= 0 alors
        baseE vaut 0
        etat vaut 1
      fin si
      si baseJ <= 0 alors
        baseJ vaut 0
        etat vaut 2
      fin si
    fin si

    appelle dessinerTout()
    pause 60
  fin tant que
fin processus


@ Programme principal
appelle nouvellePartie()
appelle dessinerTout()
MoteurJeu()

tant que enJeu
  interagir ecran, ["1", "2", "3", "4", "n", "p"] dans action, ptX, ptY
  si non enJeu alors
    arrête
  fin si
  si action = 0 alors
    si clique(ptX, ptY, 22, 356, 132, 112) alors
      ach1 vaut ach1 + 1
    sinon si clique(ptX, ptY, 176, 356, 132, 112) alors
      ach2 vaut ach2 + 1
    sinon si clique(ptX, ptY, 330, 356, 132, 112) alors
      ach3 vaut ach3 + 1
    sinon si clique(ptX, ptY, 484, 356, 132, 112) alors
      ach4 vaut ach4 + 1
    fin si
  sinon si action = 1 alors
    ach1 vaut ach1 + 1
  sinon si action = 2 alors
    ach2 vaut ach2 + 1
  sinon si action = 3 alors
    ach3 vaut ach3 + 1
  sinon si action = 4 alors
    ach4 vaut ach4 + 1
  sinon si action = 5 alors
    resetDemande vaut resetDemande + 1
  sinon
    enJeu vaut faux
    arrête
  fin si
fin tant que

affiche "Bataille terminée - base ennemie " + convertir_texte(arrondi(baseE)) + " / votre base " + convertir_texte(arrondi(baseJ))