/**
* @file jennyfer.c
* @author fatma & omar <3 
* @version 1.0
* @date 20 mai 2013
* @brief Définit le personnage jennyfer ainsi que toutes les actions possibles
*/
#include <stdio.h>
#include <stdlib.h>
#include <allegro.h>
#include "background.h"
#include "chien.h"
#include "collision.h"

#include "jennyfer.h"
#define GFX_W 642
#define GFX_H 450

/**
* @fn void load_jennyfer(jennyfer *jenn)
* @details chargement des images
* @param jenn Un pointeur sur la structure jennyfer
* @return void */ 
void load_jennyfer(jennyfer *jenn)
{
	int i;
	char buf[50];
        
	for (i = 0; i <3; i++) 
           {
            sprintf(buf, "/home/fatma/jenny/images/right%d.bmp", i);
            jenn->right[i] = load_bitmap(buf, NULL);
	    sprintf(buf, "/home/fatma/jenny/images/left%d.bmp", i);
	    jenn->left[i] = load_bitmap(buf, NULL);
           }
	    jenn->bow[0]=load_bitmap("/home/fatma/jenny/images/bowright1.bmp",NULL);
	    jenn->bow[1]=load_bitmap("/home/fatma/jenny/images/bowleft1.bmp",NULL);
            jenn->blood[0]=load_bitmap("/home/fatma/jenny/vie/blood0.bmp",NULL);
	    jenn->blood[1]=load_bitmap("/home/fatma/jenny/vie/blood1.bmp",NULL);
            jenn->blood[2]=load_bitmap("/home/fatma/jenny/vie/blood2.bmp",NULL);
            jenn->blood[3]=load_bitmap("/home/fatma/jenny/vie/blood3.bmp",NULL);
            jenn->blood[4]=load_bitmap("/home/fatma/jenny/vie/blood4.bmp",NULL);
            jenn->blood[5]=load_bitmap("/home/fatma/jenny/vie/blood5.bmp",NULL);
            jenn->gramp[0]=load_bitmap("/home/fatma/jennyfer/images/gramp0.bmp",NULL);
            jenn->gramp[1]=load_bitmap("/home/fatma/jennyfer/images/gramp1.bmp",NULL);
	    jenn->grampF[0]=load_bitmap("/home/fatma/jennyfer/images/gramp2.bmp",NULL);
}
		
  /**
* @fn void destroy_jennyfer(jennyfer *jenn)
* @details il ecrase ce qu'il y'a dans le Buffer
* @param jenn Un pointeur sur la structure jennyfer
* @return void */               

void destroy_jennyfer(jennyfer *jenn)
{ 
   int i;
   for (i = 0; i <3; i++) 
       {
        destroy_bitmap(jenn->right[i]);
        destroy_bitmap(jenn->left[i]);
	}
   for (i=0;i<6;i++)
       {
        destroy_bitmap(jenn->blood[i]);
       }
}
/**
* @fn void init_jennyfer(jennyfer *jenn)
* @details Les champs direction et position(x,y) sont initialisés avant
* que le programme entre dans la boucle de jeu
* @param jenn Un pointeur sur la structure jennyfer
* @return void */
void init_jennyfer(jennyfer *jenn)
{
	jenn->direction = 0;
	jenn->x = 20;
	jenn->y = 325;
}
/**
* @fn void move_jennyfer_right(jennyfer *jenn,int *compteur,BITMAP * Background) 
* @details elle permet au perso de se dèplacer vers la droite
* @param jenn Un pointeur sur la structure jennyfer 
* compteur son adresse aide pour le passage d'une image a une autre il est de type int 
* @return void */ 
void move_jennyfer_right(jennyfer *jenn,int *compteur,BITMAP * Background)
{       Sprite sprite1;
	sprite1.x=jenn->x;
	sprite1.y=jenn->y;
	sprite1.w=jenn->right[*compteur % 2]->w;
	sprite1.h=jenn->right[*compteur % 2]->h;

	if (key[KEY_RIGHT] && (jenn->x < SCREEN_W - jenn->right[0]->w) && !collision_background_right(sprite1,Background))
            {
	      *compteur+=1;
              (jenn->x)+=2;
	      jenn->direction = 0; //right
	    }
}
/**
* @fn void move_jennyfer_left(jennyfer *jenn,int *compteur,BITMAP * Background) 
* @details elle permet au perso de se dèplacer vers la gauche
* @param jenn Un pointeur sur la structure jennyfer 
* compteur son adresse aide pour le passage d'une image a une autre il est de type int 
* @return void */ 
void move_jennyfer_left(jennyfer *jenn,int *compteur,BITMAP * Background)
{       Sprite sprite1;
	sprite1.x=jenn->x;
	sprite1.y=jenn->y;
	sprite1.w=jenn->left[*compteur % 2]->w;
	sprite1.h=jenn->left[*compteur % 2]->h;

	if (key[KEY_LEFT] && (jenn->x > 7)&& !collision_background_left(sprite1,Background)) 
              {
	        *compteur+=1;
                (jenn->x)-=2;
		jenn->direction = 1; //left
	       }
}
/**
* @fn void jump_jennyfer(jennyfer *jennBITMAP * Background) 
* @details elle permet au perso de se dèplacer vers le haut
* @param jenn Un pointeur sur la structure jennyfer  
* @return void */ 
void jump_jennyfer(jennyfer *jenn,BITMAP * Background)
{       Sprite sprite1;
	sprite1.x=jenn->x;
	sprite1.y=jenn->y;
	sprite1.w=jenn->right[2]->w;
	sprite1.h=jenn->right[2]->h;

	if (key[KEY_UP] && (jenn->y > 0) && !collision_background_up(sprite1,Background))
            {
	      (jenn->y)-=12;
	      jenn->direction = 2;
	    }
}
void move_jennyfer_gramp(jennyfer *jenn,int *compteur)
{
   if ((key[KEY_UP]) && (key[KEY_SPACE])&& (key[KEY_LEFT])&& (jenn->x > 7))
    {          *compteur+=1 ;
           (jenn->x)-=1 ;
          jenn->direction=4;
} }
/**
* @fn void bow_jennyfer(jennyfer *jenn,BITMAP * Background) 
* @details elle permet au perso de se dèplacer vers la bas
* @param jenn Un pointeur sur la structure jennyfer 
* @return void */ 
void bow_jennyfer(jennyfer *jenn,BITMAP *Background)
{ 
   if (key[KEY_DOWN] )
      {
      jenn->direction = 3;
      }
}

/**
* @fn void move_jennyfer(jennyfer *jenn,int *compteur,BITMAP * Background) 
* @details elle permet au perso de se dèplacer , elle fait appel au 5 fonctions 
* @param jenn Un pointeur sur la structure jennyfer 
* compteur son adresse aide pour le passage d'une image a une autre il est de type int 
* @return void */ 
void move_jennyfer(jennyfer *jenn,int *compteur,BITMAP * Background)
{
	move_jennyfer_right(jenn,compteur,Background);
	move_jennyfer_left(jenn,compteur,Background);
	jump_jennyfer(jenn,Background);
        gravity_jennyfer(jenn,Background);
	bow_jennyfer(jenn,Background);

}

void gravity(int *y)

{
	*y+=1;
}
/**
* @fn void gravity_jennyfer(jennyfer *jenn,BITMAP * Background) 
* @details elle permet au perso d'avoir une gravitè 
* @param jenn Un pointeur sur la structure jennyfer 
* @return void */ 
void gravity_jennyfer(jennyfer *jenn,BITMAP * Background)

{       Sprite sprite1;
	sprite1.x=jenn->x;
	sprite1.y=jenn->y;
	sprite1.w=jenn->right[0]->w;
	sprite1.h=jenn->right[0]->h;

	if(!collision_background_down(sprite1,Background))
		gravity(&(jenn->y));
}

/**
* @fn void draw_jennyfer(jennyfer jenn,BITMAP * Buffer,int compteur) 
* @details elle permet l'affichage du perso selon sa direction et son mouvement 
*@brief on utilise la fonction draw_sprite pour l'affichage des sprites 
* @param jenn de type jennyfer , Buffer qui est la memoire ou se charge les images 
* compteur aide pour l'affichage et le passage d'une image a une autre il est de type int 
* @return void */ 


void draw_jennyfer(jennyfer jenn,BITMAP *Buffer, int compteur)
{
	static int last_direction;

	if (jenn.direction == 0){ //moving right

		draw_sprite(Buffer, jenn.right[compteur % (2) ],jenn.x, jenn.y);
		last_direction=0;
	}

	if(jenn.direction == 1){ //moving left

		draw_sprite(Buffer, jenn.left[compteur % (2) ],jenn.x, jenn.y);
		last_direction=1;
	}
	if (jenn.direction == 2 && last_direction==0) {

		draw_sprite(Buffer, jenn.right[2],jenn.x, jenn.y);
	}
	if (jenn.direction == 2 && last_direction==1) {	//jumping left

		draw_sprite(Buffer, jenn.left[2],jenn.x, jenn.y);
	}
	if (jenn.direction == 3 && last_direction==0) {

		draw_sprite(Buffer, jenn.bow[0],jenn.x, jenn.y);
	}
	if (jenn.direction == 3 && last_direction==1) {

		draw_sprite(Buffer, jenn.bow[1],jenn.x, jenn.y);
	}

              if(jenn.direction == 4){

		draw_sprite(Buffer, jenn.gramp[compteur % (1) ],jenn.x, jenn.y);

	}  if (jenn.direction==5)
            { draw_sprite(Buffer, jenn.grampF[0],jenn.x, jenn.y);}
 }
/**
* @fn void throw(jennyfer *jenn,BITMAP * Buffer,BITMAP *viande , int *s) 
* @details  elle permet l'affichage du morceau de la viande pri par jennyfer
* @param jenn est un pointeur sur le structure jennyfer,Buffer qui est la memoire ou se charge les images 
* s de type int aide pour l'afffichage de l'image mission accomplie 
* @return void */ 
void throw (int *s)
{     

     if ((key[KEY_SPACE]))

     {
       
       *s=1 ;
      }

}
/**
* @fn void blood (BITMAP *BLOOD ,BITMAP *Buffer, jennyfer *jenn, int *k)
* @details L'affihage de la barre d'energie dans chaque Background 
* @param jenn Un pointeur sur la structure jennyfer, Buffer memoire ou se charge les images 
*BLOOD de type BITMAP elle stocke la dernière image chargè
*k son adress nous permet le passae d'une image d'energie a une autre 
* @return void */

void blood(BITMAP *BLOOD ,BITMAP *Buffer, jennyfer *jenn, int *k)
{
      BLOOD=jenn->blood[*k % (5)];
	draw_sprite(Buffer, BLOOD,0,0 ) ;


}
