Partage

[SDL] MoteurGestionTiles

22 juillet 2006 à 20:07:28

Voici le dernier outil que j'ai conçu pour gerer les tiles dynamiquement (pour mon futur rpg ^^).

Ce que j'ai chercher a faire :

- Avoir des objets de type tiles avec des champs representant :
leur position à l'ecran.
la texture qu'ils doivent affiche.
les coordonnées de textures (pour n'afficher qu'une partie de la texture par exemple).

- Avoir des objet de type TileArray avec des champs representant :

le pointeur de pointeur sur le tableau d'objets tiles correspondant à l'objet TileArray.

la largueur et la hauteur du tableau.

- associer une propriéte a chaque tiles (traversable ou non representer par une enumération anonyme definie dans la source des class.)

Ce système a plusieurs avantages :
- Il permet de créer un tableau à deux dimensions dynamiques de Tiles qui s'organisent seuls.
- un accès rapide à un tile relatif à un TileArray.
- un changement rapide et peu couteux en mémoire de texture des tiles (Et oui c'est juste un pointeur qui pointe sur la texture a afficher).

Bref voici les deux class :

enum {TILE_TRAVERSABLE = 0, TILE_INTRAVERSABLE};

class Tile
{
public:
int x,y,Prop;
SDL_Surface* texture;
SDL_Rect coordtex;
Tile(){};
void ModifyTilePosition(int x,int y);
void ModifyTileProp(int Prop);
void ModifyTileTex(SDL_Surface* Texture);
void ModifyTileTexCoord(SDL_Rect coordTex);
};

class TileArray
{
Tile** ptr2ptrTile;
int x,y;
public:
TileArray(int x,int y,int w,int h,SDL_Surface* ModelTexBase);
Tile* GetTile(int x,int y);
void DisplayArray(SDL_Surface* Ecran);
~TileArray();
};

TileArray::TileArray(int x,int y,int w,int h,SDL_Surface* ModelTexBase)
{
this->x = x;
this->y = y;
ptr2ptrTile = new Tile*[x];

for(int count = 0; count<x ; count++)
{
ptr2ptrTile[count]= new Tile[y];

for(int count2 = 0; count2 < y; count2++)
{
ptr2ptrTile[count][count2].Prop = TILE_TRAVERSABLE;
ptr2ptrTile[count][count2].x = count*w;
ptr2ptrTile[count][count2].y = count2*h;
ptr2ptrTile[count][count2].texture = ModelTexBase;
ptr2ptrTile[count][count2].coordtex.x = 0;
ptr2ptrTile[count][count2].coordtex.y = 0;
ptr2ptrTile[count][count2].coordtex.w = w;
ptr2ptrTile[count][count2].coordtex.h = h;
}
}
}

Tile* TileArray::GetTile(int x, int y)
{
Tile* Renvoi = &(ptr2ptrTile[x][y]);
return Renvoi;
}

TileArray::~TileArray()
{
for(int count = 0; count<x ;count++)
{
delete[] ptr2ptrTile[count];
}
delete[]ptr2ptrTile;
}

void TileArray::DisplayArray(SDL_Surface* Ecran)
{
SDL_Rect EcranCoord;

for(int count = 0 ; count<x ; count++)
{
for(int count2 = 0; count2<y ; count2++)
{
EcranCoord.x = ptr2ptrTile[count][count2].x;
EcranCoord.y = ptr2ptrTile[count][count2].y;
SDL_BlitSurface(ptr2ptrTile[count][count2].texture,&ptr2ptrTile[count][count2].coordtex,Ecran,&EcranCoord);
}
}
SDL_Flip(Ecran);
}

void Tile::ModifyTilePosition(int x,int y)
{
this->x = x;
this->y = y;
}

void Tile::ModifyTileProp(int Prop)
{
this->Prop = Prop;
}

void Tile::ModifyTileTex(SDL_Surface* Texture)
{
this->texture = Texture;
}

void Tile::ModifyTileTexCoord(SDL_Rect coordTex)
{
this->coordtex.x = coordTex.x;
this->coordtex.y = coordTex.y;
this->coordtex.w = coordTex.w;
this->coordtex.h = coordTex.h;
}

Illustration d'une utilisation :

Pour cet exemple, nous allons faire une fenêtre de jeu de 800*600
nous allons faire une sorte d'echiquier pour illustrer ces class .
bon alors on va dire que un tile fait 50*50 pixels (ca fera donc 16*12 tiles).
pour notre "echiquier" nous allons générer deux SDL_Surface*
une de couleur noire, et une de couleur blanche.

Voici le code :

#include <SDL/SDL.h>
#include "engine.h" //On inclut nos class de gestion de tile (moi je les aient mis dans un fichier nommé engine.h).
#define WIDTH 16
#define HIGHT 12

int main(int argc,char* argv[])
{
SDL_Init(SDL_INIT_VIDEO);

SDL_Surface* Ecran = SDL_SetVideoMode(800,600,32,SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_RESIZABLE);

bool continuer = true;
SDL_Event event;

SDL_Surface* Blanc = SDL_CreateRGBSurface(SDL_HWSURFACE,50,50,32,0,0,0,0);
SDL_FillRect(Blanc,NULL,SDL_MapRGB(Blanc->format,0,0,0));
SDL_Surface* Noir = SDL_CreateRGBSurface(SDL_HWSURFACE,50,50,32,0,0,0,0);
SDL_FillRect(Noir,NULL,SDL_MapRGB(Noir->format,255,255,255));

TileArray TableauTiles(16,12,50,50,Blanc);
//On créer un tableau de 16*12 Tiles ayant comme texture la SDL_Surface Blanc.
//Comme nous voulons que il y ait une case noire tous les deux tiles on fait une boucle.
bool Black = false; //Ce booléen dira si on doit mettre une couleur noire.
Tile* TamponTile; //Ce pointeur pointera sur le tile dont il faut modifier la texture.

for(int count = 0 ; count < WIDTH ; count++)
{
for(int count2 = 0 ; count2<HIGHT ; count2++)
{
TamponTile = TableauTiles.GetTile(count,count2);
if(Black)
{
TamponTile->texture = Noir;
Black=false;
}
else
{
TamponTile->texture = Blanc;
Black=true;
}
}
if(Black) //Pour que ca fasse une case sur deux noir on inverse le booléen a chaque fin de colonne analysée.
Black=false;
else
Black=true;
}

while(continuer)
{
SDL_PollEvent(&event);
if(event.type == SDL_QUIT)
continuer = false;

TableauTiles.DisplayArray(Ecran);
}

SDL_Quit();
return 0;
}

Essayez vous verrez ! Je suis assez content de mon travail.
Si quelques personnes pouvaient m'aider à améliorer ceci ce serait sympa ^^.

A oui dernière précision à propos de la methode Tile* GetTile(int x,int y); provenant de la class TileArray.
les tiles sont organisés comme les pixels d'une surface.
c'est à dire que :

X.GetTile(0,0);
renvera l'adresse du tile tout en haut à droite du tableau de tiles.

voila voila^^

J'attend vos remarques.

Tomu

22 juillet 2006 à 21:10:33

J'ai regardé vite fait et tu utilises un manièère un peu 'barbar' des SDL_Surface dans ta classe Tile.
Je m'explique :
Si tu a une map de 200*200 tile dont 300 est de l'herbe et 1000 le même arbre.

Tu vois bien que tu vas charge les mêmes image plusieur s fois alors qu'une suffirait.

Il faut faire un classe RessourceManager.
Fait des recherches google dessus, je t'expliquerais le principe si tu ne comprend pas.

castorus

22 juillet 2006 à 21:34:46

je ne vois pas du TOUT ce que tu veu dire.... je declare une sdl surface apres tout les tile ayant le model de cette surface ont leur pointeur texture qui pointe sur cette surface je vois pas ou est le probleme.... et en plus c'est très rapide car y'a qu'a initialisé les pointeur sur l'adresse de la sdl surface créer. et ca ne bouffe pas de mémoire...
Je ne voit pas en koi c'est barbare.... A mon avis t'as pas compris comment ca marchait lol.

Mais bon vu que tu dis avoir une meilleur solution je suis preneur (si tu as en fait bien compris)^^

Edit : J'ai compris ce que tu veux dire et en fait effectivement tu n'as pas compris (dsl lol mais c vré)
Le pointeur texture de la class Tile il permet de pointer sur une surface.
Pas d'en recréer une.
Un pointeur est fait pour contenir un adresse mémoire afin de pouvoir pointer sur cet espace mémoire!
Donc je créer un seul modèle de texture. que je pointe.
Tu vois ce que je veux dire? Il suffit de lire la class et les definitions de ses méthodes pour comprendre tu verras (parce que tu n'as pas lu les definitions de methode.)

regarde voici le principe :
Je defini une texture de base dans la source main :

SDL_Surface* Blanc = SDL_CreateRGBSurface(SDL_HWSURFACE,50,50,32,0,0,0,0);
SDL_FillRect(Blanc,NULL,SDL_MapRGB(Blanc->format,0,0,0));

la cela créer la surface ok.
ensuite le pointeur texture fait cela :
texture = Blanc;
Il prend juste l'adresse de la surface qu'il devra afficher.
Voila lol c tt^^

Tomu

22 juillet 2006 à 23:45:10

Oui j'ai fait une erreur, j'ai lu trop vite.

Mais si tu veux bien structurer ton moteur, pour qu'il soit flexible, tu devrais faire une class de RessourceManager.

Je vais essayé de t'expliqué si ca t'intéresse.

Piwaï

23 juillet 2006 à 9:31:39

castorus a raison

. Son système est très bien

.

Manque peut etre une gestion de libération de la mémoire : ils sont ou les SDL_FreeSurface ? jlé ai po trouvé avec la fonction rechercher

castorus

24 juillet 2006 à 7:40:48

Arf effectivement piwaï j'y ai pas penser O_ô !
Merci de cette réponse pertinente.
Pour une fois que quelqu'un a la descence de lire la source avant de la critiquer lol.
J'y ais pas pensé c'est vrai, ca ferrais vraiment tache dans un moteur !!!
heureusement que tu m'a prévenu sinon j'aurais pas vu lol ^^.

Edit :
Ptite question, lorsque dans une class il y a un membre qui est un pointeur.
lorsque un objet respectif a cette class est créer,
et que le destructeur de cet objet est appelé, cela detruit tout seul le membre pointeur non? Comme les autres membres de l'objet d'ailleur non?
Attention je ne parle pas de ce sur quoi le pointeur pointe mais bien du pointeur lui meme!
Si la réponse est oui alors en fait je n'ai pas besoin de gerer piwaï car les modeles de textures seront représentées dans la source principale.

newEdit :
finalement c bon

j'ai fait des test et j'ai creer un class de gestion de Sprite aussi :

#define MAX_SPRITE 1000
class Sprite
{

static Sprite** SpriteArray;
static int ID,ID2;
int x,y,Number;
SDL_Surface* Texture;
SDL_Rect TextureCoord;
public:
Sprite();
friend Sprite* GetFirstSprite();
friend Sprite* GetNextSprite();
friend Sprite* GetSprite(int N);
void SetPositionSprite(int x,int y);
void SetSpriteTex(SDL_Surface* Tex);
void SetSpriteTexCoord(SDL_Rect NewRect);
void BlitSprite(SDL_Surface* Surface);
~Sprite();
};

int Sprite::ID = 0;
int Sprite::ID2 = 0;
Sprite** Sprite::SpriteArray = new Sprite*[MAX_SPRITE];

Sprite::Sprite()
{
SpriteArray[ID++]=this;
SpriteArray[ID]=NULL;
Number = (ID-1);
}

Sprite* GetFirstSprite()
{
Sprite::ID2 = 0;
return Sprite::SpriteArray[Sprite::ID2];
}

Sprite* GetNextSprite()
{
return Sprite::SpriteArray[++Sprite::ID2];
}

Sprite* GetSprite(int N)
{
return Sprite::SpriteArray[N];
}

void Sprite::SetPositionSprite(int x,int y)
{
this->x = x;
this->y = y;
}

void Sprite::SetSpriteTex(SDL_Surface* Tex)
{
this->Texture = Tex;
}

void Sprite::SetSpriteTexCoord(SDL_Rect NewRect)
{
this->TextureCoord.x = NewRect.x;
this->TextureCoord.y = NewRect.y;
this->TextureCoord.w = NewRect.w;
this->TextureCoord.h = NewRect.h;
}

void Sprite::BlitSprite(SDL_Surface* Surface)
{
SDL_Rect A;
A.x = this->x;
A.y = this->y;
SDL_BlitSurface(this->Texture,&(this->TextureCoord),Surface,&A);
}

Sprite::~Sprite()
{
int IDToRemplace = Number;

while(GetSprite(IDToRemplace)!=NULL)
{
SpriteArray[IDToRemplace]=SpriteArray[++IDToRemplace];
}
ID-=1;
}

Que fait cette class ?

Elle créer de objet Sprite dont les adresse sont organisées dans un tableau de pointeur de Sprite.
ainsi on pourra atteindre chaque sprite lorsque l'on veux.
Notament avec la méthode friend :
GetSprite(int N);
Qui renvoi l'adresse de l'objet sprite demandé.

Mais aussi des fonction friend elles aussi :
GetFirstSprite();
GetNextSprite();
Qui renvoi elles aussi les adresses des objet Tiles dans l'odre du tableau d'adresse de Sprite. Ainsi avec ceci :

Sprite* premSprite = GetFirstSprite();
while(premSprite != &premSprite)
{
premSprite = GetNextSprite();
}

permet d'explorer tout les Sprites créer.
Cela devrais etre utile dans nombre de situation !
Surtout pour la gestion des collisions Sprite to Sprite et Sprite to Tile.
Dites moi ce que vous en pensez.
Sachant que lorsque vous detruisez un sprite la liste de pointeur de sprite se réorganise automatiquement empechant ainsi les overflow.

Piwaï

24 juillet 2006 à 17:31:45

Ca a l'air joli, la par contre j'ai pas eu le temps de bien me pencher dessus.

Pour ta question, lorsqu'on fait appel au destructeur, le pointeur est détruit, puisque c'est une variable. Bien entendu, ce sur quoi il pointe n'est pas détruit, dans ton main il faut donc bien que tu mettes les free surface, mais je crois que tu disais que ca serait fait.

@++

Piwaï

castorus

24 juillet 2006 à 18:23:05

Oui alors voici la class de gestion des textures :

class Texture
{
SDL_Rect TexCoord;
SDL_Surface* Tex;
public:
Texture(int x,int y,int w,int h,char* nomfichier,SDL_Surface* Tex=NULL);
SDL_Rect* GetTexRect();
SDL_Surface* GetTexture();
void ChangeTexRect(int x,int y,int w,int h);
void ChangeTexture(SDL_Surface* NewTex);
void FreeTexture();
~Texture(){};
};

Texture::Texture(int x,int y,int w,int h,char* nomfichier,SDL_Surface* Tex)
{
if(Tex == NULL)
{
this->Tex = IMG_Load(nomfichier);
this->Tex = SDL_DisplayFormat(this->Tex);
}
else
this->Tex = Tex;

this->TexCoord.x = x;
this->TexCoord.y = y;
this->TexCoord.w = w;
this->TexCoord.h = h;
}

SDL_Rect* Texture::GetTexRect()
{
return &TexCoord;
}

SDL_Surface* Texture::GetTexture()
{
return this->Tex;
}

void Texture::ChangeTexRect(int x,int y,int w,int h)
{
this->TexCoord.x = x;
this->TexCoord.y = y;
this->TexCoord.w = w;
this->TexCoord.h = h;
}

void Texture::ChangeTexture(SDL_Surface* NewTex)
{
this->Tex = NewTex;
}

void Texture::FreeTexture()
{
SDL_FreeSurface(this->Tex);
}

Cela permet de gerer facilement les textures.
Exemple :

Texture Bonhomme(0,0,50,50,"bonhomme.bmp");

La texture Bonhomme est créer en mémoire avec un SDL_Rect respectif.

pour liberer le tout :
Bonhomme.FreeTexture();
Bonhomme.~Texture();

Et voilou !

C'est cours c'est propre c'est simple c'est cool

Piwaï

24 juillet 2006 à 20:35:25

Pkoi ne pas l'appel a free texture dans le destructeur, au lieu d'en faire une fonction public ?

Sinon, il faudrait que tu post un projet entier, pour qu'on puisse avoir un apercu, avec un exe et des graph

castorus

24 juillet 2006 à 20:52:11

Vi vi, c'est en préparation, mais je me créer un panel d'outil solide et rapide pour faire un programme stable et agréable à voir !
Mais je suis content car mon pti moteur actuel me permet de gerer absolument tout les genres de jeux 2d grace à sa génération et organisation de tile dynamique ainsi que de sprite.
Et les textures ont elles aussi une gestion legère et agréable.
Ce moteur commence à aquerrir une bonne qualitée je pense ^^.

Edit :
Suite a ta réponse piwaï je crois que je vais faire une chtite demo d'un mario like.
Je vais inclure le scrolling le saut et quelques enemis genre les champignons marrons la....
Bon pti problème, je n'ai pas de ftp donc je posterais la source que vous compilerez vous même.
ça devrais etre prêt demain je pense. voili voilou.

castorus

25 juillet 2006 à 19:14:12

Bon alors je vous place les sources Ici lol...
Ce serais sympas si quelqu'un acceptait mon msn : castorus9@hotmail.com
pour mettre sur son ftp ma démo parce que la je peu pas vous donner les images ressources du jeu (sprites de mario tiles ect).
Pour la démo finalement je n'ai pas fait de scrolling ni de gestion de collisions. j'ai juste montré que les méthodes fonctionnent.
Donc gestion de Tiles de Textures et de Sprites.

le moteur en lui même :

#define MAX_SPRITE 1000

enum {TILE_TRAVERSABLE = 0, TILE_INTRAVERSABLE};

class Tile
{
public:
int x,y,Prop;
SDL_Surface* texture;
SDL_Rect coordtex;
Tile(){};
void ModifyTilePosition(int x,int y);
void ModifyTileProp(int Prop);
void ModifyTileTex(SDL_Surface* Texture);
void ModifyTileTexCoord(SDL_Rect coordTex);
~Tile(){};
};

class TileArray
{
Tile** ptr2ptrTile;
int x,y;
public:
TileArray(int x,int y,int width_of_a_Tile,int hight_of_a_tile,SDL_Surface* ModelTexBase);
Tile* GetTile(int x,int y);
void BlitArray(SDL_Surface* SurfaceCible);
~TileArray();
};

TileArray::TileArray(int x,int y,int width_of_a_Tile,int hight_of_a_tile,SDL_Surface* ModelTexBase)
{
this->x = x;
this->y = y;
ptr2ptrTile = new Tile*[x];

for(int count = 0; count<x ; count++)
{
ptr2ptrTile[count]= new Tile[y];

for(int count2 = 0; count2 < y; count2++)
{
ptr2ptrTile[count][count2].Prop = TILE_TRAVERSABLE;
ptr2ptrTile[count][count2].x = count*width_of_a_Tile;
ptr2ptrTile[count][count2].y = count2*hight_of_a_tile;
ptr2ptrTile[count][count2].texture = ModelTexBase;
ptr2ptrTile[count][count2].coordtex.x = 0;
ptr2ptrTile[count][count2].coordtex.y = 0;
ptr2ptrTile[count][count2].coordtex.w = width_of_a_Tile;
ptr2ptrTile[count][count2].coordtex.h = hight_of_a_tile;
}
}
}

Tile* TileArray::GetTile(int x, int y)
{
Tile* Renvoi = &ptr2ptrTile[x][y];
return Renvoi;
}

TileArray::~TileArray()
{
for(int count = 0; count<x ;count++)
{
delete[] ptr2ptrTile[count];
}
delete[]ptr2ptrTile;
}

void TileArray::BlitArray(SDL_Surface* SurfaceCible)
{
SDL_Rect EcranCoord;

for(int count = 0 ; count<x ; count++)
{
for(int count2 = 0; count2<y ; count2++)
{
EcranCoord.x = ptr2ptrTile[count][count2].x;
EcranCoord.y = ptr2ptrTile[count][count2].y;
SDL_BlitSurface(ptr2ptrTile[count][count2].texture,&ptr2ptrTile[count][count2].coordtex,SurfaceCible,&EcranCoord);
}
}
}

void Tile::ModifyTilePosition(int x,int y)
{
this->x = x;
this->y = y;
}

void Tile::ModifyTileProp(int Prop)
{
this->Prop = Prop;
}

void Tile::ModifyTileTex(SDL_Surface* Texture)
{
this->texture = Texture;
}

void Tile::ModifyTileTexCoord(SDL_Rect coordTex)
{
this->coordtex.x = coordTex.x;
this->coordtex.y = coordTex.y;
this->coordtex.w = coordTex.w;
this->coordtex.h = coordTex.h;
}

class Sprite
{
public:
static Sprite** SpriteArray;
static int ID,ID2;
int x,y,Number;
SDL_Surface* Texture;
SDL_Rect TextureCoord;
Sprite();
friend Sprite* GetFirstSprite();
friend Sprite* GetNextSprite();
friend Sprite* GetSprite(int N);
void SetPositionSprite(int x,int y);
void SetSpriteTex(SDL_Surface* Tex);
void SetSpriteTexCoord(SDL_Rect NewRect);
void BlitSprite(SDL_Surface* Surface);
~Sprite();
};

int Sprite::ID = 0;
int Sprite::ID2 = 0;
Sprite** Sprite::SpriteArray = new Sprite*[MAX_SPRITE];

Sprite::Sprite()
{
SpriteArray[ID++]=this;
SpriteArray[ID]=NULL;
Number = (ID-1);
}

Sprite* GetFirstSprite()
{
Sprite::ID2 = 0;
return Sprite::SpriteArray[Sprite::ID2];
}

Sprite* GetNextSprite()
{
return Sprite::SpriteArray[++Sprite::ID2];
}

Sprite* GetSprite(int N)
{
return Sprite::SpriteArray[N];
}

void Sprite::SetPositionSprite(int x,int y)
{
this->x = x;
this->y = y;
}

void Sprite::SetSpriteTex(SDL_Surface* Tex)
{
this->Texture = Tex;
}

void Sprite::SetSpriteTexCoord(SDL_Rect NewRect)
{
this->TextureCoord.x = NewRect.x;
this->TextureCoord.y = NewRect.y;
this->TextureCoord.w = NewRect.w;
this->TextureCoord.h = NewRect.h;
}

void Sprite::BlitSprite(SDL_Surface* Surface)
{
SDL_Rect A;
A.x = this->x;
A.y = this->y;
SDL_BlitSurface(this->Texture,&(this->TextureCoord),Surface,&A);
}

Sprite::~Sprite()
{
int IDToRemplace = Number;

while(GetSprite(IDToRemplace)!=NULL)
{
SpriteArray[IDToRemplace]=SpriteArray[++IDToRemplace];
}
ID-=1;
}

class Texture
{
SDL_Rect TexCoord;
SDL_Surface* Tex;
public:
Texture(int x,int y,int w,int h,char* nomfichier,SDL_Surface* Tex=NULL);
SDL_Rect* GetTexRect();
SDL_Surface* GetTexture();
void ChangeTexRect(int x,int y,int w,int h);
void ChangeTexture(SDL_Surface* NewTex);
void FreeTexture();
~Texture(){};
};

Texture::Texture(int x,int y,int w,int h,char* nomfichier,SDL_Surface* Tex)
{
if(Tex == NULL)
this->Tex = IMG_Load(nomfichier);
else
this->Tex = Tex;

this->TexCoord.x = x;
this->TexCoord.y = y;
this->TexCoord.w = w;
this->TexCoord.h = h;
}

SDL_Rect* Texture::GetTexRect()
{
return &TexCoord;
}

SDL_Surface* Texture::GetTexture()
{
return this->Tex;
}

void Texture::ChangeTexRect(int x,int y,int w,int h)
{
this->TexCoord.x = x;
this->TexCoord.y = y;
this->TexCoord.w = w;
this->TexCoord.h = h;
}

void Texture::ChangeTexture(SDL_Surface* NewTex)
{
this->Tex = NewTex;
}

void Texture::FreeTexture()
{
SDL_FreeSurface(this->Tex);
}

La source du jeu :

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "2Dengine.h" //On inclut le moteur 2d (moi je l'ai mis dans un fichier nommé 2Dengine.h).

int main(int argc,char* argv[])
{
SDL_Init(SDL_INIT_VIDEO);

SDL_Surface* Ecran = SDL_SetVideoMode(800,600,32,SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_HWACCEL);
SDL_EnableKeyRepeat(10,10);//On active la répétition de touches.

//On déclare toutes les textures.
Texture MarioGaucheNoWalk(0,0,50,50,"mario.bmp");
Texture MarioGaucheWalk1(50,0,50,50,NULL,MarioGaucheNoWalk.GetTexture());
Texture MarioGaucheWalk2(0,50,50,50,NULL,MarioGaucheNoWalk.GetTexture());
Texture MarioDroiteNoWalk(50,50,50,50,NULL,MarioGaucheNoWalk.GetTexture());
Texture MarioDroiteWalk1(0,100,50,50,NULL,MarioGaucheNoWalk.GetTexture());
Texture MarioDroiteWalk2(50,100,50,50,NULL,MarioGaucheNoWalk.GetTexture());
Texture SKY(0,0,50,50,"tiles.bmp");
Texture herbe(50,0,50,50,NULL,SKY.GetTexture());
Texture Bonus(0,50,50,50,NULL,SKY.GetTexture());
Texture ChapiArret(0,0,50,50,"enemi.bmp");
Texture ChapiPasGauche(50,0,50,50,NULL,ChapiArret.GetTexture());
Texture ChapiPasDroit(100,0,50,50,NULL,ChapiArret.GetTexture());
Texture Nuage(0,0,100,100,"nuage.bmp");

//On met en place les colorkey des textures.
SDL_SetColorKey(MarioGaucheNoWalk.GetTexture(),SDL_SRCCOLORKEY,SDL_MapRGB(MarioGaucheNoWalk.GetTexture()->format,0,255,0));
SDL_SetColorKey(SKY.GetTexture(),SDL_SRCCOLORKEY,SDL_MapRGB(SKY.GetTexture()->format,0,255,0));
SDL_SetColorKey(ChapiArret.GetTexture(),SDL_SRCCOLORKEY,SDL_MapRGB(ChapiArret.GetTexture()->format,0,255,0));
SDL_SetColorKey(Nuage.GetTexture(),SDL_SRCCOLORKEY,SDL_MapRGB(Nuage.GetTexture()->format,0,255,0));

//On créer un tile array dont un tile fait 50*50 pixels et dont l'array fait 800*600.
TileArray Map(800,600,50,50,SKY.GetTexture());

//Definition des sprites.
Sprite Mario;
Mario.SetPositionSprite(100,500);
Mario.SetSpriteTex(MarioGaucheNoWalk.GetTexture());
Mario.SetSpriteTexCoord(*MarioDroiteNoWalk.GetTexRect());

Sprite Bonuss;
Bonuss.SetPositionSprite(300,400);
Bonuss.SetSpriteTex(Bonus.GetTexture());
Bonuss.SetSpriteTexCoord(*Bonus.GetTexRect());

Sprite Bonuss2;
Bonuss2.SetPositionSprite(350,400);
Bonuss2.SetSpriteTex(Bonus.GetTexture());
Bonuss2.SetSpriteTexCoord(*Bonus.GetTexRect());

Sprite Bonuss3;
Bonuss3.SetPositionSprite(400,400);
Bonuss3.SetSpriteTex(Bonus.GetTexture());
Bonuss3.SetSpriteTexCoord(*Bonus.GetTexRect());

Sprite Monstre;
Monstre.SetPositionSprite(50,500);
Monstre.SetSpriteTex(ChapiArret.GetTexture());
Monstre.SetSpriteTexCoord(*ChapiArret.GetTexRect());

Sprite Nuagee;
Nuagee.SetPositionSprite(50,100);
Nuagee.SetSpriteTex(Nuage.GetTexture());
Nuagee.SetSpriteTexCoord(*Nuage.GetTexRect());
//Fin définition sprite

Tile* TileToModif = NULL;

//on configure grace a une boucle le sol du TileArray.
for(int i = 0;i<16;i++)
{
TileToModif = Map.GetTile(i,11);
TileToModif->ModifyTileProp(TILE_INTRAVERSABLE);
TileToModif->ModifyTileTex(herbe.GetTexture());
TileToModif->ModifyTileTexCoord(*herbe.GetTexRect());
}

//On blit le tout sur l'ecran.
Map.BlitArray(Ecran);
Mario.BlitSprite(Ecran);
Bonuss.BlitSprite(Ecran);
Bonuss2.BlitSprite(Ecran);
Monstre.BlitSprite(Ecran);
SDL_Flip(Ecran);

//A partir d'ici c'est vous même qui gerez avec les methodes du moteur.
//Moi j'ai fait un truc vraiment discutable mdr.
//Mais au moins ça anime un peu.
bool continuer = true;
SDL_Event event;
int countAnim = 0;
int compteurAnim = 0;
bool direction = true;
bool directionnuage = true;

while(continuer)
{
SDL_PollEvent(&event);
if(compteurAnim==0)
{
Monstre.SetSpriteTexCoord(*ChapiArret.GetTexRect());
}
else if(compteurAnim==5)
Monstre.SetSpriteTexCoord(*ChapiPasGauche.GetTexRect());
else if(compteurAnim==10)
Monstre.SetSpriteTexCoord(*ChapiPasDroit.GetTexRect());

if(direction)
{
Monstre.SetPositionSprite((Monstre.x = Monstre.x+3),500);
if(Monstre.x >= 750)
direction = false;
}
else
{
Monstre.SetPositionSprite((Monstre.x = Monstre.x-3),500);
if(Monstre.x <= 0)
direction = true;
}

if(directionnuage)
{
Nuagee.SetPositionSprite((Nuagee.x = Nuagee.x+2),100);
if(Nuagee.x >= 850)
directionnuage = false;
}
else
{
Nuagee.SetPositionSprite((Nuagee.x = Nuagee.x-2),200);
if(Nuagee.x <= -100)
directionnuage = true;
}

if(event.type == SDL_QUIT)
continuer = false;

if(event.type == SDL_KEYDOWN)
{
if(event.key.keysym.sym == SDLK_LEFT)
{
if(countAnim == 0)
Mario.SetSpriteTexCoord(*MarioGaucheNoWalk.GetTexRect());
else if(countAnim == 3)
Mario.SetSpriteTexCoord(*MarioGaucheWalk1.GetTexRect());
else if(countAnim == 5)
Mario.SetSpriteTexCoord(*MarioGaucheWalk1.GetTexRect());
Mario.SetPositionSprite((Mario.x = Mario.x-7),Mario.y);
countAnim++;
}
else if(event.key.keysym.sym == SDLK_RIGHT)
{
if(countAnim == 0)
Mario.SetSpriteTexCoord(*MarioDroiteNoWalk.GetTexRect());
else if(countAnim == 3)
Mario.SetSpriteTexCoord(*MarioDroiteWalk1.GetTexRect());
else if(countAnim == 5)
Mario.SetSpriteTexCoord(*MarioDroiteWalk2.GetTexRect());
Mario.SetPositionSprite((Mario.x = Mario.x+7),Mario.y);
countAnim++;
}

if(event.key.keysym.sym == SDLK_ESCAPE)
continuer = false;

}
compteurAnim++;

if(compteurAnim > 10)
compteurAnim= compteurAnim^compteurAnim;

//On blit le tout sur l'ecran suite aux modificatins eventuelles dues a la capture d'evenements.
Map.BlitArray(Ecran);
Mario.BlitSprite(Ecran);
Bonuss.BlitSprite(Ecran);
Bonuss2.BlitSprite(Ecran);
Bonuss3.BlitSprite(Ecran);
Monstre.BlitSprite(Ecran);
Nuagee.BlitSprite(Ecran);
SDL_Flip(Ecran);

if(countAnim > 5)
countAnim = countAnim ^ countAnim ;
}

//On libère la mémoire utilisée pour les surfaces des textures.
MarioGaucheNoWalk.FreeTexture();
SKY.FreeTexture();
ChapiArret.FreeTexture();
Nuage.FreeTexture();

SDL_Quit();
return 0;
}

Bon par contre pour les fichiers images je sais pas comment vous les transmettre snif vu que g pas de ftp.
donc si une ame généreuse pouvait me contacter par msn (castorus9@hotmail.com)
pour ajouter ma démo sur sur ftp ce serais sympas. voili voilou.