[Résolu] Tilemap isométrique ? Fail !

[S66]

Salut,
J'essaie de faire une tilemap isométrique à partir du code de tilemapping de la sfml en 2d.
Gros fail.
Voici mon code:

bool loadIso(const std::string& tileset, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height) {
        if (!m_tileset.loadFromFile(tileset))
            return false;

        m_vertices.setPrimitiveType(sf::Quads);
        m_vertices.resize(width * height * 4);

        for (unsigned int x = 0; x < width; ++x)
            for (unsigned int y = 0; y < height; ++y) {
                sf::Vertex* quad = &m_vertices[(x + y * width) * 4];

                if(x % 2 == 0){ //Nombre Pair
                    //Position des quatre coins
                    quad[0].position = sf::Vector2f(x * tileSize.x,        y * tileSize.y); //tileSize.x = 64, tileSize.y = 32
                    quad[1].position = sf::Vector2f((x + 1) * tileSize.x,  y * tileSize.y);
                    quad[2].position = sf::Vector2f((x + 1) * tileSize.x, (y + 1) * tileSize.y);
                    quad[3].position = sf::Vector2f(x * tileSize.x,       (y + 1) * tileSize.y);
                }else{ //Impair
                    //Position des quatre coins
                    quad[0].position = sf::Vector2f(x * tileSize.x + (tileSize.x/2),        (y * tileSize.y) - (y * (tileSize.y/2)));
                    quad[1].position = sf::Vector2f((x + 1) * tileSize.x + (tileSize.x/2),  (y * tileSize.y) - (y * (tileSize.y/2)));
                    quad[2].position = sf::Vector2f((x + 1) * tileSize.x + (tileSize.x/2), ((y + 1) * tileSize.y) - ((y + 1) * (tileSize.y/2)));
                    quad[3].position = sf::Vector2f(x * tileSize.x + (tileSize.x/2),       ((y + 1) * tileSize.y) - ((y + 1) * (tileSize.y/2)));
                }
                quad[0].texCoords = sf::Vector2f(0, 0);
                quad[1].texCoords = sf::Vector2f(64, 0);
                quad[2].texCoords = sf::Vector2f(64, 32);
                quad[3].texCoords = sf::Vector2f(0, 32);
            }
        return true;
    }

Résultat:

Cool ! Pourquoi mon programme fait ça ?!

[Laurent]

Le plus simple est de faire du debugging pas à pas et d'inspecter les différentes valeurs pour voir ce qui ne va pas.

[S66]

J'ai qDebug() le premier coin en haut à  gauche, j'ai aussi enlevé 4 colonnes de la map, et voilà ce que ça donne:

X, Y = PosX, PosY
0 ,  0  =  0 ,  0
0 ,  1  =  0 ,  32
0 ,  2  =  0 ,  64
0 ,  3  =  0 ,  96
0 ,  4  =  0 ,  128
0 ,  5  =  0 ,  160
0 ,  6  =  0 ,  192
0 ,  7  =  0 ,  224
1 ,  0  =  96 ,  0
1 ,  1  =  96 ,  16
1 ,  2  =  96 ,  32
1 ,  3  =  96 ,  48
1 ,  4  =  96 ,  64
1 ,  5  =  96 ,  80
1 ,  6  =  96 ,  96
1 ,  7  =  96 ,  112
2 ,  0  =  128 ,  0
2 ,  1  =  128 ,  32
2 ,  2  =  128 ,  64
2 ,  3  =  128 ,  96
2 ,  4  =  128 ,  128
2 ,  5  =  128 ,  160
2 ,  6  =  128 ,  192
2 ,  7  =  128 ,  224
3 ,  0  =  224 ,  0
3 ,  1  =  224 ,  16
3 ,  2  =  224 ,  32
3 ,  3  =  224 ,  48
3 ,  4  =  224 ,  64
3 ,  5  =  224 ,  80
3 ,  6  =  224 ,  96
3 ,  7  =  224 ,  112

Big anomalie.

[kimci86]

Cool ! Pourquoi mon programme fait ça ?!

Ton programme fait ça parce que c'est ce que tu lui demandes.

Ton calcul de position est mauvais. Si je comprends bien ta façon d'indexer les tuiles, tu te rendras compte en faisant un croquis que tu voulais probablement écrire ceci dans ta boucle:

sf::Vector2f position(x / 2 * tileSize.x, y * tileSize.y);
if(x % 2) //Impair
    position += tileSize / 2.f;

quad[0].position = position;
quad[1].position = position + sf::Vector2f(tileSize.x, 0);
quad[2].position = position + tileSize;
quad[3].position = position + sf::Vector2f(0, tileSize.y);

[S66]

J'aimerais croire que ça va marcher.
Mais SaMarchPas.
Le compilo refuse de m'(t')écouter :/
Mes erreurs:

no match for 'operator/' (operand types are 'sf::Vector2u {aka sf::Vector2<unsigned int>}' and 'float')
                     position += tileSize / 2.f;
                                          ^

Et l'autre:

no match for 'operator+' (operand types are 'sf::Vector2f {aka sf::Vector2<float>}' and 'sf::Vector2u {aka sf::Vector2<unsigned int>}')
                 quad[2].position = position + tileSize;
                                             ^

Okay. So what now ?

PS: Sinon j'avais à peu près réussi à faire une map isométrique mais il y'avait un décalage à chaque deux tuiles

[kimci86]

Le compilateur te dit que des opérateurs sont appelés sur des variables dont les types ne le permettent pas. En effet, tileSize est un Vector2u. Je pensais que tu manipulais des float. Cela est plus pratique pour pouvoir assigner des vecteurs à des positions d'objets de la SFML.
Le plus simple est d'utiliser un Vector2f à la place mais si tu veux garder un Vector2u, alors il va falloir faire des conversions à gogo.

[S66]

Bah en fait, je préfère toujours la bonne vieille méthode.
Solution:

bool loadIso(const std::string& tileset, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height) {
        if (!m_tileset.loadFromFile(tileset))
            return false;

        m_vertices.setPrimitiveType(sf::Quads);
        m_vertices.resize(width * height * 4);

        for (unsigned int x = 0; x < width; ++x)
            for (unsigned int y = 0; y < height; ++y) {
                sf::Vertex* quad = &m_vertices[(x + y * width) * 4];
                if(x % 2 == 0) {
                    if (x == 0) {
                        quad[0].position = sf::Vector2f(x * tileSize.x, y * tileSize.y);
                        quad[1].position = sf::Vector2f((x + 1) * tileSize.x, y * tileSize.y);
                        quad[2].position = sf::Vector2f((x + 1) * tileSize.x, (y + 1) * tileSize.y);
                        quad[3].position = sf::Vector2f(x * tileSize.x, (y + 1) * tileSize.y);
                    } else {
                        quad[0].position = sf::Vector2f((x - x/2) * tileSize.x, y * tileSize.y);
                        quad[1].position = sf::Vector2f((x - x/2 + 1) * tileSize.x, y * tileSize.y);
                        quad[2].position = sf::Vector2f((x - x/2 + 1) * tileSize.x, (y + 1) * tileSize.y);
                        quad[3].position = sf::Vector2f((x - x/2) * tileSize.x, (y + 1) * tileSize.y);
                    }

                    //qDebug() << x << ", " << y << " = " << (x * tileSize.x) << ", " << (y * tileSize.y);
                } else {
                        quad[0].position = sf::Vector2f((x) * tileSize.x - x * 32, (y * tileSize.y) + 16);
                        quad[1].position = sf::Vector2f((x + 1) * tileSize.x - x * 32, (y * tileSize.y) + 16);
                        quad[2].position = sf::Vector2f((x + 1) * tileSize.x - x * 32, ((y + 1) * tileSize.y) + 16);
                        quad[3].position = sf::Vector2f((x) * tileSize.x - x * 32,((y + 1) * tileSize.y) + 16);

                    //qDebug() << x << ", " << y << " = " << (x * tileSize.x + 32) << ", " << ((y * tileSize.y) - (y * 16));
                }
                quad[0].texCoords = sf::Vector2f(0, 0);
                quad[1].texCoords = sf::Vector2f(64, 0);
                quad[2].texCoords = sf::Vector2f(64, 32);
                quad[3].texCoords = sf::Vector2f(0, 32);

            }
        return true;
    }