Editeur de carte

Version imprimable

Editeur de carte

Bonjour,

j'ai un petit problème avec la création de mon éditeur de carte en 2D, j'aurais besoin d'explication alors voila mon code source :

main.cpp:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
#include "main.h"
 
using namespace std;
 
int main(int argc, char **argv)
{
    SDL_Event event;
    struct_map map;
    Init();
    int offset_X=0;
    int offset_Y=0;
    Map(&map,16,20,"mchip1.bmp");
    Map_Affiche(&map,offset_X,offset_Y);
    SDL_EnableKeyRepeat(100,10);
    while(1){
        while(SDL_PollEvent(&event)){
            if(event.type == SDL_KEYDOWN){
                if(event.key.keysym.sym == SDLK_ESCAPE) return 0;
                if(event.key.keysym.sym == SDLK_LEFT) offset_X ++;
                if(event.key.keysym.sym == SDLK_RIGHT) offset_X --;
                if(event.key.keysym.sym == SDLK_UP) offset_Y ++;
                if(event.key.keysym.sym == SDLK_DOWN) offset_Y --;                
            }        
        }
        SDL_FillRect(SDL_GetVideoSurface(),NULL,0);
        Map_Affiche(&map,offset_X,offset_Y);
        Map_Affichage_Chipset(&map,500,500);
        SDL_Flip(SDL_GetVideoSurface());
    } 
    SDL_Quit();
    return 0;                                         
}
 
void Init()
{
    SDL_Surface *screen;
    screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    SDL_WM_SetCaption("EDITEUR CARTE SDL","THORN");
}
 
SDL_Rect Rect(int x,int y,int w,int h)		//pour creer des rectangles plus vite :p
{
	SDL_Rect r;
	r.x=x;
	r.y=y;
	r.w=w;
	r.h=h;
	return r;
}

main.h :

Code:

1
2
3
4
5
6
7
8
9
#ifndef MAIN_H
# define MAIN_H
 
#include <sdl/sdl.h>
#include "map.h"
 
void Init();
 
#endif

map.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <iostream>
#include <stdlib.h>
#include "map.h"
#define TILE_TAILLE 32
 
using namespace std;
 
void InitMap(struct_map *map)
{
    map->longueur=0;     
    map->largeur=0;
    map->offsetX=0;
    map->offsetY=0;
    map->nb_tile=0;  
}
 
void Map(struct_map *map, int largeur, int longueur, char *chipset)
{
    InitMap(map); 
    int i,j,x,y; 
 
    map->s_chipset=SDL_LoadBMP(chipset);   
    map->nb_tile=(map->s_chipset->w/TILE_TAILLE)*(map->s_chipset->h/TILE_TAILLE);
    map->longueur=longueur;
    map->largeur=largeur;   
 
    x=y=0;   
//Pour mettre les chipsets dans un tableau.
    for(i=0; i<map->s_chipset->h/TILE_TAILLE; i++){
        map->chipset[i].pos_y = y;     
        for(j=0; j<map->s_chipset->w/TILE_TAILLE; j++){  
            map->chipset[j].pos_x = x; 
            x += TILE_TAILLE;                        
        }
        y += TILE_TAILLE;
        x = 0;
    }                                              
}
 
void Map_Affiche(struct_map *map, int Xoffset, int Yoffset)
{
    SDL_Rect src=Rect(0,0,32,32);
    SDL_Rect dest=Rect(0,0,32,32);
 
    int y,x;
    int x1,y1;
 
    map->offsetX = Xoffset;
    map->offsetY = Yoffset;
    x1 = map->offsetX+160;
    y1 = map->offsetY;
    for(y=0; y<map->largeur; y++){
        for(x=0; x<map->longueur; x++){   
            dest=Rect(x*TILE_TAILLE+x1 , y*TILE_TAILLE+y1 , TILE_TAILLE, TILE_TAILLE);                    
            SDL_BlitSurface(map->s_chipset,&src,SDL_GetVideoSurface(),&dest);
        }
    }
    src=Rect(0,0,32,32);
    dest=Rect(0,0,32,32);
    for(y=0; y<(map->s_chipset->h/TILE_TAILLE); y++){
        for(x=0; x<(map->s_chipset->w/TILE_TAILLE); x++){   
            src=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE);
            dest=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE);
            SDL_BlitSurface(map->s_chipset,&src,SDL_GetVideoSurface(),&dest);
        }
    }        
}
 
void Map_Affichage_Chipset(struct_map *map, int x, int y)
{
    SDL_Rect src=Rect(0,0,32,32);
    SDL_Rect dest=Rect(0,0,32,32);
    src.x = map->chipset[1].pos_x;
    src.y = map->chipset[2].pos_y;    
    dest.x = (24-((800-x)/TILE_TAILLE))*TILE_TAILLE;   
    dest.y = (18-((608-y)/TILE_TAILLE))*TILE_TAILLE;   
    SDL_BlitSurface(map->s_chipset,&src,SDL_GetVideoSurface(),&dest); 
}

map.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#ifndef MAP_H
# define MAP_H
 
 
#include <sdl/sdl.h>
#define GET_TILE(x,y,map) map->data[x+y*map->longueur]
 
struct struct_chipset
{
  unsigned int pos_x;
  unsigned int pos_y;
};
 
struct struct_map
{
   unsigned int nb_tile;       
   struct struct_chipset *chipset;
   SDL_Surface *s_chipset;  
   unsigned int longueur;        
   unsigned int largeur;                
   unsigned int offsetX;      
   unsigned int offsetY;
   unsigned int *data;
};
 
void InitMap(struct_map *map);
void Map(struct_map *map, int largeur, int longueur, char *chipset);
void Map_Affiche(struct_map *map, int Xoffset, int Yoffset);
void Map_Affichage_Chipset(struct_map *map, int x, int y);
SDL_Rect Rect(int x,int y,int w,int h);
 
#endif

voila bon ce n'est juste que le début, alors voila mon probleme j ai une carte de 10carreau * 32pixels(chaques carreaux) au debut ils sont bleu mais par exemple si je veux en mettre un vert au milieu je voudrais qu'il le mette sur la carte et non sur le SDL_GetVideoSurface(), sinon quand je deplace la carte, il me refait la carte en bleu a chaque fois et le carreau vert reste a sa place, j'espère que vous avez compris :/.

merci de votre aide :) .

21/02/2006, 13h22
Fiquet

Le problème est que tu lances SDL_FillRect() sur l'écran principal et pas sur la surface d'une de tes tiles.

[edit] non j'ai rien dit [/edit]

PS: Ton code est plus du C que du C++, même si tu emploies iostream. Tu pourrais faire des classes au lieu de tes structures, ce serait mieux géré les accès ; d'autre part, tu auras plus de succès dans le forums Développement 2D, 3D et Jeux. Demande à un modo de déplacer ;)
21/02/2006, 13h28
countag

ok je vais regarder ca mais de toute facon je suis obliger de lancer SDL_FillRect() sur l ecran principal aussinon j aurais une traine et j utilise des struct car si j utilise des classes le code sera plus consequent vu que je devrais faire des methodes d acces >< pour lire et ecrire et je vais demande a un modo de le deplacer en tous cas merci :)

mais je vais essaier de mettre la carte dans un tableau comme les chipsets non ?
21/02/2006, 13h42
Fiquet

Ah oui excuse c'est moi qui ai mal vu le FillRect() que tu as là vide l'écran effectivement :roll:...

Mais ou c'est que tu veux mettre en vert ? Tu n'a qu'à appeler SDL_FillRect() sur la tile à laquelle tu veux changer la couleur, avec NULL comme SDL_Rect si tu veux redessiner toute la tile et le tour est joué ;)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void Map_Affiche(struct_map *map, int Xoffset, int Yoffset) 
{ 
    SDL_Rect src=Rect(0,0,32,32); 
    SDL_Rect dest=Rect(0,0,32,32); 
 
    int y,x; 
    int x1,y1; 
 
    map->offsetX = Xoffset; 
    map->offsetY = Yoffset; 
    x1 = map->offsetX+160; 
    y1 = map->offsetY; 
    for(y=0; y<map->largeur; y++){ 
        for(x=0; x<map->longueur; x++){    
            dest=Rect(x*TILE_TAILLE+x1 , y*TILE_TAILLE+y1 , TILE_TAILLE, TILE_TAILLE);                    
            SDL_BlitSurface(map->s_chipset,&src,SDL_GetVideoSurface(),&dest); 
        } 
    } 
    src=Rect(0,0,32,32); 
    dest=Rect(0,0,32,32); 
    for(y=0; y<(map->s_chipset->h/TILE_TAILLE); y++){ 
        for(x=0; x<(map->s_chipset->w/TILE_TAILLE); x++){    
            src=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE); 
            dest=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE); 
            SDL_BlitSurface(map->s_chipset,&src,SDL_GetVideoSurface(),&dest); 
        } 
    }        
}

cette fonction va creer la map de la longueur entre dans le main.cpp, le probleme c est que si plus tard je modifie un truc, je rapelle cette fonction et il va recreer la map avec le chipset de base (le bleu), donc je pense que je dois creer un tableau ou je stock les tiles sur la carte.

21/02/2006, 14h07
Fiquet

Citation:

Envoyé par countag

donc je pense que je dois creer un tableau ou je stock les tiles sur la carte.

Tout à fait :) Tu doit créer un tableau de surfaces pour les blitter l'une après l'autre, pour qu'elles soient différenciées. Ici, tu blittes tout le temps la même chose (map->s_chipset) sur l'écran en changeant seulement la position, ce qui n'est pas ce que tu veux.

D'autre part, il me semble que ta fonction d'affichage est bizarre. Enfin de toute façon ce sera à revoir avec un tableau de surfaces. Mais je te conseilles si tu es vraiment dans le C++ de faire quelque chose de plus orienté objet, ce sera plus simple. Sinon reste entièrement en C ;).

j ai commence a refaire mon code voici ou j en suis :

main.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <iostream>
#include "main.h"
 
using namespace std;
 
int main(int argc, char **argv)
{
    SDL_Event event;
    Cmap map;
    Init();
    int offset_X=0;
    int offset_Y=0;
    map.Map(16,16,"mchip1.bmp");
    SDL_EnableKeyRepeat(100,10);
    while(1){
        while(SDL_PollEvent(&event)){
            if(event.type == SDL_KEYDOWN){
                if(event.key.keysym.sym == SDLK_ESCAPE) return 0;
                if(event.key.keysym.sym == SDLK_LEFT) offset_X ++;
                if(event.key.keysym.sym == SDLK_RIGHT) offset_X --;
                if(event.key.keysym.sym == SDLK_UP) offset_Y ++;
                if(event.key.keysym.sym == SDLK_DOWN) offset_Y --;                
            }        
        }
        SDL_FillRect(SDL_GetVideoSurface(),NULL,0);
        map.Map_Affiche(offset_X,offset_Y);
        SDL_Flip(SDL_GetVideoSurface());
    } 
    SDL_Quit();
    return 0;                                         
}
 
void Init()
{
    SDL_Surface *screen;
    screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    SDL_WM_SetCaption("EDITEUR CARTE SDL","THORN");
}
 
SDL_Rect Rect(int x,int y,int w,int h)		//pour creer des rectangles plus vite :p
{
	SDL_Rect r;
	r.x=x;
	r.y=y;
	r.w=w;
	r.h=h;
	return r;
}

main.h:

Code:

1
2
3
4
5
6
7
8
9
#ifndef MAIN_H
# define MAIN_H
 
#include <sdl/sdl.h>
#include "map.h"
 
void Init();
 
#endif

map.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <iostream>
#include <stdlib.h>
#include "map.h"
#define TILE_TAILLE 32
 
using namespace std;
 
void Cchipset::DefX(int x){ pos_x=x; }
void Cchipset::DefY(int y){ pos_y=y; }
int Cchipset::LitX(){ return pos_x; }
int Cchipset::LitY(){ return pos_y; }
 
 
void Cmap::DefX(int x){ pos_x=x; }
void Cmap::DefY(int y){ pos_y=y; }
void Cmap::DefLongueur(int DefLongueur){ longueur=DefLongueur; }
void Cmap::DefLargeur(int DefLargeur){ largeur=DefLargeur; }
void Cmap::DefOffsetX(int DefOffsetX){ offsetX=DefOffsetX; }
void Cmap::DefOffsetY(int DefOffsetY){ offsetY=DefOffsetY; }
int Cmap::LitX(){ return pos_x; }
 
int Cmap::LitY(){ return pos_y; }
int Cmap::LitLongueur(){ return longueur; }
int Cmap::LitLargeur(){ return largeur; }
int Cmap::LitOffsetX(){ return offsetX; }
int Cmap::LitOffsetY(){ return offsetY; }
 
void Cmap::Map(int largeur, int longueur, char *chipset)
{
    int i,j,x,y; 
 
    s_chipset=SDL_LoadBMP(chipset);   
    DefLongueur(longueur);
    DefLargeur(largeur);
 
    x=y=0;
 
//Pour mettre les chipsets dans un tableau.
 
    for(i=0; i<s_chipset->h/TILE_TAILLE; i++){
        chipset[i].DefY(y);     
        for(j=0; j<s_chipset->w/TILE_TAILLE; j++){  
            chipset[i].DefX(x); 
            x += TILE_TAILLE;                        
        }
        y += TILE_TAILLE;
        x = 0;
    }                                              
}
 
void Cmap::Map_Affiche(int Xoffset, int Yoffset)
{
    SDL_Rect src=Rect(0,0,32,32);
    SDL_Rect dest=Rect(0,0,32,32);
 
    int y,x;
    int x1,y1;
 
    DefOffsetX(Xoffset);
    DefOffsetY(Yoffset);
    x1 = LitOffsetX()+160;
    y1 = LitOffsetY();
    for(y=0; y<LitLargeur(); y++){
        for(x=0; x<LitLongueur(); x++){   
            dest=Rect(x*TILE_TAILLE+x1 , y*TILE_TAILLE+y1 , TILE_TAILLE, TILE_TAILLE);                  
            SDL_BlitSurface(s_chipset,&src,SDL_GetVideoSurface(),&dest);
        }
    }
    src=Rect(0,0,32,32);
    dest=Rect(0,0,32,32);
    for(y=0; y<(s_chipset->h/TILE_TAILLE); y++){
        for(x=0; x<(s_chipset->w/TILE_TAILLE); x++){   
            src=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE);
            dest=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE);
            SDL_BlitSurface(>s_chipset,&src,SDL_GetVideoSurface(),&dest);
        }
    }        
}

map.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#ifndef MAP_H
# define MAP_H
 
 
#include <sdl/sdl.h>
 
class Cchipset
{
public:
    void DefX(int x);  
    void DefY(int y); 
    int LitX();
    int LitY();
private:      
    int pos_x;
    int pos_y;      
};
 
class Cmap
{
public:
    SDL_Surface *s_chipset; 
    Cchipset *chipset;
    void Map(int largeur, int longueur, char *chipset);
    void Map_Affiche(int Xoffset, int Yoffset);
    void DefX(int x);  
    void DefY(int y); 
    void DefLongueur(int DefLongueur);  
    void DefLargeur(int DefLargeur);
    void DefOffsetX(int DefOffsetX);  
    void DefOffsetY(int DefOffsetY);    
    int LitX();
    int LitY();  
    int LitLongueur();
    int LitLargeur();
    int LitOffsetX();
    int LitOffsetY();       
private:      
    unsigned int longueur;        
    unsigned int largeur;                
    unsigned int offsetX;      
    unsigned int offsetY;  
    unsigned int pos_x;
    unsigned int pos_y;          
};
 
SDL_Rect Rect(int x,int y,int w,int h);
 
#endif

Par contre il me fait une erreur sur : chipset[i].DefY(y);

il me dit : `DefY' is not a type alors qu il est declarer, ai je oublier un truc ? ><

merci de votre aide :)

21/02/2006, 20h07
Fiquet

Parce que chipset est déclaré comme char* si tu regardes les paramètres de ta fonction et pas comme chipset*. Par contre, tu devrais revoir certaines choses dans ton code. Le principe des classes, des fonctions membres, etc.

Si vraiment tu n'y arrives pas, alors reste sur les structures et les fonctions que tu avais avant, car là on dirait que tu as gardé le même principe, juste en changeant tes fonctions en fonctions membres et tes struct en class. Documentes-toi sur les constructueurs, etc. si tu veux faire de la POO.

voila le nouveau code :

MAP.H:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#ifndef MAP_H
# define MAP_H
 
 
#include <sdl/sdl.h>
 
class Cmap
{
public:
    Cmap();
    ~Cmap();       
    SDL_Surface *s_chipset; 
    void Map(int,int,char *chipset);
    void Map_Affiche(int,int);
 
private:      
    int LoMap;        
    int LaMap;                
    int MoffsetX;      
    int MoffsetY;  
    int Mpos_x[1024];
    int Mpos_y[1024];
    int Cpos_x[50];
    int Cpos_y[50];          
};
 
SDL_Rect Rect(int x,int y,int w,int h);
 
#endif

MAP.CPP:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <iostream>
#include <stdlib.h>
#include "map.h"
#define TILE_TAILLE 32
 
using namespace std;
 
Cmap::Cmap(){         
    LoMap=LaMap=MoffsetX=MoffsetY=0;
} 
 
void Cmap::Map(int Largeur, int Longueur, char *chipset)
{
    int i,j,x,y; 
 
    s_chipset=SDL_LoadBMP(chipset);   
    LoMap=Longueur;
    LaMap=Largeur;
    x=y=0;
 
//Pour mettre les chipsets dans un tableau.
 
    for(i=0; i<s_chipset->h/TILE_TAILLE; i++){   
        Cpos_y[i] = y;     
        for(j=0; j<s_chipset->w/TILE_TAILLE; j++){       
            Cpos_x[j] = x; 
            x += TILE_TAILLE;                       
        }
        y += TILE_TAILLE;
        x = 0;
    }   
 
//Charge le tableau de la map avec le chipset par defaut
 
    for(i=0; i<LaMap; i++){       
        for(j=0; j<LoMap; j++){   
            Mpos_y[i] = 0;          
            Mpos_x[j] = 0;                       
        }
    }  
 
}
 
void Cmap::Map_Affiche(int Xoffset, int Yoffset)
{
    SDL_Rect src=Rect(Cpos_x[0],Cpos_y[0],32,32);
    SDL_Rect dest=Rect(0,0,32,32);
 
    int y,x,x1,y1=0;
    MoffsetX = Xoffset;
    MoffsetY = Yoffset;
    x1 = MoffsetX+160;
    y1 = MoffsetY;
 
 
    Mpos_x[5] = 32;
 
    for(y=0; y<LaMap; y++){
        for(x=0; x<LoMap; x++){   
            src=Rect(Mpos_x[x],Mpos_y[y],32,32);     
            dest=Rect(x*TILE_TAILLE+x1 , y*TILE_TAILLE+y1 , TILE_TAILLE, TILE_TAILLE);                  
            SDL_BlitSurface(s_chipset,&src,SDL_GetVideoSurface(),&dest);
        }
    }
 
   src=Rect(0,0,32,32);
   dest=Rect(0,0,32,32);
 
    for(y=0; y<(s_chipset->h/TILE_TAILLE); y++){
        for(x=0; x<(s_chipset->w/TILE_TAILLE); x++){   
            src=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE);
            dest=Rect(x*TILE_TAILLE , y*TILE_TAILLE, TILE_TAILLE, TILE_TAILLE);
            SDL_BlitSurface(s_chipset,&src,SDL_GetVideoSurface(),&dest);
        }
    }       
}
 
//Destructeur du chipset et de map
Cmap::~Cmap(){       
    SDL_FreeSurface(s_chipset);       
}

le probleme maintenant, c est que je voudrai stocker la carte dans un tableau enfin les coordonnes de chaque tile, le probleme c est que si je modifie Mpos_X[5] ca modifie toute la ligne ce qui est normal, j ai essaier de faire un tableau mutlidimenssionnelle mais aparament ca plante quelqu un aurait une idee ? :/