[Ñuño Martínez]

Empezado por elpupas7

Resumiendo.
a. No hay ocultación por ningún sitio.
b. No falta información.

Discrepo: no has dado información "vital" en tus tres primeros mensajes, por lo que no sabíamos qué estás buscando o cuál es tu problema. Ahora que ya está aclarado ese punto, pues hay menos ocultación.

Referente a lo del código fuente, como bien dices es propiedad del autor del mismo y se hará lo que este quiera, pero me parece bastante inútil no publicarlo en este caso puesto que el rendimiento depende mucho de la implementación (por ejemplo, ¿usa listas simples o enlazadas para almacenar y recorrer los objetos? ¿Los objetos son bitmaps, vectoriales, poligonales...? ¿Para evitar parpadeos usa doble-buffer, triple-buffer, paginación, copia, dirty-rectangles... o da igual si parpadea o no?). Si lo que se busca es comparar el rendimiento de dos motores/bibliotecas/compiladores diferentes (o de sus distintas combinaciones) es imprescindible saber qué algoritmos utiliza (nótese el plural de "algoritmos"). Un cambio en una sóla línea puede afectar dramáticamente al rendimiento, así como las muchas opciones de compilación existentes: manejo de pilas, marcos de memoria, cachés, microprocesador de destino, etc. Y ojo, que un algoritmo/opción que funcione "bien" con un motor puede funcionar "mal" en otro, y viceversa.

Voy a aportar mi granito de arena con un ejemplo que colgué en esta página de la Wiki de Allegro.pas, para mostrar el uso de "timers". A partir de él es fácil crear un programa que haga lo que pides usando Allegro.pas.

Código Delphi [-]
(* An example to keep speed on different computers. *)
PROGRAM timers2;
 
USES
  allegro, sysutils;
 
TYPE
(* Defines the ball "sprite". *)
  TSprite = RECORD
  (* Center. *)
    X, Y,
  (* How it is. *)
    Color,
  (* Movement. *)
    SpeedX, SpeedY: INTEGER;
  END;
 
 
 
VAR
(* Count how many ticks are in queue. *)
   CntTicks: INTEGER;
(* Some color "constants". *)
   BackgroundColor, ShadowColor: INTEGER;
(* Ball values. *)
   Ball: ARRAY [1..10] OF TSprite;
(* DoubleBuffer. *)
   BackBuffer: AL_BITMAPptr;
   CntBall: INTEGER;
 
 
 
(* Helper for errors.  Ensures a clean exit. *)
  PROCEDURE RaiseError (Message: STRING);
  BEGIN
    al_message (Message);
    al_exit;
  END;
 
 
 
(* Interruption procedure: adds one tick to the ticks queue. *)
  PROCEDURE IntTicks; CDECL;
  BEGIN
    INC (CntTicks);
  END;
 
 
 
(* Program starts here. *)
BEGIN
{ Initialization. }
  IF NOT al_init THEN
  BEGIN
    WriteLn ('Error initializing Allegro!');
    EXIT;
  END;
  IF NOT al_set_gfx_mode (AL_GFX_SAFE, 640, 480, 0, 0) THEN
  BEGIN
    RaiseError ('Can''t initialize graphics mode');
    EXIT;
  END;
  BackBuffer := al_create_bitmap (AL_SCREEN_W, AL_SCREEN_H);
  IF BackBuffer = NIL THEN
  BEGIN
    RaiseError ('Can''t create double buffer!');
    EXIT;
  END;
  ShadowColor := al_makecol (0, 0, 0);
  BackgroundColor := al_makecol (255, 255, 255);
  al_install_keyboard;
{ Installs the timer interrupt.  Executes it 50 times each second. }
  al_install_timer;
  IF NOT al_install_int_ex (@IntTicks,  AL_BPS_TO_TIMER (50)) THEN
  BEGIN
    RaiseError ('Can''t intall timer interruption');
    EXIT;
  END;
{ Initialize balls. }
  Randomize;
  FOR CntBall := 1 TO 10 DO
  BEGIN
    Ball[CntBall].X := Random (AL_SCREEN_W - 50) + 25;
    Ball[CntBall].Y := Random (AL_SCREEN_H - 50) + 25;
    Ball[CntBall].Color := al_makecol (Random (64) * 3, Random (64) * 3, Random (64) * 3);
    REPEAT
      Ball[CntBall].SpeedX := Random (8) - 4;
      Ball[CntBall].SpeedY := Random (8) - 4;
    { To prevent static balls. }
    UNTIL (Ball[CntBall].SpeedX <> 0) AND (Ball[CntBall].SpeedY <> 0);
   END;
{ Main loop. }
  CntTicks := 1; { One tick in queue. }
  REPEAT
  { If there are ticks in the queue, updates the animation. }
    WHILE CntTicks > 0 DO
    BEGIN
      FOR CntBall := 1 TO 10 DO
      BEGIN
      { Animates the ball. }
        INC (Ball[CntBall].X, Ball[CntBall].SpeedX);
        INC (Ball[CntBall].Y, Ball[CntBall].SpeedY);
      { Collision. }
        IF ((Ball[CntBall].X < 25) AND (Ball[CntBall].SpeedX < 0))
        OR ((Ball[CntBall].X > AL_SCREEN_W - 25) AND (Ball[CntBall].SpeedX > 0))
        THEN
          Ball[CntBall].SpeedX := -Ball[CntBall].SpeedX;
        IF ((Ball[CntBall].Y < 25) AND (Ball[CntBall].SpeedY < 0))
        OR ((Ball[CntBall].Y > AL_SCREEN_H - 25) AND (Ball[CntBall].SpeedY > 0))
        THEN
          Ball[CntBall].SpeedY := -Ball[CntBall].SpeedY;
      END;
    { One tick less. }
      DEC (CntTicks);
    { If there are more than 25 frames in queue then may be the computer is too much slow! }
      IF CntTicks > 25 THEN
      BEGIN
        RaiseError ('Your computer is too much slow and I can''t keep the rithm!');
        EXIT;
      END;
    END;
  { Updates screen. }
    al_clear_to_color (BackBuffer, BackgroundColor);
    FOR CntBall := 1 TO 10 DO
      al_circlefill (BackBuffer, Ball[CntBall].X + 2, Ball[CntBall].Y + 2, 25, ShadowColor);
    FOR CntBall := 1 TO 10 DO
      al_circlefill (BackBuffer, Ball[CntBall].X, Ball[CntBall].Y, 25, Ball[CntBall].Color);
    al_vsync; { To prevent "waveing". }
    al_blit (BackBuffer, al_screen, 0, 0, 0, 0, AL_SCREEN_W, AL_SCREEN_H);
  { Until user press a key. }
  UNTIL al_keypressed;
{ End. }
  al_exit;
END.

Ojo que usa "timers" para mantener la velocidad de la animación lo más constante que se pueda, por lo que habría que quitarlo para obtener la máxima velocidad, aparte de añadir más interacción para que el usuario "añada" o "elimine" bolas para comprobar cómo afecta al rendimiento, poner un contador de bolas, etc. Además, usa un doble-buffer simple que puede mejorarse muchísimo (paginación y/o triple-buffer o simplemente añadir dirty-rectangles aceleraría mucho la cosa) y seguro que pueden optimizarse otro montón y medio de cosas. Ahora no voy a hacerlo porque estoy en el curro, y luego... Bueno, hay un par de bugs en Allegro.pas que requieren mi atención "urgentísimamente", así que por ahora no haré mucho más.