APPRENDRE SDL AVEC MARIO

//Les fichiers d'entête
#include "SDL/SDL.h"
#include "SDL/SDL_image.h"
#include <string>

//Les attributs de l'écran (640 * 480)
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 32;

//Les attributs de la feuille de sprites de mario
const int SHEET_WIDTH = 382;
const int SHEET_HEIGHT = 1131;

//Les attributs de la feuille de sprites de mario
const int SHEET_WIDTH2 = 60;
const int SHEET_HEIGHT2 = 25;

//Les surfaces
SDL_Surface *faces = NULL;
SDL_Surface *arriere_plan = NULL;
SDL_Surface *enemis = NULL;
SDL_Surface *screen = NULL;

//La structure d'événements
SDL_Event event;

//les premiers coordonées de mario
int posx=100,posy=415;

//le numero de l'image à afficher
int anim=0;

//proprité de l'enemie
int posx_e=0,posy_e=430, anim_e=0;


//les images de mario
SDL_Rect clip[ 10 ];

//les images des enemis
SDL_Rect clip2[ 5 ];

//charger une image 
SDL_Surface *load_image( std::string filename, int *R=NULL, int *G=NULL, int *B=NULL)
{
    //L'image qui est chargée
    SDL_Surface* loadedImage = NULL;

    //L'image optimisée qu'on va utiliser
    SDL_Surface* optimizedImage = NULL;

    //Chargement de l'image
    loadedImage = IMG_Load( filename.c_str() );

    //Si l'image est chargée
    if( loadedImage != NULL )
    {
        //Création de l'image optimisée
        optimizedImage = SDL_DisplayFormat( loadedImage );

        //Libération de l'ancienne image
        SDL_FreeSurface( loadedImage );

        //Si la création de l'image optimisée s'est bien passée
        if( optimizedImage != NULL )
        {
          Uint32 colorkey = SDL_MapRGB( optimizedImage->format, *R, *G, *B);
          SDL_SetColorKey( optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY,colorkey);
        }
    }

    //On retourne l'image optimisée
    return optimizedImage;
}

/*
avant je faisais une fonction de chargement pour chaque couleur de transparence ce qui n'été pas une bonne méthode ;)

//charger une image sans le vert
SDL_Surface *load_image( std::string filename )
{
    //L'image qui est chargée
    SDL_Surface* loadedImage = NULL;

    //L'image optimisée qu'on va utiliser
    SDL_Surface* optimizedImage = NULL;

    //Chargement de l'image
    loadedImage = IMG_Load( filename.c_str() );

    //Si l'image est chargée
    if( loadedImage != NULL )
    {
        //Création de l'image optimisée
        optimizedImage = SDL_DisplayFormat( loadedImage );

        //Libération de l'ancienne image
        SDL_FreeSurface( loadedImage );

        //Si la création de l'image optimisée s'est bien passée
        if( optimizedImage != NULL )
        {
          Uint32 colorkey = SDL_MapRGB( optimizedImage->format, 48, 169, 66);
          SDL_SetColorKey( optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY,colorkey);
        }
    }

    //On retourne l'image optimisée
    return optimizedImage;
}

//charger une image sans le blanc
SDL_Surface *load_image2( std::string filename )
{
    //L'image qui est chargée
    SDL_Surface* loadedImage = NULL;

    //L'image optimisée qu'on va utiliser
    SDL_Surface* optimizedImage = NULL;

    //Chargement de l'image
    loadedImage = IMG_Load( filename.c_str() );

    //Si l'image est chargée
    if( loadedImage != NULL )
    {
        //Création de l'image optimisée
        optimizedImage = SDL_DisplayFormat( loadedImage );

        //Libération de l'ancienne image
        SDL_FreeSurface( loadedImage );

        //Si la création de l'image optimisée s'est bien passée
        if( optimizedImage != NULL )
        {
          Uint32 colorkey = SDL_MapRGB( optimizedImage->format, 255, 255, 255);
          SDL_SetColorKey( optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY,colorkey);
        }
    }

    //On retourne l'image optimisée
    return optimizedImage;
}*/

void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL )
{
    SDL_Rect offset;

    offset.x = x;
    offset.y = y;

    //On blitte la surface
    SDL_BlitSurface( source, clip, destination, &offset );
}

bool init()
{
    //Initialisation de tous les sous-systèmes de SDL

    if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
    {
        return false;
    }

    //Mise en place de l'écran
    screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE|SDL_FULLSCREEN );

    //S'il y a une erreur lors de la mise en place de l'écran
    if( screen == NULL )
    {
        return false;
    }

    //Mise en place de la barre caption
    SDL_WM_SetCaption( "JV_ ABDOU", NULL );

    //Si tout s'est bien passé
    return true;
}

bool load_files()
{
    //Chargement de la feuille de sprite
    int r=48, g=169, b=66;
    faces = load_image( "mario.png", &r, &g, &b );
    arriere_plan = load_image( "nature.png", &r, &g, &b);
    r=255; g=255; b=255;
    enemis= load_image( "enemis.png", &r, &g, &b);
    
    //Si tout s'est bien passé
    return true;
}

void clean_up()
{
    //On libère la feuille de sprites
    SDL_FreeSurface( faces );
    SDL_FreeSurface( enemis );
    SDL_FreeSurface( arriere_plan );
    SDL_FreeSurface( screen );
              
    //On quitte SDL
    SDL_Quit();   
}

//decouper la feuille de mario
void decoupage ()
{    
    //On coupe la partie en haut à gauche (premier sprite)
    clip[ 0 ].x = SHEET_WIDTH/25;
    clip[ 0 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 0 ].w = SHEET_WIDTH/15;
    clip[ 0 ].h = SHEET_HEIGHT/30;
    
    //On coupe la partie en haut à droite (second sprite)
    clip[ 1 ].x = SHEET_WIDTH/25+SHEET_WIDTH/15;
    clip[ 1 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 1 ].w = SHEET_WIDTH/15;
    clip[ 1 ].h = SHEET_HEIGHT/30;
     
    //On coupe la partie en bas à gauche (troisième sprite)
    clip[ 2 ].x = SHEET_WIDTH/25+2*(SHEET_WIDTH/15);
    clip[ 2 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 2 ].w = SHEET_WIDTH/15-5;
    clip[ 2 ].h = SHEET_HEIGHT/30;
    
    clip[ 3 ].x = SHEET_WIDTH/25+3*(SHEET_WIDTH/15)-5;
    clip[ 3 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 3 ].w = SHEET_WIDTH/15-6;
    clip[ 3 ].h = SHEET_HEIGHT/30;
    
    clip[ 4 ].x = SHEET_WIDTH/25+4*(SHEET_WIDTH/15)-10;
    clip[ 4 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 4 ].w = SHEET_WIDTH/15-6;
    clip[ 4 ].h = SHEET_HEIGHT/30;
    
    clip[ 5 ].x = SHEET_WIDTH/25+5*(SHEET_WIDTH/15)+3;
    clip[ 5 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 5 ].w = SHEET_WIDTH/15-2;
    clip[ 5 ].h = SHEET_HEIGHT/30;
    
    clip[ 6 ].x = SHEET_WIDTH/25+6*(SHEET_WIDTH/15)-20;
    clip[ 6 ].y = 20+2*SHEET_HEIGHT/27;
    clip[ 6 ].w = SHEET_WIDTH/15-3;
    clip[ 6 ].h = SHEET_HEIGHT/30;   
    
    clip2[ 0 ].x = 0;
    clip2[ 0 ].y = 0;
    clip2[ 0 ].w = SHEET_WIDTH2/3;
    clip2[ 0 ].h = SHEET_HEIGHT2;
    
    clip2[ 1 ].x = SHEET_WIDTH2/3;
    clip2[ 1 ].y = 0;
    clip2[ 1 ].w = SHEET_WIDTH2/3;
    clip2[ 1 ].h = SHEET_HEIGHT2;    
    
    clip2[ 2 ].x = 2*SHEET_WIDTH2/3;
    clip2[ 2 ].y = 0;
    clip2[ 2 ].w = SHEET_WIDTH2/3;
    clip2[ 2 ].h = SHEET_HEIGHT2;   
    
}

//traiter les evenements
void evenement()
{
   //Obtenir les KeyStates
   Uint8 *keystates = SDL_GetKeyState( NULL );  
   bool move= false;
        if( keystates[ SDLK_UP ] )
        {
         posy-=3; 
         move= true;
        }

        //Si Bas est pressé (la fleche)
        if( keystates[ SDLK_DOWN ] )
        {
         posy+=3;
         move= true;
        }

        //Si Gauche est pressé (la fleche)
        if( keystates[ SDLK_LEFT ] )
        {
         posx-=3;
         if ( posx < 0 ) posx++;
         move= true;
        }
        
        //Si Droite est pressé (la fleche)
        if( keystates[ SDLK_RIGHT ] )
        {
         posx+=3;
         if (posx >= SCREEN_WIDTH-15 ) posx--;
         move= true;
        }     
        
    if ( move == true ) anim++;
    else anim = 6;
    if ( anim == 7) anim = 0;
}

void evenement_enemis()
{
  //cette fonction permet l'animation de l'enemis
  apply_surface( posx_e, posy_e, enemis, screen, &clip2[anim_e] );
  //changer la position de l'enemi
  posx_e++;
  //changé l'animation
  anim_e++;
  if ( posx_e == SCREEN_WIDTH ) posx_e=0;
  if (anim_e == 2 ) anim_e=0;
}     
 

int main( int argc, char* args[] )
{
    //Ce qui va nous permettre de quitter
    bool quit = false; 

    //Initialisation
    if( init() == false )
    {
        return 1;
    }

    //Chargement des fichiers
    if( load_files() == false )
    {
        return 1;
    }

    decoupage();
    
    //Tant que l'utilisateur n'a pas quitter
    while( quit == false )
    {   
        //preparer l'arriere plan
        apply_surface( 0, 0, arriere_plan, screen);

        //traiter les evenement clavier
        evenement();
        
        //preparer le personnage mario
        apply_surface( posx, posy, faces, screen, &clip[anim] );
        
        
        //si l'enemi n'est pas toucher
        evenement_enemis();
      
        //afficher
        SDL_Flip( screen);

        //Tant qu'il y a un événement
        while( SDL_PollEvent( &event ) )
        {
            switch (event.key.keysym.sym)
            {
              case SDLK_ESCAPE: /* Appui sur la touche Echap, on arrête le programme */
                                quit = true;
                                break;
            }        
        }
        
    }

    //On libère les images et on quitte SDL
    clean_up();

    return 0;
}

Télécharger le zip

15 août 2008 13:17:47 :

suite à une remarque faite par mon ami "ALUCARDS" qui m'a proposer de faire qu'une seule fonction de "load_image" qui prendra en paramètre la couleur de transparence, j'ai modifié la source toute en laissant les deux fonctions que j'utilisais en commentaire. merci "ALUCARDS" ;).

15 août 2008 20:25:42 :

;).

03 septembre 2008 13:53:53 :

Suppression d'une instruction inutile. (Merci ALUCARDS)