sf::RenderWindow draw() not updating sf::Sprite move() (Player movement).

[Snizzlenose]

I'm trying to separate my code into different threads, using C++11 <thread>, namely player movement to make it consistent and not dependent on the speed of  the game loop. 
The game builds and runs in debug mode (VS2013) but the problem I'm facing is that my player sprite's position, a red rectangle, is not being updated on my window despite it's position is getting registered back-end, printing my test outputs in the console, and interacting with my collision function. 
The movement works when I put world.player.movement in the game loop (note: not world.movement). 
Any ideas why it doesn't work and suggestions to fix it?

Github link: https://github.com/Snizzlenose/2D-SFML-shooter 

main.cpp

(click to show/hide)

#include <SFML/Graphics.hpp>
#include <SFML/OpenGL.hpp>
#include "World.h"
#include <iostream>
#include <thread>

extern const float WINDOW_WIDTH = 1280;
extern const float WINDOW_HEIGHT = 720;

template<class T, class Y> bool collision( const T& movingObject, const Y& stillObject )
{
        for( int y = stillObject.getPosition( ).y; y <= 720; y++ )
        {
                for( int x = stillObject.getPosition( ).x; x <= 1280; x++ )
                {
                        if( movingObject.getPosition( ).x > x &&
                                movingObject.getPosition( ).y + 18 > y )
                        {
                                return true;
                        }
                }
        }

        return false;
}
void physics( ) // Temporary
{
        sf::Time interval = sf::milliseconds( 100 );

        /* Gravity */
        while( true )
        {
                std::cout << "Gravity is in progress\n";
               
                sf::sleep( interval );
        }
}

int main( )
{
        sf::RenderWindow window( sf::VideoMode( WINDOW_WIDTH, WINDOW_HEIGHT ), "2D-SFML-shooter" );
        World world;

        std::thread thread_1( &World::movement, world );
        thread_1.detach( );
        std::thread thread_2( physics ); // Refactor to class World
        thread_2.detach( );

        while( window.isOpen( ) )
        {
                /* Collision detection */
                if( collision( world.player.sprite, world.ground.rectangleShape ) == true ) // Might not work
                {
                        std::cout << "Collision detected!\n";

                        if( world.player.sprite.getPosition( ).y + 18 > world.ground.rectangleShape.getPosition( ).y )
                        {
                                world.player.sprite.setPosition( world.player.sprite.getPosition( ).x, world.ground.rectangleShape.getPosition( ).y - 18 );
                                std::cout << "Teleported above ground\n";
                        }

                }

                sf::Event event;
                while( window.pollEvent( event ) )
                {
                        if( event.type == sf::Event::Closed )
                        {
                                window.close( );
                        }

                        if( world.player.get_shootingState( ) == false &&
                                event.type == sf::Event::MouseButtonPressed )
                        {
                                world.player.startShooting( sf::Mouse::getPosition( window ).x, sf::Mouse::getPosition( window ).y );
                        }

                        if( event.type == sf::Event::MouseButtonReleased )
                        {
                                world.player.stopShooting( );
                        }

                        if( event.type == sf::Event::KeyPressed &&
                                event.key.code == sf::Keyboard::LControl )
                        {
                                world.player.dash( );
                        }
                }

                window.clear( sf::Color::Black );

                window.draw( world.player.sprite );
                window.draw( world.player.projectile );
                window.draw( world.ground.rectangleShape );

                window.display( );
        }

        return 0;
}
 

World.h 

(click to show/hide)

#include <SFML/Graphics.hpp>
#include "Player.h"
#include "Ground.h"

class World
{
        public:
                Player player;
                Ground ground;
                void movement( );
                void collision( );

        private:

};
 

World.cpp 

(click to show/hide)

#include <SFML/Graphics.hpp>
#include "World.h"
#include "Player.h"
#include "Ground.h"

void World::movement( )
{
        sf::Time interval = sf::milliseconds( 1 );

        while( true )
        {
                player.movement( );

                sf::sleep( interval );
        }
}
 

Player.h 

(click to show/hide)

#pragma once

#include <SFML/Graphics.hpp>

class Player
{
        public:
                Player( );
                sf::Sprite sprite;
                sf::Texture texture;
                sf::VertexArray projectile;
                void movement( );
                void dash( );
                void startShooting( int mouse_x, int mouse_y );
                void stopShooting( );
                bool get_shootingState( );

        private:
                bool movePlayerUp = false;
                bool movePlayerDown = false;
                bool movePlayerLeft = false;
                bool movePlayerRight = false;
                bool movePlayerJump = false;
                bool shooting = false;
                int spriteWidth = 15;
                int spriteLength = 35;
};
 

Player.cpp 

(click to show/hide)

#include <SFML/Graphics.hpp>
#include "Player.h"
#include <iostream>

extern const float WINDOW_WIDTH;
extern const float WINDOW_HEIGHT;

Player::Player( )
{
        if( !texture.loadFromFile( ( "whitebackground1920x1200.jpg" ), sf::IntRect( 0, 0, spriteWidth, spriteLength ) ) )
        {
                std::cout << "Texture error\n";
        }
        sprite.setTexture( texture );
        sprite.setColor( sf::Color::Red );
        sprite.setOrigin( 8, 18 );
        sprite.setPosition( WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2 );


        projectile.setPrimitiveType( sf::Lines );
        sf::Vertex tempVertex;
        projectile.append( tempVertex );
        projectile.append( tempVertex );
        projectile[0].color = sf::Color::Yellow;
        projectile[1].color = sf::Color::Yellow;
}

void Player::movement( )
{
        /* Start player movement */
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::W ) )
        {
                movePlayerUp = true;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::S ) )
        {
                movePlayerDown = true;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::A ) )
        {
                movePlayerLeft = true;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::D ) )
        {
                movePlayerRight = true;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::Space ) )
        {
                movePlayerJump = true;
        }

        /* Stop player movement */
        if( !sf::Keyboard::isKeyPressed( sf::Keyboard::W ) )
        {
                movePlayerUp = false;
        }
        if( !sf::Keyboard::isKeyPressed( sf::Keyboard::S ) )
        {
                movePlayerDown = false;
        }
        if( !sf::Keyboard::isKeyPressed( sf::Keyboard::A ) )
        {
                movePlayerLeft = false;
        }
        if( !sf::Keyboard::isKeyPressed( sf::Keyboard::D ) )
        {
                movePlayerRight = false;
        }
        if( !sf::Keyboard::isKeyPressed( sf::Keyboard::Space ) )
        {
                movePlayerJump = false;
        }

        /* Define player movement */
        if( movePlayerUp == true )
        {
                sprite.move( 0, -1.0f );
                std::cout << "Move up\n";
        }
        if( movePlayerDown == true )
        {
                sprite.move( 0, 1.0f );
                std::cout << "Move down\n";
        }
        if( movePlayerLeft == true )
        {
                sprite.move( -1.0f, 0 );
                std::cout << "Move left\n";
        }
        if( movePlayerRight == true )
        {
                sprite.move( 1.0f, 0 );
                std::cout << "Move right\n";
        }
        if( movePlayerJump == true )
        {
                std::cout << "Jump\n";
        }

        /* Teleport player if out of bounds */
        if( sprite.getPosition( ).y < 0 )
        {
                sprite.setPosition( sprite.getPosition( ).x, 0 );
                std::cout << "Teleport down\n";
        }
        if( sprite.getPosition( ).y > WINDOW_HEIGHT )
        {
                sprite.setPosition( sprite.getPosition( ).x, (float)WINDOW_HEIGHT );
                std::cout << "Teleport up\n";
        }
        if( sprite.getPosition( ).x < 0 )
        {
                sprite.setPosition( 0, sprite.getPosition( ).y );
                std::cout << "Teleport right\n";
        }
        if( sprite.getPosition( ).x > WINDOW_WIDTH )
        {
                sprite.setPosition( (float)WINDOW_WIDTH, sprite.getPosition( ).y );
                std::cout << "Teleport left\n";
        }
}

void Player::dash( )
{
        /* Dash player in a direction based on which keys are held down (Note: boolean AND) */
        sprite.move( 0, -50.0f * movePlayerUp );
        sprite.move( 0, 50.0f * movePlayerDown );
        sprite.move( -50.0f * movePlayerLeft, 0 );
        sprite.move( 50.0f * movePlayerRight, 0 );
        std::cout << "Dash\n";
}

void Player::startShooting( int mouse_x, int mouse_y )
{
        projectile[0].position = sf::Vector2f( sprite.getPosition( ).x, sprite.getPosition( ).y );
        projectile[1].position = sf::Vector2f( mouse_x, mouse_y );
        shooting = true;
        std::cout << "Shoot\n";
}

void Player::stopShooting( )
{
        projectile[0].position = sf::Vector2f( 9999, 9999 );
        projectile[1].position = sf::Vector2f( 9999, 9999 );
        shooting = false;
}

bool Player::get_shootingState( )
{
        return shooting;
}
 

Ground.h 

(click to show/hide)

#pragma once

#include <SFML/Graphics.hpp>
#include <SFML/OpenGL.hpp>

class Ground
{
        public:
                Ground( );
                sf::RectangleShape rectangleShape;

        private:

};
 

Ground.cpp 

(click to show/hide)

#include <SFML/Graphics.hpp>
#include <SFML/OpenGL.hpp>
#include "Ground.h"

Ground::Ground( )
{
        rectangleShape.setSize( sf::Vector2f( 1280, 20 ) );
        rectangleShape.setFillColor( sf::Color::Green );
        rectangleShape.setPosition( 0, 700 );
}
 

[eXpl0it3r]

I'm trying to separate my code into different threads, using C++11 <thread>, namely player movement to make it consistent and not dependent on the speed of  the game loop.

Don't.

You may think it's a good idea and may think it will make things "independent", but truth is, it will make everything a lot more complicated and it won't even be independent.
Multi-threading is an advanced topic and needs a lot of knowledge on synchronization and parallel programming in general. Additionally you need to have all the object's logic updated before rendering a frame, thus making the whole parallel part totally useless.

There are a lot of threads on the forum talking about if you're interested.

[Snizzlenose]

I'm trying to separate my code into different threads, using C++11 <thread>, namely player movement to make it consistent and not dependent on the speed of  the game loop.

Don't.

You may think it's a good idea and may think it will make things "independent", but truth is, it will make everything a lot more complicated and it won't even be independent.
Multi-threading is an advanced topic and needs a lot of knowledge on synchronization and parallel programming in general. Additionally you need to have all the object's logic updated before rendering a frame, thus making the whole parallel part totally useless.

There are a lot of threads on the forum talking about if you're interested.

Oh okay, I figured threads was a set and forget kind of thing, but if they need a lot more work, they're unneeded for a simple game like mine. 
Should I worry about player movement being inconsistent as more computation is required in the main gameloop, as I'm essentially teleporting the sprite every loop individual loop?

[zsbzsb]

You should read the following links.

http://gafferongames.com/game-physics/fix-your-timestep/
http://www.koonsolo.com/news/dewitters-gameloop/