/* ********************************************************************
    WARCRAFT BATTLE : Jeu au tour par tour similaire à Final Fantasy
    développé entièrement par moi :p pour le plaisir^^
    Je sais c'est du beau quand même sa fait plaisir de faire un programme
    assez complet avec pour seule aide un clavier et une souris (et encore là
    j'ai pas de souris je programme sur pc portable xD)
    Enfin bref voilà ma création :)
    Fais en bon usage et bon jeu à toi ;)

PS : Et surtout copyright :p pas touche à mon code pas de désassemblage ni rien
hein ;) MON PROGRAMME ! :o)

@+++ amuse toi bien */



#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include "structures.h"
#include "constantes.h"
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include "prototypes.h"
#include <time.h>

int main (int argc, char *argv[])
{
    srand (time(NULL));
    SURFACES surfaces;
    POSITIONS positions;
    Finitialisersurfaces (&surfaces);
    if (SDL_Init (SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Erreur lors de l'ouverture de la SDL : %s", SDL_GetError());
        exit (EXIT_FAILURE);
    }
    surfaces.Pecran = SDL_SetVideoMode (XWIN,YWIN,32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    if (surfaces.Pecran == NULL)
    {
        fprintf(stderr,"Impossible de charger la mémoire vidéo : %s", SDL_GetError());
        exit (EXIT_FAILURE);
    }
    SDL_EnableUNICODE (1);
    TTF_Init();
    SDL_WM_SetCaption ("WARCRAFT BATTLE",NULL);
    SDL_ShowCursor(SDL_DISABLE);
    if (Fchargerimages (&surfaces) < 0) {
        TTF_Quit();
        SDL_Quit();
        return -1;
    }

    Finitialiserpositions (&positions,&surfaces);
    Fmenuprincipal (&surfaces, &positions);


    //une fois le jeu quitté
    Fdechargerimages (&surfaces);
    SDL_EnableUNICODE (0);
    TTF_Quit();
    SDL_Quit();


    return 0;
}

void Finitialisersurfaces (SURFACES *surfaces)
{
    int i;
    surfaces->Pcurseurennemis=NULL;
    surfaces->Pcurseurallies=NULL;
    surfaces->Pchoixvoleur=NULL;
    surfaces->Pchoixpretre=NULL;
    surfaces->Pchoixpaladin=NULL;
    surfaces->Pecran=NULL;
    surfaces->Pgobelin=NULL;
    surfaces->Ppaladin=NULL;
    surfaces->Ppretre=NULL;
    surfaces->Pvoleur=NULL;
    surfaces->Pmenujouer=NULL;
    surfaces->Pmenuoptions=NULL;
    surfaces->Pmenuquitter=NULL;
    surfaces->Pfondjeu=NULL;
    surfaces->Ppvpersos=NULL;
    surfaces->Ppmpersos=NULL;
    for (i=0;i<3;i++)
        surfaces->Tperso[i]=NULL;
    for (i=0;i<5;i++)
        surfaces->Tennemi[i]=NULL;
    for (i=0;i<3;i++)
        surfaces->Pnomactions[i]=NULL;
    surfaces->Ptextechoixmenu=NULL;
    surfaces->Pnbdegats=NULL;
    surfaces->Pcadrecible=NULL;
    surfaces->Pnomcible=NULL;
    surfaces->Pactive=NULL;
    surfaces->Pdesactive=NULL;
    surfaces->Ppvcible=NULL;
    surfaces->Ppmcible=NULL;
    surfaces->Pcadreactions=NULL;
    surfaces->Pactionselectionnee=NULL;
    surfaces->Pactiondesactivee=NULL;
    surfaces->Pmort=NULL;
    for (i=0;i<3;i++)
        surfaces->Pquantite[i]=NULL;
}

void Finitialiserpositions (POSITIONS *positions, SURFACES *surfaces)
{
    int i,y=0,z=0;
    positions->Vpositionmenu.x = 0;
    positions->Vpositionmenu.y = 0;
    positions->Vpositionmenupretre.x = XWIN/2 - surfaces->Ppretre->w/2;
    positions->Vpositionmenupretre.y = YWIN - 20 - surfaces->Ppretre->h;
    positions->Vpositionmenupaladin.x = positions->Vpositionmenupretre.x/2 - surfaces->Ppaladin->w/2;
    positions->Vpositionmenupaladin.y = YWIN - 20 - surfaces->Ppaladin->h;
    positions->Vpositionmenuvoleur.x = XWIN/4*3 - surfaces->Pvoleur->w/2;
    positions->Vpositionmenuvoleur.y = YWIN - 20 - surfaces->Pvoleur->h;
    positions->Vpositiontextemenu.y = 362;
    positions->Vpositioncurseurennemis.x=1024;
    positions->Vpositioncurseurennemis.y=768;
    positions->Vpositioncurseurallies.x=1024;
    positions->Vpositioncurseurallies.y=768;
    positions->Vpositioncurseurennemis.w = surfaces->Pcurseurennemis->w;
    positions->Vpositioncurseurennemis.h = surfaces->Pcurseurennemis->h;
    positions->Vpositioncadrecible.y = 15;
    positions->Vpositioncadrecible.x = XWIN/2-50-surfaces->Pcadrecible->w/2;
    positions->Vpositioncadrecible.w = surfaces->Pcadrecible->w;
    positions->Vpositioncadrecible.h = surfaces->Pcadrecible->h;
    positions->Vpositioncadreactions.y = YWIN-surfaces->Pcadreactions->h;
    positions->Vpositioncadreactions.x = XWIN/2-50-surfaces->Pcadreactions->w/2;
    positions->Vpositioncadreactions.w = surfaces->Pcadreactions->w;
    positions->Vpositioncadreactions.h = surfaces->Pcadreactions->h;
    positions->Vpositionpvcible.x = 380;
    positions->Vpositionpvcible.y = 185;
    positions->Vpositionpmcible.x = 545;
    positions->Vpositionpmcible.y = 185;
    positions->Vpositiondegats.x=1024;
    positions->Vpositiondegats.y=768;
    for(i=0;i<3;i++)
    {
        positions->Vpositionactionselectionnee[i].x=positions->Vpositioncadreactions.x+5;
        positions->Vpositionactionselectionnee[i].y=positions->Vpositioncadreactions.y+5+44*i;
        positions->Vpositionnomactions[i].x=positions->Vpositioncadreactions.x+15;
        positions->Vpositionnomactions[i].y=positions->Vpositioncadreactions.y+12+44*i;
        positions->Vpositionquantite[i].y=positions->Vpositionnomactions[i].y;
        positions->Vpositionquantite[i].x=positions->Vpositioncadreactions.x+surfaces->Pcadreactions->w-45;
    }
    for (i=0;i < 16;i++)
    {
        positions->Vpositionactivedesactive[i].x = 471+51*y;
        positions->Vpositionactivedesactive[i].y = 101+19*z;
        if (y < 3)
            y++;
        else
        {
            y=0;
            z++;
        }
    }
}

int Fchargerimages (SURFACES *surfaces)
{
#define LOAD_IMAGE(_name, _path) \
    if ((surfaces->_name = IMG_Load(_path)) == NULL) { \
        fprintf(stderr, "Impossible d'ouvrir " _path); \
        return -1; \
    }

    int i;

    LOAD_IMAGE(Pgobelin, "images/gobelin.bmp");
    LOAD_IMAGE(Ppaladin, "images/paladin.bmp");
    LOAD_IMAGE(Ppretre, "images/pretre.bmp");
    LOAD_IMAGE(Pvoleur, "images/voleur.bmp");
    LOAD_IMAGE(Pmenujouer, "images/menu_principal/jouer.bmp");
    LOAD_IMAGE(Pmenuoptions, "images/menu_principal/options.bmp");
    LOAD_IMAGE(Pmenuquitter, "images/menu_principal/quitter.bmp");
    LOAD_IMAGE(Pchoixvoleur, "images/menu_choix_classe/voleur.bmp");
    LOAD_IMAGE(Pchoixpretre, "images/menu_choix_classe/pretre.bmp");
    LOAD_IMAGE(Pchoixpaladin, "images/menu_choix_classe/paladin.bmp");
    LOAD_IMAGE(Pcurseurennemis, "images/jeu/curseur.bmp");
    LOAD_IMAGE(Pcurseurallies, "images/jeu/curseurpersos.bmp");
    LOAD_IMAGE(Pcadrecible, "images/jeu/cadre_cible.bmp");
    LOAD_IMAGE(Pactive, "images/jeu/active.bmp");
    LOAD_IMAGE(Pdesactive, "images/jeu/desactive.bmp");
    LOAD_IMAGE(Pcadreactions, "images/jeu/cadre_actions.bmp");
    LOAD_IMAGE(Pactionselectionnee, "images/jeu/cadre_actions_select.bmp");
    LOAD_IMAGE(Pactiondesactivee, "images/jeu/cadre_actions_unactive.bmp");
    LOAD_IMAGE(Pmort, "images/jeu/mort.bmp");
    for (i = 0;i < 5;i++)
        surfaces->Tennemi[i] = surfaces->Pgobelin;

#undef LOAD_IMAGE

    //définition de la transparence alpha dans les surfaces
    SDL_SetColorKey(surfaces->Pgobelin,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,0,255,18));
    SDL_SetColorKey(surfaces->Ppretre,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,39,189,31));
    SDL_SetColorKey(surfaces->Ppaladin,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,189,31,31));
    SDL_SetColorKey(surfaces->Pvoleur,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,39,189,31));
    SDL_SetColorKey(surfaces->Pcurseurennemis,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
    SDL_SetColorKey(surfaces->Pcurseurallies,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
    SDL_SetColorKey(surfaces->Pactive,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
    SDL_SetColorKey(surfaces->Pdesactive,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
    SDL_SetColorKey(surfaces->Pmort,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));

    return 0;
}

void Fdechargerimages (SURFACES *surfaces)//dechargement des surfaces alouées
{
    int i;
    SDL_FreeSurface(surfaces->Pecran);
    SDL_FreeSurface (surfaces->Pgobelin);
    SDL_FreeSurface (surfaces->Ppaladin);
    SDL_FreeSurface (surfaces->Ppretre);
    SDL_FreeSurface (surfaces->Pvoleur);
    SDL_FreeSurface (surfaces->Pmenujouer);
    SDL_FreeSurface (surfaces->Pmenuoptions);
    SDL_FreeSurface (surfaces->Pmenuquitter);
    SDL_FreeSurface (surfaces->Pchoixpretre);
    SDL_FreeSurface (surfaces->Pchoixpaladin);
    SDL_FreeSurface (surfaces->Pchoixvoleur);
    SDL_FreeSurface (surfaces->Pcurseurennemis);
    SDL_FreeSurface (surfaces->Pcurseurallies);
    SDL_FreeSurface (surfaces->Pcadrecible);
    SDL_FreeSurface (surfaces->Pactive);
    SDL_FreeSurface (surfaces->Pdesactive);
    SDL_FreeSurface (surfaces->Pcadreactions);
    SDL_FreeSurface (surfaces->Pactionselectionnee);
    SDL_FreeSurface (surfaces->Pactiondesactivee);
    SDL_FreeSurface (surfaces->Pmort);
    SDL_FreeSurface (surfaces->Pfondjeu);
    SDL_FreeSurface(surfaces->Ptextechoixmenu);
    SDL_FreeSurface(surfaces->Pnbdegats);
    SDL_FreeSurface(surfaces->Pnomcible);
    SDL_FreeSurface(surfaces->Ppvcible);
    SDL_FreeSurface(surfaces->Ppmcible);
    SDL_FreeSurface(surfaces->Ppvpersos);
    SDL_FreeSurface(surfaces->Ppmpersos);
    for(i = 0;i < 3;i++)
    {
        SDL_FreeSurface(surfaces->Tperso[i]);
    }
    for(i=0;i<3;i++)
    {
        SDL_FreeSurface (surfaces->Pnomactions[i]);
    }
    for(i=0;i<3;i++)
    {
        SDL_FreeSurface (surfaces->Pquantite[i]);
    }
}

void inverse(int *bool)
{
    if (*bool)
        *bool=0;
    else if (!*bool)
        *bool=1;
}


/* ********************************************************************* */
/*obtenirPixel : permet de récupérer la couleur d'un pixel
Paramètres d'entrée/sortie :
SDL_Surface *surface : la surface sur laquelle on va récupérer la couleur d'un pixel
int x : la coordonnée en x du pixel à récupérer
int y : la coordonnée en y du pixel à récupérer

Uint32 resultat : la fonction renvoie le pixel aux coordonnées (x,y) dans la surface
*/
Uint32 obtenirPixel(SDL_Surface *surface, int x, int y)
{
    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
    de l'image : 8, 16, 24 ou 32 bits.*/
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    /* Ici p est l'adresse du pixel que l'on veut connaitre */
    /*surface->pixels contient l'adresse du premier pixel de l'image*/
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
    switch(nbOctetsParPixel)
    {
        case 1:
            return *p;

        case 2:
            return *(Uint16 *)p;

        case 3:
            /*Suivant l'architecture de la machine*/
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                return p[0] << 16 | p[1] << 8 | p[2];
            else
                return p[0] | p[1] << 8 | p[2] << 16;

        case 4:
            return *(Uint32 *)p;

        /*Ne devrait pas arriver, mais évite les erreurs*/
        default:
            return 0;
    }
}

/* ********************************************************************* */
/*definirPixel : permet de modifier la couleur d'un pixel
Paramètres d'entrée/sortie :
SDL_Surface *surface : la surface sur laquelle on va modifier la couleur d'un pixel
int x : la coordonnée en x du pixel à modifier
int y : la coordonnée en y du pixel à modifier
Uint32 pixel : le pixel à insérer
*/
void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
    de l'image : 8, 16, 24 ou 32 bits.*/
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    /*Ici p est l'adresse du pixel que l'on veut modifier*/
    /*surface->pixels contient l'adresse du premier pixel de l'image*/
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
    switch(nbOctetsParPixel)
    {
        case 1:
            *p = pixel;
            break;

        case 2:
            *(Uint16 *)p = pixel;
            break;

        case 3:
            /*Suivant l'architecture de la machine*/
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            }
            else
            {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4:
            *(Uint32 *)p = pixel;
            break;
    }
}