So my main issue when programming a game of pong is the ball reflection when it collides with the player or AI paddle. When I first made a pong game I just gave the ball's yvel a random value between -1 and 1 and just flipped the sign on the xvel when it struck the paddle but that is horrendously boring. The player needs some sort of control over the ball and I was going for the kind that when the ball strikes the paddle it is reflected in the direction based on where it struck the paddle.

There were a few ways I was going to go about this, the most simple seemed to split the paddle into a few sections. When the ball and paddle collide check how far down the middle of the ball hit the paddle and give the ball a preset yvel based on where it hit. Closer to the edges gave it a larger value and closer to the center made the yvel close into 0. This of course would go for beneath the center and would make the ball head downward.

However I thought there was a better way to do this. What I tried to do ended of working with some glitches. I would take the amount of pixel difference between the center of the ball and where it hit the paddle and made that into a reasonable yvel value. Its hard to explain so I will include code that I used which is in C++ SFML.

        // Ball/Paddle Collision
        else if(sBall.getPosition().x <= 30 &&
                sBall.getPosition().y + BALLHEIGHT >= sPaddle.getPosition().y &&
                sBall.getPosition().y <= sPaddle.getPosition().y + PADDLEHEIGHT)
        {
            bpdelta = (sBall.getPosition().y + BALLHEIGHT) - sPaddle.getPosition().y;
            std::cout << "BPDelta: " << bpdelta << std::endl;
            ballvelx = ballvelx * -1;
            if(bpdelta < 60)
            {
                ballvely = 1 / (bpdelta / 10);
                std::cout << "Delta <= 60" << std::endl;
                std::cout << ballvely << std::endl;
                if(ballvely > 0)
                    ballvely = ballvely + -1;
            }
            else if (bpdelta > 60)
            {
                bpdelta = bpdelta - 60;
                ballvely = bpdelta / 100;
                std::cout << "Delta > 60" << std::endl;
                std::cout << ballvely << std::endl;
            }
            else
                ballvely = 0;
        }

These are just things that I tried to do without copying anyone elses work, what I want to know is what is the easiest and proper way to do this. I am currently not concerned by spin with how fast the paddle was moving when striking the ball, thanks and sorry for the wall of text

You don't need to split up the paddle into multiple sections. When the ball collides with the paddle get the distance from the y position of the ball( if the position correlates to the center of the ball ) to the y position of the paddle( if the position correlates with the center of the paddle ).

YDistance = Ball.y - Paddle.Y;

From that you'll get a value ranging from half of the paddle width to negative half of the paddle width. You can go ahead and turn it into a range from [-1,1] by dividing.

YVelocity = YDistance / ( PaddleLength / 2 );

This way the y velocity will depend on where you hit the ball with the paddle( hitting it on the top will make it have a velocity of -1, hitting it with the bottom will make it have a velocity of 1, and every position and velocity in between is attainable ) OR Vice Versa on velocities depending on where you treat the origins of x and y.

Another way to make the game more interesting is to check if the paddle is moving up or down when the ball collides and add a multiplier( negative or positive depending on where the hit happens ) which makes the ball move faster.

YVelocity = YVelocity + ( YVelocity * PaddleMultiplier );
// Paddle multiplier should be positive if moving downwards, negative when moving upwards, and 0 when not moving at all.

Take a look at this example. If the ball hits the bottom of the paddle, it's velocity will equal -1 and with a multiplier of 0.5( paddle moving down ) will make it's new velocity of the ball equal -1.5. The ball is faster because you hit it while moving downwards. However, if the multiplier is -0.5( paddle is moving up ), the ball moves slower as a penalty for hitting it on the wrong side.

Should add some fun to the game and make things interesting.

technically, in pong, the center offset of the paddle and ball would have no effect on trajectory, since the paddles are always vertical. only when you clip the ball with the end of the paddle would that come into play. OTOH, the speed and direction of the paddle WILL affect trajectory. so you're ignoring what really affects trajectory and modeling "made up physics" of how it works. the physics behind pong aren't that hard. and physics, math, and geometry are the three staples of game coding. it might be worth your time to do it right.

or get your "made up" stuff working, and then do it right - learn even more that way.

What i did in my first game (pong) is divide up the left and right side of the paddle in percentages. Then you can use that to multiply the balls X velocity. Pretty ease to implement. You can increment this even more when you hit the ball while the paddle is moving. Next step would be to create a spin to the ball when it hits the paddle moving, with the spin it would change direction on the edges, blocks and paddle decrementing after each hit.