sfml c++

#include <iostream>
#include <SFML/Graphics.hpp>
#include<cmath>
//#include"block.h"
//sf::RenderWindow win(sf::VideoMode(800,600),"RPG");
using namespace std;
enum class State{PAUSE,PLAYING};

/*
You only need to load a texture once per file. I've moved the texture you're using to a global variable for now to make things a bit easier.
*/
sf::Texture tex;

class Block{
sf::Sprite spr;
sf::Vector2f pos;

public:
    int pos_i;
    Block(float x=0.f,float y=0.f,float hi=0.f,float wd=0.f){

        sf::Vector2f size(hi,wd);
        pos.x=x; pos.y=y;
        spr.setTexture(tex);
        /*
        The way the original code was set up, it was using the same bit of art, which makes it really hard to tell what's the hero, and what's the weapon, and what's the map.
        This code picks a part of a 32x32 square in an image, which makes it easier to see what's what.
        Basically, a super simple way to do tilemaps and spritesheets and such.
        */
        spr.setTextureRect(sf::IntRect(size.x,size.y, 32,32));
        spr.setPosition(sf::Vector2f(x,y));
}


   void draw(sf::RenderWindow* win){

             win->draw(spr);
    }


    void set_size(sf::Vector2f size){spr.setTextureRect(sf::IntRect(0,0,size.x,size.y));}
    sf::Vector2f get_pos(){return pos;}
    sf::Sprite& get_tex(){return spr;}

   void set_pos(sf::Vector2f pos){spr.move(pos);}
};




class World{
int wd;
int hi;
int level[6][6];

public:

 Block** block1;
   int count;
    int get_pos(int i,int j){return level[i][j];} //world position.

    World():level{
    {1,0,0,0,0,0},
    {1,0,0,0,0,0},
    {1,0,0,0,0,0},
    {1,0,0,0,0,0},
    {1,0,0,0,0,0},
    {1,1,1,1,1,1}}{
    wd=6;
    hi=6;
    block1=new Block*[wd];
    for(int i=0;i<hi;i++)
        block1[i]=new Block[hi];

    for(int i=0;i<hi;i++){
        for(int j=0;j<wd;j++){

            if(level[i][j]==1){
           Block blk(j*24,i*24,0,0);
        block1[i][j]=blk;

        cout<<"  x "<<j<<"  y "<<i<<'\n';
        //cout<<" pos x "<<pos.x<<" pos y "<<pos.y<<'\n';
        }

        }


    }

//block[1].set_pos(sf::Vector2f(1.f*16,4.f*16));

}

void draw(sf::RenderWindow* win){
for(int i=0;i<wd;i++)
    for(int j=0;j<hi;j++){
        block1[i][j].draw(win);

}
}
};

class weapon{
 Block blc;
 bool m_up;
 bool m_dn;
 bool m_lt;
 bool m_rt;
 sf::Vector2f m_res;

 public:
       weapon():blc(0,0,32,0){
           /*
           setOrigin here places the origin of the sprite in the centre. This way, when we rotate the sprite, it spins around the middle
           */
       blc.get_tex().setOrigin(16, 16);
       }
    void move_rt(){m_rt=true;}
    void move_lt(){m_lt=true;}
    void move_up(){m_up=true;}
    void move_dn(){m_dn=true;}

    void stop_rt(){m_rt=false;}
    void stop_lt(){m_lt=false;}
    void stop_up(){m_up=false;}
    void stop_dn(){m_dn=false;}
    void faceDown() {
        /*
        the way i drew the person/weapon sprite, they're facing down. Thus, "down" is angle 0, and we go clockwise from there.
        */
        blc.get_tex().setRotation(0);
    }
    void faceUp() {
        blc.get_tex().setRotation(180);
    }
    void faceLeft() {
        blc.get_tex().setRotation(90);
    }
    void faceRight() {
        blc.get_tex().setRotation(270);
    }
    void setPos(sf::Vector2f pos){blc.set_pos(pos);}
    sf::Sprite getWep(){return blc.get_tex();}
    void update( sf::Vector2f pos ,sf::Vector2i mse_pos){

if(m_up)
    blc.set_pos(pos - sf::Vector2f(0.f,10.f));
if(m_dn)
    blc.set_pos(pos + sf::Vector2f(0.f,10.f));
if(m_rt)
    blc.set_pos(pos + sf::Vector2f(10.f,0.f));
if(m_lt)
    blc.set_pos(pos - sf::Vector2f(10.f,0.f));

/*
I'm not sure of the maths required to make the sprite face where the mouse is pointing. I think what you have here is really close, but I'm not really able to work out the solution right now
*/
//float angle=(atan2(mse_pos.y-m_res.y/2,mse_pos.x-m_res.x/2))*180/3.14f;


}



};

class Player{
    Block blc;
    weapon Weapon;
    sf::Vector2f m_res;
     sf::Vector2i pos1; //player position

    bool m_up;
    bool m_dn;
    bool m_lt;
    bool m_rt;

    float m_speed;
    sf::Time last_hit;

public:
    Player():blc(0,0,64,0),pos1(0,0){

    }

    void spawn(sf::Vector2f res,sf::Vector2f loc){
        blc.set_pos(loc);
        pos1.x=loc.x; //set position.
        this->pos1.y=loc.y;
        Weapon.setPos(sf::Vector2f(loc.x+5.0f,loc.y+5.0));
       blc.get_tex().setOrigin(16, 16);


    m_res.x=res.x;
    m_res.y=res.y;
    /*
    most of the changes I made up in weapon I copied down here. We also want to start the player out facing the "right" way.
    This is more useful if you draw them facing one direction, and want them to start the game pointing in another direction.
    */
    faceDown();

    }
    weapon& getWep(){return Weapon;}
    bool hit(sf::Time time_hit);
    sf::FloatRect get_pos(){return blc.get_tex().getGlobalBounds();}
    sf::Vector2f get_cen(){return blc.get_pos();}
    float get_rot(){return blc.get_tex().getRotation();}
    sf::Sprite get_pla(){return blc.get_tex();}

    void move_rt(){m_rt=true;}
    void move_lt(){m_lt=true;}
    void move_up(){m_up=true;}
    void move_dn(){m_dn=true;}
    sf::Vector2i get_map_pos(){return pos1;}
    void stop_rt(){m_rt=false;}
    void stop_lt(){m_lt=false;}
    void stop_up(){m_up=false;}
    void stop_dn(){m_dn=false;}
    void faceDown() {
        blc.get_tex().setRotation(0);
        /*
        instead of calling faceDown()/etc for the player AND the weapon when we move the player, we can just call the function for the weapon here, and it'll automatically happen no matter what
        really useful if we want other things to change what direction the player is facing
        you can do the same type of thing in the update functions, to keep the player and weapon connected to each other easier
        */
        Weapon.faceDown();
    }
    void faceUp() {
        blc.get_tex().setRotation(180);
        Weapon.faceDown();
    }
    void faceLeft() {
        blc.get_tex().setRotation(90);
        Weapon.faceLeft();
    }
    void faceRight() {
        blc.get_tex().setRotation(270);
        Weapon.faceRight();
    }

void update( sf::Vector2f pos ,sf::Vector2i mse_pos){

if(m_up){
        pos1.y+=1; // update player position.
   blc.set_pos(pos - sf::Vector2f(0.f,10.f));}
if(m_dn)
    blc.set_pos(pos + sf::Vector2f(0.f,10.f));
if(m_rt)
    blc.set_pos(pos + sf::Vector2f(10.f,0.f));
if(m_lt)
    blc.set_pos(pos - sf::Vector2f(10.f,0.f));



//float angle=(atan2(mse_pos.y-m_res.y/2,mse_pos.x-m_res.x/2))*180/3.14f;

//blc.get_tex().setRotation(angle);
}


};


int main()
{
        /*
        instead of loading the texture a bunch of times for each sprite we want to draw, we load it once here.
        it takes time to load a texture, so ideally, we want to do it once, then just refer back to that texture when creating a new sprite.
        once you need more than a few textures, you can put them in a resource management class that has a std::vector or std::map, and access them through those data structures.
        for now, a couple of global variables are fine.
        */
        tex.loadFromFile("1.png");
    //State s=State::PAUSE;
    sf::Vector2f res;
    /*
    i made the window a bit smaller than the full screen resolution, just for testing things out
    */
    res.x = 800;
    res.y = 600;
    //res.x=sf::VideoMode::getDesktopMode().width;
    //res.y=sf::VideoMode::getDesktopMode().height;
    sf::RenderWindow win(sf::VideoMode(res.x,res.y),"RPG");
    //sf::RenderWindow win1(sf::VideoMode(res.x,res.y),"RPG");
    sf::View mainView;
    mainView.reset(sf::FloatRect(0,0,res.x,res.y));
    mainView.setViewport(sf::FloatRect(0,0,1.0f,1.0f));
    sf::Clock clock;
    sf::Time gameTotal;
    sf::Vector2f mouseWPos;
    sf::Vector2i mouseSPos;


    World w;
Player pla;
weapon wep;
sf::Vector2i pos1=pla.get_map_pos();
pla.spawn(res,sf::Vector2f(2.0f,2.0f));
      while(win.isOpen()){
            sf::Vector2i pos1=pla.get_map_pos();

            sf::Event eve;
            while(win.pollEvent(eve)){

                if(true){
                  if(sf::Keyboard::isKeyPressed(sf::Keyboard::W)){
                        //if(w.get_pos(pos1.x,pos1.y+1)==1)

                  pla.move_up();
                  pla.getWep().move_up();
                  pla.faceUp();
                  }
                else{
                    pla.stop_up();
                    pla.getWep().stop_up();}
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::S)){
                   pla.move_dn();
                   pla.getWep().move_dn();
                   pla.faceDown();
                   }
                else{
                    pla.stop_dn();
                    pla.getWep().stop_dn();}
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::A)){
                     pla.move_lt();
                     pla.getWep().move_lt();
                   pla.faceLeft();
                     }
                else{
                    pla.stop_lt();
                    pla.getWep().stop_lt();}
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::D)){
                    pla.move_rt();
                    pla.getWep().move_rt();
                   pla.faceRight();
                    }
                else{
                    pla.stop_rt();
                    pla.getWep().stop_rt();}

                    }
                    /*
                    exits the game when the escape key is pressed.
                    */
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)){
                win.close();}



                    sf::Vector2f plaPos(pla.get_cen());
                    pla.update(plaPos,sf::Mouse::getPosition());
                    pla.getWep().update(plaPos,sf::Mouse::getPosition());
            }

                    clock.restart();


            win.clear(sf::Color::Black);
            /*
            draw the map, then weapon, then player.
            */
            w.draw(&win);
            win.draw(pla.getWep().getWep());
            win.draw(pla.get_pla());
            win.setView(mainView);


            win.display();


        }
    //cout << "Hello world!" << endl;
    return 0;
}