#define NBREVIF 100

#include <stdio.h>
#include <stdlib.h>
#include <allegro.h>
#include <time.h>




/**********************/
/*     STRUCTURES     */
/**********************/

// chaque acteur qui se déplace
typedef struct acteur
{

    // position du coin sup. gauche
    int x,y;

    // vecteur deplacement
    int dx,dy;

    // largeur hauteur
    int tx,ty;

    // couleur (ne sera plus pertinent avec des sprites importés...)
    int couleur;

    // type (ici 2 types mais on peut en mettre plus):
    //   0 laser
    //   1 missile (accélération horizontale)
    int type;

    // comportement :
    //   0 normal déplacement
    //   1 explosion
    int comportement;
    int cptexplo; // temps depuis l'explosion

    // vivant :
    //   0 mort (doit disparaitre de la liste)
    //   1 vivant
    int vivant;

} t_acteur;

// Une collection de acteurs
typedef struct listeActeurs
{
    // nombre maxi d'éléments
    // =taille du tableau de pointeurs
    int max;

    // nombre effectif de pointeurs utilisés
    // (les autres sont à NULL)
    int n;

    // le tableau de pointeurs (alloué dynamiquement)
    t_acteur **tab;

} t_listeActeurs;


// Spécifique à cet exemple : un vaisseau et une cible

// Un élément à déplacement interactif
typedef struct joueur{
    int x,y;     // position
    int tx,ty;   // taille
    int vit;     // vitesse des déplacements (nombre de pixels)
    int cpttir0; // tempo armement 0
    int cpttir1; // tempo armement 1
    BITMAP *img; // sprite (image chargée)
} t_joueur;

// Un élément à déplacement automatique aléatoire
typedef struct ennemi{
    int x,y;     // position
    int dx,dy;   // vecteur déplacement
    int tx,ty;   // taille
    BITMAP *img; // sprite (image chargée)
} t_ennemi;

typedef struct vif{
    int x,y;     // position
    int dx,dy;   // vecteur déplacement
    int tx,ty;   // taille
    BITMAP *img; // sprite (image chargée)
} t_vif;


/*********************/
/*     PROTOTYPES    */
/*********************/

// Allouer et initialiser un acteur
// pour ce projet il faut x y de départ et type
//   ( à adapter selon besoins )
t_acteur * creerActeur(int x,int y,int type);

// Allouer et initialiser une liste (vide) de acteurs
t_listeActeurs * creerListeActeurs(int maxacteurs);

// Retourne un booléen vrai si il reste de la place
// dans la liste, faux sinon
int libreListeActeurs(t_listeActeurs *la);

// Allouer et ajouter un acteur à la liste
// et retourner l'adresse de ce nouveau acteur
// retourne NULL en cas de problème
// pour ce projet il faut x y de départ et type
//   ( à adapter selon besoins )
t_acteur * ajouterActeur(t_listeActeurs *la,int x,int y,int type);

// Enlever et libèrer un acteur qui était dans la liste en indice i
void enleverActeur(t_listeActeurs *la,int i);



// Actualiser un acteur (bouger ...)
void actualiserActeur(t_acteur *acteur);

// Gérer l'évolution de l'ensemble des acteurs
void actualiserListeActeurs(t_listeActeurs *la);


// Dessiner un acteur sur la bitmap bmp
void dessinerActeur(BITMAP *bmp,t_acteur *acteur);

// Dessiner sur une bitmap l'ensemble des acteurs
void dessinerListeActeurs(BITMAP *bmp,t_listeActeurs *la);


// Un acteur a été touché ou a touché une cible : modifier son état
// ici on indique qu'il passe en comportement 1 (explosion)
// et le vecteur vitesse est divisé en norme (ralentissement)
void destinActeur(t_acteur *acteur);

// Gérer collision (éventuelle) entre un acteur (un tir) et un ennemi
void collisionActeur(t_ennemi *ennemi,t_acteur *acteur);

// Gérer les collisions entre les acteurs (tous les tirs) et un ennemi
void collisionListeActeurs(t_ennemi *ennemi,t_listeActeurs *la);


// Spécifique à cet exemple : gérer le vaisseau et la cible

// Allouer et initialiser joueur
t_joueur * creerJoueur(char *nomimage);

// Actualiser joueur (bouger interactivement et tirer...)
void actualiserJoueur(t_joueur *joueur,t_listeActeurs *la);

// Dessiner joueur sur la bitmap bmp
void dessinerJoueur(BITMAP *bmp,t_joueur *joueur);


// Allouer et initialiser ennemi
t_ennemi * creerEnnemi(char *nomimage);

t_vif * creerVif(char *nomimage);


// Actualiser ennemi (bouger automatiquement au hasard...)
void actualiserEnnemi(t_ennemi *ennemi);

void actualiserVif(t_vif *vif);
// Dessiner ennemi sur la bitmap bmp
void dessinerEnnemi(BITMAP *bmp,t_ennemi *ennemi);
void dessinerVif(BITMAP *bmp,t_vif *vif);

int main()
{
struct ennemi*ennemi[20];
struct vif*vif[5];
    // Buffer
    BITMAP *page;

    // Image de fond
    BITMAP *decor;

    BITMAP *badvif;

    BITMAP *bonvif;

    BITMAP *regle;

    BITMAP *pause;

    BITMAP *arriere;

    BITMAP *vie;

    // La collection des acteurs (les tirs)
    t_listeActeurs *acteurs;

    // Le vaisseau manipulé par le joueur
    t_joueur *vaisseau;

    // La cible qui se déplace automatiquement
    //t_ennemi *cible;

    // Il y aura du hasard
    srand(time(NULL));

    // Lancer allegro et le mode graphique
    allegro_init();
    install_keyboard();
     install_mouse();

    set_color_depth(desktop_color_depth());
    if (set_gfx_mode(GFX_AUTODETECT_WINDOWED,1300,700,0,0)!=0)
    {
        allegro_message("prb gfx mode");
        allegro_exit();
        exit(EXIT_FAILURE);
    }

    // buffer
    page=create_bitmap(SCREEN_W,SCREEN_H);

    // charger image de fond
    decor=load_bitmap("fond.bmp",NULL);
    badvif=load_bitmap("vif2.bmp",NULL);
    bonvif=load_bitmap("vif.bmp",NULL);
    regle=load_bitmap("regle.bmp",NULL);
    pause=load_bitmap("pause.bmp",NULL);
    vie=load_bitmap("vie6.bmp",NULL);

    if (!decor)
    {
        allegro_message("pas pu trouver le fond.bmp");
        exit(EXIT_FAILURE);
    }

    // créer le vaisseau et la cible
//    vaisseau=creerJoueur("bonharry.bmp");



    // préparer la liste des acteurs (100 maxi)
    // mais vide initialement
//    acteurs=creerListeActeurs(100);
int i;
int jeu=0;
int depart=0;
    t_ennemi * cible [NBREVIF];

    for( i = 0;i<NBREVIF;i++)
    {
        cible[i] = creerEnnemi("vif2.bmp");

    }

     t_vif * cible1 [5];

    for( i = 0;i<5;i++)
    {
        cible1[i] = creerVif("vif.bmp");
    }
    show_mouse(screen);
    // BOUCLE DE JEU
    while (!key[KEY_ESC])
    {
        blit(regle,page,0,0,0,0,SCREEN_W,SCREEN_H);
        blit(page,screen,0,0,0,0,SCREEN_W,SCREEN_H);
        if (key[KEY_ENTER])
        {
            //clear_bitmap(page);

           regle=decor;
           depart=1;
        }
        if (depart==1)
        {
            masked_blit(vie,page,0,0,0,0,SCREEN_W,SCREEN_H);
            blit(page,screen,0,0,0,0,SCREEN_W,SCREEN_H);
            if (key[KEY_P])
            {
                jeu=1;

            }
            if (jeu==1)
            {
                masked_blit(pause,page,0,0,0,0,SCREEN_W,SCREEN_H);
                blit(page,screen,0,0,0,0,SCREEN_W,SCREEN_H);
            }
            if (key[KEY_O])
            {
                jeu=0;
            }

            if (jeu==0)
            {

            if ( mouse_b&1)

            {
                printf("test : %d\n %d\n",getpixel(page,mouse_x,mouse_y),makecol(0,0,0));
                if (getpixel(page,mouse_x,mouse_y)==656652)
                {
                    //textprintf_ex(screen,font,4,6,makecol(255,0,0),makecol(0,255,0),"EXIT");
                    printf("ok");

                }
            }

        // effacer buffer en appliquant décor  (pas de clear_bitmap)
        //blit(decor,page,0,0,0,0,SCREEN_W,SCREEN_H);

        // bouger tout le monde
        //actualiserJoueur(vaisseau,acteurs);
        for(i=0;i<NBREVIF;i++)
        {
            actualiserEnnemi(cible[i]);
            dessinerEnnemi(page,cible[i]);
        }

         for(i=0;i<5;i++)
        {
            actualiserVif(cible1[i]);
            //actualisercercle
            //dessinercerclesurbuffer
            dessinerVif(page,cible1[i]);
        }

//        actualiserListeActeurs(acteurs);

        // gérer les collisions
///        collisionListeActeurs(cible,acteurs);

        // afficher tout le monde
///        dessinerJoueur(page,vaisseau);
///

   ///     dessinerListeActeurs(page,acteurs);

        // afficher tout ça à l'écran
        blit(page,screen,0,0,0,0,SCREEN_W,SCREEN_H);

        // petite temporisation
        rest(10);
    }}}

    return 0;
}
END_OF_MAIN();


// Dessiner ennemi sur la bitmap bmp
void dessinerEnnemi(BITMAP *bmp,t_ennemi *ennemi){
    draw_sprite(bmp,ennemi->img,ennemi->x,ennemi->y);
}

void dessinerVif(BITMAP *bmp,t_vif *vif){
    draw_sprite(bmp,vif->img,vif->x,vif->y);
}

// Allouer et initialiser ennemi
t_ennemi * creerEnnemi(char *nomimage){
    t_ennemi *nouv;

    // Allouer
    nouv = (t_ennemi *)malloc(1*sizeof(t_ennemi));

    // Initialiser

    nouv->img=load_bitmap(nomimage,NULL);
    if (!nouv->img)
    {
        allegro_message("pas pu trouver %s",nomimage);
        exit(EXIT_FAILURE);
    }

    nouv->tx = nouv->img->w;
    nouv->ty = nouv->img->h;

    nouv->x = SCREEN_W/2-nouv->tx;
    nouv->y = SCREEN_H/2-nouv->ty;
    nouv->dx=0;
    nouv->dy=0;

    return nouv;
}

t_vif * creerVif(char *nomimage){
    t_vif *nouv;

    // Allouer
    nouv = (t_vif *)malloc(1*sizeof(t_vif));

    // Initialiser

    nouv->img=load_bitmap(nomimage,NULL);
    if (!nouv->img)
    {
        allegro_message("pas pu trouver %s",nomimage);
        exit(EXIT_FAILURE);
    }

    nouv->tx = nouv->img->w;
    nouv->ty = nouv->img->h;

    nouv->x = SCREEN_W/2-nouv->tx;
    nouv->y = SCREEN_H/2-nouv->ty;
    nouv->dx=0;
    nouv->dy=0;

    return nouv;
}

// Actualiser ennemi
// (bouger automatiquement au hasard dans la moitié droite...)
void actualiserEnnemi(t_ennemi *ennemi){

    // proba de changement de déplacement : une chance sur 20
    if ( rand()%20==0 ){
        // Nouveau vecteur déplacement
        ennemi->dx = rand()%11-5;
        ennemi->dy = rand()%11-5;
    }

    // contrôle des bords : ici on décide de rebondir sur les bords
    if  (  ( ennemi->x < 0 && ennemi->dx < 0 ) ||
           ( ennemi->x + ennemi->tx > SCREEN_W && ennemi->dx > 0) )
        ennemi->dx = -ennemi->dx;

    if  (  ( ennemi->y < 0 && ennemi->dy < 0 ) ||
           ( ennemi->y + ennemi->ty > SCREEN_H && ennemi->dy > 0) )
        ennemi->dy = -ennemi->dy;

    // calculer nouvelle position
    // nouvelle position = position actuelle + deplacement
    ennemi->x = ennemi->x + ennemi->dx;
    ennemi->y = ennemi->y + ennemi->dy;

}


void actualiserVif(t_vif *vif){

    // proba de changement de déplacement : une chance sur 20
    if ( rand()%20==0 ){
        // Nouveau vecteur déplacement
        vif->dx = rand()%11-5;
        vif->dy = rand()%11-5;
    }

    // contrôle des bords : ici on décide de rebondir sur les bords
    if  (  ( vif->x < 0 && vif->dx < 0 ) ||
           ( vif->x + vif->tx > SCREEN_W && vif->dx > 0) )
        vif->dx = -vif->dx;

    if  (  ( vif->y < 0 && vif->dy < 0 ) ||
           ( vif->y + vif->ty > SCREEN_H && vif->dy > 0) )
        vif->dy = -vif->dy;

    // calculer nouvelle position
    // nouvelle position = position actuelle + deplacement
    vif->x = vif->x + vif->dx;
    vif->y = vif->y + vif->dy;

}