Windows Técnico : .Net, C#

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:56 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!

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 II)

Juan Antonio — Mon, 03 May 2010 20:13:48 GMT

Buenas a todos, continuando con la cadena de posts sobre Desarrollo Basado en Modelos y su aplicación con DSL hoy vamos a hablar sobre el ejemplo que utilizaremos para explicar el desarrollo de aplicaciones con esta tecnología.

De las alternativas mostradas en el post anterior abordaremos la basada en Domain-Specific Language. Con ella se implementará un Dsl que automatice la escritura de documentos Xml. Para ello en primer lugar se identifican las partes del problema de la generación de documentos Xml que pueden ser modeladas.

Un documento Xml está formado por una iniciación común y por una serie de etiquetas en forma de árbol. Por ejemplo:

<?xml version="1.0" encoding="ISO-8859-1" ?>

<ficha>

Juan Antonio

</nombre>

Calles

</apellido>

c/elblogdecalles, 4, 1ºK

</direccion>

</ficha>

Estas etiquetas podrían ser representadas en un modelo, a través de nodos. Será necesario tener en cuenta que un nodo puede no tener hijos, en este caso se tratará de un nodo hoja, es decir, de una etiqueta que no contiene más etiquetas hijas. Podremos tener también nodos con hijos, entonces podrá tratarse del nodo raíz, que solo habrá uno, o de un nodo intermedio.

Además hay que tener en cuenta que un nodo puede contener ninguno o varios atributos.

Por tanto para representar un documento Xml en un modelo en formato de árbol habrá que desarrollar un modelo que soporte la inclusión de:

Iniciación común.
Nodos:
- Hoja
- Intermedio
- Raíz
Atributos.
- cero o más

La iniciación común puede sacarse del diseño del modelo, y será codificada directamente en la parte de escritura del código.

Se generarán clases independientes para los nodos y los atributos. Y se tomarán las características: hoja, intermedio y raíz del Nodo, como atributos modificables por el desarrollador durante el diseño del modelo.

Finalmente la posibilidad de que haya cero o más atributos en un nodo se representará con cardinalidades en las uniones de la clase nodo y atributo.

Tras haber planteado el problema y representado el modelo se generará el DSL. Una vez desarrollado, se utilizará para diseñar un documento Xml de manera gráfica, y se codificará el código necesario para ser convertido a la sintaxis de Xml. Estas partes se verán en el próximo punto, Implementación.

Implementación

Generación del Proyecto

Para el desarrollo de nuestro DSL con Dsl Tools necesitaremos tener instalado Visual Studio 2005/2008 con un SDK actualizado. Para este ejemplo, hemos utilizado Visual Studio 2008, con el SDK 1.0.

En primer lugar se debe abrir Visual Studio, e ir al menú de creación de nuevo proyecto:

Después se generará el proyecto, para ello accedemos a Nuevo proyecto -> Otros tipos de proyectos -> Extensibilidad y seleccionamos “Domain-Specific Language Designer”. Le damos un nombre al proyecto y aceptamos:

Ahora elegiremos Minimal Language, para no tener que empezar a diseñar nuestro DSL desde cero y tengamos ya un pequeño esqueleto generado:

Ahora nos inventamos un nombre para la extensión que tendrá el fichero donde se guardará nuestro modelo:

Indicamos un nombre de compañía:

Y le indicamos que cree una clave ya que no vamos a utilizar una existente:

Tras pulsar Finalizar veremos el esqueleto de nuestro DSL:

Esto es todo por hoy, en el próximo post diseñaremos el resto del DSL y contaremos como se diseña la interface gráfica del mismo.

saludos!

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 I)

Juan Antonio — Tue, 27 Apr 2010 14:20:00 GMT

El desarrollo de software es uno de los procesos que más ha evolucionado en los últimos 30 años. En la década de los 80 se introdujo la orientación a objetos, base de la mayor parte de la tecnología que se posee en la actualidad. En los años 90 las numerosas variantes de notación del análisis y diseño orientado a objetos que comenzaron en la década anterior derivaron hacia la utilización de una notación común, Unified Modeling Language, UML.

En los últimos años, UML ha sido un lenguaje bastante criticado, que ha derivado en dos corrientes, sus seguidores y sus no seguidores. A día de hoy han surgido nuevas alternativas de desarrollo de software como Agile y Extreme Programming, que dan menos importancia al modelo inicial y producen un acercamiento más libre a los métodos de diseño y administración de los proyectos.

Hoy UML ha dado un salto muy importante proponiendo una nueva alternativa en el diseño de software, que consiste en la generación de código de manera automática a través de un modelo. Este sueño idílico de todo desarrollador es conocido en la actualidad como el futuro de los lenguajes de cuarta generación.

Para conseguir esto se deben hacer mejoras en el propio UML, el cual no es capaz de expresar aún toda la lógica de un problema, y por tanto incapaz de representar completamente como debería de ser un software, como por ejemplo en el tema de las interfaces.

Los dos mayores impulsores de esta tecnología son Microsoft y la OMG. Esta última ha sido impulsora de esta tecnología con su popular Model Driven Architecture, MDA. Microsoft por su parte está siendo impulsora de una alternativa a la que ha denominado Software Factory y que está teniendo un gran éxito en los últimos años. Además, la creciente aparición de Lenguajes de Dominio, también conocidos como DSL, representan nuevos caminos en la construcción de software. Especialmente en los casos en que la orientación a objetos y el diseño dirigido por modelos estén integrados.

Las herramientas de cuarta generación de las que se hablaba antes no pueden ser consideradas como un lenguaje como tal ya que el desarrollo completo de un proyecto solo puede ser encarado por una arquitectura de trabajo que debe abarcar el ciclo de desarrollo del software casi en su totalidad.

Finalmente, se pueden destacan en esta nueva alternativa de desarrollo la siguientes tendencias:

MDA, Model Driven Architecture de la OMG.
SF, Software Factories de Microsoft.
Oslo.
SPL, Software Product Lines, SPL

Dsl Tools

En la cadena de posts que hoy doy comienzo veremos una implementación de la tendencia Domain Specific Languages que está imponiendo Microsoft con su proyecto OSLO.

Según la definición propia de Microsoft, DSL (Domain Specific Language), está diseñado para ser útil para una tarea específica en un dominio de problema fijo. Con un lenguaje grafico o textual, puede definir un nuevo lenguaje de modelado y ponerlo en marcha de manera muy sencilla. Al crear un lenguaje específico del dominio propio y el diseño del modelo personalizado, se puede especificar exactamente qué conceptos se necesitan en la herramienta a desarrollar.

Cuando en el desarrollo se utiliza un DSL, se comienza identificando las partes de las aplicaciones que son susceptibles de ser modeladas usando un DSL. Después, se define y se implementa este lenguaje. Los usuarios del lenguaje crean modelos que usan para generar el código y adaptan el código generado en sus aplicaciones finales.

El Domain-Specific Language Tools permite crear un lenguaje específico del dominio que tiene su propio diseño gráfico y su notación de diagrama propio, para a continuación, utilizar el lenguaje para generar el código fuente adecuadamente para cada proyecto.

El Domain-Specific Development es el proceso de identificar las partes de las aplicaciones que se pueden modelar mediante el uso de un lenguaje específico del dominio y, a continuación la construcción del lenguaje y su despliegue a los desarrolladores de aplicaciones. Los desarrolladores utilizan el lenguaje específico del dominio para construir modelos que son específicos para sus aplicaciones, utilizar los modelos para generar el código fuente, y luego usar el código fuente para desarrollar las aplicaciones.

A continuación os dejo un link muy importante en el que Microsoft resume en que consiste su proyecto faraónico OSLO, en el veréis que habla de numerosas tecnologías de las que ya os he ido hablando últimamente como Azure:

http://msdn.microsoft.com/es-es/library/dd367845.aspx

En el próximo post continuaremos hablando sobre Domain-Specific Language Tools de Microsoft y comenzaremos la implementación de un proyecto software con Visual Studio donde espero poder aclararos un poco las profundas dudas que hay en este tema tan novedoso que es el desarrollo dirigido por modelos.

saludos!

Programando para Windows Phone 7 Series

Manuel Fernandez — Wed, 24 Mar 2010 16:30:40 GMT

Esta entrada en el blog es de carácter informativo y va destinada a aquellos desarrolladores que haciendo uso del entorno .NET desean programar aplicaciones para telefonía móvil basada en “Windows 7 Phone”.

(http://www.windowsphone7series.com/).

Para ellos Microsoft ha publicado el libro ‘Programming Windows Phone 7 Series’ descargable desde http://download.microsoft.com/download/7/C/8/7C820C6F-C205-4ECF-B9F3-1505DD13F9BF/ProgWinPhonePreview.pdf en el cual se tratan diversos aspectos de la programación sobre este tipo de dispositivos, proporcionando a su vez código fuente a modo de ejemplo.

Los capítulos contenidos en el libro son los siguientes:

· Capitulo 1: Phone Hardware + Your Software

· Capitulo 2: Hello, Windows Phone

· Capitulo 3: Code and XAML

· Capitulo 4: Presentation and Layout

· Capitulo 5: Principles of Movement

· Capitulo 6: Textures and Sprites

El manual plantea todos los ejemplos y desarrollos haciendo uso del lenguaje C# .NET. Por ello es necesario disponer de conocimientos de programación en este lenguaje. Para aquellos que ya tengáis dichos conocimientos y deseéis programar sobre ‘Windows 7 Phone’, este libro es ideal para tomarlo como guía de referencia.

Un saludo y espero que esta información os sea de utilidad ¡¡¡¡¡

Modificación e inyección de código en ensamblados .NET

Manuel Fernandez — Tue, 09 Feb 2010 19:02:52 GMT

Durante éste articulo se verá cómo es posible modificar los ensamblados en .NET, de modo que podamos inyectar nuestro propio código .NET o código no manejado en éstas aplicaciones, pudiendo dotarlas de nuevas características como plugins sin que la aplicación original disponga de soporte para ello.

· Reflector

· Reflexil

Para realizar esto se hará uso de un decompilador de .NET (Reflector), un plugin con el que inyectar código IL (Reflexil) y un mínimo de conocimientos del lenguaje .NET y IL.

Antes de comenzar, debemos instalar el plugin ‘Reflexil’ para ‘Reflector’. Para agregarlo, basta con ir a ‘View -> Add-ins -> Add’ y cargar la librería ‘reflexil.dll’ . Una vez cargado, es posible acceder a su menú haciendo clic en ‘Tools -> Reflexil’.

Cargando plugin Reflexil

Ahora, crearemos una pequeña librería en .NET que será la que la aplicación cargará, consiguiendo así la ejecución de código y accesibilidad a sus componentes internos a través de reflexión.

La Liberia será muy sencilla, únicamente cargará un formulario con una imagen y mostrará un mensaje.

Código que cargaremos en la aplicación como DLL.

Una vez tenemos nuestra librería, es necesaria la decompilación de la aplicación sobre la cual queremos realizar la inyección de código, basta con arrastrar el ejecutable sobre el panel de ‘Reflector’, y se nos mostrará un árbol con todas sus métodos, propiedades, etc.

Para saber donde realizar la inclusión de nuestro código se debe localizar el punto de entrada de la aplicación, o el método en el que se desea que se ejecute el código. En mi caso lo realizaré sobre la entrada a la aplicación, en Main(String[]) .

Una vez llegamos a éste punto, es hora de usar ‘Reflexil’ para la inclusión de código IL. Unicamente deberemos inyectar las instrucciones necesarias para que realice la carga de forma dinámica de la librería que hemos creado anteriormente.

No os asustéis, únicamente son cinco instrucciones, y una vez la aplicación esté parcheada no será necesaria volver a modificarla. Basta con hacer clic derecho sobre el panel de ‘Instructions’ del plugin y clic sobre ‘Create new’ para agregar las siguientes instrucciones:

· LDSTR ‘c:\ruta\libreria.dll’

· CALL System.Reflection.Assembly::LoadFile(System.String)

· LDSTR ‘namespace.class’

· CALLVIRT System.Reflection.Assembly::CreateInstance(System.String)

· POP

LDSTR ‘c:\ruta\libreria.dll’

CALL System.Reflection.Assembly::LoadFile(System.String)

LDSTR ‘namespace.class’

CALLVIRT System.Reflection.Assembly::CreateInstance(System.String)

POP

Cuando se busque el método CreateInstance() o LoadFile() en las instrucciones CALL y CALLVIRT, se encontrarán dentro del nodo ‘mscorlib -> CommonLanguajeRuntimeLibrary -> System.Reflection -> Assembly’.

Una vez finalizado, el método modificado debería quedar de forma similar a la siguiente captura de pantalla (En azul está el código inyectado que realiza la carga de la librería):

Una vez finalizado podemos guardar el ensamblado modificado haciendo clic en el nodo del ensamblado en Reflector, y a continuación en ‘Save As’.

Guardando el ensamblado modificado

Si todo se ha realizado correctamente, al ejecutar la aplicación se cargará y ejecutará nuestra librería, consiguiendo así nuestro objetivo, como se puede ver en la siguiente captura de pantalla, donde junto con la ejecución de la aplicación también se ha ejecutado el formulario que desarrollamos en la librería.

También aprovecho para hacer uso de ProcessExplorer, mediante el cual se puede ver como la aplicación tiene cargada en memoria la librería ‘dll.dll’.

Éste ha sido un sencillo ejemplo de los pasos necesarios para la posibilidad de ejecución de código por una aplicación. Esto, junto con conocimientos de reflexión en .NET abre un gran número de posibilidades, donde se puede obtener un gran control sobre la aplicación, ofreciendo la posibilidad de crear o agregar nuevas características a las mismas.

¡Hasta otra!

Obtener IP publica desde consola

Manuel Fernandez — Thu, 10 Dec 2009 10:13:48 GMT

Para aquellos amantes de la consola de comandos, nuestro compañero Francisco Oca (http://el-blog-de-thor.blogspot.com) ha realizado una pequeña aplicación portable en C#, muy útil para obtener la dirección IP pública de la máquina.

El funcionamiento es muy simple, la ejecución de la aplicación muestra por consola la dirección IP, y si se le aplica el parámetro –c (‘getip –c’) copiará la dirección IP en el portapapeles.

La aplicación y el código fuente puede ser descargado desde el adjunto al final del documento.

Adjunto con código fuente y binario: GetIP.rar

Matar procesos desde código C# en .NET

Juan Antonio — Wed, 02 Dec 2009 09:37:33 GMT

A menudo, en nuestros desarrollos nos encontramos con la necesidad de querer parar algún tipo de proceso, normalmente porque son procesos largos y que ya nos han proporcionado la información que creíamos necesaria, para ello no necesitamos ir al TaskManager y matar el proceso cada vez que lo ejecutemos, desde el propio código C# podremos crearnos un botón y hacer que cuando le pulsemos mate todos los procesos que haya con un determinado nombre.

En el siguiente ejemplo os muestro como mataríamos todos los procesos del programa nslooup:

private void button1_Click(object sender, EventArgs e)

{

          foreach (Process proceso in Process.GetProcesses())

          {

                    if (proceso.ProcessName == “nslookup")

                    {

                              proceso.Kill();

                    }

          }

}

El código como veis es muy sencillo. Se trata de recorrer con un foreach todos los procesos que existen en la máquina, que obtendremos con la función “GetProcesses()”, y verificar que si el proceso obtenido se llama igual que el que queremos matar, llamamos a la función Kill() para matarlo.

En próximos post me gustaría seguir contando algunos pequeños trucos de .NET para facilitaros las tareas de desarrollo. Hasta el próximo post.

Saludos!

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

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

Juan Antonio — Fri, 30 Oct 2009 12:24:00 GMT

En el post de hoy vamos a continuar con la cadena de post en los que voy a explicaros los aspectos básicos sobre la programación de módulos para IIS7, que comenzamos el pasado día explicando que era IIS7 y comentando el lenguaje y el entorno de programación necesarios para el desarrollo:

http://www.windowstecnico.com/archive/2009/10/27/creaci-243-n-e-instalaci-243-n-de-m-243-dulos-para-internet-information-services-7-parte-i.aspx

Tras conocer un poco mas sobre el entorno, el siguiente paso será plantearnos: ¿Qué queremos hacer con un módulo en el IIS?. Para aclararos un poco mas esta pregunta os voy a describir los dos tipos de módulos que podemos programar en IIS7:

Módulos de IIS7

En IIS7 podremos instalar 2 tipos de módulos programados por nosotros, en primer lugar podremos crear módulos gráficos, que cuentan con una interfaz gráfica para realizar configuraciones en el IIS y en segundo lugar podremos programar módulos manejadores, que crean un manejador que se encuentra en todo momento escuchando todas las peticiones que llegan al servidor y cuando interceptan una nos permiten acceder a dicha petición y modificarla.

Creación e instalación de un módulo filtrador de peticiones para IIS7

Hoy os voy ha enseñar a programar el 2º de los módulos que antes comentamos, el módulo manejador, y crearemos el ejemplo mas sencillo de módulo, que simplemente interceptará una petición web, y le devolverá al cliente que la realizó la página solicitada pero con una cadena de texto al final.

Instalaciones necesarias:

Para la implementación necesitaremos los siguientes elementos:

1. Microsoft Server 2008, Microsoft Server 2008 R2, Windows Vista o Windows 7

2. Visual Studio 2005-2008

3. IIS 7

4. Asistente para creación de módulos: IIS7 Managed Module Starter Kit que ha producido el IISTeam, y que proporcionará el esqueleto del módulo para el IIS, se puede descargar desde:

http://www.iis.net/downloads/default.aspx?tabid=34&i=1302&g=6

Construcción del módulo:

Tras haber instalado el IIS7 Managed Module Starter Kit, cuando se crea un nuevo proyecto se puede ver como se ha añadido una nueva opción:

La seleccionamos, le damos un nombre, una ubicación y aceptamos. Inmediatamente después se nos abrirá una ventana donde nos resumen el contenido del asistente. Hacemos doble clic en el explorador de soluciones en el fichero MyModule.cs, que modificaremos dependiendo de las necesidades que tengamos en nuestro módulo. Se nos abrirá la ventana con el código del fichero, si expandimos las partes de código minimizadas, nos aparecerá lo siguiente:

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

namespace MyIIS7Modules

{

/// <summary>

/// The module class.

/// </summary>

public class MyModule : IHttpModule

{

#region IHttpModule Members

/// <summary>

/// Initializes the module, and registers for application events.

/// </summary>

/// <param name="application">

/// The System.Web.HttpApplication instance exposing application events.

/// </param>

public void Init(HttpApplication application)

{

// register for the PreRequestHandlerExecute event:

application.PreRequestHandlerExecute += new EventHandler(OnPreRequestHandlerExecute);

// TODO: add additional application event handlers here

}

/// <summary>

/// Disposes of the resources (other than memory) used by the module.

/// </summary>

public void Dispose()

{

}

#endregion

#region Module Event Handlers

public void OnPreRequestHandlerExecute(Object source, EventArgs e)

{

HttpApplication app = (HttpApplication)source;

HttpContext context = app.Context;

// TODO: implement module functionality here

}

#endregion

}

}

En este fichero debemos hacer 3 modificaciones:

1. Vaciamos todo el contenido de la función “Init”, y añadimos la siguiente línea que nos añadirá el evento manejador:

application.EndRequest += new EventHandler(application_EndRequest);

2. Eliminamos la siguiente función, que no necesitamos para nuestro módulo:

public void OnPreRequestHandlerExecute(Object source, EventArgs e)

{

HttpApplication app = (HttpApplication)source;

HttpContext context = app.Context;

// TODO: implement module functionality here

}

3. Añadimos la siguiente función. En la parte comentada que pone “AÑADIMOS NUESTRO CÓDIGO” es donde deberemos programar las acciones que realizará nuestro módulo, por ejemplo, añadir una línea nueva a todas las peticiones HTML que le llegan al servidor, filtrar su contenido, borrado de comentarios… Para este ejemplo, vamos a añadir una nueva línea de texto, que salga en todas las páginas web que devuelva nuestro servidor a los usuarios. Para ello simplemente llamamos al objeto context y le indicamos que en la respuesta añadiremos un bloque de texto:

void application_EndRequest(object sender, EventArgs e)

{

HttpApplication application = (HttpApplication)sender;

HttpContext context = application.Context;

//AÑADIMOS NUESTRO CÓDIGO

context.Response.Write(“Página modificada por www.windowstecnico.com”);

}

Una vez construido nuestro módulo debemos hacer 2 cosas:

1.) Tenemos que firmar nuestra librería .dll que hemos generado, para ello 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 :

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

2.) 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 se está usando Visual Studio 2008:

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

gacutil.exe /if "$(TargetPath)"

Quedando finalmente lo siguiente:

Configuración del IIS:

1. Tras ejecutarse los scripts ya tendremos nuestra .dll firmada en la carpeta C:\Windows\assembly y lista para agregarla como modulo (en caso de tener la .dll aparte, bien porque la hemos generado desde otro PC o porque estamos probando una que no hemos generado nosotros, nos bastará con copiar la .dll a esta misma carpeta, seguramente tengamos que aumentar las permisos de esta carpeta antes). Tras esto nos vamos al Administrador de Internet Information Services y hacemos doble clic en el icono “módulos”:

Vamos a la opción “agregar modulo administrado”:

En tipo, en el desplegable, seleccionamos nuestro módulo, y le damos un nombre cualquiera:

Una vez hecho esto, si abrimos un sitio web alojado en el IIS, debería estar funcionando nuestro módulo y mostrarnos en las páginas web la línea de texto que le indicamos:

Espero que os haya gustado el post y que os animéis a programar vuestros propios módulos, y recordad que lo mas importante es tener una buena idea y pensar que todo es programable, solo hacen falta las fuentes de información adecuadas :), el próximo día os hablaré sobre la programación de módulos con interfaz gráfica.

saludos!!

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

Juan Antonio — Tue, 27 Oct 2009 08:07:28 GMT

En el post de hoy vamos a comenzar una cadena de posts sobre IIS7, en concreto me gustaría hablaros sobre donde se prolongan sus límites mediante programación.

Este será el primero de tres post, en los que comentaré desde el principio hasta el final como implementar un nuevo módulo para IIS7 desde 0, que haga lo que vosotros queráis, desde captar una simple petición web que haga algún usuario al servidor, y modificarla a vuestro antojo, a sustituírsela por otro documento, añadirle scripts, lo que vosotros queráis, la imaginación pondrá el límite en esta tarea.

En este, que será el primer post, os voy a introducir en la materia y daros un poco de información sobre el tema empezando por el principio de los tiempos.

¿Que es IIS7?

IIS7 es el servidor que llevan incorporadas las últimas versiones de los sistemas operativos Windows, en concreto IIS 7.0 en las versiones de Windows Vista y Microsoft Server 2008 e IIS 7.5 en su nueva versión para Windows 7 y Microsoft Server 2008 R2. Para los expertos en el tema sabréis que IIS7 se ha visto mejorado con respecto a IIS6 en numerosos aspectos, entre los que destaca la seguridad y sobre todo su aspecto y simplicidad, y es en este último en el que Microsoft puede estar bien orgullosa, porque navegar por el menú gráfico del IIS7 es un verdadero placer:

IIS7 también destaca por su sencillez de configuración, en gran parte conseguido por su interface.

Además, IIS7 ha sido diseñado pensando en los desarrolladores, facilitándoles Starters Kits para la implementación de extensiones para añadirles más características. Para estos últimos también posee un sistema de diagnóstico en tiempo de ejecución, muy útil a la hora de depurar, que ofrece información sobre que peticiones están ejecutándose actualmente, cuánto tiempo llevan ejecutándose, que URLs están siendo invocadas, que cliente las invoca, y cuál es su estado actual. Un verdadero gustazo.

Ahora que ya sabéis un poco más sobre IIS7, a instalarlo!, tenéis un sencillo manual sobre su instalación en el siguiente link:

http://learn.iis.net/page.aspx/28/installing-iis-70-on-windows-vista/

¿En qué lenguaje programaremos los módulos para IIS7?

Una vez instalado IIS7, y nos hayamos familiarizado con el entorno, comenzaremos a programar nuestro primer módulo. Los módulos para IIS7 los programaremos en C#, en .NET por supuesto :), así que ir preparando el Visual Studio (2005 o 2008), que el próximo día daremos caña al compilador.

En el próximo post, os comentaré como programar vuestro primer módulo, en él, os enseñaré a crear una extensión para el servidor que capture todas las peticiones web que realicen los usuarios al servidor y a modificarles las páginas solicitadas, añadiéndoles una línea de texto al final de la página antes de devolvérsela al usuario. Un ejemplo muy sencillo, pero con el que veréis claramente, que se puede hacer casi cualquier cosa en el servidor desde un simple módulo del IIS.

Saludos!

Diseña tus propios videojuegos para Windows, Zune y XBOX 360 con Microsoft XNA (Parte VI)

Juan Antonio — Mon, 28 Sep 2009 13:04:26 GMT

Buenas a todos, la pasada semana finalizamos la cadena de posts sobre programación de videojuegos en XNA explicando como se producían las colisiones entre los diferentes objetos del juego. Hoy vamos a pasar a resumir todos los contenidos que hemos visto, os enseñaré a poner música de fondo en los juegos para darles un toque mas profesional y finalmente os voy a enseñar algunos ejemplos de videojuegos, algunos programados por mi, para daros ideas de videojuegos que podéis programar.

Añadir una cancion como fondo de un videojuego

Una de las mejores opciones que nos proporciona XNA es la de poder añadir una canción en formato mp3 para que suene mientras se reproduce el juego, para ello en primer lugar elegiremos la canción que nos interese, y la almacenaremos en la carpeta “Content” del videojuego, al igual que las imágenes que hemos utilizado en anteriores post. Una vez agregada la cargaremos en el juego de la misma manera que cargamos una imagen, primero nos crearemos una variable tipo song:

song musica;

Y después iremos a la función LoadContent() y la agregaremos de la siguiente manera, siendo canción nuestra cancion.mp3 (recordar que siempre ponemos el nombre sin la extensión):

musica = Content.Load<Song>(“cancion”);

Para reproducir la canción nos bastara con poner inmediatamente después de la linea anterior, lo siguiente:

MediaPlayer.Play(musica);

Como veis es muy sencillo.

¿Qué hemos visto sobre programación de videojuegos en 2D?

En primer lugar hablamos sobre XNA, que era, para que servía, que podíamos hacer con el, que necesitábamos para instalarnoslo y vimos algunos ejemplos, entre ellos un videojuego de sonic que programé para enseñaroslo:

http://www.windowstecnico.com/archive/2009/08/31/dise-241-a-tus-propios-videojuegos-para-windows-zune-y-xbox-360-con-microsoft-xna-parte-i.aspx

En segundo lugar estudiamos como crear un proyecto en XNA, vimos para que servían cada una de las funciones que nos proporcionaba la plataforma y cargamos el videojuego que trae XNA de ejemplo para probarlo:

http://www.windowstecnico.com/archive/2009/09/07/dise-241-a-tus-propios-videojuegos-para-windows-zune-y-xbox-360-con-microsoft-xna-parte-ii.aspx

En tercer lugar, os enseñé a cargar un objeto y un fondo en el proyecto de nuestro videojuego, y aprendimos a mover un objeto por la pantalla, capturando las teclas de nuestro teclado:

http://www.windowstecnico.com/archive/2009/09/14/dise-241-a-tus-propios-videojuegos-para-windows-zune-y-xbox-360-con-microsoft-xna-parte-iii.aspx

En cuarto lugar estudiamos como simular los pasos que daría un muñeco cuando va andando:

http://www.windowstecnico.com/archive/2009/09/17/dise-241-a-tus-propios-videojuegos-para-windows-zune-y-xbox-360-con-microsoft-xna-parte-iv.aspx

En quinto lugar aprendimos a generar colisiones entre los diferentes objetos del videojuego:

http://www.windowstecnico.com/archive/2009/09/22/dise-241-a-tus-propios-videojuegos-para-windows-zune-y-xbox-360-con-microsoft-xna-parte-v.aspx

Hoy finalmente hemos aprendido a añadir música de fondo al videojuego.

Con todo esto, tenéis los conocimientos necesarios para programar casi cualquier videojuego en 2D, simplemente os queda practicar mucho, y si queréis dar mas realismo a vuestros videojuegos acompañar estas prácticas con el estudio de algunas funciones matemáticas y físicas que os permitan el conseguir movimientos de lanzamientos, impactos y golpes mas realistas entres los diferentes objetos del juego, cosas que se escapan del contenido de este manual con el que simplemente os quería introducir en la programación de videojuegos y que espero os haya sido muy útil y os sirva de plinto para seguir aprendiendo mucho mas sobre esta tecnología.

Os dejo también algunos videos de videojuegos en 2D que han sido programados en XNA:

Para finalizar os voy a mostrar el último videojuego que programé, para mostrarle una idea a uno de los lectores de nuestro blog sobre como programar un tetris. Está programado con una única pieza (la L), y sin rotaciones, para ahorrar tiempo, pero podéis ver la potencia de la plataforma que en poco mas de media hora y con las dos siguientes imágenes como base me permitieron programar el siguiente juego:

Diseña tus propios videojuegos para Windows, Zune y XBOX 360 con Microsoft XNA (Parte V)

Juan Antonio — Tue, 22 Sep 2009 14:32:46 GMT

Buenas a todos, estamos en semana de SIMO!, supongo que muchos de vosotros estaréis disfrutando ahora mismo de él, mientras que otros estaréis esperando post y comentarios en blogs de informática que leer para enteraros de todo lo que pasa en el pabellón 7 del IFEMA, pero mientras tanto, como durante todo el mes de Septiembre, os traigo el V y último post del manual sobre programación en 2D. Voy a extender el manual un post más, que publicaré en unos días, para mostraros algunos videos de videojuegos en 2D que he programado y enseñaros a programar otro juego en 2D, pero diferente, para que veáis otras posibilidades de juegos en 2D, hay cientos de ellas. Mientras tanto hoy vamos a continuar por donde lo dejamos el último día, y vamos a aprender a generar colisiones entre dos objetos.

Seguiremos aprovechando el videojuego Alien, y vamos a añadirle una piedra en el suelo a nuestro juego, para que cuando nuestro muñeco choque con ella no pueda avanzar, y no le quede más remedio que superarla de un salto.

Para comenzar debemos conseguir una imagen de una piedra, la almacenaremos en la carpeta Content y la cargaremos en el juego como ya sabemos. Ahora debemos repasar como crear un objeto en el juego, para ello volveremos a la parte III del manual, y crearemos un nuevo vector, una nueva textura, a la que le asignaremos la imagen que antes cargamos, y en la función Draw() la dibujaremos en pantalla, de tal manera que tengamos al arrancar el videojuego una imagen como la siguiente:

Bien, una vez que tengamos generada nuestra piedra, debemos realizar la colisión. Para ello vamos a rodear a nuestro alienígena y a nuestra piedra de una “esfera imaginaria” que simule el cuerpo del alienígena y la superficie de la piedra, ya que recordemos, que nuestros objetos en el videojuego ocuparán un único pixel (un vector2D). Una vez que hayamos generado las esferas hay una función en XNA que nos dirá si han chocado entre sí o no.

En primer lugar debemos crear 2 vectores que simularan el centro del cuerpo del alienígena y el centro de la superficie de la piedra:

Vector2 centro_piedra;

Vector2 centro_alien;

Después crearemos las 2 esferas que rodearán al alienígena y a la piedra:

BoundingSphere esfera_alien;

BoundingSphere esfera_piedra;

Ahora vamos a crearnos una función auxiliar que comprobará si los 2 objetos, el alienígena y la piedra han colisionado:

public bool colision()

{

centro_piedra = new Vector2(textura_piedra.Width / 2, textura_piedra.Height / 2);

centro_piedra += piedra;

esfera_piedra = new BoundingSphere(new Vector3(centro_piedra, 0), textura_piedra.Width / 2);

centro_alien = new Vector2(textura_alien_der_parado.Width / 2, textura_alien_der_parado.Height / 2);

centro_alien += alien;

esfera_alien = new BoundingSphere(new Vector3(centro_alien, 0), textura_alien_der_parado.Width / 2);

if(esfera_alien.Intersects(esfera_piedra))

{

return true;

}

return false;

}

Si estudiamos el código detenidamente, en primer lugar veremos que debemos calcular el centro de la piedra, que evidentemente se sitúa en la mitad del ancho y del alto del dibujo de la piedra que le hemos asignado a la textura.

Inmediatamente después, le sumamos el vector piedra a la variable centro_piedra, ya que el dibujo de la piedra no se encuentra en el punto “0,0” del eje de las X y de las Y, sino que se encuentra en el punto donde estaba la piedra originalmente.

Finalmente generamos la esfera, a la que le tenemos que pasar como primer parámetro un Vector3(x,y,z), en el que la X y la Y serán nuestro centro de la piedra, y Z será 0, ya que es un juego en 2D y no tiene profundidad, y como segundo parámetro le pasaremos el radio de la esfera, es decir, la mitad del ancho de la piedra.

Las siguiente tres líneas de código son semejantes pero para el alienígena.

Nota: además de la esfera, podéis rodear a los objetos del juego también por cuadrados, siempre debéis usar la forma geométrica que mejor se adapte al objeto que estáis dibujando.

Tras las creaciones de las esferas veréis un IF, en el que comprobamos si una esfera intercepta con la otra, y devolvemos true o false, dependiendo de si ha habido colisión o no.

¿Hasta ahora bastante sencillo no?, ya solo nos queda utilizar nuestra función colision() en la función Update() de la siguiente manera, debemos cambiar el contenido del bucle “foreach” por el siguiente:

if (ekey == Keys.Left)

{

if (!colision)

alien.X -= 5;

else

alien.X += 5;

direccion_movimiento = izq;

num_movimiento += 1;

if (num_movimiento == 3) num_movimiento = 0;

}

if (ekey == Keys.Right)

{

if (!colision)

alien.X += 5;

else

alien.X -= 5;

direccion_movimiento = der;

num_movimiento += 1;

if (num_movimiento == 3) num_movimiento = 0;

}

Si os fijáis, el único cambio ha sido añadir una línea de código en cada IF, de tal manera que si se produce una colisión el alienígena retroceda 5pixels, pero os pongo el código entero del bucle para que lo veáis más claro.

Si compiláis y ejecutáis debería producirse la colisión perfectamente. Ahora si os creáis una función sencilla que os permita saltar hasta cierta altura, capturando en vez de las teclas izquierda y derecha, la tecla arriba y haciendo que cuando el muñeco llegue a determinada altura baje hasta el suelo, tendréis un videojuego parecido al del siguiente vídeo:

Con todo lo que llevamos aprendido a lo largo de estos 5 posts a modo de manual deberíais estar preparados para programar casi cualquier videojuego en 2D, ahora solo os queda practicar y sobretodo imaginación, ya que la clave de un buen juego es la novedad y el ingenio. En el próximo post, como comenté más arriba, os traeré ejemplos de videojuegos en 2D, algunos programados por mí, y programaremos otro tipo de videojuego en 2D, pero como ya tenemos las bases no nos entretendremos en aspectos técnicos e iremos directamente a ver los resultados para daros mas ideas sobre videojuegos para programar.

Saludos! Y practicar mucho!

Diseña tus propios videojuegos para Windows, Zune y XBOX 360 con Microsoft XNA (Parte IV)

Juan Antonio — Thu, 17 Sep 2009 08:16:01 GMT

Buenas a todos, tras tres post explicando la programación de videojuegos con XNA ya debéis tener una idea más o menos clara del contenido necesario para programar videojuegos en 2D. Hoy vamos a complementarla con un pequeño truco en el que enseñaremos a simular el movimiento que realizaría nuestro alienígena andando. Para ello, tenemos que conseguir sprites del alienígena en diferentes posturas en las que salga andando. En mi caso, como os comenté el otro día, el muñeco lo he dibujado con el 3D Studio y me limité a tomar capturas del mismo, pues bien, hoy he colocado el personaje en diferentes posturas y he tomado las siguientes capturas mirando hacia ambos lados:

Cómo es evidente, el mayor realismo a la hora de andar lo conseguiremos con sprites en posturas realistas, los mías no son los mejores, pero para enseñaros el ejemplo nos valdrán.

En primer lugar, cargaremos los sprites en la carpeta “Content” y los agregaremos al proyecto, como aprendimos en el pasado post.

Después deberemos agregar una variable textura nueva por cada nuevo sprite que vayamos a añadir, en mi caso, las seis variables siguientes:

Texture2D textura_alien_der_parado;

Texture2D textura_alien_der_andando;

Texture2D textura_alien_der_andando2;

Texture2D textura_alien_izq_parado;

Texture2D textura_alien_izq_andando;

Texture2D textura_alien_izq_andando2;

Y en la función Loadcontent() enlazaremos a las variables sus respectivas imágenes:

textura_alien_der_parado = Content.Load<Texture2D>("alien-der-parado");

textura_alien_der_andando = Content.Load<Texture2D>("alien-der-andando");

textura_alien_der_andando2 = Content.Load<Texture2D>("alien-der-andando2");

textura_alien_izq_parado = Content.Load<Texture2D>("alien-izq-parado");

textura_alien_izq_andando = Content.Load<Texture2D>("alien-izq-andando");

textura_alien_izq_andando2 = Content.Load<Texture2D>("alien-izq-andando2");

Bien, una vez cargados los sprites, nos queda la tarea de simular el movimiento, para ello mostraremos los sprites en cadena, enlazándolos a las pulsaciones de las teclas, es decir, en principio el alienígena comienza parado, si pulsamos una vez la tecla derecha, avanza 5pixels a la derecha y mostramos el sprite del alienígena levantando un poco una pierna, si volvemos a pulsar la tecla derecha avanzaremos otros 5pixels y mostraremos el sprite del alienígena levantando mas la pierna. Para ello hay infinitas maneras, yo os voy a proponer la siguiente que es bastante sencilla:

En primer lugar crearemos las siguientes variables, que nos permitirán almacenar la dirección del movimiento del teclado, y el número de sprite a mostrar (parado, andando1 o andando2):

const int izq = 1;

const int der = 2;

int direccion_movimiento=2, num_movimiento=0;

Después modificaremos el contenido de la función Update() por el siguiente:

estadoteclado = Keyboard.GetState();

Keys[] teclaspulsada = estadoteclado.GetPressedKeys();

foreach (Keys ekey in teclaspulsada)

{

if (ekey == Keys.Left)

{

alien.X -= 5;

direccion_movimiento = izq;

num_movimiento += 1;

if (num_movimiento == 3) num_movimiento = 0;

}

if (ekey == Keys.Right)

{

alien.X += 5;

direccion_movimiento = der;

num_movimiento += 1;

if (num_movimiento == 3) num_movimiento = 0;

}

Como veis, el único cambio que hemos realizado es que cuando identificamos que se ha pulsado la tecla del cursor derecho o izquierdo almacenamos el movimiento, y aumentamos la variable num_movimiento, que definirá el nº del sprite a mostrar.

Finalmente modificaremos la línea de código de la función Draw() que pintaba al alienígena en la pantalla por el siguiente código, en el que dependiendo de la dirección del movimiento y del número de movimiento pintará un sprite u otro:

switch (direccion_movimiento)

{

case izq:

switch (num_movimiento)

{

case 0:

spriteBatch.Draw(textura_alien_izq_parado, alien, Color.White);

break;

case 1:

spriteBatch.Draw(textura_alien_izq_andando, alien, Color.White);

break;

case 2:

spriteBatch.Draw(textura_alien_izq_andando2, alien, Color.White);

break;

}

break;

case der:

switch (num_movimiento)

{

case 0:

spriteBatch.Draw(textura_alien_der_parado, alien, Color.White);

break;

case 1:

spriteBatch.Draw(textura_alien_der_andando, alien, Color.White);

break;

case 2:

spriteBatch.Draw(textura_alien_der_andando2, alien, Color.White);

break;

}

break;

}

Si compilamos y ejecutamos deberíamos ver un movimiento como el siguiente:

En mi caso no ha quedado perfecto ya que los sprites no eran los mejores, para que salga el efecto más realista os recomiendo bajaros los sprites hechos de internet, como hice con el juego que os mostré en el primer post y que programé para rememorar un antiguo Sonic.

El próximo día avanzaremos un poco con las clases de XNA y estudiaremos como reproducir colisiones entre dos objetos del juego, en el ejemplo del videojuego alien, vamos a hacer que se encuentre con una piedra que le frene el paso, y tenga que saltarla para seguir adelante.

Así que hasta el próximo post os dejo tiempo para que practiquéis y probéis varios sprites hasta que os queden movimientos más realistas, lo más importante es la imaginación!

Saludos!!

Diseña tus propios videojuegos para Windows, Zune y XBOX 360 con Microsoft XNA (Parte III)

Juan Antonio — Sun, 13 Sep 2009 22:15:39 GMT

Buenas a todos, hoy vamos a proseguir con el manual de programación de videojuegos en XNA continuando como comentamos el último día por la programación de nuestro primer videojuego en 2D.

En el pasado post comentamos como instalar Visual Studio y las librerías de XNA, creamos el proyecto de nuestro primer videojuego y finalmente hablamos de las funciones principales que llevan los videojuegos en XNA y el acometido de cada una de ellas. Pues bien, hoy vamos a proceder a “rellenar” estas funciones para generar nuestro primer juego, será uno muy sencillo, en el que un muñeco se mueva hacia los lados por un escenario sin obstáculos, pero para empezar esta semana, no está mal, y servirá para que aprendáis los elementos necesarios para que un juego se ejecute.

En primer lugar debéis conseguir el sprite de un muñeco y un fondo para el videojuego, un sprite es una imagen de un muñeco u objeto del videojuego en una postura determinada, en mi caso como tenía algo de tiempo libre he creado un alienígena en 3D Studio y he hecho una captura del mismo que he pasado a imagen en formato PNG, para que conserve más calidad, pero en principio el Visual Studio aceptará las imágenes de vuestros sprites en cualquier formato.

ALIENIGENA:

FONDO:

Una vez tengáis vuestros sprites, nos iremos a la carpeta raíz de nuestro proyecto, y en la subcarpeta “Content” los copiaremos, ya que es en esta carpeta donde los buscará el Visual Studio por defecto.

Ahora abriremos el proyecto de Visual Studio que creamos el último día e iremos a la carpeta “content”, pulsaremos el botón derecho del ratón sobre ella y en el desplegable que se nos abrirá seleccionamos “agregar un elemento existente”, entonces se nos abrirá la carpeta content en la que veremos nuestros sprites, los seleccionamos y aceptamos, y ya tendremos nuestras imágenes agregadas al proyecto.

Tras esta sencilla tarea vamos a explicar cómo se integra un sprite en el videojuego. Imaginemos por un momento que nuestro videojuego corresponde con una ventana de 640x480 pixels, 640px de ancho, por 480px de alto, un muñeco en el videojuego representará un único pixel en el videojuego de estos 640x480, llamado Vector2D, a lo que os preguntareis: pero… ¿si nuestra imagen ocupa más de 1pixel?, bien, para eso hay una función programada en XNA que diciéndole el pixel donde está el muñeco en la pantalla y el ancho y alto de nuestro Sprite, nos lo rodea de una forma geométrica (esfera, cuadrado,…) para cuando ese sprite tenga que colisionar con otro objeto se “choquen” y podamos detectarlo.

Por tanto en un videojuego en 2D tenemos que tener claro el concepto de que un sprite, será un Vector2D que ocupará un único pixel en la pantalla. Aclarada esta idea, comencemos a picar código.

En primer lugar deberemos declarar las variables necesarias, en nuestro sencillo videojuego solo necesitaremos cuatro, la primera variable representará la textura del muñeco, es decir, la imagen que “enlazaremos” al vector ó pixel que representa al muñeco en pantalla. La segunda de ellas representará la textura del fondo del videojuego. La tercera variable nos servirá para almacenar las teclas que un usuario a tecleado y así comprobar la tecla que ha pulsado para reproducir sus pulsaciones en movimientos del muñeco en el videojuego. La cuarta variable representará el pixel del muñeco que comentamos antes.

//Declaracion de variables

Texture2D textura_alien;

Texture2D textura_fondo;

KeyboardState estadoteclado;

Vector2 alien;

Declaradas las variables vamos a comenzar a rellenar las funciones que hablamos el último día. Comenzaremos por la función Initialize() dónde deberemos sustituir la línea comentada:

// TODO: Add your initialization logic here

Por las siguientes cuatro líneas de código, que simplemente definirán el ancho y alto de la pantalla del videojuego, y crearemos el Vector2 (el famoso pixel, que antes definimos), el cual situaremos por ejemplo en la posición X=100px Y=380px de la pantalla:

graphics.PreferredBackBufferHeight = 480;

graphics.PreferredBackBufferWidth = 640;

graphics.ApplyChanges();

alien = new Vector2(100, 380);

El siguiente paso será asociar las fotos que almacenamos en la carpeta “Content” con las variables texture2D que antes declaramos, para ello le indicamos el nombre de la imagen, pero sin la extensión, el Visual Studio la encontrá igualmente, no os preocupéis, en mi caso tenía las imágenes: alien_der_andando.png y fondo.jpg.

Al igual que antes, sustituiremos la línea comentada:

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

Por las siguientes:

textura_alien = Content.Load<Texture2D>("alien_der_andando");

textura_fondo = Content.Load<Texture2D>("fondo");

Ahora programaremos los movimientos de nuestro muñeco, para ello nos iremos a la función Update() y sustituiremos de nuevo la línea comentada de siempre por el siguiente código, en el que leeremos el estado del teclado y observaremos todas las pulsaciones comprobando si coincide con una pulsación de la “flecha izquierda” del teclado o de la “flecha derecha”, en caso de ser una de ellas, moveremos nuestro muñeco (nuestro pixel) a la izquierda o a la derecha en el eje de las X de la pantalla, en nuestro caso hemos puesto que se mueva 5pixels, que es una velocidad bastante aceptable:

estadoteclado = Keyboard.GetState();

Keys[] teclaspulsada = estadoteclado.GetPressedKeys();

foreach (Keys ekey in teclaspulsada)

{

if (ekey == Keys.Left)

{

alien.X -= 5;

}

if (ekey == Keys.Right)

{

alien.X += 5;

}

}

Finalmente tendremos que pintar el muñeco en la pantalla, para ello nos vamos a la función Draw() y sustituiremos la línea comentada por las siguientes líneas. Al principio y al final abriremos y cerraremos el modo “dibujo” y entre medias podremos dibujar los objetos en la pantalla:

spriteBatch.Begin(SpriteBlendMode.AlphaBlend);

spriteBatch.Draw(textura_fondo, Vector2.Zero, Color.White);

spriteBatch.Draw(textura_alien, alien, Color.White);

spriteBatch.End();

Como veis dibujar un objeto es muy sencillo, el primer parámetro que le pasaremos a la función “spriteBatch.Draw” será la textura del objeto, el segundo parámetro será la posición de la pantalla que ocupará, como habréis imaginado, al actualizar la posición del muñeco en la función Update, ya no hace falta que dibujemos el objeto unos pixels hacia un lado, ya que el vector se actualizó en la función Update() que se ejecuta antes que la función Draw(), el tercer parámetro lo dejaremos tal cual:

spriteBatch.Draw(TEXTURA, VECTOR, Color.White);

Pues esto es todo por hoy, si os ha salido todo bien, debería compilar y ejecutarse sin problemas y tendréis un videojuego como el siguiente:

El próximo día vamos a convertir el movimiento de nuestro muñeco en algo más realista, haciendo que cuando se mueva simule que va andando, moviendo las piernas, y que cuando vaya hacia atrás, mire hacia atrás, hasta entonces os dejo practicando con el post de hoy!

Saludos!

Diseña tus propios videojuegos para Windows, Zune y XBOX 360 con Microsoft XNA (Parte II)

Juan Antonio — Sun, 06 Sep 2009 22:53:32 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!!