Interacción en XNA para Windows Phone: Capturas usando TouchCollection

A pesar de la comodidad que nos brinda el framework XNA para reconocer gestos de manera sencilla, a veces podemos encontrarnos en la situación que queremos tener mas control sobre el manejo de eventos en la pantalla táctil del teléfono. Es por esto que existe otra forma de realizar captura de datos de la pantalla por parte del usuario. Hagamos un ejemplo para que veas este camino de interactividad con la pantalla táctil de un Windows Phone.

Ejemplo de captura de eventos táctiles

Abre Visual Studio 2010, y crea un proyecto Windows Phone Game (4.0), nómbralo «TouchXNA». Ahora para este proyecto, implementaremos una lógica para desplegar una imagen donde el usuario este «tocando» la pantalla, y además muestre las coordenadas y el ID del punto detectado.

Ahora busca cualquier imagen que deseas que no pase los 80×80 pixeles, y descárgala. En este ejemplo se usará la siguiente imagen del planeta marte.

Preparando el Content

Ahora dale clic-derecho sobre el Content del proyecto, y selecciona «agregar->ítem existente» y busca la imagen que deseas agregar. Ahora agrega un nuevo ítem en el Content, pero esta vez tipo «Sprite Font», y nómbralo «SpriteFont1»

Implementando la lógica

Regresa a la clase Game1.cs, en la región de la declaración de los atributos, agrega lo siguiente justo debajo de la línea «SpriteBatch spriteBatch;«:

SpriteFont spriteFont;
TouchCollection touchCollection;
Texture2D planetaTextura;
Vector2 planetaPosicion;
Vector2 textoPosicion;

Usaremos el spriteFont para el formato del string que imprimiremos la información del punto de contacto encontrado. planetaTextura resguarda la textura de la imagen que deseamos desplegar en el punto de contacto. planetaPosicion se utilizará para designar la posición donde queremos desplegar planetaTextura. touchCollection es de tipo TouchCollection, y funciona como una lista que almacena los puntos de contacto detectados en cada instante de tiempo.

Dirígete al método LoadContent para cargar la fuente y la textura que habíamos agregado previamente a nuestro Content del proyecto:

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

Ya con nuestro contenido cargado a nuestra aplicación, proseguimos a realizar el proceso de detección de puntos de contacto por parte del usuario, donde asignaremos la posición del planeta y del texto a desplegar en la pantalla. Esto se realiza en el método Update:

protected override void Update(GameTime gameTime)
{
	if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) 
		this.Exit();

	touchCollection = TouchPanel.GetState();
	if(touchCollection.Count >= 1){
		planetaPosicion.X = touchCollection[0].Position.X - planetaTextura.Width / 2;
		planetaPosicion.Y = touchCollection[0].Position.Y - planetaTextura.Height / 2;
		textoPosicion.X = touchCollection[0].Position.X + 35;
		textoPosicion.Y = touchCollection[0].Position.Y + 10;
	}
	base.Update(gameTime);
}

Puedes observar que a planetaPosicion le asignamos la posición del punto encontrado, restándole la mitad del ancho y alto para los ejes X e Y. Si no hacemos esto, donde nosotros toquemos la pantalla, la imagen se mostrará pero no centrada en el punto. Esto es porque la posición de  una imagen es con respecto a la esquina izquierda superior. Esto se puede ajustar sencillamente restándole la mitad del ancho y alto de la imagen a la posición del punto de contacto.

Ahora, en cuanto al método Draw, agrega las siguientes líneas de instrucciones:

protected override void Draw(GameTime gameTime)
{
	GraphicsDevice.Clear(Color.CornflowerBlue);
	spriteBatch.Begin();
	foreach (TouchLocation touch in touchCollection)
	{
		spriteBatch.Draw(planetaTextura, planetaPosicion, Color.White);
		spriteBatch.DrawString(spriteFont, 
			"ID: " + touch.Id.ToString() + " (" + (int)touch.Position.X +
			"," + (int)touch.Position.Y + ")", textoPosicion, Color.White);
	}
	spriteBatch.End();
	base.Draw(gameTime);
}

Ahora es momento de compilar y ejecutar tu aplicación. Si todo funciona correctamente, veras el emulador de Windows Phone con tu aplicación ejecutándose, y cuando hagas clic en la pantalla y arrastres el cursor, veras la imagen moviéndose junto a su mouse. A continuación una captura de la aplicación:

Sencillo, no crees? Unas cuantas líneas de código y puedes conseguir los puntos de contacto detectados en la pantalla táctil del Windows Phone. Si tu proyecto presenta errores de compilación, puedes descargarte el ejemplo:

Proyecto TouchXNA

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

Ejemplo XNA parte 1 – Creacion del Proyecto XNA

Vamos a crear un juego completo sencillo desde cero.

Dinámica del juego

Haremos un juego 2D, donde el usuario controlará una aeronave que dispara rayos laser para detonar minas que se le presentan en su camino, evitando que colisione contra ellas. El diagrama a seguir será el siguiente:

Se puede ver un tanto complicado, pero verás que armándolo paso a paso será sencillo.  Es siempre una buena practica diagramar el juego que estés diseñando, a modo que tengas una vista general de lo que quieres crear de manera modular y organizada. Puedes ver los diversos estados en el que se encuentra tu aplicación, como Menú Principal, Fase «Juego» y toda la lógica que conlleva esa fase, como el chequeo de input, actualización de posición de los elementos del juego como los enemigos, proyectiles, etc.; hasta la fase de fin de juego, q te llevara de regreso al menú principal.

En este capitulo de construcción del juego, nos enfocaremos en la fase de «Juego», donde manejaremos despliegue de elementos animados (el jugador, enemigos, proyectiles, explosiones), una técnica para el fondo, dando sensación de profundidad, efectos de sonido, puntaje y colisiones. A continuación te muestro un snapshot de como quedara el juego al final.

Sin más preámbulo, prepárate para la implementación de nuestro juego.

Comencemos a implementar nuestro juego

Abre Visual Studio 2010, y crea un proyecto XNA para Windows PC, y nómbralo «Shooter».

Material Requerido

Vamos a necesitar el siguiente contenido gráfico para nuestro content.

Material Shooter

Crea una carpeta «Imágenes», «Fuente» y «Audio» en la sección Content, y agrega el contenido descargado en las carpetas agregadas correspondientes. También descarga la clase Animación (link) para animar los elementos descargados, y agrégalo a tu proyecto.

Agregar el Material al Proyecto

En la sección Content del proyecto, agrega tres carpetas nombradas «Imagenes», «Fuente» y «Sonidos». Ahora prosigue a agregar el material descargado previamente en las carpetas correspondientes. En la sección de código del proyecto, agrega la Clase “Animation”, que la usaremos después. Asegúrate que el Namespace de esa clase sea la misma a como nombraste el proyecto («Shooter»).

Una vez haya agregado todo el contenido necesario para nuestro juego, la estructura del proyecto debe quedar de la siguiente forma:

Ahora prosigue a compilar tu solución y ejecútalo. Si todo funciona bien, te debería desplegar una ventana con un gran panel azul.

Hasta este punto hemos preparado nuestro proyecto con todo el material audiovisual necesario para implementar nuestro juego. Si deseas descargarte la fase final de este tutorial, simplemente da click al proyecto:

Proyecto Shooter Parte 1

Despliegues de Sprites en 2D

Bien, ya visto en articulos anteriores todo el basamento teórico de como funciona el Framework XNA, las versiones que han salido desde su lanzamiento en el 2007, el soporte para las diversas plataformas de Microsoft (Windows PC, Xbox 360 y Windows Phone), el funcionamiento de XNA y por último, la estructura de un proyecto de un Windows Game XNA en Visual Studio, es hora que empecemos a codificar y dibujar elementos.

Paso 1. Crear el proyecto

Debes abrir Visual Studio 2010 con XNA Game Studio 4 previamente instalado, y crear un proyecto Windows Game (4) como se mostró en el artículo anterior.

Paso 2. Agregar una imagen a nuestro Content

Ahora debemos agregar una carpeta en el Content donde colocaremos nuestras imágenes. No es requerido crear un directorio, pero lo recomiendo para mantener nuestro contenido gráfico organizado. Simplemente da un clic-derecho en tu proyecto Content, le das clic a agregar->nueva carpeta, y lo nombraremos «Imagenes».

Para agregar una imagen (que la pueden encontrar aqui para descargar), dale clic-derecho a la carpeta «Imagenes» ya creada, luego clic en agregar->item existente. Te saldrá un explorador de archivos, para que busques el archivo de imagen que deseas agregar a tu proyecto. Selecciona la imagen que descargaste previamente (smiley.png), y le das clic a «Agregar»).

Paso 3. Dibujar el sprite en la Escena

Ya que tenemos nuestra imagen en el Content de nuestro proyecto, debemos cargarla y desplegarla escribiendo código. Lógicamente para desplegar esta imagen, dependemos lógicamente de dos cosas: Posición y Textura. Para eso, agrega las siguientes dos variables dentro de tu clase principal (Game1), debajo de spriteBatch. El código se vería de la siguiente manera:

Vector2 es un tipo de datos que posee dos campos float x,y; a modo de trabajar con coordenadas de dos dimensiones. Ininializa posicion en el método Initialize:

Ahora procedemos a cargar la imagen a nuestro juego. Esto se hace en el método LoadContent. El código quedaría así:

Puedes observar que se instancia la variable spriteBatch (el cual puedes verlo por los momentos como el pincel encargado de pintar todos los elementos en la escena de nuestro juego). También observa como se carga una textura2D con el método Load. Toma en cuenta el string que pasamos como parámetro; es la ruta del elemento que queremos cargar. Por esto, es importante colocar en qué directorio se encuentra si esta organizado de esta manera.

Paso 4. Desplegar nuestro sprite en la escena

Recapitulando, hemos agregado nuestra imagen archivo al contenido de nuestro proyecto; hemos agregado una variable para la posición donde desplegaremos nuestro sprite, y declaramos una variable Texture2D, donde realizamos la carga de nuestra imagen del contenido a la aplicación. Ahora, sin más preámbulos, dibujemos nuestro sprite. Esto se implementa en el método Draw.

Para pintar nuestro sprite, debemos utilizar nuestra variables spriteBatch, ya que este es el encargado de dibujar los elementos en la escena como ya mencione a priori. Todos los elementos que vayamos a dibujar se hacen mediante su método Draw(), y estos deben estar encerrados dentro de los métodos spriteBatch.Begin() y spriteBatch.End(). Muy importante estos dos métodos, porque estamos avisando a nuestra aplicación que vamos a pintar elementos, y cuando terminemos, invocamos el método End(). En nuestro caso, nuestro código se vera así:

Fíjate el método spriteBatch.Draw(). Solo estamos pasando la textura que deseamos desplegar, la posición, y el color que queremos que sea desplegado. Si colocamos Blanco, se mostraran los colores originales de la imagen. Cualquier otro color modificara los colores de nuestro sprite.

Finalmente, al ejecutar nuestra aplicación, tendrás un resultado como este:

Sencillo, no crees? Esta es la manera mas elemental para desplegar un sprite en nuestro juego. El método Draw que utilizamos es el mas básico disponible, ya que este método cuenta con 7 formas distintas de invocar con diversos parámetros, incluyendo efectos, manejo de rectángulos para dibujar ciertas áreas, etc. Para proyectos más complejos, se trabajan con clases donde encapsulan estas propiedades (textura, posición), y se le agregan mas propiedades para ser mas flexibles ante transformaciones y efectos.

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.

Que es XNA?

Microsoft XNA es un conjunto de herramientas con un entorno de ejecución provisto por Microsoft que facilita el desarrollo y manejo de videojuegos. XNA se enfoca de librar a los desarrolladores de juegos de escribir mucho código repetitivo pero con ligeros cambios, y traer diferentes aspectos de producción del juego en un solo sistema.

Actualmente, XNA engloba toda la sección de desarrollo de videojuegos para Microsoft, incluyendo el kit de desarrollo estándar de Xbox y XNA Game Studio.

El nombre XNA se origino de un nombre de proyecto de desarrollo, la Nueva Arquitectura de la Xbox en ingles. En lugar de ser liberado con el nombre de Xbox, se lanzo al mercado el Xbox 360, y XNA llevo el nuevo acrónimo “XNA NO es un Acrónimo”.

Versiones de XNA

XNA Game Studio Express

Fue el primer release de XNA Game Studio, para estudiantes, aficionados y desarrolladores de juegos independientes. Estaba disponible como una descarga gratuita. Express provee kits básicos para desarrollo rápido de géneros de juegos específicos, como juegos de plataforma, estrategia en tiempo real, y shooter en primera persona. Desarrolladores pueden crear juegos para Windows gratuitos con el Framework de XNA, pero para Xbox 360 se debe pagar una subscripción anual de 99$ en el XNA Creators Club.

La primera versión beta de XNA Game Estudio Express fue liberado para descarga el 30 de agosto del 2006, seguido de una segunda versión el 1ero de noviembre del mismo año. El 11 de diciembre Microsoft publicó la versión final.

El 24 de abril del 2007, Microsoft liberó una actualización conocida como el XNA Game Studio Express 1.0 Refresh.

XNA Game Studio 2.0

XNA Game Studio 2.0 fue liberado el 13 de Diciembre del 2007. Esta versión incluía la facilidad de ser utilizado en todas las versiones de Visual Studio 2005 (incluyendo la versión gratuita Edicion Express  de Visual C#),  incluyendo un API con conexión a servicios de Xbox Live en ambos Windows y Xbox 360, y mejor manejo de dispositivos.

XNA Game Studio 3.0

Esta versión salió para Visual Studio 2008 y la edición gratis Visual C# 2008 Express. XNA Game Studio 3.0 permitió la producción de juegos orientados a la plataforma Zune y agrega soporte de la comunidad de Xbox Live. Un beta de un toolset fue liberado el 30 de Octubre del 2008. Para esta versión ya soportaba C# 3.0, LINQ y muchas más versiones de Visual Studio 2008. En cuanto a nuevas funcionalidades del framework, se agregó el modo trial para hacer versiones de prueba de los juegos desarrollados, funciones de multijugador para Xbox Live como invitaciones in-game, crear juegos para las plataformas Windows, Xbox 360 y Zune.

XNA Game Studio 3.1

XNA Game Studio 3.1 fue soltado el 11 de junio del 2009. Este API incluye soporte para reproducción de video, un nuevo API de audio, el sistema de Xbox Live Party y soporte para juegos que utilicen avatares de Xbox 360.

XNA Game Studio 4.0

Anunciado y liberado inicialmente a una comunidad técnica de prueba en la Conferencia de Desarrolladores de Juegos, el 9 de marzo del 2010, y en su versión final el 16 de septiembre del mismo año. Esta versión agrego soporte a la plataforma de Windows Phone (incluyendo aceleración de hardware para 3D), perfiles de hardware, efectos configurables, estados de objetos embebidos, el cruce de plataformas, input multitouch y micrófono e incluso la integración con Visual Studio 2010.

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