DevZing

No, no estaba muerto… bueno, quizás un poco, pero ahora que tengo más tiempo espero volver a actualizar el blog más a menudo. Y para empezar no hay nada mejor que un post-publicidad sobre el proyecto en el que he estado metido estos meses y que ha sido una de las causas de que DevZing no diera señales de vida: ARM9Core

¿Y qué es ARM9Core? Pues es el proyecto final de carrera que he estado haciendo junto con otros dos compañeros, es una librería que permite emular el microprocesador ARM9 (que es, por ejemplo, el que tiene la Nintendo DS), y que puede usarse dentro de aplicaciones mayores que necesiten emular el comportamiento de máquinas basadas en ese procesador (como por ejemplo… no sé… la DS )

Algunas “features”:

• Diseñado para funcionar en tiempo real.
• Soporte para regiones de memoria, restricciones de acceso, etc…
• Soporta interrupciones y todos los modos de ejecución del ARM.
• Permite personalizar el tratamiento de interrupciones y del sistema de memoria al usuario.
• Se integra muy bien en aplicaciones mayores y se hace amigo enseguida de las otras clases.
• Puede emular sistemas multicore.
• Se puede usar para depuración, ejecución paso a paso, etc…

Como véis, no es porque yo haya trabajado en él, es que el ARM9Core es una maravilla. Y además es Open Source. Y además en la página tenéis la memoria del proyecto, una impresionante muestra de 100 páginas de absurda prosa ingenieril. ¿A qué estáis esperando?

Comments(0)

Seguro que todos los que alguna vez hayais programado en C o C++ conocereis a la funcion “printf”, que se usa para imprimir un texto por pantalla. Printf es un tanto especial, porque podemos pasarle un número cualquiera de parámetros sin que proteste. Este tipo de funciones usan una lista de argumentos variable. Printf se define asi:

int printf (const char *fmt, … );

Los tres puntos (…) son la elipsis, y lo que indican es que ahi va una serie de parámetros, que en principio desconocemos y van dados por el programador que usa la función. Esto hace a una función como “printf” mucho más flexible que otra como, por ejemplo, “puts”, y por eso es tan usada. ¿Pero cómo funcionan las listas de argumentos variables?

(Read the article)

Comments(2)

Nueva entrega de los tutoriales. De nuevo lamento la larga espera (provocada por la falta de tiempo libre, como siempre, y porque hablar de los dirty rectangles siempre me ha dado algo de pereza ) y espero que la disfruteis, porque ya me queda poco para terminar la serie.

Programación Gráfica 2D (IX) - Picking y Dirty Rectangles

Y aquí el enlace a la versión en PDF

Comments(5)

Por fin, esta vez me ha llevado bastante tiempo (más que nada, por falta de tiempo libre), pero aquí tenéis otra nueva entrega de la serie:

Programación Gráfica 2D (VIII) - Bichos y tochos

Y como siempre, el enlace en PDF

Espero que os guste!

Comments(0)

El control del tiempo en cualquier tipo de programa que funcione en tiempo real es fundamental, y más en un juego, donde tenemos tiempos de fotogramas del orden de unos pocos milisegundos, y que si no calculamos bien puede provocar errores, o movimientos poco fluidos, etc…

Por regla general, se puede usar una función como GetTickCount (), que devuelve el número de milisegundos transcurridos desde el arranque del sistema, y olvidarse del tema.

El problema de GetTickCount () es que, para valores muy pequeños, no suele ser preciso, pues su resolución puede ser de hasta varios ms. En el caso de los juegos, donde un fotograma puede durar menos de 15ms, este error puede ser muy significativo.

Así que necesitamos un temporizador con una resolución mayor. Y eso es precisamente lo que nos dan QueryPerformanceCounter () y QueryPerformanceFrequency (), un método para medir el tiempo con una precisión de menos de 1ms.

QPC devuelve el valor del contador de alta precisión, y QPF su frecuencia (en nº de ciclos por segundo). Ambas usan LARGE_INTEGERs, enteros de 64 bits que dependiendo del compilador son o no soportados nativamente.

El proceso para medir el tiempo usando estas funciones es bastante sencillo:

LARGE_INTEGER a, b, frecuencia;

//Obtenemos el valor de la frecuencia
QueryPerformanceFrequency (&frecuencia);

//Tomamos la medida inicial
QueryPerformanceCounter (&a);

//CODIGO

//Tomamos la medida final
QueryPerformanceCounter (&b);

//Calculamos la diferencia, y la dividimos por la frecuencia
double segundos = (b.QuadPart - a.QuadPart) / frecuencia.QuadPart;

El campo “QuadPart” es un entero de 64 bits, y si el compilador no lo acepta habrá que trabajar en su lugar con LowPart y HighPart. En cualquier caso, yo nunca he tenido ese problema.

Otra cosa a tener en cuenta si estais adaptando desde GetTickCount () es que la frecuencia de QPF va en ciclos / segundo. Por lo que al dividir, la medida de tiempo que se obtiene viene en segundos, y no en ms como la de GetTickCount ().

Y una última observación: La frecuencia se suele calcular al principio y dejar guardada en una variable, porque se supone que no va a cambiar. Normalmente es así, pero no siempre. Pensad en los portátiles con sistemas que reducen el consumo de energía precisamente variando la frecuencia del micro, en esos casos puede que sea interesante controlar si la frecuencia ha cambiado o no.

Un sistema que funciona es tomar la medida tanto con QPC/QPF como con GetTickCount (), y comparar los resultados. Si son demasiado distintos (por ejemplo, medio segundo de diferencia entre uno y otro), entonces se puede suponer que QPC/QPF ha fallado, y sería momento de volver a calcular la nueva frecuencia.

Comments(1)

Un nuevo tutorial sobre el mismo proyecto, sólo que esta vez he cambiado de registro y en lugar de hablar de gráficos, hablo del sistema de inteligencia artificial. Espero que si alguien está haciendo un juego parecido le pueda servir de ayuda.

Diseñando la I.A. de un juego tipo Tycoon

Y aquí el enlace en PDF

Un saludo!

Comments(1)

El otro día estuve leyendo un artículo muy interesante en Gamasutra (es posible que haya que registrarse para verlo), acerca de cómo simular los cambios de opiniones e ideas en una población artificial.

Se trata de tomar las opiniones de la gente como si fueran una manada, y se movieran más o menos en conjunto. Para ello, se aplica el algoritmo de los Boids, sólo que en lugar de hablar de movimiento en un espacio, se habla de alineamiento respecto a una idea.

Las aplicaciones de algo así serían muy interesantes, y por ejemplo, me gustaría ver un juego de estrategia en el que no sólo haya que conquistar ciudades, sino también el apoyo del pueblo para mantenerse en el poder. En que tengas que controlar los medios de comunicación e iniciar campañas políticas, en que el jugador elija entre desprestigiar a sus opositores, o eliminarlos directamente, etc…

En resumen, leed el artículo, que merece la pena

Comments(0)

Otra entrega más. Esta (y las que vengan detrás) no son parte de la serie original, y las he escrito después de acabar el proyecto. Así que irán más orientadas a explicar qué soluciones implementamos nosotros concretamente, y como resolvimos ciertos problemas, etc…

Programación Gráfica 2D (VII) - Más sobre tilesets

Aquí teneis el enlace para bajarlo en PDF

Un saludo!

Comments(1)

Gracias a Harko, que se ha tomado la molestia de pasar los tutoriales a un formato más cómodo para imprimir, ahora están todos disponibles en PDF. Teneis los enlaces para descargarlos en la página de tutoriales.

Muchas gracias!

Comments(3)

Se ha hecho esperar, pero ya está disponible la sexta entrega de la serie de tutoriales sobre programación isométrica bajo SDL:

Programación Gráfica 2D (VI) - Mousemapping y optimizaciones

Espero que os sea útil, un saludo!

Comments(2)