SFML Question

#include <SFML\Graphics.hpp>
#include <sstream>
#include <string>
#include <list>
using namespace std;

sf::Sprite        pPaddleL;
sf::Sprite        pPaddleR;
sf::Sprite        pBall;
sf::Sprite        pParticle;
sf::Texture       pPaddle;
sf::Texture       pBallText;
sf::Clock         pClock;
sf::Clock         pMessage;
sf::Font          pFont;
sf::Text          pPText;
sf::Text          pGame;
sf::Text          pMess;
sf::Text          pPETS;
sf::Text          pPaused;
stringstream      pSs;

sf::Keyboard::Key   HOTKEY_EXIT;
sf::Keyboard::Key   HOTKEY_UP;
sf::Keyboard::Key   HOTKEY_DOWN;
sf::Keyboard::Key   HOTKEY_START;
sf::Keyboard::Key   HOTKEY_PAUSE;
sf::Mouse::Button   HOTKEY_START_ALT;

void setHotkeys();
void render(sf::RenderWindow *pRenderWindow);
void loadTextures(sf::RenderWindow *pRenderWindow);
void update(sf::RenderWindow *pRenderWindow);
void userControl();
void getFrameTime();
void botControl();
void controlCenter(sf::RenderWindow *pRenderWindow);
void ballControl(sf::RenderWindow *pRenderWindow);
void collisions();
void paddleLHit();
void paddleRHit();
void gameLost(sf::RenderWindow *pRenderWindow);
void textManagement();
void spawnParticles(int amount);
void displayRoundEndingMessage(bool won);
void updateHighscore();
void respawnBall(sf::RenderWindow *pRenderWindow);
void restorePaddles();
void pressEnterToStart(sf::RenderWindow *pRenderWindow);
void paused(sf::RenderWindow *pRenderWindow);

float            frametime;
int speed        = 500;
int defaultSpeed = speed;
bool x           = true;
bool y           = true;
int tilt         = 7;
int points       = 0;
bool pauseGame   = false;
int highscore = 0;
bool isRespawning = false;
bool isOn         = false;
bool canClickP    = true;

struct Spielstand
{
    int spieler;
    int bot;
};

Spielstand neuesSpiel;

class Particle
{
public:
    Particle(int x, int y, float scale, int lifetime);
    void render(sf::RenderWindow *rw);
    void update(float frametime);
    bool isAlive;
private:
    sf::Sprite pParticle;
    sf::Clock  pClock;
    bool upOrDown;
    int movementDown;
    int movementSide;
    int leftOrRight;
    int speed;
    int lifetime;
};

class PartMan
{
public:
    PartMan();
    void insert(Particle *particle);
    void render(sf::RenderWindow *rw);
    void update(float frametime);

    list<Particle*> mList;
    list<Particle*> *getList() {return &mList;};

private:
};

Particle::Particle(int x, int y, float scale, int lft)
{
    pParticle.setTexture(pBallText);
    pParticle.setPosition(x, y);
    if(rand()%2+1 == 1)
    {
        speed = (rand()%2+1)*1;
    }
    else
    {
        speed = (rand()%2+1)*-1;
    }
    movementDown = (rand()%150+75)*speed;
    movementSide = ((rand()%190+10)-100)*speed;
    pParticle.setScale(scale, scale);
    lifetime = lft;

    return;
}

void Particle::update(float frametime)
{
    pParticle.move(((movementSide*frametime)*2)*2, ((movementDown*frametime)*1)*2);

    if(pClock.getElapsedTime().asMilliseconds() >= lifetime)
    {
        isAlive = false;
    }
    return;
}

PartMan::PartMan()
{
    return;
}

void Particle::render(sf::RenderWindow *rw)
{
    rw->draw(pParticle);
    return;
}

void PartMan::insert(Particle *particle)
{
    mList.push_back(particle);
    return;
}

void PartMan::render(sf::RenderWindow *rw)
{
    for(auto it : mList)
    {
        it->render(rw);
    }
    return;
}

void PartMan::update(float frametime)
{
    for(auto it : mList)
    {
        it->update(frametime);
    }

    for(auto it = mList.cbegin(); it != mList.cend();)
    {
        if((*it)->isAlive == false)
        {
            it = mList.erase(it);
        }
        else
        {
            it++;
        }
    }

    return;
}

PartMan pm;

void pressEnterToStart(sf::RenderWindow *pRenderWindow)
{
    while(!sf::Keyboard::isKeyPressed(HOTKEY_START))
    {
        pRenderWindow->clear();

        pRenderWindow->draw(pPETS);

        pRenderWindow->display();

        if(sf::Keyboard::isKeyPressed(HOTKEY_EXIT))
        {
            pRenderWindow->close();
            exit(0);
        }
    }
    return;
}

void setHotkeys()
{
    HOTKEY_EXIT      = sf::Keyboard::Key::Escape;
    HOTKEY_UP        = sf::Keyboard::Key::Up;
    HOTKEY_DOWN      = sf::Keyboard::Key::Down;
    HOTKEY_START     = sf::Keyboard::Key::Return;
    HOTKEY_START_ALT = sf::Mouse::Button::Left;
    HOTKEY_PAUSE     = sf::Keyboard::Key::P;

    return;
}

void loadTextures(sf::RenderWindow *pRenderWindow)
{
    pPaddle.loadFromFile("paddle.png");
    pBallText.loadFromFile("ball.png");
    pPaddleL.setTexture(pPaddle);
    pPaddleR.setTexture(pPaddle);
    pBall.setTexture(pBallText);

    pPaddleL.setOrigin(0,pPaddle.getSize().y/2);
    pPaddleR.setOrigin(pPaddle.getSize().x,pPaddle.getSize().y/2);
    pBall.setOrigin(pBallText.getSize().x/2,pBallText.getSize().y/2);

    pBall.setPosition(pRenderWindow->getSize().x/2,pRenderWindow->getSize().y/2);
    pPaddleL.setPosition(0, 300);
    pPaddleR.setPosition(800, 300);

    pFont.loadFromFile("AllerDisplay.ttf");
    pPText.setFont(pFont);
    pPText.setPosition(350, 5);
    pGame.setFont(pFont);
    pGame.setPosition(375, 30);
    pMess.setFont(pFont);
    pMess.setScale(3, 3);
    pMess.setPosition(25, 150);
    pPETS.setFont(pFont);
    pPETS.setScale(3.5, 3.5);
    pPETS.setString(" Bitte drücke\n      [ENTER]\num zu starten!");
    pPETS.setPosition(60, 100);
    pPaused.setFont(pFont);
    pPaused.setString("       Spiel Pausiert!\n        \"P\" drücken\n um weiter zu spielen!");
    pPaused.setScale(2, 2);
    pPaused.setPosition(100, 100);

    return;
}

int main(char t_char[], int args)
{
    sf::RenderWindow  pRenderWindow;
    setHotkeys();
    loadTextures(&pRenderWindow);
    pRenderWindow.create(sf::VideoMode(800, 600, 32), "Pong", sf::Style::Titlebar);
    pRenderWindow.setFramerateLimit(60);

    pressEnterToStart(&pRenderWindow);
    pClock.restart();

    while(!sf::Keyboard::isKeyPressed(HOTKEY_EXIT))
    {
        getFrameTime();
        if(pauseGame == true)
        {
            frametime = 0;
        }
        update(&pRenderWindow);
        render(&pRenderWindow);
    }

    return 0;
}

void restorePaddles()
{
    pPaddleL.setPosition(0, 300);
    pPaddleR.setPosition(800, 300);

    return;
}

void update(sf::RenderWindow *pRenderWindow)
{
    pm.update(frametime);
    controlCenter(pRenderWindow);
    textManagement();
    updateHighscore();
    respawnBall(pRenderWindow);

    if(sf::Keyboard::isKeyPressed(HOTKEY_PAUSE) && canClickP == true)
    {
        paused(pRenderWindow);
        canClickP = false;;
    }
    if(!sf::Keyboard::isKeyPressed(HOTKEY_PAUSE))
    {
        canClickP = true;
    }

    return;
}

void paused(sf::RenderWindow *pRenderWindow)
{
    pRenderWindow->draw(pPaused);
    pRenderWindow->display();

    while(sf::Keyboard::isKeyPressed(HOTKEY_PAUSE))
    {

    }

    while(!sf::Keyboard::isKeyPressed(HOTKEY_PAUSE))
    {
        if(sf::Keyboard::isKeyPressed(HOTKEY_EXIT))
        {
            pRenderWindow->close();
            exit(0);
        }
    }

    pClock.restart();
    frametime = 0;

    return;
}

void updateHighscore()
{
    if(points >= highscore)
    {
        highscore = points;
    }

    return;
}

void textManagement()
{
    pSs.str("");
    pSs<<points<<" Beste: "<<highscore;
    pPText.setString(pSs.str());

    pSs.str("");
    pSs<<neuesSpiel.spieler<<" : "<<neuesSpiel.bot;
    pGame.setString(pSs.str());

    return;
}

void controlCenter(sf::RenderWindow *pRenderWindow)
{
    userControl();
    botControl();
    ballControl(pRenderWindow);
    collisions();

    return;
}

void userControl()
{
    if(isRespawning == false)
    {
        if(pPaddleL.getPosition().y <= 600-(pPaddle.getSize().y/2))
        {
            if(sf::Keyboard::isKeyPressed(HOTKEY_DOWN))
            {
                pPaddleL.move(0, +speed*frametime);
            }
        }

        if(pPaddleL.getPosition().y >= 0+(pPaddle.getSize().y/2))
        {
            if(sf::Keyboard::isKeyPressed(HOTKEY_UP))
            {
                pPaddleL.move(0, -speed*frametime);
            }
        }
    }

    return;
}

void botControl()
{
    if(isRespawning == false)
    {
        if(pBall.getPosition().y <= 600-(pPaddle.getSize().y/2))
        {
            if(pBall.getPosition().y >= 0+(pPaddle.getSize().y/2))
            {
                pPaddleR.setPosition(pPaddleR.getPosition().x, pBall.getPosition().y);
            }
        }
    }

    return;
}

void displayRoundEndingMessage(bool won)
{
    pauseGame = true;
    if(won == false)
    {
        pMess.setString("Du hast verloren!");
    }
    if(won == true)
    {
        pMess.setString("Du hast gewonnen!");
    }
    pMessage.restart();

    return;
}

void ballControl(sf::RenderWindow *pRenderWindow)
{
    if(isRespawning == false)
    {
        if(x == true)
        {
            if(y == true)
            {
                pBall.move((speed*frametime)*1, ((speed/tilt)*frametime)*1);
            }

            if(y == false)
            {
                pBall.move((speed*frametime)*1, ((speed/tilt)*frametime)*-1);
            }
        }
        if(x == false)
        {
            if(y == true)
            {
                pBall.move((speed*frametime)*-1, ((speed/tilt)*frametime)*1);
            }

            if(y == false)
            {
                pBall.move((speed*frametime)*-1, ((speed/tilt)*frametime)*-1);
            }
        }


        if(pBall.getPosition().x <= 000)
        {
            gameLost(pRenderWindow);
            neuesSpiel.bot++;
            displayRoundEndingMessage(false);
        }
        if(pBall.getPosition().x >= 800)
        {
            gameLost(pRenderWindow);
            neuesSpiel.spieler++;
            displayRoundEndingMessage(true);
        }
        if(pBall.getPosition().y >= 600)
        {
            y=!y;
            spawnParticles(200);
        }
        if(pBall.getPosition().y <= 000)
        {
            y=!y;
            if(isRespawning == false)
            {
                spawnParticles(200);
                }
        }
    }

    return;
}

void gameLost(sf::RenderWindow *pRenderWindow)
{
    restorePaddles();
    speed = defaultSpeed;
    pBall.setPosition(pRenderWindow->getSize().x/2, -50);
    isRespawning = true;
    points = 0;
    x=!x;

    return;
}

void respawnBall(sf::RenderWindow *pRenderWindow)
{
    if(isRespawning == true)
    {
        if(pBall.getPosition().y <= pRenderWindow->getSize().y/2)
        {
            pBall.move(0, 300*frametime);
        }
        else
        {
            isRespawning = false;
        }
    }

    return;
}

void spawnParticles(int amount)
{
    int c = 0;
    while(c <= amount)
    {
        Particle *part = new Particle(pBall.getPosition().x, pBall.getPosition().y, 0.75, rand()%1000+500);
        pm.insert(part);
        c++;
    }
    return;
}

void collisions()
{
    if(pBall.getGlobalBounds().intersects(pPaddleL.getGlobalBounds()))
    {
        paddleLHit();
    }
    if(pBall.getGlobalBounds().intersects(pPaddleR.getGlobalBounds()))
    {
        paddleRHit();
    }

    return;
}

void paddleLHit()
{
    spawnParticles(200);
    speed = speed + 25;
    points++;
    x=!x;
    return;
}

void paddleRHit()
{
    spawnParticles(200);
    speed = speed + 25;
    x=!x;
    return;
}

void render(sf::RenderWindow *pRenderWindow)
{
    pRenderWindow->clear();

    pm.render(pRenderWindow);
    pRenderWindow->draw(pPaddleL);
    pRenderWindow->draw(pPaddleR);
    pRenderWindow->draw(pBall);
    pRenderWindow->draw(pPText);
    pRenderWindow->draw(pGame);
    if(pMessage.getElapsedTime().asMilliseconds() <= 500)
    {
        pRenderWindow->draw(pMess);
    }
    else
    {
        pauseGame = false;
    }

    pRenderWindow->display();

    return;
}

void getFrameTime()
{
    frametime = pClock.getElapsedTime().asSeconds();
    pClock.restart();

    return;
}