Hi, sorry I didn't reply sooner, been abit busy.
With movement and collision, you have a couple of pitfalls. One is that the speed/velocity of a moving object can exceed the width of objects being tested against, a symptom of this is moving objects 'tunneling through' other objects. This occurs when you use 'static collision testing', which is testing the current position of objects in each iteration as opposed to testing the positions and trajectories of objects. With static tests, two collision tests ( in two frames/iterations ) can report a non-collision even though the trajectory of an object may have passed right through another object.
You can often get away with static tests by increasing the number of iterations and decreasing the maximum velocities involved, this means you can keep the same 'visual speed', but objects are actually moving much less between frames and being collision-tested much more frequently.
Another specific problem with the bounce method you're using is that the ball can be collision-tested as being below paddle.top( ), your code will flip the velocity of the ball; in the next frame, the ball might not escape the collision between paddle.top( ), meaning the ball trajectory gets flipped again, and again, and so on. The ball would indeed 'spaz about' in that case, the ball never actually escapes the top of the paddle.
Two viable fixes:
if(m_position.y+m_height >= paddle->GetY() && m_position.y <= paddle->GetY() + paddle->GetHeight() && m_position.x+m_width/2 > paddle->GetX() && m_position.x+m_width/2 < paddle->GetX() + paddle->GetWidth())
{
m_velocity.x += paddle->GetMoveX()*(0.25);
m_velocity.y *= (-1);
m_position.y -= [a small number];
}
This assumes that y=0 is the top of the screen, effect is slightly displacing ( separating ) the ball position from the collision, so that the ball can start moving away without getting stuck in this test. Another solution:
if(m_position.y+m_height >= paddle->GetY() && m_position.y <= paddle->GetY() + paddle->GetHeight() && m_position.x+m_width/2 > paddle->GetX() && m_position.x+m_width/2 < paddle->GetX() + paddle->GetWidth())
{
m_velocity.x += paddle->GetMoveX()*(0.25);
m_velocity.y = fabs( m_velocity.y ) * -1;
}
( again assuming that negative velocity in Y goes upwards, if not the case, remove the *-1 ). Need to #include <cmath> to get fabs, and fabs just takes the absolute of a floating point number ( i.e. without the sign ). This way, you can always push the ball 'upwards'.
I said two viable solutions.. there's actually three, the last is to use vector math to calculate the reflection against the surface based on the normal of the surface.. equation for which is something like:
velocity2 = ( 2 * surface_normal * surface_normal.dot( velocity1 ) ) - velocity1;
( not tested )
