sad

Ball.h

@@ -0,0 +1,21 @@
+#include <SFML/Graphics.hpp>
+#include <SFML/Audio.hpp>
+
+class Ball : public sf::CircleShape {
+    private:
+        float x,
+              y,
+              radius = 10;
+        const float ballSpeed = 400;
+    
+    public:
+        Ball();
+        Ball(int radius);
+        void move(float x, float y);
+        void setPosition(float x, float y);
+        float getX() const;
+        float getY() const;
+        float getSpeed() const;
+        void render(sf::RenderWindow) const;
+
+};

Makefile

@@ -1,3 +1,2 @@
 all: pong.cpp resources
-	g++ pong.cpp -o pong  -lsfml-graphics -lsfml-window -lsfml-system -lsfml-audio
-
+	g++ pong.cpp functions.cpp -o pong  -lsfml-graphics -lsfml-window -lsfml-system -lsfml-audio

Paddle.h

@@ -0,0 +1,20 @@
+#include <SFML/Graphics.hpp>
+#include <SFML/Audio.hpp>
+
+class Paddle : public sf::RectangleShape {
+    private:
+    float x,
+          y;
+    sf::Vector2f size;
+
+    public:
+        Paddle();
+        void move(float x, float y);
+        void draw(sf::RenderWindow);
+        float getX() const;
+        float getY() const;
+        sf::Vector2f getSize() const;
+        void setPosition(float x, float y);
+        void render(sf::RenderWindow) const;
+
+};

functions.cpp

@@ -0,0 +1,71 @@
+#include "Ball.h"
+#include "Paddle.h"
+
+
+Ball::Ball() {
+    setRadius(radius - 3);
+    setOutlineThickness(3);
+    setOutlineColor(sf::Color::Black);
+    setFillColor(sf::Color::White);
+    setOrigin(radius / 2, radius / 2);
+}
+
+Ball::Ball(int r) {
+    setRadius(r - 3);
+    setOutlineThickness(3);
+    setOutlineColor(sf::Color::Black);
+    setFillColor(sf::Color::White);
+    setOrigin(r / 2, r / 2);
+    radius = r;
+}
+
+float Ball::getX() const {
+    return getPosition().x;
+}
+
+float Ball::getY() const {
+    return getPosition().y;
+}
+
+void Ball::setPosition(float x, float y) {
+    sf::Transformable::setPosition(x, y);
+}
+
+float Ball::getSpeed() const {
+    return ballSpeed;
+}
+
+void Ball::move(float x, float y) {
+    sf::Transformable::move(x, y);
+}
+
+
+Paddle::Paddle() {
+    size.x = 25;
+    size.y = 100;
+    setSize(sf::Vector2f(25, 100) - sf::Vector2f(3, 3));
+    setOutlineThickness(3);
+    setOutlineColor(sf::Color::Black);
+    setFillColor(sf::Color(200, 200, 200));
+    setOrigin(sf::Vector2f(25, 100) / 2.f);
+}
+
+float Paddle::getY() const {
+    return getPosition().y;
+}
+
+float Paddle::getX() const {
+    return getPosition().x;
+}
+
+void Paddle::setPosition(float x, float y) {
+    sf::Transformable::setPosition(x, y);
+}
+
+sf::Vector2f Paddle::getSize() const {
+    return size;
+}
+
+void Paddle::move(float x, float y) {
+    sf::Transformable::move(x, y);
+}

oldpong.cpp

@@ -0,0 +1,282 @@
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics.hpp>
+#include <SFML/Audio.hpp>
+#include <cmath>
+#include <ctime>
+#include <cstdlib>
+
+#ifdef SFML_SYSTEM_IOS
+#include <SFML/Main.hpp>
+#endif
+
+std::string resourcesDir()
+{
+#ifdef SFML_SYSTEM_IOS
+    return "";
+#else
+    return "resources/";
+#endif
+}
+
+////////////////////////////////////////////////////////////
+/// Entry point of application
+///
+/// \return Application exit code
+///
+////////////////////////////////////////////////////////////
+int main()
+{
+    std::srand(static_cast<unsigned int>(std::time(NULL)));
+
+    // Define some constants
+    const float pi = 3.14159f;
+    const int gameWidth = 800;
+    const int gameHeight = 600;
+    sf::Vector2f paddleSize(25, 100);
+    float ballRadius = 10.f;
+
+    // Create the window of the application
+    sf::RenderWindow window(sf::VideoMode(gameWidth, gameHeight, 32), "SFML Pong",
+                            sf::Style::Titlebar | sf::Style::Close);
+    window.setVerticalSyncEnabled(true);
+
+    // Load the sounds used in the game
+    sf::SoundBuffer ballSoundBuffer;
+    if (!ballSoundBuffer.loadFromFile(resourcesDir() + "ball.wav"))
+        return EXIT_FAILURE;
+    sf::Sound ballSound(ballSoundBuffer);
+
+    // Create the left paddle
+    sf::RectangleShape leftPaddle;
+    leftPaddle.setSize(paddleSize - sf::Vector2f(3, 3));
+    leftPaddle.setOutlineThickness(3);
+    leftPaddle.setOutlineColor(sf::Color::Black);
+    leftPaddle.setFillColor(sf::Color(100, 100, 100));
+    leftPaddle.setOrigin(paddleSize / 2.f);
+
+    // Create the right paddle
+    sf::RectangleShape rightPaddle;
+    rightPaddle.setSize(paddleSize - sf::Vector2f(3, 3));
+    rightPaddle.setOutlineThickness(3);
+    rightPaddle.setOutlineColor(sf::Color::Black);
+    rightPaddle.setFillColor(sf::Color(100, 100, 100));
+    rightPaddle.setOrigin(paddleSize / 2.f);
+
+    // Create the ball
+    sf::CircleShape ball;
+    ball.setRadius(ballRadius - 3);
+    ball.setOutlineThickness(3);
+    ball.setOutlineColor(sf::Color::Black);
+    ball.setFillColor(sf::Color::White);
+    ball.setOrigin(ballRadius / 2, ballRadius / 2);
+
+    // Load the text font
+    sf::Font font;
+    if (!font.loadFromFile(resourcesDir() + "sansation.ttf"))
+        return EXIT_FAILURE;
+
+    // Initialize the pause message
+    sf::Text pauseMessage;
+    pauseMessage.setFont(font);
+    pauseMessage.setCharacterSize(40);
+    pauseMessage.setPosition(170.f, 150.f);
+    //pauseMessage.setFillColor(sf::Color::White);
+    
+    #ifdef SFML_SYSTEM_IOS
+    pauseMessage.setString("Welcome to SFML pong!\nTouch the screen to start the game");
+    #else
+    pauseMessage.setString("Welcome to SFML pong!\nPress space to start the game");
+    #endif
+
+    // Define the paddles properties
+    sf::Clock AITimer;
+    const sf::Time AITime   = sf::seconds(0.1f);
+    const float paddleSpeed = 400.f;
+    float rightPaddleSpeed  = 0.f;
+    const float ballSpeed   = 400.f;
+    float ballAngle         = 0.f; // to be changed later
+
+    sf::Clock clock;
+    bool isPlaying = false;
+    while (window.isOpen())
+    {
+        // Handle events
+        sf::Event event;
+        while (window.pollEvent(event))
+        {
+            // Window closed or escape key pressed: exit
+            if ((event.type == sf::Event::Closed) ||
+               ((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Escape)))
+            {
+                window.close();
+                break;
+            }
+
+            // Space key pressed: play
+            if (((event.type == sf::Event::KeyPressed) && (event.key.code == sf::Keyboard::Space)) ||
+                (event.type == sf::Event::TouchBegan))
+            {
+                if (!isPlaying)
+                {
+                    // (re)start the game
+                    isPlaying = true;
+                    clock.restart();
+
+                    // Reset the position of the paddles and ball
+                    leftPaddle.setPosition(10 + paddleSize.x / 2, gameHeight / 2);
+                    rightPaddle.setPosition(gameWidth - 10 - paddleSize.x / 2, gameHeight / 2);
+                    ball.setPosition(gameWidth / 2, gameHeight / 2);
+
+                    // Reset the ball angle
+                    do
+                    {
+                        // Make sure the ball initial angle is not too much vertical
+                        ballAngle = (std::rand() % 360) * 2 * pi / 360;
+                    }
+                    while (std::abs(std::cos(ballAngle)) < 0.7f);
+                }
+            }
+            
+            // Window size changed, adjust view appropriately
+            if (event.type == sf::Event::Resized)
+            {
+                sf::View view;
+                view.setSize(gameWidth, gameHeight);
+                view.setCenter(gameWidth/2.f, gameHeight/2.f);
+                window.setView(view);
+            }
+        }
+
+        if (isPlaying)
+        {
+            float deltaTime = clock.restart().asSeconds();
+
+            // Move the player's paddle
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) &&
+               (leftPaddle.getPosition().y - paddleSize.y / 2 > 5.f))
+            {
+                leftPaddle.move(0.f, -paddleSpeed * deltaTime);
+            }
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down) &&
+               (leftPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f))
+            {
+                leftPaddle.move(0.f, paddleSpeed * deltaTime);
+            }
+            
+            if (sf::Touch::isDown(0))
+            {
+                sf::Vector2i pos = sf::Touch::getPosition(0);
+                sf::Vector2f mappedPos = window.mapPixelToCoords(pos);
+                leftPaddle.setPosition(leftPaddle.getPosition().x, mappedPos.y);
+            }
+
+            // Move the computer's paddle
+            if (((rightPaddleSpeed < 0.f) && (rightPaddle.getPosition().y - paddleSize.y / 2 > 5.f)) ||
+                ((rightPaddleSpeed > 0.f) && (rightPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f)))
+            {
+                rightPaddle.move(0.f, rightPaddleSpeed * deltaTime);
+            }
+
+            // Update the computer's paddle direction according to the ball position
+            if (AITimer.getElapsedTime() > AITime)
+            {
+                AITimer.restart();
+                if (ball.getPosition().y + ballRadius > rightPaddle.getPosition().y + paddleSize.y / 2)
+                    rightPaddleSpeed = paddleSpeed;
+                else if (ball.getPosition().y - ballRadius < rightPaddle.getPosition().y - paddleSize.y / 2)
+                    rightPaddleSpeed = -paddleSpeed;
+                else
+                    rightPaddleSpeed = 0.f;
+            }
+
+            // Move the ball
+            float factor = ballSpeed * deltaTime;
+            ball.move(std::cos(ballAngle) * factor, std::sin(ballAngle) * factor);
+
+            #ifdef SFML_SYSTEM_IOS
+            const std::string inputString = "Touch the screen to restart";
+            #else
+            const std::string inputString = "Press space to restart or\nescape to exit";
+            #endif
+            
+            // Check collisions between the ball and the screen
+            if (ball.getPosition().x - ballRadius < 0.f)
+            {
+                isPlaying = false;
+                pauseMessage.setString("You Lost!\n" + inputString);
+            }
+            if (ball.getPosition().x + ballRadius > gameWidth)
+            {
+                isPlaying = false;
+                pauseMessage.setString("You Won!\n" + inputString);
+            }
+            if (ball.getPosition().y - ballRadius < 0.f)
+            {
+                ballSound.play();
+                ballAngle = -ballAngle;
+                ball.setPosition(ball.getPosition().x, ballRadius + 0.1f);
+            }
+            if (ball.getPosition().y + ballRadius > gameHeight)
+            {
+                ballSound.play();
+                ballAngle = -ballAngle;
+                ball.setPosition(ball.getPosition().x, gameHeight - ballRadius - 0.1f);
+            }
+
+            // Check the collisions between the ball and the paddles
+            // Left Paddle
+            if (ball.getPosition().x - ballRadius < leftPaddle.getPosition().x + paddleSize.x / 2 &&
+                ball.getPosition().x - ballRadius > leftPaddle.getPosition().x &&
+                ball.getPosition().y + ballRadius >= leftPaddle.getPosition().y - paddleSize.y / 2 &&
+                ball.getPosition().y - ballRadius <= leftPaddle.getPosition().y + paddleSize.y / 2)
+            {
+                if (ball.getPosition().y > leftPaddle.getPosition().y)
+                    ballAngle = pi - ballAngle + (std::rand() % 20) * pi / 180;
+                else
+                    ballAngle = pi - ballAngle - (std::rand() % 20) * pi / 180;
+
+                ballSound.play();
+                ball.setPosition(leftPaddle.getPosition().x + ballRadius + paddleSize.x / 2 + 0.1f, ball.getPosition().y);
+            }
+
+            // Right Paddle
+            if (ball.getPosition().x + ballRadius > rightPaddle.getPosition().x - paddleSize.x / 2 &&
+                ball.getPosition().x + ballRadius < rightPaddle.getPosition().x &&
+                ball.getPosition().y + ballRadius >= rightPaddle.getPosition().y - paddleSize.y / 2 &&
+                ball.getPosition().y - ballRadius <= rightPaddle.getPosition().y + paddleSize.y / 2)
+            {
+                if (ball.getPosition().y > rightPaddle.getPosition().y)
+                    ballAngle = pi - ballAngle + (std::rand() % 20) * pi / 180;
+                else
+                    ballAngle = pi - ballAngle - (std::rand() % 20) * pi / 180;
+
+                ballSound.play();
+                ball.setPosition(rightPaddle.getPosition().x - ballRadius - paddleSize.x / 2 - 0.1f, ball.getPosition().y);
+            }
+        }
+
+        // Clear the window
+        window.clear(sf::Color(50, 200, 50));
+
+        if (isPlaying)
+        {
+            // Draw the paddles and the ball
+            window.draw(leftPaddle);
+            window.draw(rightPaddle);
+            window.draw(ball);
+        }
+        else
+        {
+            // Draw the pause message
+            window.draw(pauseMessage);
+        }
+
+        // Display things on screen
+        window.display();
+    }
+
+    return EXIT_SUCCESS;
+}

pong.cpp

@@ -1,4 +1,3 @@
-
 ////////////////////////////////////////////////////////////
 // Headers
 ////////////////////////////////////////////////////////////
@@ -7,12 +6,16 @@
 #include <cmath>
 #include <ctime>
 #include <cstdlib>
+#include "Ball.h"
+#include "Paddle.h"
 
 #ifdef SFML_SYSTEM_IOS
 #include <SFML/Main.hpp>
 #endif
 
-std::string resourcesDir()
+using namespace std;
+
+string resourcesDir()
 {
 #ifdef SFML_SYSTEM_IOS
     return "";
@@ -21,6 +24,7 @@ std::string resourcesDir()
 #endif
 }
 
+
 ////////////////////////////////////////////////////////////
 /// Entry point of application
 ///
@@ -29,14 +33,14 @@ std::string resourcesDir()
 ////////////////////////////////////////////////////////////
 int main()
 {
-    std::srand(static_cast<unsigned int>(std::time(NULL)));
+    srand(static_cast<unsigned int>(time(NULL)));
 
     // Define some constants
-    const float pi = 3.14159f;
+    const float pi = 3.14159;
     const int gameWidth = 800;
     const int gameHeight = 600;
-    sf::Vector2f paddleSize(25, 100);
-    float ballRadius = 10.f;
+    
+    float ballRadius = 10;
 
     // Create the window of the application
     sf::RenderWindow window(sf::VideoMode(gameWidth, gameHeight, 32), "SFML Pong",
@@ -50,28 +54,13 @@ int main()
     sf::Sound ballSound(ballSoundBuffer);
 
     // Create the left paddle
-    sf::RectangleShape leftPaddle;
-    leftPaddle.setSize(paddleSize - sf::Vector2f(3, 3));
-    leftPaddle.setOutlineThickness(3);
-    leftPaddle.setOutlineColor(sf::Color::Black);
-    leftPaddle.setFillColor(sf::Color(100, 100, 200));
-    leftPaddle.setOrigin(paddleSize / 2.f);
+    Paddle leftPaddle;
 
     // Create the right paddle
-    sf::RectangleShape rightPaddle;
-    rightPaddle.setSize(paddleSize - sf::Vector2f(3, 3));
-    rightPaddle.setOutlineThickness(3);
-    rightPaddle.setOutlineColor(sf::Color::Black);
-    rightPaddle.setFillColor(sf::Color(200, 100, 100));
-    rightPaddle.setOrigin(paddleSize / 2.f);
+    Paddle rightPaddle;
 
     // Create the ball
-    sf::CircleShape ball;
-    ball.setRadius(ballRadius - 3);
-    ball.setOutlineThickness(3);
-    ball.setOutlineColor(sf::Color::Black);
-    ball.setFillColor(sf::Color::White);
-    ball.setOrigin(ballRadius / 2, ballRadius / 2);
+    Ball ball;
 
     // Load the text font
     sf::Font font;
@@ -82,7 +71,7 @@ int main()
     sf::Text pauseMessage;
     pauseMessage.setFont(font);
     pauseMessage.setCharacterSize(40);
-    pauseMessage.setPosition(170.f, 150.f);
+    pauseMessage.setPosition(170, 150);
     //pauseMessage.setFillColor(sf::Color::White);
     
     #ifdef SFML_SYSTEM_IOS
@@ -96,7 +85,6 @@ int main()
     const sf::Time AITime   = sf::seconds(0.1f);
     const float paddleSpeed = 400.f;
     float rightPaddleSpeed  = 0.f;
-    const float ballSpeed   = 400.f;
     float ballAngle         = 0.f; // to be changed later
 
     sf::Clock clock;
@@ -126,17 +114,17 @@ int main()
                     clock.restart();
 
                     // Reset the position of the paddles and ball
-                    leftPaddle.setPosition(10 + paddleSize.x / 2, gameHeight / 2);
-                    rightPaddle.setPosition(gameWidth - 10 - paddleSize.x / 2, gameHeight / 2);
+                    leftPaddle.setPosition(10 + leftPaddle.getSize().x / 2, gameHeight / 2);
+                    rightPaddle.setPosition(gameWidth - 10 - leftPaddle.getSize().x / 2, gameHeight / 2);
                     ball.setPosition(gameWidth / 2, gameHeight / 2);
 
                     // Reset the ball angle
                     do
                     {
                         // Make sure the ball initial angle is not too much vertical
-                        ballAngle = (std::rand() % 360) * 2 * pi / 360;
+                        ballAngle = (rand() % 360) * 2 * pi / 360;
                     }
-                    while (std::abs(std::cos(ballAngle)) < 0.7f);
+                    while (abs(cos(ballAngle)) < 0.7f);
                 }
             }
             
@@ -150,18 +138,19 @@ int main()
             }
         }
 
+
         if (isPlaying)
         {
             float deltaTime = clock.restart().asSeconds();
 
             // Move the player's paddle
             if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) &&
-               (leftPaddle.getPosition().y - paddleSize.y / 2 > 5.f))
+               (leftPaddle.getY() - leftPaddle.getSize().y / 2 > 5))
             {
                 leftPaddle.move(0.f, -paddleSpeed * deltaTime);
             }
             if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down) &&
-               (leftPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f))
+               (leftPaddle.getY() + leftPaddle.getSize().y / 2 < gameHeight - 5))
             {
                 leftPaddle.move(0.f, paddleSpeed * deltaTime);
             }
@@ -170,12 +159,11 @@ int main()
             {
                 sf::Vector2i pos = sf::Touch::getPosition(0);
                 sf::Vector2f mappedPos = window.mapPixelToCoords(pos);
-                leftPaddle.setPosition(leftPaddle.getPosition().x, mappedPos.y);
+                leftPaddle.setPosition(leftPaddle.getX(), mappedPos.y);
             }
-
             // Move the computer's paddle
-            if (((rightPaddleSpeed < 0.f) && (rightPaddle.getPosition().y - paddleSize.y / 2 > 5.f)) ||
-                ((rightPaddleSpeed > 0.f) && (rightPaddle.getPosition().y + paddleSize.y / 2 < gameHeight - 5.f)))
+            if (((rightPaddleSpeed < 0.f) && (rightPaddle.getY() - leftPaddle.getSize().y / 2 > 5.f)) ||
+                ((rightPaddleSpeed > 0.f) && (rightPaddle.getY() + leftPaddle.getSize().y / 2 < gameHeight - 5.f)))
             {
                 rightPaddle.move(0.f, rightPaddleSpeed * deltaTime);
             }
@@ -184,77 +172,77 @@ int main()
             if (AITimer.getElapsedTime() > AITime)
             {
                 AITimer.restart();
-                if (ball.getPosition().y + ballRadius > rightPaddle.getPosition().y + paddleSize.y / 2)
+                if (ball.getY() + ballRadius > rightPaddle.getY() + leftPaddle.getSize().y / 2)
                     rightPaddleSpeed = paddleSpeed;
-                else if (ball.getPosition().y - ballRadius < rightPaddle.getPosition().y - paddleSize.y / 2)
+                else if (ball.getY() - ballRadius < rightPaddle.getY() - leftPaddle.getSize().y / 2)
                     rightPaddleSpeed = -paddleSpeed;
                 else
                     rightPaddleSpeed = 0.f;
             }
 
             // Move the ball
-            float factor = ballSpeed * deltaTime;
-            ball.move(std::cos(ballAngle) * factor, std::sin(ballAngle) * factor);
+            float factor = ball.getSpeed() * deltaTime;
+            ball.move(cos(ballAngle) * factor, sin(ballAngle) * factor);
 
             #ifdef SFML_SYSTEM_IOS
-            const std::string inputString = "Touch the screen to restart";
+            const string inputString = "Touch the screen to restart";
             #else
-            const std::string inputString = "Press space to restart or\nescape to exit";
+            const string inputString = "Press space to restart or\nescape to exit";
             #endif
             
             // Check collisions between the ball and the screen
-            if (ball.getPosition().x - ballRadius < 0.f)
+            if (ball.getX() - ballRadius < 0.f)
             {
                 isPlaying = false;
                 pauseMessage.setString("You Lost!\n" + inputString);
             }
-            if (ball.getPosition().x + ballRadius > gameWidth)
+            if (ball.getX() + ballRadius > gameWidth)
             {
                 isPlaying = false;
                 pauseMessage.setString("You Won!\n" + inputString);
             }
-            if (ball.getPosition().y - ballRadius < 0.f)
+            if (ball.getY() - ballRadius < 0.f)
             {
                 ballSound.play();
                 ballAngle = -ballAngle;
-                ball.setPosition(ball.getPosition().x, ballRadius + 0.1f);
+                ball.setPosition(ball.getX(), ballRadius + 0.1f);
             }
-            if (ball.getPosition().y + ballRadius > gameHeight)
+            if (ball.getY() + ballRadius > gameHeight)
             {
                 ballSound.play();
                 ballAngle = -ballAngle;
-                ball.setPosition(ball.getPosition().x, gameHeight - ballRadius - 0.1f);
+                ball.setPosition(ball.getX(), gameHeight - ballRadius - 0.1f);
             }
 
             // Check the collisions between the ball and the paddles
             // Left Paddle
-            if (ball.getPosition().x - ballRadius < leftPaddle.getPosition().x + paddleSize.x / 2 &&
-                ball.getPosition().x - ballRadius > leftPaddle.getPosition().x &&
-                ball.getPosition().y + ballRadius >= leftPaddle.getPosition().y - paddleSize.y / 2 &&
-                ball.getPosition().y - ballRadius <= leftPaddle.getPosition().y + paddleSize.y / 2)
+            if (ball.getX() - ballRadius < leftPaddle.getX() + leftPaddle.getSize().x / 2 &&
+                ball.getX() - ballRadius > leftPaddle.getX() &&
+                ball.getY() + ballRadius >= leftPaddle.getY() - leftPaddle.getSize().y / 2 &&
+                ball.getY() - ballRadius <= leftPaddle.getY() + leftPaddle.getSize().y / 2)
             {
-                if (ball.getPosition().y > leftPaddle.getPosition().y)
-                    ballAngle = pi - ballAngle + (std::rand() % 20) * pi / 180;
+                if (ball.getY() > leftPaddle.getY())
+                    ballAngle = pi - ballAngle + (rand() % 20) * pi / 180;
                 else
-                    ballAngle = pi - ballAngle - (std::rand() % 20) * pi / 180;
+                    ballAngle = pi - ballAngle - (rand() % 20) * pi / 180;
 
                 ballSound.play();
-                ball.setPosition(leftPaddle.getPosition().x + ballRadius + paddleSize.x / 2 + 0.1f, ball.getPosition().y);
+                ball.setPosition(leftPaddle.getX() + ballRadius + leftPaddle.getSize().x / 2 + 0.1f, ball.getY());
             }
 
             // Right Paddle
-            if (ball.getPosition().x + ballRadius > rightPaddle.getPosition().x - paddleSize.x / 2 &&
-                ball.getPosition().x + ballRadius < rightPaddle.getPosition().x &&
-                ball.getPosition().y + ballRadius >= rightPaddle.getPosition().y - paddleSize.y / 2 &&
-                ball.getPosition().y - ballRadius <= rightPaddle.getPosition().y + paddleSize.y / 2)
+            if (ball.getX() + ballRadius > rightPaddle.getX() - leftPaddle.getSize().x / 2 &&
+                ball.getX() + ballRadius < rightPaddle.getX() &&
+                ball.getY() + ballRadius >= rightPaddle.getY() - leftPaddle.getSize().y / 2 &&
+                ball.getY() - ballRadius <= rightPaddle.getY() + leftPaddle.getSize().y / 2)
             {
-                if (ball.getPosition().y > rightPaddle.getPosition().y)
-                    ballAngle = pi - ballAngle + (std::rand() % 20) * pi / 180;
+                if (ball.getY() > rightPaddle.getY())
+                    ballAngle = pi - ballAngle + (rand() % 20) * pi / 180;
                 else
-                    ballAngle = pi - ballAngle - (std::rand() % 20) * pi / 180;
+                    ballAngle = pi - ballAngle - (rand() % 20) * pi / 180;
 
                 ballSound.play();
-                ball.setPosition(rightPaddle.getPosition().x - ballRadius - paddleSize.x / 2 - 0.1f, ball.getPosition().y);
+                ball.setPosition(rightPaddle.getX() - ballRadius - leftPaddle.getSize().x / 2 - 0.1f, ball.getY());
             }
         }