the aberrant

FormulaRetro alpha 13

2010-04-27T08:02:00.000-07:00

FormulaRetro | Get FormulaRetro at SourceForge.net
Echadle un vistazo :)

Página de Formula Retro

2010-02-14T14:52:00.000-08:00

Formula Retro
Poco a poco va tomando forma.

Nuevo proyecto.

2010-01-21T02:49:00.000-08:00

Desde que terminé Teclas Divertidas, he empezado Formula Retro. Un jueguecillo de coches. Estoy utilizando Irrlicht para los gráficos y Mikmod para el sonido. Mi idea es pasarlo a alguna plataforma comercial e intentar venderlo.

Teclas Divertidas terminado.

2009-10-21T10:07:00.001-07:00

Más información en:

http://sites.google.com/site/teclasdivertidas/

Tercera y última alpha 3 de Teclas Divertidas.

2009-10-15T02:33:00.001-07:00

Este pesa bastante más y tiene ¡100% más sonido!

http://www.easy-share.com/1908134138/teclasdivertidas_alpha3.zip

Segunda alpha de Teclas Divertidas.

2009-09-30T09:07:00.001-07:00

Para descargar en el siguiente enlace:

http://www.easy-share.com/1907962184/teclasdivertidas_alpha2.zip

Primera alpha de Teclas Divertidas.

2009-09-06T05:31:00.001-07:00

Aquí:

http://www.easy-share.com/1907650078/teclasdivertidas.zip

Teaser Teclas divertidas

2009-08-24T09:53:00.001-07:00

Polimorfismo.

2009-08-20T01:25:00.001-07:00

En C++, a un puntero declarado como una clase A se le puede asignar una instancia de una clase B si éste es hijo de A.
Utilizo esta técnica para las escenas de mi nuevo proyecto, de tal forma que dentro un bucle principal que se encarga del refresco de la pantalla continuamente, se llama a un método de una clase instanciada en un puntero. Este puntero esta declarado como tipo "ClaseEscena" y tiene un método virtual que se encarga de actualizar los sprites. Sin embargo, en cada momento este puntero tiene una instancia de una clase hija de la "ClaseEscena", que implementa el método virtual de acuerdo con la escena de ese momento. Así, con un mismo bucle principal, tengo diferentes animaciones según convenga al juego.

Retomamos aficiones y dibujamos un poquito.

2009-08-14T08:52:00.000-07:00

Hace mucho que no escribo nada aquí, pero sigo vivo. Vuelvo a tener tiempo libre, por lo que me he puesto a programar otra vez y he retomado este blog que, según las estadísticas, no lee nadie desde hace al menos 5 meses. Más o menos el tiempo que he estado ocupado.

¡Volvemos a programar! Esta vez me propongo un reto un poco más fácil. Imitar un viejo juego de Spectrum y Commodore 64 que se llamaba "Teclas Divertidas", aunque The Aberrant no está olvidado. Ya he creado un esqueleto con un bucle principal y tengo que crear un sistema de escenas y gestión de animaciones y respuesta a eventos.

De momento, pongo unas nubes que irán en la presentación del juego.

Prueba desde Facebook.

2009-08-14T08:47:00.001-07:00

Estoy escribiendo este post desde una aplicación de Facebook para probar.

De vuelta en casa y curvas.

2009-03-08T01:22:00.000-08:00

Ahora vivo en mi propia casa. Una cosa en la lista menos :)

Desde hace mucho tiempo siempre quise hacer una cosa en mis animaciones: curvas. Siempre he querido hacer que un sprite se mueva como en las presentaciones de los juegos de CAPCOM o SNK. La foto de un luchador haciendo pose que viene desde fuera de la pantalla a mucha velocidad y suavemente se coloca en la en su posición.
Para conseguier este efecto primero pensé en utilizar tablas de senos y cosenos para añadir un modificador a una funcion lineal simple. Pero siempre que lo intenté implementar, ni siquiera conseguí compilar.
Desde hace un tiempo tengo este libro de matemáticas para juegos. En uno de los capítulos, tras unas sesudas demostraciones matemáticas, enseña las fórmulas que describen cómo hallar un vector que interpola otros cuatro que describen el punto inicial, final y dos modificadores. En otras palabras, curvas Hermite y Beizer:


claseVector2D curvaHermite(Uint32 tInicial, Uint32 tFinal, Uint32 tAhora, claseVector2D p1, claseVector2D p2, claseVector2D t1, claseVector2D t2){
    claseVector2D H(0,0);
    if ((tAhora > tFinal)||(tAhora < tInicial)) return H;
    double t=(double)(tAhora-tInicial)/(double)(tFinal-tInicial); // t es un valor entre 0 y 1
    //printf("%f , %d, %d, %d\n",t,tInicial,tFinal,tAhora); // debug
    H=((1-(3*t*t)+(2*t*t*t))*p1)+(((t*t)*(3-2*t))*p2)+(t*((t-1)*(t-1))*t1)+(((t*t)*(t-1))*t2);
    return H;
}

claseVector2D curvaBeizer(Uint32 tInicial, Uint32 tFinal, Uint32 tAhora, claseVector2D p0, claseVector2D p3, claseVector2D p1, claseVector2D p2){
    claseVector2D B(0,0);
    if ((tAhora > tFinal)||(tAhora < tInicial)) return B;
    double t=(double)(tAhora-tInicial)/(double)(tFinal-tInicial); // t es un valor entre 0 y 1
    B=(((1-t)*(1-t)*(1-t))*p0)+(((3*t)*((1-t)*(1-t)))*p1)+(((3*(t*t))*(1-t))*p2)+((t*t*t)*p3); // se puede optimizar esta formula calculando (1-t) y pasandolo a una variable
    return B;
}

Simple y eficiente. En otro post explico la implementación de "claseVector2D".

Sensación extraña

2009-02-07T15:07:00.000-08:00

Volver a ver mi código después de tantos meses, es raro. En general lo entiendo bien, pero parece que algunas cosas son demasiado complicadas para lo que hacen.

Ahora que estoy en paro, tengo más tiempo para cacharrear y he descubierto esta pequeña joyita: irrlicht. He conseguido mover un cubo por una pista hecha en blender como si fuera un coche.

Creo que voy a volver con el proyecto e incluso iniciar otro para no terminar ninguno de los dos :)

Eh! que me bloquean...

2008-11-19T00:34:00.000-08:00

Tengo tan olvidada esta página, que google cree que soy "spam". Bueno, señores de google, no se preocupen. Respondí a la solicitud y al "captcha" de sonido (por que la imagen era imposible de descifrar).

Este proyecto esta en parada técnica. Ahora mismo estoy buscando trabajo y no puedo estar con esto. Pero volveré.

Ping?

2008-05-18T04:28:00.000-07:00

Parece que el proyecto esta parado, pero no olvidado.

De momento, publicaré lo que tengo hecho hasta ahora, ya que el servidor donde alojaba antes ya no está disponible. ¿Alguien me ofrece unos cuantos megabytes en línea? Con 250 me conformo :)

ping?

2008-04-15T02:44:00.000-07:00

Estoy vivo, pero últimamente hay mucho trabajo: una nueva PS3 al que instalar linux, creación de un media server (media tomb) para la PS3, un guerrero undead de nivel 21 y subiendo, fiestas de cumpleaños con gente perdiendo el conocimiento... En fin, muchas cosas sucediendo.

¿Textos al pinchar en sprites? Hecho.

2008-03-31T03:54:00.000-07:00

Estoy pensando ahora en más tipos de eventos y en disparar más de una acción por evento. También estaría bien hacer un par de escenas de ejemplos y publicar unos binarios.

Temas pendientes

2008-03-25T04:34:00.000-07:00

Que no se me olvide que tengo pendiente:

Crear método "void claseTexto::SetParrafoVisible(unsigned short int parrafo)". Cambia el estado del parrafo indicado a visible.
Crear método "void claseTexto::print()". Hacer tick() al parrafo visible. Si devuelve true, imprime el párrafo marcado como visible. si no, es que ya no es visible. Ajustar propiedades privadas para el nuevo estado.
Crear contador "tick" y bool Visible en claseParrafoTexto.
Crear metodo "bool claseParrafoTexto::tick()". tick++. Cuando tick supere un valor, cambiar visible a false y devolver false. Si no, devolver true.
Crear nueva accion-evento "muestra texto" y llamadas correspondientes en claseJuego.
Hacer prueba de pinchar en sprite y mostrar texto.
Ir pensando en eventos para gestionar objetivos del juego.
Ir pensando en condicionar la construcción de escenas dependiendo de los objetivos conseguidos.
Ir pensando en nuevos tipos de escena: diálogo, lucha...

Limpieza y textos

2008-03-19T02:58:00.000-07:00

Voy lento pero seguro. Ya hemos hecho limpieza en las librerías y arrays del juego. El código en esa parte ha quedado mucho más limpio y comprensible.
Ahora hay que seguir con las clases para los textos. Es más complicado de lo que parece, ya que hay un montón de propiedades a tener en cuenta para presentar los textos adecuadamente. Y la cosa se complica mucho más si quiero hacer animaciones chulas con el texto. Más sobre este tema pronto.

Array como argumento de función.

2008-03-12T12:39:00.000-07:00

Un array pasado a una función como argumento, se convierte en puntero para la función.

Lo explican muy bien aqui: http://www.eskimo.com/~scs/cclass/notes/sx10f.html

Qué cosas tiene el C... hay que quererlo tal y como es :)

¿Arrays de enteros o array de struct?

2008-03-10T12:22:00.000-07:00

Me he dado cuenta de que la forma de almacenar los datos del juego, como los eventos por escena, los nombres de los ficheros y demás, que estoy utilizando es, sinceramente, una chapuza.
Casi todos los datos son listas de enteros y enums. Los meto en arrays de esta forma:


int datosTextos[]= {
    12,     0,          0,      NORMAL_PEQ, 128,    128,    128,    50, 50,
    12,     0,          1,      NORMAL_PEQ, 128,    128,    128,    50, 50,
    12,     1,          2,      ABERRED_GRA,255,    0,      0,      200,300
};

Luego, en los constructores de los objetos, por ejemplo claseEscena, utilizo funciones que me sacan los datos y construyo las propiedades privadas que necesito en ese momento.
El problema que tiene esta forma de trabajar es que sólo puedo meter enteros en los arrays. Los literales de texto van a parte en funciones específicas. He ahí la chapuza.
Estoy pensando en utilizar structs. Así, podría meter un literal char * junto con los int para cada elemento del array. Podría mantener las llamadas a las funciones y la librería de datos quedaría mucho más clara.
Ya veremos qué hago. Lo dejamos en la lista de "estaría bien si...".

Textos Multilínea

2008-02-25T01:03:00.000-08:00

Me he encontrado con un pequeño problema. La librería SDL_ttf, que voy a utilizar para generar los textos, sólo es capaz de crear superficies SDL con textos en una sola línea. Un sprite, una línea. Podría utilizar la generación de "glifos", pero sinceramente, no me apetece. Así que me toca añadir una capa más de abstracción a la clase que se encarga de los textos, creando otra clase capaz de albergar más de un sprite cada línea del texto.
Es un poco pesado de programar, pero qué le vamos a hacer. La clase será "claseParrafoTexto".
También estoy pensando en añadir soporte para varios tipos de letra, tamaño, color, fondo... Si lo hago bien, utilizaré estas mismas clases para la generación de los menús. Si es que algún día los hago :)

Niños, recordad siempre que...

2008-02-22T10:10:00.000-08:00

Hay que inicializar todas las propiedades privadas de una clase en C++. Siempre. Siempre. Siempre. Siempre.

Siempre.

Por que si no, recolectas basura de la memoria. Y empiezas a llamar a métodos y funciones con basura en sus argumentos. Y de repente tu programa casca. Sin errores aparentes. De forma aparentemente aleatoria. Y encontrar lo que falla se vuelve un infierno.

Y eso no puede ser. Por que la salud mental sufre. Y nosotros queremos mantener la salud mental. ¿Verdad? Sí... Sí...

Representación de textos en escena interactiva

2008-02-17T08:22:00.001-08:00

Una parte importante de juego son los textos. Por eso, voy a crear una clase sólo para gestionarlos. La clase se llamará claseTextos. Los textos en realidad serán sprites generados al principio de la escena. Los constructores de la escena llamarán a los métodos de la nueva clase para generar todos los textos. Cada texto será un sprite de una lista como propiedad privada de la clase.

En la ejecución de la escena interactiva se mostrará sólo un texto a la vez. Aprovecharé esto para que la clase haga aparecer y desaparecer los textos de forma suave.

Para las escenas en las que se hable con un personaje del juego, crearé otro tipo de escena, ya que la representación de los textos será distinta.

ping?

2008-01-28T02:03:00.000-08:00

Es cierto, he dejado descuidado el blog y por lo tanto, el desarrollo. Pero tengo buenas escusas. Mudanza, falta de conexión, estudio para certificarme como administrador de sistemas...

Pero hay planes de desarrollo muy interesantes. Si hay suerte, voy a ayudar a un amigo a realizar su proyecto de fin de carrera. Más noticias pronto.

Progreso lento, planes interesantes.

2007-11-19T01:42:00.000-08:00

La vida es lo que te interrumpe mientras codeas.
Ya se ha superado el tema de pinchar en los sprites.
Ahora tengo que implementar las llamadas a los eventos-acciones. No creo que me cueste mucho. Seguramente haré un par de escenas de ejemplo.
Ahora estoy pensando en construir el sistema de interfaz, que serán dos bandas negras para convertir el juego en una especie de película "cinemascope". En estas bandas aparecerá la puntuación, los mensajes y las descripciones, los diálogos, etc.
Para las escenas de lucha tengo grandes planes y una colaboración. El engine contará con una característica muy interesante.

Más noticias pronto.

ping?

2007-11-07T00:33:00.001-08:00

pong!

Píxeles de SDL_Surface y eventos de sprite.

2007-10-22T03:11:00.000-07:00

Al final era más fácil de lo que yo creía. Hay un ejemplo en la documentación de libSDL que explicaba perfectamente cómo hacerlo. Copiaré el código con muy pocos cambios. Así, la detección de sprites pinchados se queda de la siguiente manera:

1.- Crear propiedad privada del sprite que sea un SDL_Surface con tamaño igual al de la superficie de la pantalla y 8 bits de profundidad con flag SWSURFACE. Esta superficie será la máscara.
2.- Cuando se cree un frame del sprite, crear una copia del frame a 8 bits como "sombra", también con flag SWSURFACE
3.- cuando se pida un tick del sprite (actualización de animación y frame para hacer blitting a la pantalla), rellenar la superficie máscara de un color concreto (¿rosa? ¿verde fosforito? ¿azul puro?) y hacer blit de la sombra del frame actual sobre la superficie máscara.
4.- para saber si el ratón ha pinchado sobre nuestro sprite, sacamos el color del pixel donde está el ratón de la máscara. Si no es el color de fondo asignado, hemos pinchado en nuestro sprite y disparamos evento de usuario de SDL, que a su vez disparará una o varias acciones de la lista de acciones de la escena.

A ver si esta tarde o mañana lo programo.

No he avanzado mucho...

2007-10-19T05:32:00.000-07:00

... desde el último post. Pero tengo una buena excusa; he estado con Ubuntu 7.10 probando, reprobando y poniendo más a prueba. Y sólo tiene dos problemas para mí:

El controlador de intel para las Xorg detecta el DPI demasiado grande que no concuerda con los ajustes de Gnome. Así, las barras de ventana, a cargo de compiz, salen con letras muy grandes respecto del resto del apartado gráfico, a cargo de Gnome. Es molesto, pero no es importante. Se arregla añadiendo la opción "-dpi 96" en el menú Sistema ==> Administración ==> Ventana de entrada ==> Seguridad ==> Configurar Servidor X ==> Comando.
Se agota la batería de mi portátil en tres horas escasas. Claro, que no tengo un portátil muy bueno, pero creo que es poco tiempo. Deben mejorar bastante en el consumo de energía.

El resto del sistema simplemente funciona como debe.

Máscaras de sprites

2007-10-14T03:44:00.000-07:00

Me están costando más de lo que suponía.
Leer un pixel de una superficie SDL tiene su miga, ya que la información de los pixeles sólo es accesible directamente desde la memoria. Y además, si la superficie es de tipo "HWSURFACE", está en la memoria de la tarjeta gráfica, lo que hace las lecturas lentas. Y no podría leer pixeles fuera de rango sin hacer costosas comprobaciones antes.
Ahora mismo estoy creando un sistema de "sombra" de los sprites, en la que creo una superficie "SWSURFACE" de acceso rápido equivalente a la superficie de la pantalla, pero en la que sólo "bliteo" una copia del sprite que también es "SWSURFACE". Todo esto con sólo 8 bits de profundidad para hacer el bliteo lo más rapido posible.
Cuando quiera leer el pixel donde se encuentra el ratón, tengo que bloquear la superficie "sombra", haciendo una lectura de este estilo:


Uint8 *bufp;//Avanzamos en bloques de 8 bits en vez de 1 byte
SDL_LockSurface(superficie);
            bufp = (Uint8 *)superficie->pixels + y*superficie->pitch/2 + x;
// realizamos comparación de bufp con un valor generado por la función
// SDL_MapRGB para saber si hemos tocado nuestro sprite
SDL_UnlockSurface(superficie);

Siendo "superficie" un SDL_Surface.

Más noticias pronto :)

Punteros de ratón.

2007-10-06T11:51:00.000-07:00

El ratón tiene punteros que indican la acción activa en ese momento.
Para "usar", un par de engranajes. Para "ver", una lupa. Para "coger", una mano. Para "disparar", una mirilla. Y por supuesto, un puntero normal.

Lo siguiente serán eventos disparados por los sprites. Pero antes debo decidir cómo gestiono las máscaras de los sprites... Esto me va a costar un poco más, pero una vez resuelto este tema, ya se podrán crear juegos simples.

Música en las escenas y futuro

2007-09-29T14:43:00.000-07:00

He programado un pequeño gestor de sonido y ahora las escenas tienen música de fondo. Pronto código y binario.
Lo siguiente va a ser los modos de interacción (ver, usar, coger) con el ratón, eventos generados por los sprites, presentación de texto, efectos de sonido...

Temas pendientes

2007-09-19T14:38:00.001-07:00

Ahora que ya tengo una base funcionando, tengo pendientes un montón de cosas:

- Sonido en las escenas. Listas de sonidos, eventos de reproducción.
- Máscaras en los sprites. ¿Autogeneradas?
- Los sprites deben generar eventos al ser pinchados con el ratón.
- Las escenas interactivas deben comprobar la lista de objetivos cumplidos y generar las acciones oportunas. Esto sirve para que los objetos cambiados en el juego tengan persistencia.
- Hay que ir pensando en una forma de representar texto en la pantalla dinámicamente para diálogos y descripciones.
- Un sistema de inventario también estaría bien.

Primer ejecutable

2007-09-18T16:33:00.000-07:00

Ya he conseguido implementar las listas de sprites y su presentación en la pantalla. La librería SDL funciona muy bien. Incluso puedo dar unas especificaciones mínimas para el engine: Procesador pentium a 800 MHz, Windows 2000, una tarjeta gráfica que soporte directX 7 y 256 Mb de ram.

Aberrant Engine. Código fuente.
Ejemplo de Aberrant Engine. Binario Win32.

Intrucciones para el Binario de ejemplo: descomprimir y ejecutar "theaberrant.exe" de la carpeta "theaberrant". Para salir del programa, pulsar la tecla F10.

Ahora queda implementar eventos disparados desde los sprites y ya se podrá hacer un juego tipo "Exmortis"

Creación de Sprites comprobada

2007-09-08T07:52:00.000-07:00

Ahora tengo que idear un sistema para asignar a cada sprite una función de posición que dependa del tiempo y que sea individual para cada Sprite.
Será una función de la librería de datos a la que se le pasará toda la información importante por referencia.
Por cierto, seguramente me llevaré el ordenador portátil a mis vacaciones, bajo el benepácito de mi novia, por lo que el desarrollo no se detendrá. Creo.

Se acercan las vacaciones...

2007-09-07T04:40:00.000-07:00

Ya tengo escrito todo el sistema de métodos que cargarán los frames de cada sprite de una escena en memoria. Leer estos frames será tan sencillo como devolver el puntero SDL_Surface para hacer blitting directamente a la pantalla. Tengo que hacer unas cuantas pruebas para ver si no me dejo ningún puntero por borrar.
¿Sería posible reproducir una animación de "Loading" mientras se carga? Tengo que investigarlo.
Están las vacaciones a la vuelta de la esquina, por lo que el proyecto se quedará parado entre una y dos semanas a partir de este domingo. Publicaré lo que llevo hecho por si alguien quiere echarle un vistazo. Pero vista la increíble audiencia de este blog :P no creo que nadie me mande parches.

Codeando voy, codeando vengo...

2007-09-06T01:00:00.000-07:00

Escribo código allá donde puedo; en el trabajo medio a escondidas, en casa después de limpiar, cocinar y hacer compra. La implementación de los sprites avanza lentamente.
Serán animados, pero no tendrán máscaras todavía. Estoy pensando en crear un sistema automático de creación de máscaras para ahorrar espacio en disco pero no creo que lo haga.
Los sprites podrán ser animados. Cada objeto sprite tiene una lista de frames que irán rotando automáticamente.
Todavía no tengo código enseñable. Pronto más.

¿Y dónde pongo los sprites?

2007-08-31T12:28:00.000-07:00

He retrasado todo lo que he podido la implementación de la escena interactiva por que quería estar completamente seguro del diseño.
Tengo dos clases que manejan el comportamiento del programa. La clase juego, gestiona las llamadas a la librería SDL, guarda los datos persistentes del juego y manda eventos a la clase escena. La clase escena se instancia para cada escena, y modifica los datos de la clase juego en respuesta a los eventos recibidos.
Cada vez que se crea una escena nueva, hay que cargar los sprites, sonidos, reglas, y todo lo relacionado con la escena. Pero, ¿dónde se cargan?. Parece que lo lógico sería que todo lo de la escena fuera propiedad privada de la clase escena. Pero eso son datos que va a utilizar SDL en realidad. Los sprites serán pngs que se "blitearán" a la pantalla. Y los sonidos lo mismo. Así que he decidido que todo lo que tenga relación con SDL estará en la clase juego. Crearé los arrays de sprites y sonidos como propiedad privada de la clase juego. Como los punteros de cada instancia son conocidos, haré que en el constructor de la escena se carguen los sprites en la clase juego.

Código fuente

2007-08-31T01:00:00.000-07:00

Vamos a publicar lo que llevamos hecho:

http://www.arrakis.es/~cesrodmo/theaberrant_20070831.zip

Si alguien lo pide, publicaré un binario con un par de escenas de ejemplo.

ping?

2007-08-21T02:09:00.000-07:00

pong!

Nueva versión de Work Logger

2007-08-15T05:35:00.000-07:00

Ya se graba la hora correctamente en los log.

Reproductor de vídeo terminado.

2007-08-14T03:06:00.000-07:00

El engine ya tiene una funcionalidad mínima como secuenciador de vídeo :) Ahora soy capaz de ordenar escenas de vídeo, definir la siguiente escena, salir del juego con una tecla determinada y responder al teclado. He implementado un sistema simple de eventos que servirá de base para las escenas interactivas.
Empieza la parte realmente interesante; crear las listas de sprites y sonidos, reproducirlos en orden, crear los eventos adecuados y hacerlo todo orientado a un desarrollo del juego rápido y sencillo dentro de lo que cabe.

En otro orden de cosas, me he dado cuenta que el Work Logger pone los "timestamps" con dos horas de retraso. Luego lo arreglo.

Work Logger

2007-08-10T18:07:00.000-07:00

Esto no esta relacionado con el juego, pero creo que merece la pena ponerlo aquí. A lo mejor a alguien le resulta útil...
He hecho una pequeña utilidad para windows que sirve para llevar un registro de lo que haces. Abres el programa, escribes lo que has hecho y lo cierras. Nada más. El programa te deja un registro en tu escritorio con la hora de la entrada y la entrada.
Luego si alguien te pregunta, o tienes que decirle a otra persona lo que llevas hecho, sólo tienes que pasarle el log.

Código fuente: worklogger.zip
Binario: worklogger.exe

Eventos, condiciones y acciones

2007-08-02T10:04:00.001-07:00

Este fin de semana voy a tratar de solucionar un problema que, cada vez que lo pienso, se vuelve más complicado dentro de mi cabeza.
Necesito crear un sistema para cambiar las propiedades del objeto juego y el objeto escena, que se configure en cada escena, que reaccione a los clicks del ratón o a temporizadores ajustados y que dependa de cualquier propiedad del objeto juego o del objeto escena.
Ya contaré más sobre el tema.

Librería SMPEG

2007-07-29T01:34:00.000-07:00

Me bajé un devpak con el DEV-C++ para la librería SMPEG. La librería, compilada como estática, proporciona funciones para cargar y reprodcir videos en formato mpeg1. Tiene un buen rendimiento pero esta abandonada.
Este devpak reproduce correctamente los vídeos, pero no los paraba hasta el final. He tenido que bajarme el último cvs, importar el proyecto de visual C a DEV-C++ y recompilar la librería. El resultado es un archivo con extension ".a" que se sustituye por la que venía con el devpak.
Ahora los vídeos se reproducen, se pausan y se paran sin ningún problema.

La página del SMEPG es http://icculus.org/smpeg/

Vamos avanzando

2007-07-28T04:13:00.000-07:00

El engine empieza a tomar forma, aunque todavía no hace nada interesante en realidad. El esqueleto con la relación juego<-->escena esta hecho. Se inicia el juego, el juego inicia la primera escena, que es un video y lo reproduce. Esto es todo de momento.
Ahora tengo que añadir a la escena el sistema de eventos-acciones que modifica el juego y asi pasar a la siguiente escena de una forma programada.
Lo siguiente será crear el sistema de escena interactiva. Será lo que me lleve más tiempo en realidad, ya que va a ser un sistema un poco complicado. Habrá listas de sprites animados, animaciones programadas mediante funciones, transparencias, eventos generados por el ratón y el teclado...
Estaba pensando en hacer otro programa que gererase el código de la librería de datos. Algo así como un editor del engine para crear juegos. Eso lo dejaremos para lo último.

Nueva versión de SDL

2007-07-23T08:29:00.000-07:00

SDL 1.2.12

y de SDL_mixer y de SDL_image y de SDL_gfx... toca rehacer las librerías y el sistema de compilado.

ping idaho^j idaho is alive

2007-07-20T03:58:00.000-07:00

Mucho trabajo y mucho cansancio últimamente. El proyecto esta un poco parado. Pronto más. :)

Referencias cruzadas entre dos clases

2007-07-08T04:54:00.001-07:00

En mi diseño, los métodos de una clase tienen que poder llamar a los métodos de una segunda. Los métodos de la segunda clase tienen que poder llamar a los métodos de la primera.
La solución para este problema que se me ha ocurrido es poner un puntero a la clase que queremos llamar como parte privada. Uno de los métodos públicos de la clase se encargará de darle el valor adecuado a ese puntero. Supongamos una cabecera “clasejuego.h”:


#include "claseescena.h"

class claseJuego
{
    private:
    claseEscena * punteroEscena;
[...]
  public:
      // class constructor
      claseJuego();
      // class destructor
      ~claseJuego();

      // Asigna la dirección del objeto Escena en el Juego
      void asignaEscena(claseEscena * nuevoPunteroEscena);

      // Con este método cambio propiedades del objeto Escena
      void cambiaEscena(int a, int b);
[...]
};

En “claseescena.h” el código sería muy parecido.
Nosotros crearíamos las instancias de los objetos e inmediatamente después llamaríamos a asignaEscena y a asignaJuego tal que así:


#include "clasejuego.h"
#include "claseescena.h"

int main(int argc, char *argv[])
{
  claseJuego * punteroJuego;
  claseEscena * punteroEscena;

  punteroJuego = new claseJuego;
  punteroEscena = new claseEscena;

  punteroJuego->asignaEscena(punteroEscena);
  punteroEscena->asignaJuego(punteroJuego);
[...]
}

Parece correcto, ¿verdad? Pues esto no compila. No se pueden hacer includes cruzados por que no se pueden declarar dos tipos a la vez. Por muchos includes que se pongan en las cabeceras, el compilador recibe las declaraciones de una en una. Siempre se encotrará con que se hace referencia a un tipo todavía no declarado. Así que investigando sobre este problema he encontrado que se pueden hacer declaraciones de tipos por adelantado. Así en “clasejuego.h”:


#include "claseescena.h"

class claseEscena; // referencia por adelantado de un tipo
class claseJuego

{

    private:
          claseEscena * punteroEscena;
[...]

Igual en la otra cabecera.
Hay otra soluciones para este problema, pero esta me parece la más fácil. Ahora, a otra cosa :)

Estilo de código

2007-07-08T04:22:00.000-07:00

Utilizaré estilo de notación de camello y todas las variables tendrán su tipo como prefijo excepto los de tipo obvio que necesite para contar o guardar cadenas de caracteres. Creo que este estilo se llama notación Húngara. Ejemplos:

claseJuego: Estructura de la clase para el juego.
puntJuego: Puntero de una instacia de claseJuego
i: variable entero que utilizo para un bucle o algo así
boolCheckSprite: booleando de una comprobación.

Las constantes irán en mayúsculas. Los bloques de código dentro de bucles y funciones añadirán cuatro espacios o un tabulador antes de cada línea. Los comentarios podrán ir detrás de cada línea con doble barra o en bloques de barra asterisco.

Cambiar de opinión (licencias, la venganza)

2007-07-06T00:09:00.000-07:00

Dicen que es de sabios.
He hablado con Fabi. Me ha convencido. Liberaré el Aberrant Engine bajo GPLv3 y el Juego bajo CC sin permiso para modificar.
No es una contradicción, ya que como autor, puedo considerar el juego como arte derivado. Una obra separada. Que yo diga que ese arte derivado tiene parte GPL no implica que deba liberarlo también.

Hablando de otros temas, tengo el diseño casi terminado. Pronto más.

La criatura se va a llamar:

2007-07-05T11:02:00.000-07:00

Tras pensarmelo mucho, el engine del juego se va a llamar:

Aberrant engine

Listas en c++

2007-07-01T04:37:00.001-07:00

Las clases que voy a utilizar en el programa van a hacer un uso intensivo de listas de datos que se recorrerán para realizar alguna función.
Por ejemplo, la clase "escena" tendrá una lista de "sprites". "sprite" será a su vez otra clase que contendrá más listas.
¿Cómo implemento una lista? La opción más académica es crear un sistema de punteros con una clase que gestiona la creación de nodos, su inserción y su recorrido. Es un sistema eficiente en la gestión de memoria pero es un poco pesado de implementar. Además, no tengo claro la forma en que gestionaria los diferentes tipos de punteros. ¿Tengo que hacer una clase lista para cada tipo? ¿o hago una clase genérica y luego voy heredando y sobrecargando los metodos para cada una? Un coñazo.
La opción vaga es hacer arrays de objetos de esta forma:

    laClase *arrayClase;
  
   arrayClase = new laClase[TAMANIO_LISTA];

[...]
  
   delete[] arrayClase;

Así, todas las clases se instancian por que "new" llama a todos los constructores de cada elemento del array. Al principio, estos objetos tendrán la menor cantidad de datos posible e iremos "llenando" de datos cada nodo de la lista según lo vayamos necesitando. El comando "delete[]" llama a todos los destructores de las clases, que a su vez se encargarán de "deletear" sus arrays-listas. Es un sistema poco eficiente en el uso de memoria, pero seguro y fácil de implementar.
La memoria no me preocupa mucho. Todos los ordenadores modernos tienen bastante memoria.

Sigo vivo...

2007-06-24T02:47:00.001-07:00

Pronto más posts...

Conclusión sobre las licencias.

2007-06-16T03:10:00.001-07:00

Para el motor del juego y un pequeño módulo de ejemplo, utilizaré la licencia BSD, en la que permitiré la libre distribución del código y crear trabajos derivados tanto en forma de código como en binarios siempre y cuando se me nombre explícitamente en créditos y publicidad.
Para el juego completo utilizaré "Licencia Reconocimiento-No comercial-Sin obras derivadas 2.5 España License de Creative Commons" en la que no permito el uso comercial del juego ni permito modificarlo. Me reservo el derecho de cambiar de opinión más adelante :P

Más acerca de las licencias.

2007-06-13T09:57:00.001-07:00

He seguido investigando sobre los tipos de licencias que podría aplicar al juego. En general, mis conclusiones son las siguientes:
La licencia GPLv2 y posteriores me obligan a publicar TODO el código fuente del juego. Eso incluiría las funciones que definen las escenas que van en librerías a parte. No me interesa esto, ya que no podría poner a descargar el juego sin que la parte creativa quedase expuesta.
La licencia LGPLv2 y posteriores permite que el código sea enlazado desde programas privativos si obligar a esos programas a que liberen a su vez su código. Esto esta pensado para publicar librerías de tal forma que todo el mundo pueda usarlas, incluyendo los productos privativos.
La licencia BSD original permite hacer cualquier cosa con el código siempre y cuando se nombre explícitamente al autor del programa o librería incluso en la publicidad que se haga del programa. Puede que esto me interese, ya que podría liberar sólo parte del programa bajo BSD y el resto sería cerrado. Otra versión de BSD posterior no tiene la clausula de publicidad.
La licencia X11. Quizás es la más sencilla de todas. Permite hacer lo que sea con el código mientras no se nombre en otro producto como característica. Como lo que busco es que mi nombre vaya con el juego, no creo que elija esta.

De momento, creo que BSD es lo que más me gusta. Ahora quiero saber si existe un equivalente legal español a esta licencia.

Librerias y licencias

2007-05-29T02:19:00.000-07:00

Quiero diseñar el juego de tal forma que el intérprete de escenas y los descriptores de escenas se compilen independientemente. Así, la máquina principal del juego, que controlará el refresco de pantalla, el ratón, las transiciones y demás, serán el ejecutable principal en C++. Cuando se “instancie” un objeto que contenga toda la información de una escena, el constructor llamará a funciones C que devolverán los valores adecuados para esa escena. Estas funciones estarán en una DLL a parte. Así tendré separados el juego del “engine”.
El uso de DLL es más lento (sólo un poquito más lento, vamos, inapreciable) que si integrase todo en un mismo ejecutable, pero así puedo lanzar el contenido artístico con una licencia restrictiva y el código del juego con otra más abierta.
Ya he hecho mis primeras pruebas y es relativamente sencillo. Incluir código C en C++ se hace con la instrucción:

extern “C” {
#include “cabeceraC.h”
}

Así, podremos llamar a las funciones en C desde C++.

2007-05-01T03:04:00.000-07:00

Almacenamiento y otros problemas

Tengo un mac de 24 pulgadas, un pentium 4 HT, un portatil de 12 pulgadas con un core 2 duo y otro portatil viejo que hace las veces de servidor de ficheros.

Utilizaré este último como repositorio del código y del "toolkit". Será algo sencillo, un samba para almacenar ficheros comprimidos manulamente. Pondré la versión a mano en el nombre de fichero. Sé que lo ideal sería un cvs o algo así, pero no tengo tiempo para eso.

Además, no puedo postear con el widget blogger en este blog. ¿Alguien sabe de algún programa para mac os x para postear aquí?

2007-04-30T04:15:00.000-07:00

Preparación de librerías

El juego estará hecho sobre SDL, SDL_mixer, SDL_gfx, SDL_image y SMPEG. Hoy por fin he conseguido crear un entorno de programación. Voy a user DEV C++. He bajado las librerías precompiladas de todo lo que me hace falta. No he utilizado los devpaks por que no estan actualizados. Es una pena.

El método que he seguido es el siguiente:

- Bajar el devpak si lo hubiera.

- Bajar la ultima version de la librería

- Sustituir los .h, los .a y los .dll

SDL_gfx tuve que compilarlo para crear los DLL. Con SMPEG no ha habido suerte y voy a utilizar un devpak que parece que funciona bien. Más adelante intentaré compilarlo yo mismo.

¿Que es esto?

2007-04-30T03:43:00.000-07:00

El diario de creación del proyecto "The Aberrant". Juego de terror-horror multiplataforma basado en las librerias SDL, hecho en C y C++.