import processing.core.*; 
import processing.data.*; 
import processing.event.*; 
import processing.opengl.*; 

import processing.sound.*; 
import processing.video.*; 

import java.util.HashMap; 
import java.util.ArrayList; 
import java.io.File; 
import java.io.BufferedReader; 
import java.io.PrintWriter; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.io.IOException; 

public class Rising__Beta_1_0 extends PApplet {

// jeu lézard

/*
version 2.6
 
mettre un delai entre les saut pour rendre la machinque moin poluante
ajuster le mangerOn, il est pas régulier
mettre la mort dans la chute en bas / probleme de blocage quand touche les bords ecran
ajuster le saut avec le deplacement map vers le haut

satiete : beug quand mange perfois +10 satiete au lieu de 1 ou 3
rendre le son progressif 0.1


ajouter arbre / branche


son : calibrer les sons
ajouter des timeurs


*/


       // importer la library sound processing  ==> a l'air de creer des lags gratuitement


SoundFile sonV;                  // ensemble des pistes sons
SoundFile sonP;
SoundFile sonOver;
SoundFile sonMazon;
SoundFile sonSaut;
SoundFile sonSatiete;
SoundFile sonForet;
SoundFile sonAmbiance;
SoundFile sonCascade;

PFont fontL;
PFont fontS;

Movie intro;
Movie bisous;

page1 P1;
Map niveau1;                      // objet Map, niveau 1
Personnage liz;                   // objet Personnage, lezard
Satiete life;                     // objet satiete, barre de vie
Score point;

boolean introOn = true;
boolean bisousOn;
float time;
float startIntro, startBisous;
int page;

public void setup() {
  //fullScreen();
                  // ecran 3 : 4
  background( 0 );                 // dessine un fond noir/gris
  //pixelDensity(1);               // gerer la densiter pixels
  frameRate(30);                   // 30 image par segonde
  noCursor();
  
  niveau1 = new Map ( 1 , (height/15) * 100 , width - (height/15 )*100, (height/15 ) * 20 + 450 , height - (height/15 )*14 );   // définition Map : ( droite / gauche / haut / bas )// ( 48*100 | width - 48*100 | 48*20 + hautSup | height - 48*20 )
  liz = new Personnage();                              // définition personnage
  life = new Satiete();                                // defintion satiete
  point = new Score();
  
  fontL = createFont("Cwebl.ttf", 24 );
  fontS = createFont("Cwebs.ttf", 24 );
  
  P1 = new page1();
  
  sonForet = new SoundFile(this, "zic foret.mp3");     // ensemble chargement des fichier son
  sonAmbiance = new SoundFile(this, "ambiance oiseaux.mp3");
  

  intro = new Movie (this, "introFinal.mp4" );
  bisous = new Movie( this, "bisousFinalb.mp4" );
  
  sonSaut = new SoundFile(this, "son saut.mp3" );
  sonV = new SoundFile(this, "vers.mp3");
  sonP = new SoundFile(this, "pap.mp3" );
  sonOver = new SoundFile(this, "gameover.mp3" );
  sonMazon = new SoundFile(this, "son mazone.mp3" );
  sonSatiete = new SoundFile(this, "satiete.mp3");
  sonCascade = new SoundFile(this, "cascade.mp3" );
}

public void movieEvent(Movie m) {
  m.read();
}

public void draw() {                          // fonction principale, en boucle
  time = millis();                     // horloge interne au programme
  
  
  if ( page == 0 ) {
    if ( introOn == true ) {
      intro.play();
      startIntro = time;
      introOn = false;
    }
    push();
    imageMode(CENTER);
    image(intro, width/2, height/2 );
    pop();
    if ( time > 77700 + startIntro) {
      page = 1;
      P1.resetOn = false;
      intro.stop();
      sonForet.loop();
      sonAmbiance.loop();
    }
  }
  
  if ( page == 1) {
    P1.display();
    P1.update();
  }
  
  if ( page == 2 ) {                   // charger la page 1 : niveau1 avec personnage
    niveau1.display();                   // fonction affichage de la Map
    liz.display();                       // fonction affichage Personnage
    life.display();                      // fonction affichage Satiete
    point.display();
    liz.deplacement( niveau1 , liz, life);     // fonction deplacement Personnage
    point.update();
    push();
    fill(255);
    textSize(15 );
    //text ( "liz pos : " + liz.pos + " vit : " + liz.vit + "etat : " + liz.etat + " Saut : " + liz.sautOn + "/ map posX : " + (niveau1.pap[0].posX - 1 ) + " posY : " + niveau1.pap[0].posY, 20, 30 );
    pop();
  }
  
  if ( page == 3 ) {
    if ( !bisousOn ) {
    sonForet.stop();
    sonAmbiance.stop();
    sonSatiete.stop();
    bisous.play();
    startBisous = time;
    bisousOn = true;
    }
    push();
    imageMode(CENTER);
    image(bisous, width/2, height/2 );
    pop();
    
    if ( time > startBisous && time < startBisous + 13500 ) {
      push();
      imageMode(CENTER);
      image( point.youLived , width/2, height/2 );
      textFont(fontL);
      textAlign( LEFT, BOTTOM );
      textSize(77);
      noStroke();
      fill( 0xffffff66);  //, ( time - endFond ) / 20 );
      text( PApplet.parseInt (point.end/100)  , width/2 + 114 , height/2 + 26 );
      pop();
    }    

    
    if ( time > 41900 + startBisous ) {
      bisous.stop();
      introOn = true;
      page = 0;
    }
  }
  
 // println( "liz.vit : " + liz.vit +" liz.fallOn : " + liz.fallOn +  " liz.sautOn : " + liz.sautOn ); //+ " liz.up : " + liz.up + " liz.leftLock : " + liz.leftLock +" / lize.etat() : " + liz.etat );
 // println(liz.onArbre ) ;          // affiche le contenue dans la console
}


public void keyPressed() {              // fonction lue si touche clavier pressée
  if ( page == 2 ) {             // touche pour la page 1
    liz.PkeyPressed();             // touche pour le Presonnage
  }
  if ( page == 1 ) {
   if ( keyCode == 32 ) {
    page = 2;
    liz.reset();
   }
  }
  if ( page == 0) {
    if ( keyCode == 32 ) {
      page = 1;
      intro.stop();
      sonForet.loop();
      sonAmbiance.loop();
      P1.resetOn = false;
    }
  }
  if ( page == 3 ) {
    if ( keyCode == 32 ) {
      page = 2;
      liz.reset();
    }
  }
}

public void keyReleased() {   
  liz.PkeyReleased();        
}
class Pap {
  
  
  String[] papNames = { "fly1.png", "fly2.png" };
  PImage[] animePap = new PImage[ papNames.length ];
  int frame = 0;
  int frameMin = 0;
  int frameMax = 1;
  
  float posX, posY;
  float larg, haut;
  
  PVector poss, hitBox;
  PVector pos;
  int i;
  float sens = 1;
  float sense;
  float papX = 70;
  
  boolean actif = true, dead = false;
  boolean getHp;

  float temp;
  float vitesse, tempoA;
  
  
 Pap( float pos_X, float pos_Y ) {
    
    
    
    posX = pos_X;
    posY = pos_Y;
    pos = new PVector ( posX, posY );
    
    larg = 12;
    haut = 12;
    hitBox = new PVector ( larg, haut );
    vitesse = 100;
    temp = random ( 100, 500 );
    tempoA = 40;
    sense = random ( - 1, 1 );
    vitesse = random ( 140, 400 );
    if (sense < 0 ) {
      sens = -1;
    } else sens = 1;
    papX = random ( 30, 200 );
    
    poss = new PVector ( papX, 0);
    
    for ( int i = 0; i < papNames.length; i ++ ) {
      String papName = papNames[i];
      animePap[i] = loadImage(papName);
    }
  }
 
 public void display() {
    
    if ( !dead ) {
      if ( frame < frameMin || frame >frameMax ) {
        frame = frameMin;
      }
      if ( time > temp + tempoA ) {
        temp = time;
        frame++;
        if ( frame < frameMin || frame > frameMax ) {
          frame = frameMin;
        }
      }
      push();
      imageMode( CENTER );
      //if ( !liz.mangeOn ) {
        image(animePap[ frame ], posX + poss.x , posY + poss.y );
      //}
      pop();
    }
    
    
    /*
      push();
      rectMode(CENTER);
      noStroke();
      fill(0, 200, 0);
      ellipse(posX + poss.x, posY + poss.y, 3, 3);
      stroke( 0 );
      fill( 170, 30, 30, 100 );
      rect( posX + poss.x , posY + poss.y , larg, haut );
      pop();
      */
      
  }
  
  //--------------
  
  public void mouvement() {
    
   i++;
   if ( ( sin(poss.heading()) * sin(poss.heading()) ) < 0.18f ) { 
     i++;
     poss.rotate(sens * PI/vitesse);
   }
   if ( ( sin(poss.heading()) * sin(poss.heading()) ) < 0.1f ) { 
     i++;
     poss.rotate(sens * PI/vitesse);
     i++;
     poss.rotate(sens * PI/vitesse);
   }
   poss.rotate(sens * PI/vitesse);
   poss.setMag( papX * sin(poss.heading()) * sin(poss.heading()) );

   if ( i >= vitesse ) {
      i = 0;
      sens = sens * -1;
      poss.rotate(PI);
    }
  }
  
  //--------------
  
  public void update( Map niveau) {
   pos.x = 0;
   pos.y = 0;
   
   posX +=niveau.move.x;
   posY +=niveau.move.y;

   mouvement();
   pos.x = posX + poss.x;
   pos.y = posY + poss.y;
  }
  
  //--------------
  
  public void manger( PVector pos, PVector hitBox ) {   //// revient a collision peut faire plus simple
    
    if ( pos.x + hitBox.x/2 > posX + poss.x - larg/2 && pos.x - hitBox.x/2 < posX + poss.x + larg/2 && pos.y - hitBox.y/2 > posY + poss.y - hitBox.y && pos.y + hitBox.y/2 < posY + poss.y + haut + hitBox.y ) {
      mort();
    }
    if ( pos.x - hitBox.x/2 > posX + poss.x + larg/2 && pos.x - hitBox.x/2 < posX + poss.x + larg/2 && pos.y - hitBox.y/2 > posY + poss.y - hitBox.y && pos.y + hitBox.y/2 < posY + poss.y + haut + hitBox.y ) {
      mort();
    }
    if ( pos.y + hitBox.y/2 > posY + poss.y && pos.y + hitBox.y/2 < posY + poss.y + haut/2 && pos.x - hitBox.x/2 > posX + poss.x - hitBox.x && pos.x + hitBox.x /2 < posX + poss.x + larg + hitBox.x) {
      mort();
    }
    if ( pos.y - hitBox.y/2 > posY + poss.y + haut/2 && pos.y - hitBox.y/2 < posY + poss.y + haut && pos.x - hitBox.x/2 > posX + poss.x - hitBox.x && pos.x + hitBox.x /2 < posX + poss.x + larg + hitBox.x) {
      mort();
    }
    
  }

  public void mort() {
    if ( actif ) {
      if ( !dead ) {
        actif = false;
        liz.mangeOn = true;
        dead = true;
        sonP.play();
        if ( dead && liz.mangeOn) { 
          if ( !getHp ) {
            life.satiety+= 3;
            getHp = true;
          }
        }
      }
    }
  }
  
  
  
}
  
 
class Parrot {

  // fonction display / animation / vitesse animation /  update /mouvement / variation mouvement / collision / mangerpap( sur pap )  / activer:desactiver

  String[] parrot1NamesL = { "parLeft1.png" , "parLeft3.png", "parLeft2.png" };
  String[] parrot1NamesR = { "parRight1.png"  , "parRight3.png" , "parRight2.png"};
  String[] parrot2NamesL = { "parLeft1bis.png" , "parLeft3bis.png", "parLeft2bis.png" };
  String[] parrot2NamesR = { "parRight1bis.png"  , "parRight3bis.png" , "parRight2bis.png"};
  String[] parrot3NamesL = { "conurLeft3.png" , "conurLeft1.png", "conurLeft2.png" };
  String[] parrot3NamesR = { "conurRight3.png"  , "conurRight1.png" , "conurRight2.png"};
  PImage[] animeParrot1L= new PImage[parrot1NamesL.length];
  PImage[] animeParrot1R= new PImage[parrot1NamesR.length];
  PImage[] animeParrot2L= new PImage[parrot2NamesL.length];
  PImage[] animeParrot2R= new PImage[parrot2NamesR.length];
  PImage[] animeParrot3L= new PImage[parrot3NamesL.length];
  PImage[] animeParrot3R= new PImage[parrot3NamesR.length];
  
  int type;
  int frame = 0;
  int frameMin = 0;
  int frameMax = 2;
  
  float posX, posY;
  float larg, haut;
  
  PVector poss, centerImage;
  
  float perroX = 250;
  int i; 
  float g;
  int n = 1;
  float sens = 1;
  float vitesse = 350;
  
  boolean actif = false, dead = false;;
  
  
  float temp;
  float tempo, tempoA;
  float start, end;
  boolean vole, right;
  boolean mangerOn;
  
  Parrot( float pos_X, float pos_Y , int typ ) {
    
    
    type = typ;

    
    if ( type == 3 ) {
      perroX = 80;
      posX = pos_X + 20;
      posY = pos_Y - 650;
    }
    if ( type == 1 || type == 2 ) {
      posX = pos_X;
      posY = pos_Y - 650;
    }
    
    poss = new PVector ( perroX, 0);
    if ( type == 1 || type == 2 ) { 
      centerImage = new PVector(19, -13);
    }
    if ( type == 3 ) {
      centerImage = new PVector(0, 9);
    }
    
    vole = false;
    
    larg = 20;
    haut = 20;
    
    tempo = 1000;
    tempo = (random(1 , 10)* 1000);
    start = 0;
    end = time + (random(1 , 10)* 1000);
    tempoA = 80;
    
    if ( type == 1 ) {
      for ( int i = 0; i < parrot1NamesL.length; i ++ ) {
      String parrotName = parrot1NamesL[i];
      animeParrot1L[i] = loadImage(parrotName);
      }
      for ( int i = 0; i < parrot1NamesR.length; i ++ ) {
      String parrotName = parrot1NamesR[i];
      animeParrot1R[i] = loadImage(parrotName);
      }
    }
    if ( type == 2 ) {
      for ( int i = 0; i < parrot2NamesL.length; i ++ ) {
      String parrotName = parrot2NamesL[i];
      animeParrot2L[i] = loadImage(parrotName);
      }
      for ( int i = 0; i < parrot2NamesR.length; i ++ ) {
      String parrotName = parrot2NamesR[i];
      animeParrot2R[i] = loadImage(parrotName);
      }
    }
    if ( type == 3 ) {
      for ( int i = 0; i < parrot3NamesL.length; i ++ ) {
      String parrotName = parrot3NamesL[i];
      animeParrot3L[i] = loadImage(parrotName);
      }
      for ( int i = 0; i < parrot3NamesR.length; i ++ ) {
      String parrotName = parrot3NamesR[i];
      animeParrot3R[i] = loadImage(parrotName);
      }
    }
  }
  

  public void display() {

    if ( !dead ) {

      if ( time > temp + tempoA ) {
          temp = time;
          frame += n;
      }
      
      push();
      imageMode( CENTER );
      
      if ( !right ) {
        if ( type == 1 ) {
          centerImage.x = 19;
          image(animeParrot1L[ frame ], posX + poss.x + centerImage.x , posY + poss.y + centerImage.y);
        }
        if ( type == 2 ) {
          centerImage.x = 19;
          image(animeParrot2L[ frame ], posX + poss.x + centerImage.x , posY + poss.y + centerImage.y);
        } 
        if ( type == 3 ) {
          centerImage.x = -5;
          image(animeParrot3L[ frame ], posX + poss.x + centerImage.x , posY + poss.y + centerImage.y);
        } 
      }
      if ( right ) {
        if ( type == 1 ) {
          centerImage.x = -19;
          image(animeParrot1R[ frame ], posX + poss.x + centerImage.x , posY + poss.y + centerImage.y);
        }
        if ( type == 2 ) {
          centerImage.x = -19;
          image(animeParrot2R[ frame ], posX + poss.x + centerImage.x , posY + poss.y + centerImage.y);
        }
        if ( type == 3 ) {
          centerImage.x = 5;
          image(animeParrot3R[ frame ], posX + poss.x + centerImage.x , posY + poss.y + centerImage.y);
        }
      }
      pop();
      if ( frame <= frameMin ){
        frame = frameMin;
        n = 1;
      }
      if ( frame >= frameMax ) {
        frame = frameMax;
        n = -1;
      }

    }
    /*
      push();
      rectMode(CENTER);
      noStroke();
      fill(0, 200, 0);
      ellipse(posX + poss.x, posY + poss.y, 3, 3);
      stroke( 0 );
      fill( 170, 30, 30, 100 );
      rect( posX + poss.x , posY + poss.y , larg, haut );
      pop();
      */
  }
  
  
  public void update( Map niveau) {
    
   posX +=niveau.move.x;
   posY +=niveau.move.y;
   
   if ( posX < - 300 && posX > width + 300 ) {
     actif = false;
     poss.set( perroX, 0 );
   }
   if ( posX > - 300 && posX < width + 300 ){
     actif = true;
   }
   if ( actif ) {
   
   mouvement();
   }
  }
  
  
    
  public void mouvement() {
   
    if ( time > end ) {
     vole = true;
     start = time;
     end = start + tempo;
     
    }
    
   if ( vole ) {
   if ( type == 1 || type == 2 ) { 
      i++;
      poss.rotate(sens * PI / vitesse );
      if ( (sin(poss.heading()) > 0.65f)) {
        poss.setMag ( perroX  + ( 770 * ( sin(poss.heading())*sin(poss.heading())*sin(poss.heading()))) );
      }
   }
   if ( type == 3 ) {
      i++;
      poss.rotate(sens * PI / vitesse );
      if ( (sin(poss.heading()) > 0.75f)) {
        poss.setMag ( perroX  + ( 1250 * ( sin(poss.heading())*sin(poss.heading())*sin(poss.heading())*sin(poss.heading()) * sin(poss.heading()) * sin(poss.heading()) ) ) );
      }
   }
   if ( i == vitesse ) {
     i = 0;
     sens = sens * -1;
      
    right = !right;
    vole = false;
    mangerOn = false;
   }
    
  start = time;
  end = start + tempo; 
  }
}
  
  public void collision( PVector pos, PVector hitBox ) {
    if ( pos.x + hitBox.x/2 > posX + poss.x - larg/2 && pos.x - hitBox.x/2 < posX + poss.x + larg/2 && pos.y - hitBox.y/2 > posY + poss.y - hitBox.y && pos.y + hitBox.y/2 < posY + poss.y + haut + hitBox.y ) {
      if ( !dead ) {
      if ( !liz.dead ) {
          sonOver.play();
        }
      liz.actif = false;
      liz.dead = true;
      liz.pos.x = posX + poss.x;
      liz.pos.y = posY + poss.y;
      }
    }
    if ( pos.x - hitBox.x/2 > posX + poss.x + larg/2 && pos.x - hitBox.x/2 < posX + poss.x + larg/2 && pos.y - hitBox.y/2 > posY + poss.y - hitBox.y && pos.y + hitBox.y/2 < posY + poss.y + haut + hitBox.y ) {
      if ( !dead ) {
      if ( !liz.dead ) {
          sonOver.play();
        }
      liz.actif = false;
      liz.dead = true;
      liz.pos.x = posX + poss.x;
      liz.pos.y = posY + poss.y;
      }
    }
    if ( pos.y + hitBox.y/2 > posY + poss.y && pos.y + hitBox.y/2 < posY + poss.y + haut/2 && pos.x - hitBox.x/2 > posX + poss.x - hitBox.x && pos.x + hitBox.x /2 < posX + poss.x + larg + hitBox.x) {
      if ( !dead ) {
      if ( !liz.dead ) {
          sonOver.play();
        }
      liz.actif = false;
      liz.dead = true;
      liz.pos.x = posX + poss.x;
      liz.pos.y = posY + poss.y;
      }
    }
    if ( pos.y - hitBox.y/2 > posY + poss.y + haut/2 && pos.y - hitBox.y/2 < posY + poss.y + haut && pos.x - hitBox.x/2 > posX + poss.x - hitBox.x && pos.x + hitBox.x /2 < posX + poss.x + larg + hitBox.x) {
      if ( !dead ) {
        if ( !liz.dead ) {
          sonOver.play();
        }
      liz.actif = false;
      liz.dead = true;
      liz.pos.x = posX + poss.x;
      liz.pos.y = posY + poss.y;
      }
    }
  }
public void mange( PVector pos, PVector hitBox , Pap pap) {
    if ( pos.x + hitBox.x/2 > posX + poss.x - larg/2 && pos.x - hitBox.x/2 < posX + poss.x + larg/2 && pos.y - hitBox.y/2 > posY + poss.y - hitBox.y && pos.y + hitBox.y/2 < posY + poss.y + haut + hitBox.y ) {
      if ( !pap.dead && !mangerOn) {
      pap.actif = false;
      pap.dead = true;
      sonMazon.play();
      mangerOn = true;
      }
    }
    if ( pos.x - hitBox.x/2 > posX + poss.x + larg/2 && pos.x - hitBox.x/2 < posX + poss.x + larg/2 && pos.y - hitBox.y/2 > posY + poss.y - hitBox.y && pos.y + hitBox.y/2 < posY + poss.y + haut + hitBox.y ) {
      if ( !pap.dead  && !mangerOn) {
      pap.actif = false;
      pap.dead = true;
      sonMazon.play();
      mangerOn = true;
      }
    }
    if ( pos.y + hitBox.y/2 > posY + poss.y && pos.y + hitBox.y/2 < posY + poss.y + haut/2 && pos.x - hitBox.x/2 > posX + poss.x - hitBox.x && pos.x + hitBox.x /2 < posX + poss.x + larg + hitBox.x) {
      if ( !pap.dead  && !mangerOn) {
      pap.actif = false;
      pap.dead = true;
      sonMazon.play();
      mangerOn = true;
      }
    }
    if ( pos.y - hitBox.y/2 > posY + poss.y + haut/2 && pos.y - hitBox.y/2 < posY + poss.y + haut && pos.x - hitBox.x/2 > posX + poss.x - hitBox.x && pos.x + hitBox.x /2 < posX + poss.x + larg + hitBox.x) {
      if ( !pap.dead  && !mangerOn) {
      pap.actif = false;
      pap.dead = true;
      sonMazon.play();
      mangerOn = true;
      }
    }
  }
  
}
class Personnage {
  
  
  // 0-1:normalR  2-3:normalL  4-5:rightUp 6-7:rightDown 8-9:leftUp  10-11:leftDrown 12-13:UpJump 14-15:RightJump 16-17:LeftJump 18:RightDead 19:LeftDead
  //etat : 0         1            2            3              4             5            6               7               8              9          10
  
  String[] perNames =   { "lizRight1.png", "lizRight2.png" , "lizLeft1.png", "lizLeft2.png" , "lizRightUp1.png" , "lizRightUp2.png" , "lizRightDown1.png" , "lizRightDown2.png", "lizLeftUp1.png", "lizLeftUp2.png", "lizLeftDown1.png", "lizLeftDown2.png", "lizUpJump.png", "lizUpJump.png", "lizRightJump.png", "lizRightJump.png", "lizLeftJump.png", "lizLeftJump.png", "lizRightDead.png", "lizLeftDead.png"    };
  PImage[] animePer = new PImage[ perNames.length ];          // liste des images pour le lazard au repos ( une liste de noms suivie d'une liste d'objet image );
  
  //manger : 0-1:normalR  2-3:normalL  4-5:rightUp(UpJumpRight) 6-7:rightDown  8-9:leftUp(UpJumpLeft)  10-11:leftDrown  12-13:UpJump    14-15:RightJump   16-17: LeftJump    18:normalR   19:normalL
  //etat :     0             1             2                         3               4                        5               6                7                  8            9              10
  
  String[] mangeNames = { "lizRight3.png", "lizRight4.png" , "lizLeft3.png", "lizLeft4.png" , "lizRightUp3.png" , "lizRightUp4.png" , "lizRightDown3.png" , "lizRightDown4.png", "lizLeftUp3.png", "lizLeftUp4.png", "lizLeftDown3.png", "lizLeftDown4.png", "lizRightUp3.png", "lizRightUp4.png", "lizRightJump3.png", "lizRightJump4.png", "lizLeftJump3.png", "lizLeftJump4.png", "lizRight3.png", "lizLeft4.png"          };
  PImage[] animeMange = new PImage[ mangeNames.length ];      // liste des images pour le lezard entrain de manger ( une liste de noms suivie d'une liste d'objet image );
  
  int frame = 0;                                              // variable pour selectionner l'image a afficher;
  
  PVector pos, centerImage, hitBox;                        // vecteur pour la position (centre) du personnage | vecteur pour le centre de l'image a afficher(centre) | Vecteur pour la taille de la hitBox
  PVector vit;                                                // Vecteur vitesse pour gerer le mouvement du personnage
  PVector gravite;                                            // Vecteur de gravité ( force appiliquer au vecteur vitesse ) 
  float hautHit = 15;                                         // hauteur de la hitBox
  float largHit = 36;                                         // largeur de la hitBox
  
  boolean left, right, up, down, space;                       // interrupter pour les touches claviers
  boolean mangeOn, sautOn, fallOn, rightLock, leftLock, dead, onArbre; // interrupter pour détecter l'état du personnage
  boolean actif = true, graviteOn = true;                     // interrupter On/Off gobale | interrupter gravite
  int etat = 0;                                               // variable pour selectionner l'état du personnage
  boolean sonOk;
  float vitSaut = 0;                                         // variable de la force en y du saut
  
  float temp;                                                 // variable pour stoquer le debut du cronometre
  float tempo = 100;                                          // variable qui déinie le rythme entre chaque nouvelle mesure
  
  float vitesse = 4;
  
  Personnage(  ) {                                            // constructor Objet Personnage | initialisation des objet/variable
    
    pos = new PVector ( 100, 400 );                           // création des vecteurs 
    centerImage = new PVector ( -15, 0 );
    vit = new PVector ( 0, 0 );
    gravite = new PVector ( 0, 4 );
    hitBox = new PVector ( largHit, hautHit );
    
    for ( int i = 0; i < perNames.length; i ++ ) {            // création des images en passant par une boucle qui lie chaque noms de la liste
      String perName = perNames[i];
      animePer[i] = loadImage(perName);
    }
    for ( int i = 0; i < mangeNames.length; i ++ ) {
      String mangeName = mangeNames[i];
      animeMange[i] = loadImage(mangeName);
    }
  }
  
  //----------------
  
  public void display() {                       // fonction affichage du personnage
      etat();                            // fonction qui détermine l'état du personnage
      animation( etat );                 // fonction qui détermine le contenue des etats ( image/statut )
      /*
      push();                            // ensemble pour afficher la hitBox du personnage
      rectMode(CENTER);
      noStroke();
      fill(0, 200, 0);
      ellipse(pos.x + centerImage.x, pos.y + centerImage.y, 3, 3);
      stroke( 0 );
      fill( 170, 30, 30, 100 );
      rect( pos.x , pos.y , hitVector.x, hitVector.y );
      pop();
      */
  }
  
  //----------------
  
  public void update() {                // fonction qui met a jour le personnage
  }
  
  //----------------
  
  public void etat() {
    
                                            // fonction qui détermine le changement d'état
    if ( onArbre ) {
      if ( up ) {
        if ( etat == 2 || etat == 0 || etat == 6 || etat == 7 || etat == 3 || right ) {
          etat = 2;
          graviteOn = false;
          fallOn = false;
        }
        if ( etat == 4 ||etat == 1 || etat == 8 || etat == 5 || left ) {
          etat = 4;
           graviteOn = false;
           fallOn = false;
        }
      }
      if ( down ) {
        if ( etat == 3 ||etat == 2 || right ) {
          etat = 3;
           graviteOn = false;
           fallOn = false;
        }
        if ( etat == 5 ||etat == 4 || left ) {
          etat = 5;
           graviteOn = false;
           fallOn = false;
        }
      }
      if ( !up && !down ) {
        if ( right ) {
          etat = 7;
          onArbre = false;
           graviteOn = true;
        }
        if ( left ) {
          etat = 8;
          onArbre = false;
          graviteOn = true;
        }      
      }
    }
      
    if ( !onArbre ) {
      if ( (!rightLock && etat == 2 )|| (!rightLock && etat== 3 )) {
        etat = 6;
        sautOn = true;
        fallOn = true;
      }
      if (( !leftLock && etat == 4 )|| (!leftLock && etat== 5) ) {
        etat = 6;
        sautOn = true;
        fallOn = true;
      }
    if ( right && rightLock ) {
       if ( vit.x >= 12 ) {
          liz.rightLock = false;
          fallOn = true;
          etat = 7;
        }
    }
    if ( left && leftLock ) {
       if ( vit.x <= -12 ) {
          liz.leftLock = false;
          fallOn = true;
          etat = 8;
        }
    }
    if ( !right && rightLock ) {
          rightLock = false;
          fallOn = true;
          etat = 7;
    }
    if ( !left && leftLock ) {
          leftLock = false;
          fallOn = true;
          etat = 8;
    }
    if ( !fallOn ) {
      if ( etat == 6 || etat == 7 ) {
      etat = 0;
      frame = 0;
      }
      if ( etat == 8 ) {
        etat = 1;
        frame = 3;
      }
    }
    if ( fallOn ) {
      if ( up ) {
        etat = 6;
      }
      if ( right ) {
        etat = 7;
      }
      if ( left ) {
        etat = 8;
      }
    }
    if ( !sautOn && !fallOn && !rightLock && !leftLock ) {
      if ( right ) {
        etat = 0;
      }
      if ( left ) {
        etat = 1;
      }
    }
    if ( rightLock ) {
      if ( right ) {
        if ( etat > 3 || etat < 2 ) {
          etat = 2;
        }
        if ( etat == 2 ) {
          etat = 2;
        }
        if ( etat == 3 ) { 
          etat = 3;
        }
      }
      if ( right ) {
      }
      if ( up ) {
        etat = 2;
      }
      if ( down ) {
        etat = 3;
      }
    }
    if ( leftLock ) {
      if ( left ) {
        if ( etat < 4 || etat > 5 ) {
          etat = 4;
        }
        if ( etat == 4 ) {
          etat = 4;
        }
        if ( etat == 5 ) { 
          etat = 5;
        }
      }
      if ( left ) {
      }
      if ( up ) {
        etat = 4;
      }
      if ( down ) {
        etat = 5;
      }
    }
    }
    if ( dead ) {
      if ( etat == 0 || etat == 2 || etat == 3 || etat == 4 || etat == 6 || etat == 7 || etat == 9 ) {
        etat = 9;   
      } else etat = 10;
    }
    
  }
  
  //-----------------
  
  public void deplacement( Map niveau,  Personnage person, Satiete vie) {      // fonction qui détermine le déplacement du personnage
    vit.set( 0, 0 );
    
    if ( !mangeOn ) {
    if ( etat == 0 || etat == 1 ) {    // etat normal droite/gauche
      if ( right ) {
        vit.add( vitesse, 0 );
      }
      if ( left ) {
        vit.add( -vitesse, 0 );
      }
      if ( up && !sautOn && !onArbre ) {
         
        sautOn = true;
        fallOn = true;
        vitSaut = -12;
      }
      if ( down ) {
      }
    }
    if ( etat == 6 || etat == 7 || etat == 8 ) {      // etat saut
      if ( right ) { 
        vit.add( vitesse, 0 );
      }
      if ( left ) {
        vit.add( -vitesse, 0 );
      }
      if ( up ) {
      }
      if ( down ) {
      }
    }
    if ( etat == 2 || etat == 3 ) {        // etat rightLock droite
      if ( !onArbre ) {
        if ( right ) { 
          vit.add( 12, 0 );  // ou 19 ?
        }
      }
      if ( onArbre ) {
        if ( right ) { 
          vit.add( vitesse , 0 );  // ou 19 ?
        }
      }
      if ( left ) {
        vit.add( -vitesse, 0 );
      }
      if ( up ) {
        vit.add( 0, -vitesse );
      }
      if ( down ) {
        vit.set( 0, vitesse );
      }
    }
    if ( etat == 4 || etat == 5 ) {        // etat leftLock gauche
      
      if ( right ) { 
        vit.add( vitesse, 0 );
      }
      if ( !onArbre ) {
        if ( left ) {
          vit.add( -12, 0 );
        }
      }
      if ( onArbre ) {
        if ( left ) {
          vit.add(-vitesse, 0 );
        }
      }
      if ( up ) {
        vit.add( 0, -vitesse );
      }
      if ( down ) {
        vit.set( 0, vitesse );
      }
    }
                       // si saut lire la fonction du saut
    saut();      
    gravite( niveau , person, vie );                     // fonction gravité
    collision( niveau , person , vie );          // fonction qui corrige la vitesse selon les collisions de la Map
    }
    if ( vit.x >= 11 && vit.x <= -11 ) {
      vit.x = 0;
      fallOn = true;
    }
    if ( etat ==9 || etat == 10 ) {        // etat mort droite / gauche
      if ( space ) {                       // fonction reset si mort
        reset();
      }
    }
    if ( etat == 0|| etat == 1 ) {         // si etat normal
      if ( vit.y > 1 ) {                   // et si personnage va déssendre
        fallOn = true;                     // il est entrain de tomber
      }
    }
    niveau.deplacement( person ); 
    pos.add( vit );                        // ajouter la vitesse a la position du personnage
    liz.onArbre = false;
    niveau1.correction( pos, hitBox );  // correction de la position du personnage selon les bloc de la map ( sécurité pour éviter que le Personnage entre dans un bloc et passe au travers la fonction collision()
  }
  
  //----------------
  
  public void saut() {                      // fonction pour la mechanique du saut //// désactiver la gravité
    if ( sautOn) {                // si en cour de saut
      graviteOn = false;
      if ( !up && vitSaut < -5 ) {
        vitSaut = -2.5f;
      }
      vit.add( 0, vitSaut );     // ajouter la vitesse de saut a la vitesse du personnage  
      vitSaut += 0.5f;               // diminier la vitesse de saut
      if (vitSaut > 5  ) {           // si la vitesse du saut est negative  /// désactiver saut
        sautOn = false;                // bloquer la vitesse de saut a -1
        graviteOn = true;
      }
    }
  }

  //----------------
  
  public void collision( Map niveau , Personnage person, Satiete vie  ) {    // fonction qui rassemble toute les collisions potentiel du personnage
    niveau.collision( pos, vit , hitBox, niveau, person, vie );    // collision par rapport au bloque de la map
                          // fonction qui deplace la map si le personnage se deplace   //// changer de place ( source de beug );
    limiteEcran( pos, vit, hitBox );                 // fonction qui limite le personnage au borne de l'écran
  }
  
  //----------------
    
  public void limiteEcran( PVector pos, PVector vit, PVector hitBox ) {         // fonction qui limite la vitesse du personnage au limite de l'ecran
   if ( pos.x + vit.x <= 0 + hitBox.x / 2 ) {
        vit.x = 0 + hitBox.x / 2 - pos.x;                                             // si le personnage va au dela de l'écran il est désactivé //// probleme a changer
    }
    if ( pos.x + vit.x >= width - hitBox.x / 2 ) {
        vit.x = width - hitBox.x/2 - pos.x;
        if ( !dead ) {
          bisousOn = false;
          point.end = point.score;
          page = 3;
        }
    }
    if ( pos.y + vit.y >= height - hitBox.y / 2 + 30 ) {
        vit.y = height - hitBox.y/2 - pos.y + 30;
        if ( !liz.dead ) {
          sonOver.play();
        }
        actif = false;
        dead = true;
    }
    //if ( pos.y + vit.y <= 0 + hitBox.y/2 - 30 ) {
    //    vit.y = 0 + hitBox.y/2 - pos.y;
    //}
  }
  
  //----------------
  
  public void gravite(Map niveau, Personnage person, Satiete vie ) {                  // fonction qui applique la gravite
    gravite.set( 0, 6);                        // définie qui détermine la gravite a 6
    
    niveau.collision( pos, gravite, hitBox, niveau, person, vie); // vérifie que la gravité ne fait pas entrer dans un bloc de la map //// pas efficace a cette endroit changer
    
    if ( graviteOn ) {                        // si la gravite a active
    vit.add(gravite);                         // appliquer la gravité a la vitesse du personnage
    }
  }
  
  //----------------
  
  public void PkeyPressed() {         // fonction qui active les commande en fonction des touches
    if ( actif) {
      if ( keyCode == 39 ) {
        right = true;
      }
      if ( keyCode == 37 ) {
        left = true;
      }
      if ( keyCode == 38 ) {
        up = true;
        if ( etat == 0 || etat == 1 ) {
           if ( !sonOk ) {
              sonSaut.play();
              sonOk = true;
            }          // jouer le son du saut                //// mal placé a clarifier
        }
          if ( sautOn || fallOn ) { // et si en cour de saut ou de chute
            if ( !onArbre ) {
            up = false;    
            }// la commande up ne s'active pas
          }
         
      }
      if ( keyCode == 40 ) {
        down = true;
      }
    } 
    if ( keyCode == 32 ) {
      space = true;
    }
  }
  
  //----------------
  
  public void PkeyReleased() {                    // fonction qui désactive les commande en fonction des touches ( permet de maintenir enfoncer les touche );
      if ( keyCode == 39 ) {
        right = false;
      }  
      if ( keyCode == 37 ) {
        left = false;
      }
      if ( keyCode == 38 ) {
          up = false;  
      }
      if ( keyCode == 40 ) {
        down = false;
      }
      if ( keyCode == 32 ) {
        space = false;
      }
  }
  
  //----------------
  
  public void animation( int etat ) {           // fonction qui paramtre les etat et jou les animations //// pas évident s'épparer les deux fonction, plus simple
    if ( etat == 0 ) {                  // si etat normal droite
      graviteOn = true;                 // gravite est appliqué
      hitBox.set(36, 15);            // la hitBox fait 36 de large et 15 de hauteur
      centerImage.set( -15, 0 );        // le centre de l'image est décaller de -15 sur x par rapport a position Personnage
      anime ( right, 0, 1, 0, 4 );      // jouer animation ( si commmande droite actif ( pas d'animation si a l'arret ) | jouer la frame 0 et 1 | décaller image de 4 en y par rapport a centreImage
    }
    if ( etat == 1 ) {
      graviteOn = true;
      hitBox.set(36, 15);
      centerImage.set( 15, 0 );
      anime( left, 2, 3, 0, 4 );
    } 
    if ( etat == 2 ) {
      graviteOn = false;
      vitSaut = 0;
      sautOn = false;
      fallOn = false;
      hitBox.set(15, 36);
      centerImage.set( 0, 15 );
      anime(up, 4, 5, 4, 0 );
    }
    if ( etat == 3 ) {
      graviteOn = false;
      vitSaut = 0;
      sautOn = false;
      fallOn = false;
      hitBox.set(15, 36);
      centerImage.set( 0, -15 );
      anime(down, 6, 7, 4, 0 );
    }
    if ( etat == 4 ) {
      graviteOn = false;
      vitSaut = 0;
      sautOn = false;
      fallOn = false;
      hitBox.set(15, 36);
      centerImage.set( 0, 15 );
      anime(up, 8, 9, -2, 0 );
    }
    if ( etat == 5 ) {
      graviteOn = false;
      vitSaut = 0;
      sautOn = false;
      fallOn = false;
      hitBox.set(15, 36);
      centerImage.set( 0, -15 );
      anime(down, 10, 11, -2, 0 );
    }
    if ( etat == 6 ) {
      graviteOn = true;
      hitBox.set(15, 36);
      centerImage.set( 2, 18 );
      anime(fallOn, 12, 13, 0, 0 );
    }
    if ( etat == 7 ) {
      graviteOn = true;
      hitBox.set(36, 15);
      centerImage.set( 0, 15 );
      anime(right, 14, 15, -4, 0 );
    }
    if ( etat == 8 ) {
      graviteOn = true;
      hitBox.set(36, 15);
      centerImage.set( 0, 15 );
      anime(left, 16, 17, 4, 0 );
    }
    if ( etat == 9 ) {
      graviteOn = true;
      hitBox.set(36, 15);
      centerImage.set( -15, 0 );
      anime(dead, 18, 18, 4, 0 );
    }
    if ( etat == 10 ) {
      graviteOn = true;
      hitBox.set(36, 15);
      centerImage.set( 15, 0 );
      anime(dead, 19, 19, 4, 0 );
    }    
    niveau1.correction(pos, hitBox);             // corriger la position du personnage si la hitBob rentre dans bloc apres changement de sa taille
  }
  
  //----------------
  
  public void anime( boolean touche, int frameMin, int frameMax, int x, int y ) {  // fonction qui joue une animation
    if ( !mangeOn ) {                                        // si personnage n'est pas entrain de manger
      tempo = 100;                                             // temps entre chaque image  en ms
      if ( frame < frameMin || frame > frameMax ) {            // et si frame n'est pas compris entre frameMin et frameMax
        frame = frameMin;                                      // alors frame devien frameMin ( entre dans l'intervale de l'animation);
      }      
      if ( touche ) {                                          // si la cammande touche est activer
        if ( time > temp + tempo ) {                             // et que lemps(horgloge interne) est supérieur a la limite du crono ( temps enregistrer + tempo );
          temp = time;                                           // alors enregistrer le temps ( début crono );
          frame++;                                               // frame suivante 
          if ( frame < frameMin || frame > frameMax ) {            // si  frame est sortie de l'intervale
            frame = frameMin;                                      // revenir la premiere frame de l'animation ( boucle debut | fin | debut | fin | ect ...)
          }
        }
      }
      push();                                                   // insoler réglage ( crée une bulle isolé );
      imageMode( CENTER );                                      // mode d'affichage des images, center par rapport a un point
      image(animePer[ frame ], pos.x + centerImage.x + x, pos.y + centerImage.y + y ); // afficher l'image[ frame] la position du personnage + centerImage + décallage
    }  
    if ( mangeOn ) {
      actif = false;            //// doit pouvoir etre changer de place
      tempo = 200;
      if ( frame < frameMin || frame >frameMax ) {
        frame = frameMin;
        temp = time;
      }
      push();
      imageMode( CENTER );
      image(animeMange[ frame ], pos.x + centerImage.x + x, pos.y + centerImage.y + y );
      if ( time > temp+tempo ) {
        temp = time;
        frame++;
        if ( frame > frameMax ) {
        mangeOn = false;              //// changer de place ( crée des probleme );
        actif = true;
        }
      }
    }
    pop();
  }


  public void reset() {   // fonction reset ; retour des paramettre a 0;
    time = 0;
    time = millis();
    point.start = time;
    point.actif = true;
    pos.set( 100, 400 );
    niveau1.reset();
    dead = false;
    actif = true;
    etat = 0;
    life.satiety = 12;
    life.over = false;
    sonP.stop();
    sonMazon.stop();
    sonV.stop();
    sonSatiete.stop();
    sonSatiete.loop();
    sonSaut.stop();   
  }
  
}
class Satiete{
  
  String[] imgNames = { "s00.png", "s01.png", "s02.png", "s03.png", "s04.png", "s05.png", "s06.png", "s07.png", "s08.png","s09.png", "s10.png","s11.png" , "s12.png" };
  PImage[] animeImg = new PImage[imgNames.length];
  
  int satiety = 10;
  float start, end;
  boolean over;
  
  
  Satiete(  ) {
    
    for ( int i = 0; i < imgNames.length; i ++ ) {
    String imgName = imgNames[i];
    animeImg[i] = loadImage(imgName);
    }
    start = 0;
    end = start + 1500;
  }
  
   public void display() {
     
    if ( time >= end ) {
      satiety-= 1;
      start = time;
      end = start + 1500;
    } 
    if ( satiety < 5 && satiety > 0) {
      sonSatiete.amp(0.1f*(6 - satiety));
      //sonForet.amp(0.2);
      //sonAmbiance.amp(0.0);
    }
    if ( satiety >= 5 ) {
      sonSatiete.amp(0);
      //sonForet.amp(0.5);
      //sonAmbiance.amp(0.4);
    }
    if ( satiety == 0 ) {
      if ( !over ) {
      sonSatiete.stop();
      if ( !liz.dead ) {
      sonOver.play();
      }
      //sonForet.amp(0.2);
      //sonAmbiance.amp(0.2);
      liz.dead = true;
      over = true;
      }
    }
    if ( liz.dead ) {
      sonSatiete.stop();
    }
    satiety = constrain( satiety, 0, 12);
    image( animeImg[satiety], 35, height - 30);
    // animeImg[satiety].width*3, animeImg[satiety].height*3 );
   
 }
 
 public void update() {
   
 }
  
}
class Score {
  
  float score;
  float start, end;
  float startFond, endFond;
  boolean actif;
  PImage youLived;
  
  Score(  ) {
    
  youLived = loadImage( "youLivedFor.png");  
  score = 0;
  start = time;
  
  }
  
  
  
  
  public void display(){

    if ( liz.dead ) {
      push();
      imageMode(CENTER);
      image( youLived , width/2, height/2 );
      textFont(fontL);
      textAlign( LEFT, BOTTOM );
      textSize(77);
      noStroke();
      fill( 0xffffff66);  //, ( time - endFond ) / 20 );
      text( PApplet.parseInt (point.end/100) , width/2 + 114 , height/2 + 26 );
      pop();
    }
  }
  
  
  public void update() {
    
    if ( actif ) {
    score  = time - start;
    startFond = time;
    }
    if ( liz.dead ) {
      actif = false;
      end = score;
      endFond = startFond;
    }
    
  }
  
}
class Vers {

  String[] wormNames = { "worm1.png", "worm2.png" };
  PImage[] animeWorm = new PImage[ wormNames.length ];
  int frame = 0;
  int frameMin = 0;
  int frameMax = 1;
  
  float posX, posY;
  float larg, haut;
  
  PVector pos;
  
  boolean actif = true, dead = false;
  boolean sonOn = true;
  boolean getHp;

  float temp;
  float tempo = 200;
  
  Vers( float pos_X, float pos_Y  ) {
    
    pos = new PVector ( random(((height/15)/2) - 10, ((height/15)/2) + 10 ) , height/15 - 6);
    posX = pos_X;
    posY = pos_Y;
    larg = 20;
    haut = 12;
    tempo = random ( 80, 200 );
    
    for ( int i = 0; i < wormNames.length; i ++ ) {
      String wormName = wormNames[i];
      animeWorm[i] = loadImage(wormName);
    }
  }
  
  //--------------
  
  public void display() {    // fonction affichage vers
    if ( actif ) {
      if ( !dead ) {
        if ( time > temp + tempo ) {
          temp = time;
          frame++;
          if ( frame > frameMax ) {
            frame = frameMin;
          }
        }
        push();
        imageMode( CENTER );
        image(animeWorm[ frame ], posX + pos.x , posY + pos.y );
        pop();
      }
      
    }
    /*
      push();
      rectMode(CENTER);
      noStroke();
      fill(0, 200, 0);
      ellipse(posX + poss.x, posY + poss.y, 3, 3);
      stroke( 0 );
      fill( 170, 30, 30, 100 );
      rect( posX + poss.x , posY + poss.y , larg, haut );
      pop();
      */
  }
  
  //--------------
  
  public void update( Map niveau) {        // fonction mise a jour du vers / repositionnement si map bouge
   posX +=niveau.move.x;
   posY +=niveau.move.y;
  }
  
  //--------------
  
  public void collision( Personnage person, Satiete vie ) {    // fonction collision, si objet sur vers, le vers meur
    if ( actif ) {
      if ( person.pos.x + person.hitBox.x/2 > posX + pos.x - larg/2 && person.pos.x - person.hitBox.x/2 < posX + pos.x + larg/2 && person.pos.y - person.hitBox.y/2 > posY + pos.y - person.hitBox.y && person.pos.y + person.hitBox.y/2 < posY + pos.y + haut + person.hitBox.y ) {
        mort( person, vie );
      }
      if ( person.pos.x - person.hitBox.x/2 > posX + pos.x + larg/2 && person.pos.x - person.hitBox.x/2 < posX + pos.x + larg/2 && person.pos.y - person.hitBox.y/2 > posY + pos.y - person.hitBox.y && person.pos.y + person.hitBox.y/2 < posY + pos.y + haut + person.hitBox.y ) {
        mort( person, vie );
      }
      if ( person.pos.y + person.hitBox.y/2 > posY + pos.y && person.pos.y + person.hitBox.y/2 < posY + pos.y + haut/2 && person.pos.x - person.hitBox.x/2 > posX + pos.x - person.hitBox.x && person.pos.x + person.hitBox.x /2 < posX + pos.x + larg + person.hitBox.x) {
        mort( person, vie );
      }
      if ( person.pos.y - person.hitBox.y/2 > posY + pos.y + haut/2 && person.pos.y - person.hitBox.y/2 < posY + pos.y + haut && person.pos.x - person.hitBox.x/2 > posX + pos.x - person.hitBox.x && person.pos.x + person.hitBox.x /2 < posX + pos.x + larg + person.hitBox.x) {
        mort( person, vie );
      }
    }
  }

  public void mort( Personnage person, Satiete vie ) {          // fonction pour faire mourir le vers
    if ( !dead ) {
      person.mangeOn = true;
      dead = true;
      actif = false;
      if ( sonOn ) {
        sonV.play();
      }
    if ( dead && person.mangeOn) {         // si le vers est mort et personnage entrain de manger
        if ( !getHp ) {
          vie.satiety++;
          getHp = true;
        }
      }
    }
  }
  
  
}
class Arbre {
  
  float posX, posY;
  float larg, haut;
  int type;
  
  Arbre( float pos_X, float pos_Y, int typ ) {
    
    type = typ;
    posX = pos_X;
    posY = pos_Y;
    if ( type == 1) {
      larg = (height / 15);
    }
    if ( type == 2 ) {
      larg = height / 15;
      posY += 15;
    }
    //height / 15;
    //width/20;
    haut = height / 15;
    
  }
  
  
  
  public void display() {
      push();
      noFill();
      stroke(255);
      //rect(posX, posY, larg, haut);
      pop();
    
  }
  
  
  public void update( Map niveau ) {
   posX +=niveau.move.x;
   posY +=niveau.move.y;
  }
  
  
  
   public void surArbre ( PVector pos, PVector hitBox ) {
     if ( type == 1 ) {

      if ( pos.x >= posX && pos.x  <= posX + larg && pos.y  >= posY && pos.y <= posY + haut ) {
        //if ( !liz.onArbre ) {
        liz.onArbre = true;
        //}
      }
    }
     
     /*
     if ( type == 1 ) {

      if ( pos.x + hitBox.x/2 >= posX && pos.x + hitBox.x/2 <= posX + larg/2 && pos.y - hitBox.y/2 >= posY - hitBox.y && pos.y + hitBox.y/2 <= posY + haut + hitBox.y ) {
        if ( !liz.onArbre ) {
        liz.onArbre = true;
        }
      }
      if ( pos.x - hitBox.x/2 >= posX + larg/2 && pos.x - hitBox.x/2 <= posX + larg && pos.y - hitBox.y/2 >= posY - hitBox.y && pos.y + hitBox.y/2 <= posY + haut + hitBox.y ) {
        if ( !liz.onArbre ) {
        liz.onArbre = true;
        }
      }
      if ( pos.y + hitBox.y/2 >= posY && pos.y + hitBox.y/2 <= posY + haut/2 && pos.x - hitBox.x/2 >= posX - hitBox.x && pos.x + hitBox.x /2 <= posX + larg + hitBox.x) {
        if ( !liz.onArbre ) {
        liz.onArbre = true;
        }
      }
      if ( pos.y - hitBox.y/2 >= posY + haut/2 && pos.y - hitBox.y/2 <= posY + haut && pos.x - hitBox.x/2 >= posX - hitBox.x && pos.x + hitBox.x /2 <= posX + larg + hitBox.x) {
        if ( !liz.onArbre ) {
        liz.onArbre = true;
        }
      }
    }
    */
   }
  
  public void collision( PVector pos, PVector vit, PVector hitBox ) {         
    if ( type == 2 && !liz.down) {
      if ( pos.y <= posY - hitBox.y/2 ) {
        if(pos.y + vit.y >= posY - hitBox.y/2 && pos.x + vit.x > posX - hitBox.x/2 && pos.x + vit.x < posX + larg + hitBox.x/2 ) {
          vit.y = posY - hitBox.y/2 - pos.y;
          liz.sautOn = false;
          liz.fallOn = false;
          liz.sonOk = false;
  
        }
      }
    }
  }
  
}
class Element {
  
  PImage decorGreen;
  float posX, posY;
  float larg, haut;
  
  
  Element( float pos_X, float pos_Y ) {
     
    
    //decorGreen = loadImage("caillou1.png");
    posX = pos_X;
    posY = pos_Y;
    larg = height / 15;
    //height / 15;
    //width/20;
    haut = height / 15;
    //height / 15;
    //height/15;
   
  }
 
  //----------------
  
  public void display() {
    
    push();
    //noStroke();
    stroke(180);
    noFill();
    //rect ( posX, posY, larg, haut );
    //imageMode(CENTER);
    //image(decorGreen, posX + larg/2, posY + haut/2 );
    pop();
  }
 
  //----------------
  
  public void update( Map niveau) {
    
   posX +=niveau.move.x;
   posY +=niveau.move.y;
  }
  
  //----------------
  
  public void collision( PVector pos, PVector vit, PVector hitBox ) {         
    
    if ( pos.x <= posX - hitBox.x/2 ) {
      if(pos.x + vit.x >= posX - hitBox.x/2 && pos.y + vit.y > posY - hitBox.y/2 && pos.y + vit.y < posY + haut + hitBox.y/2 ) {   
        if ( pos.x + vit.x >= posX - hitBox.x/2 && liz.right && liz.fallOn) {
        liz.rightLock = true;
        }
        vit.x = posX - hitBox.x/2 - pos.x;     
      }
    }
    if ( pos.x >= posX + larg + hitBox.x/2 ) {
      if( pos.x + vit.x <= posX + larg + hitBox.x/2 && pos.y + vit.y > posY - hitBox.y/2 && pos.y + vit.y < posY + haut + hitBox.y/2 ) {
        if ( pos.x + vit.x <= posX + larg + hitBox.x/2 && liz.left && liz.fallOn) {
        liz.leftLock = true;
        }
        vit.x = posX + larg + hitBox.x/2 - pos.x;
      }
    }
    if ( pos.y >= posY + haut + hitBox.y/2 ) {
      if( pos.y + vit.y <= posY + haut + hitBox.y/2 && pos.x + vit.x > posX - hitBox.x/2 && pos.x + vit.x < posX + larg + hitBox.x/2 ) {
        vit.y = posY + haut + hitBox.y/2 - pos.y;
        liz.vitSaut =  2;
      }
    }
    if ( pos.y <= posY - hitBox.y/2 ) {
      if(pos.y + vit.y >= posY - hitBox.y/2 && pos.x + vit.x > posX - hitBox.x/2 && pos.x + vit.x < posX + larg + hitBox.x/2 ) {
        vit.y = posY - hitBox.y/2 - pos.y;
        liz.sautOn = false;
        liz.fallOn = false;
        liz.sonOk = false;

      }
    }
  }
   
    //----------------
  
  public void correction ( PVector pos, PVector hitBox ) {
    if ( pos.x + hitBox.x/2 > posX && pos.x + hitBox.x/2 < posX + larg/2 && pos.y - hitBox.y/2 > posY - hitBox.y && pos.y + hitBox.y/2 < posY + haut + hitBox.y ) {
      pos.x = constrain( pos.x, 0, posX - hitBox.x/2 - 1 );
    }
    if ( pos.x - hitBox.x/2 > posX + larg/2 && pos.x - hitBox.x/2 < posX + larg && pos.y - hitBox.y/2 > posY - hitBox.y && pos.y + hitBox.y/2 < posY + haut + hitBox.y ) {
      pos.x = constrain( pos.x, posX + larg + hitBox.x/2 + 1, width);
    }
    if ( pos.y + hitBox.y/2 > posY && pos.y + hitBox.y/2 < posY + haut/2 && pos.x - hitBox.x/2 > posX - hitBox.x && pos.x + hitBox.x /2 < posX + larg + hitBox.x) {
      pos.y = constrain( pos.y, 0, posY - hitBox.y/2  - 1);
    }
    if ( pos.y - hitBox.y/2 > posY + haut/2 && pos.y - hitBox.y/2 < posY + haut && pos.x - hitBox.x/2 > posX - hitBox.x && pos.x + hitBox.x /2 < posX + larg + hitBox.x) {
      pos.y = constrain( pos.y, posY + haut + hitBox.y/2 + 1, height);
    }
  }

  
}
class Map {
  
  int niveau;
              /*    
  int map[][] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
                  { 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
                  { 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 },
                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 },
                  { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 },
                  { 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 },
                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1 },
                  { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1 },
                  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1 },
                  { 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 },
                  { 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
                  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } };  
  */
  
  int map[][] =  {
{ 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 4, 0, 3, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 5, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 3, 0, 0, 5, 4, 4, 5, 0, 6, 0, 0, 0, 0, 0, 6, 5, 0, 3, 0, 0, 0, 6, 0, 0, 6, 6 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 4, 4, 4, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 6, 4, 4, 4, 0, 0, 4, 0, 4, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 8, 8, 7, 4, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 7, 8, 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 5, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4, 0, 7, 0, 0, 0, 4, 0, 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 4, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 7, 7, 8, 8, 0, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 8, 7, 0, 4, 4, 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 8, 8, 7, 8, 8, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 4, 0, 0, 8, 8, 0, 4, 0, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5 },
{ 0, 0, 0, 4, 7, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 7, 0, 0, 4, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 7, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 4, 7, 7, 0, 0, 0, 0, 8, 7, 8, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 4, 0, 8, 7, 8, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 8, 0, 4, 0, 4, 4, 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 7, 7, 7, 0, 7, 8, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 4, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 4, 4, 8, 4, 7, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 7, 0, 4, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 4, 0, 4, 4, 0, 4, 0, 7, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 4, 0, 0, 7, 0, 0, 0, 8, 8, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0 },
{ 1, 1, 0, 0, 0, 7, 8, 8, 0, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 7, 0, 4, 0, 4, 4, 4, 8, 8, 8, 7, 0, 1, 1, 1, 1, 1, 1, 0, 0, 4, 4, 0, 0, 0, 1, 1, 1, 0, 2, 0, 0, 0, 0, 0, 1, 1, 2, 0, 4, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0 },
{ 1, 1, 1, 1, 0, 7, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 1, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 7, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 2, 2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 2, 0, 0, 2, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 4, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 2, 2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0 },
{ 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 2, 0, 0, 4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 2, 1, 0, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 2, 2, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 2, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 }, };


  Element[] decors;
  Vers[] vers;
  Parrot[] parrot;
  Pap[] pap;
  Arbre[] arbre;
  
  int largCarre = height/15;
  //height/15;
  //width / 20;
  int hautCarre = height/15;
  //height/15;
  //height / 15;
  int nbElement = 0;
  int nbVers;
  int nbParrot;
  int nbPap;
  int nbArbre;
  
  PVector pos, move;
  boolean checkPos;
  boolean cascade;
  float limiteG, limiteD, limiteB, limiteH;
  
  float decorX = 0;
  float decorY = 0;
  float decor1X = 0;
  float decor1Y = 0;
  PImage decorCiel, decor1;
  
  String[] cascadeNames = { "cascade1.png", "cascade2.png", "cascade3.png" }; 
  PImage[] animeCascade;
  int frame;
  float start;
  float tempo = 100;
  float startCascade;
  
  Map( int niveaux , float limiteGauche, float limiteDroite, float limiteHaut, float limiteBas ) {
    
    decorCiel = loadImage("cielOk3.png");
    decor1 = loadImage("decorFINAL.png");
    animeCascade = new PImage[cascadeNames.length];
    for ( int i = 0; i < cascadeNames.length; i ++ ) {
      String cascadeName = cascadeNames[i];
      animeCascade[i] = loadImage(cascadeName);
    }
      
    decors = new Element[ map[0].length * map.length ];
    vers = new Vers[ map[0].length * map.length ];
    parrot = new Parrot[ map[0].length * map.length ]; 
    pap = new Pap[ map[0].length * map.length ]; 
    arbre = new Arbre[ map[0].length * map.length ];
    
    pos = new PVector( 0, 0 );
    move = new PVector( 0, 0 );
    niveau = niveaux;
    limiteG = limiteGauche;
    limiteD = limiteDroite;
    limiteB = limiteBas;
    limiteH = limiteHaut;
    int index1 = 0;
    int index2 = 0;

    for ( float y = pos.y; y < hautCarre * map.length; y+= hautCarre ) { 
      index2 = 0;
      
      for ( float x = pos.x; x < largCarre * map[0].length; x+= largCarre ) {
        if ( map[ index1 ][ index2 ] == 1 ) { 
          decors[ nbElement ] = new Element ( pos.x + x, pos.y + y);
          nbElement++;
        }
        if ( map[ index1 ][ index2 ] == 2 ) {
          vers[ nbVers ] = new Vers ( pos.x + x, pos.y + y );
          nbVers++;
        }
        if ( map[ index1 ][ index2 ] == 3 ) {
          parrot[ nbParrot ] = new Parrot ( pos.x + x, pos.y + y , 1);
          nbParrot++;
        }
        if ( map[ index1 ][ index2 ] == 5 ) {
          parrot[ nbParrot ] = new Parrot ( pos.x + x, pos.y + y , 2);
          nbParrot++;
        }
        if ( map[ index1 ][ index2 ] == 6 ) {
          parrot[ nbParrot ] = new Parrot ( pos.x + x, pos.y + y , 3);
          nbParrot++;
        }
        if ( map[ index1 ][ index2 ] == 4 ) {
          pap[ nbPap ] = new Pap ( pos.x + x, pos.y + y );
          nbPap++;
        }
        if ( map[ index1 ][ index2 ] == 7 ) {
          arbre[ nbArbre ] = new Arbre ( pos.x + x, pos.y + y , 1);
          nbArbre++;
        }
        if ( map[ index1 ][ index2 ] == 8 ) {
          arbre[ nbArbre ] = new Arbre ( pos.x + x, pos.y + y , 2);
          nbArbre++;
        }
        index2++;
        index2 = constrain( index2, 0, map[0].length - 1 );
      }
      index1++;
      index1 = constrain( index1, 0, map.length - 1 );
    }
  }
  
  
  //----------------
  
  public void display() {
    
    background(0);
    back();
    
    for ( int index = 0; index < nbElement; index++ ) {
    decors[ index ].display(); 
    }
    for ( int index = 0; index < nbArbre; index++ ) {
    arbre[ index ].display(); 
    }
    for ( int index = 0; index < nbVers; index++ ) {
    vers[ index ].display(); 
    }
    for ( int index = 0; index < nbParrot; index++ ) {
    parrot[ index ].display(); 
    }
    for ( int index = 0; index < nbPap; index++ ) {
    pap[ index ].display(); 
    }
  }
  
  //----------------
  
  public void update(){

  }
  
  public void back() {
    image( decorCiel, decorX, decorY - 710 );
    image ( animeCascade[ frame ], pap[0].posX + 1743, pap[0].posY + 563 );
    image ( decor1, pap[0].posX + 3, pap[0].posY + 31 );
    if ( time > start + tempo ) {
    frame++;
    start = time;
    }
    if ( frame > 2 ) {
      frame = 0;
    }
    println( "time = " + time + " startCasacde = " + startCascade + " cascadeOn = " + cascade );
    if ( !cascade && pap[0].posX + 3 < - 980 && pap[0].posX + 3 > - 1080 && time > startCascade + 80000) {
      sonCascade.play();
      cascade = true;
      startCascade = time;
    }
  }
  //----------------
  
  public void deplacement( Personnage person ) {
    move.set( 0, 0 );
    if ( !checkPos( 3, decors ) ) {        //gauche   //// methode chelou sans doute plus simple a faire
      if ( person.pos.x - person.largHit/2 < 200 ) {
        move.x = 2;
        person.pos.add( 4, 0);                                    //// rendre vit.x ou y = 0, generer trop de problem ou bien faire un interrupere sur personnage ( état bloquer );
        decorX+= 2;
        decor1X += move.x;
      }
    }
    if ( !checkPos( 1, decors ) ) {          //droite
      if ( person.pos.x + person.largHit/2 > width - 200 ) {   
        move.x = -2;
        person.pos.add( -4, 0);
        decorX-= 2;
        decor1X += move.x;
      }
    }
    if ( !checkPos( 4, decors ) ) {        // haut
      if ( person.pos.y - person.hautHit/2 < 100 ) {
        move.y = 4;
        person.pos.add( 0, 5 );
        decorY+= 8;
        decor1Y += move.y;
      }
    }
    if ( !checkPos( 2, decors ) ) {        // bas
      if ( person.pos.y + person.hautHit/2 > ( height - 100 ) ) {
        move.y = -5;
        person.pos.add( 0, -6 );
        decorY -= 8;
        decor1Y +=  move.y;
      }
    }
        

  }
  
  //----------------
  
  public void collision( PVector pos, PVector vit, PVector hitBox, Map niveau, Personnage person, Satiete vie ) {  
    
    for ( int index = 0; index < nbElement; index++ ) {
        decors[ index ].update(niveau);
        decors[ index ].collision( pos, vit , hitBox );
    }
    for ( int index = 0; index < nbArbre; index++ ) {
        arbre[ index ].update(niveau);
        arbre[ index ].collision( pos, vit , hitBox );
    } 
    for ( int index = 0; index < nbVers; index++ ) {
        vers[ index ].update(niveau);
        vers[ index ].collision( person, vie );
    }
    for ( int index = 0; index < nbParrot; index++ ) {
        parrot[ index ].update(niveau);                                    // perro actif
        parrot[ index ].collision( person.pos, person.hitBox );
    }
    for ( int index = 0; index < nbPap; index++ ) {
        pap[ index ].update(niveau);
        pap[ index ].manger( person.pos, person.hitBox );
    }
    for (int i = 0; i < nbPap; i ++ ) {
      for (  int index = 0; index < nbParrot; index++ ) {
        parrot[ index ].mange( pap[i].pos , pap[i].hitBox, pap[i] );
      }
    }
  }
  
  //----------------

  public void correction ( PVector pos, PVector hitBox ) {
    for ( int index = 0; index < nbElement; index++ ) {
    decors[ index ].correction( pos, hitBox );
    }
    for ( int index = 0; index < nbArbre; index++ ) {
        arbre[ index ].surArbre( pos, hitBox );
    } 
  }

  //----------------
  
  public void reset() {
    nbElement = 0;
    nbVers = 0;
    nbParrot = 0;
    nbPap = 0;
    nbArbre = 0;
    decorX = 0;
    decorY = 0;
    decor1X = 0;
    decor1Y = 0;
    //sonCascade.stop();
    cascade = false;
    int index1 = 0;
    int index2 = 0;

    for ( float y = pos.y; y < hautCarre * map.length; y+= hautCarre ) { 
      index2 = 0;
      
      for ( float x = pos.x; x < largCarre * map[0].length; x+= largCarre ) {
        if ( map[ index1 ][ index2 ] == 1 ) { 
          decors[ nbElement ] = new Element ( pos.x + x, pos.y + y);
          nbElement++;
        }
        if ( map[ index1 ][ index2 ] == 2 ) {
          vers[ nbVers ] = new Vers ( pos.x + x, pos.y + y );
          nbVers++;
        }
        if ( map[ index1 ][ index2 ] == 3 ) {
          parrot[ nbParrot ] = new Parrot ( pos.x + x, pos.y + y , 1);
          nbParrot++;
        }
        if ( map[ index1 ][ index2 ] == 5 ) {
          parrot[ nbParrot ] = new Parrot ( pos.x + x, pos.y + y , 2);
          nbParrot++;
        }
        if ( map[ index1 ][ index2 ] == 6 ) {
          parrot[ nbParrot ] = new Parrot ( pos.x + x, pos.y + y , 3);
          nbParrot++;
        }
        if ( map[ index1 ][ index2 ] == 4 ) {
          pap[ nbPap ] = new Pap ( pos.x + x, pos.y + y );
          nbPap++;
        }
        if ( map[ index1 ][ index2 ] == 7 ) {
          arbre[ nbArbre ] = new Arbre ( pos.x + x, pos.y + y , 1);
          nbArbre++;
        }
        if ( map[ index1 ][ index2 ] == 8 ) {
          arbre[ nbArbre ] = new Arbre ( pos.x + x, pos.y + y , 2);
          nbArbre++;
        }
        index2++;
        index2 = constrain( index2, 0, map[0].length - 1 );
      }
      index1++;
      index1 = constrain( index1, 0, map.length - 1 );
    }
  }
    
    
    
  public boolean checkPos(int nb, Element[] decors) {    // 1:gauche  2:haut  3:droite  4:bas
    if ( nb == 1 ) {
      for ( int index = 0; index < nbElement; index++ ) {
        if ( decors[ index ].posX < limiteD ) {
          return true;
        }
      }
    }
    if ( nb == 2 ) {
      for ( int index = 0; index < nbElement; index++ ) {
        if ( decors[ index ].posY < limiteB ) {
        return true;
        }
      } 
    }
    if ( nb == 3 ) {
      for ( int index = 0; index < nbElement; index++ ) {
        if ( decors[ index ].posX + decors[ index ].larg > limiteG ) {
          return true;
        } 
      }
    }
    if ( nb == 4 ) {
      for ( int index = 0; index < nbElement; index++ ) {
        if ( decors[ index ].posY + decors[ index ].haut > limiteH ) {
          return true;
        }
      }
    }
    return false;
  }
  
}
class page1 {
  
  String[] godNames = { "godzilla1.png" , "godzilla5.png", "godzilla2.png" , "godzilla3.png" , "godzilla4.png" };
  PImage[] animeGod= new PImage[godNames.length];
  String[] fondNames = { "godFond.png" , "godFondTexte1.png", "godFond.png", "godFondTexte2.png" };
  PImage[] animeFond= new PImage[fondNames.length];
  PImage decorGod;
  int frame, frameF;
  int countF, countL;
  float start, end, startF;
  float tempo = 100;
  float tempoo = 70;
  float tempoF = 500;
  float startIntro;
  float tempoIntro = 60000;
  boolean langueOn, titreOn, resetOn;
  
  Parrot perro;
  Pap papi;
  
  page1() {
    
    perro = new Parrot( 900, 0, 1 );
    papi = new Pap ( 720, 240 );
    perro.vitesse = 200;
    
    for ( int i = 0; i < fondNames.length; i ++ ) {
      String fondName = fondNames[i];
      animeFond[i] = loadImage(fondName);
    }
      
    for ( int i = 0; i < godNames.length; i ++ ) {
      String godName = godNames[i];
      animeGod[i] = loadImage(godName);
    }
    
    
  }
  
  
  
  
  public void display() {
    if ( !resetOn ) {
      startIntro = time;
      resetOn = true;
    }
    if ( time > startIntro + tempoIntro ) {
      introOn = true;
      resetOn = false;
      page = 0;
      sonForet.stop();
      sonAmbiance.stop();
    }
    push();
    image( animeFond[frameF], 0, 0 , 960, 720);
    image ( animeGod[frame], - 48 , height - 403 );
    textAlign(CENTER, CENTER);
    textFont(fontL);
    textSize(90);
    fill(255);
    pop();
    papi.display();
    perro.display();
  }
  
  
  public void update() {
    perro.update(niveau1);
    papi.update(niveau1);
    perro.mange( papi.pos , papi.hitBox, papi );
    
    if ( time > startF + tempoF ) {
      frameF++;
      startF = time;
    }
    if ( frameF > 3 ) {
      frameF = 0;
    }
    
    
    
    
    
    
    
    
    
    if ( !langueOn ) {
      if ( time > start + tempo ) {
        countF++;
        start = time;
      }
      if ( countF == 1 ) {
        frame = 1;
      }
      if ( countF >= 8 ) {
        frame = 0;
        countL++;
        countF = 0;
      }
      if ( countL == 3 ) {
        langueOn = true;
        countL = 0;
        countF = 1;
    }
    }
    if ( langueOn ) {
      if ( time > start + tempoo ) {
        countF++;
        start = time;
      }
      if ( countF == 1 ) {
        frame = 1;
      }
      if ( countF == 2 ) {
        frame = 0;
      }
      if ( countF == 3 ) {
        frame = 2;
      }
      if ( countF == 4 ) {
        frame = 3;
      }
      if ( countF == 5 ) {
        frame = 4;
      }
      if ( countF == 6 ) {
        frame = 2;
      }
      if ( countF == 7 ) {
        frame = 1;
      }
      if ( countF == 8 ) {
        frame = 1;
        langueOn = false;
        countF = 0;
      }
    }

    
  }
}
  
  
  
  
  
 
  public void settings() {  size( 960, 720 ); }
  static public void main(String[] passedArgs) {
    String[] appletArgs = new String[] { "Rising__Beta_1_0" };
    if (passedArgs != null) {
      PApplet.main(concat(appletArgs, passedArgs));
    } else {
      PApplet.main(appletArgs);
    }
  }
}
