game: Add a buildable version of the agme

Signed-off-by: Olivier Gayot <duskcoder@gmail.com>

1 files changed, 382 insertions, 0 deletions

diff --git a/main.c b/main.c
new file mode 100644
index 0000000..3406771
--- /dev/null
+++ b/main.c
@@ -0,0 +1,382 @@
+/* ********************************************************************

+    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|SDL_NOFRAME|SDL_FULLSCREEN);

+    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);

+    Fchargerimages (&surfaces);

+    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++;

+        }

+    }

+}

+

+void Fchargerimages (SURFACES *surfaces)

+{

+    int i;

+    surfaces->Pgobelin = IMG_Load ("images/gobelin.bmp");

+    surfaces->Ppaladin = IMG_Load ("images/paladin.bmp");

+    surfaces->Ppretre = IMG_Load ("images/prêtre.bmp");

+    surfaces->Pvoleur = IMG_Load ("images/voleur.bmp");

+    surfaces->Pmenujouer = IMG_Load ("images/menu_principal/jouer.bmp");

+    surfaces->Pmenuoptions = IMG_Load ("images/menu_principal/options.bmp");

+    surfaces->Pmenuquitter = IMG_Load ("images/menu_principal/quitter.bmp");

+    surfaces->Pchoixvoleur = IMG_Load ("images/menu_choix_classe/voleur.bmp");

+    surfaces->Pchoixpretre = IMG_Load ("images/menu_choix_classe/pretre.bmp");

+    surfaces->Pchoixpaladin = IMG_Load ("images/menu_choix_classe/paladin.bmp");

+    surfaces->Pcurseurennemis = IMG_Load ("images/jeu/curseur.bmp");

+    surfaces->Pcurseurallies = IMG_Load ("images/jeu/curseurpersos.bmp");

+    surfaces->Pcadrecible = IMG_Load ("images/jeu/cadre_cible.bmp");

+    surfaces->Pactive = IMG_Load ("images/jeu/active.bmp");

+    surfaces->Pdesactive = IMG_Load ("images/jeu/desactive.bmp");

+    surfaces->Pcadreactions = IMG_Load ("images/jeu/cadre_actions.bmp");

+    surfaces->Pactionselectionnee=IMG_Load ("images/jeu/cadre_actions_select.bmp");

+    surfaces->Pactiondesactivee=IMG_Load("images/jeu/cadre_actions_unactive.bmp");

+    surfaces->Pmort=IMG_Load("images/jeu/mort.bmp");

+    for (i = 0;i < 5;i++)

+        surfaces->Tennemi[i] = surfaces->Pgobelin;

+

+    //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));

+}

+

+void Fdechargerimages (SURFACES *surfaces)//dechargement des surfaces alouées

+{

+    int i;

+    if(surfaces->Pecran!=NULL)

+        SDL_FreeSurface(surfaces->Pecran);

+    if(surfaces->Pgobelin!=NULL)

+        SDL_FreeSurface (surfaces->Pgobelin);

+    if(surfaces->Ppaladin!=NULL)

+        SDL_FreeSurface (surfaces->Ppaladin);

+    if(surfaces->Ppretre!=NULL)

+        SDL_FreeSurface (surfaces->Ppretre);

+    if(surfaces->Pvoleur!=NULL)

+        SDL_FreeSurface (surfaces->Pvoleur);

+    if(surfaces->Pmenujouer!=NULL)

+        SDL_FreeSurface (surfaces->Pmenujouer);

+    if(surfaces->Pmenuoptions!=NULL)

+        SDL_FreeSurface (surfaces->Pmenuoptions);

+    if(surfaces->Pmenuquitter!=NULL)

+        SDL_FreeSurface (surfaces->Pmenuquitter);

+    if(surfaces->Pchoixpretre!=NULL)

+        SDL_FreeSurface (surfaces->Pchoixpretre);

+    if(surfaces->Ppaladin!=NULL)

+        SDL_FreeSurface (surfaces->Pchoixpaladin);

+    if(surfaces->Pvoleur!=NULL)

+        SDL_FreeSurface (surfaces->Pchoixvoleur);

+    if(surfaces->Pcurseurennemis!=NULL)

+        SDL_FreeSurface (surfaces->Pcurseurennemis);

+    if(surfaces->Pcurseurallies!=NULL)

+        SDL_FreeSurface (surfaces->Pcurseurallies);

+    if(surfaces->Pcadrecible!=NULL)

+        SDL_FreeSurface (surfaces->Pcadrecible);

+    if(surfaces->Pactive!=NULL)

+        SDL_FreeSurface (surfaces->Pactive);

+    if(surfaces->Pdesactive!=NULL)

+        SDL_FreeSurface (surfaces->Pdesactive);

+    if(surfaces->Pcadreactions!=NULL)

+        SDL_FreeSurface (surfaces->Pcadreactions);

+    if(surfaces->Pactionselectionnee!=NULL)

+        SDL_FreeSurface (surfaces->Pactionselectionnee);

+    if(surfaces->Pactionselectionnee!=NULL)

+        SDL_FreeSurface (surfaces->Pactiondesactivee);

+    if(surfaces->Pmort!=NULL)

+        SDL_FreeSurface (surfaces->Pmort);

+    if(surfaces->Pfondjeu != NULL)

+        SDL_FreeSurface (surfaces->Pfondjeu);

+    if(surfaces->Ptextechoixmenu!=NULL)

+        SDL_FreeSurface(surfaces->Ptextechoixmenu);

+    if(surfaces->Pnbdegats!=NULL)

+        SDL_FreeSurface(surfaces->Pnbdegats);

+    if(surfaces->Pnomcible!=NULL)

+        SDL_FreeSurface(surfaces->Pnomcible);

+    if(surfaces->Ppvcible!=NULL)

+        SDL_FreeSurface(surfaces->Ppvcible);

+    if(surfaces->Ppmcible!=NULL)

+        SDL_FreeSurface(surfaces->Ppmcible);

+    if(surfaces->Ppvpersos!=NULL)

+        SDL_FreeSurface(surfaces->Ppvpersos);

+    if(surfaces->Ppmpersos!=NULL)

+        SDL_FreeSurface(surfaces->Ppmpersos);

+    for(i = 0;i < 3;i++)

+    {

+        if(surfaces->Tperso[i]!=NULL)

+            SDL_FreeSurface(surfaces->Tperso[i]);

+    }

+    for(i=0;i<5;i++)

+    {

+        if(surfaces->Tennemi[i]!=NULL)

+            SDL_FreeSurface(surfaces->Tennemi[i]);

+    }

+    for(i=0;i<3;i++)

+    {

+        if(surfaces->Pnomactions[i]!=NULL)

+            SDL_FreeSurface (surfaces->Pnomactions[i]);

+    }

+    for(i=0;i<3;i++)

+    {

+        if(surfaces->Pquantite[i]!=NULL)

+            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;

+    }

+}

+

+

+