Bueno, pues aquí teneis una nueva versión de nuestro bomberman. Como podreis observar hay diferentes estilos de menus, para que nos deis vuestra opinion (también recibimos sugerencias si estais inspirados).
También tenemos un prota nuevo, aún que todavía falta ajustarlo un poco, pero así ya vais viendo y comentando ;)

A disfrutar:

ichiBomberman v.0.4.0 [windows]

Buenas Azazel,

Sé que no tiene mucho tiempo, pero.... sería posible que me hicieras una mini introducción/tutorial para poder leer archivos XML poder modificarlos y guardarlos en el DPF?  Es que no me acabo de aclarar  :oops:

Muchas gracias :D

Pues ya podeis destrozar a vuestros primeros rivales en nuestro Bomberman, eso si, tendran que estar a vuestro lado o por otra parte podeis jugar "a 2 manos" si podeis pensar por dos personas a la vez xD

¡Descargate la demo YA!

Versión actual: 0.3.0

La configuración de las teclas es la siguiente:
PLAYER 1:
movimiento -> flechas de dirección
poner bomba -> shift derecho
resucitar -> F1

PLAYER 2:
movimiento -> wasd
poner bomba -> shift izquierdo
resucitar -> F2

Espero comentarios (buenos y malos :P)   :D

Buenas apañeros,
Me he quedado encallado un poco con un tema que no se del todo bien por donde pillarlo.
Nuestras bombas ya hacen explotar los ladrillos y bloquean el paso, pero el problema es cuando la explosión toca a otra bomba y entonces esta otra debería explotar.
Pues bien, el tema es que tengo una clase jugador, que tiene un array de bombas (de tipo "bomb" que es otra clase). Y claro, cuando la bomba genera la explosión va mirando por las bombas del jugador padre para ver si toca alguna.
Hasta aquí todo bien, el problema viene cuando el fuego alcanza la bomba de otro jugador, es aquí cuando no se como montarlo, ya que ahora mismo solo "se ven" las bombas de un mismo jugador. ¿Cómo lo tendría que hacer para que se vieran todas las bombas? ¿Creando un array de bombas de manera general, es decir, una global? ¿O hacer el array de jugadores global y ir accediendo por cada jugador a las bombas que posee?

Jur, he acabado haciendome un lio :?

PD. Otra cosa que tengo es que voy modificando la estructura del mapa para indicar que hay una bomba en una cierta posición, pero no guardo de quien es.... Sería mejor seguir por esta línea y especificar en la estructura del mapa el propietario de la bomba para enviarle a dicho jugador que la haga explotar?

[CFont]

CFont
¿Porqué cuando "dibujo" en la superficie CRM32Pro.screen en el siguiente refresco se queda guardado lo que he bliteado?
Ejemplo, si imprimo un texto con el módulo CFont en CRM32Pro.screen y en otro refresco cambio el texto, el texto antiguo se queda en pantalla.

CSprite
¿Porqué tengo que llamar en cada refresco a la función CSprite::MoveTo()?
Es decir, en el caso de que la posición del sprite no varie, si no llamo al MoveTo el Sprite "tiembla"

¿Se pueden definir más animaciones? Por ejemplo, si el prota tiene animaciones como "pegar puñetazo" o "pegar patada" a parte de las de movimiento, como hago para definirlas y/o llamarlas? ya que solo tengo opción de definir las animaciones con movimientos (8 direcciones) y estado normal...

Ale, de momento eso es todo, pero seguro que poco a poco van surgiendo más cosas :P

Bueno, pues aquí espero vuestras opiniones sobre los documentos que hemos diseñado. ¿Os parce correcto el plan de trabajo o añadiriais/quitariais cosas?¿Y el diseño, os gustan las ideas?

Ya he comentado que casi tenemos la versión 0.1 pero me gustaría pulir algunos algoritmos, de todas formas ¿quereis que suba el código o los binarios?

Enga pues, opiniones opiniones :roll:

[Introducción sobre los tutoriales:]

Introducción sobre los tutoriales:

Esta serie de tutoriales pretenden ser una guía para conocer la librería de CRM32Pro y cómo utilizarla. En ningún caso pretende ser una explicación exhaustiva de todos los parámetros y métodos (funciones), dado que esto es lo que hace la documentación de la librería. Así pues nosotros sólo mostraremos las bases, será tarea del lector profundizar más en las diversas opciones consultando la documentación.

También remarcar que estos tutoriales se centran en el uso de la librería, no del administrador de recursos: EditorDPF.

Tutorial 1: Carga de superficies y blitting

Introducción:

Una superficie (surface) es cómo denomina SDL a las imágenes, de esta manera cada imagen es tratada como una superficie con sus características particulares. "Blitting" simplemente significa aplicar una superficie a otra.

En este tutorial veremos como cargar un fondo y una imagen para después mostrarlos por pantalla.

Tutorial:

Trabajando con CRM32Pro
Primero de todo deberemos incluir las cabeceras de CRM32Pro y antes de poder llamar a cualquier función de CRM32Pro tenemos que inicializarlo.

Código [Seleccionar] Expand


#include "CRM32Pro.h"

int main( int argc, char* args[] )
{
   if(CRM32Pro.Init(SDL_INIT_VIDEO) < 0)
   {
       printf("No se ha podido iniciar CRM32Pro: %s\n",SDL_GetError());
       return 1;
   }
   CRM32Pro.Quit();

   return 0;
}

Como podéis ver hemos utilizado 3 funciones, primero explicaremos la CRM32Pro.Init(Uint32 flags).
Esta función recibe como parámetro de entrada un Uint32, esto quiere decir un (unsigned) int de 32 bits. De esta manera le decimos al CRM32Pro qué subsistemas queremos iniciar, en nuestro ejemplo solamente iniciamos el de vídeo: SDL_INIT_VIDEO. Los posibles parámetros son:

SDL_INIT_VIDEO
SDL_INIT_AUDIO
SDL_INIT_TIMER
SDL_INIT_CDROM
SDL_INIT_JOYSTICK
SDL_INIT_EVERYTHING

Para poder inicializar más de un subsistema los podemos concatenar con la barra vertical (|), por ejemplo: CRM32Pro.Init(SDL_INIT_VIDEO | SDL_INIT_TIMER)
Por otra parte tenemos la funcion SDL_GetError() que nos devuelve el último error que ha registrado SDL.
Finalmente, al igual que hemos tenido que inicializar la librería, cuando hemos acabado de trabajar necesitamos cerrarla. Esto lo realizaremos con la función CRM32Pro.Quit().

Iniciando el sistema de vídeo

Ahora que ya hemos inicializado CRM32Pro vamos a definir el sistema de vídeo, para ello primero rellenaremos los parámetros de configuración:

Código [Seleccionar] Expand


   CRM32Pro.Config.Title = "Tutorial 1"; //titulo de la ventana
   CRM32Pro.Config.VideoWidth = 640;   //establecemos la resolución: 640 de ancho
   CRM32Pro.Config.VideoHeight = 480;  //por 480 de alto
   CRM32Pro.Config.VideoBPP = 32;      //y una profundidad de bit de 32

Aquí hemos configurado el titulo de la ventana, la resolución y los bits por píxel. A pesar de que por defecto ya esta configurado para 640x480 hemos querido mostrar como configurar estos parámetros. Otros valores también configurables son: VideoAccel, para determinar el tipo de aceleración; VideoRender para determinar el tipo de render, Icon para establecer un icono de ventana a nuestra aplicación y VideoWindow para establecer la ejecución en modo pantalla completa o no.
Las opciones del VideoAccel y VideoRender son:

ACCEL_HARDSMOOTH
ACCEL_HARDSPEED
ACCEL_SOFTWARE
RENDER_DEFAULT
RENDER_DGA
RENDER_DIRECTX
RENDER_FBCON
RENDER_OPENGL
RENDER_WINDIB
RENDER_X11

Nota temporal: ¿Creéis necesario explicar cada opción aquí o dejamos esto para consulta del lector en la documentación?.

Una vez tenemos la configuración definida, podemos establecer dicha configuración con la función CRM32Pro.SetVideoMode().

Código [Seleccionar] Expand


   if(!CRM32Pro.SetVideoMode())
   {
       CRM32Pro.Quit();
       return 1;
   }


Cargando imágenes
Ahora que ya tenemos el modo de vídeo en funcionamiento, llega el momento de cargar las imágenes, para ello necesitaremos definirnos unas superficies que será donde colocaremos nuestras imágenes.

Código [Seleccionar] Expand


   SDL_Surface *logo = NULL;   //Las superficies que utilizaremos
   SDL_Surface *background = NULL;

   background = IImage->Load("imagenes.dpf","background");
   logo = IImage->Load("imagenes.dpf","logo");

La función para cargar las imágenes es IImage->Load(char *fileDPF, char *imgname, sHeaderIPF *header=NULL). Aquí utilizamos uno de los módulos de CRM32Pro, el IImage. El primer parámetro que tenemos que pasarle es la localización de nuestro paquete de recursos y después el nombre de la imagen que hemos definido dentro del paquete. El último parámetro es una estructura sHeadrIPF para poder definir algunas variables de la imagen, como el valor alpha (transparencia) los bps, colorKey, nombre o tamaño de la imagen.

Nota provisional: no entiendo que sentido tiene definir aquí el nombre y tamaño, puedes aclararme para que sirve esto Azazel?

Ahora vamos a pasar a la tarea del "blitting", para ello utilizaremos la siguiente función:

int CRM32Pro.Blit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface
*dst, SDL_Rect *dstrect);

Esta función copia zonas rectangulares de una superficie a otra. Si observamos los parámetros, se dividen en dos bloques, SDL_Surface del src (origen) o el dst (destino) y
SDL_Rect también del src o el dst. El primer tipo ya lo conocemos, son las superficies de unas imágenes, mientras que el segundo es un rectángulo, tiene la siguiente estructura:
typedef struct{
Sint16 x, y;
Uint16 w, h;
} SDL_Rect;
De esta forma podemos definir dos rectángulos, el del origen para definir que parte copiar y el de destino para definir en dónde copiar la imagen. Veamos entonces como copiamos el logo en la posición 100x100 del fondo:

Código [Seleccionar] Expand


   SDL_Rect dest;

   dest.x = 100;
   dest.y = 100;
   dest.w = logo->w;
   dest.h = logo->h;

   CRM32Pro.Blit(background,NULL,CRM32Pro.screen,NULL);
   CRM32Pro.Blit (logo,NULL,CRM32Pro.screen,&dest);

En el código podemos observar como la superficie de destino en los dos casos es CRM32Pro.screen, esta es la superficie de la pantalla que hemos definido con CRM32Pro.SetVideoMode().

Tenemos que tener en cuenta que una vez utilizadas las superficies tenemos que liberarlas de memoria para que no nos sigan ocupando espacio innecesario:

Código [Seleccionar] Expand


   CRM32Pro.FreeSurface(background);
   CRM32Pro.FreeSurface(logo);


Ahora que ya tenemos todo montado llega el turno de mostrarlo por pantalla, esto lo haremos con la función SDL_Flip(SDL_Surface *screen)

Código [Seleccionar] Expand


   SDL_Flip(CRM32Pro.screen);


Para acabar crearemos un pequeño loop para que la imagen no aparezca y desaparezca sin más, de esta forma nos esperaremos a que el usuario presione una tecla.

Código [Seleccionar] Expand


   SDL_Event event;

   while(done == 0) {
       while ( CRM32Pro.Update(&event) ) {
           if ( event.type == SDL_KEYDOWN )
               done = 1;
       }
   }


Descargar archivos del tutorial

:( toy perdio :(

Llevo un rato intentando configurar CRM32Pro en Code::Blocks y no tengo ni idea de pk falla.

Cuando intento compilar el ejemplo de "Basic Code" me sale el siguiente error:

Linking console executable: bin\Debug\CRM32 Pro.exe
C:\MinGW\lib/libmingw32.a(main.o):main.c:(.text+0x106): undefined reference to `WinMain@16'
collect2: ld returned 1 exit status
Process terminated with status 1 (0 minutes, 1 seconds)
0 errors, 0 warnings

Segun esto el erro es que no hay main (cuando logicamente si que lo hay) y tengo todas las librerias bien configuradas y tal (o eso creo) alguina idea?

Bueno, ya habéis visto que hemos decidido programar el juego en C++ y Lua, con la librería de SDL y el IDE Code::Blocks.

¿Qué os parecen estas decisión?
Estuvimos valorando otras IDEs como Dev-C++, pero al final nos decantamos por CodeBlocks por estar más actualizada y tener un buen soporte. Como restricciones teníamos que fuera gratuito y es aquí cuando las alternativas se reducen considerablemente.

Lo mismo con SDL. Investigando un poco (en 2D) y viendo alternativas (como Allegro), nos decantamos por SDL, los motivos no los podemos decir claramente (fue bastante arbitrario dada la similitud de las librerías), pero al programar nuestro juego en C++ hemos encontrado más acertado SDL que no Allegro que esta programada en C.
¿Opiniones? (supongo que por aquí ya habéis discutido más de una vez el tema de Allegro vs. SDL y me podéis redirigir a otro hilo)

Finalmente, ¿Qué opináis sobre la decisión de utilizar Lua para parámetros de configuración y estas cosas?