[Ñuño Martínez]

A ver, a ver, "que sus estáis liando".

Cuando se está intentando reproducir un efecto físico, lo mejor es acudir a la física.

La pelota tiene una posición, que en física suele designarse mediante un vector P = { x, y }. Al mismo tiempo tiene una velocidad, que en física también se designa mediante un vector V = { Vx, Vy }, el cual representa la diferencia de posición de la pelota (Δ o "delta") en un espacio de tiempo t (es decir, el tiempo de un fotograma).

Por tanto la nueva posición de la pelota sería la suma de vectores P1 = P + V = { x + Vx, y + Vy }.

Según Newton (que a pesar de Einstein sigue siendo vigente) la velocidad es constante y sólo cambia si se le aplica una fuerza externa (por ejemplo, se golpea la pelota con una pala o raqueta, o la pelota golpea una pared). En física* las fuerzas también son vectores y normalmente se aplican sumándolos al vector V, aunque a la hora de programar pueden usarse algunos trucos. Por ejemplo, si se quiere que rebote contra los bordes de la pantalla entonces lo que hay que hacer es "invertir" el eje afectado. Si golpea los laterales, se invierte el eje horizontal (P2 = { x * (-1), y}), y si es la parte superior o la inferior se invierte el vertical (P2 = { x, y * (-1)}).

En cuanto a la parábola, sí es cierto que puede simularse mediante el seno y el coseno, pero será complicado. Aplicando la física es mucho más simple. La pelota describe una parábola porque es atraída por la Tierra. La atracción gravitatoria es una fuerza, y hemos dicho que las fuerzas son vectores, así que si tenemos la fuerza G podemos aplicarla a la velocidad de la pelota sumándosela.

¿Y todo esto cómo se codifica? Pues más fácil de lo que parece:

Código Delphi [-]
TYPE
(* Definimos el vector 2D. *)
  TVect2D = RECORD
    x, y: SINGLE;
  END;

(* Definimos una pelota. *)
  TPelota = RECORD
    Posicion, Velocidad: TVect2D
    ...
  END;

VAR
(* La pelota. *)
  Pelota: TPelota;
(* Fuerza gravitatoria. *)
  FuerzaG: TVect2D = (x: 0; y: 0.01); { Seguro que hay que ajustarla...}

(* Suma de vectores. *)
  PROCEDURE SumaVector2D (VAR Resultado: TVect2D; CONST V1, V2: TVect2D); INLINE;
  BEGIN
    Resultado.x := V1.x + V2.x;
    Resultado.y := V1.y + V2.y;
  END;


(* El meollo de la cuestión. *)
  PROCEDURE AnimaPelota;
  BEGIN
  { Movemos la pelota a la nueva posición. }
    SumaVector2D (Pelota.Posicion, Pelota.Posicion, Pelota.Velocidad);
  { Calculamos nueva velocidad. }
  { Primero, colisiones. }
    IF Pelota.Posicion.x <= 0 THEN
    BEGIN
      Pelota.Posicion.x := 0; { Para que no atraviese la pared. }
      Pelota.Velocidad.x := Posicion.Velocidad.x * (-1);
    END;
    IF Pelota.Posicion.x >= AnchoPantalla THEN
    BEGIN
      Pelota.Posicion.x := AnchoPantalla; { Para que no atraviese la pared. }
      Pelota.Velocidad.x := Posicion.Velocidad.x * (-1);
    END;
  { Hacer lo mismo con la parte superior y la inferior, pero no voy a escribirlo
    porque es muy parecido.  }
  { Ahora, la fuerza gravitatoria. }
    SumaVector2D (Pelota.Velocidad, Pelota.Velocidad, FuerzaG);
  END;

Más o menos. Si se quiere hacer absolutamente realista habría que andarse con normales, módulos, producto escalar, producto matricial... Pero para un caso simple como este esto es más que suficiente (estrictamente hablando es una optimización* del cálculo vectorial y matricial implicado).
__________________________

* Si hay algún físico en la sala seguro que me desacreditará dada la extrema simplificación, porque la cosa es algo más complicada a lo que explico, pero para lo que se necesita aquí es suficiente.