Vea el Tutorial de Objeto para más información sobre la creación básica de un objeto.

Aquí vamos a registrar el proceso de llamada de retorno en dos relojes diferentes solo con propósitos didácticos. Todos los objetos son actualizados desde el mismo reloj. ¹⁾

El primer reloj corre a 0.01s por tictac (100 Hz) y el segundo corre a 0.2s por tictac (5 Hz).

Sí presionas las teclas ARRIBA, ABAJO y DERECHA, podrás alterar el tiempo del primer reloj. Este será actualizado al mismo tiempo, pero el tiempo para la llamada de retorno del reloj será modificado.

Esto permite de forma fácil adicionar distorsión al tiempo y tener varias partes de la lógica actualizándose en diferentes frecuencias. Un reloj puede tener tantas llamadas de retornos registradas como quieras, con un parámetro de contexto opcional.

Por ejemplo, el contador FPS mostrado en la esquina arriba izquierda es calculado con un reloj no-alterado que corre a 1Hz.

Cuando usamos orx, no necesitamos escribir un

while(1){}

ciclo global para actualizar nuestra lógica. Lo que hacemos es crear un reloj ²⁾, especificando su frecuencia de actualización.

Podemos crear cuantos relojes querramos, debemos asegurarnos que la parte más importante de nuestra lógica (jugadores, enemigos …) serán actulizados frecuentemente, mientras que el código de baja prioridad (objetos no interactivos, fondos…) será llamado una ves en el ciclo (while(1){}). Por ejemplo, la física y la representación de gráficos usan dos relojes diferentes que tiene frecuencias distintas.

Existe otra gran ventaja en usar varios relojes pues podemos facilmente obtener distorción del tiempo.

En este tutorial, crearemos dos relojes, uno que corre a 100Hz (período = 0.01s) y otro a 5Hz (período = 0.2s).

orxCLOCK *pstClock1, *pstClock2;
 
pstClock1 = orxClock_Create(orx2F(0.01f), orxCLOCK_TYPE_USER);
 
pstClock2 = orxClock_Create(orx2F(0.2f), orxCLOCK_TYPE_USER);

Note que pasamos el tipo orxCLOCK_TYPE_USER para poder obtenerlo más tarde (si no queremos almacenarlo), desde cualquier lugar en nuestro código. Cualquier valor por encima de este es válido. Los más bajos son reservados para uso interno del motor.

Ahora usaremos el mismo actualizador de llamada de retorno para los dos relojes. Sin embargo, vamos a definir diferentes contextos, por lo tanto el primer reloj modificará al primer objeto y el segundo reloj al otro objeto:

orxClock_Register(pstClock1, Update, pstObject1, orxMODULE_ID_MAIN, orxCLOCK_PRIORITY_NORMAL);
 
orxClock_Register(pstClock2, Update, pstObject2, orxMODULE_ID_MAIN, orxCLOCK_PRIORITY_NORMAL);

Esto significa que nuestra llamada de retorno será ejecutada 100 veces por segundo con pstObject1 y el segundo será ejecutado 5 veces por segundo con el objeto pstObject2.

Como nuestro actualizador de llamada de retorno solamente rota el objeto que se obtiende del parametro “contexto”, tendremos como resultado dos objetos que rotan a la misma velocidad. Sin embarbo, la rotación del segundo objeto se hace en mayor tiempo (5 Hz) que el primero (100 Hz) por lo que obtenemos diferentes velocidades de rotación.

Ahora veamos el código de la llamada de retorno.

Lo primero: necesitamos obtener nuestro objeto desde parametro “contexto”.
Como orx usa OOP en C, necesitamos castearlo usando un ayudante de casteo que verificará el objeto.

pstObject = orxOBJECT(_pstContext);

Sí retorna NULL, el parametro es incorrecto o no es un orxOBJECT.

Nuestro próximo paso será aplicar rotación al objeto.

orxObject_SetRotation(pstObject, orxMATH_KF_PI * _pstClockInfo->fTime)

Veamos que aquí usaremos el valor tomado de nuestro reloj.
Esto es porque toda nuestra lógica esta relacionada con relojes.

Por supuesto, existe una mejor forma de dar rotación a un objeto ³⁾.
Pero volvamos a lo que nos interesa: reloj y distorción del tiempo!

En nuestro actualizador de llamada de retorno, además encuestaremos las entradas activas. Las entradas son cadenas de caracteres que están atadas, en cada fichero de configuración o por código, a teclas precionadas, botones del ratón o incluso botones de joystick.

En nuestro caso, si las teclas “arriba” o “abajo” son precionadas, cambiaremos el valor del tiempo para el primer reloj que habiamos creado.
Si “derecha” o “izquierda” son presionadas, pondremos el reloj ala frecuencia original.

Como no guardamos el primer reloj creado ⁴⁾, necesitamos como obtenerlo devuelta!

pstClock = orxClock_FindFirst(orx2F(-1.0f), orxCLOCK_TYPE_USER);

Esto retornará el primer reloj creado con el tipo orxCLOCK_TYPE_USER y el périodo 1.0, el cual actualiza nuestro primer objeto.

Ahora, si precionamos las teclas explicadas, cambiaremos la velocidad del releoj en un factor de 4x.

if(orxInput_IsActive("Faster"))
{
  /* Hace al reloj ir 4 veces más rápido */
  orxClock_SetModifier(pstClock, orxCLOCK_MOD_TYPE_MULTIPLY, orx2F(4.0f));
}

De la misma manera hacemos esto para definir un factor de 4x pero más lento.

else if(orxInput_IsActive("Slower"))
{
  /* Hace al reloj ir 4 veces más lento */
  orxClock_SetModifier(pstClock, orxCLOCK_MOD_TYPE_MULTIPLY, orx2F(0.25f));
}

Por último, queremos poner el tiempo normal cuando precionemos la tecla asignada.

else if(orxInput_IsActive("Normal"))
{
  /* Remueve los modificadores del reloj */
  orxClock_SetModifier(pstClock, orxCLOCK_MOD_TYPE_NONE, orxFLOAT_0);
}

Como puedes ver, la distorcion del tiempo puede hacerce con solo una línea de código. Como nuestra parte lógica se encarga de rotar el objeto modificado por el tiempo, vemos la rotacion del primer objeto cambiar basandoce en el valor modificado del reloj.

Por ejemplo esto puede usarce de la misma manera para enlentecer a los mounstruos mientras el jugador se mueve a la misma velocidad. Existen otros tipos de modificadores de reloj pero los veremos mas adelante.

Código fuente: 02_Clock.c

Fichero de configuración: 02_Clock.ini