Editeur de map

**Bourg** · 21/11/2014, 10h48

Bonjour, alors voila je vous explique mon soucis , je souhaite amélioré l'éditeur de map de mario sokoban en faisant des cartes plus grandes et en rechargeant seulement une partie de la carte mais je ne sais pas du tout comment m'y prendre ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
 
void editeur(SDL_Surface* ecran)
{
    SDL_Surface *mur = NULL, *caisse = NULL, *objectif = NULL, *mario = NULL;
    SDL_Rect position;
    SDL_Event event;
 
    int continuer = 1, clicGaucheEnCours = 0, clicDroitEnCours = 0;
    int objetActuel = MUR, i = 0, j = 0;
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
 
    // Chargement des objets et du niveau
    mur = SDL_LoadBMP("mur.bmp");
    caisse = SDL_LoadBMP("caisse.bmp");
    objectif = SDL_LoadBMP("objectif.bmp");
    mario = SDL_LoadBMP("mario_bas.bmp0");
 
    if (!chargerNiveau(carte))
        exit(EXIT_FAILURE);
 
    // Boucle infinie de l'éditeur
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_MOUSEBUTTONDOWN:
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
                    carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;
                    clicDroitEnCours = 1;
                }
                break;
            case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
                if (event.button.button == SDL_BUTTON_LEFT)
                    clicGaucheEnCours = 0;
                else if (event.button.button == SDL_BUTTON_RIGHT)
                    clicDroitEnCours = 0;
                break;
            case SDL_MOUSEMOTION:
                if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;
                }
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_s:
                        sauvegarderNiveau(carte);
                        break;
                    case SDLK_c:
                        chargerNiveau(carte);
                        break;
                    case SDLK_KP1:
                        objetActuel = MUR;
                        break;
                    case SDLK_KP2:
                        objetActuel = CAISSE;
                        break;
                    case SDLK_KP3:
                        objetActuel = OBJECTIF;
                        break;
                    case SDLK_KP4:
                        objetActuel = MARIO;
                        break;
                }
                break;
        }
 
        // Effacement de l'écran
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
 
        // Placement des objets à l'écran
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
            for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
            {
                position.x = i * TAILLE_BLOC;
                position.y = j * TAILLE_BLOC;
 
                switch(carte[i][j])
                {
                    case MUR:
                        SDL_BlitSurface(mur, NULL, ecran, &position);
                        break;
                    case CAISSE:
                        SDL_BlitSurface(caisse, NULL, ecran, &position);
                        break;
                    case OBJECTIF:
                        SDL_BlitSurface(objectif, NULL, ecran, &position);
                        break;
                    case MARIO:
                        SDL_BlitSurface(mario, NULL, ecran, &position);
                        break;
                }
            }
        }
 
        // Mise à jour de l'écran
        SDL_Flip(ecran);
    }
 
    SDL_FreeSurface(mur);
    SDL_FreeSurface(caisse);
    SDL_FreeSurface(objectif);
    SDL_FreeSurface(mario);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
    int i = 0, j = 0;
 
    fichier = fopen("niveaux.lvl", "r");
    if (fichier == NULL)
        return 0;
 
    fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
 
    for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
            {
                case '0':
                    niveau[j][i] = 0;
                    break;
                case '1':
                    niveau[j][i] = 1;
                    break;
                case '2':
                    niveau[j][i] = 2;
                    break;
                case '3':
                    niveau[j][i] = 3;
                    break;
                case '4':
                    niveau[j][i] = 4;
                    break;
            }
        }
    }
 
    fclose(fichier);
    return 1;
}
 
int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;
 
    fichier = fopen("niveaux.lvl", "w");
    if (fichier == NULL)
        return 0;
 
    for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            fprintf(fichier, "%d", niveau[j][i]);
        }
    }
 
    fclose(fichier);
    return 1;
}

Merci de votre futur aide

**LittleWhite** · 22/11/2014, 10h07

Bonjour,

Pourquoi en ne rechargeant qu'une seule partie de la carte. Je pense qu'il est plus simple de charger toute la carte, mais d'afficher juste une partie.

**DiR95** · 22/11/2014, 11h06

C est ce que je veux faire mais je ne vois pas comment faire...

**LittleWhite** · 22/11/2014, 11h43

Pour cela (afficher qu'une partie) il suffit de changer la boucle d'affichage (et de ne pas toucher au chargement). Quoi que, un soucis avec ce code de chargement, c'est que la taille est définie en dur.

**DiR95** · 22/11/2014, 11h45

Pourrais tu me montrer un exemple en modifiant mes constantes par des valeurs

On modifie lors du chargement de la map ?

**LittleWhite** · 22/11/2014, 12h05

La meilleure des solutions c'est de placer la taille de la map, dans le fichier de la map :

10 15
000101101010 ...
...

Le 10, représente la largeur et le 15 la hauteur.
Malheureusement, cette méthode demande d'utiliser des tableaux dynamiques (alloué avec malloc, durant le chargement). C'est légèrement plus dur à faire, mais c'est très faisable. De plus, cela supprime les mauvaises variables globales que vous utilisez.

Pour revenir au vrai souci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// Placement des objets à l'écran
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
       for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
       {

Lorsque l'on a une carte plus grande que l'écran, il faut faire en sorte de ne plus utiliser NB_BLOCS_LARGEUR, mais un nombre de bloc, que l'écran peut afficher. En effet, si la carte fait 100 blocs, l'écran ne pourra afficher que 15 blocs. De plus, les valeurs d'initialisation de i et j, peuvent varier, suivant le placement de "l'écran" sur la carte.
En général, il faut imaginer un rectangle (l'écran) qui se déplacer sur la carte.
Cette série de tutoriels : http://jeux.developpez.com/tutoriels...uction-niveau/ explique ces principes.

**Bourg** · 23/11/2014, 00h01

Bonsoir , j'ai un petit problème avec mon editeur de map qui dejà positionne des images n 'importe comment ..
Et charge une carte avec des images alors que le fichier est vide.. je bloque complément (je suis débutant en SDL)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
void editeur(SDL_Surface* ecran)
{
   /* SDL_Surface *mur = NULL, *caisse = NULL, *objectif = NULL, *mario = NULL;*/
    SDL_Surface *herbe = NULL, *chemin = NULL, *regeneration = NULL, *arene = NULL, *dresseur = NULL;
    SDL_Rect position;
    SDL_Event event;
 
    int continuer = 1, clicGaucheEnCours = 0, clicDroitEnCours = 0;
	int objetActuel = HERBE, i = 0, j = 0;
    int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
 
 
	herbe = SDL_LoadBMP("images/bmp/herbe.bmp");
    chemin = SDL_LoadBMP("images/bmp/chemin.bmp");
    regeneration = SDL_LoadBMP("images/bmp/ipcentre.bmp");
    arene = SDL_LoadBMP("images/bmp/arene.bmp");
    dresseur = SDL_LoadBMP("water.bmp");
 
    if (!chargerNiveau(carte))
        exit(EXIT_FAILURE);
 
    // Boucle infinie de l'éditeur
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_MOUSEBUTTONDOWN:
		if(objetActuel = HERBE){
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
 
                    carte[event.button.x / 165][event.button.y / 165] = HERBE;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / 165][event.button.y /165] = VIDE;
                    clicDroitEnCours = 1;
                }
}
 
		if(objetActuel = CHEMIN){
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
 
                    carte[event.button.x / 180 ][event.button.y / 178] = CHEMIN;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / 180][event.button.y /178] = VIDE;
                    clicDroitEnCours = 1;
                }
}
 
		if(objetActuel = REGENERATION){
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
 
                    carte[event.button.x / 147][event.button.y / 159] = REGENERATION;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / 147][event.button.y /159] = VIDE;
                    clicDroitEnCours = 1;
                }
}
		if(objetActuel = ARENE){
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
 
                    carte[event.button.x / 157][event.button.y / 75] = ARENE;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / 157][event.button.y /75] = VIDE;
                    clicDroitEnCours = 1;
                }
}
 
		if(objetActuel = DRESSEUR){
                if (event.button.button == SDL_BUTTON_LEFT)
                {
                    // On met l'objet actuellement choisi (mur, caisse...) à l'endroit du clic
 
                    carte[event.button.x / 25][event.button.y / 25] = DRESSEUR;
                    clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
                }
                else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
                {
                    carte[event.button.x / 25][event.button.y /25] = VIDE;
                    clicDroitEnCours = 1;
                }
}
                break;
            case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
                if (event.button.button == SDL_BUTTON_LEFT)
                    clicGaucheEnCours = 0;
                else if (event.button.button == SDL_BUTTON_RIGHT)
                    clicDroitEnCours = 0;
                break;
            case SDL_MOUSEMOTION:
		if(objetActuel = HERBE){
		 if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / 165][event.motion.y / 165] = HERBE;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / 165][event.motion.y / 165] = VIDE;
                }
}
 
		if(objetActuel = CHEMIN){
		 if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / 180][event.motion.y / 178] = CHEMIN;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / 180][event.motion.y / 178] = VIDE;
                }
}
 
		if(objetActuel =  REGENERATION){
		 if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / 147][event.motion.y / 159] = REGENERATION;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / 147][event.motion.y / 159] = VIDE;
                }
}
 
		if(objetActuel = ARENE){
		 if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / 157][event.motion.y / 75] = ARENE;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / 157][event.motion.y / 75] = VIDE;
                }
}
 
		if(objetActuel = DRESSEUR){
		 if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
                {
                    carte[event.motion.x / 25][event.motion.y / 25] = DRESSEUR;
                }
                else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
                {
                    carte[event.motion.x / 25][event.motion.y / 25] = VIDE;
                }
}
 
 
 
                break;
 
 
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_s:
                        sauvegarderNiveau(carte);
                        break;
                    case SDLK_c:
                        chargerNiveau(carte);
                        break;
                    case SDLK_KP1:
                        objetActuel = HERBE;
                        break;
                    case SDLK_KP2:
                        objetActuel = CHEMIN;
                        break;
                    case SDLK_KP3:
                        objetActuel = REGENERATION;
                        break;
                    case SDLK_KP4:
                        objetActuel = ARENE;
                        break;
		    case SDLK_KP5:
                        objetActuel = DRESSEUR;
                        break;
                }
                break;
        }
 
        // Effacement de l'écran
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
 
        // Placement des objets à l'écran
        for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
        {
            for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
            {
		if (carte[i][j] == HERBE){
		position.x = i * 165;
                position.y = j * 165;
		 SDL_BlitSurface(herbe, NULL, ecran, &position);
		break;
		}
		if (carte[i][j] == CHEMIN){
		position.x = i * 180;
                position.y = j * 178;
		 SDL_BlitSurface(chemin, NULL, ecran, &position);
		break;
		}
		if (carte[i][j] == REGENERATION){
		position.x = i * 147;
                position.y = j * 159;
		 SDL_BlitSurface(regeneration, NULL, ecran, &position);
		break;
		}
		if (carte[i][j] == ARENE){
		position.x = i * 157;
                position.y = j * 75;
		 SDL_BlitSurface(arene, NULL, ecran, &position);
		break;
		}	
		if (carte[i][j] == DRESSEUR){
		position.x = i * 25;
                position.y = j * 25;
		 SDL_BlitSurface(dresseur, NULL, ecran, &position);
		break;
		}
 
 
 
            }
        }
 
        // Mise à jour de l'écran
        SDL_Flip(ecran);
    }
 
    SDL_FreeSurface(herbe);
    SDL_FreeSurface(chemin);
    SDL_FreeSurface(regeneration);
    SDL_FreeSurface(arene);
    SDL_FreeSurface(dresseur);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
    int i = 0, j = 0;
 
    fichier = fopen("zone/r", "r");
    if (fichier == NULL)
        return 0;
 
    fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);
 
    for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
            {
                case '0':
                    niveau[j][i] = 0;
                    break;
                case '1':
                    niveau[j][i] = 1;
                    break;
                case '2':
                    niveau[j][i] = 2;
                    break;
                case '3':
                    niveau[j][i] = 3;
                    break;
                case '4':
                    niveau[j][i] = 4;
                    break;
            }
        }
    }
 
    fclose(fichier);
    return 1;
}
 
int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
    FILE* fichier = NULL;
    int i = 0, j = 0;
 
    fichier = fopen("zone/r", "w");
    if (fichier == NULL)
        return 0;
 
    for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
        {
            fprintf(fichier, "%d", niveau[j][i]);
        }
    }
 
    fclose(fichier);
    return 1;
}

Merci de votre aide..

Editeur de map

SDL

Discussions similaires

Partager

Partager