Xna tutorial » space invaders

Tutorial [Entrega 5]: Añadiendo disparos de los enemigos

rantamplan — Wed, 23 Dec 2009 12:40:00 +0000

Llegados a este punto, tenemos nuestra nave frente a unas cuantas naves enemigas. Nuestra nave puede disparar y eliminar a los enemigos, pero los enemigos todavía no pueden dispara para intentar eliminarnos. Vamos a ver como podemos hacer esto después del salto.

Como ya sabéis, si tenéis alguna duda, podéis plantearla en el foro: http://www.foro.xna-tutorial.com/viewtopic.php?f=4&p=8#p8

Añadir los disparos de los enemigos, dado el código que tenemos ya escrito en anteriores entregas del tutorial, va a ser realmente fácil.

Veamos los cambios que debemos introducir según las clases.

Clase “Enemigo”

Lógicamente, esta será la clase que debemos modificar. Lo que haremos será principalmente generar un numero aleatorio, el cual nos indicará si el enemigo debe disparar o no debe disparar. Manos a la obra.

Primero nos definiremos dos nuevos atributos:

  1         static Random rand = new Random();     
  2         public int probabilidadDisparo = 2;

El número 2 de “probabilidadDisparo” es la cota que indica si debe disparar o no. Si subimos ese número, los enemigos dispararan más a menudo. De esta forma podemos aumentar el nivel de dificultad (la cadencia de disparos enemigos) simplemente incrementando ese valor.

Ahora vamos al método “Actualizar()”, y le añadimos lo siguiente:

  1         public void actualiza()     
  2         {     
  3     
  4             if (disp == null)     
  5             {     
  6                 if (rand.Next(1000) < probabilidadDisparo)     
  7                     disparar();     
  8             }     
  9             else     
10             {     
11                 disp.actualiza();     
12             }     
13             
14         }

Esto lo que hará será obtener un nuevo numero aleatorio, y si ese numero es menor que la cota de “probabilidadDisparo” entonces disparará. Esto solo lo hará si el enemigo no ha disparado (recordemos que cada nave solo puede tener un disparo al mismo tiempo). Si ya había disparado, entonces actualizaremos el disparo.

Clase “Nave”

En esta clase vamos a definir una propiedad que nos devuelva el rectángulo que envuelve a la nave para poder comprobar las colisiones. Es un cambio menor.

  1         public Rectangle Rectangulo     
  2         {     
  3             get { return new Rectangle((int)pos.X, (int)pos.Y, textura.Width, textura.Height); }     
  4         }

Clase “Game”

Y ahora viene la chica: si unos de los disparos del enemigo nos da, tenemos que eliminar nuestra nave. En próximas versiones lo que haremos será decrementar el contador de vidas de nuestra nave, pero ahora sólo tendremos una vida.

Así que antes de comprobar la colisión de nuestros disparos con los enemigos, que lo vimos en la anterior entrega, comprobaremos que ningún disparo de los enemigos colisione con nuestra nave. Si colisiona, eliminaremos nuestra nave.

  1             foreach (Enemigo e in enemigos)     
  2             {     
  3                 if (e.Disparo != null && nave != null)     
  4                 {     
  5                     if (e.Disparo.Rect.Intersects(nave.Rectangulo))     
  6                     {     
  7                         nave = null;     
  8                         e.Disparo = null;     
  9                     }     
10                 }     
11             }

Como ahora nuestra nave puede ser null, tenemos que cambiar todas las referencias a nuestra nave para que antes de ejecutar cualquier cosa compruebe que la nave no es null. Si no lo hacemos, nuestro juego “petará” cuando nos de un impacto. El código entero de la clase “game” es el siguiente:

  1 using System;     
  2 using System.Collections.Generic;     
  3 using System.Collections;     
  4 using System.Linq;     
  5 using Microsoft.Xna.Framework;     
  6 using Microsoft.Xna.Framework.Audio;     
  7 using Microsoft.Xna.Framework.Content;     
  8 using Microsoft.Xna.Framework.GamerServices;     
  9 using Microsoft.Xna.Framework.Graphics;     
10 using Microsoft.Xna.Framework.Input;     
11 using Microsoft.Xna.Framework.Media;     
12 using Microsoft.Xna.Framework.Net;     
13 using Microsoft.Xna.Framework.Storage;     
14     
15 namespace spaceInvaders     
16 {     
17     ///      
18     /// This is the main type for your game     
19     ///      
20     public class Game1 : Microsoft.Xna.Framework.Game     
21     {     
22         GraphicsDeviceManager graphics;     
23         SpriteBatch spriteBatch;     
24         Nave nave;     
25         //Enemigo enemigo;     
26         ArrayList enemigos;     
27          
28     
29         ///      
30         /// Constructor de la clase     
31         ///      
32         public Game1()     
33         {     
34             graphics = new GraphicsDeviceManager(this);     
35             Content.RootDirectory = "Content";     
36              
37         }     
38     
39         ///      
40         /// Allows the game to perform any initialization it needs to before starting to run.     
41         /// This is where it can query for any required services and load any non-graphic     
42         /// related content.  Calling base.Initialize will enumerate through any components     
43         /// and initialize them as well.     
44         ///      
45         protected override void Initialize()     
46         {     
47             // TODO: Add your initialization logic here     
48             nave = new Nave();     
49             enemigos = new ArrayList();     
50     
51     
52             base.Initialize();     
53         }     
54     
55         ///      
56         /// LoadContent will be called once per game and is the place to load     
57         /// all of your content.     
58         ///      
59         protected override void LoadContent()     
60         {     
61             // Create a new SpriteBatch, which can be used to draw textures.     
62             spriteBatch = new SpriteBatch(GraphicsDevice);     
63              
64             //Le decimos a la nave que textura tiene que cargar     
65             nave.Textura = Content.Load("nave");     
66             nave.TexturaDisparo = Content.Load("disparoNave");     
67     
68     
69             //Creamos los enemigos y los metemos en el arraylist     
70             int numeroEnemigos = 5;     
71             float X = 275;     
72             float Y = 100;     
73     
74             for (int i = 0; i < numeroEnemigos;i++)     
75             {     
76                 Vector2 pos = new Vector2(X, Y);     
77                 Enemigo e = new Enemigo(pos);     
78                 enemigos.Add(e);     
79                 X += 50;     
80             }     
81              
82             //cargamos las texturas del enemigo     
83             foreach(Enemigo e in enemigos)     
84             {     
85                 e.Textura = Content.Load("enemigo");     
86                 e.TexturaDisparo = Content.Load("disparoNave");     
87             }     
88             // TODO: use this.Content to load your game content here     
89         }     
90     
91         ///      
92         /// UnloadContent will be called once per game and is the place to unload     
93         /// all content.     
94         ///      
95         protected override void UnloadContent()     
96         {     
97             // TODO: Unload any non ContentManager content here     
98         }     
99     
100         ///      
101         /// Allows the game to run logic such as updating the world,     
102         /// checking for collisions, gathering input, and playing audio.     
103         ///      
104         /// Provides a snapshot of timing values.     
105         protected override void Update(GameTime gameTime)     
106         {     
107             // Allows the game to exit     
108             if (Keyboard.GetState().IsKeyDown(Keys.Escape))     
109                 this.Exit();     
110     
111             // TODO: Add your update logic here     
112             if (nave != null)     
113                 nave.actualiza();     
114     
115     
116             foreach (Enemigo e in enemigos)     
117             {     
118                 e.actualiza();     
119             }     
120     
121     
122             //comprobamos si algun disparo enemigo nos ha dado     
123             foreach (Enemigo e in enemigos)     
124             {     
125                 if (e.Disparo != null && nave != null)     
126                 {     
127                     if (e.Disparo.Rect.Intersects(nave.Rectangulo))     
128                     {     
129                         nave = null;     
130                         e.Disparo = null;     
131                     }     
132                 }     
133             }     
134     
135             //Comprobamos que el disparo colisiona con algun enemigo     
136             //Si colisiona, eliminamos el enemigo y el disparo     
137              
138             //Array auxiliar para alamacenar los enemigos que debemos eliminar     
139             ArrayList eliminar = new ArrayList();     
140     
141             //Si no hay disparo, no hace falta que entre     
142             if (nave != null && nave.Disparo != null)     
143             {     
144                 //Recorremos la lista de enemigos y comprobamos si alguno colisiona     
145                 foreach (Enemigo e in enemigos)     
146                 {     
147                     Rectangle rectEnemigo = e.Rect;     
148                     Rectangle rectDisparo = nave.Disparo.Rect;     
149     
150                     if (rectEnemigo.Intersects(rectDisparo))     
151                     {     
152                         //añadimos al enemigo a la lista a eliminar     
153                         eliminar.Add(e);     
154                     }     
155                 }     
156     
157                 //si la lista de enemigos a eliminar no esta vacia     
158                 if (eliminar.Count > 0)     
159                 {     
160                     foreach (Enemigo el in eliminar)     
161                     {     
162                         //eliminamos al enemigo     
163                         enemigos.Remove(el);     
164                     }     
165     
166                     //eliminamos el disparo     
167                     nave.Disparo = null;     
168                 }     
169             }     
170     
171     
172             base.Update(gameTime);     
173         }     
174     
175         ///      
176         /// This is called when the game should draw itself.     
177         ///      
178         /// Provides a snapshot of timing values.     
179         protected override void Draw(GameTime gameTime)     
180         {     
181             GraphicsDevice.Clear(Color.Black);     
182     
183             // TODO: Add your drawing code here     
184             spriteBatch.Begin();     
185              
186            if (nave != null) nave.Draw(spriteBatch); //pitnamos la nave     
187             foreach (Enemigo e in enemigos)     
188             {     
189                 e.Draw(spriteBatch);     
190             }     
191              
192     
193             spriteBatch.End();     
194     
195     
196             base.Draw(gameTime);     
197         }     
198     }     
199 }     
200 

Y ya está! ya tenemos nuestros enemigos disparando y nosotros también disparando.

Como siempre, puedes bajarte el código fuente del siguiente enlace:

Descargar Código Fuente del tutorial

Un saludo y hasta la próxima entrega!

Tutorial [Entrega 4]: Añadiendo enemigos

rantamplan — Thu, 17 Dec 2009 09:31:00 +0000

Continuamos con la siguiente entrega del tutorial. Llegados a este punto, tenemos a una nave que disipara. La nave se mueve con las teclas de dirección y dispara pulsando la tecla de dirección arriba. Pero…. ¿a qué dispara? Hoy introduciremos los enemigos para que sirvan de diana, XD. Y lo de siempre, para cualquier duda tienes el foro: http://www.foro.xna-tutorial.com/viewtopic.php?f=4&t=4

Mira el tutorial después del salto.

Así que sigues interesado en XNA y el ejemplo del Space Invaders, eh? Pues aquí tienes como meter los enemigos.

Clase Enemigo.cs

Al igual que hicimos con la clase “Nave.cs”, vamos a crear una nueva clase donde encapsular métodos y atributos necesarios para el enemigo.

Atributos

Como atributos vamos a tener los mismos que e la nave: el sprite de la nave, la posición, y el disparo de los enemigos y la textura del disparo de los enemigos.

  1         private Vector2 pos; //posicion del enemigo     
  2         private Texture2D textura; //textura del enemigo     
  3           
  4         private Disparo disp; //disparo     
  5         private Texture2D texturaDisparo; //Textura del disparo

Y las propiedades para cada atributo:

  1         public Vector2 Posicion  
  2         {  
  3             get { return pos; }  
  4             set { pos = value; }  
  5         }  
  6           
  7         public Texture2D Textura  
  8         {  
  9             get { return textura; }  
10             set { textura = value; }  
11         }  
12     
13         public Disparo Disparo  
14         {  
15             get { return disp; }  
16             set { disp = value; }  
17         }  
18     
19         public Texture2D TexturaDisparo  
20         {  
21             get { return texturaDisparo; }  
22             set { texturaDisparo = value; }  
23         }

Vamos a ver ahora que métodos necesita, aunque supongo que ya te imaginarás que necesita prácticamente los mismo métodos que nuestra clase “Nave.cs”

Métodos

  1         ///      
  2         /// Constructor por defecto del enemigo     
  3         ///      
  4         public Enemigo()     
  5         {     
  6             pos = new Vector2(400,100);     
  7         }     
  8     
  9     
10         ///      
11         /// consturctor sobrecargado del enemigo donde le damos una pos inicial     
12         ///      
13         public Enemigo(Vector2 posicion)     
14         {     
15             pos = posicion;     
16         }     
17     
18         ///      
19         /// Comprueba el teclado y mueve la nave segun las teclas pulsadas     
20         ///      
21         public void actualiza()     
22         {     
23              //De momento nuestro enemigo no hace nada  
24         }     
25     
26     
27     
28         ///      
29         /// Pinta la nave y el disparo si lo tiene     
30         ///      
31         ///      
32         public void Draw(SpriteBatch batch)     
33         {     
34             batch.Draw(textura, pos, Color.White);     
35     
36             //Pintamos el disparo     
37             if (disp != null)     
38             {     
39                 batch.Draw(disp.Textura, disp.Posicion, Color.White);     
40             }     
41         }

Ahora podemos introducir nuestros enemigos en el juego. Vamos a ver como los introducimos.

Clase “Game1.cs”

Como queremos tener unos cuantos enemigos en la pantalla (solo uno seria muy aburrido), vamos a crearnos una nueva lista donde meteremos a nuestros enemigos.

  1 ArrayList enemigos;

Y en el método Initialize() inicializaremos el array:

  1        protected override void Initialize()     
  2         {     
  3             // TODO: Add your initialization logic here     
  4             nave = new Nave();     
  5             enemigos = new ArrayList();     
  6     
  7     
  8             base.Initialize();     
  9         }

El método LoadContent() es el que más tela tiene, así que lo voy a comentar:

  1             //Creamos los enemigos y los metemos en el arraylist     
  2             int numeroEnemigos = 5;

Con esta variable le decimos el numero de enemigos que queremos ver en la pantalla, en este caso 5.

  3             float X = 275;     
  4             float Y = 100;  
  

Estas dos variables son las coordenadas de donde queremos que se pinte el primer enemigo. En este caso, al ser 5 enemigos, le voy a decir que el primero se pinte a la izquierda para que el conjunto quede centrado en la pantalla.

Ahora, con un bucle, creamos los enemigos, metiendo una separación de 50pix entre cada uno, y los metemos en la lista de enemigos.

  6             for (int i = 0; i < numeroEnemigos;i++)     
  7             {     
  8                 Vector2 pos = new Vector2(X, Y);     
  9                 Enemigo e = new Enemigo(pos);     
10                 enemigos.Add(e);     
11                 X += 50;     
12             }     
13              

Ahora, para cada enemigo de la lista, tenemis que decirle que texturas vamos a cargar. En este caso, todos los enemigos tienen la misma textura, y el disparo es el mismo que dispara nuestra nave.

14             //cargamos las texturas del enemigo     
15             foreach(Enemigo e in enemigos)     
16             {     
17                 e.Textura = Content.Load("enemigo");     
18                 e.TexturaDisparo = Content.Load("disparoNave");     
19             }

Por cierto, aquí os dejo el sprite del enemigo:

Si le dais a” botón derecho/guardar imagen como” os podéis guardar el sprite.

Ahora queda pintar a los enemigos en la pantalla. Nota: El método update() me lo salto porque de momento los enemigos no hacen nada.

Pues al igual que con la nave, tenemos que decirle a todos los enemigos que se pinten. Para ellos, recorremos la lista con un bucle “foreach” dela siguiente manera:

  1             foreach (Enemigo e in enemigos)     
  2             {     
  3                 e.Draw(spriteBatch);     
  4             }

Y ya está. Ya tenemos a 5 enemigos en nuestra pantalla. Si quieres puedes ir jugando con las posiciones iniciales de los enemigos, meter mas filas de enemigos, etc. hasta que escriba el siguiente tutorial, donde haremos que los enemigos se muevan!!!

Y como siempre, el código fuente del tutorial:

Descargar código fuente

Si tienes alguna duda con el tutorial, puedes preguntármela en el foro: http://www.foro.xna-tutorial.com/viewtopic.php?f=4&t=4

Un saludo a todos!

Tutorial [Entrega 2]: Moviendo un sprite por la pantalla

rantamplan — Mon, 14 Dec 2009 19:08:46 +0000

Parece que ha habido un error y la 2º parte del tutorial se ha borrado, asi que vuelvo a subirlo: Un saludo y perdonar las molestias

Continuamos la serie de tutoriales con lo más básico de XNA: crear el proyecto y mover un sprite por la pantalla.

En esta entrega crearemos un proyecto de XNA 3.1 y dibujaremos por la pantalla un sprite (nuestra nave) y haremos que se mueva por la pantalla. Vamos a empezar por cosas fáciles y ya iremos subiendo poco a poco el nivel de dificultad.

Encontrarás el tutorial completo después del salto.

Creando el proyecto

Lo primero que tenemos que hacer es crear un nuevo proyecto de XNA. Para ello, abrimos el VS2008 (o el Visual C# Studio si tienes la versión gratuita) y le damos a “Archivo/Nuevo/Proyecto”.

Nos saldrá una nueva ventana donde debemos elegir como tipo de proyecto “XNA Game Studio 3.1” y como plantilla “Windows Game”.

También le debemos dar un nombre al proyecto. Como hoy estoy poco ingenioso, lo llamaré simplemente “Space Invaders”. Vosotros podéis darle el nombre que queráis.

Si le damos a aceptar, veremos que se creará un proyecto nuevo, con varios ficheros (Game1.cs, Program.cs). Vemos que ya hay código escrito, y si le damos a F5 nos saldrá una pantalla azul. Esa pantalla es nuestro futuro juego. El fichero Program.cs no debemos tocarlo.

Creando la nave

Ahora vamos a crear nuestra nave y pintarla en la pantalla esa azul que nos ha salido antes.

Para ello, en el archivo Game1.cs nos creamos una variable llamada nave de tipo ‘Texture2D’ que representará nuestra nave para combatir la invasión alienígena y un nuevo tipo de dato que trae XNA llamado ‘Vector2’ para almacenar la posición de la nave.

private Texture2D nave;
private Vector2 pos;

Ahora vamos al método Initialize(). En este método iniciamos la posición inicial de la nave. El resultado del método os quedará así:

protected override void Initialize()
{
// TODO: Add your initialization logic here
pos = new Vector2(400,550);base.Initialize();
}

Ya tenemos la posición de la nave. Ahora le tenemos que indicar al programa que sprite queremos usar como nave. Así que os dejo yo aquí uno muy chulo hecho por mi con gran destreza haciendo uso de mis años usando el Paint, XD.

Bien, para cargar la imagen primero tenemos que agregarla al directorio “Content” del juego. Para ello, le damos a “Botón Derecho” sobre “Content” y seleccionamos “Agregar/Elemento Existente”. Buscamos el sprite y le damos a aceptar. También podemos arrastrar directamente una imagen al directorio.

Ahora en nuestro proyecto tenemos un sprite llamado “nave”. Para cargarlo, usaremos el método ‘Load()’ dentro de nuestro método LoadContent(). Nos quedará algo así:

protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
nave = Content.Load("nave");// TODO: use this.Content to load your game content here
}

Ahora ya falta dibujarlo por la pantalla. Así que en el método Draw() escribimos el siguiente código para pintarlo.

protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);// TODO: Add your drawing code here
spriteBatch.Begin();
spriteBatch.Draw(nave, pos, Color.White);
spriteBatch.End();

base.Draw(gameTime);
}

Si le damos ahora a F5 nos mostrará por la pantalla un fondo azul y nuestra nave. Igual que esta imagen:

Muy bonito, si, pero todavía no podemos hacer nada con ella, así que vamos a ver como moverla por la pantalla.

Para ello, volvemos al método “update()” y escribimos dos instrucciones if: una para mover a la izquierda y otra para mover a la derecha.

protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (Keyboard.GetState().IsKeyDown(Keys.Escape))
this.Exit();

// TODO: Add your update logic here
if (Keyboard.GetState().IsKeyDown(Keys.Left))
pos.X -= 5;
if (Keyboard.GetState().IsKeyDown(Keys.Right))
pos.X += 5;
base.Update(gameTime);
}

Ahora, si le damos a F5, con las teclas de dirección podremos mover nuestra nave hacia izquierda y derecha. Fácil, verdad?

En la próxima entrega crearemos una clase para nuestra nave para poder controlarla mejor y haremos que pueda disparar.

Descargar Código Fuente

Hasta la próxima entrega!

Tutorial [Entrega 3]: Añadiendo disparos

rantamplan — Fri, 04 Dec 2009 15:28:00 +0000

Continuamos con las entregas del tutorial para hacer un clon del Space Invaders en XNA.

Ahora que ya tenemos una nave protagonista moviéndose por la pantalla, le realizaremos algunas mejoras a la nave y haremos que pueda dispara.

Podrás leer el tutorial completo después del salto. Y recuerda que si tienes alguna duda con el tutorial, puedes preguntármela en el foro: http://www.foro.xna-tutorial.com/viewtopic.php?f=4&t=4

Sabras de jugar a juegos, tanto si son de consola como si son de otro tipo como PartyPoker español que tener una guia ayuda bastante a mejorar.Los consejos en los juegos son esenciales para jugar a un buen nivel. Espero que el siguiente tutorial te sea de ayuda.

Clase Nave

Para empezar, vamos a encapsular nuestra nave en una clase llamada “Nave”. Esto lo deberíamos haber hecho desde el principio, pero como quería mostraros lo fácil que era cargar sprites en XNA y moverlos por la pantalla, me lo pase por alto.

Para crear la clase “Nave”, clicamos con el botón derecho sobre el proyecto y de damos a “Agregar/Clase”.

Como nombre escribimos “Nave.cs” y le damos a “Agregar”. Vale, ya tenemos nuestra clase. Ahora vamos a completarla.

Atributos

De momento, vamos a crear dos atributos:

private Vector2 pos; //posicion de la nave
private Texture2D textura; //textura de la nave

Y sus respectivas propiedades:

public Vector2 Posicion
{
get { return pos; }
set { pos = value; }
}

public Texture2D Textura
{
get { return textura; }
set { textura = value; }
}

Métodos

Necesitamos el constructor de la clase, donde le daremos una posición inicial a la nave, un método para actualiza la posición de la nave, y otro ultimo para pintar la nave en la pantalla.

CONSTRUCTOR

public Nave()
{
pos = new Vector2(400,550); //nave centrada en la pantalla, parte inferior
}

METODO ACTUALIZA

Ahora, además de mover la nave, vamos a comprobar que no se salga de la pantalla. Si esto ocurre, no le vamos a dejar moverse.

public void actualiza()

{

 if (Keyboard.GetState().IsKeyDown(Keys.Left))

 {

 if (pos.X > 0) //no se sale por la izquierda

 pos.X -= 5;

 }

 if (Keyboard.GetState().IsKeyDown(Keys.Right))

 {

 if (pos.X + textura.Width < 800) //no se sale por la derecha

 pos.X += 5;

 }

}

METODO DRAW

public void Draw(SpriteBatch batch)
{

//Pintamos la nave
batch.Draw(textura, pos, Color.White);

}

Ya tenemos nuestra clase nave. Vamos ahora con la siguiente.

Clase Disparo

Ahora vamos a crear la clase disparo. Realmente no haría falta, ya que podríamos asignar al personaje una nueva textura y una variable posición y lo tendríamos solucionado. Sin embargo, pensando a largo plazo, creo que nos va a venir bien una clase disparo para poder meterle animaciones, distintos tipos de disparos, etc…

Atributos

De momento, vamos a crear cuatro atributos:

private Vector2 pos; //posición del disparo

private Texture2D textura; //textura del disparo
private bool vivo; //indica si el disparo aun esta en el juego

Y sus respectivas propiedades:

public Vector2 Posicion

{

 get { return pos; }

  set { pos = value; }

}

public Texture2D Textura

{

  get { return textura; }

  set { textura = value; }

}

public bool Vivo

{

  get { return vivo; }

  set { vivo = value; }

}

Métodos

Al igual que antes, vamos a programar un constructor de la clase y un método al que llamaremos para actualizar su posición en la pantalla.

Para el constrictor, necesitaremos una posición inicial y un sprite. Lo posición inicial:

public Disparo(Vector2 posicionInicial, Texture2D sprite)
{
pos = posicionInicial;
textura = sprite;
vivo = true;
}

El método actualiza lo usaremos para comprobar que el disparo sale de la pantalla o no. Si sale de la pantalla, pondremos su variable “vivo” a false. Si sigue vivo, entonces lo movemos.

public void actualiza()
{
if (pos.Y + textura.Height < 0) vivo = false;
if (pos.Y > 600) vivo = false;

if (vivo)
pos.Y -= 10;
}

Cambios en la clase nave

Ahora que ya tenemos una clase disparo, vamos a hacer que nuestra nave pueda disparar. Solo le vamos a permitir un disparo (al igual que en el juego original), y hasta que ese disparo no impacte con un enemigo, o se salga de la pantalla, no vamos a poder volver a disparar.

Para hacer esto, tenemos que realizar las siguientes modificaciones en la clase “Nave.cs”

publicvoid actualiza()

{
 if (Keyboard.GetState().IsKeyDown(Keys.Left))
 {
 if (pos.X > 0)
 pos.X -= 5;
 }
 if (Keyboard.GetState().IsKeyDown(Keys.Right))
 {
 if (pos.X + textura.Width < 800)
 pos.X += 5;
 } //Añadimos el disparo
 if (Keyboard.GetState().IsKeyDown(Keys.Up))
 {
 if (disp == null)
 disp = new Disparo(new Vector2(pos.X + textura.Width/2, pos.Y), texturaDisparo);  //la  posicion del disparo es la mitad de nuestra nave
 }
 //Si el disparo esta vivo, lo movemos. Si no, lo ponemos a null

 //para poder volver a disparar

 if (disp != null)

 {

 if (disp.Vivo)

 disp.actualiza();

 else

 disp = null;

 }

}
 
public void Draw(SpriteBatch batch)

{

 batch.Draw(textura, pos, Color.White);
 //Pintamos el disparo

 if (disp != null)

 {

 batch.Draw(disp.Textura, disp.Posicion, Color.White);

 }

}

Clase Game1.cs

Y ya tenemos nuestra clase “Disparo”. Ahora nos falta agregar la lógica necesaria en “Game1.cs”.

Lo que haremos en “Game1.cs” será definirnos y crearnos la nave:

Nave nave;

Cargar las texturas necesarias para la nave y el disparo de la nave:

protected override void LoadContent()

{

  // Create a new SpriteBatch, which can be used to draw textures.

  spriteBatch = new SpriteBatch(GraphicsDevice); //Le decimos a la nave que textura  tiene que cargar

  nave.Textura = Content.Load(“nave”);

  nave.TexturaDisparo = Content.Load(“disparoNave”);  // TODO: use this.Content to load your game content here

}

Llamar al método actualizar de nuestra nave en cada bucle del juego:

protected override void Update(GameTime gameTime)

{

 // Allows the game to exit

  if (Keyboard.GetState().IsKeyDown(Keys.Escape))

  this.Exit(); // TODO: Add your update logic here

  

  nave.actualiza();

base.Update(gameTime);
}

Y por ultimo pintar la nave. pero ahora como nuestra clase nave tiene un método para pintarse, simplemente llamaremos a ese método pasándole como argumento nuestro Spritebacht.

protected override void Draw(GameTime gameTime)

{

  GraphicsDevice.Clear(Color.Black); //Pintamos el fondo de negro // TODO: Add your  drawing code here

  spriteBatch.Begin();

  nave.Draw(spriteBatch);

  spriteBatch.End();  base.Draw(gameTime);

}

Y voilá!! Tenemos nuestra nave moviéndose por la pantalla, pero sin salirse de ella, y disparando con la tecla “Arriba”. Al igual que el Space Invaders, solo podemos tener un disparo en la pantalla.

Como podéis observar, le he cambiado el color de fondo para que en lugar de azul sea negro. Además, he pintado la nave de blanco para que se vea mejor. Así conseguimos un estilo más “retro”.

Y como siempre, aquí tenéis el código fuente para poder probarlo vosotros mismos.

Descargar Código Fuente

Si tienes alguna duda con el tutorial, puedes preguntármela en el foro: http://www.foro.xna-tutorial.com/viewtopic.php?f=4&t=4

Un saludo y hasta la próxima entrega, donde añadiremos a los enemigos!!

Tutorial [Entrega 1]: Descargando el Software Necesario

rantamplan — Sat, 21 Nov 2009 10:42:19 +0000

Aprovechando el fin de semana, empezamos el tutorial en el que programaremos un clon del Space Invaders. Lo primero que tenemos que hacer es descargarnos todo el software que vamos a necesitar.

Para empezar ha hacer juegos con XNA, necesitamos una serie de programas especiales para poder empezar a programar. Pero que no cunda el pánico: todo el software Microsoft lo ofrece gratuitamente. Así que no vas a tener necesidad de piratear nada, XD.

Para empezar, necesitamos un IDE de Microsoft. En concreto, necesitaremos Visual Studio 2008 (de aquí en adelante, VS2008 o simplemente VS). Como este IDE es de pago (depende de donde lo compres, desde 600€ a 1500€) Microsoft nos ofrece la posibilidad de bajarnos una versión más limitada, pero totalmente gratuita llamada Visual C# Studio 2008 Express, que funcionará a la perfección para nuestro objetivo de hacer un juego.

Visual C# Studio 2008 Express Edition (Descargar)
Es gratuito y nos servirá para nuestro objetivo. Un IDE parecido a Visual Studio 2008 pero un poco más limitado. Totalmente válido para hacer juegos.

XNA 3.1 FrameWork (Descargar)
Las librerías que usaremos para hacer los juegos. Contiene las rutinas de bajo nivel para cargar música, imágenes, modelos 3D, etc… sin que nosotros tengamos que preocuparnos de ello.

DirectX (Descargar)
Casi todo el mundo tiene instalada la ultima versión de DirectX. Si no es tu caso y no tienes DirectX actualizado, puedes visitar la web de Microsoft y bajarte la última versión, aunque lo dicho, casi todo el mundo lo tiene instalado aunque no lo sepa.

Todas estas descargas están disponibles también en la web de XNA, llamada XNA Creators Club.

Una vez hayamos realizados las descargas, instalamos primero el Visual C# Studio y luego el XNA 3.1 (esto no hacia falta que lo dijera, no? XD) y ya podremos crear proyectos de XNA desde el Visual Studio.

En la próxima entrega os explicaré como crear un proyecto de XNA nuevo y hacer que un sprite se mueva por la pantalla.

Un saludo.

Creando un juego completo desde 0

rantamplan — Wed, 18 Nov 2009 19:22:45 +0000

Hola a todos:

Os anuncio que dentro de unos días (aún estoy acabando algunos tutoriales) voy a empezar a explicar paso a paso como crear un juego en 2D programado con XNA. El juego no será excesivamente complejo, pero tampoco tan fácil como puede parecer.

La idea es hacer un clon de Space Invaders. Ya os anticipo que no será el mejor clon, pero la idea es aprender como cargar sprites, mover un personaje, colisiones, lógica del juego, añadir menú del juego, gestion de estados, etc… vamos, tocar todos los aspectos que hacen falta en la creación de un juego.

El resultado será algo más o menos parecido a esto.

Intentaré ir publicando los distintos apartados del manual poco a poco, aunque espero que sin pausa.

Espero que os gusten los tutoriales, y que sepáis que si tenéis alguna duda estamos aquí para ayudar.

Un saludo a todos y nos vemos dentro de unos días con la 1º entrega del tutorial!