1. Bladimir Díaz Campos
Bladimir.diaz@ues.edu.sv
bdiaz@eisi.ues.edu.sv

2. Un explorador espacial y queda atrapado en un campo de
asteroides. ¿Por cuanto tiempo es posible resistir?

3. •El jugador puede moverse libremente alrededor de la pantalla.
•Los asteroides aparecen al inicio de la pantalla y se mueven
hacia abajo con un ángulo y una velocidad aleatoria. Después de
algún tiempo se adicionan mas asteroides
•La puntuación es dada por el número de asteroides que se
esquivan en la pantalla.
•Si el jugador colisiona con alguno de ellos, le puntaje se torna
cero y el juego se reinicia a su estado inicial

4. •Pensando como programadores tenemos: Nave
Espacial, Asteroides y Puntajes (objetos del juego).
•Se debe detallar antes de iniciar el proyectos
(características y comportamiento).
•Una correcta definición del comportamiento y del
estado de los objetos del juego son las tareas mas
desafiantes en la programación
•Vamos a tener solo tres efectos de sonido: sonar
música cuando el juego este activo, un sonido cuando
un asteroide nuevo esta en la pantalla y una explosión
cuando se presenta una colisión

6. Es un folder especial donde colocamos objetos como:
imágenes, sonidos y otros que van a ser cargados a
través del Content Pipeline

7. Adicionamos el fondo

8. En este caso tenemos dentro de una misma imagen 3
elementos del juego: la nave espacial y los asteroides

9. 1. Creamos la variable para los asteroides
2. Luego la cargamos

10. Ahora se va a crear una clase que representa
al jugador:
1. Adicionamos un nuevo GameComponent
al proyecto, con el nombre de Nave.cs

11.  Este componente es agregado al proyecto, el cual
contiene una clase derivada de GameComponent, este
no es visible en juego, por lo que no puede dibujar.
Derivando de DrawableGameComponent, se tiene un
método Draw que se pude utilizar para dibujar en el
juego, y este que ocuparemos.

12. Este componente copia la región de la textura que
contiene la imagen de la nave espacial en una
posición especifica. Para lograr esto lo único que
necesitamos son las coordenadas de donde se
encuentra la imagen y la coordenada de la imagen
donde será renderizada.

13. Existen dos pasos bien definidos en
DrawableGameComponent. En el método
Draw() se copia la figura en la pantalla y en el
método update() se actualizad la pantalla de
acuerdo al estado del gamepad o del teclado
(todo esta esta definido en la clase nave.cs que se
crea)

14. Para lograr probar el colocar la nave en la pantalla y probar el
GameComponent,se crea un metodo llamado iniciar() que sera utilizado para
inicializar los objetos (en el inicio solo el jugador)
private void Iniciar()
{
// Creamos si es necesario y colocamos el jugador en la posicion incial
if (player == null)
{
// Adicionamos el jugador
player = new Ship(this, ref meteorTexture);
Components.Add(player);
}
player.PutinStartPosition();
}
Note que la variable jugador, debe ser declarada al inicio de la clase game1
Private Nave jugador
Recordemos que todas la variables que estan antes utilizadas, se deben de
declarar antes¡

15. Luego debemos modificar la funcion Update y modificamos como sigue:
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
estadoGamepad = GamePad.GetState(PlayerIndex.One);
tecla = Keyboard.GetState();
if ((estadoGamepad.Buttons.Back== ButtonState.Pressed) ||
(tecla.IsKeyDown(Keys.Escape)))
this.Exit();
if (jugador == null)
Iniciar();
// TODO: Add your update logic here
base.Update(gameTime);
}

16. Para crear la lluvia de asteroides, deberemos proceder de la misma manera,
creando la clase, definiendo comportamientos, etc.
Y dentro del método Iniciar() adicionamos el siguiente código:
private void Iniciar()
{
// Creamos si es necesario y colocamos el jugador en la posicion incial
if (jugador == null)
{
// Adicionamos el jugador
jugador = new Nave(this,ref asteroideTextura );
Components.Add(jugador);
}
jugador.ColocarPosicionInicial();
// Adiciona los asteroides
for (int i = 0; i < INICIAASTEROIDES; i++)
Components.Add(new asteroide(this, ref asteroideTextura));
// inicializa el contador
ultimoConteo = System.Environment.TickCount;
// resetea el contador de rocas
cuentaRocas = INICIAASTEROIDES;
}

17. Para adicionar el sonido, usaremos 3 sonidos:
1. Explosion.wav: cuando el jugador colisiona con un asteroide
2. Backmusic.wav: La música de fondo del juego
3. Newmeteor.wav: Suena cuando un nuevo asteroide es
adicionado al juego
Creamos un nuevo proyecto XACT y adicionamos estos archivos,
guardamos el proyecto con el nombre de audio.xap.
Y para manejar estos objetos vamos a crear de nuevo otro nuevo
GameComponent con el nombre Audio, para el cual tenemos
el siguiente codigo

18.  #region Using Statements
 using System;
 using System.Collections.Generic;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Audio;
 #endregion
 namespace tormentaEspacial
 {
 /// <summary>
 /// Manejamos los componentes de audio del juego
 /// </summary>
 public class audio :
Microsoft.Xna.Framework.GameComponent
 {
 private AudioEngine motoraudio;
 private WaveBank bancowave;
 private SoundBank bancosonido;
 public audio(Game game)
 : base(game)
 {
 // TODO: Construct any child components
here
 }
 /// <summary>
 /// Allows the game component to perform any
initialization it needs to before starting
 /// to run. This is where it can query for any
required services and load content.
 /// </summary>
 public override void Initialize()
 {
 // Iniciamos el motor del sonido
 motoraudio = new AudioEngine("audio.xgs");
 bancowave = new WaveBank(motoraudio,
"Wave Bank.wsb");
 if (bancowave != null)
 {
 bancosonido = new SoundBank(motoraudio,
"Sound Bank.xsb");
 }
 base.Initialize();
 }
 /// <summary>
 /// Allows the game component to update itself.
 /// </summary>
 /// <param name="gameTime">Provides a
snapshot of timing values.</param>
 public override void Update(GameTime
gameTime)
 {
 motoraudio.Update();
 base.Update(gameTime);
 }
 public void SuenaPista(string pista)
 {
 bancosonido.PlayCue(pista);
 }
 }
 }

19. Agregamos la siguiente línea de código a la clase Game1
private audio componenteAudio;
Inicializamos los sonidos en el metodo Initialize() de la siguiente
manera
protected override void Initialize()
{
componenteAudio = new audio(this);
Components.Add(componenteAudio);
base.Initialize();
// inicia la musica de fondo
componenteAudio.SuenaPista("backmusic");
}
Y dentro del mètodo lgica del juego, donde se produce la colision se
agrega:
//Explosion
componenteAudio.SuenaPista("explosion");

20. También abra que adicionar otra pista cuando u asteroide es
adicionado al juego, para lo que buscamos la línea donde esta
cuentaRocas++;
Y antes de ella adicionamos el código
componenteAudio.SuenaPista("newmeteor");

21. Para esto lo podemos hacer dentrodel método Draw de
la clase Game1 adicionando un SpriteFont,.
Primero declaramos el objeto para esto
private SpriteFont fuenteJuego;
Y luego inicalizamos el objeto en el método
LoadContent()
fuenteJuego = Content.Load <SpriteFont> ("font");

22. Ahora lo que nos queda es dibujar las fuentesdespues
de que dibujamos los sprites, por lo que dentro del
método Draw tendriamos el siguiente código
// Dibujar el marcador
spriteBatch.Begin();
spriteBatch.DrawString(fuenteJuego,
"Asteroides: " + cuentaRocas.ToString(), new
Vector2(15, 15), Color.YellowGreen);
spriteBatch.End();

23. Como siempre deberíamos de agregar un GameComponent
Y un código de la siguiente manera

24.  #region Using Statements
 using System;
 using System.Collections.Generic;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Input;
 #endregion
 namespace tormentaEspacial
 {
 /// <summary>
 /// Este componente ayuda con los controles de la Xbox
 /// </summary>
 public class vibracion :
Microsoft.Xna.Framework.GameComponent
 {
 private int tiempo;
 private int ultimoConteo;
 public vibracion(Game game)
 : base(game)
 {
 // TODO: Construct any child components here
 }
 /// <summary>
 /// Allows the game component to perform any
initialization it needs to before starting
 /// to run. This is where it can query for any required
services and load content.
 /// </summary>
 public override void Initialize()
 {
 // TODO: Add your initialization code here
 base.Initialize();
 }
 /// <summary>
 /// Allows the game component to update itself.
 /// </summary>
 /// <param name="gameTime">Provides a snapshot of
timing values.</param>
 public override void Update(GameTime gameTime)
 {
 if (tiempo > 0)
 {
 int pasado = System.Environment.TickCount -
ultimoConteo;
 if (pasado >= tiempo)
 {
 tiempo = 0;
 GamePad.SetVibration(PlayerIndex.One, 0, 0);
 }
 }
 base.Update(gameTime);
 }
 protected override void Dispose(bool disposing)
 {
 GamePad.SetVibration(PlayerIndex.One, 0, 0);
 base.Dispose(disposing);
 }
 public void RumblePad(int Tiempo, float MotorIzquierdo,
float MotorDerecho)
 {
 ultimoConteo = System.Environment.TickCount;
 tiempo = Tiempo;
 GamePad.SetVibration(PlayerIndex.One, MotorIzquierdo,
MotorDerecho);
 }
 }
 }

25. Creamos el objeto que cuasa el efecto de vibracion
//Objeto para el efecto
private vibracion VivraPad;
Y luego en el método Initialize() de la clase Game1
VivraPad = new vibracion(this);
Components.Add(VivraPad);
Y por ultimo para crear la vibración al momento de chocar se agrega la
siguiente línea de código, donde verificamos la colisión
VivraPad.RumblePad(500, 1.0f, 1.0f);

26. Ahora ya se tiene el juego completo, si se quiere hacer
una copia para que se ejecute en la Xbox, click derecho
en el solution explorer y luego……