Windows Técnico : Visual Studio

Evento de lanzamiento de VS2012

Ioseba Palop — Wed, 26 Sep 2012 08:07:00 GMT

¡Ya tenemos fecha de lanzamiento de Visual Studio 2012!
Microsoft España ha preparado un evento de lanzamiento del entorno de desarrollo por excelencia, Visual Studio 2012. Recordad que es necesario registrarse para poder asistir. Las fechas elegidas son:

· Madrid, Teatro Goya, 2 de Octubre 09:30.

· Barcelona, Hotel Hesperia Tower, 4 de Octubre 09:30.

Figura 01 – Agenda de la presentación de VS2012

Entre otras muchas novedades, encontraremos una interfaz renovada al estilo Windows 8, herramientas de administración del ciclo de vida de las aplicaciones, plantillas y herramientas para la creación y distribución de aplicaciones Windows 8 y compatibilidad integrada con la nube.

Figura 02 – Nueva interfaz 2012

Si quieres aprender mucho más sobre los secretos de lo sistemas Microsoft Windows, te recomendamos leer el libro de Sergio de los Santos “Máxima Seguridad en Windows: Secretos Técnicos”.Si quieres aprender más secretos, configuraciones, integraciones, desarrollo de PowerShell te recomendamos leer el libro de Pablo González y Ruben Alonso “PowerShell: La navaja suiza de los administradores de sistemas” y, por último, te recordamos que si te ha gustado el artículo puedes suscribirte al Canal RSS de Windows Técnico para estar al día de las novedades e información técnica de interés.

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed” .Anexo

Jhonattan Fiestas — Thu, 15 Sep 2011 19:06:00 GMT

La presente entrada corresponde con el anexo anunciado en el post previo con el cual se pretende cerrar la dilatada serie “Desarrollo de aplicación de ejemplo Windows7 Multitouch: Simon Dice Renewed” sobre el comportamiento de la aplicación de ejemplo Simón Dice.
Durante el transcurso del análisis se presentaran diversas formas de ver el juego que han sido desarrollados por diversas personas, que a lo largo del tiempo han dedicado parte de su tiempo a programar este juego, cada uno con su toque personal y diferente.

Como se venía comentando en la anterior entrada, en esta ocasión se centrara la atención en definir las últimas funciones pertenecientes a la clase “MainWindow”, y hacer un repaso general sobre lo aprendido a lo largo de toda la serie.

Lo primero a realizar será el análisis y descripción de las funciones por medio de enunciados y/o comentarios sobre código para facilitar de esta manera el conocimiento de la aplicación en cada uno de sus líneas de código.

· inicializarJuego

Como su propio nombre indica esta función es llamada al inicio de la partida, para colocar los valores de inicio, como son el número de intentos y la puntuación de la partida actual.

private void inicializarJuego()

{

txtIntentos.Text = "3";

txtPuntuacion.Text = "0";

estado.Visibility = Visibility.Hidden;

}

· nuevaLista

Esta función tiene como objetivo crear una lista y añadir aleatoriamente números del 0 al 6 hasta completar la longitud (“Length”), finalmente copiamos el puntero de esta lista(variable local) a la lista de juego (que es una variable global).

public void nuevaLista(int length)

{

List<int> lista2 = new List<int>();

int i = 0;

while (i < length)

{

int numero = (int)r.Next(0, 6);

lista2.Add(numero);

i++;

}

lista = lista2;

}

· establecerSonido

Esta función tiene un cometido lógico y bastante fácil de comprender. Una vez establecidos los sonidos en el array de string “sonidobtn”, según sea el botón pulsado, se establece el valor en la variable “son”, para que después sea reproducido por el objeto de la clase Windows Media Player llamado “Player”.

private void establecerSonido(int btn)

{

switch (btn)

{

case 0: son = sonidobtn[0];

break;

case 1: son = sonidobtn[1];

break;

case 2: son = sonidobtn[2];

break;

case 3: son = sonidobtn[3];

break;

case 4: son = sonidobtn[4];

break;

case 5: son = sonidobtn[5];

break;

default: son = sonidobtn[0]; break;

}

· ImagenNormal

Tanto la función “ImagenNormal” como la función “ImagenPulsada” tienen un cometido en común, diferenciar la apariencia del botón cuando éste está siendo pulsado y cuando no. En ambos casos se indica el botón que cambiará de apariencia y porque imagen será reemplazada.

private void imagenNormal(int btn)

{

try

{

switch (btn)

{

case 0: btn1.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/azul.png"));

break;

case 1: btn2.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/morado.png"));

break;

case 2: btn3.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/rojo.png"));

break;

case 3: btn4.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/verde.png"));

break;

case 4: btn5.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/verdemar.png"));

break;

case 5: btn6.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/naranja.png"));

break;

default: System.Windows.MessageBox.Show("Boton: " + btn); break;

}

catch

{

imagenNormal(btn);

}

private void imagenpulsada(int btn)

{

switch (btn)

{

case 0: btn1.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/azul2.png"));

break;

case 1: btn2.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/morado2.png"));

break;

case 2: btn3.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/rojo2.png"));

break;

case 3: btn4.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/verde2.png"));

break;

case 4: btn5.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/verdemar2.png"));

break;

case 5: btn6.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;

component/Img/naranja2.png"));

break;

default: System.Windows.MessageBox.Show("Boton: " + btn);

break;

}

· midiOutOpen

Esta función hace llamadas a la API de Windows en relación con la apertura de dispositivos de salida, como puede ser los altavoces del equipo. Para poder hacer uso de estas funciones se tiene que agregar la referencia a la librería “winmm.dll” de Windows Media Player, como se puede apreciar en el código que la implementa.

[DllImport("winmm.dll")]

private static extern int midiOutOpen(ref int handle, int deviceID,

MidiCallback proc, int instance, int flags);

· btnJugar_MouseLeftButtonDown y btnJugar_TouchDown

Cuando el usuario se encuentra en el lienzo de juego y pulsa sobre el botón jugar, se debe comprobar que el nivel sea superior a 0, ya que si se llega al caso de que el nivel sea cero se cambiará el valor del nivel a 1, hasta que se gasten todos los intentos disponibles. Recordad que el número de elementos de la lista de juego depende del nivel, por eso mismo, nunca debe ser cero, y como mínimo deberá bajar hasta 1.

Una vez pulsado sobre el botón “Jugar”, se reproducirá la secuencia de pulsaciones correspondiente a los elementos que se encuentran en la lista “lista”.

private void btnJugar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

estado.Visibility = Visibility.Hidden;

nivel=nivel==0?1:nivel;

txtRonda.Text = String.Format("{0}", nivel);

btnJugar.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;component/Img/"

+ "btnJugar2.png"));

btnJugar.IsEnabled = false;

nuevaLista(nivel);

habilitarBotones();

jugarLista();

}

· btnJugar_MouseLeftButtonUp_1 y btnJugar_TouchUp

Cuando se deja de pulsar el botón debe recuperar su imagen habitual, de esta forma da una sensación de pulsado.

private void btnJugar_MouseLeftButtonUp_1(object sender, MouseButtonEventArgs e)

{

btnJugar.Source = new BitmapImage(

new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "btnJugar.png"));

}

· btnSalir_MouseLeftDown y btnSalir_TouchDown

Cuando se ejecute esta función, se cambia del lienzo de juego al lienzo de inicio, cancelando la reproducción de sonidos si el caso lo requiere.

private void btnSalir_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

juego.Visibility = Visibility.Hidden;

Inicio.Visibility = Visibility.Visible;

cancelarEjecucion();

}

· btnSalirTotal_MouseLeftDown y btnSalirTotal_TouchDown

En ambos casos, la acción de este método conlleva la salida de la aplicación y el cerrado de la interfaz de usuario asociada a la aplicación.

private void btnSalirTotal_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

System.Windows.Forms.Application.Exit();

this.Close();

}

· cancelarEjecucion

Cuando se da al botón salir, desde el lienzo del juego, se debe cancelar la ejecución del reproductor de sonidos y vaciar la lista de juego, para que en la próxima entrada al juego dicha lista esté vacía y no tenga ningún valor en su contenido.

private void cancelarEjecucion()

{

lista = new List<int>();

Player.controls.stop();

}

Secuencia de juego:

Al iniciar la aplicación se lanza el evento “OnLoad” con su función “WindowsLoaded” asociada, para inicializar variables.

Luego se ejecuta “InicializarBotones” junto con “Deshabilitarbotones” para evitar que alguien pulse cuando aún no es necesario, aquí se detiene la ejecución de la aplicación a la espera de una acción del usuario.

En el caso de pulsar sobre el botón “Jugar” se lanzaría la función “btnEntrar_TouchDown”, en caso contrario si se pulsa sobre el botón de salir se ejecutaría la función “btnSalirTotal_TouchDown”, saliendo completamente del proyecto.
Si se sigue por la primera vía, se pasaría otra vez a un estado de espera hasta que el usuario pulse sobre “jugar” con lo que se desencadena la función “btnJugar_touchDown”, dentro del cual se ejecutan las funciones “nuevaLista”,”habilitarBotones” y “jugarLista”, dentro de esta última función se ejecutan las siguientes acciones: Por cada elemento de la lista de juego se genera una pulsación virtual (“imagenpulsada”), después se deshabilitan los botones hasta que termine la secuencia a reproducir(“deshabilitarBotones”), se establece un sonido (“establecerSonido”), se reproduce y por último la imagen que ha sido cambiada debe volver a su estado original.(“imagenNormal”) hasta que por último se habilitan los botones para ser pulsados(“habilitarBotones”).El siguiente paso es pulsar sobre el botón adecuado siguiendo la secuencia correcta. Al pulsar sobre cualquier botón se ejecutará la función “btn_TouchDown” y posteriormente al dejar de pulsar pasara a ejecutarse “btn_TouchUp” relativo a dejar de pulsar sobre dicha imagen.
Si la pulsación es correcta, se ira a la función “comprobar” y proseguirá con la secuencia hasta reproducirla por completo, con los cual se ejecutaría la función “ganar”; en caso contrario, si el usuario se equivoca en un paso se lanzaría la función “error” bajando un nivel del actual, hasta un mínimo de 1.

Básicamente estas serían las funciones esenciales que describen el funcionamiento de la aplicación. Si se desea una descripción más específica de cada una de ellas siempre se puede acceder a cada una de las entregas de esta serie mediante los enlaces que aparecen debajo.

Sin más que añadir, desde Windows Técnico se espera que esta serie haya servido para introducir un punto más de inquietud en los desarrolladores para la creación de aplicaciones para este tipo de dispositivos y al uso de las herramientas amigables que proporciona Microsoft a través de Visual Studio 2010 y Windows Presentation Fundation.

Para acabar, recuerda que si quieres aprender mucho más sobre los secretos de los sistemas Microsoft Windows, te recomendamos leer el libro de Sergio de los Santos "Máxima Seguridad en Windows: Secretos Técnicos" , o siempre puedes suscribirte al Canal RSS de Windows Técnico para estar al día de las novedades e información técnica de interés.

---------------------------------------------------------------------------------------------------------------------------

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed” I

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed” II

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed” III

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed” IV

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed” V

Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simón Dice Renewed”. Anexo

----------------------------------------------------------------------------------------------------------------------------

Tablets MultiTouch con MS Windows 7: Comunicación del S.O. y las aplicaciones.

Ignacio Briones — Thu, 17 Mar 2011 13:20:00 GMT

En la anterior entrada de la serie Tablets MultiTouch con MS Windows 7: Herramientas presentábamos aquellos entornos y utilidades disponibles para la programación de aplicaciones en dispositivos tablet multitouch con Windows 7.

Pero como ya anunciábamos, tras unas primeras entradas de carácter más generalista nuestro objetivo con esta serie es ir aportando información más específica y que pueda ser de utilidad en aspectos concretos para el desarrollo de aplicaciones. En esta línea, vamos a tratar en el presente post los mecanismos de los que hace uso Ms Windows 7 para comunicar a las aplicaciones las acciones realizadas por parte del usuario sobre los dispositivos tablet.

Cada vez que se realiza una acción en la pantalla de los dispositivos multitouch, Ms Windows 7 genera dos tipos de mensajes: WM_TOUCH y WM_GESTAURES. Ambos son recogidos por aplicaciones o frameworks de programación, como WPF (Windows Presentation Foundation) que ya citábamos. Tras ello, las aplicaciones actuarán en consecuencia.

Valoremos a continuación el primer tipo de mensajes VM_TOUCH. Este recoge las acciones más simples, básicamente presión, movimiento y la acción de levantar el dedo de la pantalla. Cada acción de este mensaje puede tratarse de forma individualizada, asociándole un proceso de ejecución. Para ello haremos uso de WPF (Windows Presentation Foundation) que se encargará de de transformar la gestión del mensaje WM_TOUCH, en una gestión controlada de eventos.

Seguidamente se muestra cómo se capturan los eventos de presión de la pantalla “TouchDown”, movimiento por la misma “TouchMove” y levantar el dedo “TouchUp”, para luego realizar una gestión del evento sin tener que acceder directamente al mensaje WM_TOUCH.

El segundo mensaje que debemos tener en cuenta, en la programación para un dispositivo multitouch, es WM_GESTAURES. Este mensaje es lanzado por el sistema operativo cuando se producen gestos sobre la pantalla del tablet. Como vimos en la primera entrada de la serie Tablets MultiTouch con MS Windows 7: Desarrollo de Aplicaciones, estos gestos son los que corresponden a las acciones de zoom, giro o desplazamiento.

De igual modo que para el anterior mensaje WM_TOUCH, también la plataforma .Net y WPF, proporcionan librerías para la gestión de WM_GESTAURES y su consiguiente transformación en eventos del sistema.

Las librerías encargadas de esto son Microsoft.Expresion.Interactions y System.Windows.Interactive. Si queremos dotar a nuestro aplicativo de las funcionalidades proporcionadas por los gestos de los dispositivos Multitouch, tendremos que incluir estas dos librerías en el desarrollo de nuestro código.

Una de las ventajas al hacer uso de estas librerías, es dotar a los objetos de WPF de las cualidades de giro y de zoom, por medio de la propiedad TranslateZoomRotateBehavior. Adicionalmente estas librerías evitan tener que tratar de forma directa el mensaje WM_GESTAURES, que complicaría la programación de aplicaciones.

Se muestra a continuación como incluir la propiedad TranslateZoomRotateBehavior en un objeto de WPF y así dotarlo de zoom y de rotacion:

Con la entrada de hoy hemos visto como recibir por parte de la aplicaciones las acciones básicas que se realizan sobre los dispositivos tablet multitouch. De esta manera nuestra aplicación podrá interactuar con el tablet y el usuario, aprovechando las ventajas de las funcionalidades incorporadas en los dispositivos multitouch.

Seguiremos dando entrada en Windows Técnico a nuevos posts de esta serie.

Para acabar, recuerda que si quieres aprender mucho más sobre los secretos de los sistemas Microsoft Windows, te recomendamos leer el libro de Sergio de los Santos "Máxima Seguridad en Windows: Secretos Técnicos" , o siempre puedes suscribirte al Canal RSS de Windows Técnico para estar al día de las novedades e información técnica de interés.

Camino a la cuarta generación del desarrollo software: Desarrollo Dirigido por Modelos y su aplicación con la tecnología Domain Specific Language de Microsoft (Parte III)

Juan Antonio — Tue, 11 May 2010 16:57:00 GMT

Buenas a todos, en el post de hoy continuaremos la cadena de post sobre desarrollo con DSL Tools y diseñaremos el resto del DSL que comenzamos la semana pasada. Después, contaremos como se diseña la interface gráfica de nuestro DSL.

Para el ejemplo que hemos utilizado y en el que vamos a desarrollar un dsl que nos permita automatizar la generación de ficheros XML, requeriremos una serie de elementos que nos permitan generar un árbol abstracto que simule las etiquetas del árbol XML. Estos elementos serán representados por nodos y atributos. Cada nodo puede tener cero o más atributos. Además, los nodos pueden ser de tres tipos, nodo raíz, nodo hoja, o nodo normal. El nodo raíz podrá tener 0 o más hijos. El nodo hoja no podrá tener hijos. Y los nodos normales tendrán padre y cero o más hijos. Este efecto lo conseguiremos jugando con las cardinalidades.

Ahora aprovecharemos el esqueleto del modelo proporcionado y modificaremos los nombres y atributos de las clases hasta dejarlos como en la captura de pantalla que se verá a continuación.

Cambios a realizar:

Cambiar el nombre del modelo (en la clase “domain class”) de ExampleModel a ModeloDocXml.
Cambiar el nombre de la clase ExampleElement a Nodo. Cambiar el nombre de su atributo Name a Nombre. Y añadirle los atributos Campo (string), Raiz (boolean), Hoja (boolean), con los que identificaremos el tipo de nodo del que se trata.
Modificaremos el nombre Elements a Nodos de la Reference Relationship que une ModeloDocXml con Nodo. Y que utilizaremos posteriormente para identificar el número de nodos que contiene nuestro modelo.
Además añadiremos una clase nueva a la que le daremos de nombre Atributo y le añadiremos los atributos Nombre e Identificador. Que uniremos a la clase nodo con un Embbeding Relationship. Modificaremos finalmente la cardinalidad de manera que un nodo pueda tener cero o mas atributos.

Tras realizar estos cambios deberíamos tener nuestro modelo terminado:

Ahora llega la hora de diseñar la interface que tendrá nuestro modelo. En la parte derecha veréis que hay un diagrama paralelo llamado Diagram Elements, en él se diseñará la interface de nuestro modelo.

Para aclararnos renombraremos la forma ExampleShape a NodoShape. El ExampleConnector a NodoConnector y el LanguageDiagram a XmlGeneratorDiagram.

Como partimos nuestro modelo de un esqueleto, ya está diseñada la interface de la clase nodo, y de la flecha que se utiliza para unir los nodos. Ahora queda diseñar la interface de los atributos que puede tener un nodo. Para ello arrastraremos desde la toolbox un Geometry Shape y un Connector a los que renombraremos como AtributoShape y AtributoConnector. Ahora pulsaremos botón derecho sobre Decorator en la clase AtributoShape y añadiremos un atributo NameDecorator, lo que nos permitirá poner un nombre en el atributo, durante el diseño de nuestro modelo. Tras realizar estos cambios deberíais tener lo siguiente:

Y el resultado final sería el siguiente:

Ahora debemos asociar la clase Atributo y el conector que le une con la clase Nodo, con sus correspondientes shape. Para ello utilizaremos la herramienta de la toolbox Diagram Element Map.

Una vez hecho esto pincharemos en la flecha que une la clase Atributo con AtributoShape y accederemos a la pestaña Decorator Maps, donde marcaremos la casilla NameDecorator como muestra la siguiente imagen y seleccionaremos en Display Property el atributo Nombre. De esta manera conseguiremos que dentro del nodo en el modelo muestre el atributo Nombre:

Ahora iremos a la pestaña General y comprobaremos que el Parent Element Map está apuntando al ModelDocXml desde donde hereda, para que posteriormente desde el código del programa podamos acceder a sus atributos:

Finalmente, y como función únicamente estética podremos modificar el aspecto de los nodos y atributos del modelo jugando con las distintas posibilidades que ofrecen desde su correspondiente menú propiedades, colores, formas de los nodos, etc:

Esto es todo por hoy, en el próximo post generaremos la toolbox que contendrá todos los elementos de nuestro DSL y la probaremos.

Hasta el próximo post, saludos!

Microsoft Alm’09 Sessions

Juan Antonio — Tue, 17 Nov 2009 09:48:00 GMT

El próximo día 24 de Noviembre se celebrará el Microsoft Alm’09 Sessions en Madrid. El Alm’09 Sessions es un día de conferencias en el que Microsoft y sus partners hablan sobre las ofertas de optimización del ciclo de vida del software. Contará con 6 Sesiones en paralelo y más de 30 ponencias, un verdadero lujo. Las sesiones son las siguientes:

Como optimizar sus procesos y metodologías aplicadas en casos prácticos (SCRUM, Agile, CMMI).
Presentar nuestra nueva solución de Testing para elevar el nivel de calidad en sus desarrollos.
Arquitectura UML y Cloud Computing.
Herramientas propias y de terceros, presentes y futuras versiones.
Una Plataforma de Aplicaciones totalmente integrada.
Diseño que se complementa con el desarrollo y enriquece sus aplicaciones.

Agenda:

6 sesiones en paralelo: Procesos, calidad y testing, arquitectura, herramientas, plataforma de aplicaciones, diseño y UX.
30 ponencias presentadas por nuestros principales partners.
Presentación de una nueva solución Testing que eleva el nivel de calidad de las aplicaciones.
Casos prácticos de procesos y metodologías.
Arquitectura UML y Cloud Computing
Herramientas propias y de terceros.
Una plataforma de aplicaciones totalmente integrada.
Diseño que se complementa con el desarrollo y enriquece sus aplicaciones

Horario y resumen de cada ponencia:

http://www.microsoft.com/spain/visualstudio/ALM09/agenda.aspx

Cómo llegar:

http://www.microsoft.com/spain/visualstudio/ALM09/DondeCuando.aspx

Página oficial del evento:

http://www.microsoft.com/spain/visualstudio/ALM09/

Microsoft Visual Studio 2010 Beta 2:

http://www.microsoft.com/spain/visualstudio/default.mspx

Creación e instalación de módulos para Internet Information Services 7 (parte III)

Juan Antonio — Mon, 02 Nov 2009 14:21:15 GMT

Hoy vamos a finalizar la cadena de post sobre programación de módulos para IIS7. En este post voy a explicaros cómo programar vuestro propio módulo con interfaz gráfica configurable y cómo instalarlo en el IIS.

¿Para que sirve un módulo gráfico?

Muchos, por no decir la mayoría de los programas requieren de algunos parámetros que necesitan ser configurables para adaptarse a las diferentes situaciones para las que es aplicable el programa que se ha desarrollado. Los módulos del IIS no son menos, y estos no son ni más ni menos que un programa normal, pero embebido dentro de la interfaz del IIS. La programación gráfica de estos programas será exactamente igual a la de otro programa realizado en .NET, con la diferencia de que tendremos que añadirle algunos elementos para que pueda ser reconocido por el IIS. ¡Vamos a ello!

Instalaciones necesarias:

1. Microsoft Server 2008

2. Visual Studio 2005-2008

3. IIS 7

Construcción del módulo:

Una vez tengamos IIS instalado, abrimos el Visual Studio, el primer paso para la construcción de nuestro módulo será crear un nuevo proyecto, seleccionamos crear una nueva Biblioteca de clases, le damos un nombre, por ejemplo: proyecto_i64 y aceptamos:

Eliminamos la clase que nos crea por defecto: Class1.cs, que no la vamos a utilizar.

Ahora tenemos que añadir dos referencias, para ello hacemos clic con el botón derecho del ratón en “References” y pulsamos en “Agregar Referencia”.

Tenemos que incluir las siguientes referencias:

Microsoft.Web.Administration.dll.
Microsoft.Web.Management.dll.

Las encontraremos en la pestaña examinar, en la ruta: c:\windows\system32\inetsrv.

Una vez agregadas las referencias procedemos a firmar nuestra librería, para que el IIS pueda reconocerla como .dll:

1. Para firmar nuestra librería .dll hacemos doble clic en el explorador de soluciones en la etiqueta “properties” y nos vamos a la pestaña “firma”, marcamos la casilla “firmar el ensamblado” y en seleccionar un archivo de clave de nombre seguro le damos a <Nueva..>:

2. Le asignamos un nombre, por ejemplo, key.snk y desmarcamos la casilla de proteger con contraseña. Con esto ya tenemos nuestra .dll firmada:

3. Tenemos que añadir un pequeño script, que nos enviará nuestra .dll firmada a la carpeta de ensamblados que se encuentra en la ruta C:\Windows\assembly, desde donde el IIS la recogerá para poder agregarla finalmente cómo modulo. Para ello, sin salirnos de la ventana “properties” nos vamos a la pestaña “Eventos de generación”, y en el cuadro “línea de comandos del evento posterior a la generación” incluimos el siguiente script si estáis usando Visual Studio 2005:

CALL "%VS80COMNTOOLS%\vsvars32.bat" > NULL

gacutil.exe /if "$(TargetPath)"

ó el siguiente si estáis usando Visual Studio 2008:

CALL "%VS90COMNTOOLS%\vsvars32.bat" > NULL

gacutil.exe /if "$(TargetPath)"

Quedando finalmente algo cómo lo siguiente:

Una vez hecho esto vamos a proceder a preparar el módulo. Se va a componer de tres partes, las dos primeras son comunes a cualquier tipo de modulo que queramos crear, la tercera tendrá una parte también común y otra que variará dependiendo del módulo que queramos realizar, que será la parte de la interfaz:

1. Module: Inicializa el módulo en nuestro servidor, y lo añade a la consola del IIS para poder seleccionarlo.

2. Module Provider: Donde indicaremos el alcance de nuestro módulo, para todo el servidor, o local a ciertas partes, el tipo de módulo, etc.

3. Module Page: Esta es la parte más importante de nuestro módulo, aquí es donde programaremos la interface gráfica y las acciones del mismo.

Ya que está claro de qué partes se compondrá nuestro módulo, ahora procedemos a montarlo.

Primero crearemos el Module, para ello agregamos un nuevo elemento al proyecto, le damos un nombre, por ejemplo, i64Module, y añadimos el siguiente código, en caso de utilizar otros nombres deberéis cambiar las diferentes llamadas que haya en el código a otras partes del módulo por el nombre que hayáis elegido:

using System;

using Microsoft.Web.Management.Client;

using System.Windows.Forms;

using Microsoft.Web.Management.Server;

namespace proyecto_i64

{

internal class i64Module : Module

{

protected override void Initialize(IServiceProvider serviceProvider, Microsoft.Web.Management.Server.ModuleInfo moduleInfo)

{

base.Initialize(serviceProvider, moduleInfo);

IControlPanel controlPanel = (IControlPanel)GetService(typeof(IControlPanel));

ModulePageInfo modulePageInfo = new ModulePageInfo(this, typeof(i64Page), "Respuestas", "Muestra proc");

controlPanel.RegisterPage(modulePageInfo);

}

En Segundo lugar tenemos que montar el Module Provider, volvemos a agregar un nuevo elemento al proyecto, le damos un nombre, por ejemplo: i64Provider, y añadimos el código siguiente:

using System;

using Microsoft.Web.Management.Server;

namespace proyecto_i64

{

class i64Provider : ModuleProvider

{

//devuelve el tipo de módulo de servicios que está asociado con el proveedor de módulo

public override Type ServiceType

{

get { return null; }

}

//metodo que devuelve informacion sobre nuestro modulo

public override ModuleDefinition GetModuleDefinition(IManagementContext context)

{

return new ModuleDefinition(Name, typeof(i64Module).AssemblyQualifiedName);

}

//decide el alcance del modulo, en nuestro caso, TODO el servidor

public override bool SupportsScope(ManagementScope scope)

{

return true;

}

En tercer lugar tenemos que montar el Module Page, volvemos a agregar un Nuevo elemento al proyecto y le damos un nombre, por ejemplo: i64Page. Esta parte es la más compleja, así que vamos a ir por partes, en primer lugar debemos crear el esqueleto, por lo que agregaremos el siguiente código:

using System;

using System.Windows.Forms;

using Microsoft.Web.Administration;

using Microsoft.Web.Management.Client.Win32;

namespace proyecto_i64

{

internal class i64Page : ModulePage

{

Microsoft.Web.Administration.ServerManager manager = new ServerManager();

public i64Page()

{

InitializeComponent();

}

private void InitializeComponent()

{

}

Una vez agregado, vamos a estudiarlo. Nada más empezar tenemos la siguiente línea de código:

Microsoft.Web.Administration.ServerManager manager = new ServerManager();

Esta línea crea una nueva ServiceManager que podemos utilizar para recuperar las solicitudes de nuestro servidor, en caso de que lo necesitemos. Después ya podemos ver la función que inicializará nuestro módulo. Ahora queremos programar una interface gráfica para nuestro módulo. Para ellos vamos a aprovechar la característica Forms que nos brinda .NET, desde la que podemos agregar todo tipo de elementos gráficos pinchándolos con el botón del ratón y arrastrando desde una toolbar. Para poder utilizar Forms, debemos hacer un pequeño truco, tenemos que cambiar el tipo de clase actual:

internal class i64Page : ModulePage

por el siguiente:

internal class i64Page : Form

Ahora si hacemos doble clic en el explorador de soluciones sobre nuestra clase i64Page, se nos abrirá una ventana con un fondo blanco, este será el aspecto de nuestro módulo, si abrimos el cuadro de herramientas, veremos todos los posibles elementos que le podemos agregar, por ejemplo, podéis agregar un button y un campo label, cambiar fondos de la pantalla, tipos de letra,... Si queremos que alguno de estos elementos interactúe con nuestro módulo haremos doble clic sobre él una vez que lo hayamos agregado, de esta manera se nos añade el sólo al código de nuestra clase i64Page.

Una vez agregados los elementos volvemos a dejar el tipo de la clase como estaba antes, si no, nos dará fallo de compilación:

internal class i64Page : ModulePage

Ahora veremos que se nos han añadido varias partes nuevas a nuestro código. Primero veremos que nada más empezar la clase se nos han incluido la declaración del button y el label, y de los demás elementos que agregasemos antes. Después en la función InitializeComponent(), se nos ha añadido todo el apartado gráfico de los elementos que hemos agregado, esto lo hace internamente el Visual Studio, por lo que directamente procedemos a ignorarlo. Por otro lado vemos que se nos ha añadido una función nueva por cada elemento insertado en el que hicimos doble clic. En estas funciones es donde debemos programar lo que queremos que haga nuestro módulo, por ejemplo en la función button, podemos decirle que muestre un determinado texto en el label.

Ya tenemos nuestro módulo terminado, si lo guardamos y compilamos, el gacutil firmará el ensamblado y podremos acceder a él en la ruta: C:\Windows\assembly. Le buscamos en dicha carpeta y deberemos copiar el key que le ha sido asignado, para ello (pulsamos botón derecho sobre el, propiedades y lo copiamos:

Ahora debemos irnos al fichero Administration.config, en la ruta:

c:\windows\system32\inetsrv\config\Administration.config

Y modificaremos 2 líneas. Para abrirlo veréis que posiblemente no tengáis derechos de administrador, por lo que hay que subir los derechos del fichero o bien abrirlo desde el WordPad por ejemplo ejecutándolo como administrador:

Buscamos la línea <ModuleProviders> dentro del fichero y añadimos después la siguiente línea, sustituyendo la palabra KEY por el key que antes copiamos:


<add name="CurrentRequestsUI" type="CurrentRequestsUI.RequestModuleProvider, CurrentRequestsUI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=269f1cc1a4bf892b" /> <add name="proyecto_i64" type="proyecto_i64. i64Provider, proyecto_i64, Version=1.0.0.0, Culture=neutral, PublicKeyToken=KEY" />

Ahora buscamos la línea <modules> y añadimos la siguiente línea:

Si habéis dado otros nombres al proyecto y al provider deberéis modificarlos por los correspondientes.

Una vez hecho todo, reiniciamos el servidor, para ello abrimos una consola en modo administrador y escribimos: iisreset.

Con esto ya deberíamos tener el módulo funcionando y con un icono seleccionable en nuestro servidor:

Si lo abrimos podremos ver la interface de nuestro módulo. Para restar complejidad al post he decidido no comentar aspectos sobre la interfaz, que son comunes a cualquier otro desarrollo realizado en .NET por lo que para ello podréis acceder a numerosos manuales oficiales donde os explicarán en profundidad esta tarea.

Saludos! Y hasta el próximo post

Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (II de VI)

Juan Antonio — Sun, 06 Sep 2009 22:53:00 GMT

Buenas a todos, en el post de hoy vamos a continuar con la cadena de posts sobre Microsoft XNA, comenzando por donde lo dejamos el ultimo día, la instalación del producto.

Para instalar la plataforma completa deberemos tener dos ejecutables diferentes, el primero será el archivo que nos instalará el Visual Studio Express Edition, bien la versión 2005 ó bien la versión 2008 según la que nos hayamos descargado. El segundo será el instalador de XNA, donde se encuentran todas las librerías necesarias para la programación de videojuegos.

Hacemos doble clic en el primero de ellos, el Visual Studio, como veréis es un instalador normal, procederemos con la técnica del “siguiente, siguiente,…”, por lo que no nos vamos a entretener mas en explicarlo. Una vez instalado, instalaremos XNA desde su ejecutable de la misma manera.

Tras instalar ambos elementos, abrimos el Visual Studio:

Una vez abierto iremos a la pestaña “Archivo” y seleccionaremos “Nuevo proyecto”:

Deberíamos ver lo siguiente:

Ya tenemos todo preparado para empezar a programar nuestros videojuegos. Pero antes de tirarnos al rio, vamos a aprender jugando un poco. Como habréis visto en la imagen anterior, al instalarnos XNA, se nos ha instalado el código fuente de un videojuego que nos dan de ejemplo, al que han llamado “Platformer Starter Kit (3.1)”. Vamos a utilizar este código y generar el juego para practicar, para ello seleccionaremos el icono del muñeco que pone “Platformer Starter Kit (3.1)”, le daremos un nombre, una ubicación y aceptamos, deberíamos ver, el siguiente árbol de clases en el explorador de soluciones:

No os asustéis al verlo, aunque sea muy grande, es porque está el videojuego programado para las tres plataformas, es decir, es el mismo código, pero copiado tres veces para ejecutarse en Windows, en Xbox 360 y en Zune.

Si compilamos y ejecutamos el juego, pulsando F5, podremos jugar a nuestro primer juego hecho con XNA.

Tras haber jugado un poco con esta especie de “Indiana Jones” en 2D, vamos a pararnos un rato a estudiar el código. Cómo veréis, tenemos numerosas cosas, en primer lugar veremos 3 grandes bloques, uno con un icono de Windows, otro con un icono de Xbox 360 y otro con el icono de Zune, como es obvio y habréis intuido, es el mismo juego, pero programado para las tres plataformas diferentes. Si ahora nos centramos en el bloque del código de Windows, veremos numerosas clases diferentes, “enemy, animation, gem, player …”, pero ¿para qué queremos todas estas clases? Bien, cuando creemos un nuevo proyecto, se nos generará una única clase llamada “game”, donde contendrá todos los elementos necesarios para ejecutar el videojuego, pero por mantener un poco de orden y limpieza, y que cuando llevemos algunos cientos de líneas no nos comencemos a liar, está bien el utilizar una de las ventajas que nos ofrece C#, la orientación a objetos, y separar los elementos principales del juego en clases independientes, que iremos instanciando en la clase “game” según vayamos necesitando. Por ejemplo, podemos separar en clases independientes los movimientos que puede realizar el personaje principal del juego de los de otros personajes que salgan en el juego, sus texturas y variables, … Si no tenéis muy claro aún de que estamos hablando, cuando veamos algo de código volveremos sobre ello.

Por otro lado, además de las clases, veréis una sección en la que pone HighResolutionContent y otra que pone SharedContent, estas son las carpetas que contendrán las imágenes, fondos, músicas y demás elementos externos que utiliza el videojuego. Todos estos elementos externos como imágenes, sonidos, música de fondo… los almacenaremos en la carpeta “Content”, que se nos ha generado dentro de la carpeta raíz del proyecto, y luego podremos ir generando dentro de ella subcarpetas para organizar todo un poco.

Tras explicaros un poco a “groso modo” el contenido del videojuego de muestra, vamos a cerrarlo y a crear el proyecto de nuestro primer videojuego.

Al igual que antes vamos a la pestaña “Archivo” y seleccionamos “Nuevo proyecto”, se nos abrirán todas las plantillas que podemos seleccionar, de todos los elementos que salen a nosotros solo nos interesan tres de ellos:

· Windows Game (3.1)

· Xbox 360 Game (3.1)

· Zune Game (3.1)

Para comenzar vamos a generar un “Windows Game”. Bien, ahora le damos un nombre, una ubicación y aceptamos.

Si os fijáis en el explorador de soluciones, ya no tenemos todas las clases que teníamos en el videojuego anterior, como os dije solo tenemos ahora una clase llamada Game1, donde deberemos programar todo el juego. Por otro lado tenemos otra clase llamada Program, que ignoraremos, ya que simplemente es la encargada de llamar a la clase Game1 para ejecutar el juego.

Para finalizar por hoy, vamos a abrir el código de la clase Game1.cs y estudiarlo un poco, para ello, podemos hacer doble clic sobre ella, se os abrirá la clase con el siguiente código que vamos a analizar por partes:

En primer lugar veremos todas las librerías que utiliza, si os fijáis la mayoría llaman a la biblioteca de Xna:

using System;

using System.Collections.Generic;

using System.Linq;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Audio;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.GamerServices;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

using Microsoft.Xna.Framework.Media;

using Microsoft.Xna.Framework.Net;

using Microsoft.Xna.Framework.Storage;

Avanzando un poco llegamos a una serie de funciones, de las cuales nos centraremos únicamente en cuatro de ellas, ya que serán las únicas que debemos tocar a la hora de programar el juego.

La primera de las cuatro funciones que aparecen es la función Initialize, esta función se ejecuta únicamente cuando se inicia el videojuego, así que la aprovecharemos para inicializar variables, inicializar las texturas de los personajes e inicializar el tamaño de pantalla del videojuego:

protected override void Initialize()

{

// TODO: Add your initialization logic here

base.Initialize();

}

La siguiente función, LoadContent, la utilizaremos para cargar las imágenes (que almacenaremos en la carpeta “Content”) que representaran las texturas del juego y los sonidos y demás elementos externos que requiramos en el videojuego:

protected override void LoadContent()

{

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

spriteBatch = new SpriteBatch(GraphicsDevice);

// TODO: use this.Content to load your game content here

}

Las dos funciones anteriores, Initialize y LoadContent se ejecutarán únicamente al principio del juego. Ahora vamos a explicar las siguiente funciones que se ejecutaran de manera infinita hasta que el juego finalice, es decir, en un bucle cuya función de salida es cerrar el videojuego.

En la función Update deberemos programar las acciones que determinen las modificaciones en el juego, es decir, por ejemplo, si el personaje principal, se mueve hasta la mitad de la pantalla y hay una piedra, que no pueda avanzar más, o por poner otro ejemplo, si estamos programando un juego de coches, si el jugador pulsa la tecla flecha izquierda, haremos que el coche gire a la izquierda:

protected override void Update(GameTime gameTime)

{

// Allows the game to exit

if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)

this.Exit();

// TODO: Add your update logic here

base.Update(gameTime);

}

Finalmente nos encontraremos con la function Draw, que se ejecutará después de la función Update, y será la encargada de dibujar todos los elementos en pantalla, por tanto, si se ha producido un cambio en el juego en la función Update, cambiaremos los objetos de pantalla para reproducir ese cambio en la función draw. Por continuar el ejemplo, si tenemos el coche en el centro de la pantalla, y en la función Update detectamos que el jugador a pulsado la tecla izquierda, y hemos indicado al coche, que gire a la izquierda unos pixels, dibujaremos el coche en esta iteración del bucle general unos pixels mas a la izquierda, para visualizar la acción que ha ejercido el jugador sobre el teclado en la pantalla:

protected override void Draw(GameTime gameTime)

{

GraphicsDevice.Clear(Color.CornflowerBlue);

// TODO: Add your drawing code here

base.Draw(gameTime);

}

Con todo esto, tenéis para practicar durante los próximos días, hoy ya hemos visto un código terminado, es más sencillo de lo que parece a primera vista, y como habéis visto en el videojuego que estamos programando desde cero, las funciones para las que debemos generar el código se resumen en cuatro muy sencillas de entender y que tienen una finalidad muy delimitada, lo que las simplifica enormemente.

El próximo día rellenaremos estas cuatro funciones para generar nuestro primer juego, en él, añadiremos un muñeco que se mueva por la pantalla, un ejemplo sencillo y muy ilustrativo, por si queréis ir preparándolo, necesitaremos un fondo como el que habéis visto en el videojuego “Platformer Starter Kit (3.1)”, y dos imágenes de un muñeco mirando hacia ambos lados.

Un saludo y espero estéis disfrutando del manual!!

****************************************************************

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (I de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (II de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (III de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (IV de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (V de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (VI de VI)

****************************************************************

Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (I de VI)

Juan Antonio — Mon, 31 Aug 2009 08:38:00 GMT

Buenas a todos, tras una temporada de relax por vacaciones, vuelvo a Windows Técnico con un tema que atraerá a muchos usuarios de videojuegos que aún sabiendo algo de programación no han tenido la oportunidad de programarse sus propios videojuegos por la complicación que esto conllevaba. Esto gracias a Microsoft XNA ya es historia, ya que con esta plataforma, el diseño y la programación de videojuegos será una tarea bastante sencilla si poseemos algunos conocimientos de programación.

A lo largo de las próximas semanas vamos a introducirnos en la plataforma XNA de Microsoft, que nos permitirá programar nuestros propios videojuegos para Windows y XBOX 360, aprenderemos el contenido necesario que requiere un juego para ejecutarse, hablaremos de cómo conseguir efectos visuales atractivos, movimientos y de cómo conseguir que un jugador pueda interactuar con los contenidos del juego y finalmente tras aprender cómo funciona un videojuego internamente, programaremos nuestro primer juego.

En el post de hoy, vamos a empezar explicando el porqué de XNA, que es, cuanto lleva entre nosotros, que clase de videojuegos nos va a permitir crear y sobretodo que facilidades nos proporcionará para ello.

¿Qué es Microsoft XNA?

XNA es una plataforma de desarrollo de videojuegos que nos permitirá programar todo tipo de videojuegos sin limitaciones tanto en 2D, como en 3D, gracias a una rica biblioteca de clases.

XNA se instala sobre Visual Studio C# 2005/2008 Express Edition, la versión gratuita de Visual Studio para programar en C#, por lo que la programación de videojuegos bajo esta plataforma es totalmente gratuita.

¿Tiene algún coste la programación en XNA?, ¿Cómo lo podemos obtener?

Como os acabo de contar, la programación de videojuegos es totalmente gratuita, simplemente nos descargaremos Visual Studio C# 2005 Express Edition ó Visual Studio C# 2008 Express Edition desde el siguiente enlace:

http://www.microsoft.com/express/download/default.aspx#webInstall

Nos daremos de alta con nuestra cuenta de Hotmail como habitualmente, y nos enviarán una licencia de uso totalmente gratis.

Después, nos bajaremos la biblioteca de clases de XNA:

http://www.microsoft.com/downloads/details.aspx?FamilyID=80782277-d584-42d2-8024-893fcd9d3e82&displaylang=en

Y la instalaremos.

¿Qué versión de XNA nos tenemos que descargar?

En la actualidad XNA va por la versión 3.1, la cual es necesaria si queremos programar además de los juegos, los Xbox LIVE Indie Games, los muñecos o avatares que nos representan a nosotros en nuestra consola Xbox 360 e integrarlos en los juegos, ¿una auténtica pasada no?

¿En qué sistemas operativos podemos instalar Microsoft XNA?

XNA se puede instalar en todos los sistemas operativos de Microsoft a partir de Windows XP SP2. Yo lo tengo instalado sobre Windows 7 funcionando de maravilla :)

¿Cuándo comenzó Microsoft XNA?

XNA comenzó a mediados del 2006 con la versión beta, que se hizo definitiva a finales del mismo año.

En sus posteriores versiones se han ido añadiendo novedades como la integración con la versión 2008 de Visual Studio, la posibilidad de programar videojuegos para Zune, el reproductor multimedia de Microsoft, y se han aumentado el número de clases y resuelto algunos bugs..

¿En donde podremos ejecutar nuestros juegos?

Podremos programar videojuegos tanto para PC, como para XBOX 360, como para Zune.

¿Podrá alguien jugar con nuestros juegos?

Por supuesto, de hecho es uno de los aspectos más importantes con los que se ha pensado y diseñado XNA, “videojuegos de todos y para todos”, por ello han querido generar una plataforma sencilla y fácil de entender por el usuario medio.

En el siguiente link, encontrareis la comunidad que ha creado Microsoft para que todo el mundo pueda participar, intercambiar videojuegos, que sean probados por revisores, podréis conseguir manuales, códigos fuentes, los programas necesarios para el desarrollo de videojuegos y muchas cosas más:

http://creators.xna.com/es-ES/

¿Es diferente programar un videojuego de Windows a uno de XBOX 360?

No, la programación de los videojuegos es la misma, simplemente para interactuar con el ordenador, tendremos que indicarle a nuestro programa que capture las teclas o los movimientos del ratón y en el caso de la Xbox 360, que capture las pulsaciones de los botones del mando, como veréis en próximos post esta tarea es muy sencilla.

¿En qué lenguaje de programación se programan los videojuegos de XNA?

Los videojuegos se programan en C#. Si no estáis familiarizados con el lenguaje os diré que es hoy por hoy el presente y el futuro de Microsoft y de muchísimas otras empresas tras convertirse en un estándar. Es un lenguaje derivado de C/C++ orientado a objetos y que se encuentra totalmente integrado con la plataforma .NET. Si buscáis por internet encontraréis infinidad de manuales y como veréis si tenéis conocimientos de programación en C/C++ o Java, adaptaros a C# serán escasos cinco minutos.

¿Qué clase de videojuegos podremos crear?

Con XNA podremos programar todo tipo de juegos en 2D y recordar la mítica época del mundo de las consolas en la década de los 80-90 o bien videojuegos modernos en 3D, para estos últimos lógicamente necesitareis ayudaros de un programa de diseño 3D cómo 3ds Max, y luego importar los elementos que generéis a XNA. Si no queréis quedaros solo en la programación de videojuegos en 2D y queréis dar el salto a 3D pero no queréis aprender a diseñar figuras en 3D, siempre podéis descargaros algunas por internet, con cualquier buscador encontrareis cientos de ellas, yo hace poco me descargué unos cuantos coches modernos en 3D para practicar un poco.

Así que ya solo me queda decir, que os animéis a seguir esta cadena de posts que hoy comenzamos y programéis vuestros propios videojuegos, que como veréis es una tarea más sencilla de lo que parece y que os gustará y enganchará. Y si queréis intentad compartirlos con los demás usuarios, quien sabe, quizás entre ellos salga uno de los programadores del próximo Halo… J

De momento para abriros el apetito, os dejo un video de un juego que he programado en una tarde (para que veáis la facilidad que nos proporciona XNA y el ahorro de tiempo en comparación con otras plataformas) versionando un poco uno de los juegos que más me gustaron de mi infancia:

Os dejo también algunas imágenes y un video de varios videojuegos que han sido programados en XNA:

Cómo veis mi videojuego es algo más humilde a los de las capturas que os acabo de mostrar, pero como siempre en la vida, empezaremos la casa por los cimientos para luego escalar hasta el tejado.

En el próximo post, hablaremos de cómo instalar todos los elementos que nos hemos descargado, cómo crear el proyecto de nuestro primer videojuego y hablaremos finalmente de las partes de las que se compone un juego.

Saludos!

****************************************************************

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (I de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (II de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (III de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (IV de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (V de VI)

- Diseñar juegos para Windows y XBOX 360 con Microsoft XNA (VI de VI)

****************************************************************