¿Os acordais de SkyNET? La perversa IA que crea el caos y la destruccion en Terminator. Ahora teneis la oportunidad de colaborar en el desarrollo de una inteligencia artificial capaz de liderar y defenderse de un ataque nuclear. El juego DEFCON.

El IEEE Symposium Computational on Intelligence  and Games (CIG para los amigos) ha puesto en marcha un concurso en el que se trata de construir un agente de IA(bot) que permita manejar las unidades y los edificios. La finalidad es causar el mayor numero de bajas perdiendo al minimo.

Ataque en Defcon

Robin Baumgarten ha creado una API que permite trabajar con el juego orientada a crear Bots que cntrolen los sistemas.

Para ello se debe descargar la version de prueba del juego que permite realizar todo lo que necesitemos.

• Descarga el juego
  

La informacion de la API la podemos obtener aqui:

• API del juego

Poco a poco se iran dando detalles de esta iniciativatan interesante.A lo mejor alguno de vosotros gana la competicion este año. ¿Quien sabe?

Hasta la proxima

Hola AI Padawans,

Hoy hablaremos de un algoritmo muy utilizado en la inteligencia artificial, el A* o ‘a estrella’. Mediante este algoritmo pretendemos realizar una búsqueda en nuestro espacio de soluciones de una forma más eficaz, es decir, con conocimiento de causa.

En primer lugar a grandes rasgos comentar que para que el algoritmo funcione se debe poder establecer un valor de calidad a la solución parcial actual, es decir, un estimador o heurístico. Cada nueva solución propuesta tendrá su propio valor de calidad, lo que determinará el orden en el que la evaluaremos y continuaremos buscando.

De este modo, el algoritmo A* utiliza una función de evaluación f(n) = g(n) + h‘(n), donde h‘(n) representa el valor heurístico del nodo a evaluar desde el actual, n, hasta el final, y g(n), el coste real del camino recorrido para llegar a dicho nodo, n.

A* mantiene dos estructuras de datos auxiliares, que podemos denominar nodos abiertos, implementado como una cola de prioridad (ordenada por el valor f(n) de cada nodo), y nodos cerrados, donde se guarda la información de los nodos que ya han sido visitados. En cada paso del algoritmo, se expande el nodo que esté primero en abiertos, y en caso de que no sea un nodo objetivo, calcula la f(n) de todos sus hijos, los inserta en abiertos, y pasa el nodo evaluado a cerrados.

En resumen, buscamos primero en los más prometedores teniendo en cuenta lo que nos cuesta llegar a la solución parcial y lo que estimamos que nos costará llegar a la solución final.

El algoritmo es una combinación entre búsquedas del tipo primero en anchura con primero en profundidad: mientras que h‘(n) tiende a primero en profundidad, g(n) tiende a primero en anchura. De este modo, se cambia de camino de búsqueda cada vez que existen nodos más prometedores.

El pseudocódigo será:

ABIERTOS := [INICIAL] 	   //inicialización
CERRADOS := []
f'(INICIAL) := h'(INICIAL)
repetir
   si ABIERTOS = [] entonces FALLO
   si no                           // quedan nodos
      extraer MEJORNODO de ABIERTOS con f' mí­nima
         // cola de prioridad
      mover MEJORNODO de ABIERTOS a CERRADOS
      si MEJORNODO contiene estado_objetivo entonces
         SOLUCION_ENCONTRADA := TRUE
      si no
         generar SUCESORES de MEJORNODO
         para cada SUCESOR hacer TRATAR_SUCESOR
hasta SOLUCION_ENCONTRADA o FALLO

Qué tiene que ver el Super Mario en todo esto. Pues bien para ver el ejemplo práctico de aplicación hay que ver algo que nos convenza de la utilidad y de la aplicación práctica del mismo. Con este propósito se muestra la Mario AI Competition, un concurso de desarrolladores de IA para juegos donde la finalidad es generar un Mario Inteligente capaz de sortear a los enemigos.

ABIERTOS := [INICIAL] 	   //inicialización
CERRADOS := []
f'(INICIAL) := h'(INICIAL)
repetir
   si ABIERTOS = [] entonces FALLO
   si no                           // quedan nodos
      extraer MEJORNODO de ABIERTOS con f' mí­nima
         // cola de prioridad
      mover MEJORNODO de ABIERTOS a CERRADOS
      si MEJORNODO contiene estado_objetivo entonces
         SOLUCION_ENCONTRADA := TRUE
      si no
         generar SUCESORES de MEJORNODO
         para cada SUCESOR hacer TRATAR_SUCESOR
hasta SOLUCION_ENCONTRADA o FALLO

Como veis las lineas rojas son las estimaciones de posición futura. En la pasada edición el algoritmo A* ganó la convocatoria. Se trata de calcular sobre el modelo de Mario en Java un agente o entidad inteligente capaz de hacer que Mario llegue lo más rápido y lejos posible.

En este último documento se incluye la presentación del evento, de sus participantes y de sus estrategias predefinidas. Entre ellas una gran descripción de la utilizada por el ganador, Robin Baumgarten, el A Estrella.

>> GIC2009Competition

Veremos más detalles más adelante!

Hasta la próxima!

Visto el backtracking vamos un poco más allá con uno de los algoritmos utilizados en la IA y
con más medida en la IA orientada al entretenimiento, el minimax.

En teoría de juegos, Minimax es un método de decisión para minimizar la pérdida máxima esperada en juegos con adversario y con información perfecta. Este cálculo se hace de forma recursiva.

El funcionamiento de Minimax puede resumirse como elegir el mejor movimiento para ti mismo suponiendo que tu contrincante escogerá el peor para ti.

La receta del algoritmo Minimax:

• 1. Generación del árbol de juego. Se generarán todos los nodos hasta llegar a un estado terminal o determinando una profundidad concreta.

Vamos aplicando el algoritmo por un número fijo de iteraciones hasta alcanzar una determinada profundidad. En estas aplicaciones la profundidad suele ser el número de movimientos o los incluso el resultado de aplicar diversos pasos de planificación en un juego de estrategia.

• 2. Cálculo de los valores de la función de utilidad para cada nodo terminal.

Para cada resultado final, cómo de beneficioso me resulta si estamos en MAX o cuanto me perjudicará si estamos en MIN.

• 3. Calcular el valor de los nodos superiores a partir del valor de los inferiores. Alternativamente se elegirán los valores mínimos y máximos representando los movimientos del jugador y del oponente, de ahí el nombre de Minimax.

• 4 . Elegir la jugada valorando los valores que han llegado al nivel superior.

El algoritmo explorará los nodos del árbol asignándoles un valor numérico mediante una función de utilidad, empezando por los nodos terminales y subiendo hacia la raíz. La función de utilidad como se ha comentado, definirá lo buena que es la posición para un jugador cuando la alcanza.

Versiones más avanzadas como el minimax con poda alfa beta hacen que se reduzca considerablemente el número de nodos a visitar por lo que el tiempo de cálculo se reduce ampliamente.

Y para terminar comentar un ejemplo cásico, el tres en raya (juego del gato, tatetí, triqui, tres en gallo, michi, la vieja o tic tac toe). Se trata de hacer una fila de tres para ganar y evitar que el oponente la haga antes que tu.

Al aplicar el algoritmo, se suceden una serie de estados que se resumen en la fotografía. Un estado -1 significa que MAX gana, 0 empate o -1 pierde.

Se distinguen los nodos terminales con jugada finalizada y los del trayecto. En este juego se puede llegar a la profundidad máxima puesto que se trata de 9 movimientos fijos, en otros como el ajedrez o las damas es muy necesario limitar la profundidad y aplicar medidas que aumenten la eficiencia.

El código se adjunta en python muy comentado. El bloque principal, y a partir de ahi todo lo demás en el documento adjunto, es el siguiente:

b = Board()
turn = 1
while True:
print “Turno %i.” % turn
jugadorHumano(b, Jugador_X)
if b.gameOver():
break

jugadorMaquina(b, Jugador_O)
if b.gameOver():
break
turn += 1

Donde se crea una instancia del tablero, necesaria para detallar los elementos que intervienen en juego y e ir aplicando el algoritmo. Se pueden intercambiar jugadores o incluso hacer que jueguen dos máquinas o dos humanos simplemente modificando estas lineas de arriba.

En resumen.

• El minimax aporta una herramienta de proceso recursiva muy útil
• Se pueden aplicar modificaciones al algoritmo para hacerlo más eficiente

En el tres en raya:

• Gana el 1, pierde el -1 y empate 0
• La profundida máxima es de 9, como el número de jugadas posible
• La cota superior de nodos a visitar es en el peor caso (primer movimiento) 9 factoria -A> 9!
• No hay restricciones sobre la validez de un movimiento, simplemente que no se haya hecho antes, por lo que el coste del cálculo es bajo (no hay que aplicar reglas complejas).
• Almacenar las soluciones intermedias no es excesivamente complejo
• Generar los diferentes tableros con las soluciones intermedias a explorar no es costoso pero podría ser un problema en otros juegos y limitar la profundidad por memoria
• La máquina nunca pierde, el juego está completado
• Las partidas entre jugadores máquina siempre quedan en tablas.

El tiempo que tarda un jugador pc en procesar la primera jugada es de 4047,181 ms en un ordenador medio, el que tarda cuando procesa la jugada que lo hace ganador en el último movimiento 0,568 ms y cuando procesa la que lo deja en tablas 0,337. La diferencia de tiempo de cálculo entre los primeros movimientos cuando quedan muchas opciones y el resto es 8000 veces mayor, por lo que el tema de la eficiencia habrá que tocarlo.

El próximo tema trataremos el concepto de agente y probaremos con otro juego. Que lo disfruteis !!!

• tictactoeia

Aquí estamos de nuevo tras una pausa de no haber publicado nada del tutorial de openGL. El tiempo es limitado y las cosas que uno tiene que hacer a veces supera ese tiempo.

En este capítulo lo que haremos es rotar una figura bidimensional en alguno de sus ejes. Concretamente el triángulo en el eje de las x y el cuadrilátero en el eje de las y. Las modificaciones al código anterior son pocas. Recordemos que los métodos de inicialización y manejo de la ventana son idénticos que en el resto de publicaciones.

Recordemos el código del método DrawGLScene del capítulo anterior:

Si hacemos memoria este código lo que hacía era dibujar en nuestra ventana OpenGL dos figuras geométricas básicas distanciadas en el eje de las x: un triángulo con un degradado de color (debido a la imposición de diferentes colores en sus vértices) y un cuadrilátero con un único color (debido a la imposición de color a nivel de figura).
En esta publicación introduciremos el concepto de rotación. La rotación en OpenGL se hace mediante la función glRotatef. La definición de la función es la siguiente:

donde angle especifica el ángulo de rotación en grados y x,y y z definen las coordenadas x,y,z de un vector.
glRotate produce una rotación en un ángulo determinado alrededor de un vector (x,y,z). La matriz actual (dada por glMatrizMode) es multiplicada por la matriz de rotación reemplazando la actual matriz por el resultado del producto. Si la matriz actual es GL_MODELVIEW o GL_PROJECTION todos los objetos dibujados después de la llamada a glRotate serán rotados. Si queremos salvar nuestro sistema de coordenadas sin rotar podemos guardar la matriz previa a la modificación en una pila con la función glPushMatrix y recuperarla posteriormente con glPopMatrix.
Por tanto, nuestro código anterior donde únicamente se veía dos figuras estáticas coloreadas puede cambiar a ser dinámicas con una simple modificación:

Como podemos observar, al triángulo lo rotamos rtri sobre el vector (0,1,0) o lo que viene a ser lo mismo que decir que modificamos en rtri el eje de las y. Al cuadrilátero le modificamos en rquad el vector (1,0,0) o lo que viene a ser que modificamos en rquad el eje de las x. Cada vez que GLU llama a GLScene (cada vez que necesita redibujar la escena) rtri se incremente en 1 grado y rquad se decrementa en un grado y da esa sensación de movimiento.

¿Cansados ya de figuras en el plano bidimensional? En la próxima entrega ya entraremos en el plano tridimensional y crearemos a partir del cuadrilátero, un cubo; y del triángulo, un cono y las haremos rotar en el espacio tridimensional.

¡hasta entonces!

Después de una semana de ansiona espera (supongo) aquí llega la cuarta entrega del tutorial de OpenGL basado en Python. En esta entrega iremos un paso más allá ahora que ya comprendemos todo lo que necesitamos para crear un programa OpenGL. Si no lo recordamos, haré algo de memoria:
Para crear un contexto OpenGL con todo lo necesario necesitaremos de tres métodos obligatorios y uno opcional básicos:

• método InitGL: inicializa OpenGL al estado incicial. Ésto supoce inicializar el color de borrado de la pantalla, inicializar el buffer de profundidad (el z-buffer), el smooth shading, la matriz de proyección para dimensionar la ventana y la matriz de vista.
• método ResizeGLScene: La idea de este método es que se active cuando redimensionamos la ventana. Ya la hagamos más grande o más pequeña ha de modificar la matriz de proyección para adaptar la proyección al nuevo tamaño de la ventana y la correspondiente nueva perspectiva del dibujo.
• método DrawGLScene: Este método es el básico de todo el montaje. Es el que define lo que se dibuja en la ventana OpenGL. Depende de lo complejo que sea lo que queramos dibujar, será más elaborado o menos pero aquí es donde se define lo que visualizaremos en la ventana OpenGL. Básicamente borrará el contenido de la ventana, dibujará lo que tenga que dibujar y activará el double buffer para evitar problemas de visualización consecuencia del refresco de la pantalla.
• método KeyPressed: Controla que se pulse la tecla ESC (en nuestro caso).

Una vez implementados estos métodos y inicializada la ventana con glut (el controlador de la ventana) en el constructor de la clase los registramos con los métodos glutXXXFunc para que observe el estado y dispare el método adecuado cuando ocurre el evento.

Una vez hecho este pequeño resumen de lo básico de OpenGL entramos ya en lo que haremos en este segundo tutorial. Básicamente el esqueleto de la aplicación es el mismo a excepción del método DrawGLScene que se amplia con algo más de contenido. Era frustrante ver esas línias de código que parecía que no hiciesen nada. Eso no era cierto, inicializaban el contexto OpenGL pero no dibujaban nada. Que no se vea algo no significa que no exista.

Este cuarto tutorial lo dividiremos en dos partes. La primera, dibujará un triángulo y un cuadrado en dos dimensiones sin relleno de color y, después, modificaremos esa implementación para darle un relleno de color a cada una de esas figuras.

Los métodos principales se conservarán igual que el tutorial anterior ya que han de hacer el mismo trabajo, el único que variará es el DrawGLScene que pasará de no dibujar NADA a dibujar ALGO. Tampoco lo cargaremos de trabajo,la verdad, pero algo hará.

Estas dos llamadas las ha de tener todo método DrawGLScene ya que inicializa los buffers de color y de profundidad dejandolos preparados para comenzar a pintar.

glTranslate produce una translación en (x,y,z). La matriz actual (modelview en este caso) es multiplicada por la matriz de translación reemplazándola en la matriz actual obteniendo así el resultado de la translación. En definitiva, glTranslate reemplaza la matriz de vista del modelo por una matriz transladada dada por el producto del vector (x,y,z) y la propia matriz. Al modificar la matriz todos los objetos entre glBegin y glEnd dibujados después de la llamada a glTranslate serán transladados según defina esta llamada.

glBegin define el inicio de los limitadores de definición de los vértices de las primitiva o grupo de primitivas. Entendiendo como primitivas las figuras geométricas básicas:

n es un tipo entero incremental y N el número total de vértices

• glBegin(GL_POINTS): Trata cada vértice como un punto simple.El vértice n define el punto n. Se dibujarán N puntos.
• glBegin(GL_LINES): Trata cada par de vértices como un segmento linear independiente. Los vértices 2n-1 y 2n formarán las línia n. Se dibujarán un total de N/2 línias.
• glBegin(GL_LINE_STRIP): Dibuja un conjunto de segmentos de línia conectados desde el primer vértice al último. Los vértices n y n+1 definen la línia n. Se dibujarán N-1 línias.
• glBegin(GL_LINE_LOOP): Dibuja un conjunto de segmentos de línia conectados desde el primer vértice al último, entonces vuelve al primero. No obstante, la última línia es definida por los vértices 1 y N. Se dibujarán N línias.
• glBegin(GL_TRIANGLES): Trata cada tres vértices como un triángulo independiente. Los vértices 3n-2, 3n-1 y 3n definirán el triángulo n. Se dibujarán N/3 triángulos.
• glBegin(GL_TRIANGLE_STRIP): Dibuja un grupo conectado de triángulos. Un triángulo es definido por cada vértice presentado después del primero de dos vértices. Para n impar, los vértices n, n+1 y n+2 formarán un triángulo n. Para n par, n+1, n y n+2 formarán un triángulo n. Se dibujarán N-2 triángulos.
• glBegin(GL_TRIANGLE_FAN): Dibuja un grupo conectado de triángulos. Un triángulo es definido por cada vértice presentado después del primero de dos vértices. Los vértices 1, n+1 y n+2 definirán el triángulo n. Se definirán N-2 triángulos.
• glBegin(GL_QUADS): Trata cada grupo de cuatro vértices como un cuadrilatero independiente. Los vértices 4n-3, 4n-2, 4n-1 y 4n definen el cuadrilátero n. N/4 cuadriláteros serán dibujados.
• glBegin(GL_QUAD_STRIP): Dibuja un grupo conectado de cuadriláteros. Un cuadrilátero es definido por cada par de vértices presentados después del primer par. Los vértices 2n-1, 2n, 2n+2 y 2n+1 definen el cuadrilátero n. Se dibujarán (N/2)-1 cuadriláteros. El orden de la información dada para dibujar este tipo de cuadriláteros es diferente al anterior.
• glBegin(GL_POLYGON): Dibuja un polígono simple y convexo. Los vértices 1 hasta el N definen el polígono.

glBegin acepta un solo parámetro que especifica con cuál de los diez tipos de vertices se ha de interpretar.

glVertex es la función que dibuja un vértice (o punto) con tres parámetros x, y y z que son de tipo glFloat.

glEnd define el final de la definición de vértices de la figura o figuras primitivas. Lo que acabamos de hacer nos dibujará un triángulo en las coordenadas definidas ((0.0,1.0,0.0),(1.0,-1.0,0.0),(-1.0,-1.0,0.0)) sin ningún tipo de color de relleno. Ésto sería equivalente a:

Definimos vértices únicamente con las coordenadas x e y.

Transladamos la primitiva que dibujaremos a continuación 3.0 unidades en el eje de las x.

Con el código anterior lo que hemos hecho es definir un cuadrilátero simple representando sus cuatro vértices.

Y como comentamos en el tutorial anterior hemos de activar el double buffer para evitar problemas de representación gráfica dados por el refresco de la pantalla.

Este código lo que hará será dibujar dos figuras sin relleno de color aliniadas en el eje de las x y separadas tres unidades.

En el caso que queramos añadirle color a la figura tendremos que definir el ámbito del color ANTES de llamar a la función que dibuja el vértice o primitiva. En nuestro caso el color del triángulo será de ámbito de vértice y el color del cuadrilátero será de ámbito de primitiva:

glColor3f define el color de lo que se dibujará a continuación basándose en tres parámetros de tipo glFloat que son la cantidad de rojo, verde y azul en el rango [0.0,1.0]. Donde 0.0 es el mínimo y 1.0 es el máximo. Existe otra función que se puede definir el parámetro alpha o de transparencia glColor4f. Esta función tiene un último parámetro que se especifica también en el rango anteriormente definido.

En nuestro código, en el triángulo el color se define a nivel de vértico con lo que la figura se verá con un color de degradado suma de los diferentes colores de los vértices. En cuadrilátero al definirse a nivel de primitiva todo él será del mismo color.

Y con ésto acabamos este cuarto tutorial de OpenGL. En el próximo tutorial hablaremos de rotaciones y movimientos de primitivas.

¡Hasta entonces!

• Fuente en Python
• Fuente en Python

Primero de todo lo que vamos a hacer es adaptar el – a mi entender – uno de los mejores tutoriales de openGL que hay en la red a Python. El tutorial en cuestión es el de NeHe.

Empezaremos por crear una ventana donde no se vea nada. Puede parecer ridículo pero creando un contexto gráfico donde no hay nada podemos ver las funciones esenciales que se necesitan de GLU(T) y openGL.

Nuestro código en Python comienza con:

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys

En el fragmento de código anterior lo que hacemos es importar las funciones de las librerías de pyOpenGL. Concretamente GL,GLU y GLUT. También importamos el módulo sys para trabajar con algunas llamadas al sistema.

Antes de continuar me gustaría definir unos cuantos conceptos que no se ven explícitos en el código Python pero que es bueno comprenderlos ya que en otros lenguajes es necesario definirlos de forma explícita.

El primero de ellos es el Rendering Context (RC) o el Contexto de Renderizado. Todo programa en OpenGL está enlazado a un RC que no es otra cosa que una capa intermedia que enlaza las llamadas a OpenGL con el Device Context (DC) o Contexto Hardware. Para que el tinglado funcione también es necesario definir (explícita o implicitamente) el Contexto Hardware. El Contexto Hardware no es más que otra capa que enlaza la ventana que el llamado GDI (Graphics Device Interface). Por tanto, el RC lo que hace es conectar OpenGL con el DC para tratar lo que en la ventana se haya de visualizar.

Una vez definidos estos conceptos ya podemos continuar con nuestro código. Una vez importadas las librerías necesarias hemos de definir la clase ventana.

class Ventana:

La primera de las variables que hemos definido declara el código de tecla que se utilizará para salir del programa. En nuestro caso, Esc. La segunda variable define el número de la ventana en GLUT.

A continuación definiremos el método que trata lo que ocurre en la ventana cuando la redimensionamos:
Lo primero que vamos a hacer es hacer la definición de la función que admitirá dos parámetros de entrada: el ancho y el alto.

   #glutFullScreen()

• lesson1oo
• opengl-l1
• makefile

Como comenté en el post previo, vamos a empezar a definir la tecnología que utilizaremos.

El lenguaje de programación por excelencia en este tipo de aplicaciones viene a ser C/C++. No obstante doy por supuesto que cualquiera que se hace llamar informático domina ya bastante bien este par de lenguajes. Lo que no dominames es un “nuevo” lenguaje emergente llamado Python. Por ello, orientaré esta serie de tutoriales a este lenguaje. No lo he comentado antes pero TODO absolutamente TODO lo basaré en software libre. Con ello quiero decir que la plataforma en la que trabajo es una Gentoo Linux. No debería haber ninguna diferencia respecto a otras plataformas en las que sigais lo que aquí se dice. Únicamente necesitareis el intérprete Python y sus respectivos módulos, y las versiones adecuadas de las diferentes librerías que utilizaremos para la plataforma que esteis utilizando. Una vez dicho ésto, paso a describir la tecnología en la que nos basaremos:

• Python: Lenguaje de programación de alto nivel diseñado por Guido van Rossum a principios de los años 90. No obstante actualmente es un lenguaje libre que se administra desde la Python Software Foundation. Los programas escritos en Python facilitan la reutilización de código ya que proporciona gran cantidad de módulos estándard. Ésto facilita la tarea al programador el cual únicamente deberá centrarse en la lógica de su problema y no en los problemas que pueda dar el lenguaje. Python es un lenguaje interpretado y multiparadigma. Ésto quiere decir que el código no se compila ni se enlaza, únicamente se interpreta y se ejecuta. Al ser así, el programador se ahorra un tiempo más que considerable en el desarrollo del programa. La propiedad multiparadigma del lenguaje significa que no fuerza a programar en un estilo concreto si no que permite diferentes estilos y será el programador el que elija el que mejor se adecue a su forma de programar. Los paradigmas estándard de Python son la programación orientada a objetos, programación estructurada y la programación funcional. No obstante, mediante el uso de módulos podemos añadirle otros paradigmas de programación. Hay otro concepto importante a definir, no es otro que lo “pythónico”. Un código es pythónico si sigue la filosofía de legibilidad y transparencia. Contrariamente, un código ofuscado y opaca se le llama “no pythónico”. Esta filosofía queda bastante clara en el Zen de Python. A continuación colocaremos dos códigos para comprender la facilidad respecto a C de Python:

Nos disponemos a programar el cálculo de la serie de Fibonacci en C:


long fibonacci(int n)

{
    if (1 == n || 2 == n)
    {
       return 1;
    }
    else
    {
        return (fibonacci(n-1) + fibonacci(n-2));
    }
}

Podemos hacer un código no pythónico haciendo una simple conversión:

def fibonacci(n):
    if x == 0 || 2==n:
       return 1
   else:
       return (fibonacci(n-1)+fibonacci(n-2))

O por el contrario crear un código pythónico:

import operator
factorial = lambda x: reduce(operator.__mul__, range(1, x))

Básicamente estas son las herramientas que utilizaremos. Las primeras a modo de introducción para irnos haciendo a la forma de trabajar y, una vez ya dominemos las bases nos olvidaremos del árduo trabajo de llamar directamente a físicas y contextos gráficos y lo haremos todo a partir de una capa de abstracción que nos facilita Crystal Space. Seguramente me habré dejado alguna herramienta, cuando me venga a la cabeza, es decir, cuando la necesitemos, ya la comentaré.

• OpenGL: OpenGL es una especificación estándard que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. Es una librería libre teniendo en cuenta su política de licencias. OpenGL se utiliza en CAD o en realidad virtual, también en representación científica o en simulaciones de vuelo o, como no, en el desarrollo de videojuegos en el que compite directamente con Direct3D de M$ Windows. En la actualidad OpenGL tiene dos propósitos principales: el primero, ocultar la complejidad de la interfaz con las diferentes tarjetas gráficas, presentando al programador una API única y uniforme; y la segunda, ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten el conjunto completo de características OpenGL. Basándonos en esta API nosotros utilizaremos un par de bibliotecas externas para desarrollar nuestros gráficos iniciales. Estas bibliotecas serán GLU y GLUT. La primera ofrece funciones ampliadas para la renderización de gráficos y la segunda para la interacción con teclado y ratón.
• PyOpenGL: Ahora toca conectar el lenguaje de programación que utilizaremos, es decir, Python; y las librerías de dibujo gráfico, es decir OpenGL y sus extensiones GLU y GLUT. Para ello instalaremos PyOpenGl que no es más que un módulo para Python que enlaza con las librerías anteriormente definidas. Es una libería completamente libre basada en la licencia BSD. Sólo comentar que es aconsejable instalar los siguientes módulos para trabajar de forma cómoda con PyOpenGL: Doy por sentado que las librerías OpenGL, GLU, GLUT y GLE estás instaladas correctamente en el sistema. Además de éstas y del intérprete Python más reciente hemos de instalar Numpy para cálculo numérico complejo, PIL para el tratamiento fácil de imágenes, PyDisptcher es un módulo de control de eventos, SimpleParse es un módulo para parsear documentos basados en el formato VRML97, TTFQuery y FontTools para el tratamiento de fuentes, PyGame para añadir funcionalidades de contextos gráficos y de ventana y win32all.
• Open Dinamics Engine: Open Dinamics Engine o como se le suele conocer, ODE, es una librería de altas características y libre para simular la dinámica de cuerpos rígidos. Las características de la misma están completas, estables y maduras. Es fácil acceder a ellas mediante lenguajes C/C++. Su uso suele ser en detección de colisiones con fricción. Suele ser útil para la simulación de coches, objetos en entornos de realidad virtual o criaturas virtuales. Es actualmente una de las más usadas en entornos de juegos, herramientas 3D y herramientas de simulación.
• Crystal Space: Crystal Space es una plataforma de desarrollo de gráficos 3D en tiempo real, concretamente orientada a juegos. Tiene una capa de abstracción a OpenGL desarrollada por Nvidia llamada Cg y, otra a ODE, entre muchas otras características como audio o vídeo. Crystal Space tiene el componente que crea el concepto de entidad al que se le pueden aplicar características físicas concretas. Esta librería es parte del Engine y se llama CEL. Este componente es multilenguaje y soporta bastante bien Python.

Sin más, ¡comencemos!