[SFML 2.0] Edytor map - rysowanie

Sprite level[ 15 ][ 20 ];

struct tileset
{
    Texture TilesetImage;
    Sprite TilesetSprite;
    unsigned int WhichFieldX;
    unsigned int WhichFieldY;
    Sprite ActiveField;
};

void GetField( tileset & titek, RenderWindow & wnd )
{
    titek.WhichFieldX =( Mouse::getPosition( wnd ).x / 32 ) * 32;
    titek.WhichFieldY =( Mouse::getPosition( wnd ).y / 32 ) * 32;
   
   
    if( Mouse::getPosition( wnd ).x <= titek.TilesetImage.getSize().x &&
    Mouse::getPosition( wnd ).y <= titek.TilesetImage.getSize().y )
    {
        if( Mouse::isButtonPressed( Mouse::Left ) )
        {
            titek.ActiveField.setTexture( titek.TilesetImage );
            titek.ActiveField.setTextureRect( IntRect( titek.WhichFieldX, titek.WhichFieldY, 32, 32 ) );
           
        }
    }
   
}

void ViewBrusch( tileset & titek, RenderWindow & wnd )
{
    for( int y = 0; y < 15; y++ )
    {
        for( int x = 0; x < 20; x++ )
        {
            titek.ActiveField.setPosition(( Mouse::getPosition( wnd ).x / 32 ) * 32,( Mouse::getPosition( wnd ).y / 32 ) * 32 );
            level[ y ][ x ] = titek.ActiveField;
            wnd.draw( level[ y ][ x ] );
        }
    }
}

void DrawInMap( tileset & titek, RenderWindow & wnd )
{
   
    //titek.WhichFieldX = (Mouse::getPosition(wnd).x / 32) * 32;
    //titek.WhichFieldY = (Mouse::getPosition(wnd).y / 32) * 32;
   
    if( Mouse::isButtonPressed( Mouse::Left ) )
    {
        level[ Mouse::getPosition( wnd ).y / 32 ][ Mouse::getPosition( wnd ).x / 32 ] = titek.ActiveField;
        level[ titek.WhichFieldY ][ titek.WhichFieldX ].setPosition( titek.WhichFieldX, titek.WhichFieldY );
    }
   
    for( int y = 0; y < 15; y++ )
    {
        for( int x = 0; x < 20; x++ )
        {
           
           
            wnd.draw( level[ y ][ x ] );
        }
    }
   
    system( "cls" );
    cout << Mouse::getPosition( wnd ).x / 32 << endl;
   
}

int main()
{
    RenderWindow Window( VideoMode( 640, 420, 32 ), "Spartan" );
   
    tileset titek;
    titek.TilesetImage.loadFromFile( "Tileset.png" );
    titek.TilesetSprite.setTexture( titek.TilesetImage );
   
    Event zdarzenie;
   
    while( Window.isOpen() )
    {
        while( Window.pollEvent( zdarzenie ) )
        {
            switch( zdarzenie.type )
            {
            case Event::Closed: Window.close(); break;
            }
        }
       
        Window.clear( Color::Black );
       
        ViewBrusch( titek, Window );
       
        if( Mouse::isButtonPressed( Mouse::Right ) )
        {
            GetField( titek, Window );
            Window.draw( titek.TilesetSprite );
        }
        DrawInMap( titek, Window );
        Window.display();
    }
    return 0;
}

#include "../include/Map.h"
#include <fstream>
#include <iostream>


bool Map::LoadFont( const std::string & filename )
{
    if( font.loadFromFile( filename ) )
    {
        return true;
    }
    else
    {
        std::cout << "Can't load Font: " << filename << std::endl;
        return false;
    }
}

void Map::LoadText()
{
    mousepos.setFont( this->font );
    mousepos.setPosition( 500, 50 );
    mousepos.setCharacterSize( 12 );
}
bool Map::LoadTexture( const std::string & filename )
{
    if( Texture.loadFromFile( filename ) )
    {
        TileSet.setTexture( Texture );
        std::cout << "Texture loaded" << std::endl;
        return true;
    }
    else { std::cout << "Can't Load Texture from file: " << filename << std::endl; return false; }
   
}

bool Map::LoadMap( const std::string & filename )
{
    std::fstream file;
    file.open( filename.c_str() );
    char first;
    char x = 'X';
    char y = 'Y';
    char z = 'Z';
    char sep = ':';
    char sepp = '.';
    if( file.is_open() )
    {
        while( !file.eof() )
        {
            file >> first >> sep;
            switch( first )
            {
            case 'T':
                {
                    Tile * temptile = new Tile;
                    file >> x >> temptile->X >> sep >> y >> temptile->Y >> sep >> z >> temptile->Z >> sep >> temptile->SpriteX >> sepp >> temptile->SpriteY;
                    TileList.push_back( temptile );
                    break;
                }
            case 'O':
                {
                    Object * tempobject = new Object;
                    file >> x >> tempobject->X >> sep >> y >> tempobject->Y >> sep >> z >> tempobject->Z >> sep >> tempobject->SpriteX >> sepp >> tempobject->SpriteY >> sep >> tempobject->type;
                    ObjectList.push_back( tempobject );
                    break;
                }
            }
        }
        Pos.x = 0;
        Pos.y = 0;
        std::cout << "Map loaded" << std::endl;
        return true;
    }
    else { std::cout << "Can't Load Map from file: " << filename << std::endl; return false; }
}

bool Map::Save( const std::string & filename )
{
    std::fstream file;
    file.open( filename.c_str(), std::ios::in | std::ios::out | std::ios::trunc );
    char x = 'X';
    char y = 'Y';
    char z = 'Z';
    char sep = ':';
    char sepp = '.';
    if( file.is_open() )
    {
        for( std::list < Tile *>::iterator it = TileList.begin(); it != TileList.end(); ++it )
        {
            Tile & tile = ** it;
            if( it == TileList.end() )
            {
                file << 'T' << sep << x << tile.X << sep << y << tile.Y
                << sep << z << tile.Z << sep << tile.SpriteX << sepp << tile.SpriteY;
            }
            else
            {
                file << 'T' << sep << x << tile.X << sep << y << tile.Y
                << sep << z << tile.Z << sep << tile.SpriteX << sepp << tile.SpriteY << "\n";
            }
        }
        for( std::list < Object *>::iterator it = ObjectList.begin(); it != ObjectList.end(); ++it )
        {
            Object & tile = ** it;
            if( it == ObjectList.end() )
            {
                file << 'O' << sep << x << tile.X << sep << y << tile.Y << sep << z << tile.Z
                << sep << tile.SpriteX << sepp << tile.SpriteY << sep << tile.type << "\n";
            }
            else
            {
                file << 'O' << sep << x << tile.X << sep << y << tile.Y << sep << z << tile.Z
                << sep << tile.SpriteX << sepp << tile.SpriteY << sep << tile.type;
            }
        }
        std::cout << "Map Saved" << std::endl;
        return true;
    }
    else { std::cout << "Can't Save Map to file: " << filename << std::endl; return false; }
}

void Map::DrawMap( sf::RenderWindow & wnd )
{
    for( std::list < Tile *>::iterator it = TileList.begin(); it != TileList.end(); ++it )
    {
        Tile & tile = ** it;
        if( tile.Z != currentlayer ) continue;
       
        TileSet.setPosition(( tile.X * tilesize ) +( Pos.x * tilesize ),( tile.Y * tilesize ) +( Pos.y * tilesize ) );
        TileSet.setTextureRect( sf::IntRect( tile.SpriteX * tilesize, tile.SpriteY * tilesize, tilesize, tilesize ) );
        wnd.draw( TileSet );
    }
   
    for( std::list < Object *>::iterator it = ObjectList.begin(); it != ObjectList.end(); ++it )
    {
        Object & obj = ** it;
        if( obj.Z != currentlayer ) continue;
       
        TileSet.setPosition( obj.X * tilesize, obj.Y * tilesize );
        TileSet.setTextureRect( sf::IntRect( obj.SpriteX * tilesize, obj.SpriteY * tilesize, tilesize, tilesize ) );
        wnd.draw( TileSet );
    }
   
}

bool Map::CheckTile( sf::RenderWindow & wnd )
{
    for( std::list < Tile *>::iterator it = TileList.begin(); it != TileList.end(); ++it )
    {
        Tile & tile = ** it;
        if( tile.Z == currentlayer && tile.X == mouse.getPosition( wnd ).x / tilesize
        && tile.Y == mouse.getPosition( wnd ).y / tilesize )
        {
            tile.X = mouse.getPosition( wnd ).x / tilesize;
            tile.Y = mouse.getPosition( wnd ).y / tilesize;
            tile.Z = currentlayer;
            tile.SpriteX = currenttile.SpriteX;
            tile.SpriteY = currenttile.SpriteY;
            return false;
        }
    }
    return true;
}

void Map::AddTile( sf::RenderWindow & wnd )
{
   
    Tile * temptile = new Tile;
    temptile->X =( mouse.getPosition( wnd ).x +( - Pos.x * tilesize ) ) / tilesize;
    temptile->Y =( mouse.getPosition( wnd ).y +( - Pos.y * tilesize ) ) / tilesize;
    temptile->Z = currentlayer;
    temptile->SpriteX = currenttile.SpriteX;
    temptile->SpriteY = currenttile.SpriteY;
    TileList.push_back( temptile );
}

void Map::Help( sf::RenderWindow & wnd )
{
    str = "Position: ";
    str += std::to_string(( mouse.getPosition( wnd ).x +( - Pos.x * tilesize ) ) / tilesize );
    str += " ";
    str += std::to_string(( mouse.getPosition( wnd ).y +( - Pos.y * tilesize ) ) / tilesize );
    str += "\nLayer: ";
    str += std::to_string( currentlayer );
    str += "\nCurrent Tile: X: ";
    str += std::to_string( currenttile.SpriteX );
    str += " Y: ";
    str += std::to_string( currenttile.SpriteY );
    str += "\nHELP\nNext Tile - Q\nPrevious Tile - W\nNext Layer - E\nPrevious Layer - R\nSave Map - S\n";
    mousepos.setString( str );
    wnd.draw( mousepos );
    TileSet.setPosition( mouse.getPosition( wnd ).x, mouse.getPosition( wnd ).y );
    TileSet.setTextureRect( sf::IntRect( currenttile.SpriteX * tilesize, currenttile.SpriteY * tilesize, tilesize, tilesize ) );
    wnd.draw( TileSet );
}

void Map::NextTile()
{
    sf::Sprite sprite;
    sprite.setTexture( Texture );
    if( currenttile.SpriteX >= 0
    && currenttile.SpriteX <=( sprite.getTextureRect().width / tilesize ) - 2 )
    {
        currenttile.SpriteX++;
    }
    else if( ++currenttile.SpriteX >=( sprite.getTextureRect().width / tilesize ) - 2
    && currenttile.SpriteY <=( sprite.getTextureRect().height / tilesize ) - 2 )
    {
        currenttile.SpriteY++;
        currenttile.SpriteX = 0;
    }
   
    if( currenttile.SpriteY <= 0 )
    {
        currenttile.SpriteY = 0;
    }
   
    if( currenttile.SpriteX <= 0 )
    {
        currenttile.SpriteX = 0;
    }
}

void Map::PreviousTile()
{
    sf::Sprite sprite;
    sprite.setTexture( Texture );
    if( currenttile.SpriteX <= 0
    && currenttile.SpriteX >=( sprite.getTextureRect().width / tilesize ) - 2 )
    {
        currenttile.SpriteX--;
    }
    else if( --currenttile.SpriteX <= 0
    && currenttile.SpriteY >= 0 )
    {
        currenttile.SpriteY--;
        currenttile.SpriteX =( sprite.getTextureRect().width / tilesize ) - 1;
        if( currenttile.SpriteX <= 0 )
        {
            currenttile.SpriteX = 0;
        }
       
        if( currenttile.SpriteY <= 0 )
        {
            currenttile.SpriteY = 0;
        }
    }
}

void Map::NextLayer()
{
    currentlayer++;
}
void Map::PreviousLayer()
{
    currentlayer--;
}