Bonjour tout le monde
 
J'ai un petit projet qui est la crétion d'un jeux 2D (genre zelda) sans prétention, ceci sera ma première expérience de jeux video (générallement je code plus de petites appli. "utile" qui ne touche en aucun cas au domaine du jeux video).
Donc après avoir choisi la SDL pour faire ce jeux (qui je pense est une bonne bibliothéque), je décide de me lancer dans le cahier des charge, et là j'ai trop du mal à visualiser un algorithme pour gérer l'affichage la crétion de la map etc...
 
Donc voilà :
je compte représenter la map dans un tableau a 2 dimensions, charger mon chipset (qui contient tout les tiles ) dans un SD_Surface *chipset
la map sera lu a partir d'un fichier qui contiendra des chiffres qui représenterons les tiles (un editeur de map verra donc le jour)
une fois le fichier de la map chargé je parcourerais mon chipset en fonction du chiffre (mais là je vois pas comment, comment faire le liens entre le chiffre et la position de la tile a afficher)
...
 
enfin bref comme vous pouvez le voir j'ai un gros problème de conceptualisation, je n'arrive pas a visualiser l'affichage de la map ainsi que la sauvegarde etc...
 
ce que j'attend de vous ce sont des conseils, des methodes, un algorithme ?! me dire si je suis sur la bonne voix et peut-etre m'éclairer sur "comment faire le liens entre le chiffre et la position de la tile a afficher" etc...

Crée un objet plus complexe CTile qui contiendrait, en plus de son identifiant de représentation ses coordonnées.

je devrais donc faire une procédure chargementTile qui se chargerai avant toute manipulation de parcourir le chipset et d'attribuer pour chaque tile un identifiant et sa position en x et y (l'objet CTile), et ensuite si je veux charger une map j'aurai simplement à lire dans le fichier .map (par exemple) l'identifiant et ensuite en fonction de celui-ci je parcours mon chipset et j'affiche, c'est ca ?

par exemple, en gérant le tout dans un vector.

hmm, ok bon j'vais déjà essayer de voir ca, merci
 
si quelqu'un à une méthode pour gérer une map je suis prenneur

hum, si c'est une carte 2D, divisée en carrés, chaque carré contenant une tile, tu peut t'inspirer du format d'image XPM, avec des tiles au lieu de couleurs. Ça ressemble à ça:

• entête: tailleX tailleY nombre_tiles_utilisés
• liste des fichiers tiles utilisés séparés par \n:

sol.bmp
sable.bmp
mer.bmp
...

• carte, format binaire, par ex. une plage:

00000
01110
11211
22222
22222
(note: 0=sol, 1=sable, 2=mer)
 
Quand tu lis la carte, tu crée deux tableaux:

• les tiles: nom fichier et image SDL
• la carte: numéro de tile dans le tableau de tiles

Quand tu édite la carte, tu ajoute des tiles à la liste des tiles utilisés, tu modifie la taille de la carte, et/ou tu change les numéros de tiles dans chaque case du tableau 2D.
 
Quand tu sauvegarde la carte, tu sauvegarde l'entête, puis le tableau de tiles utilisés en utisant le nom de fichier tile, puis la carte 2D.
 
Quand tu affiche la carte, tu affiche une partie du tableau 2D, pour chaque case affichée le tile est dans tiles_utilisés[ carte[x][y] ]. Quand tu scrolle la carte, tu scrolle l'écran, et tu ne réaffiche que les nouveaux tiles qui apparaissent sur les bords.
 
SDL possède des fonctions pour charger différents formats de fichiers image.
 
Si tu souhaite ajouter plusieurs niveaux de hauteur tu peut utiliser le même principe avec un tableau 3D pour la carte.
 
Si tu souhaite ajouter des objets par dessus la carte, comme des personnages, tu peut t'inspirer de formats tels que HTML ou XML:
<JOUEUR>
  <POSX>10</POSX>
  <POSY>15</POSY>
</JOUEUR>
<ENEMI>
  <POSX>10</POSX>
  <POSY>15</POSY>
</ENEMI>
Tu stocke les objets dans une liste chaînée, pour la parcourrir facilement. En fonction du tag, tu peut créer des objets de type différents, avec des propriétés différentes, tu as besoin dans ce cas d'un numéro de type (enum), et/ou de pointeurs sur fonctions.
Par ex.
struct Enemi
{
  enum TypeEnemi type;
  int posX, posY;
  SDL_Surface tiles[4]; // quatre positions NordSudEstOuest
  int (*action)(struct Enemi*); // pointeur sur fonction ``action`` pour intelligence artificielle
};

ca c'est de la réponse merci beaucoup j'arrive déjà mieux à me repérer, c'est cool

bonsoir,
 
j'ai commencé par pondre un petit truc, le compilo me retourne aucune erreur mais lors de l'execution c'est le plantage
 
je suis complétement largué    
 
main.cpp //pour vous montrer comment je l'utilise

 
map.cpp

 
map.h

 
ce que me dit le debugger:
 

 
apparemment c'est un pointeur mais j'ai regardé et je ne vois vraimment rien, je désespère là problème avec mes vector ?  

j'allais oublier le back-trace me donne ca:
 

 
en ce qui concerne la classe Tile, il n'y a vraimment rien d'important, l'implémentation est des plus simpliste (du genre return x

Pour trouver ce genre de bug, fait tourner le programme avec le débugger, il te donnera la ligne où se trouve l'erreur.
 
(pour info) fait gaffe avec ça:

le résultat de la division est tronqué. Il est préférable de regrouper la définition de WIDTH, TILE_W, et WIDTH/TILE_W, pour les avoir sous les yeux ensemble.
 
> srand(time(NULL));
à ne faire qu'une seule fois en début de programme
 
> affichage() { ...    for()   for()      x=0;
- essaye de mettre l'initialisation avant le deuxième for(). comme tu est en C++, tu peut même déclarer x dans le premier for()

D'après le trace:
> tiles[i].setX(x);
plante car tiles[i] n'a pas été initialisé. agrandit ton vector avant d'écrire dedans:
http://gcc.gnu.org/onlinedocs/libs [...] 1vectora24
utilise resize()
 
Edit: idem pour: map[i][j] = rand()%nb_tile;

donc voila, j'ai redimentionné les tiles comme ceci:

 
et la map comme cela:

 
je n'est plus d'erreur, la fenêtre s'affiche bien mais reste toute blanche (la map ne s'affiche pas) un erreur dans mon algo. ?!

J'ai trouvé ce que j'avais oublié trop content ca marche.
 
Merci beaucoup.

ok, pas de problème n'hésite pas si tu as d'autres questions