typedef struct Sprite Sprite
struct Sprite
{
    bool activer = false; // un peu de C++
    SDL_Surface **Anim = {NULL}; // Servira à faire l'animation
    int nb_anim = 0;  // Sert à balayer le tableau
    int nb_anim_max =0; // Sert à indiquer combien il y a de sprites
    bool anim_aller-retour = false; //faut-il decrementer nb_anim une fois nb_anim_max atteint
   // et plein d'autre options

Mais j'ai besoin d'un petit coup de main

SDL_Surface *Anim = {NULL};

SDL_Surface **Anim;

enum {PAR_DEFAUT,PERSO_1,PERSO_2,PERSO_3...};
enum {DROITE,GAUCHE,HAUT,BAS};

class Sprite
{
   public:
     //Mon constructeur
     Sprite (string nom="VIDE",int nombre_sprites=2, int mode_affichage=PAR_DEFAUT)
     {
        SDL_Surface *surface = IMG_Load (nom);
        SDL_Rect Decoupage;
        bool activer = false;
        int sprite_actuel = 0;
        Init (mode_affichage);
     }
     ~Sprite ()
     {
     //les destructeurs
     }
   
     Anim (*position_du_sprite)
     {
         // Cette fonction reçoit comme argument la position ou l'on doit   afficher le sprite, et c'est tout. Elle va gerer toute seul le temps, et toute  les autres options.
        temps_actuel = SDL_GetTicks();
        if (temps_actuel - temps_avant > 1/fps)
        {
            // il faut calculer la structure decoupage.
            switch (direction)
            {
               case DROITE:
                 decoupage.x=sprite_actuel*decoupage.w;
                 break;
               case BAS:
                 decoupage.y=sprite_actuel*decoupage.h;
                 break;
            }
       
        if (va_et_vient == true)
        {
           if (retour = false)
              sprite_actuel++;
           else
              sprite_actuel--;
           if (sprite_atuel > nombre_sprites)
              retour = true;
           if ((sprite_atuel < 0)
              retour = false;         
        }
        else
        {
           if (sprite_actuel >= nombre_sprites)
              nombre_sprites = 0;
           else
              sprite_actuel++;
        }
        SDL_BlitSurface (surface, &decoupage, ecran ,&position_de_sprite)
        temps_avant = temps_actuel;
        }       
     }
   
   private:
     int fps = 0, temps_avant = 0, temps_ecoule = 0, temps_actuel = 0 ...;
     bool va_et_vient = false, retour = false;
 //Pour ne pas a avoir surcharger le constructeur
     void Init (int mode_affichage, int arg1=0, int arg2=0, int arg3=0...)
     (
        switch (mode_affichage)
           {
               case PAR_DEFAUT:
                 Decoupage.h = 32;
                 Decoupage.w = 32;
                 Decoupage.x = 0;
                 Decoupage.y = 0;
                 Direction = DROITE;
                 break;
           }     
     }           

N'oublier pas d'apporter de nouvelle idée pour nous facilité la vie.

/*
main.c
------

Par gm

*/

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#include <iostream>

#include "sprite.h"


int main(int argc, char **argv)
{
    SDL_Event event;
   
    SDL_Init(SDL_INIT_VIDEO);
    //SDL_WM_SetIcon(IMG_Load("icone.ico"), NULL);
    SDL_Surface *ecran = SDL_SetVideoMode( 256, 256, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("TEST CLASS SPRITE", NULL);
   
    SDL_Surface *surface = NULL;
    surface = IMG_Load("mon_sprite.png");
   
   
    class sprite mon_sprite(ecran,surface,0,0,128,128,4,1);


    bool continuer = true;

    while (continuer)
    {
        SDL_PollEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = false;
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = false;
                        break;
                }
                break;
        }
        SDL_Delay(250);
       
        mon_sprite.afficher();
       
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
        SDL_Flip(ecran);
    }

    SDL_FreeSurface(ecran);
    SDL_Quit();

    return EXIT_SUCCESS;
}



 

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#include <iostream>

#include <math.h>

#include "sprite.h"


sprite::sprite(SDL_Surface *_ecran,SDL_Surface *_surface,int vecteur_x ,int vecteur_y ,int decoupage_w ,int decoupage_h ,int nombre ,int s_couleur)
{
     nbr = nombre;
     speed = 0;
     angle = 0;
     couleur = s_couleur;
     
     
     *ecran = *_ecran;
     *surface = *_surface;
     vecteur.x = vecteur_x;
     vecteur.y = vecteur_y;
     vecteur.w = 0;
     vecteur.h = 0;
     decoupage.x = 0;
     decoupage.y = 0;
     decoupage.w = decoupage_w;
     decoupage.h = decoupage_h; 
     nbr = nbr * decoupage.w;
     switch(couleur)
     {
       case 1:
       SDL_SetColorKey(surface, SDL_SRCCOLORKEY, SDL_MapRGB(surface->format, 255, 0, 0));
       case 2:
       SDL_SetColorKey(surface, SDL_SRCCOLORKEY, SDL_MapRGB(surface->format, 0, 255, 0));
       case 3:
       SDL_SetColorKey(surface, SDL_SRCCOLORKEY, SDL_MapRGB(surface->format, 0, 0, 255));         
     }
}

sprite::~sprite() 
{
    SDL_FreeSurface(surface);
}

void sprite::move()
{
    vecteur.x += speed * cos(angle);
    vecteur.y += speed * sin(angle);
}

void sprite::anim()
{
        decoupage.x += decoupage.w;
        if (decoupage.x >= nbr)
        {
          decoupage.x = 0;
        }
}

void sprite::afficher()
{
     anim();
     move();
     SDL_BlitSurface( surface, &decoupage, ecran, &vecteur);
}

 

#ifndef SPRITE_H
#define SPRITE_H

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#include <iostream>


class sprite
{
      public:
        sprite(SDL_Surface *_ecran,SDL_Surface *_surface,int vecteur_x ,int vecteur_y ,int decoupage_w ,int decoupage_h ,int nombre ,int s_couleur);
        ~sprite();
       
        void move();
        void anim();
        void afficher();
       
        int speed;
        int angle;
       
       
      protected:
        SDL_Surface *ecran, *surface;
        SDL_Rect vecteur, decoupage;
        int couleur;
        int nbr;
     
       
};
#endif



 

Le debug dit: "vecteur = ?"