Ejemplo XNA parte 2 – Creación de la Clase Jugador

Haz un clic derecho sobre el proyecto y agrega una nueva clase llamada «Jugador», y agrega los métodos Initialize, Update y Draw. Deberás importar las librerías de XNA.

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Shooter
{
	class Jugador
	{
		public void Initialize()
		{
		}

		public void Update()
		{
		}

		public void Draw()
		{
		}
	}
}

Esta es la estructura básica de nuestra clase Jugador, que funcionará para desplegar el elemento que controlará el usuario, que en nuestro caso es la aeronave. Ahora agrega los siguientes atributos (observa la importancia de cada uno que se encuentran comentados)

// Animacion representando al jugador
public Texture2D PlayerTexture;

// Posicion del jugador
public Vector2 Position;

// Estado del jugador
public bool Active;

// Cantidad de vida del jugador
public int Health;

// Obtener el ancho del jugador
public int Width
{
	get { return PlayerTexture.Width; }
}

// Obtener el alto del jugador
public int Height
{
	get { return PlayerTexture.Height; }
}

Estos son algunos atributos fundamentales para nuestra clase jugador, pero obviamente se pueden agregar mas dependiendo del control que queramos tener sobre este elemento. Ahora reemplaza el método Initialize (de la clase Jugador) con lo siguiente:

public void Initialize(Texture2D texture, Vector2 position)
{
	PlayerTexture = texture; 
	// Asignar la posicion del jugador
	Position = position;
	// Activar el jugador
	Active = true;
	// Inicializar la vida del jugador
	Health = 100;
}

Como se puede ver claramente, lo que hace el metodo Initialize es establecer las propiedades iniciales de nuestra clase Jugador. Ahora reemplaza el metodo Draw con el siguiente:

public void Draw(SpriteBatch spriteBatch)
{ 
	spriteBatch.Draw(PlayerTexture, Position, null, 
		Color.White, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
}

Ya con la clase Jugador con sus atributos y funciones listas, pasaremos a la clase principal para instanciar un objeto Jugador.

En la clase Game1.cs

Ya que tenemos todo preparada la clase Jugador, debemos instanciarla, inicializarla y por último, invocar su método Draw desde esta clase principal para desplegar la nave en la pantalla. Ve al inicio de esta clase, y debajo de la declaración del atributo SpriteBatch spriteBatch; agrega nuestra variable tipo Jugador.

Jugador jugador;

Y ahora en el método Initialize, instanciamos nuestra clase:

jugador = new Jugador();

Siguiente, debemos cargar la textura de nuestra nave que se encuentra en el Content de nuestro proyecto. En el método LoadContent, agrega las siguientes líneas:

// Load the player resources 
Vector2 playerPosition = new Vector2(
	GraphicsDevice.Viewport.TitleSafeArea.X,
	GraphicsDevice.Viewport.TitleSafeArea.Y + 
	GraphicsDevice.Viewport.TitleSafeArea.Height / 2);
jugador.Initialize(Content.Load<Texture2D>("Imagenes/nave"), playerPosition);

Ya que tenemos nuestro objeto Jugador instacianciado, y cargado, ve al metodo Draw y agrega las siguientes instrucciones:

spriteBatch.Begin();
jugador.Draw(spriteBatch);
spriteBatch.End();

Ahora finalmente compila el proyecto, y ejecútalo. Si todo funciona correctamente, verás algo como esto:

Si tu proyecto presenta errores y no encuentra como solucionarlos, no entres en pánico, puedes descargar el proyecto de acá en su estado final de este tutorial, simplemente da clic al siguiente enlace:

Proyecto Shooter Parte 2

Interacción en XNA para Windows Phone: Reconocimiento de Gestos

XNA posee funcionalidades innatas para reconocer los gestos más comunes con los que interactuamos normalmente con cualquier dispositivo móvil en la actualidad. Simplemente se debe habilitar el reconocimiento de gestos, y así el juego tendrá la capacidad de interpretar cualquier tipo de gesto realizado por parte del usuario. Los gestos más comunes se muestran en el siguiente diagrama.

Un Tap es el gesto cuando le damos un toque rápido en algún punto de la pantalla. Double Tap son dos toques consecutivos en un mismo punto, como hacer un doble clic. El Pinch y Stretch son el típico gesto que conocemos para hacer zoom-in y zoom-out en una foto o una imagen. El gesto Pan ocurre cuando deseamos trasladarnos por un scrollbar, o navegar por un mapa o imagen. Flick es un toque rápido con alguna dirección, lo que causa una especie de inercia a algún elemento que estemos trasladando.

A continuación implementaremos un ejemplo sencillo de reconocimiento de gestos utilizando el Framework XNA para Windows Phone.

Ejemplo de Reconocimiento de Gestos

Crea un proyecto Windows Phone Game (4.0), y nómbralo «GestosXNA», selecciona versión del sistema operativo 7.1. Haz un clic-derecho sobre el Content del proyecto, y agrega un nuevo Ítem de tipo «Sprite Font», y nómbralo «SpriteFont1».

En la clase Game1.cs, después de la declaración del atributo SpriteBatch spriteBatch; agrega los siguientes atributos:

SpriteFont spriteFont;
String message = "Realiza un gesto";
Vector2 messagePos = Vector2.Zero;
Color color = Color.Black;

Ahora, en el método Initialize, y agrega la siguiente instrucción antes de la línea base.Initialize(); y agrega lo siguiente:

TouchPanel.EnabledGestures = GestureType.Tap | GestureType.DoubleTap | 
                        GestureType.Hold | GestureType.HorizontalDrag | 
                        GestureType.VerticalDrag | GestureType.FreeDrag | 
                        GestureType.DragComplete | GestureType.Pinch | 
                        GestureType.PinchComplete | GestureType.Flick;

De esta forma, estamos habilitando cuales gestos deseamos que nuestra aplicación sea capaz de reconocer en tiempo de ejecución. En el método LoadContent, cargaremos la fuente agregada del Content, de esta manera:

protected override void LoadContent()
{
	spriteBatch = new SpriteBatch(GraphicsDevice);
	spriteFont = Content.Load<Texture2D>("SpriteFont1");
}

Ahora, en el método Update es donde en cada ciclo del Game Loop, el juego realizara una captura del estado de la pantalla táctil, registrando gestos realizados por el usuario, y los irá reconociendo en tiempo real. El método completo está implementado de la siguiente forma:

if (TouchPanel.IsGestureAvailable)
{
	GestureSample gesture = TouchPanel.ReadGesture();
	switch (gesture.GestureType)
	{
		case GestureType.Tap:
			message = "Tap";
			color = Color.Red;
			break;
		case GestureType.DoubleTap:
			message = "Doble Tap";
			color = Color.Orange;
			break;
		case GestureType.Hold:
			message = "Hold";
			color = Color.Yellow;
			break;
		case GestureType.HorizontalDrag:
			message = "Arrastre horizontal";
			color = Color.Blue;
			break;
		case GestureType.VerticalDrag:
			message = "Arrastre vertical";
			color = Color.Indigo;
			break;
		case GestureType.FreeDrag:
			message = "Arrastre libre";
			color = Color.Green;
			break;
		case GestureType.DragComplete:
			message = "Gesto arrastre completado";
			color = Color.Gold;
			break;
		case GestureType.Flick:
			message = "Flick";
			color = Color.Violet;
			break;
		case GestureType.Pinch:
			message = "Pinch";
			color = Color.Violet;
			break;
		case GestureType.PinchComplete:
			message = "Gesto pinch completado";
			color = Color.Silver;
			break;
	}
	messagePos = gesture.Position;
}

Primero se verifica si el TouchPanel tiene el reconocimiento de gestos habilitados. Luego TouchPanel.ReadGesture() devuelve un GestureSample en cada ciclo del GameLoop, que es analizado en el switch(gesture), y se detendrá en el caso correspondiente al gesto reconocido, cambiando el valor del string message, informando el gesto detectado, y finalmente, se le asigna la posición del mensaje donde ocurrió el gesto analizado.

En el método Draw, proseguimos a dibujar nuestro string:

protected override void Draw(GameTime gameTime)
{
	GraphicsDevice.Clear(Color.CornflowerBlue);
	spriteBatch.Begin();
	spriteBatch.DrawString(spriteFont, message, messagePos, color);
	spriteBatch.End();
	base.Draw(gameTime);
}

Listo! Ahora compila la solución y si todo esta correctamente codificado, veras la siguiente pantalla:

Ya con la aplicación ejecutándose en el emulador Windows Phone, realiza gestos utilizando tu mouse y verás que son reconocidos por nuestra aplicación, mostrando un mensaje sobre el gesto detectado, y en la posición donde ocurrió.

Desafortunadamente no podrás realizar gestos multitouch como el Pinch; para eso necesitarías hacer deploy del proyecto a un teléfono físico. Sin embargo, puedes realizar cualquier otro gesto habilitado. Experimenta y realiza todos los gestos disponibles.

Si tu proyecto presenta errores de compilación, puedes descargarte el ejemplo:

Proyecto GestosXNA

Estructura de un proyecto XNA

Para crear un proyecto XNA, debemos abrir Visual Studio 2010 con el XNA Game Studio 4.0 previamente instalado. Da un clic en Archivo, Nuevo Proyecto, y ve a la categoría de plantillas «XNA Game Studio», y selecciona la plantilla Windows Game (4.0). Escribe el nombre de proyecto deseado y le das click en  aceptar.

Una vez creado el proyecto, verás la clase principal del proyecto que por defecto se llama Game1. En el Solution Explorer, veras la siguiente estructura de carpetas.

Proyecto WindowsGame1

En esta sección de la solución es donde se desarrolla toda la lógica del juego. La clase principal es la llamada Class1, donde se encuentra bien definidos los métodos principales a implementar acorde al funcionamiento del framework XNA. Existe otra clase estática llamada Program.cs, donde aquí en realidad es el que invoca la Clase1 para ejecutarla; sin embargo, tu labor es implementar tu juego es en la clase Class1.

También veras un archivo llamado «Game.ico», donde este es un pequeño icono de 32×32 pixeles que se coloca en la esquina superior izquierda de la ventana de nuestro juego al momento de ejecutar nuestra aplicación. Este icono también se mostrara si lo anclas a la barra de inicio.

Entre otros elementos dentro de este proyecto, se encuentra el directorio “Properties”, donde se encuentra el archivo “AssemblyInfo.cs”, que es el archivo configuración de ensamblado de nuestro proyecto. Al abrirlo, veras que contiene toda la información acerca de la versión de la aplicación, el Titulo del juego, producto, descripción, año, etc. También se encuentra el directorio «References», donde en esta se encuentra referencias a las librerías fundamentales requeridas para el funcionamiento de este proyecto. Si deseas trabajar con librerías externas encontradas en la web (Como trabajar con el Kinect, o librerias de físicas, etc.), con descargarlas y hacerles referencia, ya se encuentran disponibles para utilizarlas en tu juego.

En este punto, te sugiero que trabajes con directorios de clases, a modo de trabajar un proyecto de manera organizada por grandes módulos esenciales, como física, sonido, gráficos, interacción entrada/salida, etc.

Proyecto WindowsGame1Content

Para este proyecto de tipo Windows Game Library (4.0) que se genera automáticamente en la solución al momento que se crea un Windows Game (4.0), es donde se coloca todo el contenido gráfico audiovisual del juego. Se recomienda que organices el contenido en directorios, para imágenes, archivos de configuración, sonidos, videos, música de fondo, etc. Esta sección ya se encuentra referenciada por el proyecto principal (que se puede ver dentro del directorio «Content References»).

Mecanismo del Framework XNA

A continuación se muestra una figura de la forma como funciona el framework XNA a nivel de implementación. Es de suma importancia saber el orden de los métodos que son invocados cómo desarrollamos nuestros juegos. Sin mas que agregar, se muestra el diagrama, y la explicación de cada método en el orden de ejecución para el momento que se inicia un juego hasta el momento que finaliza.

Método Initialize

El método Initialize es usado para inicializar variables y otros objetos asociados con el objeto Game1. Los objetos del dispositivo grafico será inicializados en este punto y pueden ser usados en el métodos Initialize para ayudarte a inicializar otros objetos que dependen en la configuración. Utilizarás este método para inicializar valores de puntuación y otros valores afines.

Método LoadContent

El método LoadContent es invocado después del método Initialize, de la misma forma para el caso que el contenido grafico debe ser recargado (Por ejemplo cuando el dispositivo grafico debe ser reiniciado debido a que el jugador ha cambiado la configuración grafica del juego, o algo por el estilo). El método LoadContent es donde se carga todos los gráficos y otro contenido requerido por el juego, incluyendo imágenes, modelos, sonidos, etc.

Game Loop (Método Update y Metodo Draw)

Despues que culmina el método LoadContent, el juego entra en un estado conocido como Game Loop, o bucle de juego.  Casi todos los juegos entran en algún tipo de bucle de juego, independientemente si están escritos en XNA o no. Esta área de código difiere del típico entorno de programación de juegos, y para algunos desarrolladores les puede tomar algo de tiempo acostumbrarse.

En esencia, un Game Loop consiste en una serie de métodos que son invocados una y otra vez hasta que el juego finaliza. En XNA, el Game Loop consiste en dos métodos: Update y Draw. Por ahora, puedes pensar en el Game Loop en estos términos: toda la lógica que afecta el juego actual se encontrará en el método Update o el método Draw. El método Draw es típicamente usado, obviamente, para dibujar elementos. Procura implementar lo mínimo que puedas en esta área excepto para desplegar elementos de tu escena. Todo lo demás que sea necesario para la ejecución adecuada de tu juego (que eventualmente involucra el mover objetos, chequear colisiones, actualizar puntuaciones, chequear la condición fin de juego, etc.) se encontrará en el método Update.

Método UnloadContent

Al punto dentro del Game Loop donde se llegue a una condición de finalizar el Juego, el bucle se termina, y se invoca automáticamente el método UnloadContent. Este método es usado para liberar cualquier contenido cargado previamente en el método LoadContent que requiere un manejo especial de liberación. Tipicamente, XNA (como .NET) manejara la recolección de basura automáticamente, pero si has modificado la memoria en algún objeto que requiere un manejo especial, el método UnloadContent es donde implementaras la lógica de liberación de contenido de la memoria.

Diseña un sitio como este con WordPress.com
Comenzar