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 : 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
 
#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 : 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
 
 
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