Para darle aceleración, puedes hacer como dice amchacon, aunque también puedes usar fórmulas físicas, es decir:

X(t)=X0+V0*t+(1/2)a*t²

Siendo: 

• X0: posición inicial (en píxeles).
• V: velocidad inicial (en píxeles/ciclo, si los fps de tu juego son constantes, o en píxeles/milisegundos, si no lo son).
• a: aceleración (en píxeles/ciclo² si los fps son constantes o en píxeles/milisegundos², si no lo son).
• t: tiempo (en ciclos, o milisegundos, dependiendo de los fps) desde que se inicio ese movimiento.

Necesitas una de estas ecuaciones y variables para cada eje (uno para X, y otro para Y).

Cuando quieras cambiar un movimiento (por ejemplo, por choque con una pared en el eje X):

1. Coges la X actual, y la usas para X0 (X0=X).
2. Cambias la velocidad (en el ejemplo, V0=-V0).
3. Cambias la aceleración (lo dejo a tu imaginación).

Mientras que el movimiento sea constante, lo único que debes hacer para que la pelota se mueva es incrementar la t.

Suponiendo que esta esté en ciclos, bastará que en cada ciclo la incrementes en uno (t++).

Si esta en milisegundos, puedes añadirle a t la diferencia en milisegundos desde el último movimiento, aunque casi resulta mejor darle a t el valor de los milisegundos actuales - los milisegundos desde que se inicio el movimiento. Así, cuando inicies un movimiento, guarda el valor de los milisegundos que han pasado desde que se inició el juego en una variable (entera y grande). Creo que SDL tiene una función para ello. Luego, cuando quieras saber el valor de t, coges el valor de los milisgundo actuales y le restas el valor que has guardado. Suponiendo que la función que devuelva los milisegundos desde el inicio sea milis ():

//Inicio del movimiento:
 
long int stmil = millis ();
 
...
 
//Calculo de t:
 
t= millis () -stmil;

En cuanto a los ángulo, si cuando choques con un borde le cambias el signo a la velocidad y a la aceleración, los ángulos no te deberían salir de 90º, pero hay ya no se que decirte.

EDITO:

Se me olvidaba comentarte una cosa. Si necesitas saber la velocidad en un eje en un momento dado:

V=V0+a*t;

Si introduces todas estas variables en una clase (C++) o estructura + funciones (C), obtener la posición y la velocidad podría ser tan sencillo como hacer x() y v(), respectivamente (por poner un ejemplo).

Por cierto, cuando termines de arreglarlo podrías subirlo por aquí, que lo veamos.

Tendrás que cambiar por completo tu sistema entonces.

Tienes que implementar el concepto de velocidad para poder aplicar el concepto de aceleración:

int X = 0;
int Y = 0;
int VelocidadX = 0;
int VelocidadY = 0;
int AceleracionX = 0;
int AceleracionY = 0;

Ahora movemos la pelota usando la velocidad:

X += VelocidadX;
Y += VelocidadY;

Si queremos que se mueva a la izquierda, solo tendrémos que hacer una velocidad negativa. Si a esto le aplicamos la aceleración:

VelocidadX += AceleracionX; // Acuerdate de ajustar la aceleracion a un valor adecuado
VelocidadY += AceleracionY; 
X += VelocidadX;
Y += VelocidadY;

Cuando choque contra una pared, tendremos que cambiar los valores de velocidad/aceleración. Si choca contra una pared cambiamos sus valoresl:

// Pared derecha
 
VelocidadX = -1;
AceleracionX *= -1;
 
// Pared izquierda
 
VelocidadX = 1;
AceleracionX *= -1;
 
// Pared Arriba
 
VelocidadY = -1;
AceleracionY *= -1;
 
// Pared Abajo
 
VelocidadY = 1;
AceleracionY *= -1;

Con esto ya lo tenemos implementado, solo queda ajustar
los valores de velocidad/aceleración para que sea acorde a tu campo. Así
mismo como tu delay.