Curso programación de videojuegos con SDL – Moviendo una imagen por la pantalla

Tras cargar la imagen y quedarse estática en la pantalla os darán ganas de moverla. Aprendamos a como moverla por la pantalla con las flechas del teclado. Aprovecharemos para cambiar la forma de salirnos de la aplicación, ahora lo podremos hacer mediante la tecla ESC o haciendo clic en el cierre de la ventana. Veamos como en el caso anterior lo que debemos incluir:

  1. Declaramos un entero para las coordenadas X e Y de nuestro avión:int posicionJugadorX=320, posicionJugadorY=40;
  2. Declaramos un puntero, para que se almacene un vector dinámico con las teclas pulsadas:Uint8* teclas;
  3. Cambiamos la estructura del programa. Ahora, tras inicializar todo, parte que terminamos cambiando el título a la ventana, pasamos a hacer un bucle para que el programa se ejecute hasta que el jugador quiera salir.while(!terminar)
  4. Usamos la variable posicion tanto para dibujar el fondo como el avión en cada paso del bucle:SDL_BlitSurface(fondo, NULL, screen, &posicion); …posicion.x=posicionJugadorX; posicion.y=posicionJugadorY; SDL_BlitSurface(jugador, NULL, screen, &posicion);
  5. Bucle para detectar salidas (pulsación de ESC o de la cruz de cerrar programa):while ( SDL_PollEvent(&event) ) {if(event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE)terminar = 1;}
  6. Finalmente, el resto de las teclas:teclas = SDL_GetKeyState(NULL);if(teclas[SDLK_UP]) { posicionJugadorY -= 2; }if(teclas[SDLK_DOWN]) { posicionJugadorY += 2;}if(teclas[SDLK_LEFT]) { posicionJugadorX -= 2; }if(teclas[SDLK_RIGHT]) { posicionJugadorX += 2; }

De esta manera conseguiremos que nuestro avión se mueva a través de la pantalla siguiendo nuestras órdenes. Modificaremos nuestro fichero Makefile para poder compilar este ejemplo. El resultado es el mismo que antes pero podemos mover nuestro avión. El código completo:

#include <stdio.h> #include <stdlib.h> #include <SDL/SDL.h> #define MASK 255, 255, 255 int main() { SDL_Surface *screen; SDL_Surface *fondo; SDL_Surface *jugador; SDL_Event event; int terminar=0; SDL_Rect posicion; int i, j; int posicionJugadorX=320, posicionJugadorY=40; Uint8* teclas; if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("No se pudo inicializar SDL: %s\n", SDL_GetError()); exit(1); } fondo = SDL_LoadBMP("fondo.bmp"); jugador = SDL_LoadBMP("avion.bmp"); SDL_SetColorKey (jugador, SDL_SRCCOLORKEY, SDL_MapRGB (jugador->format, MASK)); screen = SDL_SetVideoMode(640, 480, 16, SDL_HWSURFACE ); if( screen == NULL ) {   printf( "Error al entrar a modo grafico: %s\n", SDL_GetError() );   SDL_Quit();   return -1; } SDL_WM_SetCaption( "Moviendo nuestro avion", "Moviendo nuestro avion" ); while(!terminar) {   for (i=0; i<10; i++)     for (j=0; j<10; j++)     {       posicion.x=64*i;       posicion.y=48*j;       SDL_BlitSurface(fondo, NULL, screen, &posicion);     }   posicion.x=posicionJugadorX;   posicion.y=posicionJugadorY;   SDL_BlitSurface(jugador, NULL, screen, &posicion);   SDL_Flip(screen);   /*salida con ESC o cerrar ventana*/   while ( SDL_PollEvent(&event) )   {     if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE)       terminar = 1;   }   /* Vemos el estado indivudal de las teclas de la cruceta */   teclas = SDL_GetKeyState(NULL);   if (teclas[SDLK_UP]) { posicionJugadorY -= 2; }   if (teclas[SDLK_DOWN]) { posicionJugadorY += 2;}   if (teclas[SDLK_LEFT]) { posicionJugadorX -= 2; }   if (teclas[SDLK_RIGHT]) { posicionJugadorX += 2; } } SDL_Quit(); return 0; } read more

Publicado: 13 agosto 2011
Por: F. Javier Carazo Gil
Leer más » 5 Comentarios

Curso programación de videojuegos con SDL – Cargando imágenes con SDL

Ya hemos visto cómo cargar una ventana simple con SDL y ponerle título. No está mal para comenzar, pero estaréis deseando hacer algo más. Lo siguiente que haremos será cargar una imagen en pantalla operación que se repite multitud de veces en cualquier juego a la hora de cargar tanto fondos, como personajes.

Para carga una imagen haremos lo siguiente:

  1. Declaramos un puntero a una variable del tipo SDL_Surface: SDL_Surface *jugador;
  2. Declaramos una variable del tipo SDL_Rect:SDL_Rect posicion;
  3. Cargamos el mapa de bits: jugador=SDL_LoadBMP(“avion.bmp”);
  4. Asignamos la posición, mediante sus coordenadas X e Y:
    posicion.x=320;
    posicion.y=400;
  5. Acoplamos la imágen al “screen”: SDL_BlitSurface(jugador, NULL, screen, &posicion);
  • jugador: superficie (SDL_Surface) que queremos insertar o de orígen.
  • NULL: indica que queremos insertar toda la imagen.
  • screen: superficie dónde se va a insertar.
  • posicion: la posición dónde se colocará.

Ya tenemos la imagen cargada. El problema de cargarla de esta manera es que no tenemos transparencias y tendríamos la imagen nuestra, avión sobre fondo blanco, apareciendo sobre el fondo, azul (imitando al mar), por lo que alrededor del avión quedaría un recuadro blanco que sin duda quedaría muy mal. Para eliminar este fondo blanco y hacer que SDL lo cargue transparente hacemos lo siguiente:

  1. Definimos una máscara con el color RGB del color a hacer transparente. En este caso el blanco, RGB(255,255,255): #define MASK 255, 255, 255
  2. Hacemos transparentes los píxeles blancos: SDL_SetColorKey (jugador, SDL_SRCCOLORKEY, SDL_MapRGB (jugador->format, MASK));
  • jugador: la superficie en la que aplicar el efecto.
  • SDL_SRCCOLORKEY: Indicar hacer transparencia.
  • SDL_MapRGB jugador->format: formato de la imagen
  • SDL_MapRGB MASK: máscara, en realidad son tres parámetros, (r,g,b).

De esta manera conseguimos un resultado así:

Veamos el código al completo:

#include <stdio.h> #include <stdlib.h> #include <SDL.h> #define MASK 255, 255, 255 int main() { SDL_Surface *screen; SDL_Surface *fondo; SDL_Surface *jugador; SDL_Event event; int terminar=0; SDL_Rect posicion; int i, j; if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("No se pudo inicializar SDL: %s\n", SDL_GetError()); exit(1); } fondo = SDL_LoadBMP("fondo.bmp"); jugador = SDL_LoadBMP("avion.bmp"); SDL_SetColorKey (jugador, SDL_SRCCOLORKEY, SDL_MapRGB (jugador->format, MASK)); screen = SDL_SetVideoMode( 640, 480, 16, SDL_HWSURFACE ); if( screen == NULL ) { printf( "Error al entrar a modo grafico: %s\n", SDL_GetError() ); SDL_Quit(); return -1; } SDL_WM_SetCaption( "Moviendo nuestro avion", " Moviendo nuestro avion" ); for (i=0; i<10; i++) for (j=0; j<10; j++) { posicion.x=64*i; posicion.y=48*j; SDL_BlitSurface(fondo, NULL, screen, &posicion); } posicion.x=320; posicion.y=400; SDL_BlitSurface(jugador, NULL, screen, &posicion); SDL_Flip(screen); while(terminar == 0) { while ( SDL_PollEvent(&event) ) { if ( event.type == SDL_KEYUP ) terminar = 1; } } SDL_Quit(); return 0; } read more

Publicado: 2 agosto 2011
Por: F. Javier Carazo Gil
Leer más » 13 Comentarios

Curso programación de videojuegos con SDL – ¡Hola mundo!

Comenzaremos con un ejemplo mínimo de SDL dónde abriremos una ventana con el título “Hola Mundo”. Para ello además del código en C prepararemos el Makefile para compilarlo. Podríamos haber usado un entorno de desarrollo integrado como Anjuta por ejemplo, pero ya que se trata de una iniciación a SDL lo mejor creo que es trabajar directamente sobre el compilador y los Makefile.

Makefile

Comenzaremos con el Makefile. Incluiremos además de “sdl-config” las librerías que hemos instalado en el paso anterior:

SDL_CONFIG = sdl-config
DEFAULT_CFLAGS = $(shell $(SDL_CONFIG) --cflags)
MORE_CFLAGS = -O2 

CFLAGS = $(DEFAULT_CFLAGS) $(MORE_CFLAGS)
CXXFLAGS = $(DEFAULT_CFLAGS) $(MORE_CFLAGS) -fno-exceptions -fno-rtti 

LDLIBS = -lSDL_image -lSDL_mixer -lSDL_ttf -lSDL_net
 $(shell $(SDL_CONFIG) --libs) 

all: holamundo_sdl
holamundo_sdl: holamundo_sdl.c 

clean:
	rm -f *~
	rm -f main.o main

holamundo_sdl.c

Pasemos ahora a implementar nuestro primer programa con SDL. Será lo más sencillo posible y básicamente realizará las dos siguientes acciones:

  • Abrirá una ventana con el título “Hola Mundo SDL”.
  • Se cerrará cuando pulsemos “Tecla hacia arriba”.

#include <stdio.h> #include <stdlib.h> #include <SDL.h> int main(int argc, char *argv[]) { SDL_Surface *image, *screen; SDL_Rect dest; SDL_Event event; int terminar=0; atexit(SDL_Quit); if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("No se pudo iniciar SDL: %s\n",SDL_GetError()); exit(1); } screen = SDL_SetVideoMode(640,480,24,SDL_HWSURFACE); if (screen == NULL) { printf("No se puede inicializar el modo gráfico: %s\n", SDL_GetError()); exit(1); } SDL_WM_SetCaption("Hola Mundo SDL","Hola Mundo SDL"); SDL_Flip(screen); while(terminar == 0) { while ( SDL_PollEvent(&event) ) { if ( event.type == SDL_KEYUP ) terminar = 1; } } return 0; } read more

Publicado: 26 julio 2011
Por: F. Javier Carazo Gil
Leer más » 11 Comentarios

Curso programación de videojuegos con SDL – Instalación y configuración

Una vez introducidos en qué es SDL pasemos a la parte práctica. Comencemos instalando los componentes necesarios. Si usas Ubuntu, Debian o cualquier otra distribución que use Synaptic o APT instalaremos los siguientes paquetes: read more

Publicado: 19 julio 2011
Por: F. Javier Carazo Gil
Leer más » 3 Comentarios

Curso programación de videojuegos con SDL – Allegro, otra librería para el desarrollo de videojuegos

Como en (casi) todos los demás aspectos del software libre, existen más alternativas para este mismo propósito. La más famosa de todas es Allegro y tras SDL es la más potente. Algunos consideran OpenGL como una alternativa, sin embargo creo que no debería considerarse así  puesto que se puede integrar perfectamente dentro de un proyecto en SDL o en Allegro para dotar de gráficos tridimensionales al juego.

Hablando de Allegro podemos decir que a grandes rasgos se trata de un conjunto de librerías con el mismo propósito que SDL. Ofrece una funcionalidad realmente parecida. Sin embargo hay aspectos en que se diferencian: read more

Publicado: 15 julio 2011
Por: F. Javier Carazo Gil
Leer más » 3 Comentarios

Curso programación de videojuegos con SDL – ¿Qué es SDL?

En la Wikipedia encontramos que: ”LibSDL es un conjunto de librerías desarrolladas con el lenguaje C que proporcionan funciones básicas para realizar operaciones de dibujado 2D, gestión de efectos de sonido y música, y carga y gestión de imágenes. SDL es una abreviatura en inglés de Simple DirectMedia Layer.”

Resaltar como podéis ver que se trata de un conjunto de librerías para C encargada de todos los aspectos que a la hora de crear un juego faltan en las librerías básicas de C. Con ella podemos controlar las pulsaciones sobre el teclado, cargar imágenes, mover sprites o reproducir un sonido. Usando SDL tendremos toda la libertad del mundo para desarrollar un juego tal como nos parezca. SDL se convierte sólo en la herramienta básica para hacer todo aquello que necesitamos, pero a un nivel que no interviene más que en eso. read more

Publicado: 13 julio 2011
Por: F. Javier Carazo Gil
Leer más » 5 Comentarios

Curso programación de videojuegos con SDL – Introducción

Con esta entrada presento el próximo curso que Linux Hispano os va a presentar: “Programación de videojuegos con SDL“. Constará de una serie de entregas que irán  apareciendo periódicamente en forma de entradas, al igual que en el caso de los cursos que ya están publicados:

Aún recuerdo la primera vez que cogí entre mis manos el mando de la Master System II que mis tíos habían regalado a mi primo por Reyes. Estuve jugando al juego más popular de la primera ”mascota” de Sega, Alex Kidd in the miracle world. Fue mi primer acercamiento al ocio digital y en ese mismo momento me pregunté, ¿cómo estará hecho ese videojuego? read more

Publicado: 12 julio 2011
Por: F. Javier Carazo Gil
Leer más » 6 Comentarios

Enviar correos con C# usando Mono

Si necesitáis conectaros a un servidor SMTP para hacer envíos de correos desde una aplicación que corre Mono, os dejo el código siguiente que seguro que os es de utilidad. Este ejemplo en concreto envía un mensaje usando un SMTP que requiere autenticación, si necesitáis alguna variantes: varios destinatarios, SMTP sin autenticación o cualquier otra cosa, ¡preguntad en los comentarios!

public static void Main (string[] args) { MailAddress para = new MailAddress("para@direccion.com"); MailAddress desde = new MailAddress("desde@direccion"); MailMessage mensaje = new MailMessage(desde, para); mensaje.Subject = "Asunto"; mensaje.Body = @"Cuerpo del correo"; SmtpClient cliente = new SmtpClient("direccion_servidor", puerto); cliente.Credentials = new System.Net.NetworkCredential ("nombre_usuario", "contraseña_usuario"); Console.WriteLine("Enviando mensaje de correo para: " + para.User + " en " + para.Host + " usando el servidor=" + cliente.Host + "."); try { cliente.Send(mensaje); Console.WriteLine("Mensaje enviado"); } catch (Exception ex) { Console.WriteLine("Problemas enviando mensaje: " + ex.ToString()); } } read more

Publicado: 6 junio 2011
Por: F. Javier Carazo Gil
Leer más » 5 Comentarios

Curso C# con Mono – Interfaces

Si la última vez que hablamos de C#, estuvimos comentando la herencia, hoy hablaremos de las interfaces.

Interfaces en lenguajes de programación orientados a objetos

Todos conoceréis las interfaces gráficas de usuario. Son el mecanismo software que nos permite interactuar de manera más o menos intuitiva con unas funcionalidades que nos provee el programa. Es decir, es un mecanismo de comunicar distintos niveles, ocultando los detalles de la implementación.

Eso mismo son las interfaces en lenguajes de programación orientados a objetos como son C# o Java. Se trata de un conjunto de métodos, delegados o eventos, que no tienen implementación. El desarrollo de la funcionalidad de los mismos, se hace en la clase que implementa la interfaz. Es un concepto similar a los prototipos de funciones en lenguajes como C.

Declaración

Siguiendo con el ejemplo de los motores, comentado en la entrega anterior dedicada a la herencia, vamos a crear un interfaz IMotor, a la que luego haremos referencia desde la implementación de la clase. He incluido un método más para que se vean más claras las posibilidades.

interface IMotor { // declaración de propiedades int Potencia { get; set; } decimal Par { get; set; } // declaración de métodos void printInfo(); // declaración de eventos } public class Motor : IMotor { int potencia; decimal par; public int Potencia { get { return this.potencia; } set { potencia = value; } } public decimal Par { get { return this.par; } set { par = value; } } public void printInfo() { Console.WriteLine("La potencia es " + Potencia.ToString() + " y el par: " + Par.ToString()); } } read more

Publicado: 24 enero 2011
Por: F. Javier Carazo Gil
Leer más » 8 Comentarios

Curso C# con Mono – Herencia

Siguiendo con características propias de los lenguajes de alto nivel con orientación a objetos, llegamos a la herencia.

¿Qué es la herencia?

En programación orientada a objetos, la herencia es el mecanismo básico para crear nuevas clases (hijas o derivadas), basándonos en clases anteriores (a la que llamaremos padre, base o superclase). La relación es similar a la que se produce en muchas situaciones de la vida cotidiana, por ejemplo en el campo de la biología en las relaciones padre-hijo.

Gracias a este mecanismo, podemos basarnos en clases anteriores, para crear nuevas clases sobre trabajo ya hecho, de forma que extendemos la funcionalidad de la clase padre hacia un campo nuevo, sin tener que volver a reescribir todo el contenido de la misma.

Ejemplos

Hay multitud de casos de este tipo. Por ejemplo, la clase padre excepción, provee unos métodos y atributos generales para todas las excepciones posibles. De ella derivan excepciones concretas, por ejemplo de división entre cero, que además de los métodos y atributos ya existentes, añaden funcionalidad extra, pero reutilizando toda la funcionalidad de la clase padre.

Otro ejemplo clásico es el de los controles de una interfaz gráfica. La clase control es la padre de todo un abanico de clases hijo. La clase control tiene por ejemplo la situación (todos los controles tienen situación) pero cada clase hijo aporta nuevas funcionalidades (por ejemplo, sus propios eventos).

Implementación

Veremos la implementación en C# con un ejemplo concreto. Ya que están tan de moda los vehículos eléctricos, vamos a implementar una serie de clases, con herencia, que reflejen la siguiente realidad:

  • Clase padre: motor, tendrá las características propias de toda clase de motores, gestionaremos potencia (entero en kW) y par (decimal en Nm)
  • Clase hijo: eléctrico, contendrá información exclusiva de los motores eléctricos, intensidad (entero en amperios), potencial (entero en voltios)
  • Clase hijo: de combustión interna, gestionará información de este tipo de motores. Cilindrada (entero en cc.), número de cilindros (entero) y emisiones de CO2 (decimal en gr/km)

public class Motor{ int potencia; decimal par; public int Potencia { get { return this.potencia; } set { potencia = value; } } public decimal Par { get { return this.par; } set { par = value; } } } public class Electrico : Motor{ int intensidad; int potencial; public int Intensidad { get { return this.intensidad; } set { intensidad = value; } } public int Potencial { get { return this.potencial; } set { potencial = value; } } } public class CombustionInterna : Motor{ int cilindrada; int cilindros; public int Cilindrada { get { return this.cilindrada; } set { cilindrada = value; } } public int Cilindros { get { return this.cilindros; } set { cilindros = value; } } } read more

Publicado: 4 enero 2011
Por: F. Javier Carazo Gil
Leer más » 8 Comentarios

Suscríbete

RSS de Linux Hispano

Síguenos

Twitter
Facebook

Contacta

email

Páginas

Entradas recientes

Categorías

Meta

Linux Hispano 2020
Tema de WordPress Vega por LyraThemes