finally

.vscode/c_cpp_properties.json

                 "${workspaceFolder}/**"
             ],
             "defines": [],
-            "compilerPath": "/usr/bin/clang",
+            "compilerPath": "/usr/bin/g++",
             "cStandard": "c11",
             "cppStandard": "c++17",
-            "intelliSenseMode": "clang-x64"
+            "intelliSenseMode": "gcc-x64"
         }
     ],
     "version": 4

.vscode/settings.json

+{
+    "files.associations": {
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "chrono": "cpp",
+        "codecvt": "cpp",
+        "condition_variable": "cpp",
+        "cstdint": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp",
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__functional_base": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "bit": "cpp",
+        "ios": "cpp",
+        "locale": "cpp",
+        "queue": "cpp",
+        "stack": "cpp"
+    }
+}

Ball.h

-#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;
-        float getRadius() const;
-        void render(sf::RenderWindow) const;
-
-};

Classes.h

+#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;
+
+};
+
+class Ball : public sf::CircleShape {
+    private:
+        float radius = 10,
+              angle = 0;
+        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;
+        float getRadius() const;
+        float getAngle() const;
+        void setAngle(float a);
+        void render(sf::RenderWindow) const;
+        void checkLeftPaddle(Paddle leftPaddle, sf::Sound ballSound);
+        void checkRightPaddle(Paddle rightPaddle, sf::Sound ballSound);
+
+};

Makefile

-all: pong.cpp resources
-	g++ pong.cpp functions.cpp -o pong  -lsfml-graphics -lsfml-window -lsfml-system -lsfml-audio
+all: pong.o functions.o resources
+	g++ pong.o functions.o -o pong  -lsfml-graphics -lsfml-window -lsfml-system -lsfml-audio; ./pong
+pong.o: pong.cpp
+	g++ -c pong.cpp
+functions.o: functions.cpp
+	g++ -c functions.cpp

Paddle.h

-#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

-#include "Ball.h"
-#include "Paddle.h"
+#include "Classes.h"
 #include "Game.h"
+#include <cmath>
+#include <iostream>
 
 
 Ball::Ball() {
-    setRadius(radius - 3);
+    setRadius(radius);
     setOutlineThickness(3);
     setOutlineColor(sf::Color::Black);
     setFillColor(sf::Color::White);
 }
 
 Ball::Ball(int r) {
-    setRadius(r - 3);
+    setRadius(r);
     setOutlineThickness(3);
     setOutlineColor(sf::Color::Black);
     setFillColor(sf::Color::White);
     return radius;
 }
 
+float Ball::getAngle() const {
+    return angle;
+}
+
+void Ball::setAngle(float a) {
+    angle = a;
+}
+
+void Ball::checkLeftPaddle(Paddle leftPaddle, sf::Sound ballSound) {
+    
+    if (getPosition().x - radius < leftPaddle.getX() + leftPaddle.getSize().x / 2 &&
+        getPosition().x - radius > leftPaddle.getX() &&
+        getPosition().y + radius <= leftPaddle.getY() + leftPaddle.getSize().y / 2 &&
+        getPosition().y - radius >= leftPaddle.getY() - leftPaddle.getSize().y / 2)
+        
+    {
+        if (getPosition().y > leftPaddle.getY())
+            angle = M_PI - angle + (rand() % 20) * M_PI / 180;
+        else
+            angle = M_PI - angle - (rand() % 20) * M_PI / 180;
+
+        ballSound.play();
+        setPosition(leftPaddle.getX() + radius + leftPaddle.getSize().x / 2 + 0.1f, getPosition().y);
+    }
+}
+
+void Ball::checkRightPaddle(Paddle rightPaddle, sf::Sound ballSound) {
+    
+    if (getPosition().x + radius > rightPaddle.getX() - rightPaddle.getSize().x / 2 &&
+        getPosition().x + radius < rightPaddle.getX() &&
+        getPosition().y + radius >= rightPaddle.getY() - rightPaddle.getSize().y / 2 &&
+        getPosition().y - radius <= rightPaddle.getY() + rightPaddle.getSize().y / 2)
+    {
+        if (getPosition().y > rightPaddle.getY())
+            angle = radius - angle + (rand() % 20) * radius / 180;
+        else
+            angle = radius - angle - (rand() % 20) * M_PI / 180;
+
+        ballSound.play();
+        setPosition(rightPaddle.getX() - radius - rightPaddle.getSize().x / 2 - 0.1, getPosition().y);
+    }
+}
 
 Paddle::Paddle() {
     size.x = 25;

pong.cpp

 #include <cmath>
 #include <ctime>
 #include <cstdlib>
-#include "Ball.h"
-#include "Paddle.h"
+#include "Classes.h"
 
 #ifdef SFML_SYSTEM_IOS
 #include <SFML/Main.hpp>
     sf::Clock AITimer;
     const sf::Time AITime   = sf::seconds(0.1f);
     const float paddleSpeed = 400.f;
-    float rightPaddleSpeed  = 0.f;
-    float ballAngle         = 0.f; // to be changed later
+    float rightPaddleSpeed  = 0.f; // to be changed later
 
     sf::Clock clock;
     bool isPlaying = false;
                     do
                     {
                         // Make sure the ball initial angle is not too much vertical
-                        ballAngle = (rand() % 360) * 2 * pi / 360;
+                        ball.setAngle((rand() % 360) * 2 * pi / 360);
                     }
-                    while (abs(cos(ballAngle)) < 0.7f);
+                    while (abs(cos(ball.getAngle())) < 0.7f);
                 }
             }
             
 
             // Move the ball
             float factor = ball.getSpeed() * deltaTime;
-            ball.move(cos(ballAngle) * factor, sin(ballAngle) * factor);
+            ball.move(cos(ball.getAngle()) * factor, sin(ball.getAngle()) * factor);
 
             #ifdef SFML_SYSTEM_IOS
             const string inputString = "Touch the screen to restart";
             #endif
             
             // Check collisions between the ball and the screen
-            if (ball.getX() - ball.getRadius() < 0.f)
+            if (ball.getX() - ball.getRadius() < 0)
             {
                 isPlaying = false;
                 pauseMessage.setString("You Lost!\n" + inputString);
             if (ball.getY() - ball.getRadius() < 0.f)
             {
                 ballSound.play();
-                ballAngle = -ballAngle;
+                ball.setAngle(-ball.getAngle());
                 ball.setPosition(ball.getX(), ball.getRadius() + 0.1f);
             }
             if (ball.getY() + ball.getRadius() > gameHeight)
             {
                 ballSound.play();
-                ballAngle = -ballAngle;
+                ball.setAngle(-ball.getAngle());
                 ball.setPosition(ball.getX(), gameHeight - ball.getRadius() - 0.1f);
             }
 
             // Check the collisions between the ball and the paddles
             // Left Paddle
-            if (ball.getX() - ball.getRadius() < leftPaddle.getX() + leftPaddle.getSize().x / 2 &&
-                ball.getX() - ball.getRadius() > leftPaddle.getX() &&
-                ball.getY() + ball.getRadius() >= leftPaddle.getY() - leftPaddle.getSize().y / 2 &&
-                ball.getY() - ball.getRadius() <= leftPaddle.getY() + leftPaddle.getSize().y / 2)
-            {
-                if (ball.getY() > leftPaddle.getY())
-                    ballAngle = pi - ballAngle + (rand() % 20) * pi / 180;
-                else
-                    ballAngle = pi - ballAngle - (rand() % 20) * pi / 180;
-
-                ballSound.play();
-                ball.setPosition(leftPaddle.getX() + ball.getRadius() + leftPaddle.getSize().x / 2 + 0.1f, ball.getY());
-            }
+            ball.checkLeftPaddle(leftPaddle, ballSound);
 
             // Right Paddle
-            if (ball.getX() + ball.getRadius() > rightPaddle.getX() - leftPaddle.getSize().x / 2 &&
-                ball.getX() + ball.getRadius() < rightPaddle.getX() &&
-                ball.getY() + ball.getRadius() >= rightPaddle.getY() - leftPaddle.getSize().y / 2 &&
-                ball.getY() - ball.getRadius() <= rightPaddle.getY() + leftPaddle.getSize().y / 2)
-            {
-                if (ball.getY() > rightPaddle.getY())
-                    ballAngle = pi - ballAngle + (rand() % 20) * pi / 180;
-                else
-                    ballAngle = pi - ballAngle - (rand() % 20) * pi / 180;
-
-                ballSound.play();
-                ball.setPosition(rightPaddle.getX() - ball.getRadius() - leftPaddle.getSize().x / 2 - 0.1f, ball.getY());
-            }
+            ball.checkRightPaddle(rightPaddle, ballSound);
+            
         }
 
         // Clear the window