ES

www.codigo-facil.com > Programar videojuegos con Object Pascal y SDL (2)

Programar videojuegos con Object Pascal, SDL y OpenGL


Capitulo 2: Dibujando sprites en pantalla.

Capitulos

Programar videojuegos con Object Pascal y SDL (1)

Primer capitulo de una serie en la que intentare explicar de forma sencilla los primeros pasos para desarrollar un mini juego en 2d.

En este articulo veremos las herramientas que vamos a utilizar y definiremos lo que sera el nucleo principal de nuestro juego.

Programar videojuegos con Object Pascal y SDL (2)

En este capitulo crearemos la clase sprite, que nos servira para poder dibujar los elementos que van a interactuar en nuestro juego.

Veremos como queda nuestro avion protagonista en la pantalla

Programar videojuegos con Object Pascal y SDL (3)

En este capitulo veremos como desplazar nuestro avion con las teclas del teclado. Ademas añadiremos un fondo al que aplicaremos un efecto para dar la sensacion de movimiento.

Introduccion


En las decadas de los 80 y 90 los elementos que veiamos en un videojuego se les denominaban sprites. Un sprite es una figura grafica o mapa de bits dibujado en la pantalla del ordenador. Ademas el sprite puede estar formado de otros sub-sprites para poder representar los diferentes estados o movimientos que pudiera adoptar segun el juego.

Para nuestro juego vamos a utilizar sprites para la visualizacion de los aviones que van a aparecer, aunque deberemos de implementar algunas clases para adaptar el desarrollo al entorno OpenGl en el que estamos trabajando, ya que vamos a representar cada elemento del juego a traves de 2 triangulos. Estos 2 triangulos estaran alineados de tal manera que formaran un cuadrado.


Esto quiere decir que debemos incluir en nuestra clase los metodos necesarios para poder definir los vertices que serviran para la formacion de los triangulos.


Pero aqui no acaba la cosa, ya que ahora nos faltaria mapear la textura dentro de cada triangulo para la correcta visualizacion del sprite.


Para ello vamos a incluir 2 coordenadas mas (u,v) a cada vertice y que equivalen a las coordenadas x,y de la textura. Estas coordenadas toman valores reales y oscilan entre 0 y 1. Asi para un sprite de 100px ancho y 100px de alto tendriamos las siguientes coordenas para formar los triangulos y mapear la correspondiente textura :

Notese que tomo por punto de inicio el origen de coordenadas (0,0) y que ademas los vertices para cada triangulo se definen en el sentido de las agujas del reloj.

Coordenadas trianglo 1 :

v1 (x=0 , y=0 , z=0 , u=0 , v=1 )
v2 (x=0 , y=100 , z=0 , u=0 , v=0 )
v3 (x=100 , y=100 , z=0 , u=1 , v=0 )

Coordenadas triangulo 2 :

v1 (x=100 , y=100 , z=0 , u=1 , v=0 )
v2 (x=100 , y=0 , z=0 , u=1 , v=1 )
v3 (x=0 , y=0 , z=0 , u=0 , v=1 )

En este capitulo vamos a ir viendo paso a paso como implementar los diferentes procedimientos para realizar todas estas tareas y empezar asi a dibujar sprites por pantalla.

Creando la unidad U_Sprite.pas


Vamos a empezar añadiendo una nueva unidad a nuestro proyecto y la guardaremos con el nombre de "U_Sprite.pas". En esta unidad vamos a implementar todo lo necesario para que podamos añadir sprites a nuestros juego.

Como hemos hecho en anteriores ocasiones voy a ir colocando el codigo explicando las partes que considere mas relevantes. 

Librerias que vamos a incluir en la unidad.

Antes de empezar vamos a ver que librerias necesitamos antes de empezar a desarrollar nuestros procedimientos.

  1. unit U_Sprite;
  2.  
  3. {$mode objfpc}{$H+}
  4.  
  5. interface
  6.  
  7. uses
  8.   Windows,
  9.   gl,
  10.   sdl2,
  11.   sdl2_image,
  12.   u_sdl;
  13.  
  14. (...)


Declarando la clase sprite.

Una vez que ya hemos inlcluido las librerias necesarias vamos a crear una nueva clase que nos servira para crear los diferentes sprites que vamos a utilizar.

  1. (...)

  2. type
  3. Tsprite = class
  4.   public    
  5.     Superficie: PSDL_Surface; //superficie temporal donde se carga la textura que utiliza
  6.     img: boolean; //sirve para indicar si el sprite tiene una imagen o no
  7.     x, y: integer; //coordenadas de sprite en la pantalla
  8.     subW, subH: integer; //ancho y alto del sprite
  9.     subX, subY: integer; //subsprite que se ha seleccionado para dibujar
  10.     numX, numY: integer; //columnas y filas con el total de subsprites
  11.     opacity: single; //nivel transparencia del sprite
  12.     {
  13.     Como hemos visto en la introduccion cada sprite se forma
  14.     con la alineacion de 2 triangulos formando un cuadrado, 
  15.     aqui declaro un array de 2 posiciones del tipo TTriangulo, 
  16.     una nueva clase que veremos mas abajo
  17.     }
  18.     poligono: array[1..2] of TTriangulo;

  19.     {
  20.     Matriz bidimensional con el total de texturas que puede tener 
  21.     un sprite, esto es para poder crear sprites con subsprites y asi poder
  22.     representar diferes movimientos o estados del mismo
  23.     }
  24.     textures: array [0..MAX_TEXTURAS - 1, 0..MAX_TEXTURAS - 1] of TTexture;
  25.     
  26.     {
  27.     Coordenadas para saber cual es el centro del sprite, segun su ancho 
  28.     y alto, esto me sirve para el momento en el que dibujamos el sprite, 
  29.     diciendo a opengl se posicione en el centro, esto es util en caso de 
  30.     querer hacer rotaciones del sprite ya que asi rota sobre su eje.
  31.     }
  32.     centX1, centX2, centY1, centY2: shortint;

  33.     {
  34.     Defino un constructor de la clase, con la imagen que se quiere 
  35.     vincular y el acho y alto de cada frame
  36.     }
  37.     constructor Create(imgP: string; subWP, subHP: integer);

  38.     {
  39.     Destructor de la clase, para liberar memoria cuando se elimine un sprite
  40.     }
  41.     destructor Destroy; override;
  42.     {
  43.     Procedimiento para poder crear los 2 triangulos que se utilizan
  44.     }
  45.     procedure crearPoligono;
  46.     {
  47.     Procedimiento para crear las diferetes texturas segun la imagen 
  48.     }
  49.     procedure crearTexturas;
  50.     {
  51.     Procedmiento que se encarga de dibujar el sprite en pantalla
  52.     }
  53.     procedure dibujar;

  54.   private
  55.     {
  56.     ALgunas varaibles privadas para uso inteno de clase,
  57.     las primeras son para guardar el ancho y alto de la 
  58.     textura que se va a crear en opengl, recordar que debe 
  59.     ser potencia de 2. La ultima variable guarda el nombre 
  60.     de la imagen
  61.     }
  62.     textDimeW, textDimeH: word;
  63.     archivo: string[15];
  64. end;
  65.  
  66. (...)

Como podemos ver en el codigo hacemos referencia a una constante "MAX_TEXTURAS" que aun no hemos declarado, esta es su declaracion :

  1. unit U_Sprite;
  2.  
  3. {$mode objfpc}{$H+}
  4.  
  5. interface
  6.  
  7. uses
  8.   Windows,
  9.   gl,
  10.   sdl2,
  11.   sdl2_image,
  12.   u_sdl;
  13.  
  14. const
  15. {
  16. Maximos de texturas que puede tener un sprite, sirve
  17. nos permite crear sprites con varios subsprites para sus
  18. animaciones
  19. }
  20. MAX_TEXTURAS = 20;

  21. (...)  

Ademas en la clase sprite hemos incluido dos tipos de variables ( TTriangulo y TTexture ) que aun no hemos definido y que vamos a ver a continuacion antes de continuar con la implementacion.
La clase TTriangulo y TVertice.

Estas van a ser dos clases sencillas que nos permitiran especificar las coordenadas para la construcion de los dos triangulos que se utilizan para formar un sprite. Recordad que a las coordenas (x,y,z) añadimos la coordenadas (u,v) a cada vertice para poder mapear la textura.

La definicion de estas clases es la siguiente :

  1. (...)

  2. type
  3.   TVertice = class
  4.     x, y, z: GLfloat; // Coordenadas para dibujar el triangulo
  5.     u, v: GLfloat; //coordenadas para dibujar la textura (valor entre 0 y 1)
  6.     constructor Create(xP, yP, zP, uP, vP: GLfloat);
  7.   end;
  8.  
  9.   TTriangulo = class
  10.     vertice: array[1..3] of TVertice;
  11.     constructor Create(x1, y1, z1, u1, v1, x2, y2, z2, u2, v2, x3,
  12.     y3, z3, u3, v3: GLFloat);
  13.   end;
  14.  
  15. (...)

Como vemos son dos clases sencillas a la que solo nos falta la implementacion de sus contructores.

  1. (...)

  2. implementation
  3.  
  4. constructor TVertice.Create(xP, yP, zP, uP, vP: GLFloat);
  5. begin
  6.   self.x := xP;
  7.   self.y := yP;
  8.   self.z := zP;
  9.   self.u := uP;
  10.   self.v := vP;
  11. end;
  12.  
  13. constructor TTriangulo.Create(x1, y1, z1, u1, v1, x2, y2, z2, u2, v2,
  14. x3, y3, z3, u3, v3: GLFloat);
  15. begin
  16.   vertice[1] := tvertice.Create(x1, y1, z1, u1, v1);
  17.   vertice[2] := tvertice.Create(x2, y2, z2, u2, v2);
  18.   vertice[3] := tvertice.Create(x3, y3, z3, u3, v3);
  19. end

  20. (...)

Ahora ye tenemos lo necesario para poder definir los triangulos en la clase sprite. Vamos a continuar con la definicion de la otra clase que nos faltaba.
La clase TTexture

Vamos a implementar la clase que nos permitira crear las texturas para su utilizacion en OpenGL. Empezamos viendo su declaracion :

  1. (...)

  2. type
  3. TTexture = class
  4.   ID: GLuint; //identificador que nos dara OpenGL para la textura

  5.   constructor Create(base: PSDL_surface; x, y, wS, hS: integer;
  6.   textDimeW, textDimeH: word);
  7. end;

  8. (...)

Como vemos hemos declarado el constructor con una serie de parametros, estos parametros son la superficie donde se ha cargado la imagen del sprite, las coordenadas x, y donde quiero copiar y por ultimo el ancho y alto de la textura que vamos a crear. Recordad que las texturas que se crean en openGL debe ser potencia de 2. A continuacion la implementacion del contructor :

  1. (...)

  2. implementation 

  3. constructor TTexture.Create(base: PSDL_surface; x, y, wS, hS: integer;
  4. textDimeW, textDimeH: word);
  5. var
  6. Temp: PSDL_Surface;
  7. Org, Des: TSDL_Rect;
  8. begin
  9.  
  10.   {
  11.   Creo una superficie con las dimensiones de la textura
  12.   }
  13.   Temp := SDL_CreateRGBSurface(SDL_SWSURFACE, textDimeW, textDimeH, 32,
  14.   $000000FF, $0000FF00, $00FF0000, $FF000000);
  15.  
  16.   {
  17.   Coordenadas del area que queremos copiar de la textura
  18.   y la coordenadas del espacion de la superficie destino
  19.   donde vamos a pegar
  20.   }
  21.   org.x := x;
  22.   org.w := wS;
  23.   org.y := y;
  24.   org.h := hS;
  25.   des.x := 0;
  26.   des.w := org.w;
  27.   des.y := 0;
  28.   des.h := org.h;
  29.  
  30.   {
  31.   Pego dentro de la superficie el trozo del subsprite que
  32.   corresponda de la imagen original
  33.   }
  34.   SDL_BlitSurface(base, @Org, Temp, @Des);
  35.  
  36.   {
  37.   Le pedimos a OpenGL que nos asigne un identificador de la textura
  38.   }
  39.   glGenTextures(1, ID);
  40.  
  41.   {
  42.   Enviamos la textura a la superficie de vídeo con OpenGL
  43.   }
  44.   glBindTexture(GL_TEXTURE_2D, ID);
  45.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Filtro de
  46.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // suavizado
  47.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); // Para que no se
  48.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); // repita la textura
  49.   glTexImage2D(GL_TEXTURE_2D, 0, 4, textDimeW, textDimeH, 0, GL_RGBA,
  50.   GL_UNSIGNED_BYTE, Temp^.pixels);
  51.  
  52.   {
  53.   Liberamos la superficie temporal que habiamos creado
  54.   }
  55.   SDL_FreeSurface(Temp);
  56.   temp := nil;
  57. end;
  58.              
  59. (...)

Antes de continuar comentar que debemos incluir en la unidad los procedimientos externos que hemos invocado en la implementacion del contructor de la clase TTexture:

  1. (...)

  2. procedure glGenTextures(n: GLsizei; var textures: GLuint);  stdcall; external opengl32;
  3. procedure glBindTexture(target: GLenum; texture: GLuint);  stdcall; external opengl32;
  4.  
  5. implementation  

  6. (...)

Una vez que ya tenemos la implementacion de las clases "TTriangulo" y "TTexture" ya podemos continuar desarrollando los metodos que habimos definido en la clase "TSprite".
Implementado los metodos de la clase TSprite

Vamos a empezar viendo el constructor de la clase el cual admite 3 parametros :
  1. imgP : Indica el archivo de imagen que se asocia al sprite.
  2. subWP : Define el acho del sprite.
  3. subHP : Define el alto del sprite.
El codigo para su implementacion lo vemos a continuacion.

  1. (...)

  2. implementation

  3. (...)

  4. constructor tSprite.Create(imgP: string; subWP, subHP: integer);
  5. var 
  6.   rwop: PSDL_RWops;
  7.   i, j, iniW, iniH, wT, hT: integer;
  8.   enconW, enconH: boolean;

  9. begin

  10.   self.subW := subWP;
  11.   self.subH := subHP;
  12.  
  13.   {
  14.   Para poder dibujar los triangulos
  15.   desde el punto central del sprite
  16.   segun su ancho y alto
  17.   }
  18.   centX1 := subW div 2;
  19.   centX2 := subW - centX1;
  20.   centY1 := subH div 2;
  21.   centY2 := subH - centY1;
  22.  
  23.  
  24.   {
  25.   En openGL las texturas deben ser potencia de 2
  26.   asi que calculo el tamaño de la textura segun el
  27.   ancho y alto especificado de cada frame de sprite
  28.   mediante un bucle que se ejecuta hasta que haya 
  29.   asignado un ancho y alto compatible
  30.   }
  31.   enconW := False;
  32.   enconH := False;
  33.   iniW := 8;
  34.   iniH := 8;
  35.   while (enconW = False) or (enconH = False) do
  36.   begin

  37.     if (enconW = False) then
  38.     begin
  39.       if (iniW >= subW) then
  40.       begin
  41.         textDimeW := iniW;
  42.         enconW := True;
  43.       end
  44.       else
  45.         iniW := iniW * 2;
  46.     end;
  47.  
  48.     if (enconH = False) then
  49.     begin
  50.       if (iniH >= subH) then
  51.       begin
  52.         textDimeH := iniH;
  53.         enconH := True;
  54.       end
  55.       else
  56.         iniH := iniH * 2;
  57.     end;
  58.  
  59.   end;
  60.  
  61.   {
  62.   Selecciono el frame por defecto que se va a dibujar
  63.   }
  64.   subX := 1;
  65.   subY := 1;
  66.  
  67.   {
  68.  defino el nivel de transparecia por defecto
  69.  este valor oscila entre 0-1, por defecto sin transparencia 
  70.  para que sea totalmente transparente=0
  71.   }
  72.   opacity := 1; 
  73.  
  74.   {
  75.   La posicion que tiene el sprite en la pantalla
  76.   }
  77.   x := 0;
  78.   y := 0;

  79.   {
  80.   Compruebao si se ha especificado algun archivo
  81.   para la textura del sprite
  82.   } 
  83.   if (imgP <> '') then
  84.   begin
  85.     {
  86.     Guardo el nombre del archivo y 
  87.     coloco una bandera para indicar 
  88.     que este sprite tiene una imagen vinculada
  89.     }
  90.     archivo := imgP;
  91.     self.img := True;

  92.     {
  93.     Inicializa la matriz de texturas para este sprite
  94.     }
  95.     for i := 0 to max_texturas - 1 do
  96.       for j := 0 to max_texturas - 1 do
  97.         textures[i][j] := nil;

  98.     {
  99.     Metodo para cargar imagenes en formato png con
  100.     fondo transparente
  101.     } 
  102.     rwop := SDL_RWFromFile(PChar(imgP), 'rb');
  103.     Superficie := IMG_LoadPNG_RW(rwop);
  104.     {
  105.     Guardo el ancho y alto de la imagen 
  106.     que se ha especiifcado para el sprite
  107.     }
  108.     wT := superficie^.w;
  109.     hT := superficie^.h;
  110.     Superficie^.flags := SDL_SWSURFACE;

  111.     {
  112.     Invoco los procedimientos que se encrgan de definir
  113.     los 2 triangulos y crear las texturas en openGL
  114.     }
  115.     crearPoligono;
  116.     crearTexturas;
  117.     SDL_FreeSurface(Superficie);
  118.     Superficie := nil;
  119.   end
  120.   else
  121.   begin
  122.     {
  123.     Entra aqui en caso de no existir imgen, 
  124.     por lo que solo creo los triangulos
  125.     }
  126.     crearPoligono;
  127.     self.img := False;
  128.   end;
  129.  
  130. end;
  131.  
  132. (...)

Como podemos ver en la implementacion del constructor invocamos a los metodos para la creacion de los triangulos del sprite y de las correspondientes texturas. Vamos a continuar con la implementacion de estos dos metodos empezando por el que se encarga de la creacion de los 2 triangulos.

  1. (...)

  2. procedure tsprite.crearPoligono;
  3. begin
  4.   {
  5.   Creamos los 2 triangulos que se utilizan para dibujar un sprite
  6.   Los vertices se definen en el sentido de las agujas del reloj
  7.   Los parametros de cada triangulo se corrsponden a las coordenas x,y,z
  8.   y otros 2 para u,v que sirve para indicarnos los extremos de cada triangulo
  9.   para poder depues incluir la textura, utilizando el valor 1 para indicar que
  10.   son los puntos de extremo correspondiente al eje X y al eje Y respectivamente
  11.   Como estamos en un juego en 2D no nos preocupamos de la coordenada z
  12.   Recordar que definimos los vertices para que se dibujen los triangulos desde el 
  13.   centro del sprite segun su ancho y alto
  14.   }
  15.   poligono[1] := ttriangulo.Create(-centX1, centY1, 0, 0, 0, centX2,
  16.   centY1, 0, 1, 0, -centX1, -centY2, 0, 0, 1);
  17.   poligono[2] := ttriangulo.Create(-centX1, -centY2, 0, 0, 1, centX2,
  18.   centY1, 0, 1, 0, centX2, -centY2, 0, 1, 1);
  19. end;

  20. (...)

A continuacion vamos a ver la implementacion del metodo que se encarga de crear las texturas del sprite en OpenGl.

  1. (...)
  2.  
  3. procedure TSprite.crearTexturas;
  4. var
  5.   maxTH, maxTV: word//guardar el maximo texturas horizontal y vertical
  6.   i, j: integer;
  7.  
  8. begin
  9.  {
  10.   Calculo el total de subsprites que tiene el sprite
  11.   para recorrer la matriz de texturas para ir creandolas
  12.   }
  13.   maxTH := (Superficie^.w div subW) - 1;
  14.   maxTV := (Superficie^.h div subH) - 1;

  15.   {
  16.   Monto el bucle que recorre la matriz de texturas
  17.   para ir creandola con el subsprite troceado de la 
  18.   imagen original
  19.   }
  20.   for j := 0 to maxTV do
  21.   begin
  22.     for i := 0 to maxTH do
  23.     begin
  24.       {
  25.       Creo la textura segun el tamaño potencia de 2 con el frame que
  26.       corresponda extraido de la imagen original
  27.       }
  28.       textures[j][i] := TTexture.Create(superficie, (i * subW),(j * subH), subW,
  29.       subH, textDimeH, textDimeH);
  30.     end;
  31.   end;
  32.  {
  33.   Guardo el total de subsprites horizontales y verticales
  34.   para futuras operaciones
  35.   }
  36.   numX := trunc(Superficie^.w / SubW);
  37.   numY := trunc(Superficie^.h / SubH);
  38. end;
  39.  
  40. (...)

Una vez que ya tenemos implementados los procedimientos para definir los triangulos y crear las texturas del sprite, ya solo nos falta implementar el metodo que se encargue de dibujarlo en la pantalla. 

  1. (...)
  2.  
  3. procedure TSprite.dibujar;
  4. var
  5.   j, k: integer;
  6.   selTX, selTY: word;
  7.   tmpU, tmpV: single;
  8. begin
  9.   {
  10.   Reinicio la matriz de modelado y ajusto 
  11.   la transparencia y superposicion de color (por defecto ninguna)
  12.   }
  13.   glLoadidentity();
  14.   glColor4f(1, 1, 1, opacity);
  15.  
  16.   if (img = True) then
  17.   begin
  18.     {
  19.     Activo la utilizacion de texturas y seleccion el 
  20.     frame que se va a utilizar para dibujar
  21.     }
  22.     glEnable(GL_TEXTURE_2D);
  23.     selTX := subX - 1;
  24.     selTY := subY - 1;
  25.     {
  26.     Digo a OpenGL que textura quiero utilizar
  27.     }
  28.     glBindTexture(GL_TEXTURE_2D, Textures[selTY][selTX].ID);
  29.   end
  30.   else
  31.     glDisable(GL_TEXTURE_2D);
  32.  
  33.   {
  34.   Me posiciono para dibujar, como en opengl las coordenadas
  35.   se representan segun el eje cartesiano tengo que ajustar la
  36.   coodenada Y, ya que nosotros tomamos el inicio de y en la parte
  37.   superior de la pantalla.
  38.   Ademas indico a openGL que se van a dibujar triangulos
  39.   }
  40.   glTranslatef((x + centX1), screenH - (y + centY1), 0);
  41.   glBegin(GL_TRIANGLES);
  42.  
  43.   for j := 1 to 2 do
  44.   begin
  45.     {
  46.     vertices de cada triangulo
  47.     }
  48.     for k := 1 to 3 do
  49.     begin 
  50.       {
  51.       En caso de existir imagen voy definiendo las coodenas
  52.       de la textura dentro del triangulo, para ello me guio
  53.       por la coordenada u (horizontal) y v(vertical) para saber
  54.       donde estan los limites de cada triangulo (1=limite)
  55.       Ademas como la textura pude ser mas grande que el tamaño del frame
  56.       preciso cuanta textura quiero que pegue, siendo 1 el total de la misma
  57.       }
  58.       if (img = True) then
  59.       begin
  60.  
  61.         if (poligono[j].Vertice[k].u = 1) then
  62.           tmpU := (subW) / textDimeW
  63.         else
  64.           tmpU := 0;
  65.  
  66.         if (poligono[j].Vertice[k].v = 1) then
  67.           tmpV := (subH) / textDimeH
  68.         else
  69.           tmpV := 0;
  70.  
  71.         glTexCoord2f(tmpU, tmpV);
  72.  
  73.       end;
  74.  
  75.       glVertex3f(poligono[j].Vertice[k].x,
  76.       poligono[j].Vertice[k].y,
  77.       poligono[j].Vertice[k].z);
  78.  
  79.     end;
  80.  
  81.   end;
  82.  
  83.   glEnd();
  84.  
  85. end;
  86.  
  87. (...)

Para terminar con la clase "TSprite" nos falta la implementacion del destructor del objeto, que se encargara de liberar los recursos utilizados por un sprite cuando este deje de ser utilizado.

  1. destructor TSprite.Destroy;
  2. var
  3.   i, j: shortint;
  4. begin
  5.   {
  6.   Eliminamos las texturas que tenga un sprite
  7.   }
  8.   if (img) and (Superficie <> nil) then
  9.   begin
  10.     for i := 0 to MAX_TEXTURAS - 1 do
  11.       for j := 0 to MAX_TEXTURAS - 1 do
  12.       begin
  13.         if textures[i][j] <> nil then
  14.           glDeleteTextures(1, textures[i][j].id);
  15.         end;
  16.       end;
  17.       inherited;
  18. end

Creando nuestro avion


Una vez que ya hemos creado la clase "TSprite" ya podemos crear el avion protagonista y ver como queda en la pantalla. Para ello vamos a hacer algunos cambioos en nuestro programa principal.

Empezamos añadiendo la unidad U_Sprite para poder utilizar la clase.

  1. (...)
  2.  
  3. uses
  4.  
  5. (...)
  6.  
  7. U_Sprite;
  8.  
  9. (...)

Despues vamos a declarar la variable que utlizaremos para crer el sprite y a incluir el codigo para crearlo antes de entrar en el bucle principal.

  1. (...)
  2.  
  3. var
  4. avion:tsprite;//variable que vamos a utilizar para crear el avion

  5. begin
  6.   ModoVideo( 640, 480, 16, true );
  7.   Teclado := TTeclado.Create;
  8.   Temporizador := TTemporizador.Create;

  9.   {
  10.   Creamos el avion protagonista
  11.   }
  12.   avion:=tsprite.create('avion.png',95,73);
  13.  
  14. (...)

Y para terminar añdimos el codigo en el bucle principal del juego para poder dibujarlo. No nos olvidamos de liberar los recursos al finalizar la ejecucion.

  1. (...)
  2.  
  3. {
  4. Bucle principal de juego
  5. }
  6. while salir=false do
  7. begin
  8.   Temporizador.Actualizar;
  9.   limpiarBuffer;
  10.   Teclado.Leer;

  11.   {
  12.   Dibujo el avion en la pantalla
  13.   }
  14.   avion.dibujar;

  15.   pintarBuffer;
  16.   Temporizador.esperar; 
  17. end;

  18. {
  19. Libero los recursos al termina el juego
  20. }
  21. avion.free;
  22.  
  23. (...)

LLegados a este punto y si todo lo hemos hecho correctamente cuando ejecutemos el juego veremos a nuestro avion en la esquina superior izquierda sobre el fondo negro. Os dejo el codigo fuente y el ejecutable con los progresos realizados hasta este capitulo en el siguiente enlace.

En el siguiente capitulo veremos como desplazarlo mediante el teclado y ademas crearemos un fondo para nuestro juego para que deje de ser tan soso.

Y hasta aqui el capitulo de hoy espero que os haya resultado de interes y como siempre digo nos vemos en futuras publicaciones. Gracias a tod@s por vuestro apoyo

Ultimas noticias

Crea tu propio framework en javascript

Recopilacion de articulos donde mostrare paso a paso como podemos crear nuestro propio framework en javascript, totalmente funcional y listo para ser utilizado en nuestros futuros proyectos.

Para mas informacion :

Tutorial para crear tu propio FrameWork en JavaSript

Más información
13/12/2013 11:42:57

Como crear una DLL en delphi?

En esta serie de 2 capitulos veremos como crear y utilizar una DLL en Delphi.

Abajo os dejo los enlaces a estos 2 capitulos que componen este mini tutorial, espero que sea de vuestro agrado :

Capitulo 1 : Creacion y utilizacion de una DLL

Capitulo 2 : Creacion de un formulario dinamico utilizando una DLL
Más información
19/09/2013 17:35:59

Ya puedes publicar tu opinion

A partir de ahora ya puedes comentar todas las publicaciones que encuentres en el portal.

Podras opinar tanto si algo te gusta como si no, o si crees que es conveniente completar alguna publicacion, ya que la encuentras incompleta o erronea.

O simplemente por si nos quieres felictar por algo bien hecho :-).

Valoraremos cualquier critica que nos puedas hacer.
Más información
20/05/2013 15:30:10

Tutorial PHP5

Fundamentos de la programacion orientada a objetos
Un interesante tutorial repartido en una serie de capitulos donde se tratan los conocimientos basicos de la programacion orientada a objetos (POO) en PHP5.

Para mayor informacion siga el siguiente enlace :

Tutorial POO en PHP

Más información
04/09/2013 15:44:29
0