[SFML]Problème Tile Mapping

Version imprimable

Bonjour tout le monde !

J'ai un petit problème de boucle et je dois dire que je n'y comprends plus rien ....

Voici le code fautif :

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
 
//Fonction qui permet d'afficher la map
void Map::afficheMap(Sprite &spriteMur, Sprite &spriteCaisse, Sprite &spriteMario, RenderWindow &fenetre)
{
    //Map
    map =
        {
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,MUR},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,MARIO,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,MUR,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,CAISSE},
        };
 
    //Parcourt de la map pour afficher les sprites correspondant
    for(int i = 0; i < NB_TILE_LARGEUR; i++)
    {
        for(int j = 0; j < NB_TILE_LONGUEUR; j++)
        {
            if(map[i][j] == MUR)
            {
                spriteTexture = spriteMur;
                spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                fenetre.Draw(spriteTexture);
                cout << "i : " << i << "j : " << j << endl;
            }/*
            else if(map[i][j] == CAISSE)
            {
                spriteTexture = spriteCaisse;
                spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                fenetre.Draw(spriteTexture);
                cout << "Pasage CAISSE [i][j] [" << i << "][" << j << "]" << endl;
            }
            else if(map[i][j] == MARIO)
            {
                spriteTexture = spriteMario;
                spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                fenetre.Draw(spriteTexture);
                cout << "Pasage MARIO [i][j] [" << i << "][" << j << "]" << endl;
            }*/
        }
    }
}

Map.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class Map
{
    public:
 
    Map();
    ~Map();
    void afficheMap(Sprite &spriteMur, Sprite &spriteCaisse, Sprite &spriteMario, RenderWindow &fenetre);
 
    private:
 
    Sprite spriteTexture;
    int map[NB_TILE_LARGEUR][NB_TILE_LONGUEUR];
};

Après plusieurs tests, il vient bien dans le premier if, m'affiche un seul mur (alors que je devrais en avoir 2) et boucle infiniment et je ne sais pas pourquoi :cry:

A l'affichage dans la commande des valeurs de i et j, j'ai ceci :

i : 1
j : 9

i : 6
j : 6

Ces 2 duos de nombres se répètent à l'infini..

Merci d'avance pour vos réponses.

P.S: J'essaye de faire un Mario Sokoban.

28/09/2010, 14h20
seeme

A première vue, le code à l'air correct.

Montre ton appel, les déclarations de tes constantes stp.

Voilà :

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
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
 
#include "Mario.h"
#include "Caisse.h"
#include "Constantes.h"
#include "Map.h"
 
int main(int argc, char** argv)
{
    //Création de la fenêtre
    RenderWindow fenetre(VideoMode(LONGUEUR_FENETRE, LARGEUR_FENETRE, AFFICHAGE_BITS), "Mario Sokoban");
 
    /* --- Création des différents objets --- */
    Mario mario;
    Caisse caisse("caisse.png");
    Mur mur("mur.png");
    Map map;
 
    //Test pour savoir si l'affectation du sprite a échouée
    if(!mario.affecteSprite("mario_droite.png"))
    {
        return EXIT_FAILURE;
    }
 
    Sprite spriteMur = mur.getSprite();
    Sprite spriteCaisse = caisse.getSprite();
    Sprite spriteMario = mario.getSprite();
 
    while(fenetre.IsOpened())
    {
        Event event;
 
        while(fenetre.GetEvent(event))
        {
            switch(event.Type)
            {
                case Event::Closed:
                    fenetre.Close();
                    break;
 
                //Gestion des événements des touches
                case Event::KeyPressed:
                {
                    switch(event.Key.Code)
                    {
                        case Key::Escape:
                            fenetre.Close();
                            break;
 
                        case Key::Right:
                            mario.affecteSprite("mario_droite.png");
                            mario.avancerDroite(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Left:
                            mario.affecteSprite("mario_gauche.png");
                            mario.avancerGauche(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Down:
                            mario.affecteSprite("mario_bas.png");
                            mario.descendre(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Up:
                            mario.affecteSprite("mario_haut.png");
                            mario.monter(VITESSE_DEPLACEMENT);
                            break;
                    }
                }
            }
        }
 
        fenetre.Clear();
        map.afficheMap(spriteMur, spriteCaisse, spriteMario,fenetre);
        fenetre.Display();
    }
 
    return EXIT_SUCCESS;
}

Constantes.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
 
/*
--- Fichier contenant les #define et les #include
*/
 
#ifndef CONSTANTES_H_INCLUDED
#define CONSTANTES_H_INCLUDED
 
#define LARGEUR_FENETRE 600
#define LONGUEUR_FENETRE 800
#define AFFICHAGE_BITS 32
#define VITESSE_DEPLACEMENT 10
#define LONGUEUR_TILE 80
#define LARGEUR_TILE 60
#define NB_TILE_LONGUEUR 10
#define NB_TILE_LARGEUR 10
#define MUR 1
#define CAISSE 2
#define MARIO 3
 
#include <iostream>
#include <SFML/Graphics.hpp>
#include <string>
#include <vector>
 
using namespace std;
using namespace sf;
 
#endif // CONSTANTES_H_INCLUDED

Dans Map.cpp, j'inclue bien Constantes.h et Map.h 8-)

28/09/2010, 14h30
seeme

Bon
Déjà c'est normal que ça boucle à l'infinie, vu que tu appels ta méthode dans une boucle infinie.

Pour le coup du mur, je suis en train de regarder, mais je crois que tu as un problème de référence.

:mrgreen: J'avais oublié la boucle infinie du début.

Enfin, voilà, j'ai modifié mon code comme ceci :

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
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 "Mario.h"
#include "Caisse.h"
#include "Constantes.h"
#include "Map.h"
#include "Mur.h"
 
int main(int argc, char** argv)
{
    //Création de la fenêtre
    RenderWindow fenetre(VideoMode(LONGUEUR_FENETRE, LARGEUR_FENETRE, AFFICHAGE_BITS), "Mario Sokoban");
 
    /* --- Création des différents objets --- */
    Mario mario;
    Caisse caisse("caisse.png");
    Mur mur("mur.png");
    Map map;
 
    //Test pour savoir si l'affectation du sprite a échouée
    if(!mario.affecteSprite("mario_droite.png"))
    {
        return EXIT_FAILURE;
    }
 
    Sprite spriteMur = mur.getSprite();
    Sprite spriteCaisse = caisse.getSprite();
    Sprite spriteMario = mario.getSprite();
 
    map.afficheMap(spriteMur, spriteCaisse, spriteMario,fenetre);
 
    while(fenetre.IsOpened())
    {
        Event event;
 
        while(fenetre.GetEvent(event))
        {
            switch(event.Type)
            {
                case Event::Closed:
                    fenetre.Close();
                    break;
 
                //Gestion des événements des touches
                case Event::KeyPressed:
                {
                    switch(event.Key.Code)
                    {
                        case Key::Escape:
                            fenetre.Close();
                            break;
 
                        case Key::Right:
                            mario.affecteSprite("mario_droite.png");
                            mario.avancerDroite(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Left:
                            mario.affecteSprite("mario_gauche.png");
                            mario.avancerGauche(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Down:
                            mario.affecteSprite("mario_bas.png");
                            mario.descendre(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Up:
                            mario.affecteSprite("mario_haut.png");
                            mario.monter(VITESSE_DEPLACEMENT);
                            break;
                    }
                }
            }
        }
 
        fenetre.Clear();
        fenetre.Display();
    }
 
    return EXIT_SUCCESS;
}

Le problème, c'est qu'il ne m'affiche plus rien maintenant et quand je regarde les valeurs de i et de j, j'ai les suivantes :

i : 1
j : 9

i : 6
j : 6

Ce que je comprend pas, c'est que dans ma boucle je fait un i++ et dans l'autre un j++ et là, il passe 2x fois dans la boucle et i vaut 1 et 6 et j vaut 9 et 6.

C'est pas normal non ?

28/09/2010, 14h45
seeme

Vu que tu fais ton cout dans le if (donc uniquement si la case en (i, j) est un mur), c'est normal qu'il n'affiche que les coordonnées des murs.

A vérifier dans la doc de la SFML, mais on me souffle dans l'oreillette que les sprites ne s'utilisent qu'une fois. Il faut donc que chaque case porte un sprite!
28/09/2010, 14h49
Charvalos

Oulah, suis pas réveillé moi :aie:

Mais alors, si il passe dans le if, donc normalement, c'est que la case du tableau contient MUR donc, si on suit la logique, il devrait m'afficher mon MUR non ?

Pourtant, ce n'est pas le cas... :(
28/09/2010, 14h53
seeme

Citation:

Envoyé par seeme

Vu que tu fais ton cout dans le if (donc uniquement si la case en (i, j) est un mur), c'est normal qu'il n'affiche que les coordonnées des murs.

A vérifier dans la doc de la SFML, mais on me souffle dans l'oreillette que les sprites ne s'utilisent qu'une fois. Il faut donc que chaque case porte un sprite!

cf mon post:

http://www.sfml-dev.org/tutorials/1....ics-sprite.php

Dans "Drawing a sprite"
28/09/2010, 14h56
Charvalos

Et si à la place de SetPosition, je fais Move ?
28/09/2010, 15h00
seeme

C'est pas logique de faire move...

* Il va mettre à jour le buffer avec le premier mur rencontré.
* Tu vas faire un move, il va mettre le buffer à jour en effaçant le mur et en le mettant à la position du deuxième mur
* Il va rendre la fenêtre (un seul mur à la dernière position trouvée dans le tableau...)

C'est pas beau de chercher à contourner les problèmes :aie:
28/09/2010, 15h02
saffir

Salut,

Le setPosition est très bien =)

L'idée est que tu dois passer une image à afficheMap, pour chaque case tu créés un sprite qui utilise cette image et tu le positionnes avec setPosition.

Et puis tu peux remettre l'appel à afficheMap dans la boucle (où il était avant) c'est normal qu'il soit appelé en boucle !
28/09/2010, 15h08
seeme

Citation:

Envoyé par saffir

Salut,

Le setPosition est très bien =)

L'idée est que tu dois passer une image à afficheMap, pour chaque case tu créés un sprite qui utilise cette image et tu le positionnes avec setPosition.

Et puis tu peux remettre l'appel à afficheMap dans la boucle (où il était avant) c'est normal qu'il soit appelé en boucle !

On va même pousser l'idée en passant une référence ou un pointeur vers l'image histoire de ne pas complètement saturer la pile :)
28/09/2010, 15h08
Charvalos

Aaaah :mrgreen:

Alors, si je comprends bien, cela sert à rien de passer par référence mes sprites.

Il faut que je charge mes images dans ma fonction afficheMap en fonction de la case de la map (mur, mario ou caisse), ensuite, j'affecte l'image au sprite privée de la classe map qui va ensuite l'afficher ?

J'ai modifié mon code mais j'ai toujours rien qui s'affiche...

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
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
 
#include "Mario.h"
#include "Caisse.h"
#include "Constantes.h"
#include "Map.h"
#include "Mur.h"
 
int main(int argc, char** argv)
{
    //Création de la fenêtre
    RenderWindow fenetre(VideoMode(LONGUEUR_FENETRE, LARGEUR_FENETRE, AFFICHAGE_BITS), "Mario Sokoban");
 
    /* --- Création des différents objets --- */
    Mario mario;
    Caisse caisse("caisse.png");
    Mur mur("mur.png");
    Map map;
 
    //Test pour savoir si l'affectation du sprite a échouée
    if(!mario.affecteSprite("mario_droite.png"))
    {
        return EXIT_FAILURE;
    }
 
    Image imageMur = mur.getImage();
 
    map.afficheMap(imageMur, fenetre);
 
    while(fenetre.IsOpened())
    {
        Event event;
 
        while(fenetre.GetEvent(event))
        {
            switch(event.Type)
            {
                case Event::Closed:
                    fenetre.Close();
                    break;
 
                //Gestion des événements des touches
                case Event::KeyPressed:
                {
                    switch(event.Key.Code)
                    {
                        case Key::Escape:
                            fenetre.Close();
                            break;
 
                        case Key::Right:
                            mario.affecteSprite("mario_droite.png");
                            mario.avancerDroite(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Left:
                            mario.affecteSprite("mario_gauche.png");
                            mario.avancerGauche(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Down:
                            mario.affecteSprite("mario_bas.png");
                            mario.descendre(VITESSE_DEPLACEMENT);
                            break;
 
                        case Key::Up:
                            mario.affecteSprite("mario_haut.png");
                            mario.monter(VITESSE_DEPLACEMENT);
                            break;
                    }
                }
            }
        }
 
        fenetre.Clear();
        fenetre.Display();
    }
 
    return EXIT_SUCCESS;
}

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
 
//Fonction qui permet d'afficher la map
void Map::afficheMap(Image &imageMur, RenderWindow &fenetre)
{
    //Map
    map =
        {
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,MUR},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,MARIO,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,MUR,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,CAISSE},
        };
 
    //Parcourt de la map pour afficher les sprites correspondant
    for(int i = 0; i < NB_TILE_LARGEUR; i++)
    {
        for(int j = 0; j < NB_TILE_LONGUEUR; j++)
        {
            if(map[i][j] == MUR)
            {
                spriteTexture.SetImage(imageMur);
                spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                fenetre.Draw(spriteTexture);
                cout << "i : " << i << " j : " << j << endl;
            }/*
            else if(map[i][j] == CAISSE)
            {
                spriteTexture = spriteCaisse;
                spriteTexture.Move(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                fenetre.Draw(spriteTexture);
                cout << "Pasage CAISSE [i][j] [" << i << "][" << j << "]" << endl;
            }
            else if(map[i][j] == MARIO)
            {
                spriteTexture = spriteMario;
                spriteTexture.Move(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                fenetre.Draw(spriteTexture);
                cout << "Pasage MARIO [i][j] [" << i << "][" << j << "]" << endl;
            }*/
        }
    }
}

28/09/2010, 15h15
seeme

Non, pas du tout...

On reprend depuis le début.

Une image, vois ça comme un énorme monstre glouton prêt à se repaitre de ta vram (ou de ta ram).

Comme on veut pas que le méchant glouton ne t'oblige à posséder 8 cartes graphiques pour afficher une image de 10px², le créateur de la sfml utilise le concept de sprite.

L'idée, c'est qu'une image, tu la charges une fois pour toute dans la vram. Ensuite, tu utilises des sprites pour dessiner cette image (voit ça comme un alias de ton image).

Donc, il faut avoir un vecteur de sprite (un vecteur de pointeur ou de références, selon ce que tu préfères..) pour dessiner ton plateau de jeu.

Par défaut, tu mets le sprite d'une case vide (un carré noir à partir d'un pixbuff, cf la doc sfml). Si tu rentres dans le if (sic), tu changes cette référence/pointeur par une vers un sprite de mur.

Donc, une solution serait d'avoir un tableau de pointeur/références vers des sprites, de passer une référence à ton image en paramètre, et dans ton if, de faire un plateau[i][j] = image.getSprite()
28/09/2010, 15h20
Charvalos

Ah ok, je vois le principe :

1) On charge une seul fois les images
2) On crée les sprites avec les images
3) On crée un tableau de références vers les sprites.
4) De base, dans la map, on fait une référence vers un sprite de case vide
5) Pour finir, dans mes if, je change le pointeur de la case vers le sprite correspondant.

C'est juste cette fois ? :D
28/09/2010, 15h27
seeme

Citation:

Envoyé par Charvalos

Ah ok, je vois le principe :

1) On charge une seul fois les images
2) On crée les sprites avec les images
3) On crée un tableau de références vers les sprites.
4) De base, dans la map, on fait une référence vers un sprite de case vide
5) Pour finir, dans mes if, je change le pointeur de la case vers le sprite correspondant.

C'est juste cette fois ? :D

Presque!
Pour récapituler..
Ajoute un tableau de sprite en membre privé de Map.
Dans le constructeur de Map, initialise tes sprites avec les sprites d'une image par défaut (un chemin praticable ou du noir j'imagine)
Change ton prototype pour passer une référence vers l'image qui t'intéresse
Dans ta boucle, quand tu rentres dans ton if, change le sprite dans ton tableau (à cette position) pour un sprite issu de l'image qui t'intéresse (en l'occurrence, un mur).

Attention: Pour le moment, tu n'as que des sprites de mur, donc ça passe, mais quand tu vas ajouter mario, les caisses, il faudra les passer aussi en paramètre (et si demain tu veux ajouter 14 types de cases différentes, tu vas te retrouver avec un prototype long comme le bras..)

Un conseil comme ça: à part Map, je ne pense pas que d'autres classes aient besoin de ces images. Pourquoi ne pas mettre ces images en membre private de Map, les charger dans le constructeur, les supprimer dans le destructeur?

edit: en fait de "presque", oui c'ets ça :)

Citation:

J'ai modifié mon code mais j'ai toujours rien qui s'affiche...

Comme je l'ai dit plus haut, il faut remettre l'affichage. Là tu vides ton écran... et tu remets rien dedans :s

Donc :
Code:

1 2 3 fenetre.Clear(); fenetre.Display();
Redeviens :
Code:

1 2 3 4 fenetre.Clear(); map.afficheMap(spriteMur, spriteCaisse, spriteMario,fenetre); // mais ça va changer comme tu vas pas envoyer les sprites mais les images ! (ou les images vont devenir membre de Map, cf seeme solution) fenetre.Display();
Et pour le reste je n'aurais pas dit mieux que Seeme !

28/09/2010, 15h31
Charvalos

Ok, merci beaucoup pour votre aide ! :ccool:

EDIT : Je ne le mets pas tout de suite en résolu le temps de changer mon code. ;)

Bien bien bien.

J'ai modifié mon code pour l'affichage de ma map mais j'ai toujours un petit problème d'affichage.

(Voir miniature attachée)

Voici mon code pour l'affichage de la map:

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
/*
--- Fichier contenant les implémentations de la classe Map
*/
 
#include "Constantes.h"
#include "Map.h"
 
Map::Map()
{
    //Si une image n'a pas pu se charger correctement, on arrête tout
    if(!imageCaisse.LoadFromFile("caisse.png") || !imageCaisseOk.LoadFromFile("caisseOk.png") ||
       !imageMarioBas.LoadFromFile("marioBas.png") || !imageMarioDroite.LoadFromFile("marioDroite.png") ||
       !imageMarioGauche.LoadFromFile("marioGauche.png") || !imageMarioHaut.LoadFromFile("marioHaut.png") ||
       !imageMur.LoadFromFile("mur.png") || !imageObjectif.LoadFromFile("objectif.png") || !imageCaseVide.LoadFromFile("caseVide.png"))
    {
        cout << "Une erreur est survenue lors du chargement du jeu" << endl;
        exit(EXIT_FAILURE);
    }
 
    //Affectation des sprites
    spriteCaisse.SetImage(imageCaisse);
    spriteCaisseOk.SetImage(imageCaisseOk);
    spriteMarioBas.SetImage(imageMarioBas);
    spriteMarioDroite.SetImage(imageMarioDroite);
    spriteMarioGauche.SetImage(imageMarioGauche);
    spriteMarioHaut.SetImage(imageMarioHaut);
    spriteMur.SetImage(imageMur);
    spriteObjectif.SetImage(imageObjectif);
    spriteCaseVide.SetImage(imageCaseVide);
 
    //Création du tableau des références vers les sprites
    creerTableauRef(spriteMur, spriteCaisse, spriteCaisseOk, spriteMarioDroite, spriteMarioGauche, spriteMarioHaut, spriteMarioBas, spriteObjectif, spriteCaseVide);
}
 
Map::~Map()
{
}
 
//Fonction qui va créer le tableau des références des sprites
void Map::creerTableauRef(Sprite &mur, Sprite &caisse, Sprite &caisseOk, Sprite &marioDroite, Sprite &marioGauche, Sprite &marioHaut, Sprite &marioBas, Sprite &objectif, Sprite &caseVide)
{
    tabReference[MUR] = mur;
    tabReference[CAISSE] = caisse;
    tabReference[CAISSE_OK] = caisseOk;
    tabReference[MARIO_DROITE] = marioDroite;
    tabReference[MARIO_GAUCHE] = marioGauche;
    tabReference[MARIO_HAUT] = marioHaut;
    tabReference[MARIO_BAS] = marioBas;
    tabReference[OBJECTIF] = objectif;
    tabReference[CASE_VIDE] = caseVide;
}
 
//Fonction qui va afficher la map
void Map::afficheMap(RenderWindow &fenetre)
{
    map = {
        {CASE_VIDE, CAISSE, MARIO_DROITE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        {CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE, CASE_VIDE},
        };
 
    //Parcourt de la map et affichage des sprites
    for(int i = 0; i < NB_TILE_LARGEUR; i++)
    {
        for(int j = 0; j < NB_TILE_LONGUEUR; j++)
        {
            switch(map[i][j])
            {
                case CASE_VIDE:
                    spriteTexture = tabReference[CASE_VIDE];
                    spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                    fenetre.Draw(spriteTexture);
                    break;
 
                case CAISSE:
                    spriteTexture = tabReference[CAISSE];
                    spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                    fenetre.Draw(spriteTexture);
                    break;
 
                case MARIO_DROITE:
                    spriteTexture = tabReference[MARIO_DROITE];
                    spriteTexture.SetPosition(i * LARGEUR_TILE, j * LONGUEUR_TILE);
                    fenetre.Draw(spriteTexture);
                    break;
            }
        }
    }
}
 
//Retourne la référence du sprite du tableau
Sprite Map::getSprite(int caseTab)
{
    return tabReference[caseTab];
}

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
 
/*
--- Fichier contenant les définitions des méthodes et des attributs
--- de la classe Map
*/
 
#ifndef MAP_H_INCLUDED
#define MAP_H_INCLUDED
#include "Constantes.h"
 
class Map
{
    public:
 
    Map();
    ~Map();
    void afficheMap(RenderWindow &fenetre);
 
    private:
 
    Sprite spriteTexture;
    Sprite spriteMur;
    Sprite spriteCaisse;
    Sprite spriteCaisseOk;
    Sprite spriteMarioDroite;
    Sprite spriteMarioGauche;
    Sprite spriteMarioHaut;
    Sprite spriteMarioBas;
    Sprite spriteObjectif;
    Sprite spriteCaseVide;
    Sprite tabReference[NB_SPRITE];
    Image imageMur;
    Image imageCaisse;
    Image imageCaisseOk;
    Image imageMarioDroite;
    Image imageMarioGauche;
    Image imageMarioHaut;
    Image imageMarioBas;
    Image imageObjectif;
    Image imageCaseVide;
    int map[NB_TILE_LARGEUR][NB_TILE_LONGUEUR];
    void creerTableauRef(Sprite &mur, Sprite &caisse, Sprite &caisseOk, Sprite &marioDroite, Sprite &marioGauche, Sprite &marioHaut, Sprite &marioBas, Sprite &objectif, Sprite &caseVide);
    Sprite getSprite(int caseTab);
};
 
#endif // MAP_H_INCLUDED

A mon avis, je me tromper quelque part dans ma fonction d'affichage, au moment où je crée la map.

Mais voilà, je sèche car je ne comprend pas pourquoi il me met autant d'espace entre les cases.... :cry:

Si quelqu'un sait pourquoi, je suis tout ouìe. :D