spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

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

const int ScreenWidth = 800;
const int ScreenHeight = 600;
const float PlayerSpeed = 300.f;
const float AISpeed = 250.f;
const float BallSpeed = 475.f;
const float BallRadius = 8.f;
const float PI = 3.14159f;
const sf::Vector2f PaddleSize(22.f, 100.f);
const sf::Time TimePerFrame = sf::seconds(1.f / 60.f);

void processEvents(sf::RenderWindow* window);
void updatePlayer(sf::RectangleShape* player, const sf::Time& elapsed);
void updateAI(sf::RectangleShape* ai, const sf::CircleShape& ball, const sf::Time& elapsed);
bool updateBall(const sf::RectangleShape& player, const sf::RectangleShape& ai, sf::CircleShape* ball, const sf::Time& elapsed, sf::Sound* ballSound, float* ballAngle, sf::Text* score);
void render(sf::RenderWindow* window, const sf::RectangleShape& player, const sf::RectangleShape& ai, const sf::CircleShape& ball, const sf::Text& score);

int main()
{
    std::srand(static_cast<unsigned int>(std::time(NULL)));

    sf::RenderWindow window(sf::VideoMode(ScreenWidth, ScreenHeight), "Pong", sf::Style::Close);
    window.setVerticalSyncEnabled(true);
    window.setMouseCursorVisible(false);

    sf::RectangleShape player;
    player.setSize(PaddleSize);
    player.setFillColor(sf::Color::Cyan);
    player.setOutlineThickness(-2.f);
    player.setOutlineColor(sf::Color::Black);       
    player.setOrigin(PaddleSize / 2.f);

    sf::RectangleShape ai;
    ai.setSize(PaddleSize);
    ai.setFillColor(sf::Color(153, 0, 76));
    ai.setOutlineThickness(-2.f);
    ai.setOutlineColor(sf::Color::Black);
    ai.setOrigin(PaddleSize / 2.f);

    sf::CircleShape ball;
    ball.setRadius(BallRadius);
    ball.setFillColor(sf::Color::White);
    ball.setOutlineThickness(-2.f);
    ball.setOutlineColor(sf::Color::Black);
    ball.setOrigin(BallRadius / 2.f, BallRadius / 2.f);
    float ballAngle = 0.f;

    sf::SoundBuffer ballSoundBuffer;
    if (!ballSoundBuffer.loadFromFile("media/ball.wav"))
        return 1;
    sf::Sound ballSound(ballSoundBuffer);

    sf::Font font;
    if (!font.loadFromFile("media/sansation.ttf"))
        return 1;

    sf::Text score;
    score.setFont(font);
    score.setCharacterSize(50);
    score.setStyle(sf::Text::Bold);
    score.setPosition(ScreenWidth / 2 - 70.f, 25.f);        // string mitte ermitteln?
    score.setString("0 : 0");
    
    sf::Clock clock;
    sf::Time timeSinceLastUpdate = sf::Time::Zero;
    bool isPlaying = false;
    while (window.isOpen())
    {
        if (!isPlaying)
        {
            isPlaying = true;

            // Reset position of player, AI and ball
            player.setPosition(8.f + PaddleSize.x / 2.f, ScreenHeight / 2);
            ai.setPosition(ScreenWidth - 8.f - PaddleSize.x / 2.f, ScreenHeight / 2);
            ball.setPosition(ScreenWidth / 2, ScreenHeight / 2);

            // Reset ball angle
            do 
            {
                ballAngle = (std::rand() % 360) * 2 * PI / 360;

            } while (std::abs(std::cos(ballAngle)) < 0.7f);
        }

        sf::Time elapsed = clock.restart();
        timeSinceLastUpdate += elapsed;
        while (timeSinceLastUpdate > TimePerFrame)
        {
            timeSinceLastUpdate -= TimePerFrame;

            processEvents(&window);
            updatePlayer(&player, elapsed);
            updateAI(&ai, ball, elapsed);
            isPlaying = updateBall(player, ai, &ball, elapsed, &ballSound, &ballAngle, &score);
        }
        
        render(&window, player, ai, ball, score);
    }
    
    return 0;
}

void processEvents(sf::RenderWindow* window)
{
    sf::Event event;
    while (window->pollEvent(event))
    {
        switch (event.type)
        {
        case sf::Event::Closed:
            window->close();
            break;
        case sf::Event::KeyPressed: 
            if (event.key.code == sf::Keyboard::Escape)
                window->close();
            break;
        }
    }
}

void updatePlayer(sf::RectangleShape* player, const sf::Time& elapsed)
{
    sf::Vector2f movement(0.f, 0.f);
    sf::Vector2f position = player->getPosition();

    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) && position.y > PaddleSize.y / 2.f)
    {
        movement.y -= PlayerSpeed;
    }
    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down) && position.y < ScreenHeight - PaddleSize.y / 2.f)
    {
        movement.y += PlayerSpeed;
    }
    
    player->move(movement * elapsed.asSeconds());
}

void updateAI(sf::RectangleShape* ai, const sf::CircleShape& ball, const sf::Time& elapsed)
{
    sf::Vector2f movement(0.f, 0.f);
    sf::Vector2f positionBall = ball.getPosition();
    sf::Vector2f positionAI = ai->getPosition();

    if (positionBall.y < positionAI.y - 10.f && positionAI.y > PaddleSize.y / 2.f)
    {
        movement.y -= AISpeed;
    }
    else if (positionBall.y > positionAI.y + 10.f && positionAI.y < ScreenHeight - PaddleSize.y / 2.f)
    {
        movement.y += AISpeed; 
    }
    else 
    {
        movement.y = 0.f;
    }

    ai->move(movement * elapsed.asSeconds());
}

bool updateBall(const sf::RectangleShape& player, const sf::RectangleShape& ai, sf::CircleShape* ball, const sf::Time& elapsed, sf::Sound* ballSound, float* ballAngle, sf::Text* score)
{
    bool isPlaying = true;
    static unsigned int scoreAI = 0;
    static unsigned int scorePlayer = 0;

    // Move the ball
    float factor = BallSpeed * elapsed.asSeconds();
    ball->move(std::cos(*ballAngle) * factor, std::sin(*ballAngle) * factor);

    // Check collision between ball and screen
    sf::Vector2f positionBall = ball->getPosition();

    if (positionBall.x - BallRadius < 0.f)
    {
        isPlaying = false;
        scoreAI++;
        score->setString(std::to_string(scorePlayer) + " : " + std::to_string(scoreAI));
    }
    if (positionBall.x + BallRadius > ScreenWidth)
    {
        isPlaying = false;
        scorePlayer++;
        score->setString(std::to_string(scorePlayer) + " : " + std::to_string(scoreAI));
    }
    if (positionBall.y - BallRadius < 0.f)
    {
        ballSound->play();
        *ballAngle = -*ballAngle;
    }
    if (positionBall.y + BallRadius > ScreenHeight)
    {
        ballSound->play();
        *ballAngle = -*ballAngle;
    }

    sf::FloatRect ballBounds = ball->getGlobalBounds();
    sf::FloatRect playerBounds = player.getGlobalBounds();
    sf::FloatRect aiBounds = ai.getGlobalBounds();
    
    // Check colission between ball and player
    if (ballBounds.intersects(playerBounds))
    {
        if (ball->getPosition().y > player.getPosition().y)
            *ballAngle = PI - *ballAngle + (std::rand() % 20) * PI / 180;
        else
            *ballAngle = PI - *ballAngle - (std::rand() % 20) * PI / 180;

        ballSound->play();
        ball->setPosition(player.getPosition().x + BallRadius + PaddleSize.x / 2 + 0.1f, ball->getPosition().y);
    }

    // Check colission between ball and AI
    if (ballBounds.intersects(aiBounds))
    {
        if (ball->getPosition().y > ai.getPosition().y)
            *ballAngle = PI - *ballAngle + (std::rand() % 20) * PI / 180;
        else
            *ballAngle = PI - *ballAngle - (std::rand() % 20) * PI / 180;

        ballSound->play();
        ball->setPosition(ai.getPosition().x - BallRadius - PaddleSize.x / 2 - 0.1f, ball->getPosition().y);
    }
    
    return isPlaying;
}

void render(sf::RenderWindow* window, const sf::RectangleShape& player, const sf::RectangleShape& ai, const sf::CircleShape& ball, const sf::Text& score)
{
    window->clear(sf::Color::Green);
    window->draw(player);
    window->draw(ai);
    window->draw(ball);
    window->draw(score);
    window->display();
}