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.

In our case, if the up or down arrow keys are pressed, we'll strecthed the time for the first clock that has been created.
If left or right arrow keys are pressed, we'll remove the stretching and go back to the original frequency.

As we didn't store our first created clock ⁴⁾, we need to get it back!

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

Specifying -1.0f as desired period means we're not looking for a precise period but for all clocks of the specified type. It'll return the first clock created with the orxCLOCK_TYPE_USER type, which is the one updating our first object.

Now, if the “Faster” input is active(ie. up arrow key is pressed), we'll speed our clock with a factor 4X.

if(orxInput_IsActive("Faster"))
{
  /* Makes this clock go four time faster */
  orxClock_SetModifier(pstClock, orxCLOCK_MOD_TYPE_MULTIPLY, orx2F(4.0f));
}

In the same way we make it 4X slower than originally by changing its modifier when “Slower” input is active (ie. down arrow pressed).

else if(orxInput_IsActive("Slower"))
{
  /* Makes this clock go four time slower */
  orxClock_SetModifier(pstClock, orxCLOCK_MOD_TYPE_MULTIPLY, orx2F(0.25f));
}

Lastly, we want to set it back to normal, when the “Normal” input is active (ie. left or right arrow key pressed).

else if(orxInput_IsActive("Normal"))
{
  /* Removes modifier from this clock */
  orxClock_SetModifier(pstClock, orxCLOCK_MOD_TYPE_NONE, orxFLOAT_0);
}

And here we are!
As you can see, time stretching is achieved with a single line of code. As our logic code to rotate our object will use the clock's modified time, we'll see the rotation of our first object changing based on the clock modifier value.

This can be used in the exact same way to slow down monsters while the player will still move as the same pace, for example. There are other clock modifiers type but they'll be covered later on.

Source code: 02_Clock.c

Config file: 02_Clock.ini