Windows Técnico : Tablet

Descargar juegos de Xbox Live en Windows 8

Francisco Javier Santiago — Fri, 25 Jan 2013 12:15:00 GMT

Microsoft ha publicado un servicio que lleva por nombre PLAY que permite la descarga de una serie de juegos de Xbox Live Arcade para cualquier dispositivo con Windows 8 como parte de su nueva iniciativa de juego.

La lista de títulos incluye juegos simples como buscaminas y solitario, pero también clásicos de Xbox como son Toy Soldiers, Gunstringer e Ilomilo.

Todos los títulos están disponibles en dispositivos Windows 8 excepto Toy Soldiers, que no funcionará con Windows RT.

Microsoft explica en su sitio oficial: "Our games have something for everyone, from casual puzzlers and high energy racing to immersive adventure and non-stop arcade. For Xbox fans you'll also find your favourite features like leaderboards, multiplayer modes, connecting with friends, and more”.

En todos los títulos disponibles en Microsoft Studios se permite probar los juegos antes de comprar; por otro lado Microsoft Studios está disponible para Windows 8 y Windows RT a través de la tienda de Windows.

Incluye una lista completa de títulos compatibles:

Toy Soldiers (no está disponible en Windows RT)
4 Elements: Special Edition
Hydro Thunder Hurricane
Rocket Riot 3D
Reckless Racing Ultimate
Microsoft Solitaire Collection
Microsoft Mahjong
Microsoft Minesweeper
Taptiles
Adera
Pinball FX2
Wordament
Gunstringer: Dead Man Running
Ilomilo+
Skulls of the Shogun

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”. Si quieres conocer las novedades y secretos de la nueva versión del sistema operativo servidor de Microsoft te recomendamos Windows Server 2012 para IT Pros. 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”.

Además si te ha gustado el artículo puedes suscribirte al Canal RSS de Windows Técnico, o seguirnos por el Canal Google+ de Windows Técnico o Twitter para estar al día de las novedades e información técnica de interés.

Un nuevo Tablet de Nokia con Windows 8 amenazaría el éxito del nuevo iPad.

Jhonattan Fiestas — Fri, 20 Apr 2012 13:07:05 GMT

Todo el mundo sabe e impacto social que ha tenido la Apple con su tableta iPad, el cual sigue siendo el delirio de grandes y pequeños, sobretodo por su facilidad de transporte y ligero peso.

Debido a esto y ante la mas que inminente salida al mercado de la nueva generación de dispositivos iPad, que la empresa finlandesa Nokia ha querido contrarrestar el impacto que la manzana hará en el mercado, ya que con la ayuda su fiel compañero Microsoft, empezarán la producción de un Tablet que pondrá en jaque la hegemonía de iPad en los hogares del publico en general, donde competiría no solamente en calidad, sino en precio, algo en lo que hasta hoy en día nadie le podría discutir.

Una de las grandes novedades que aportará la tableta desarrollada por Nokia sería tener como sistema operativo el nuevo MS Windows 8, beneficiándose así de todas las capacidades y tecnología disponible en dicho software.

Ante este aporte en el sistema operativo muchos bloggers empiezan a debatir sobre que estos terminales tendrán un rendimiento muy por encima, de lo que se espera de la competencia, y no es nada fuera de lo común, ya que fuentes fiables confirman que MS Windows 8 superará en rendimiento a su predecesor MS Windows 7.

Con el sector de las tabletas en auge, en el que cada año miles de usuarios se suman a su causa, era de esperarse que una compañía como Nokia que es una de las grandes protagonistas de la industria móvil quiera introducirse en el mercado con la colaboración de otro grande en la materia, y quien mejor que Microsoft para ser su compañero de viaje en este nuevo proyecto.

Esta noticia, que empezó como un rumor meses atrás, se va consolidando con el paso de los días, dado que el director ejecutivo de la compañía nórdica, Stephen Elop, ha realizado declaraciones en las cuáles no deja apartado a este sector de las tabletas, sino todo lo contrario y actualmente el jefe de diseño de Nokia Marko Ahtisaari ha confirmado que está trabajando en ello.

Inicialmente se empezará con un lanzamiento de 200.000 unidades, que aumentarán dependiendo de como responda el mercado, pudiendo duplicarse el primer lote de en el primer trimestre tras el lanzamiento.

La tableta mencionada saldría a la venta a finales de este mismo año, con grandes características como la mencionada inclusión de Windows 8 como sistema operativo, procesador Qualcomm Dual Core compatible con la arquitectura ARM y una pantalla táctil de 10 pulgadas.

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” .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.

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

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

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

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

Jhonattan Fiestas — Tue, 13 Sep 2011 16:24:00 GMT

En principio ésta sería la última entrada de la serie correspondiente al análisis del código que se encuentra detrás de la aplicación “Simon Dice Renewed”, disponible desde hace poco mas de 2 semanas en el canal “windows7multitouch” en el repositorio de “codeplex”, y que en este corto periodo de tiempo ha sido descargado en mas de 50 ocasiones entre sus versiones:

Sin embargo debido a la densidad del contenido y a la amplitud del código a desarrollar se ha decidido ampliar a un capitulo mas, con lo cual se añadirá al final de la serie un “Anexo I” correspondiente a las funciones que no queden analizadas en esta entrada, y a una visión general del funcionamiento del juego.

Como se comento en la entrada anterior se proseguirá con la descripción de las funciones incluidas en la clase “MainWindow”:

· Btn_MouseLeftButtonDown y Btn_touchDown

Para la realización del juego es necesario guardar las pulsaciones de botones que se realizan en cada nivel. Por ello se añadirá a la lista “jugadas” un número que corresponda con el botón sobre el cual se ha hecho clic (o se ha pulsado según el caso), después se deberá asignar el sonido a reproducir y cambiar la apariencia del botón pulsado. Como último paso se reproducirá el sonido que ha sido establecido previamente.

Una observación que se ha querido hacer es que cuando se realiza una pulsación sobre la pantalla táctil se genera el evento “onTouch” correspondiente, al finalizar dicho evento se genera un segundo evento relacionado con el “hacer clic” sobre las coordenadas de la pulsación, es decir, se desencadena un evento “onLeftButtonClick”, con lo cual, si esta situación no es controlada podría generar el error.

Una de las formas de controlar si estamos accediendo a la aplicación mediante una tecnología táctil o mediante el uso de un ratón seria haciendo uso de una función contenida en la librería “Windows7.Multitouch”.Se comentara el código para una mejor visión del desarrollo realizado.

private void btn_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

// Si el equipo consta de capacidades digitales y está preparado para “Multitouch”

// se ejecuta el contenido de esta función, en caso contrario no se ejecuta nada.

if (!Windows7.Multitouch.TouchHandler.DigitizerCapabilities.IsMultiTouchReady)

{

// Se añade el botón pulsado a la lista “jugadas”

switch (((Image)(sender)).Name)

{

case "btn1": jugadas.Add(0); break;

case "btn2": jugadas.Add(1); break;

case "btn3": jugadas.Add(2); break;

case "btn4": jugadas.Add(3); break;

case "btn5": jugadas.Add(4); break;

case "btn6": jugadas.Add(5); break;

}

// Se establece el sonido que será reproducido

switch (((Image)(sender)).Name)

{

case "btn1": son = sonidobtn[0]; break;

case "btn2": son = sonidobtn[1]; break;

case "btn3": son = sonidobtn[2]; break;

case "btn4": son = sonidobtn[3]; break;

case "btn5": son = sonidobtn[4]; break;

case "btn6": son = sonidobtn[5]; break;

}

// Se cambia la apariencia de la imagen, simulando una pulsación.

switch (((Image)(sender)).Name)

{

case "btn1": btn1.Source = new BitmapImage(new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "azul2.png"));

break;

case "btn2": btn2.Source = new BitmapImage(new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "morado2.png")); break;

case "btn3": btn3.Source = new BitmapImage(new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "rojo2.png")); break;

case "btn4": btn4.Source = new BitmapImage(new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "verde2.png")); break;

case "btn5": btn5.Source = new BitmapImage(new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "verdemar2.png")); break;

case "btn6": btn6.Source = new BitmapImage(new Uri(@"pack://application:,,,/SimonDice;component/Img/" + "naranja2.png")); break;

}

// Se reproduce el sonido guardado en la variable “son”.

Player.URL = System.IO.Directory.GetCurrentDirectory() + son;

Player.controls.play();

}

· Btn_MouseButtonUp y Btn_touchUp

Se describirá el funcionamiento de estas funciones por medio de los comentarios en el código.

private void btn_TouchUp(object sender, TouchEventArgs e)

{

// Se oculta la imagen de estado(el cual indica si ha habido error

// o si se ha completado el nivel con éxito

estado.Visibility = Visibility.Hidden;

// De vuelve a colocar su imagen del botón a su estado inicial.

switch (((Image)(sender)).Name)

{

case "btn1": btn1.Source = new BitmapImage(

new Uri(Environment.CurrentDirectory + "\\Img\\azul.png"));

break;

case "btn2": btn2.Source = new BitmapImage(

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

break;

case "btn3": btn3.Source = new BitmapImage(

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

break;

case "btn4": btn4.Source = new BitmapImage(

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

case "btn5": btn5.Source = new BitmapImage(

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

case "btn6": btn6.Source = new BitmapImage(

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

}

// Se realiza la comprobación de si se ha cometido un error, la secuencia

// sigue correctamente, o si se ha alcanzado a completar la secuencia

// exitosamente por medio del método “comprobar” que será descrito a continuación.

int cmp = comprobar();

// Si la secuencia de pulsaciones aun no completa la lista de juego, y está siendo

// correcta nos saltaríamos este paso. En caso contrario, si hay error o se completa

// correctamente la secuencia de juego.

if (cmp != 1)

{

if (cmp == 0)

{

jugadas = new List<int>();// Reinicia la lista de jugadas.

// se hace visible el estado, y se cambia la imagen a mostrar

estado.Visibility = Visibility.Visible;

estado.Source = new BitmapImage(new

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

// Damos un tamaño al cuadro de estado.

estado.Height = 60;

estado.Width = 500;

// Posicionamos el cuadro de estado(imagen).

estado.SetValue(Canvas.LeftProperty, 95.0);//231 original

error();//Se lanza el método de error.

}else{

if (cmp == 2){

// se hace visible el estado, y se cambia la imagen a mostrar

estado.Visibility = Visibility.Visible;

estado.Source = new BitmapImage(

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

// Damos un tamaño al cuadro de estado.

estado.Height = 49;

estado.Width = 201;

// Posicionamos el cuadro de estado(imagen).

estado.SetValue(Canvas.LeftProperty, 231.0);//231 original

ganar();// Se lanza el método de ganar.

deshabilitarBotones();// Se deshabilitan los botones

jugadas = new List<int>();// Reinicia la lista de jugadas.

}

· Comprobar

La función comprobar como su propio nombre anuncia realiza la comprobación de si la secuencia de pulsaciones realizadas es correcta, si se ha completado con éxito, o si se ha cometido un error en el orden correcto de pulsaciones.
La llamada a dicha función devuelve uno de los siguientes valores:

0: Cuando se introduce erróneamente una pulsación en la secuencia.
1: Cuando la secuencia de pulsaciones lleva un orden correcto.
2: Cuando se ha finalizado la secuencia de forma correcta.

private int comprobar()

{

int retorno = 0;

// Si la lista de jugadas es mas pequeña que la lista de juego

if (jugadas.Count < lista.Count)

{

// Recorremos la lista de juego, y si coincide con los valores en las mismas

// posiciones es que la lista de juego esta siguiendo el orden correcto.

for (int i = 0; i < jugadas.Count; i++)

{

if (jugadas.ElementAt(i) == lista.ElementAt(i))

{

retorno = 1; // Sigue el orden correcto

}

else

{

retorno = 0; // Se ha cometido un error en la secuencia de pulsaciones.

i = jugadas.Count; //Se modifica el índice de iteración para salir del “for”

}

else

{

// Si la lista de botones jugados tiene el mismo tamaño que la lista de jugadas,

// solo pueden haber dos opciones, que se haya introducido mal el ultimo elemento

// o que la secuencia sea correcta.

if (jugadas.Count > lista.Count)

{

// Si por alguna extraña razón, la lista de pulsaciones es mas grande que la

// lista de juego, se deberá comprobar en función de la lista de juego si la

// secuencia de pulsaciones ha sido introducido correctamente, sin tomar en

// cuenta el excedente.

for (int i = 0; i < lista.Count; i++)

{

if (jugadas.ElementAt(i) == lista.ElementAt(i))

{

retorno = 2; // Todo ha sido correcto

}

else

{

retorno = 0; // Error

i = jugadas.Count; // Salida del bucle.

}

else

{

//Este es el caso antes mencionado, si ambas listas poseen el mismo tamaño.

for (int i = 0; i < jugadas.Count; i++)

{

if (jugadas.ElementAt(i) == lista.ElementAt(i))

{

retorno = 2;

}

else

{

retorno = 0; // Error.

i = jugadas.Count; // Salida del bucle.

}

return retorno;

}

· Error

private void error()

{

// Se detiene la reproducción de sonidos en el caso de que estuviera reproduciéndose

// algún sonido correspondiente a algún botón, se establece el sonido de error en la

// salida de audio y posteriormente se procede a reproducirse el sonido.

Player.controls.stop();

Player.URL = System.IO.Directory.GetCurrentDirectory() + sonidoError;

Player.controls.play();

deshabilitarBotones();// Se deshabilitan los botones hasta que se pulse en “Play”

// Se habilita el botón “play” y se cambia a la apariencia normal, es decir, listo

// para jugar.

btnJugar.IsEnabled = true;

btnJugar.Source = new BitmapImage(new

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

// En el caso de que se cometa un error el número de intentos debería bajar una

// unidad y en el caso de que llegue a 0, se emitirá un panel de dialogo en el que se

// muestra el resultado final de la ejecución de juego, volviendo al lienzo de

// inicio, reiniciándose el ciclo del juego.

txtIntentos.Text = Convert.ToString(Convert.ToInt32(txtIntentos.Text) - 1);

bajarNivel();

if (Convert.ToInt32(txtIntentos.Text) == 0) {

Resultado res = new Resultado();

res.lblResultado.Content = txtPuntuacion.Text;

res.WindowStartupLocation = WindowStartupLocation.CenterScreen;

res.ShowDialog();

res.WindowState = WindowState.Maximized;

cancelarEjecucion();

inicializarJuego();

juego.Visibility = Visibility.Hidden;

Inicio.Visibility = Visibility.Visible;

}

· ganar

// Cuando se termine correctamente la secuencia de pulsaciones, se lanzará este método.

private void ganar()

{

// Se establece como sonido para ser reproducido un sonido de vítores , se sube de nivel

// y se sube la puntuación 5 veces el nivel que se haya superado

Player.URL = System.IO.Directory.GetCurrentDirectory() + sonidofinal;

Player.controls.play();

txtPuntuacion.Text = Convert.ToString(Convert.ToInt32(txtPuntuacion.Text) + nivel * 5);

subirNivel();

btnJugar.IsEnabled = true;

btnJugar.Source = new BitmapImage(new

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

}

En el próximo post y ultimo de la serie de procederá finalizará la descripción de los métodos incluidos en la clase “MainWindow”, y se hará la tan comentada visión general de la aplicación.

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

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

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

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

Jhonattan Fiestas — Tue, 06 Sep 2011 21:31:00 GMT

En estos días ya son muchos los usuarios que han enviado comentarios a través del canal codeplex sobre la aplicación de ejemplo “Simon Dice Renewed”, con diferentes dudas y sugerencias para ampliaciones en este divertido juego desarrollado con fines didácticos, lo cual indica que este trabajo ha despertado la curiosidad tanto entre nuevos desarrolladores ,que ven esta aplicación una buena forma de introducirse en el mundo de la programación para este tipo de dispositivos, como entre los desarrolladores no tan nuevos, que han encontrado en este proyecto una nostálgica puerta abierta a sus recuerdos de infancia o niñez.

Para continuar con la serie en esta ocasión se mostrarán las funciones que se encargarán del desarrollo en general del proyecto.

Funciones contenidas dentro de MainWindow

· MainWindow

Esta función es el constructor de la clase que como puede observarse inicializa los componentes de los formularios que constituyen la aplicación.

public MainWindow()

{

InitializeComponent();

}

· slider_ValueChanged

Como se comentaba previamente, esta función se desencadenara cuando se haga un cambio en el “slider” para variar el valor del volumen. Se variara de forma conjunta tanto el slider como el “progressBar”, pero como el rango de valores del “progressBar” es diez veces más grande, pues se multiplicará por 10 el valor que tenga el slider en cada momento.

Para modificar el volumen en tiempo de ejecución se ira a la configuración (“Settings”) del objeto “player”, y allí se modifica el valor del volumen.

private void slider1_ValueChanged(object sender,

RoutedPropertyChangedEventArgs<double> e)

{

this.progressBar1.Value = slider1.Value * 10;

Player.settings.volume = (int)(this.progressBar1.Value);

}

· Windows_Loaded

Esta función se desencadena al inicio de la ejecución del programa e inicializa las variables con las cuales se va a trabajar en el desarrollo del juego.Se comentará paso a paso para ver la finalidad de cada línea de código.

// Se inicializa el objeto de “WindowsMediaPlayer”, y se establece el valor del volumen
// en 50 de intensidad.

Player = new WindowsMediaPlayer();

Player.settings.volume = 50;

// para manipular el volumen de la emisión de sonidos del reproductor, se ha puesto un

// slider de forma conjunta con un progressbar para que se visualice en todo momento el

// valor del volumen. Se establecen ambos en la mitad de sus posibles valores.

progressBar1.Value = 50;

slider1.Value = 5;

// Se cambia la imagen de fondo, de la forma en la que se ha procedido en

// anteriores publicaciones.

ImageBrush imgBrush = new ImageBrush();

imgBrush.ImageSource = new BitmapImage(new

Uri(@"pack://application:,,,/SimonDice;component/Img/pez.jpg"));

canvas1.Background = imgBrush;

// se inicializa la cadena sonido con los 6 posibles sonidos que podrán

// ser utilizados por parte de los botones del juego.

sonido = new String[6];

sonido[0] = @"/Sonidos/risahomero.mp3";

sonido[1] = @"/Sonidos/rock.mp3";

sonido[2] = @"/Sonidos/willSmith.mp3";

sonido[3] = @"/Sonidos/tiburon.mp3";

sonido[4] = @"/Sonidos/tambores.mp3";

sonido[5] = @"/Sonidos/secreto.mp3";

sonidobtn = new String[6];

lista = new List<int>();

// Se inicializa el objeto Random para posteriormente generar números aleatorios, en

// este caso se utilizara como semilla el milisegundo actual

r = new Random(DateTime.Now.Millisecond);

// Se inicializan los sonidos(véase en la descripción de la siguiente función)

InicializarSonidos();

txtRonda.Text = String.Format("{0}", nivel); //Se coloca el nivel actual.

// Se deshabilitan los botones, hasta que se pulse sobre el botón play

deshabilitarBotones();

· InicializarSonidos

Esta función se encarga de cargar los valores las canciones que irán en cada botón, de forma que no se repita el mismo sonido en dos botones diferentes. La idea principal es introducir cada número en una lista y comprobar si existe, en caso afirmativo se vuelve a generar otro número, en caso contrario se añade el número a la lista y se asigna el sonido a la lista “sonidoBtn” en la posición determinada.

private void InicializarSonidos()

{

for (int i = 0; i < sonidobtn.Length; i++)

{

Boolean entrar = true;

while (entrar)

{

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

if (!numero.Contains(a))

{

sonidobtn[i] = sonido[a];

numero.Add(a);

entrar = false;

}

· habilitarBotones y deshabilitarBotones

Parece bastante intuitivo lo que hace esta función por el nombre con el cual ha sido declarado y evidentemente realiza las acciones descritas sobre botos los botones excepto el “btnJugar” y el “btnSalir”.

private void habilitarBotones()

{

btn1.IsEnabled = true;

btn2.IsEnabled = true;

btn3.IsEnabled = true;

btn4.IsEnabled = true;

btn5.IsEnabled = true;

btn6.IsEnabled = true;

}

private void deshabilitarBotones()

{

btn1.IsEnabled = false;

btn2.IsEnabled = false;

btn3.IsEnabled = false;

btn4.IsEnabled = false;

btn5.IsEnabled = false;

btn6.IsEnabled = false;

}

· btnEntrar_MouseLeftButtonDown y btnEntrar_touchDown

Estas dos funciones representan la acción de ingresar en el área de juego después de hacer clic izquierdo o pulsar sobre el “btnJugar” respectivamente.

private void btnEntrar_MouseLeftButtonDown(object sender,

MouseButtonEventArgs e)

{

Inicio.Visibility = Visibility.Hidden;

juego.Visibility = Visibility.Visible;

nivel = 1;

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

btnJugar.Source = new BitmapImage(new

Uri(@"pack://application:,,,

/SimonDice;component/Img/" +

"btnJugar.png"));

btnJugar.IsEnabled = true;

}

· BajarNivel y SubirNivel

Como su propio nombre indica, las siguientes funciones modifican el valor de la variable “nivel”, para subir o bajar la dificultad del juego.

private void bajarNivel()

{

nivel--;

}

private void subirNivel()

{

Nivel++;

}

· JugarLista

Esta función se podría considerar como la ejecución de un jugador implícito, ya que sigue un patrón y asegura que en cada nivel se realizan unas “pulsaciones virtuales” sobre los botones de juego,para que después “el jugador real” intente reproducir la secuencia de correctamente. Se explicará el código por medio de comentarios.

private void jugarLista()

{

// Dentro de la variable “lista” están las pulsaciones que se han generado

// aleatoriamente, por lo tanto, para cada elemento de la lista se generara una

// pulsación “virtual”

for (int i = 0; i < lista.Count; i++)

{

thisbtn = lista[i];

// Se cambia la apariencia del botón para que parezca pulsado

imagenpulsada(thisbtn);

deshabilitarBotones(); //Se deshabilitan los botones.

// Se establece el sonido a reproducir, más adelante se verá la forma en la que

// se asigna un sonido a la variable son.

establecerSonido(thisbtn);

Player.controls.stop(); //Se detiene el reproductor

// Se establece el sonido que se va a reproducir

Player.URL = System.IO.Directory.GetCurrentDirectory() + son;

//Se reproduce el sonido

Player.controls.play();

// Aquí se puede observar un método diferente para detener la ejecución de la

// función “JugarLista”.

//Se recoge la fecha exacta en la que pasa por este punto.

DateTime a = DateTime.Now;

int j = 0;

// Se vuelve a ejecutar el bucle mientras la diferencia entre la fecha guardada

// anteriormente y la actual sea menor a 2 segundos.

while (j < 2)

{

DateTime b = DateTime.Now;

j = (int)((b - a).TotalSeconds);

         // Con DoEvent se busca si hay alguna acción en pendiente de ejecución, y si la hay,

         // se ejecuta dicha acción.En este caso se ejecuta el reproductor se sonido ya que

         // no podía reproducirse hasta que termine la ejecución de la función.

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

}

//Se vuelve a restablecer a su apariencia habitual a la imagen pulsada

imagenNormal(thisbtn);

}

// Después de pulsarse virtualmente todos los botones contenidos en la “lista”, se

// habilitarían los botones para empezar a reproducir la secuencia.

habilitarBotones();

}

En la siguiente entrada se finalizará la descripción y análisis de esta divertida aplicación terminando con las funciones restantes que aun no han sido descritas, así como una visión general del funcionamiento de la aplicación una vez conocidos todos sus componentes.

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

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

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

Jhonattan Fiestas — Fri, 02 Sep 2011 14:26:00 GMT

Continuando con la serie, “Desarrollo de aplicación de ejemplo Windows 7 Muititouch : Simon Dice Renewed” ,donde se intenta explicar detalladamente el funcionamiento y lógica de esta aplicación didáctica mencionado tipo de dispositivos.En esta ocasión se continua con dicho análisis realizando la localización y descripción de las variables utilizadas, para una visión general en la siguiente imagen podréis ver el numero y nombres de dichas variables de forma que os vayáis familiarizando con ellas.

· botonesJugados

Es una pequeña lista donde se podría guardar el nombre de los botones pulsados durante el juego, y se dice podrían porque aunque está declarado en la aplicación aún no es funcional ya que está pensado para una futura ampliación del juego.

· Handle

El campo “handle” es un número entero que será utilizado como referencia a la hora de hacer una llamada a la función “midiOutOpen” que será descrita una vez más en esta serie.

· Lista

Esta lista describe la serie de pulsaciones correcta para superar un nivel de juego, la lista será inicializada en comenzar cada nivel y no guardara relación con la anterior, para aumentar así la dificultad de memorización.

· Nivel

Por el nombre que tiene cabe suponer que es el grado de dificultad que presenta el juego en la presente etapa de ejecución. Aumentará en una unidad cuando se complete correctamente una serie completa de pulsaciones y en contraposición perderá una unidad cuando se cometa un fallo en intentar completar dicha serie. Cabe resaltar que el número de elementos de la cadena de pulsaciones depende directamente del nivel sobre el que se este jugando.

· Número

En este caso se hace referencia a una cadena (array) de números enteros que guardará los números del 0 al 5 de forma aleatoria para dar sonidos diferentes a los botones en cada nivel del juego, aumentando así por segunda vez, la dificultad del juego.

· Player

Instancia de la clase Windows Media Player de la librería “WMPLib”.

Esta instancia será la encargada de reproducir los sonidos de juego, pudiéndose iniciar, pausar y continuar en el momento que el programador desee.

La declaración de esta variable se hace de la siguiente forma.

WMPLib.WindowsMediaPlayer Player;

Para más información se puede acudir a Microsoft Development Network (MSDN)

· R

Esta variable es un elemento de tipo “Random”, que será el numero aleatorio que sea utilizado para inicializar, tanto los sonidos que serán asociados a los botones como la secuencia de botones a pulsar que será guardado en la variable “Lista” descrita anteriormente.

· Son

Representa el sonido que se va a reproducir en cada momento. El valor de esta variable cambiará en tiempo de ejecución en el instante que el usuario pulse sobre un botón, asignándosele el sonido correspondiente. Posteriormente este valor será utilizado por el objeto “player” para establecer el valor de la URL a reproducir.

· Sonido

Ésta es una matriz (array) de cadenas de caracteres que muestra la ruta absoluta de los seis sonidos que serán incluidos en el desarrollo del juego. Esta lista se podría denominar constante ya que se podría referir a cada elemento de la colección por su subíndice sin peligro a que sufra algún cambie durante la ejecución.

· Sonidobtn

Este “array” guarda la ruta de todos los posibles sonidos contenidos en la variable “sonido”, pero aquí guardados de forma aleatoria para que en cada nivel todos los botones tengan un sonido diferente con respecto al nivel anterior.

· sonidoError

Esta constante, de forma similar a la variable “sonido”, guarda la ruta del archivo de sonido que será reproducido cuando se cometa un error durante la ejecución del juego.

· sonidofinal

De forma análoga a la anterior, esta constante guarda la ruta del archivo de sonido que se reproducirá cuando se cumpla con la secuencia pulsaciones de forma satisfactoria.

· thisbtn

Ésta variable indica al método “JugarLista()” que elemento debe manipular en cada momento, es decir, cuando se inicia cada nivel la aplicación realiza automáticamente una serie de pulsaciones que el usuario debe memorizar para después intentar repetirlo en el orden correcto. Se podría interpretar por pulsación automática cuando el botón cambia de apariencia y se reproduce el sonido que lleva asociado.

En la siguiente entrada de la serie se abordarán los diferentes métodos y funciones de las que dispone la aplicación además de la relación que se establecen entre ellos. Otro aspecto a reseñar es el encapsulado del código para su reutilización, las novedades con respecto al sonido y la gestión de eventos en tiempo de ejecución.

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

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

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

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

Jhonattan Fiestas — Thu, 01 Sep 2011 13:42:00 GMT

En el transcurso de las siguientes entradas se completará el análisis de esta divertida aplicación que presenta diferentes aspectos interesantes a mencionar, tal y como se hizo en el post inicial de la serie, Desarrollo de aplicación de ejemplo Windows 7 Multitouch: “Simon Dice Renewed” I, en el que se realizó una pequeña introducción al árbol de ficheros que compone el proyecto “Simón Dice” y a las acciones de compilación disponibles en Visual Studio 2010 , haciendo una breve descripción de lo que son y en que situaciones es conveniente utilizarlos.

Para el desarrollo de esta aplicación no ha sido necesario el uso de controles de usuario, por lo cual todo el código necesario para la ejecución de la aplicación está incluido dentro de la clase “MainWindow”.

Para continuar con el análisis lo primero a observar es la vista de diseño de la clase, donde se comentará todos los controles utilizados en la interfaz del juego. Para definir mejor cada elemento se añadirá comentarios en el código.

<!--Como detalle interesante se puede ver que en el atributo “Icon” se ha establecido el

archivo “colores.ico” -->

<Window x:Class="WpfApplication1.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"

xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:my="clr-namespace:WpfApplication1"

Title="MainWindow" WindowStartupLocation="CenterScreen"

WindowState="Maximized" ResizeMode="NoResize" Loaded="Window_Loaded"

WindowStyle="None" Background="#FF2A7979"

Icon="/SimonDice;component/colores.ico">

<!--Éste es el lienzo principal, o lienzo padre donde estarán situados los demás lienzos que

serán puestos o quitados en tiempo de ejecución-->

<!--Este lienzo será el primero en ser mostrado al iniciar la ejecución del juego. Y será

tratado como una pantalla de bienvenida en el cual se decidirá si ir al lienzo de juego

o salir completamente de la aplicación -->

<Image Canvas.Left="300" Source="Img/Titulo.png" Canvas.Top="60" Height="240"

Name="Titulo" Stretch="Fill" Width="600" />

<!—Una imagen que sirve como botón que permite salir completamente de la aplicacion-->

<Image Canvas.Left="380" Source="Img/btnSalir.png" Canvas.Top="500" Height="80"

Name="btnSalirTotal" Stretch="Fill" Width="100" MouseLeftButtonDown="btnSalirTotal_MouseLeftButtonDown" TouchDown="btnSalirTotal_TouchDown" />

<!—Una imagen como botón que oculta el lienzo actual, para mostrar el lienzo de juego-->

<Image Canvas.Left="300" Source="Img/btnJugar.png" Canvas.Top="250"

Height="160" Name="btnEntrar" Stretch="Fill" Width="278"

MouseLeftButtonDown="btnEntrar_MouseLeftButtonDown" TouchDown="btnEntrar_TouchDown" />

<!—Cabria resaltar que algunas de las imagines mostradas en esta aplicación han sido

reutilizados de proyectos anteriores.-->

</Canvas>

<!—Este lienzo es donde se desarrollara el juego, y es donde está situado la gran mayoría de

controles con los que el usuario interactuara-->

<!—Seis imágenes correspondientes a los seis botones de colores que deberán ser pulsados

para la realización del juego y dependiendo de la tecnología con la que se acceda a ellos(Mouse o Touch) se lanzará un evento u otro-->

<Image Name="btn2" Source="Img/morado.png" Width="100" Height="100" Canvas.Left="81"

Canvas.Top="67" MouseLeftButtonUp="btn_MouseLeftButtonUp"

TouchDown="btn_TouchDown" TouchUp="btn_TouchUp"

MouseLeftButtonDown="btn_MouseLeftButtonDown"></Image>

<Image Name="btn1" Source="Img/azul.png" Width="100" Height="100" Canvas.Left="12"

Canvas.Top="165" MouseLeftButtonDown="btn_MouseLeftButtonDown"

MouseLeftButtonUp="btn_MouseLeftButtonUp" TouchUp="btn_TouchUp"

TouchDown="btn_TouchDown"></Image>

<Image Name="btn3" Source="Img/rojo.png" Width="100" Height="100" Canvas.Left="202"

Canvas.Top="12" MouseLeftButtonDown="btn_MouseLeftButtonDown"

MouseLeftButtonUp="btn_MouseLeftButtonUp" TouchUp="btn_TouchUp"

TouchDown="btn_TouchDown"></Image>

<Image Name="btn4" Source="Img/verde.png" Width="100" Height="100" Canvas.Left="330"

Canvas.Top="12" MouseLeftButtonDown="btn_MouseLeftButtonDown" MouseLeftButtonUp="btn_MouseLeftButtonUp" TouchDown="btn_TouchDown" TouchUp="btn_TouchUp"></Image>

<Image Name="btn5" Source="Img/verdemar.png" Width="100" Height="100" Canvas.Left="463"

Canvas.Top="67" MouseLeftButtonDown="btn_MouseLeftButtonDown"

MouseLeftButtonUp="btn_MouseLeftButtonUp" TouchDown="btn_TouchDown"

TouchUp="btn_TouchUp"></Image>

<Image Name="btn6" Source="Img/naranja.png" Width="100" Height="100" Canvas.Left="557"

Canvas.Top="165" MouseLeftButtonDown="btn_MouseLeftButtonDown"

MouseLeftButtonUp="btn_MouseLeftButtonUp" TouchDown="btn_TouchDown"

TouchUp="btn_TouchUp"></Image>

<!-- Una caja de texto que mostrara el nivel en el que se encuentra, dicho nivel será

incrementado al completar la serie y por lo contrario será reducido en una unidad

cuando se cometa un fallo-->

<TextBox Canvas.Left="248" Canvas.Top="178" Height="53" Name="txtRonda" Width="103"

Text="1" TextAlignment="Center" FontSize="30" IsReadOnly="True" />

<!—Imagen que será utilizada como botón para salir del lienzo de juego hacia el lienzo

de inicio-->

<Image Canvas.Left="608" Source="Img/btnSalir.png" Canvas.Top="-130" Height="80"

Name="btnSalir" Stretch="Fill" Width="100" MouseLeftButtonDown="btnSalir_MouseLeftButtonDown" TouchDown="btnSalir_TouchDown" />

<!—Barra de progreso que representara el nivel de volumen que tendrá el reproductor de

sonidos, y que podrá ser modificado en tiempo de ejecución. Para modificar la barra

de progreso habrá casi superpuesto a ella un slider horizontal para modificar el

valor que será mostrado en dicho ProgressBar-->

<ProgressBar Canvas.Left="240" Canvas.Top="-130" Height="26" Name="progressBar1"

Width="254" Foreground="#FF0000FA" />

<Slider Canvas.Left="240" Canvas.Top="-117" Height="30" Name="slider1" Width="256"

ValueChanged="slider1_ValueChanged" />

<!—Imagen representativa al volumen -->

<Image Canvas.Left="108" Source="Img/imagenvolumen.png" Canvas.Top="-130" Height="40"

Name="volumen" Stretch="Fill" Width="59" />

<!—Esta imagen que como viene siendo costumbre será utilizada como botón, será utilizada

para dar inicio a cada ronda, y será bloqueada después de cada pulsación , y será

desbloqueada al completar la serie o al cometer un fallo, dando la posibilidad de

empezar una nueva serie.-->

<Image Canvas.Left="-148" Source="Img/btnJugar.png" Canvas.Top="-130" Height="80"

Name="btnJugar" Stretch="Fill" Width="139" MouseLeftButtonDown="btnJugar_MouseLeftButtonDown" MouseLeftButtonUp="btnJugar_MouseLeftButtonUp_1" TouchDown="btnJugar_TouchDown" TouchUp="btnJugar_TouchUp" />

<!—Esta imagen, que en principio esta oculta, es la que será mostrada cuando se cometa

un fallo o se logre completar la serie de pulsaciones correctamente. En cada caso se

cambiará el origen de datos de la imagen por la imagen más adecuada al caso-->

<Image Canvas.Left="202" Visibility="Hidden" Source="Img/textomuybien.png"

Canvas.Top="-70" Height="49" Name="estado" Stretch="Fill" Width="201" />

<Label Name="lblPuntuacion" Content="Puntuación" Canvas.Left="238" Canvas.Top="258"

FontFamily="Times New Roman" FontSize="20" FontWeight="Bold"

Foreground="#FF1B65D4" />

<!—Se decidió colocar un “TextBlock” para indicar la puntuación actual de la partida, de

forma que cada nivel superado suma a la puntuación actual 5 veces el valor del nivel

en el que se haya encontrado.-->

<TextBlock Name="txtPuntuacion" Text="0" Canvas.Left="358" Canvas.Top="263"

FontFamily="Times New Roman" FontSize="20" FontWeight="Bold" />

<Label Name="lblIntentos" Content="Intentos: " Canvas.Left="238" Canvas.Top="308"

FontFamily="Times New Roman" FontSize="20" FontWeight="Bold" Foreground="#FF1B65D4" />

<!-- Numero de intentos restantes para terminar con el juego. Se empieza con 3 intentos

y se va restando uno cuando se comete un fallo, quitando a la vez una unidad al

nivel.Cuando el número de intentos llega a cero. Se mostrará una ventana -->

<TextBlock Name="txtIntentos" Text="3" Canvas.Left="358" Canvas.Top="313"

FontFamily="Times New Roman" FontSize="20" FontWeight="Bold" />

</Canvas>

</Window>

En el siguiente post de la serie se comentará en detalle las variables de la clase “MainWindow” y se empezará con la definición de las funciones utilizadas de forma que quede todo explicado de la manera más extendida posible.

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

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

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

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

Jhonattan Fiestas — Fri, 26 Aug 2011 09:01:00 GMT

Desde el día martes 25 de Agosto está disponible en el canal “Codeplex” la nueva aplicación multitouch de ejemplo denominada “Simón Dice Renewed”, un pequeño tributo al tradicional juego que fue lanzado en formato electrónico y tuvo gran éxito en los años 80.

La aplicación está disponible en sus versiones:

Desde su salida la luz hace dos días esta aplicación de ejemplo ha sido descargada en más de diez ocasiones en su formato de código fuente, viéndose así la curiosidad de los usuarios por saber un poco más sobre el código “oculto” detrás de este divertido juego, a la vez que queda reflejado como son cada vez más los usuarios que se pasean por el canal buscando las novedades que van siendo publicadas en relación a las tecnologías táctiles.

Precisamente la última versión que es la que se acaba de mencionar es la que se va a necesitar para seguir el análisis del código existente en el proyecto, aunque si lo que necesitáis es ver el funcionamiento del juego creado siempre podréis descargaros dos versiones restantes, recordando que la aplicación ha sido desarrollada para correr tanto en entornos MS Windows tradicionales con teclado y ratón, como en entornos MS Windows 7 Multitouch.

Para empezar con el tan mencionado análisis, podéis mirar el explorador de soluciones y ver la estructura del proyecto.

Como puede verse el proyecto “Simon Dice” contiene dos carpetas “Img” y “Sonidos” las cuales, como se puede intuir, contienen las imágenes que serán usadas en la aplicación y los sonidos que serán reproducidos a lo largo de la ejecución del programa respectivamente.

También incluye clases como “App.xaml”, “MainWindow.xaml”, “Resultado.xaml” que guardan en su código diversas funcionalidades necesarias para completar la ejecución del proyecto. Por último también cabe reseñar la inclusión de una imagen con formato “.ico” que hace referencia al logotipo que usará la aplicación mientras ésta se encuentre en uso.

En la presente entrada se quiere comentar un aspecto relevante pero que sin embargo suele ser pasado por alto por las mayoría de desarrolladores, que es establecer el “Build Action” de un fichero en la opción más adecuada y no dejarla simplemente con el valor que proporciona la configuración que viene por defecto.

Para dar un ejemplo sobre esta idea se utilizarán algunos de los diversos ficheros de los que está compuesto el proyecto “Simón Dice”.

Como puede observarse en la imagen, existen diferentes tipos de acciones de compilación (“Build Action”), que son comunes entre Visual Studio 2008 y Visual Studio 2010, como son las mostradas en el grafico además de estas dos que no han sido reflejadas:

“SplashScreen” que sirve para definir una pantalla de bienvenida, en la aplicación.Para deshabilitarla simplemente se cambia este valor a “None”
“EntityDeploy” que es usada por el ADO.NET Entity Framework.

Además en VS 2010 existen algunas opciones más en la lista desplegable de “Build Action”, como son:

“DesignData” que como su propio nombre dice sirve para definir una plantilla de datos que serán usados en tiempo de diseño.
“DesignDataWithDesignTimeCreatablesTypes” que definen los tipos de datos que pueden crearse en tiempo de diseño de forma similar a “DesignData”. Los datos se pueden crear utilizando los tipos definidos por defecto. Se puede usar esta acción de compilación cuando los datos de los objetos se pueden crear utilizando su constructor implícito vacío.

La propiedad acción de compilación o “Build Action” indica lo que hace Visual Studio con un archivo cuando se realiza una compilación. En esta ocasión se van a definir los valores usados comúnmente por la propiedad “acción de compilación” para que se tenga un mayor conocimiento sobre ellos:

None:

Como su propio nombre dice, no hace nada con el fichero. Siempre que se desee que un fichero no realice ninguna acción se debe colocar

Compile:

Se realiza el compilado del archivo que suelen ser ficheros con código fuente como por ejemplo “.vb”, “.cs” , etc.

Content:

Marcando esta opción el archivo será copiado en la carpeta de compilación del proyecto para ser distribuido con la aplicación, pero solo el contenido más no su código.

Embedded Resource:

Los ficheros normalmente son copiados y distribuidos de manera independiente al ensamblado del proyecto, sin embargo si lo que deseas es incluir este fichero dentro del mismo ensamblado debes cambiar la acción de compilado a “Embedded Resource”.Esto hace que al compilar el proyecto dicho fichero sea embebido dentro del ensamblado resultante (“.dll” o “.exe”)

ApplicationDefinition:

Esta opción se introdujo como nueva en VS2008 y se usa para identificar a los archivos de marcado XAML que contienen la definición de una aplicación WPF, esto es, un archivo XAML cuyo nodo raíz es <Application>. También se puede marcar un archivo “.cs” o “.vb” si la definición de la aplicación se hace directamente por código. Sólo puede haber un archivo en todo el proyecto marcado con esta acción de compilación.

Page:

También nueva y relacionada con WPF. Se usa para marcar archivos XAML de tipo página (normalmente con un archivo “CodeBehind” asociado) cuyo contenido se convierte a formato binario y se compila en un ensamblado. Suelen contener nodos de tipo “Window”, “Page”, “FlowDocument” o “UserControl”.

Resource:

Similar a “Embedded Resource” porque incluye elementos como recursos en un ensamblado pero usado para WPF.

La aclaración sobre los conceptos de “acciones de compilación” ha sido introducida en la publicación de esta serie ya que durante el desarrollo del código de la aplicación surgieron algunas complicaciones con un fichero debido a que su “Build Action” estaba mal configurado. Tomando en cuenta esta circunstancia, se decidió hacer mención sobre ello ya que nunca viene de más aclarar conceptos para futuros desarrollos.

En la siguiente entrada se empezará con el análisis de los aspectos más técnicos de la aplicación como son los controles utilizados, atributos y funciones.

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

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

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

Aplicaciones de ejemplo MS Windows7 Multitouch – “SimonDiceTouch Renewed”

Jhonattan Fiestas — Tue, 23 Aug 2011 15:00:00 GMT

Hace varias semanas se publicó en el canal “codeplex” el último proyecto de ejemplo, denominado “MapaMeterorologicoV1.1” con el fin de averiguar el estado del tiempo en las diferentes provincias españolas utilizando las herramientas que proporciona Visual Studio 2010 , el framework 4.0 de “.Net” y el lenguaje de programación C#.

En esta ocasión, el motivo principal de esta entrada es el anuncio del lanzamiento de una nueva aplicación en el canal, llamada “Simón Dice Touch Renewed”, que sigue la línea de generación de aplicaciones de ejemplo para la programación de dispositivos tablet.

Esta es la sexta aplicación alojada en el canal “Codeplex” y desde el día de hoy se encontrará disponible para su descarga tanto la propia aplicación y su instalador (apartado “Downloads”) así como el código fuente del mismo (apartado SourceCode) junto con las demás aplicaciones de ejemplo desarrolladas hasta el momento:

Con la presente publicación se persigue el único objetivo de impulsar el interés de los programadores en el uso y explotación de herramientas Microsoft para para el desarrollo de aplicaciones para dispositivos táctiles con MS Windows 7 Multitouch.

Este proyecto está basado en el mítico juego "Simón Dice" y que se hizo popular de los años 80 con una versión electrónica donde se tenían que recordar los colores que habían sido pulsados, elevando la dificultad cuando se pulsaba la secuencia completa, añadiendo un elemento nuevo a la secuencia al final de la misma .El juego finalizaba cuando el jugador fallaba al intentar reproducir la secuencia correcta de pulsaciones.

Esta vez el proyecto hace uso de las posibilidades táctiles que ofrece MS Windows7 Multitouch para tener una visión diferente de este juego, ya que en ésta aplicación se le ha querido dar una vuelta de tuerca a la concepción original del juego, es por ello la añadidura de la palabra “Renewed”(al final del nombre de la aplicación).

Ahora la secuencia de pulsaciones siempre será diferente en cada nivel de juego y el número de elementos de la cadena cambiará dependiendo del nivel que se alcance, obligando así al usuario a no recordar una cadena, sino que en cada etapa del juego tendrá que memorizar una secuencia diferente.

Este juego lleva un marcador de puntuaciones y un número de intentos. La puntuación se incrementará cuando se complete una secuencia y se conseguirán más puntos cuanto más alto sea el nivel que se complete. Si el usuario comete un fallo en la secuencia se emitirá un sonido de error, bajándole de nivel y quitándole un intento.
Cuando los intentos restantes lleguen a cero el juego habrá terminado, y se mostrará en pantalla la puntuación final, para posteriormente volver a la pantalla de inicio de la aplicación.

Siguiendo la línea de anteriores proyectos, existen dos botones de salir: uno de ellos dentro de la pantalla de juego con el cual se volverá al inicio de la aplicación, y el segundo en la pantalla de inicio de la aplicación con el cual se conseguirá salir completamente de la aplicación.

Como se puede imaginar este juego no tiene un final concreto, ya que se puede alargar todo lo que la memoria sea capaz de almacenar y posteriormente ser capaz de reproducir la secuencia satisfactoriamente, siendo una aplicación ideal para el desarrollo intelectual de niños y no tan niños.

Como conceptos interesantes en este proyecto se podrían resaltar la manipulación de tiempos de ejecución, el uso de reproductor de sonidos de la librería “WindowsMediaPlayer”, distinción entre un dispositivo táctil y uno que no dispone de dicha tecnología, uso de lienzos para mostrar diferentes capas en cada momento, modificación del volumen del reproductor de sonidos en tiempo de ejecución entre otros...

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales III

Jhonattan Fiestas — Fri, 19 Aug 2011 20:27:00 GMT

En la anterior entrada de la serie, “Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidoAnimales II", se hizo mención de que en esta oportunidad se va a describir el funcionamiento del control de usuario llamado “UserControl1”, utilizado para interactuar con los objetos de la aplicación “SonidosAnimales” ,disponible desde hace ya un tiempo en el canal “codeplex” en sus versiones: ejecutable, instalable y código fuente (Source Code en inglés) para los que deseéis hacer un análisis de él.

Aplicación en ejecución

De los controles de usuario lo primero que hay que resaltar es el uso, una vez más, de las librerías propias de MS Windows7 Multitouch como “Interartivity” e “Interactions”, para el manipulado de dicho control. Además está formado por dos objetos bastante conocidos, como son “Image” y “TextBlock”, ya que se mostrará el nombre del animal por encima de la imagen cuando se pulse sobre este. Para comprender mejor el diseño de “UserControl1”, en las líneas siguientes se mostrará el código XAML de la clase con algunos comentarios adicionales que describirán los motivos por los cuales fueron introducidos en la definición de este control de usuario.

<UserControl x:Class="JuegoSonidosAnimales.UserControl1"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"

xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"

mc:Ignorable="d"

d:DesignHeight="104" d:DesignWidth="200" MouseLeftButtonDown="UserControl1_Click"

MouseLeftButtonUp="UserControl1_MouseUp" Loaded="UserControl_Loaded"

IsManipulationEnabled="True" VisualTextHintingMode="Animated" Visibility="Visible"

TouchDown="UserControl_TouchDown" TouchUp="UserControl_TouchUp">

<!—Se utiliza el Interaction Bahavior para dotar de movimiento al control de usuario-->

<i:Interaction.Behaviors>

<ei:TranslateZoomRotateBehavior ConstrainToParentBounds="True">

</ei:TranslateZoomRotateBehavior>

</i:Interaction.Behaviors>

<!—En este proyecto se definirá el lienzo llamado “canvas1” y con sus respectivas dimensiones-->

<!—Para definir este control de usuario se hará uso de una imagen, y de un bloque de texto que estará colocado exactamente sobre el centro de la imagen del animal-->

<!—Imagen del animal con el que se va a interactuar-->

<Image Canvas.Left="2" Canvas.Top="0" Height="105" Name="image1" Stretch="Fill"

Width="200" Source="/JuegoSonidosAnimales;component/Images/caballo.jpg" Opacity="1">

<Image.Effect>

</Image.Effect>

</Image>

<!—Cuadro de texto para informar sobre el animal que se esta pulsando-->

<TextBlock Canvas.Left="58" Canvas.Top="37" Name="textBlock1" Text="TextBlock"

Visibility="Hidden" FontWeight="Black" FontSize="24" FontStretch="Normal"

Foreground="#FF23D756" Background="#83000000" VerticalAlignment="Center"

HorizontalAlignment="Center" />

</Canvas>

</UserControl>

El control de usuario tendrá este aspecto cuando se pulse sobre la imagen de un animal.

Ahora que ya ha quedado bien definido el diseño del control de usuario, se procederá a ver el funcionamiento interno de cada una de las acciones que puede realizar dicho control, y para ello, como viene siendo habitual, se mostrará el esquema de la clase que lo describe.

En el siguiente cuadro se puede ver cada uno de los elementos de la clase y el tipo al que corresponde, así mismo se aprecia el modificador del que dispone en esta aplicación.

Para completar la descripción del proyecto, se analizara uno a uno cada uno de ellos.

Campos

· Handle:

Este campo fue descrito en la anterior entrada, ya que también forma parte de la clase “MainWindow” .En “UserControl1” cumple con la misma función, que es servir como parámetro usado por referencia a la hora de hacer una llamada a la función “midiOutOpen”.

· Imagen

Esta variable recogerá la dirección en donde estará ubicado la imagen del animal que será mostrado.

· Sonido

De manera análoga a la anterior, aquí se guardará la dirección donde se encuentra físicamente el archivo de sonido que corresponde con el animal sobre el que se ha pulsado

· Player

Esta variable será un objeto de la clase “WindowsMediaPlayer” que servirá como medio de reproducción de los sonidos que se van a emitir.Para ello es necesario importar la referencia a la Liberia “WMPLib”.

WMPLib.WindowsMediaPlayer Player;

Funciones o métodos:

· 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);

· UserControl_Loaded

Esta función se desencadena con solo iniciar la aplicación, y su cometido es inicializar o crear objetos en tiempo de ejecución, como en este caso, que se encargará de crear una instancia de la clase “WindowsMediaPlayer”.

private void UserControl_Loaded(object sender, EventArgs e) {

Player = new WindowsMediaPlayer();

}

· UserControl_TouchDown y UserControl1_Click

Ambas funciones son completamente iguales en su código, con la diferencia que se llamará a una u otra según la forma con la que se accede a estos controles. Si se hace mediante el ratón de un equipo convencional, se desencadenará el evento “Click” por lo cual se ejecutará la función “UserControl1_Click” que ha sido asociado previamente a este evento. Si por el contrario se accede mediante pulsaciones sobre la pantalla, se desencadenará el evento “TouchDown”, y de igual manera se ejecutará su método relacionado llamado “UserControl_TouchDown”.

Ahora se procederá a describir línea a línea el código que implementa.

void UserControl1_Click(object sender, MouseButtonEventArgs e)

{

// Se oculta el bloque de texto

this.textBlock1.Visibility = System.Windows.Visibility.Visible;

// Se crea un nuevo objeto de Windows Media Player

Player = new WindowsMediaPlayer();

// Se establece la ruta donde está ubicado el sonido a reproducirse

string r = System.IO.Directory.GetCurrentDirectory();

r = r+ this.sonido;

string ruta = r;

// Se le da la ruta del archivo de sonido al reproductor

Player.URL = @ruta;

// Se ejecuta el reproductor, que utilizara la ruta URL para reproducir el sonido

Player.controls.play();

DropShadowEffect myDropShadowEffect = new DropShadowEffect();

// Se establece el color a negro.

Color myShadowColor = new Color();

myShadowColor.A = 255;

myShadowColor.B = 0;

myShadowColor.G = 0;

myShadowColor.R = 0;

myDropShadowEffect.Color = myShadowColor;

//Establece la dirección en grados hacia donde ira dirigida la sombra

myDropShadowEffect.Direction = 320;

// Establece la profundidad de la sombra

myDropShadowEffect.ShadowDepth = 0;

// Establece la suavidad de la sombra.

myDropShadowEffect.BlurRadius = 6;

// Establece el grado de opacidad o transparencia.

// El rango es de 0 a 1

myDropShadowEffect.Opacity = 0.2;

this.image1.Effect = myDropShadowEffect;

}

· UserControl_TouchUp y UserControl1_MouseUp

Cuando se deje de pulsar sobre el control de usuario se desencadenará el evento “TouchUp” o “MouseUp”, por lo cual se desencadenarían las funciones “UserControl_TouchUp” y “UserControl1_MouseUp” respectivamente.

Véase la descripción del código para solventar cualquier duda asociada.

private void UserControl1_MouseUp(object sender, MouseButtonEventArgs e)

{

DropShadowEffect myDropShadowEffect = new DropShadowEffect();

// Se oculta el cuadro de texto.

this.textBlock1.Visibility = System.Windows.Visibility.Hidden;

Color myShadowColor = new Color();

//Recordad que la imagen está formada por la combinación de un factor Alfa, y los

colores Azul(Blue), Verde (Green) , y Rojo (Red)

myShadowColor.A = 0;

myShadowColor.B = 50;

myShadowColor.G = 50;

myShadowColor.R =50;

myDropShadowEffect.Color = myShadowColor;

//Establece la dirección en grados hacia donde ira dirigida la sombra

myDropShadowEffect.Direction = 320;

// Establece la profundidad de la sombra

myDropShadowEffect.ShadowDepth = 12;

// Establece la suavidad de la sombra.

myDropShadowEffect.BlurRadius = 6;

// Establece el grado de opacidad o transparencia.

// El rango es de 0 a 1

myDropShadowEffect.Opacity = 0.9;

this.image1.Effect = myDropShadowEffect;

if (Player.playState == WMPPlayState.wmppsPlaying)

Player.controls.stop();

}

· Constructor : “UserControl1”

Aquí el constructor de la clase, que recibe como parámetros una cadena que determina la ubicación de la foto que se va a mostrar, el sonido que se emitirá al pulsar sobre la imagen, y el nombre que será superpuesto a la figura del animal.

public UserControl1(string fotoi, string sonidoi,string nombre)

{

InitializeComponent();

this.image1.Source = new BitmapImage(new Uri(@fotoi));

this.sonido = sonidoi;

this.textBlock1.Text = nombre;

}

Con el presente post se daría por finalizado la descripción minuciosa del código en lo que al proyecto “SonidoAnimales” se refiere. Adelantando que para la próxima semana estará disponible en el canal “codeplex” una nueva aplicación de ejemplo en la línea de desarrollo que se ha venido proponiendo a lo largo de estas semanas. Esperando que sea del agrado de todos, y muy en especial de los nuevos desarrolladores que verán una vez más a lo largo del nuevo proyecto las bondades que proporciona la programación con MS Windows 7 Multitouch.

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

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales I

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales II

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales III

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

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales II

Jhonattan Fiestas — Wed, 17 Aug 2011 17:35:00 GMT

Como se venía anunciando en la anterior entrada de la serie “Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales I”, en esta ocasión se intentará desarrollar por completo el código que describe el funcionamiento de la aplicación “SonidoAnimales”, en concreto se analizará el código que se encuentra en la clase “MainWindow”, dejando para el siguiente post la descripción minuciosa de los controles de usuario que componen esta aplicación.

La clase “MainWindow” podría ser considerada el alma de la aplicación, ya que en ella se encuentra la base para la ejecución del proyecto y desde allí se hace llamada a las demás clases que complementarían de funcionalidades a las características que disponga “MainWindow”.Para obtener una idea global de la clase mencionada, en el siguiente grafico se muestran los campos y métodos que implementa, para posteriormente definirlos uno a uno de la forma más detallada posible.

Campo “handle”:

El campo “handle” es un número entero que será utilizado como referencia a la hora de hacer una llamada a la función “midiOutOpen” que será descrita una vez más en esta entrada.

Métodos o funciones:

· 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);

· Window_Loaded:

Función con finalidad similar al método “Form_load” de un proyecto “.Net”, y es donde se podrían inicializar varios de los campos necesarios para el inicio de la aplicación. En este proyecto, el “Window_Loaded” estará vacío ya que los campos que serán inicializados lo serán directamente desde el constructor de la clase.

· MainWindow

Es el constructor de la clase y en esta oportunidad la clase “MainWindow” solo dispone de un constructor implícito en el cual se van a inicializar los valores que se consideren necesarios.

Como una pequeña aclaración se dirá que cuando se haga alusión a “image1” se estará haciendo referencia a la imagen que es utilizada para generar el evento de “TouchDown”, con el cual se inicia el juego.

Se procederá a ver el código del constructor línea a línea describiendo, en forma de comentario, cada acción que se realice.

public MainWindow()

{

InitializeComponent();

// Al iniciar la ejecución solo es visible el lienzo “inicio” por lo tanto

// el lienzo “juego”debe estar oculto

juego.Visibility = System.Windows.Visibility.Hidden;

// Se genera un ImageBrush para ser utilizado como fondo del lienzo principal

ImageBrush imgBrush = new ImageBrush();

imgBrush.ImageSource = new BitmapImage(

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

component/Images/FondoSonidosAnimales.png"));

// El “botonRepetir” debe está oculto también, ya que solo debe estar

// visible cuando el lienzo “juego” este visible.

this.BotonRepetir.Visibility = System.Windows.Visibility.Hidden;

// Se establece la localización del “botonSalir” dentro del lienzo

this.botonSalir.SetValue(Canvas.TopProperty,

(SystemParameters.FullPrimaryScreenHeight / 2) + 123);

this.botonSalir.SetValue(Canvas.LeftProperty,

(SystemParameters.FullPrimaryScreenWidth / 2) - 45);

// Se igual manera con el “image1”.

this.image1.SetValue(Canvas.TopProperty,

(SystemParameters.FullPrimaryScreenHeight / 2) - 83);

this.image1.SetValue(Canvas.LeftProperty,

(SystemParameters.FullPrimaryScreenWidth / 2) - 160);

// Se cambia el fondo del lienzo principal

this.Padre.Background = imgBrush;

}

· BotonRepetir_TouchDown:

Este método es llamado cuando se desencadena el evento relacionado a pulsar sobre el “botonRepetir”, y su finalidad es volver a pintar el lienzo de juego, lo cual originará que se coloquen seis nuevos animales aleatorios.

private void BotonRepetir_TouchDown(object sender, TouchEventArgs e)

{

pintarjuego();

}

· botonSalir_TouchDown:

Esta función se ejecutará cuando el usuario pulse sobre el “botonSalir” que se encuentra situado en el lienzo “Inicio”, ocasionando el cierre por completo de la aplicación.

private void botonSalir_TouchDown(object sender, TouchEventArgs e)

{

this.Close();

}

· botonSalirjuego_TouchDown:

Esta función difiere de la anterior sobre todo por lo que uno entiende por “salir”.

En este caso cuando se hace referencia a la palabra “Salir” se está hablando de salir del lienzo “juego” y volver al lienzo de “inicio”.

Si lo que se desea es salir completamente de la aplicación, se puede dar a salir al botón correspondiente dentro del lienzo “inicio”.

El código que hay por detrás de este método es fácilmente interpretable, y será descrito como se ha hecho con anterioridad por medio de comentarios en dicho código.

private void botonSalirjuego_TouchDown(object sender, TouchEventArgs e)

{

// Se ocultan los botones que se mostraban en el lienzo “juego”

botonSalirjuego.Visibility = System.Windows.Visibility.Hidden;

this.BotonRepetir.Visibility = System.Windows.Visibility.Hidden;

// Se oculta el lienzo de juego, ya que se desea volver al de inicio

this.juego.Visibility = System.Windows.Visibility.Hidden;

// Se vuelve a hacer visible el lienzo de inicio

this.Inicio.Visibility = System.Windows.Visibility.Visible;

// y se vuelven a hacer visibles los botones propios de dicho lienzo.

this.image1.Visibility = System.Windows.Visibility.Visible;

this.botonSalir.Visibility = System.Windows.Visibility.Visible;

// Por último se cambia el fondo del panel padre.

ImageBrush imgBrush = new ImageBrush();

imgBrush.ImageSource = new BitmapImage(new

Uri(@"pack://application:,,,/JuegoSonidosAnimales;

component/Images/FondoSonidosAnimales.png"));

this.Padre.Background = imgBrush;

}

· image1_TouchDown:

Este botón corresponde con , por lo tanto al pulsar sobre él se desencadena el evento “Click” que llamara a este método, como puede verse en el código, hará una llamada al método “pintarJuego”, reiniciándose el juego con seis nuevos animales cogidos de manera aleatoria.

private void image1_TouchDown(object sender, TouchEventArgs e)

{

pintarjuego();

}

· pintarJuego:

Esta es la función principal de la clase “MainWindow” que se encargará de eliminar todos los controles que se encuentren dentro del lienzo de juego, colocando seis nuevos en cada ocasión valiéndose de números aleatorios, con los cual podrían salir seis animales de los catorce posibles. Todo esto se realizara en tiempo de ejecución.

En el código esta descrito todas las acciones paso a paso, para que no quede duda de la funcionalidad de este método.

public void pintarjuego()

{

// Se establecen una variable nodos, que corresponde con el número de

// animales que se encuentran contenidos en el fichero “configuración.xml”

int nodos=14;

// Se oculta todo lo relacionado con el lienzo de inicio

Inicio.Visibility = System.Windows.Visibility.Hidden;

this.image1.Visibility = System.Windows.Visibility.Hidden;

this.botonSalir.Visibility = System.Windows.Visibility.Hidden;

// Se muestra todo lo relacionado con el lienzo “juego”

juego.Visibility = System.Windows.Visibility.Visible;

botonSalirjuego.Visibility = System.Windows.Visibility.Visible;

this.BotonRepetir.Visibility = System.Windows.Visibility.Visible;

botonSalirjuego.SetValue(Canvas.LeftProperty,

SystemParameters.FullPrimaryScreenWidth - 120);

int numerohijos = juego.Children.Count; // Número de controles que “juego”

// Se buscará, si existen, controles de usuario en el lienzo, y si es así

// se añaden a una lista, para posteriormente preguntar por su ubicación

// dentro de la lista de controles y posteriormente eliminarlos, para que

// en la próxima carga hayan controles completamente nuevos.

int posicionEliminar = 0;

List<UIElement> controlespropios = new List<UIElement>();

foreach (UIElement hijo in juego.Children)

if (hijo.GetType().Name == "UserControl1")

{

controlespropios.Add(hijo);

}

foreach (UIElement hijo2 in controlespropios)

{

//Aquí se elimina un control en tiempo de ejecución.

posicionEliminar = juego.Children.IndexOf(hijo2);

juego.Children.RemoveAt(posicionEliminar);

}

// Se genera una imagen para posteriormente cambiar el fondo del lienzo “padre”

ImageBrush imgBrush = new ImageBrush();

imgBrush.ImageSource = new BitmapImage(new

Uri(@"pack://application:,,,/JuegoSonidosAnimales;

component/Images/fondo_rojo.jpg"));

// Se carga en cconfig el conjunto de animales que se encuentran en el

// fichero configuración.xml que se encuentra en la raíz de la

// aplicación. Si se desease coger el fichero del mismo nombre que se

// encuentra en la carpeta “config”, bastaría con cambiar

// XElement.Load("configuracion.xml") por XElement.Load("config/configuracion.xml")

int i = 0;

var cconfig = from c in XElement.Load("configuracion.xml").Elements("animal")

select c;

// Se genera una lista de números aleatorios.

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

Random numero = new Random();

int uno = numero.Next(nodos);

numeros.Add(uno); //El primero ingresa directamente

//Los siguientes entrarán a la lista solo si no son iguales a los anteriores.

int dos = numero.Next(nodos);

while (dos == uno)

dos = numero.Next(nodos);

numeros.Add(dos);

int tres = numero.Next(nodos);

while ((tres == uno) || (tres == dos))

tres = numero.Next(nodos);

numeros.Add(tres);

int cuatro = numero.Next(nodos);

while ((cuatro == uno) || (cuatro == dos) || (cuatro == tres))

cuatro = numero.Next(nodos);

numeros.Add(cuatro);

int cinco = numero.Next(nodos);

while ((cinco == uno) || (cinco == dos) || (cinco == tres) || (cinco==cuatro))

cinco = numero.Next(nodos);

numeros.Add(cinco);

int seis = numero.Next(nodos);

while ((seis == uno)||(seis == dos)||(seis == tres)||(seis==cuatro)||(seis==cinco) )

seis = numero.Next(nodos);

numeros.Add(seis);

// Casi para terminar, por cada elemento que haya en la lista “números”, se

// hace una búsqueda en el objeto “cconfig”, y de allí se crea un control

// de usuario en que será insertado en el lienzo en tiempo de ejecución

foreach (int pos in numeros)

{

var cadena = cconfig.ElementAt(pos);

string foto = cadena.Element("foto").Value;

string sonido = cadena.Element("sonido").Value;

string nombre = cadena.Element("nombre").Value;

//Se crea un control de usuario con los parámetros recogidos anteriormente

UserControl1 u2 = new UserControl1(foto, sonido, nombre);

u2.SetValue(Canvas.LeftProperty, 30.0 + (i % 600));

u2.SetValue(Canvas.TopProperty, 150.0 * (i / 600));

i = 300 + i;

// Y se inserta en el lienzo de juego en tiempo de ejecución

juego.Children.Add(u2);

}

// Para finalizar se cambia la imagen de fondo del lienzo “padre”.

this.Padre.Background = imgBrush;

}

Como ya se ha adelantado, en la próxima entrada se hará estudio de los controles de usuario creados en esta aplicación, de forma que quede visible la extensa lista de posibilidades que ofrece a los desarrolladores.

Si deseas continuar informado sobre las publicaciones de desarrollo, seguridad y novedades en torno a las tecnologías Microsoft no dudes en suscribirte al canal de RSS de Windows Técnico .

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

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales I

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales II

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales III

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

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales I

Jhonattan Fiestas — Sun, 14 Aug 2011 12:06:00 GMT

Son varias las publicaciones realizadas sobre desarrollo de aplicaciones con MS Windows 7 Multitouch, y para no perder las buenas costumbres en esta ocasión se va a descifrar el código que describe las funcionalidades del proyecto “SonidosAnimales” disponible en el canal Codeplex y cuya referencia ya se hizo en la entrada denominada “Aplicaciones ejemplo para Windows 7 Multitouch: SonidosAnimales”

Esta aplicación ha sido desarrollada esencialmente para ser ejecutada en dispositivos móviles con sistema operativo Windows Phone 7, sin embargo es soportada perfectamente por un Tablet MS Windows 7 Multitouch.

El público hacia el cual fue orientado esta aplicación, fue principalmente a niños que estuvieran familiarizándose con las figuras los animales, sus nombres y enlazándolos con los sonidos que emiten cada uno de ellos, de forma que se les facilitara a los padres la tarea didáctica bajo un concepto de interacción con las figuras a través del lienzo de juego.

Para seguir en la línea de explicación de código, se procederá a explicar en tres entradas el funcionamiento en general de dicha aplicación, de forma que os hagáis con conceptos claros por si os encamináis en la vía del desarrollo para este tipo de dispositivos.

Lo primero que se va a ver es el árbol del proyecto en general:

figura1

Carpetas de la aplicación:

· Config: Aquí se guarda el fichero XML llamado “configuración.xml” que es donde se guarda las rutas a las demás imágenes y sonidos.

· Images: Aquí se guardan físicamente las imágenes que se mostraran en la aplicación.

· Sonido: De igual forma aquí se guardan físicamente los archivos de audio en .mp3 que son relacionados con los animales con los que se está interactuando.

Como ya se ha explicado con anterioridad “App.xaml” es la clase de WPF (Windows Presentation Fundation) con la que se inicia la ejecución de la aplicación, como lo haría la clase “Program.cs” en una aplicación de escritorio en “C#.Net”.

Después de la clase “App.xaml”, la clase principal de la aplicación es “MainWindow.xaml” donde se hará llamado a las demás clases para realizar las acciones que se consideren oportunas.

El código XAML, que es similar al código HTML de un proyecto “Asp.Net”, de la clase “MainWindow” es el siguiente y se intentará describir con detalle para que conozcáis de que estructuras y objetos está compuesto.

A diferencia de la serie anterior, “Análisis de código de aplicaciones ejemplo MS Windows 7 Multitouch: Puzzle Animales”, en este proyecto se introduce un concepto nuevo que es el “DockPanel”.Este control define un área en la que se pueden organizar horizontalmente o verticalmente los elementos secundarios, uno respecto al otro.
Después de dicho esto, se procederá a visualizar el código XAML, y se harán comentarios en dicho código para describirlo mejor.

<DockPanel>

<!—En DockPanel.Resources se establece el diccionario de recursos definido localmente-->

<DockPanel.Resources>

<my:HalfValueConverter x:Key="HalfValue" />

<my:HalfValueConverterMasAlto x:Key="HalfValueConverterMasAlto"/>

</DockPanel.Resources>

<!--El botón denominado image1 es el botón de jugar, con el cual se mostrara

el lienzo de juego y se hará invisible los botones “botonSalir” y

“BotonRepetir” -->

<Image MouseLeftButtonDown="button1_Click" Name="image1" Stretch= "Fill"

Source="/JuegoSonidosAnimales;component/Images/BotonJugar2.png"

ForceCursor="True" VerticalAlignment="Center"

HorizontalAlignment="Center"/>

<!—el siguiente botón sirve para salir definitivamente de la aplicación-->

<Image Name="botonSalir"

Source="/JuegoSonidosAnimales;component/Images/botonSalirNormal.png"

MouseLeftButtonDown="botonSalir_MouseLeftButtonDown"/>

<!—A continuación el próximo botón, que es genérico para toda el lienzo padre,

a pesar de que se coloquen lienzos encima, sirve para repetir el juego, y

que cada vez aparezcan nuevos animales en la interfaz-->

<Image Name="BotonRepetir" MouseLeftButtonDown="BotonRepetir_MouseLeftButtonDown"

Source="/JuegoSonidosAnimales;component/Images/botonrepetirencendido.png"

VerticalAlignment="Top" HorizontalAlignment="Center" Margin="0,12,0,0">

<Canvas.Left>

<!— MultiBinding describe una colección de orígenes de datos asociados

a una sola propiedad de destino de enlace. -->

</MultiBinding>

</Canvas.Left>

</Image>

<!--Primer lienzo que puede ser visible o no. De imagen fondo de modo

ilustrativo tiene puesto la foto “vectoranimalssimpaticos.png -->

<Canvas.Background>

<ImageBrush

ImageSource="/JuegoSonidosAnimales;component/Images/vectoranimal

ssimpaticos.png" />

</Canvas.Background>

</Canvas>

<Canvas.Left>

</MultiBinding>

</Canvas.Left>

<Canvas.Top>

</MultiBinding>

</Canvas.Top>

<Canvas.Background>

</Canvas.Background>

</Canvas>

<!—Botón que tiene la función similar a la anterior de nombre parecido pero la

gran diferencia es que este botón cierra la ejecución de la aplicación-->

<Image Name="botonSalirjuego" Visibility="Hidden"

Source="/JuegoSonidosAnimales;component/Images/botonSalirNormal.png"

MouseLeftButtonDown="botonSalirjuego_MouseLeftButtonDown"

VerticalAlignment="Top" HorizontalAlignment="Right" />

</Canvas>

</DockPanel>

Como se puede ver, se está haciendo uso del recurso “HalfValueConverter” y “HalfValueConverterMasAlto”, por lo cual dichas clases deberían ser definidas en algún lugar de la aplicación.La localización actual, de estas dos clases, es dentro del fichero “MainWindow.xaml.cs” compartiendo el espacio de nombres con la clase “MainWindow”.

La clase “HalfValueConverter” y “HalfValueConverterMasAlto” devolverá el convertidor que se va a utilizar para convertir los valores de origen en el valor de destino o viceversa, pero en esta ocasión se va a dejar sin implementar el método “ConvertBack”, ya que no se hará uso de él.

Véase el código de ambas clases para ver lo que hace internamente estas clases.

public class HalfValueConverter : IMultiValueConverter

{

// El método “Convert”, como se podría imaginar, convierte los valores de origen en

// un valor del destino de enlace. El motor del enlace de datos llama a este método

// cuando se propagan los valores de los enlaces de origen al destino de enlace.

public object Convert(object[] values,Type targetType,

object parameter,CultureInfo culture){

// Si el array “values” es nulo o solo tiene un elemento. Se lanzará una

// excepción.

if (values == null || values.Length < 2)

{

throw new ArgumentException(

"HalfValueConverter expects 2 double values to be passed" +

" in this order -> totalWidth, width",

"values");

}

double totalWidth = (double)values[0];

double width = (double)values[1] + totalWidth / 3;

// Si el array “values” contiene 3 elementos en la colección se entra a la

// sentencia de control if, y se ejecuta el return, haciendo el resto de

// código inalcanzable.

if (values.Length == 3)

return (object)((totalWidth / 6) * System.Convert.ToDouble(values[2]));

// De similar forma, si el ancho total no es suficiente, se retornara un cero.

if ((totalWidth - (width + 250)) < 0)

return (object)0;

// En caso que ninguna de las condiciones anteriores se cumpla, el método

// “Convert” devolverá el resultado de la siguiente operación matemática para

// determinar un ancho.

return (object)(((totalWidth - (width + 250)) / 2));

}

// Esta función no ha sido implementada porque no será usada en el proyecto,

// pero su funcionalidad es similar a la anterior, ya que convierte los

// valores de destino en un valor del origen de enlace.

public object[] ConvertBack(object value,Type[] targetTypes,

object parameter,CultureInfo culture){

throw new NotImplementedException();

}

La clase “HalfValueConverterMasAlto” es prácticamente igual a la clase “HalfValueConvert”, con la diferencia que el valor devuelto es siempre más alto que la función anterior .Dicha diferencia radica en el siguiente trozo de código:

double totalWidth = (double)values[0];

double width = (double)values[1];

if (values.Length == 3)

return (object)((totalWidth / 6) * System.Convert.ToDouble(values[2]));

return (object)(((totalWidth - (width + 40)) / 2));

En la presente entrada se ha dado una visión general del proyecto “SonidosAnimales” como vía introductoria a todo lo que lleva consigo la aplicación. En el siguiente post de la serie se detallarán las funciones y variables que se encuentran dentro de la clase “MainWindow”, destacándose la forma de agregar y eliminar los controles de usuario en tiempo de ejecución.

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

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales I

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales II

Desarrollo de aplicaciones MS Windows 7 Multitouch: SonidosAnimales III

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