INTRODUCCIÓN

Esta es un pequeña guía para crear un Arcade miniatura, como este pequeño  clásico de disparar a los asteroides. El objetivo general es  usar todos los recursos expuestos en este pagina con algunas variaciones. Esta es la lista de recursos que usa:

1. El administrador de listas Arkanoid. [Como hacer un Arkanoid]
   La Liberia de texturas [Uso de recursos y Libreria de Texturas ]
2. Animación de Sprites de un archivo. [Animación de sprites II.]
3. También es importante leer alguno elementos del Diario de creación de Invasores Del Espacio

Hacer un Arcade como Invasores del espacio puede ser algo complicado así que el primer paso será crear uno  no tan complicado, por eso propongo este mini-juego. Este tipo de juegos puede ser tan complicado como se desee pero es mejor si es simple así se puede exponer con mayor claridad.

Descarga todo el código del proyecto SimpleArcade(1) [ThreeSixBox Link]

ANIMACIONES

[Animación de sprites II.]

La animación se basa en Animados Sprites II con algunas modificaciones:

• La clase ahora es abstact, así que debe ser heredada para que pueda funcionar.
• La gestión de las texturas la realiza la Librería de texturas
• Se agregaron nuevos procedimientos.
• Se agregaron procedimientos virtuales que deben ser implementados en los hijos de la clase estos son Start y Update .
• Se agregaron nuevos campos a las propiedades.

Veamos algunos detalles:

Campo de propiedades:

• NumeroDeCuadros :  Numero de cuadros de animación (entero)
• AnchoDeCuadro :  Ancho de cada cuadro se calcula dividiendo (entero)
• Textura :: Nombre de la textura en la librería de texturas (cadena)
• Angulo: Angulo En radianes del Sprite (entero flotante)
• Profundidad: Nivel de profundidad del Sprite 0f a 1f  (entero flotante)
• Posicion: Posición del Sprite como vector bidimensional (Vector 2D)
• Centro: Centro de masa del Sprite
• CuadroActual:  Cuadro Actual reproducido (entero)
• Efecto: El efecto del sprite (SpriteEffects )
• TextureHeight: Altura de la textura fuente de la animación (entero)
• TextureWidht:  Ancho de La textura de la animación (entero)
• noJugable: Marca para eliminar de la lista asociada  (boleano)

Métodos:

• Constructor: Sin parámetros inicia las variables a  valores de inicio.
• Iniciar(string _Textura, int Cuadros):  Inicia la animación se establece el nombre de la texturas y el numero de cuadros de animación, tambien se puede iniciar sin nombre de la textura para cambiar el numero de cuadros de animación Iniciar(int Cuadros).
• Play(): Reproduce el bucle de animación
• Play(int _Cuadro): dirige la animación a un solo cuadro
• PlayAndDie(): Reproduce la animación hasta el ultimo cuadro y después la marca para borrar.
• Draw(SpriteBatch Batch): Dibuja el cuadro de animación.

Métodos a implementar obligatoriamente:

public override void Update(): Que se encarga de gestionar las acciones del objeto de animación (nave, asteroide, marciano etc.)

protected override void Start(): Se llama desde el constructor y pude ser útil para modificar algunas propiedades del objeto Padre.

Ejemplo de implementación Básica:

Objeto Jugador.cs

En el juego solo se requiere:

1. Declarar:
   NaveJugador Jugador;
    
2. Iniciar:
   En LoadGraphicsContent
   
   LibreriaDeTexturas.RegistraTextura(content, "NaveT", "Texturas\\NaveT");
   
   Jugador = new NaveJugador(new Vector2(200, 400));
    
3. Actualizar:
   
   Jugador.Update();
    
4. Dibujar:
   
   Jugador.Draw(Sbatch);

Espero que con este ejemplo sea mas que suficiente, pero bueno debo anotar que algunos objetos no necesitan el Start por que se inician mucho después de iniciado el juego, si  no será necesario recurrir a tanta precauciones.

LISTADOS

 [Como hacer un Arkanoid] [Creando Listas en Juegos]

El listado basado en Arcalite, con algunas modificaciones:

• Admite solamente los hijos de la case de animación.
• Llama a todos los procedimientos Update de las texturas.
• Admite Acceder por índice tal como una textura

En cuanto su uso no hay muchas diferencias con el listado de bloquecitos en el Arkalite. Pero no están de mas algunos ejemplos:

Estos son los tres listados de animación que maneja el juego:

• Implosiones.
• Misiles.
• Asteroides.

Cada uno de estos objetos individualmente Implosión, Misil y Asteroides son animaciones como las expuestas anteriormente. Con funcionalidades y comportamientos correspondientes a cada objeto.

• Misil: Se inician desde la el Jugador, se mueve con velocidad constante, llega al fin de su trayectoria, tiene una mira tipo Ray, Su objetivo es impactar un Asteroide..
• Asteroide: Tiene una vida azarosa, se mueven en una sola trayectoria, se asocian niveles de daño representados en fotogramas y muere al propinársele 2 disparos acertados.
• Implosiones: Tienen una vida fugas, solo viven para extinguirse en el ultimo cuadro de animación.

Nos concentramos en el manejo de los listados y eso se representa en este código:

1. Declarar:
   ListadoAnimacion<misiles> Misiles = new ListadoAnimacion<misiles>();
   ListadoAnimacion<Implosion> Implosiones = new ListadoAnimacion<Implosion>();
   ListadoAnimacion<Asteroide> Asteroides = new ListadoAnimacion<Asteroide>();
    
2. Actualizar:
   
   Misiles.Update();
   Asteroides.Update();
   Implosiones.Update();
    
3. Dibujar:
   
   Fondo.Draw(Sbatch);
   Misiles.Draw(Sbatch);
   Implosiones.Draw(Sbatch);
   //espacio para dibujar el jugador
   Asteroides.Draw(Sbatch);

Adicionar un objeto a su respectiva lista es simple:

Por ejemplo los asteroides aparece al azar

///Disparar algunos Asteroiodes al azar
Random rdm = new Random();
int Num = rdm.Next(40);
if (Num == 5)
//Agregar el asteroide a la lista

 Asteroides.Add(new Asteroide());

Cada objeto de Animación que hemos definido como Sprite tiene sus propios constructores, no son estándares, y están diseñados para facilitar el trabajo al agregar el objeto a la animación.

SISTEMA DE ENTRADA (RATON)

Seleccione el Ratón para mostrar su uso, este solo esta disponible en plataformas Windows PC y su forma de uso es la siguiente.

1. Declarar: No requiere es un objeto estático
    
2. Iniciar:
   En el método constructor del juego se debe agregar este codigo:
   
   Mouse.WindowHandle = Window.Handle;

    

3. Actualizar:
   El ratón se actualizar automáticamente pero debemos declarar una variable para su uso
   MouseState EstadoRaton = Mouse.GetState();

Todo esto se traduce en este código que controla la la Nave:
 

//Intervalo entre misiles
int Misiles_Tiempo = 0;
int Misile_TiempoEntreMisiles = 500;
/// <summary>
/// Porcion de codigo para mover el jugador con el raton
/// Solo disponible en Windows
/// </summary>
public void LeerRaton()
{
//Leer el estado del raton
MouseState EstadoRaton = Mouse.GetState();
Jugador.Posicion = new Vector2(EstadoRaton.X, EstadoRaton.Y);

//Activar el misil
if (EstadoRaton.LeftButton == ButtonState.Pressed)
 Misiles_Tiempo = Misile_TiempoEntreMisiles;

//Lanzar el misil
 if (++Misiles_Tiempo > Misile_TiempoEntreMisiles && (EstadoRaton.LeftButton==ButtonState.Released))
 {
 //Poner tiempo entre misiles en ceros
 Misiles_Tiempo = 0;
 //Agergar un misil
 Misiles.Add(new misiles(Jugador.Posicion.X, Jugador.Posicion.Y + Jugador.AnchoDeCuadro / 2));
}
}

Tiene un efecto retardado para disparar los misiles de manera que no salgan todos al mismo tiempo. Este método se debe llamar desde el Update del juego para que tenga valides.

COLISIONES (ENTRE LISTAS)

[Colisiones Simples]

La idea detrás de las colisiones, (además de las superficies de limitación, Rayos y demás recursos) es recorrer las listas en búsqueda de colisiones.

[En este mini-juego los asteroides no dañan la nave, pero no quiere decir que no se pueda]

Esto se hace con esta pequeña porción de juego en el úpate del juego:

//Revisar las colisiones
float? Distancia;
//Por cada misil en Misiles
foreach (misiles Mi in Misiles)
 {
 //Por cada Asteroide en asteroides
 foreach (Asteroide Ast in Asteroides)
 {
 //Calcular la distancia al rayo
 Distancia = Mi.Rayo.Intersects(Ast.Box);
if (Distancia != null && Distancia == 0)
//Si no es nula o si no es 0 (cero)
{
//Eliminar el misil
Mi.noJugable = true;
//Aumentar el nivel de daño del asteroides
++Ast.NivelDano;
//Agregar una explosión
Implosiones.Add(new Implosion(Ast.Posicion));
}
}
}

Dependiendo del numero de listas será necesario un cierto numero de grupos foreach animados. Si quisiéramos destruir al jugador golpeándolo con los asteroides solo deberíamos buscar el método de no hacer mas foreach...no mas pistas..

PANTALLA TIPO SCROLL

El efecto de movimiento de pantalla es muy clásico de este tipo de Arcades, la idea básica consiste en tener en dibujar la textura de manera que parezca que sobrepone y no se pierda la continuidad.

El código escrito se basa en la ayuda de XNA, claro no sin una modificaciones importantes para que mantengan la armonía con todo lo expuesto anteriormente!

En el juego solo se requiere:

1. Declarar:
   FondoEnMovimiento Fondo;
    
2. Iniciar:
   
   LibreriaDeTexturas.RegistraTextura(content, "Fondo", "Texturas\\Fondo");

   Fondo = new FondoEnMovimiento("Fondo", Window.ClientBounds);
    

3. Actualizar:
   
   Fondo.Update(gameTime);
    
4. Dibujar:
   Debería ser el primer objeto a dibujar!
   Claro pueden haber varias capas de objetos como este
   
   Fondo.Draw(Sbatch);

Se puede cambiar la velocidad del movimiento accediendo al campo publico Velocidad.

PALABRAS FINALES Y LA FRITURA

Para cocinar bien todos estos ingredientes se requiere además de mucha paciencia y empeño, tener algo de orden:

1. XNARecursos es el nombre del namespace de los recursos reunidos en esta receta. Si quieres usarlos puede agregar

   using XNARecursos;
   
   También Claro esta agregar modificar los nombres de los namespaces, por lo cual no presentare ningún reparo
    

2. Es mejor crear carpetas para organizar los contenidos.

Sólo los usuarios registrados pueden escribir comentarios.
Por favor valídate o regístrate.

Powered by AkoComment 2.0!