/**
* @file perso.c
* @author fatma & omar <3
* @version 1.0
* @date 20 mai 2013
* @brief Définit le personnage rat ainsi que les objets qui ont un mouvement repetè
*/
#include <allegro.h>
#include <stdio.h>
#include <stdlib.h>
#include"background.h"
#include "collision.h"
#include "jennyfer.h"
#include "perso.h"
#define GFX_W 642
#define GFX_H 450

/**
*@brief module cle
*/


/**
* @fn void draw_clef(clef clef,BITMAP * Buffer,int *CLEE) 
* @details elle permet l'affichage de l'objet  
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param clef de type clef , Buffer qui est la memoire ou se charge les images 
* si cLEE=0 elle permet l'affichage de l'image de la clè 
* @return void */

void draw_clef(clef clef,BITMAP *Buffer,int *CLEE)
 { if (*CLEE==0)
      {
       draw_sprite(Buffer, clef.CLE[0],clef.x, clef.y);
      } 
}

/**
* @fn void load_clef(clef *clef)
* @details chargement des images
* @param clef Un pointeur sur la structure clef
* @return void */

void load_clef(clef *clef)
{

 clef->CLE[0]=load_bitmap("/home/fatma/jenny/images/cle.bmp",NULL);
}

/**
* @fn void init_clef(clef *clef)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param clef Un pointeur sur la structure clef
* @return void */

void init_clef(clef *clef)
{ clef->x= 600;
  clef->y=167;
}

/**
* @fn void cle(clef *clef , jennyfer *jenn , int *CLEE)
* @brief cette fonction permet a la variable CLEE de recevoir 1 qui va lui permettre de prendre la clè
* @param clef Un pointeur sur la structure clef
*jenn Un pointeur sur la structure jennyfer
*l'adresse de la variable CLEE qui est de type entier nous permet d'obtenir la clè
* @return void */

void cle(clef *clef , jennyfer *jenn , int *CLEE)
{ 
  if ((jenn->x >550) && ( jenn->y>155) && (jenn->y<290))
      { *CLEE=1 ;
      }
}

/**
*@brief module barre qui se translate sur l'axe des y
*/



/**
* @fn void load_barre(barre *barre)
* @details chargement des images
* @param barre Un pointeur sur la structure barre
* @return void */

void load_barre(barre *barre)
{
  barre->BR[0]=load_bitmap("/home/fatma/jenny/images/barre.bmp",NULL);
}

/**
* @fn void destroy_barre(barre *barre)
* @details il ecrase ce qu'il y'a dans le Buffer
* @param barre Un pointeur sur la structure barre
* @return void */ 

void destroy_barre(barre *barre)
{
  destroy_bitmap(barre->BR[0]);
}
/**
* @fn void init_barre(barre *barre)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param barre Un pointeur sur la structure barre
* @return void */
void init_barre(barre *barre)
{
 barre->direction = 2;
 barre->x = 370;
 barre->y = 40;
}
/** 
* @fn void move_barre_up(barre *barre)
*@details elle permet au perso de se dèplacer vers le haut
*@brief c'est la translation sur l'axe des y
* @param barre Un pointeur sur la structure barre 
* @return void */

void move_barre_up(barre *barre)
{
  verifdirr(barre);
  if (barre->direction==2 )
    {
      (barre->y)-=1;
    }
}

/** 
* @fn void move_barre_down(barre *barre)
*@details elle permet au perso de se dèplacer vers le bas
*@brief c'est la translation sur l'axe des y
* @param barre Un pointeur sur la structure barre 
* @return void */

void move_barre_down(barre *barre)
{  verifdirr(barre);
   if (barre->direction==3 )
     {
      (barre->y)+=1;
     }
}
/** 
* @fn void verifdirr(barre *barre)
*@details verifie la direction
* @param barre Un pointeur sur la structure barre
* @return void */
void verifdirr(barre *barre)
{
    if(barre->y<100)
	barre->direction=3 ;
    else
	if (barre->y>420)
	   barre->direction=2 ;
}
/** 
* @fn void move_barre(barre *barre)
*@details elle permet au perso de se dèplacer vers le haut et vers le bas d'un mouvement continue
*@brief cettte fonction fait appel a 2 fonction move_barre_down et move_barre_up
* @param barre Un pointeur sur la structure barre 
* @return void */
void move_barre(barre *barre)
{
  move_barre_down(barre);
  move_barre_up(barre);


}
/**
* @fn void draw_barre(barre barre,BITMAP * Buffer) 
* @details elle permet l'affichage de l'objet selon sa direction et son mouvement 
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param barre de type barre , Buffer qui est la memoire ou se charge les images 
* @return void */

void draw_barre(barre barre,BITMAP *Buffer)
{

draw_sprite(Buffer, barre.BR[0],barre.x, barre.y);
}
/**
* @fn void barreD(jennyfer *jenn,int *br,BITMAP *Buffer)
* @details elle permet le mouvement de la barre qui est en attente
*@brief au moment ou le joueur appuiera sur space la barre commencera a bouger
* @param jenn est un pointeur sur la structure jennyfer , Buffer qui est la memoire ou se charge les images
*au moment ou br qui est de type int sera egale a un la barre commencera son mouventemt
* @return void */
                                                                                                                                                                                                                                  
void barreD(jennyfer *jenn,int *br,BITMAP *Buffer)
 {

if ((key[KEY_SPACE]) && (jenn->x<318) && (jenn->x>287) && (jenn->y<225))
      { *br=1; }
}

/**
* @fn void col_barre(BITMAP *Buffer, barre *barre, jennyfer *jenn)
* @details elle permet de detecter la collision entre jennyfer et la barre
* @param jenn est un pointeur sur la structure jennyfer , Buffer qui est la memoire ou se charge les images
*barre est un pointeur sur la structure barre
* @return void */
void col_barre(BITMAP *Buffer, barre *barre, jennyfer *jenn)
{
  Sprite Sprite1;
  Sprite Sprite2;
  Sprite1.x=jenn->x;
  Sprite1.y=jenn->y;
  Sprite1.w=jenn->right[0]->w;
  Sprite1.h=jenn->right[0]->h;
  Sprite2.x=barre->x;
  Sprite2.y=barre->y;
  Sprite2.w=barre->BR[0]->w;
  Sprite2.h=barre->BR[0]->h;

    if (bounding_box_collision(Sprite1,Sprite2)==1)
        {
	jenn->y=barre->y-115;
        }
}
/**
*@brief module barre1 qui se translate sur l'axe des x
*/



/**
* @fn void load_barre1(barre1 *barre1)
* @details chargement des images
* @param barre1 Un pointeur sur la structure barre1
* @return void */

void load_barre1(barre1 *barre1)
{
 barre1->BR1[0]=load_bitmap("/home/fatma/jenny/images/barre1.bmp",NULL);
}
/**
* @fn void destroy_barre1(barre1 *barre)1
* @details il ecrase ce qu'il y'a dans le Buffer
* @param barre1 Un pointeur sur la structure barre1
* @return void */ 
void destroy_barre1(barre1 *barre1)
{
 destroy_bitmap(barre1->BR1[0]);
}

/**
* @fn void init_barre1(barre1 *barre1)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param barre1 Un pointeur sur la structure barre1
* @return void */

void init_barre1(barre1 *barre1)
{
 barre1->direction = 1;
 barre1->x = 360;
 barre1->y = 300;
}
/** 
* @fn void move_barre1_right(barre1 *barre1)
*@details elle permet au perso de se dèplacer vers la droite
*@brief c'est la translation sur l'axe des x
* @param barre1 Un pointeur sur la structure barre1 

* @return void */

void move_barre1_right(barre1 *barre1)
{ 
  verifd(barre1);
  if (barre1->direction==0)
   {
    (barre1->x)+=1;
   }
}


/** 
* @fn void move_barre1_left(barre1 *barre1)
*@details elle permet au perso de se dèplacer vers la gauche
*@brief c'est la translation sur l'axe des x
* @param barre1 Un pointeur sur la structure barre1 
* @return void */
void move_barre1_left(barre1 *barre1)
{  verifd(barre1);
   if (barre1->direction==1 )
     {
      (barre1->x)-=1;
     }
}
/** 
* @fn void verifd(barre1 *barre1)
*@details verifie la direction
* @param barre1 Un pointeur sur la structure barre1
* @return void */

void verifd(barre1 *barre1)
{  if(barre1->x>480)
	barre1->direction=1 ;
   else
	if (barre1->x<254)
	    barre1->direction=0 ;
}
/** 
* @fn void move_barre1(barre1 *barre1)

*@details elle permet au perso de se dèplacer vers la droite et vers la gauche d'un mouvement continue
*@brief cettte fonction fait appel a 2 fonction move_barre1_right et move_barre1_left
* @param barre1 Un pointeur sur la structure barre1 
* @return void */
void move_barre1(barre1 *barre1)
{
 move_barre1_left(barre1);
 move_barre1_right(barre1);


}

/**
* @fn void draw_barre1(barre1 barre1,BITMAP * Buffer) 
* @details elle permet l'affichage de l'objet selon sa direction et son mouvement 
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param barre1 de type barre1 , Buffer qui est la memoiretampon ou se charge les images 
* @return void */
void draw_barre1(barre1 barre1,BITMAP *Buffer)
{
 draw_sprite(Buffer, barre1.BR1[0],barre1.x, barre1.y);
}
/**
* @fn void col_barre1(BITMAP *Buffer, barre1 *barre1, jennyfer *jenn)
* @details elle permet de detecter la collision entre jennyfer et la barre1
* @param jenn est un pointeur sur la structure jennyfer , Buffer qui est la memoire ou se charge les images
*barre1 est un pointeur sur la structure barre1
* @return void */
void col_barre1(BITMAP *Buffer, barre1 *barre1, jennyfer *jenn)
{ 
    Sprite Sprite1;
    Sprite Sprite2;
    Sprite1.x=jenn->x;
    Sprite1.y=jenn->y;
    Sprite1.w=jenn->right[0]->w;
    Sprite1.h=jenn->right[0]->h;
    Sprite2.x=barre1->x;
    Sprite2.y=barre1->y;
    Sprite2.w=barre1->BR1[0]->w;
    Sprite2.h=barre1->BR1[0]->h;
 
    if (bounding_box_collision(Sprite1,Sprite2)==1)
       {
	 jenn->y=barre1->y-110;
         jenn->x=barre1->x+10;
       }

}

/**
*@brief module barre2 mouvement repetè sur l'axe des y
*/

/**
* @fn void load_barre2(barre2 *barre2)
* @details chargement des images
* @param barre2 Un pointeur sur la structure barre2
* @return void */
void load_barre2(barre2 *barre2)
{
 barre2->BR2[0]=load_bitmap("/home/fatma/jenny/images/BR.bmp",NULL);
}
/**
* @fn void destroy_barre2(barre2 *barre2)
* @details il ecrase ce qu'il y'a dans le Buffer
* @param barre2 Un pointeur sur la structure barre2
* @return void */ 
void destroy_barre2(barre2 *barre2)
{
 destroy_bitmap(barre2->BR2[0]);
}
/**
* @fn void init_barre2(barre2 *barre2)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param barre2 Un pointeur sur la structure barre2
* @return void */

void init_barre2(barre2 *barre2)
{
	barre2->direction = 2;
	barre2->x = 145;
	barre2->y = 40;
}
/** 
* @fn void move_barre2_down(barre2 *barre2)
*@details elle permet au perso de se dèplacer vers le haut
*@brief c'est la translation sur l'axe des y
* @param barre2 Un pointeur sur la structure barre2 
* @return void */
void move_barre2_up(barre2 *barre2)
{
  veri(barre2);
  if (barre2->direction==2 )
   {
    (barre2->y)-=1;
   }
}

/** 
* @fn void move_barre2_down(barre2 *barre2)
*@details elle permet au perso de se dèplacer vers le bas
*@brief c'est la translation sur l'axe des y
* @param barre2 Un pointeur sur la structure barre2 
* @return void */

void move_barre2_down(barre2 *barre2)
{  veri(barre2);
   if (barre2->direction==3 )
      {
       (barre2->y)+=1;
      }
}
/** 
* @fn void veri(barre2 *barre2)
*@details verifie la direction
* @param barre2 Un pointeur sur la structure barre2
* @return void */

void veri(barre2 *barre2)
{
  if(barre2->y<100)
	barre2->direction=3 ;
  else
      if (barre2->y>420)
	barre2->direction=2 ;
}
/** 
* @fn void move_barre2(barre2 *barre2)

*@details elle permet au perso de se dèplacer vers le haut et vers le bas d'un mouvement continue
*@brief cettte fonction fait appel a 2 fonction move_barre_down et move_barre_up
* @param barre2 Un pointeur sur la structure barre2 
* @return void */
void move_barre2(barre2 *barre2)
{ 
move_barre2_down(barre2);
move_barre2_up(barre2);
}

/**
* @fn void draw_barre2(barre2 barre2,BITMAP * Buffer) 
* @details elle permet l'affichage de l'objet selon sa direction et son mouvement 
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param barre2 de type barre2 , Buffer qui est la memoire ou se charge les images 
* @return void */

void draw_barre2 (barre2 barre2,BITMAP *Buffer)
{
draw_sprite(Buffer, barre2.BR2[0],barre2.x, barre2.y);
}

/**
* @fn void col_barre2(BITMAP *Buffer, barre2 *barre2, jennyfer *jenn)
* @details elle permet de detecter la collision entre jennyfer et la barre2
* @param jenn est un pointeur sur la structure jennyfer , Buffer qui est la memoire ou se charge les images
*barre2 est un pointeur sur la structure barre2
* @return void */
void col_barre2(BITMAP *Buffer, barre2 *barre2, jennyfer *jenn)
{    
     Sprite Sprite1;
     Sprite Sprite2;
     Sprite1.x=jenn->x;
     Sprite1.y=jenn->y;
     Sprite1.w=jenn->right[0]->w;
     Sprite1.h=jenn->right[0]->h;
     Sprite2.x=barre2->x;
     Sprite2.y=barre2->y;
     Sprite2.w=barre2->BR2[0]->w;
     Sprite2.h=barre2->BR2[0]->h;
 
    if (bounding_box_collision(Sprite1,Sprite2)==1)
       {
	jenn->y=barre2->y-110;
       }
}

/**
*@brief module file 
*mouvement repetè sur l'axe des x 
*/
/**
* @fn void load_file(file *file)
* @details chargement des images
* @param file Un pointeur sur la structure file
* @return void */
void load_file(file *file)
{
 file->FILE[0]=load_bitmap("/home/fatma/jenny/images/file.bmp",NULL);
}
/**
* @fn void destroy_file (file *file)
* @details il ecrase ce qu'il y'a dans le Buffer
* @param file Un pointeur sur la structure file
* @return void */
void destroy_file(file *file)
{
 destroy_bitmap(file->FILE[0]);
}
/**
* @fn void init_file(file *file)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param file Un pointeur sur la structure file
* @return void */
void init_file(file *file)
{
	file->direction = 0;
	file->x = 290;
	file->y = 0;
}
/** 
* @fn void move_file_right(file *file)
*@details elle permet au perso de se dèplacer vers la droite
*@brief c'est la translation sur l'axe des x
* @param file Un pointeur sur la structure file 
* @return void */
void move_file_right(file *file)
{
  verif(file);
  if (file->direction==0)
     {
       (file->x)+=1;
     }
}

/** 
* @fn void move_file_left(barre1 *barre1)
*@details elle permet au perso de se dèplacer vers la gauche
*@brief c'est la translation sur l'axe des x
* @param file Un pointeur sur la structure file 
* @return void */

void move_file_left(file *file)
{  verif(file);
   if (file->direction==1 )
      {
       (file->x)-=1;
      }
}

/** 
* @fn void verif(file *file)
*@details verifie la direction
* @param file Un pointeur sur la structure file
* @return void */
void verif(file *file)
{
   if(file->x>380)
      file->direction=1 ;
   else
	if (file->x<250)
	   file->direction=0 ;
}

/** 
* @fn void move_file(file *file)
*@details elle permet au perso de se dèplacer vers la droite et vers la gauche d'un mouvement continue
*@brief cettte fonction fait appel a 2 fonction move_file_right et move_file_left
* @param file Un pointeur sur la structure file 
* @return void */
void move_file(file *file)
{
move_file_left(file);
move_file_right(file);
}

/**
* @fn void draw_file(file file ,BITMAP * Buffer) 
* @details elle permet l'affichage de l'objet selon sa direction et son mouvement 
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param file de type file , Buffer qui est la memoire ou se charge les images 
* @return void */
void draw_file(file file ,BITMAP *Buffer)
{
draw_sprite(Buffer, file.FILE[0],file.x, file.y);
}
/**
* @fn void col_file(BITMAP *Buffer, file *file, jennyfer *jenn)
* @details elle permet de detecter la collision entre jennyfer et la barre2
* @param jenn est un pointeur sur la structure jennyfer , Buffer qui est la memoire ou se charge les images
*file est un pointeur sur la structure file
* @return void */

void col_file(BITMAP *Buffer, file *file, jennyfer *jenn)
{ 
    Sprite Sprite1;
    Sprite Sprite2;
    Sprite1.x=jenn->x;
    Sprite1.y=jenn->y;
    Sprite1.w=jenn->right[0]->w;
    Sprite1.h=jenn->right[0]->h;
    Sprite2.x=file->x;
    Sprite2.y=file->y;
    Sprite2.w=file->FILE[0]->w;
    Sprite2.h=file->FILE[0]->h;
     
  if (bounding_box_collision(Sprite1,Sprite2)==1)
   {   
       jenn->direction=5;
       jenn->y=file->y+15;
       jenn->x=file->x-25;
       if (key[KEY_RIGHT])
         { 
             jenn->x=400;
             jenn->y=0;
         }
   }
}




/**
*@brief module rat 
*mouvement repetè sur l'axe des x 
*/

/**
* @fn void load_rat(rat *rat)
* @details chargement des images
* @param rat Un pointeur sur la structure rat
* @return void */

void load_rat(rat *rat)
{
 rat->RAT[0]=load_bitmap("/home/fatma/jenny/images/rat0.bmp",NULL);
 rat->RAT[1]=load_bitmap("/home/fatma/jenny/images/rat1.bmp",NULL);
}
/**
* @fn void destroy_rat (rat *rat)
* @details il ecrase ce qu'il y'a dans le Buffer
* @param rat Un pointeur sur la structure rat
* @return void */
void destroy_rat(rat *rat)
{
destroy_bitmap(rat->RAT[0]);
destroy_bitmap(rat->RAT[1]);
}

/**
* @fn void init_rat(rat *rat)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param rat Un pointeur sur la structure rat
* @return void */
void init_rat(rat *rat)
{
	rat->direction = 1;
	rat->x = 266;
	rat->y = 365;
}

/** 
* @fn void move_rat_right(rat *rat)
*@details elle permet au perso de se dèplacer vers la droite
*@brief c'est la translation sur l'axe des x
* @param rat Un pointeur sur la structure rat 
* @return void */
void move_rat_right(rat *rat)
{
 verifdirre(rat);
 if (rat->direction==0 )
   {
     (rat->x)+=1;

   }
}

/** 
* @fn void move_rat_left(rat *rat)
*@details elle permet au perso de se dèplacer vers la gauche
*@brief c'est la translation sur l'axe des x
* @param rat Un pointeur sur la structure rat 
* @return void */

void move_rat_left(rat *rat)
{  verifdirre(rat);
   if (rat->direction==1 )
     {
     (rat->x)-=1;
     }
}
/** 
* @fn void verifdirre(rat *rat)
*@details verifie la direction
* @param rat Un pointeur sur la structure rat
* @return void */

void verifdirre(rat *rat)
{
 if(rat->x>265)
    rat->direction=1 ;
 else
    if (rat->x<116)
	 rat->direction=0 ;
}
/** 
* @fn void move_rat(rat *rat)
*@details elle permet au perso de se dèplacer vers la droite et vers la gauche d'un mouvement continue
*@brief cettte fonction fait appel a 2 fonction move_rat_right et move_rat_left
* @param rat Un pointeur sur la structure rat
* @return void */
void move_rat(rat *rat)
{
move_rat_left(rat);
move_rat_right(rat);	 	
}

/**
* @fn void draw_rat(rat rat  ,BITMAP * Buffer) 
* @details elle permet l'affichage du personnage rat selon sa direction et son mouvement 
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param rat de type rat , Buffer qui est la memoire ou se charge les images 
* @return void */
void draw_rat(rat rat ,BITMAP *Buffer)
{

if (rat.direction == 0)
   {
  draw_sprite(Buffer, rat.RAT[1],rat.x, rat.y);

   }

if(rat.direction == 1)
 {
  draw_sprite(Buffer, rat.RAT[0],rat.x,rat.y);
 }

}
