from gint import *
from ion import *
from time import *
from random import randint
from sprites import *
# par Afyu pour le CPC#32

LL=396 # largeur écran
HH=224 # hauteur d'écran

Arbres=[10,35,80,135,160,220,270,300,320,340,390,410,445,480]

clr_fond=C_RGB(20,10,5)
largeur_niveau=792+396 # largeur de l'image + LL

def fill_rect(x,y,l,h,clr):
  drect(x,y,x+l,y+h,clr)

def cadre_panneau(clr_fond="transp"):
  if clr_fond != "transp":
    dclear(clr_fond)
  Qx=(LL-41-40)//18 # nombre de morceaux à placer, entre la gauche et la droite
  Rx=(LL-41-40)%18 # espace à gauche + à droite
  Qy=(HH-41-40)//18 # nombre de morceaux à placer, entre le haut et le bas
  Ry=(HH-41-40)%18 # espace en haut + en bas
  dsubimage(Rx//2,Ry//2,panneau_morceaux,1,1,41,41) # coin haut gauche
  dsubimage(Rx//2+18*Qx+41,Ry//2,panneau_morceaux,64,1,40,41) # coin haut droite
  dsubimage(Rx//2,Ry//2+18*Qy+41,panneau_morceaux,1,64,41,40) # coin bas gauche
  dsubimage(Rx//2+18*Qx+41,Ry//2+18*Qy+41,panneau_morceaux,64,64,40,40) # coin bas droite
  for k in range(Qx):
    dsubimage(Rx//2+18*k+41,Ry//2,panneau_morceaux,44,1,18,41) # morceaux du haut
    dsubimage(Rx//2+18*k+41,Ry//2+18*Qy+41,panneau_morceaux,44,63,18,41) # morceaux du bas
  for k in range(Qy):
    dsubimage(Rx//2,Ry//2+18*k+41,panneau_morceaux,1,44,41,18) # morceaux de gauche
    dsubimage(Rx//2+18*Qx+41,Ry//2+18*k+41,panneau_morceaux,63,44,41,18) # morceaux de droite

def afficher_arriere_plan():
  coeff=0.5

  dimage(0,161,sentier)
  if xJ<LL//2:
    dsubimage(0,0,fond4,0,0,396,161)
  elif xJ>largeur_niveau-LL//2:
    dsubimage(0,0,fond4,792-396,0,396,161)
  else:
    dsubimage(0,0,fond4,int(coeff*(xJ-LL//2)),0,396,161)


def afficher_arbres():
  coeff=1
  for posX in Arbres:
    if -LL*2<coeff*(2*posX+LL//2-xJ)<LL*2:
      if xJ<LL//2:
        dimage(int(coeff*2*posX),0,bouleau)
      elif xJ>largeur_niveau-LL//2:
        dimage(int(coeff*(2*posX+LL-largeur_niveau)),0,bouleau)
      else:
        dimage(int(coeff*(2*posX+LL//2-xJ)),0,bouleau)

def afficher_avant_plan():
  coeff=4
  dX=1
  dY=1
  h=30
  l=30
  for buisson in Liste_buissons:
    if xJ<LL//2:
      posX=coeff*2*buisson.x
    elif xJ>largeur_niveau-LL//2:
      posX=coeff*(LL-largeur_niveau+2*buisson.x)
    else:
      posX=coeff*(LL//2+(2*buisson.x-xJ))
    dsubimage(posX,HH-30,buisson.sprite,dX+31*buisson.NivEnvahissement,dY,l,h)


def afficher_joueur():
  if attack_low_en_cours:
    dX=1+43*(Tic//2)
    dY=259
    l=42
    h=60
  elif attack_en_cours:
    dX=1+61*((Tic//2)%3)
    dY=130+43*((Tic//2)>2)
    l=60
    h=42
  elif saut_en_cours:
    dX=1+43*(Tic//5)
    dY=216
    l=42
    h=42
  elif action=="move":
    dX=1+43*(Tic//5)
    dY=1
    l=42
    h=42
  else:
    #if action==None: # mode idle
    dX=1+43*(Tic//5)
    dY=44
    l=42
    h=42

  if immunite>0 and (Tic//5)%3==0: # 1 image sur 3 (2 images sur 6) # silhouette blanche
    dX=87
    dY=87
    l=42
    h=42

  if xJ<LL//2:
    posX=xJ
  elif xJ>largeur_niveau-LL//2:
    posX=LL-largeur_niveau+xJ
  else:
    posX=LL//2
  dsubimage(posX-20*(attack_en_cours and Direction==-1 and not(immunite>0 and (Tic//5)%3==0)),int(yJ),corbeau_walk,dX,dY+321*(Direction==-1),l,h)

def effacer_joueur():
  if xJ<LL//2:
    fill_rect(xJ,int(yJ),42,42,clr_fond)
  elif xJ>largeur_niveau-LL//2:
    fill_rect(LL-largeur_niveau+xJ,int(yJ),42,42,clr_fond)
  else:
    fill_rect(LL//2,int(yJ),42,42,clr_fond)


def afficher_vie():
  for i in range(2,Vie_max+1,2):
    if i<=Vie:
      dsubimage(10*i,20,points_de_vie,1,22,20,20) # feuille entière
    elif i==Vie+1:
      dsubimage(10*i,20,points_de_vie,22,22,20,20) # feuille à moitié mangée
    elif i>Vie:
      dsubimage(10*i,20,points_de_vie,43,22,20,20) # feuille mangée
  # affichage des objets récupérés
  for i in range(Objets_recuperes.count("Atq+")):
    dsubimage(20+25*i,45,objets_precieux,22,1,20,20) # plumes d'attaque
  for i in range(Objets_recuperes.count("CleB")):
    dsubimage(20+25*i,65,objets_precieux,43,1,20,20) # clé du boss
  for i in range(Objets_recuperes.count("Vit+")):
    dsubimage(20+25*i,85,objets_precieux,64,1,20,20) # champignons de vitesse
  #dupdate()


class Objets:

  def __init__(self,x,y,Type,NivEnvahissement=2,contenu=""):
    self.x=x
    self.y=y
    self.Type=Type # parmi "rocher","coffre","panneau", "feuille"
    if self.Type in ("coffre","buisson"):
      self.NivEnvahissement=NivEnvahissement # maximum 4, minimum 0
      if self.Type=="coffre":
        self.contenu=contenu
    elif self.Type=="panneau":
      self.texte=NivEnvahissement
      self.lu=False
    elif self.Type=="feuille":
      self.Tic=300
    self.sprite=(objet_rocher,objet_coffre_envahi,objet_panneau,points_de_vie,(decor_fougere,decor_champi)[randint(0,1)])[("rocher","coffre","panneau","feuille","buisson").index(self.Type)]

  def afficher(self):
    dX=1+41*2*(self.Type=="rocher")
    dY=1
    h=40-10*(self.Type=="buisson")
    l=40-10*(self.Type=="buisson")
    if xJ<LL//2:
      posX=self.x
    elif xJ>largeur_niveau-LL//2:
      posX=LL-largeur_niveau+self.x
    else:
      posX=LL//2+(self.x-xJ)
    if self.Type=="coffre":
      dsubimage(posX,self.y,self.sprite,dX+41*(4-self.NivEnvahissement),dY,l,h)
      if self.contenu!="" and self.NivEnvahissement==0:
        dsubimage(posX+10,self.y+5,objets_precieux,dX+21*["Vie+","Atq+","CleB","Vit+"].index(self.contenu),dY,20,20)
        dupdate()
        sleep(2)
        Objets_recuperes.append(self.contenu)
        Vie_max=10+2*Objets_recuperes.count("Vie+")
        Attaque=5+3*Objets_recuperes.count("Atq+")
        self.contenu=""
    elif self.Type=="feuille":
      if self.Tic>100 or (self.Tic//10)%2==0:
        dsubimage(posX,self.y,self.sprite,dX+21*3,1,20,20)
    elif self.Type=="panneau":
      dsubimage(posX,self.y,self.sprite,dX+41*(2-self.lu),dY,l,h)
    else:
      dsubimage(posX,self.y,self.sprite,dX,dY,l,h)

  def afficher_panneau(self):
    cadre_panneau(clr_fond)
    for k in range(len(self.texte)):
      dtext(60,60+20*k,C_RGB(25,20,5),self.texte[k]) # en marron
    dtext(150,HH-10-41-10,C_RGB(30,15,0),"-- EXE pour continuer --") # en orange
    dupdate()
    self.lu=True
    while not keydown(KEY_EXE):1

class Ennemis:

  def __init__(self,x,y,vie,atq,Type=-1):
    self.x=x
    self.y=y
    self.vie=vie
    self.direction=2*randint(0,1)-1
    self.atq=atq
    self.xi=x # position initiale
    self.tic=0
    self.ticHumeur=0
    self.Humeur="neutral" # parmi "happy", "sad", "neutral" : influence l'affichage du sourire et des yeux
    self.Type=(Type,randint(0,2))[Type==-1]
    self.sprite=(ennemi_arbre_1,ennemi_arbre_2,ennemi_arbre_3)[self.Type]

  def afficher(self):
    decalage=self.tic//5
    dX=1+41*decalage
    dY=1
    h=40
    l=40
    if xJ<LL//2:
      posX=self.x
    elif xJ>largeur_niveau-LL//2:
      posX=LL-largeur_niveau+self.x
    else:
      posX=LL//2+(self.x-xJ)
    dsubimage(posX,self.y,self.sprite,dX,dY,l,h)
    if self.ticHumeur>0:
      if self.Humeur == "sad":
        if self.Type==0:
          dsubimage(posX+13,self.y+13+1*(decalage in (2,5))+2*(decalage in (3,4)),self.sprite,260,15,14,5) # yeux effarés
          dsubimage(posX+13,self.y+19+1*(decalage in (2,5))+2*(decalage in (3,4)),self.sprite,260,25,14,6) # bouche qui boude
        elif self.Type==1:
          dsubimage(posX+12,self.y+15+1*(decalage in (1,4))+2*(decalage in (2,3)),self.sprite,255,15,16,6) # yeux effarés
          dsubimage(posX+12,self.y+23+1*(decalage in (1,4))+2*(decalage in (2,3)),self.sprite,255,25,16,4) # bouche qui boude
        elif self.Type==2:
          dsubimage(posX+14,self.y+16+1*(decalage in (1,4))+2*(decalage in (2,3)),self.sprite,260,15,12,7) # yeux effarés
      elif self.Humeur == "happy":
        if self.Type==0:
          dsubimage(posX+13,self.y+19+1*(decalage in (2,5))+2*(decalage in (3,4)),self.sprite,260,35,14,6) # bouche qui sourie
        elif self.Type==1:
          dsubimage(posX+12,self.y+23+1*(decalage in (1,4))+2*(decalage in (2,3)),self.sprite,255,35,16,4) # bouche qui sourie


  def effacer(self):
    h=40
    l=40
    if randint(1,5)==1: # l'ennemi lache une feuille-point de vie
      Liste_feuilles.append(Objets(self.x,self.y,"feuille"))
    #dupdate()

  def clignote(self):
    for i in range(2):
      self.effacer()
      dupdate()
      sleep(0.1)
      self.afficher()
      sleep(0.1)
      dupdate()



# Accueil
textes=(("Bienvenue dans l'aventure :","     Promenade en Foret"),\
  ("Connais-tu l'histoire de la foret des","Carpettes ?","Non ?","Eh bien moi non plus."),\
  ("Mais ce n'est pas le sujet, en fait.","Je vais te raconter l'histoire","de la foret de Brosse&Viande"),\
  ("Il y a bien longtemps, le seigneur","Brosse, avec ses cheveux coiffes en...","- enfin bref - ","etait un grand mangeur de viande."),\
  ("Il aimait se promener en foret","pour rapporter de quoi satisfaire","son tres grand appetit."),\
  ("Mais un jour, une mysterieuse","malediction s'abatit sur sa foret","preferee et... il devint chauve ! ","Ah non, c'est pas ca. Je m'egare."),\
  ("Donc, je disais : une malediction","s'abatit sur sa foret preferee et","les animaux qui y vivaient","furent transformes en creatures","hostiles et aggressives !"),\
  ("Allons voir de quoi il s'agit !","Au fait, si tu t'aventures dans cette","mysterieuse foret, tu pourrais bien","etre tranforme toi aussi...","Prends garde !"))

Liste_panneaux=[]
for k in range(len(textes)):
  #(x,texte) in [(70,textes[0]),(120,textes[1]),(250,textes[2]),(300,textes[3]),(500,textes[4]),(650,textes[5])]:
  Liste_panneaux.append(Objets(42,HH-90,"panneau",textes[k]))

for panneau in Liste_panneaux:
  panneau.afficher_panneau()
  while keydown(KEY_EXE):1



Niveau=0

while Niveau<3:
  xJ,yJ=20,170

  if Niveau==0:

    Liste_ennemis=[]
    for x in [200,820,870,900,950,990,1050,1100,1150]:#[LL+10,LL+150,LL+280,LL+320,LL+480,LL+510,LL+660,LL+700,LL+840,LL+990,LL+1200,LL+1350,LL+1480,LL+1540,LL+1600,LL+1720]:
      Liste_ennemis.append(Ennemis(x,HH-50,20+5*(x>1000),1)) # x,y,vie,atq

    Liste_rochers=[]
    for x in [570]:#LL+250,LL+400]:
      Liste_rochers.append(Objets(x,HH-70,"rocher")) # x,y,type[,niveau d'envahissement])

    Liste_coffres=[]
    for (x,NivEnv,Contenu) in [(330,0,""),(380,2,"Vie+"),(430,4,"Atq+")]:
      Liste_coffres.append(Objets(x,HH-80,"coffre",NivEnv,Contenu))

    Liste_buissons=[]
    for x in [10,40,65,80,105,130,145,160,170,200,215,240,265,280,310,320,350,380,400]: # maximum 420 ? 396 ?
      Liste_buissons.append(Objets(x,HH-30,"buisson",randint(0,1)))


    Liste_feuilles=[]

    textes=(("Ceci est un panneau et son texte","s'affiche automatiquement","lorsque tu passes devant.","Utilise les fleches pour te deplacer","vers la gauche ou vers la droite."),\
      ("Oh, une creature hostile !","Appuie sur SHIFT pour attaquer."),\
      ("Si l'ennemi te touche, alors tu perds","un peu de vie. Ton niveau de vie actuel","est affiche en haut a gauche.","Les ennemis laissent parfois tomber","une feuille de vie une fois elimines."),\
      ("Les coffres sont parfois pleins,","parfois vides,","parfois entoures de lianes","qu'il faut casser en attaquant."),\
      ("Un rocher bloque le passage !","Un appui sur ALPHA permet de sauter."),\
      ("Lors d'un saut, on peut attaquer","vers le bas.","Pendant la descente, il faut appuyer","sur BAS et SHIFT en meme temps."),\
      ("Elimine tous les ennemis","puis va au bout du chemin","pour t'aventurer plus profondement","dans la foret. Brrr"))


    Liste_panneaux=[]
    for (x,texte) in [(70,textes[0]),(120,textes[1]),(250,textes[2]),(300,textes[3]),(500,textes[4]),(650,textes[5]),(750,textes[6])]:
      Liste_panneaux.append(Objets(x,HH-90,"panneau",texte))


  if Niveau==1:

    Liste_ennemis=[]
    for x in [80,120,200,350,400,450,700,720,740,820,950,990,1050,1100,1150]:#[LL+10,LL+150,LL+280,LL+320,LL+480,LL+510,LL+660,LL+700,LL+840,LL+990,LL+1200,LL+1350,LL+1480,LL+1540,LL+1600,LL+1720]:
      Liste_ennemis.append(Ennemis(x,HH-50,20+5*(x//100),1)) # x,y,vie,atq

    Liste_rochers=[]
    for x in [260,510,600,880]:#LL+250,LL+400]:
      Liste_rochers.append(Objets(x,HH-70,"rocher")) # x,y,type[,niveau d'envahissement])

    Liste_coffres=[]
    for (x,NivEnv,Contenu) in [(30,0,""),(160,3,"Vie+"),(430,4,"Atq+"),(550,2,"Atq+"),(710,4,"Atq+"),(1020,2,"Vie+")]:
      Liste_coffres.append(Objets(x,HH-80,"coffre",NivEnv,Contenu))

    Liste_buissons=[]
    for x in [10,40,65,80,105,130,145,160,170,200,215,240,265,280,310,320,350,380,400]: # maximum 420 ? 396 ?
      Liste_buissons.append(Objets(x,HH-30,"buisson",randint(0,1)))


    Liste_feuilles=[]

    textes=(("Il n'y avait rien de bien","interessant ici. Poursuivons.","Brr"),(""))


    Liste_panneaux=[]
    for (x,texte) in [(1130,textes[0])]:
      Liste_panneaux.append(Objets(x,HH-90,"panneau",texte))

  if Niveau==2:

    Liste_ennemis=[]
    for x in [100+50*randint(1,20) for k in range(12)]:#[LL+10,LL+150,LL+280,LL+320,LL+480,LL+510,LL+660,LL+700,LL+840,LL+990,LL+1200,LL+1350,LL+1480,LL+1540,LL+1600,LL+1720]:
      Liste_ennemis.append(Ennemis(x,HH-50,20+5*(x//100)+50*(x>1100),1)) # x,y,vie,atq

    Liste_rochers=[]
    for x in [200+80*randint(1,12) for k in range(5)]:#LL+250,LL+400]:
      Liste_rochers.append(Objets(x,HH-70,"rocher")) # x,y,type[,niveau d'envahissement])

    Liste_coffres=[]
    for (x,NivEnv,Contenu) in [(30,0,""),(160,3,"Vie+"),(230,4,""),(380,2,""),(430,4,"Atq+"),(550,2,"Atq+"),(610,4,"Atq+"),(710,4,"Atq+"),(830,2,"Vie+"),(1020,2,"Vie+")]:
      Liste_coffres.append(Objets(x,HH-80,"coffre",NivEnv,Contenu))

    Liste_buissons=[]
    for x in [10,40,65,80,105,130,145,160,170,200,215,240,265,280,310,320,350,380,400]: # maximum 420 ? 396 ?
      Liste_buissons.append(Objets(x,HH-30,"buisson",randint(0,1)))


    Liste_feuilles=[]

    textes=(("Decidement, les monstres sont coriaces","par ici.","C'etait le dernier niveau,","pour le moment.","Merci d'avoir joue !","Brr"),(""))


    Liste_panneaux=[]
    for (x,texte) in [(1130,textes[0])]:
      Liste_panneaux.append(Objets(x,HH-90,"panneau",texte))


  Objets_recuperes=[]
  Vie=10
  Direction=1
  chg=1
  immunite=0
  Tic=0
  action=None
  saut_en_cours=False
  mode_montee=False
  hauteur_initiale=0
  delta_hauteur=0
  attack_en_cours=False
  attack_low_en_cours=False


  while 1:
    Vie_max=10+2*Objets_recuperes.count("Vie+")
    Attaque=5+6*Objets_recuperes.count("Atq+") # puissance d'attaque initiale

    action=None
    dclear(clr_fond)
    if chg:
      action="move"

      xJ=max(5,min(xJ+2*chg,largeur_niveau-15))
      Direction=chg

      for panneau in Liste_panneaux:
        if xJ==panneau.x and not panneau.lu:
          panneau.afficher_panneau()

      for rocher in Liste_rochers:
        if -40<rocher.x-xJ<42 and rocher.y-yJ<40-12: # si on se cogne contre un rocher
          xJ=(rocher.x-42,rocher.x+42)[Direction!=1]
      if not saut_en_cours:
        saut_en_cours=True
        mode_montee=False
        appui_permis=False
        hauteur_initiale=(170-yJ)//2
        delta_hauteur=0.8
        #yJ=170
        for rocher in Liste_rochers:
          if -40<rocher.x-xJ<42: # si on est sur un rocher, sans dépasser le bord du rocher, alors on reste sur le rocher. logique.
            yJ=rocher.y-42+12
            saut_en_cours=False


      for feuille in Liste_feuilles:
        if -40<feuille.x-xJ<20 and feuille.y-yJ<40: # si on marche sur une feuille-point de vie
          Liste_feuilles.remove(feuille)
          Vie=min(Vie_max,Vie+2)

    else:
      action=None

    afficher_arriere_plan()
    afficher_arbres()
    afficher_vie()
    chg=keydown(KEY_RIGHT)-keydown(KEY_LEFT)


    for coffre in Liste_coffres:
      if -LL < coffre.x-xJ < LL: # si l'objet est dans la zone affichée à l'écran
        coffre.afficher()

    for rocher in Liste_rochers:
      if -LL < rocher.x-xJ < LL: # si l'objet est dans la zone affichée à l'écran
        rocher.afficher()

    for panneau in Liste_panneaux:
      if -LL < panneau.x-xJ < LL: # si le panneau est dans la zone affichée à l'écran
        panneau.afficher()

    for feuille in Liste_feuilles:
      if -LL < feuille.x-xJ < LL: # si la feuille est dans la zone affichée à l'écran
        feuille.afficher()

    for ennemi in Liste_ennemis:
      if -LL-30 < ennemi.x-xJ < LL+30: # on actualise la position que des ennemis qui sont assez proches du joueur
        ennemi.tic=(ennemi.tic+1)%30
        ennemi.ticHumeur=max(0,ennemi.ticHumeur-1)
        if ennemi.ticHumeur == 0:
          ennemi.Humeur="neutral"
        if not ennemi.xi-50<=ennemi.x<=ennemi.xi+50: # si on est hors du chemin de ronde
          ennemi.direction=(ennemi.x<ennemi.xi-50)-(ennemi.x>ennemi.xi+50)#demi_tour=(randint(0,10)==0)

        ennemi.x += ennemi.direction
        ennemi.afficher()
        if -40<ennemi.x-xJ<42 and ennemi.y-yJ<40 and immunite<1: # touché par un ennemi
          action="hurt"
          Vie-=ennemi.atq
          ennemi.Humeur="happy"
          ennemi.ticHumeur=100
          immunite=50
          xJ += 6*((ennemi.x<xJ)-(ennemi.x>xJ))#10*ennemi.direction # le joueur est repoussé
          for rocher in Liste_rochers:
            if -40<rocher.x-xJ<42 and rocher.y-yJ<40-12: # si on est repoussé DANS un rocher
              xJ=(rocher.x-42,rocher.x+42)[ennemi.direction!=1]



    if keydown(KEY_SHIFT): # on attaque !
      if saut_en_cours and keydown(KEY_DOWN) and not attack_en_cours and not attack_low_en_cours:
        attack_low_en_cours=True
        Tic=0
        for ennemi in Liste_ennemis:
          if -40<ennemi.x-xJ<42 and -10<=ennemi.y-(yJ+40)<20: # attaque qui touche sa cible

            ennemi.vie-=int(3/5*Attaque)
            ennemi.Humeur="sad"
            ennemi.ticHumeur=100
            hauteur_initiale=30 # rebond sur l'ennemi en l'attaquant par au-dessus !
            delta_hauteur=30
            mode_montee=True
            if ennemi.vie<=0:
              ennemi.effacer()
              Liste_ennemis.remove(ennemi)
      elif not attack_en_cours:
        attack_en_cours=True
        Tic=0
        for ennemi in Liste_ennemis:
          if -15+45*Direction<ennemi.x-xJ<15+45*Direction and -40<ennemi.y-yJ<20: # attaque qui touche sa cible
            ennemi.x += 10*Direction
            ennemi.vie-=Attaque
            ennemi.Humeur="sad"
            ennemi.ticHumeur=100
            if ennemi.vie<=0:
              ennemi.effacer()
              Liste_ennemis.remove(ennemi)

        for coffre in Liste_coffres:
          if -15+45*Direction<coffre.x-xJ<15+45*Direction:# and -40<coffre.y-yJ<20: # attaque qui touche sa cible
            coffre.NivEnvahissement = max(0,coffre.NivEnvahissement-1)
            coffre.afficher()

    if keydown(KEY_ALPHA) and not saut_en_cours: # on saute !
      saut_en_cours=True
      mode_montee=True
      appui_permis=True
      hauteur_initiale=0
    if keydown(KEY_ALPHA) and saut_en_cours and appui_permis and hauteur_initiale<40:
      hauteur_initiale+=4
      delta_hauteur=hauteur_initiale
    if saut_en_cours and appui_permis and hauteur_initiale>=40:
      appui_permis=False
      delta_hauteur=hauteur_initiale
    if saut_en_cours and appui_permis and not keydown(KEY_ALPHA):
      appui_permis=False
      delta_hauteur=hauteur_initiale

    if saut_en_cours and appui_permis:
      yJ=170-2*hauteur_initiale+delta_hauteur

    if saut_en_cours and not appui_permis:
      if mode_montee:
        if delta_hauteur>28:
          delta_hauteur*=0.95
        elif delta_hauteur>15:
          delta_hauteur*=0.85
        elif delta_hauteur>6:
          delta_hauteur*=0.8
        else:
          delta_hauteur*=0.8
          mode_montee=False
      else: # lors de la descente
        if delta_hauteur>28:
          delta_hauteur/=0.9
        elif delta_hauteur>15:
          delta_hauteur/=0.85
        else:
          delta_hauteur/=0.8

      if delta_hauteur>2*hauteur_initiale:
        saut_en_cours=False
        yJ=170
      else:
        yJ=170-2*hauteur_initiale+delta_hauteur

      for rocher in Liste_rochers:
        if -40<rocher.x-xJ<42 and rocher.y-yJ<30: # si on se cogne contre un rocher, en descendant
          yJ=rocher.y-42+12

    if immunite>0:
      immunite-=1

    afficher_joueur()
    afficher_avant_plan()
    afficher_vie()
    dupdate()
    Tic=(Tic+1)%30
    if Tic>11:
      attack_en_cours=False
      attack_low_en_cours=False
    for ennemi in Liste_ennemis:
      ennemi.ticHumeur=max(0,ennemi.ticHumeur-1)
    for feuille in Liste_feuilles:
      feuille.Tic-=1
      if feuille.Tic==0:
        Liste_feuilles.remove(feuille)

    if Vie<=0:
      break
    if Liste_ennemis==[] and xJ>792+396-30: # niveau terminé
      Niveau+=1
      break