Obliczanie współrzędnych mapy

#ifndef TerrainAndFloors_hpp
#define TerrainAndFloors_hpp

float tileSide = 16.0f;

enum class terrainType { grass, sands, water, gravel };

class TerrainPrefab
    : public GameObject
{
public:
    Texture * texture;
    terrainType ttype;
   
    TerrainPrefab( string name, terrainType ttype )
        : GameObject( name )
    {
        type = gameObjectType::Terrain;
        texture = getTexture( name );
        this->ttype = ttype;
    }
   
};

class Terrain
    : public sf::Drawable
    , public sf::Transformable
{
public:
    int width, height;
    sf::Vector2i coords;
   
    sf::VertexArray vertexes;
    sf::Texture tileset;
   
    std::vector < int > tiles;
   
    Terrain( int x, int y, int width, int height ) {
       
        coords.x = x;
        coords.y = y;
       
        this->width = width;
        this->height = height;
       
        tileset = sf::Texture();
        tileset = * getTexture( "tiles/0_tileset" )->texture;
       
        vertexes.setPrimitiveType( sf::Triangles );
        vertexes.resize( width * height * 6 ); // widthMap * heightMap * TwoTrianglesVertices
       
        tiles.resize( width * height );
       
        int tu, tv;
        int coord_x, coord_y;
       
        // TERRAIN - GRASS
        for( int y = 0; y < height; y++ )
        for( int x = 0; x < width; x++ ) {
           
            sf::Vertex * triangles = & vertexes[( y * width + x ) * 6 ];
           
            coord_x =( coords.x + x ); // tu jakoś źle obliczam
            coord_y =( coords.y + y ); // tu też źle obliczam
           
            triangles[ 0 ].position = sf::Vector2f( coord_x * tileSide, coord_y * tileSide );
            triangles[ 1 ].position = sf::Vector2f(( coord_x + 1 ) * tileSide, coord_y * tileSide );
            triangles[ 2 ].position = sf::Vector2f( coord_x * tileSide,( coord_y + 1 ) * tileSide );
            triangles[ 3 ].position = sf::Vector2f( coord_x * tileSide,( coord_y + 1 ) * tileSide );
            triangles[ 4 ].position = sf::Vector2f(( coord_x + 1 ) * tileSide, coord_y * tileSide );
            triangles[ 5 ].position = sf::Vector2f(( coord_x + 1 ) * tileSide,( coord_y + 1 ) * tileSide );
           
            edit( x, y, 0 );
        }
       
       
    }
   
    void edit( int x, int y, int value ) {
       
        if( x < 0 || x >= width || y < 0 || y >= height )
             return;
       
        if( value > 3 || value < 0 )
             return;
       
        tiles[ y * width + x ] = value;
       
        int global_x = coords.x + x; // wiem że tu także źle obliczam
        int global_y = coords.y + y; // i nie rozumiem dlaczego
       
        sf::Vertex * triangles = & vertexes[( y * width + x ) * 6 ];
       
        int tu =( int( global_x * tileSide ) % 64 ) +( value * 64 );
        int tv =( int( global_y * tileSide ) % 64 );
       
        //cout << "tu: " << tu << ", tv: " << tv << "\n";
       
        triangles[ 0 ].texCoords = sf::Vector2f( tu, tv );
        triangles[ 1 ].texCoords = sf::Vector2f( tu + tileSide, tv );
        triangles[ 2 ].texCoords = sf::Vector2f( tu, tv + tileSide );
        triangles[ 3 ].texCoords = sf::Vector2f( tu, tv + tileSide );
        triangles[ 4 ].texCoords = sf::Vector2f( tu + tileSide, tv );
        triangles[ 5 ].texCoords = sf::Vector2f( tu + tileSide, tv + tileSide );
    }
   
   
private:
   
    virtual void draw( sf::RenderTarget & target, sf::RenderStates states ) const
    {
       
        // draw tiles - terrain
        states.transform *= getTransform();
        states.texture = & tileset; // TO-DO
        target.draw( vertexes, states );
    }
};

#endif

class Map {
public:
    Terrain * terrain;
    Floors * floors;
   
    Map( int x, int y ) {
       
        terrain = new Terrain( x * 16, y * 16, 16, 16 );
        floors = new Floors( x * 16, y * 16, 16, 16 );
    }
   
    ~Map() { }
   
    void draw()
    {
        window->draw( * terrain );
        window->draw( * floors );
    }
};

class World {
public:
    std::vector < Map * > maps;
   
    World() {
       
        maps.clear();
    }
   
    void load() {
       
        maps.clear();
       
        // 8 x 4
        int start_x = 0;
        int end_x = 16;
        int start_y = 0;
        int end_y = 16;
       
        // CREATING MAPS
        for( int y = start_y; y <= end_y; y++ )
        for( int x = start_x; x <= end_x; x++ )
             maps.push_back( new Map( x, y ) );
       
        for( auto & map: maps ) {
            //map->load();
        }
       
    }
   
    Map * getMap( sf::Vector2f worldMousePosition ) {
       
        float left, right, top, bottom;
       
        for( auto & m: maps ) {
           
            left = m->terrain->coords.x * 16 * tileSide;
            right = left + m->terrain->width * tileSide;
            top = m->terrain->coords.y * 16 * tileSide;
            bottom = top + m->terrain->height * tileSide;
           
            if( worldMousePosition.x >= left && worldMousePosition.x <= right && worldMousePosition.y >= top && worldMousePosition.y <= bottom )
                 return m;
           
        }
       
        return nullptr;
    }
   
   
    void draw() {
        //sf::Clock c;
        //sf::Time start = c.getElapsedTime();
       
        for( auto & map: maps ) {
            map->draw();
        }
       
        //sf::Time end = c.getElapsedTime();
        //
        //cout << (end - start).asMilliseconds() << " ms,\t";
        //cout << (end - start).asSeconds() << " s \n";
    }
   
   
};