TileMap sur SFML 2.3

Version imprimable

Bonjour,

Je suis en dut info 1ère année et je dois réaliser un Rogue Like avec quelqu’un. On a décidé d'utilisé SFML pour la partie graphique.
Je me suis attaqué à la génération de la map. En soit, j'ai quasiment réussi car j'ai réussi à importer les données de mon fichier texte à mon tableau. Ensuite, je me suis trés largement inspiré du tuto sur le site de SFML pour passer de mon tableau au rendu graphique.

Lorsque je compile,mon tableau est reconnu et j'arrive à l'afficher, par contre, une fois que le bout de code sur le site de SFML vient à son tour parcourir le tableau il y a un hic ... J'ai des valeurs énormes alors que mon tableau ne contient que des 0 et des 1. Je n'arrive vraiment pas a comprendre d'où cela pourrait venir ...

Voilà mon code :
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
 
#include <SFML/Graphics.hpp>
#include <cstring>
#include <iostream>
#include <fstream>
 
using namespace std;
using namespace sf;
 
#include "tileMap.hpp"
int main()
{
    RenderWindow window(VideoMode(512, 256), "Tilemap");
 
    string niveau;
    int Y, X;
    ifstream fichier("test.txt");
 
    fichier >> niveau >> X >> Y;
    cout << " nom niveau "<< niveau << " " << " nb ligne " << X << " " << " nb colonne " << Y << endl << endl;
    int level[X*Y];
 
    for(int i=0; i<Y;i++)
    {
        for(int y=0;y<X;y++)
        {
            fichier >> level[y];
            cout<<level[y];
        }
        cout <<endl;
    }
 
 
    // on crée la tilemap avec le niveau précédemment défini
    TileMap map;
    if (!map.load("wall.png", Vector2u(32, 32), level, X, Y))
        return -1;
 
    // on fait tourner la boucle principale
 
    while (window.isOpen())
    {
  Event event;
        while (window.pollEvent(event))
        {
            if(event.type == Event::Closed)
                window.close();
        }
 
        window.clear();
        window.draw(map);
        window.display();
    }
 
    return 0;
}

tileMap.hpp

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
 
 
class TileMap : public Drawable, public Transformable
{
public:
 
    bool load(const string& tileset,Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height)
    {
        // on charge la texture du tileset
        if (!m_tileset.loadFromFile(tileset))
            return false;
 
        // on redimensionne le tableau de vertex pour qu'il puisse contenir tout le niveau
        m_vertices.setPrimitiveType(Quads);
        m_vertices.resize(width * height * 4);
 
        // on remplit le tableau de vertex, avec un quad par tuile
         for (unsigned int i = 0; i < width; ++i)
            for (unsigned int j = 0; j < height; ++j)
            {
                // on récupère le numéro de tuile courant
                int tileNumber = tiles[i + j * width];
 
                // on en déduit sa position dans la texture du tileset
                int tu = tileNumber % (m_tileset.getSize().x / tileSize.x);
                int tv = tileNumber / (m_tileset.getSize().x / tileSize.x);
 
                // on récupère un pointeur vers le quad à définir dans le tableau de vertex
                Vertex* quad = &m_vertices[(i + j * width) * 4];
 
                // on définit ses quatre coins
                quad[0].position = Vector2f(i * tileSize.x, j * tileSize.y);
                quad[1].position = Vector2f((i + 1) * tileSize.x, j * tileSize.y);
                quad[2].position = Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
                quad[3].position = Vector2f(i * tileSize.x, (j + 1) * tileSize.y);
 
                // on définit ses quatre coordonnées de texture
                quad[0].texCoords = Vector2f(tu * tileSize.x, tv * tileSize.y);
                quad[1].texCoords = Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
                quad[2].texCoords = Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
                quad[3].texCoords = Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
            }
 
        return true;
    }
 
private:
 
    virtual void draw(RenderTarget& target, RenderStates states) const
    {
        // on applique la transformation
        states.transform *= getTransform();
 
        // on applique la texture du tileset
        states.texture = &m_tileset;
 
        // et on dessine enfin le tableau de vertex
        target.draw(m_vertices, states);
    }
 
    VertexArray m_vertices;
    Texture m_tileset;
};

J’espère avoir était suffisamment clair dans mes explications !

J'attend vos réponses impatiament :?

Bonjour,

Code:

1
2
3
4
5
6
7
8
9
 for(int i=0; i<Y;i++)
    {
        for(int y=0;y<X;y++)
        {
            fichier >> level[y];
            cout<<level[y];
        }
        cout <<endl;
    }

C'est pas level[i * y] à la place de level[y] ?

Re,

Je viens de faire le test sa ne change rien :/

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
 
 
class TileMap : public Drawable, public Transformable
{
public:
 
    bool load(const std::string& tileset,Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height)
    {
        // on charge la texture du tileset
        if (!m_tileset.loadFromFile(tileset))
            return false;
 
        // on redimensionne le tableau de vertex pour qu'il puisse contenir tout le niveau
        m_vertices.setPrimitiveType(Quads);
        m_vertices.resize(width * height * 4);
 
        // on remplit le tableau de vertex, avec un quad par tuile
         for (unsigned int i = 0; i < width; ++i)
            for (unsigned int j = 0; j < height; ++j)
            {
                // on récupère le numéro de tuile courant
                int tileNumber = tiles[i + j * width];
                cout << tileNumber << " ";
 
                // on en déduit sa position dans la texture du tileset
                int tu = tileNumber % (m_tileset.getSize().x / tileSize.x);
                int tv = tileNumber / (m_tileset.getSize().x / tileSize.x);
 
                // on récupère un pointeur vers le quad à définir dans le tableau de vertex
                Vertex* quad = &m_vertices[(i + j * width) * 4];
 
                // on définit ses quatre coins
                quad[0].position = Vector2f(i * tileSize.x, j * tileSize.y);
                quad[1].position = Vector2f((i + 1) * tileSize.x, j * tileSize.y);
                quad[2].position = Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
                quad[3].position = Vector2f(i * tileSize.x, (j + 1) * tileSize.y);
 
                // on définit ses quatre coordonnées de texture
                quad[0].texCoords = Vector2f(tu * tileSize.x, tv * tileSize.y);
                quad[1].texCoords = Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
                quad[2].texCoords = Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
                quad[3].texCoords = Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
            }
 
        return true;
    }
 
private:
 
    virtual void draw(RenderTarget& target, RenderStates states) const
    {
        // on applique la transformation
        states.transform *= getTransform();
 
        // on applique la texture du tileset
        states.texture = &m_tileset;
 
        // et on dessine enfin le tableau de vertex
        target.draw(m_vertices, states);
    }
 
    sf::VertexArray m_vertices;
    sf::Texture m_tileset;
};

J'ai ajouté un cout << tileNumber << " "; pour pouvoir voir quelle valeur était prise lorsque la boucle parcours le tableau et sa ne change rien si je met mon tableau en [y*i] ou [y] lors de ma première boucle (pour récupérer la map sur le fichier texte). Au final j'ai toujours de valeurs type 9203264 et autres énormités qui viennent se greffer à la place de mes 0 ou 1 ...

Merci de ta réponse en tout cas !

24/05/2015, 14h19
Cirrus Minor

Oui, mais je me suis planté :P

Citation:

Envoyé par Cirrus Minor

C'est pas level[i * y] à la place de level[y] ?

Essaie: level[i * X + y] à la place de level[y].

EDIT: Les valeurs "énormes", ce sont des valeurs de ton tableau que tu n'as pas initialisées et qui n'ont pas été remplies par ta double boucle.
24/05/2015, 15h05
GuillaumeB.

Parfait un GRAND merci 8-) !!

A une prochaine fois peut être :)
24/05/2015, 15h18
Cirrus Minor

Cool, ça marche ! Tu as bien compris quelle était l'erreur ?

Par contre, dans un roguelike, les niveaux sont générés aléatoirement, ils ne sont pas lus dans un fichier !
Est-ce que tu vas utiliser des algorithmes de génération procédurale, ou restes-tu sur des niveaux créés "manuellement" ?
24/05/2015, 15h52
GuillaumeB.

Oui oui. En gros je parcourais mal mon tableau du coup j'initialisais pas toute mes cases (vu que je prenais en compte ni la première boucle de parcours).

Ben disons qu'on doit créer un rogue like où chacun va pouvoir créer sa propre aventure. D'où le système de fichier ect ... Du coup je reste sur des niveaux créé à la main oui !