Archive | November 2014

Programación orientada a objetos con ECMAScript 6: Clases

Hasta ahora en JavaScript si uno quería programar orientado a objeto lo que tenía que hacer es aprovecharse de la herencia de prototipos que posee JS para poder crear las "clases", esto tenía siempre una sintaxis similar a esta:

Código :

function Persona(nombre, edad) {
  this.nombre = nombre;
  this.edad   = edad;
}
Persona.prototype.presentarse = function() {
  return 'Hola me llamo ' + this.nombre + ' y tengo ' + this.edad + ' años';
}

var Sergio = new Persona('Sergio', 22);
Sergio.presentarse(); // 'Hola me llamo Sergio y tengo 22 años'

Una pequeña variación podía ser definir la función presentarse dentro de Persona usando:

Código :

function Persona(nombre, edad) {
  this.nombre = nombre;
  this.edad   = edad;

  this.presentarse = function () {
    return 'Hola me llamo ' + this.nombre + ' y tengo ' + this.edad + ' años';
  }
}

Esta fue siempre la forma de hacer POO en JS y aunque los prototipos de JS son muy poderoso para los programadores que vienen de lenguajes orientados a objetos como Java o PHP les resulta extraña ya que no son propiamente objetos, o al menos no como el resto de lenguajes considera los objetos.


Nota: El soporte para clases de ECMAScript 6 en los navegadores actualmente es nulo, esto está todavía en desarrollo y no está listo para ser usado, hay sin embargo formas de escribir código usando ES6 y luego convertir el código a ES5 quedando un resultado bastante bueno, pero no es un soporte nativo, sigue siendo ES5.

Nueva sintaxis

Para facilitar esto en ECMAScript 6 se va a agregar una forma de crear estas clases, como en los demás lenguajes, aunque al final esta nueva sintaxis para hacer POO es simplemente una capa sobre la sintaxis actual mediante prototipos, solo que más simple de entender.

En la nueva sintaxis, si quisieramos hacer el mismo ejemplo de antes haríamos:

Código :

class Persona {
  // constructor donde definir las variables que se reciben y guardarlas en el objeto usando this
  constructor(nombre, edad) {
    this.nombre = nombre;
    this.edad   = edad;
  }

  // método para presentarse
  presentarse() {
    return 'Hola me llamo ' + this.nombre + ' y tengo ' + this.edad + ' años';
  }
}

var Sergio = new Persona('Sergio', 22);
Sergio.presentarse();

Cómo se puede ver, la sintaxis es mucho más similar a la de otros lenguajes (teniendo un constructor y métodos). Esto sin embargo es, como dije antes, una capa por encima del método actual, por esa razón al momento de instancia la clase el resto de la sintaxis es igual.

Extender clases

Al igual que en otros lenguajes de programación, una clase puede extender otra clase heredando métodos o propiedades de la clase padre. Siguiendo el ejemplo anterior, vamos a extender la clase Persona:

Código :

class Desarrollador extends Persona {
  constructor(nombre, edad, cargo) {
    super(nombre, edad);
    this.cargo = cargo;
  }

  presentarse() {
    return super.presentarse() + ' y soy desarrollador ' + this.cargo;
  }
}

var Sergio = new Desarrollador('Sergio', 22, 'Frontend');
Sergio.presentarse(); // 'Hola me llamo Sergio y tengo 22 años y soy desarrollador Frontend'

Como se puede ver la sintaxis es: indicar el nombre de la nueva clase y que extiende a otra clase. Luego si se desea extender algún método ya existente como el constructor se reciben los mismo parámetros que en la clase padre más los nuevos y luego se usa la función super().

La función super() ejecuta el método con el mismo nombre desde el que se está llando a super(), de esta forma al definir el nuevo constructor llamamos a super() y le pasamos los mismos parámetros que recibe el constructor de Persona, entonces se ejecuta ese constructor y luego código del nuevo.

En el caso del método presentarse use super.presentarse(), esto lo que hace es ejecutar el método presentarse de la clase padre, en este caso sería lo mismo que hacer simplemente super(), pero si hubiese otro método con otro nombre que queremos ejecutar usar super.metodo() nos permite llamar a un método de la clase padre desde cualquier otro método de la nueva clase.

Getters y Setters

En algunos lenguajes de programación (como Java) existen los getters y setters, que son lo que se llama mutator method, estos métodos que se usan para controlar variables internas de un objeto (propiedades). Para usarlos simplemente se agrega get o set delante del nombre del método de la siguiente forma:

Código :

class Persona {
  constructor(nombre, edad) {
    this.nombre = nombre;
    this.edad   = edad;
  }

  get verNombre() {
    return this.nombre;
  }
  set nuevoNombre(nuevo) {
    this.nombre = nuevo;
  }
}
var Sergio = new Persona('Sergio', 22);
Sergio.verNombre; // devuelve Sergio
Sergio.nuevoNombre('Daniel'); // cambia el valor de nombre a Daniel
Sergio.verNombre; // devuelve Daniel

Como se puede ver es bastante simple, definir un método get con el nombre que quieras (no puede ser el nombre de la propiedad) y este debería devolver el valor deseado (tecnicamente puede hacer cualquier cosa el método), ó definis un método set con otro nombre (tampoco el mismo de la propiedad) y que recibe el nuevo valor y lo asigna a this (también puede hacer cualquier cosa en realidad, esto es útil para poder validar el nuevo valor).

Aunque esto hace bastante más legible y limpio el código al tener métodos específicos para obtener o modificar propiedades del objeto la verdad es que no son necesarios ya que simplemente usando la sintaxis de objetos de toda la vida podes obtener el valor de una propiedad y modificarlo.

Código :

Sergio.nombre = 'Sergio'; // cambia el valor de nombre a 'Sergio'
Sergio.nombre; // Devuelve 'Sergio'

Características

Los nombres de las clase no pueden ser *eval* ó *arguments*; no están permitidos nombres de clase repetidos, el nombre *constructor* solo puede ser usado para métodos, no para getters, setter o un generador de métodos (otro características de ES6, quizá para otro tutorial).

Las clases no se pueden llamar antes de definirse.

Código :

new Persona(); // runtime error
class Persona {};

Aunque esto no debería ser un problema, todavía se puede instanciar la clase desde cualquier parte, solo es necesario esperar a que esté definida.

Si no hay método constructor, entonces el método por defecto va a ser:

Código :

constructor(arg1, arg2...) {
  super(arg1, arg2...);
}

Conclusión

Aunque la forma actual de realizar POO usando prototype es muy poderosa esta nueva forma va a traer varios beneficios ya sea que termine siendo más fácil para los principiantes, hacer que crear una subclase sea más fácil tanto para principantes como para expertos o hacer código más portable entre frameworks facilitando la reutilizaciónd e código.

De todas formas, al final sigue siendo la clásica forma de crear objetos debajo de toda la nueva sintaxis.

Referencias (en inglés)

Enviar comentario

via Cristalab http://ift.tt/1t5oCn6

Interstellar es la película más importante de la ciencia moderna

El espacio es muy importante. No es una opinión popular incluso entre geeks. En Mejorando.la LIVE hemos hablado de empresas comerciales reales de exploración espacial. A nuestra audiencia geek, techie, gamer.

Y aún así, al hablar de SpaceX o de Virgin Galactic, escuchas cosas como "que aburrido, eso es ficción".

Es muy importante que todos entiendan, se inspiren y amen el espacio. De su exploración viene lo mejor de las telecomunicaciones, el GPS, el futuro enérgetico del mundo, la investigación de calentamiento global, avances en agricultura sostenible, mejoras en materiales, construcción, medicina e ingeniería.

Quedarnos atrapados en nuestra atmósfera limita nuestro avance como especie

Afortunadamente, no está ocurriendo. Gracias a la NASA. A ESA. A China. A Cosmos, Gravity y a Interstellar.

Tenemos una Estación Espacial Internacional en la órbita baja. Por años, humanos han vivido sin parar en una estructura más grande que un estadio de fútbol. Allá arriba, ahora mismo. Flotando y aprendiendo a vivir lejos de nuestro planeta.

China [url=http://ift.tt/SneRPK’e_3]envió drones[/url] de ida y vuelta a la luna. ESA aterrizó una [url=http://ift.tt/1zSlBOe en un cometa[/url] del tamaño de Madrid. Una flota de satélites y robots viven en Marte, preparando el camino para que colonicemos. No es ciencia ficción, es historia pasada.

SpaceX fabrica cohetes y naves comerciales, a una fracción del costo de la NASA. Creando el camino para que la conquista del próximo planeta sea una iniciativa privada, con humanos a bordo.


Virgin Galactic quiere hacer barata la subórbita. Llevar turistas al borde del espacio. Sí, hay problemas, pero no los suficientes para echarse para atrás. Su Spaceship Two, quizás, los lleve a ustedes y mi a tocar el espacio por primera vez.

El éxito comercial de Gravity y de la nueva serie Cosmos demostró que el espacio y la ciencia nos interesa. Que la chispa que inspira a niñas y niños a ser ingenieros y exploradores siempre se puede avivir.

Estos esfuerzos son los que Interestelar representa

Interstellar es una película llena de conceptos difíciles, pero reales. La dilación del tiempo existe. La relatividad especial existe. Los agujeros negros y de gusano existen. Una nave como Endurance es posible, quizás en unas decadas, sin duda en nuestra esperanza de vida.

En nuestro mundo real podemos enfríar una persona (no congelar) y ponerla en coma controlado cuando está muy enferma. Controlando sus sintomas y dandole la oportunidad de sobrevivir.

La dilación del tiempo por la gravedad de la tierra y la velocidad en órbita es un problema al programar satélites GPS. Google Maps funciona porque una ecuación matemática calcula ese desfase.

En nuestro mundo real hemos llegado a la luna. Tenemos robots en Marte y en un cometa. Tenemos satelites desde Venus hasta Saturno. Y pronto más allá.

El sistema de acoplaje del Endurance de Interstellar se parece al de nuestra Estación Espacial Internacional, con los transbordadores y capsulas Soyuz y Dragon.

Siri y Google Now empiezan a reaccionar como a futuro lo harán TARS, CASE y KIPP (OK, no KIPP).


Y lo malo también es verdad. Una importante fracción de nuestra humanidad, en ocasiones gente inteligente, niega el alunizaje. Niega que las misiones Apollo fueron exitosas. Algo interno y oscuro de nuestra especie niega una de las más importantes exploraciones de nuestra era. La que nos trajo nuevos materiales y maquinas médicas que, seguro, han salvado la vida de nuestros padres, hermanos y amigos.

Y spoilers suaves de Interestelar

Sí, hay un mensaje de "amor" en la película. Y sí, la gravedad que "supera" el espacio-tiempo es debatible. Sí, fue idiota aterrizar en el planeta de las olas. Sí, es poco probable que la rotación en "esa" escena fuera tan uniforme y el centro de masas se mantuviera.

Pero ese no es el mensaje. Es el vehículo de una buena película, nada más.

El mensaje es no quedarnos acá. Donde es cómodo. Explorar el espacio no es "quemar recursos". Hacerlo no significa "no arreglar nuestros problemas acá primero". Todo lo contrario. El futuro de la energía del mundo está allá afuera. Investigar el calentamiento global está allá fuera. Ser una especie interplanetaria ya estuvo en nuestras manos antes. La carrera espacial creó un mundo que vive en la era más pacífica de toda la historia. Aunque no lo quieras creer.

Nos debemos a nosotros y a nuestros hijos soñar con el espacio. Y a películas como esta, con tal cuidado científico en el limite del arte, un agradecimiento por mantener esa chispa viva.

Y spoiler duro:
No recuerdo una película que me haya hecho llorar. Pero el último segundo de Interstellar… Cuando entiendes qué implica que Brand se quite el casco… Si no se te aguan los ojos, quizás no tienes corazón :)

Enviar comentario

via Cristalab http://ift.tt/1zSlClr

Uso de módulos en Javascript con ECMAScript 6

JavaScript no tiene (por ahora) un sistema de módulos propio, aunque eso si, la comunidad fue creando varios para suplir esa necesidad. Actualmente hay dos importantes propuestas (incompatibles entre sí):

    CommonJS: Esta es la implementación usada en Node.js y Browserify, se caracteriza por una sintaxis sencilla, carga los módulos de forma síncrona y se usa principalmente en el servidor.

    Definición de Módulos Asíncronos (AMD): La implementación más popular de este estándar es RequireJS, se caracteriza por una sintaxis un poco más complicada, estar diseñado para cargar módulos de forma asíncrona y se usa principalmente en navegadores.

Más documentación sobre estos sistemas: http://ift.tt/w4Wi82

Nota: El soporte para módulos de ECMAScript 6 en los navegadores actualmente es nulo, esto está todavía en desarrollo y no está listo para ser usado, hay sin embargo formas de escribir código usando ES6 y luego convertir el código a ES5 quedando un resultado bastante bueno, pero no es un soporte nativo, sigue siendo ES5.

La meta final de los módulos de ECMAScript 6 fue crear un formato que dejara contento a los usuarios de CommonJS y AMD.

    Similitudes con CommonJS: sintaxis sencilla, preferencia por un solo export y soportar dependencias cíclicas.
    Similitudes con AMD: soporte para carga asíncrona y configurable de módulos.

Al estar el sistema incorporado directamente en el lenguaje, permite que sea mejor que CommonJS y AMD.

    La sintaxis es incluso más simple que CommonJS.

    La estructura puede ser analizada estaticamente (para comprobaciones, optimizaciones, etc.).
    Tiene un mejor soporte para dependencias cíclicas que CommonJS.

El estándar de módulo de ES6 se divido en dos partes:

    La sintaxis para exportar e importar.
    La API de carga programable, para configurar como se cargan los módulos y cargarlos en diferentes condiciones.

Visión general de la sintaxis

Hay dos formas de exportar: exportación con nombre (varias por módulo) o por defecto (una por módulo).

Exportación con nombre (varias por módulo)

Un módulo puede exportar múltiples cosas agregandole la palabra export antes de la declaración. Estas exportaciones se distinguen por su nombre.

Código :

//------ calculos.js ------
export function sumar(x, y) {
  return x + y;
}
export function restar(x, y) {
  return x - y;
}

//------ main.js ------
import { sumar, restar } from 'calculos';
console.log(sumar(2, 3)); // 5
console.log(restar(4, 3)); // 1

Como se ve es bastante simple, solo escribes el código como si no hubiera nada que lo englobe (sin scope global) y a todo lo que desees exportar solo le agregas la palabra export.

Si lo deseas también puedes importar un módulo entero y acceder a las exportaciones con nombre usando la sintaxis de propiedades:

Código :

//------ main.js ------
import * as calc from 'calculos';
console.log(calc.sumar(2, 3)); // 7
console.log(calc.restar(4, 3)); // 1

Exportación por defecto (una por módulo)

Los módulos que solo exporten un único valor son muy populares en la comunidad de Node.js y en el desarrollo frontend. Un módulo de ES6 puede tomar un valor por defecto en la exportación.

Código :

//------ miFunc.js ------
export default function () { ... };

//------ main1.js ------
import miFunc from 'miFunc';
miFunc();

Nota: El valor a exportar por defecto es una expresión y no tiene nombre, este es obtenido al importar el módulo, normalmente se usaría el nombre del módulo.

Beneficio de los módulos de ECMAScript 6

A primera vista, tener módulos de forma nativa en ES6 puede parecer una funcionalidad inútil, después de todo ya existe varios sistemas de módulos muy buenos. Pero los módulos de ES6 tienen características que no se pueden agregar con una librería, como una sintaxis reducida y una estructura estática de modulos (lo que ayuda a optimizar entre otras cosas). Además se espera que termine con la fragmentación entre los sistemas CommonsJS y AMD.

Tener un único estandar para módulos nativo significa:

    No más UMD (Definición Universal de Módulos): UMD es un patrón que permite que un mismo archivo sea usado por distintos sistemas (como CommonJS y AMD). Cuando ES6 este listo para su uso UMD se volverá obsoleto.
    Las nuevas API de los navegadores se volveran módulos en lugar de variables globales o propiedades como navigator.
    No más objetos como namespaces. Objetos como Math y JSON sirven como namespaces para funciones en ECMAScript 5. En el futuro, esta funcionalidad la darán los módulos.

Referencias (en inglés)

Para finalizar les dejo algunos links (en inglés) con más información sobre los módulos de ES6 para los que quieran aprender un poco más sobre como funcionan (como la carga asíncrona de módulos que no está explicado arriba).

    A JavaScript glossary: ECMAScript, TC39, etc.
    “Static module resolution” by David Herman
    “Modules: Cycles” in the Node.js API documentation
    “Exports” (ECMAScript 6 specification)
    “Imports” (ECMAScript 6 specification)

Enviar comentario

via Cristalab http://ift.tt/1srW5rv

6 tips críticos en desarrollo de videojuegos para Leap Motion

El Leap Motion es un dispositivo de control gestual que se conecta vía USB a cualquier computadora y reconoce los movimientos de las manos y los dedos, traduciendo esos gestos y movimientos en órdenes concretas, de forma tal que permite interactuar con la máquina utilizando sólo las manos mediante una Interfaz Natural de Usuario (NUI).

El referido dispositivo fue diseñado por la empresa californiana Leap Motion y salió a la venta el 22 de julio del año pasado. Los componentes fundamentales del hardware son dos cámaras y tres LEDs infrarrojos que detectan el movimiento de las manos y los dedos con un alcance máximo de un metro de distancia y una precisión espacial de 0.01 milímetros.

Aunque el Leap Motion fue concebido como un dispositivo de control gestual para reemplazar al mouse y el teclado, permitiendo interacturar con el sistema operativo de forma natural, utilizando sólo las manos, las perspectivas del Leap Motion en el ámbito de los videojuegos son bastante grandes, aunque también involucra nuevos desafíos para los desarrolladores, puesto que resulta complejo generar mecánicas de juego que incorporen el flujo natural de las extremidades del cuerpo humano, en roles que satisfagan las expectativas de los jugadores y reglas que sean entendidas fácilmente por los mismos.

Este artículo presenta diversos aspectos que deben atenderse al momento de desarrollar un videojuego con el dispositivo de control gestual Leap Motion. Corresponde a una presentación sucinta de aquellos aspectos críticos que he identificado durante el desarrollo de nuestro videojuego: The Rainbow Machine. Dentro de los aspectos críticos asociados al desarrollo de videojuegos con Leap Motion podemos mencionar los siguientes:

Definición de los comandos de control del juego

Un aspecto de diseño que involucra al Gameplay y la Interfaz es la definición de los controles de juego. Recordemos que el Gameplay constituye la mecánica general del juego con sus reglas, metas y objetivos y la Interfaz representa los componentes que permiten al jugador interactuar con el modo del juego definido en el Gameplay. La Interfaz tiene una influencia directa en la forma en la que percibimos el Gameplay. Ambos elementos representan aspectos cruciales del desarrollo de videojuegos puesto que están relacionados y afectan directamente la experiencia de juego.

El Leap Motion concede muchas libertades para controlar un videojuego. De acuerdo con uno de los ingenieros de la empresa, el dispositivo tiene 25 grados de libertad por cada mano, esto se refiere a la cantidad de movimientos posibles. Por consiguiente, dota de mayor complejidad el proceso de implementación de las ideas concebidas para el Gameplay y la Interfaz.

Los periféricos convencionales como: el mouse, el gamepad, el joystick, entre otros, contienen una cantidad específica de botones a los que se asigna acciones concretas. En contraste, el Leap Motion continuamente recopila una gran cantidad de información que el desarrollador debe analizar para determinar cuáles de los datos que le proporciona el Leap Motion son útiles a sus propósitos, por ejemplo, la posición de inicio de un dedo, la posición final, la velocidad de desplazamiento, gestos, entre otros, con el objeto de identificar posteriormente la semántica de los mismos. En otras palabras, el desafío de los desarrolladores de videojuegos, en lo que concierne a la definición de los comandos de control, consiste en dotar de sentido a los datos obtenidos directamente del dispositivo, para traducirlos en órdenes concretas, en función de las acciones pertinentes a su Gameplay.

Resulta conveniente resaltar que la selección de los comandos de control puede influir en la experiencia de juego positiva o negativamente, por esta razón es importante dedicar especial atención a esta fase del desarrollo.

Aprovechamiento de las características del dispositivo

Otro de los desafíos del desarrollo de videojuegos para Leap Motion, relacionado con el control, lo constituye el aprovechamiento de la Interfaz Natural de Usuario del dispositivo. Idear o adaptar mecanismos de juego para este tipo de tecnología implica desligarse de los mecanismos de control habituales. Por ejemplo, en nuestro videojuego The Rainbow Machine, un juego de puzzle en el que hay que estirar y posicionar una barra para dirigir una bola hacia un cofre, se utilizan las dos manos libremente para jugar. Esta experiencia de juego es imposible de recrear con periféricos convencionales.

La empresa Leap Motion sugiere enfáticamente el uso exclusivo de su dispositivo para el manejo de videojuegos y aplicaciones. Esto quiere decir que, por ejemplo, en lugar de utilizar el teclado para introducir alguna información requerida, como el nombre del jugador, será necesario la implementación de un teclado virtual u otro mecanismo relacionado con las herramientas de control gestual. Sin embargo, resulta pertinente destacar que la representación virtual de periféricos de control no es siempre lo más indicado. Por ejemplo, se desaprovecharían las funcionalidades del dispositivo si en el desarrollo de un gameplay cualquiera se empleara un D-Pad o cruceta para controlar el juego en lugar de utilizar el movimiento natural de las manos.

Dificultades para explicar el Gameplay

Otro aspecto crítico importante relacionado con el Gameplay y la Interfaz es la explicación de la mecánica del juego y los controles de movimiento. Resulta importante especificar claramente en primera instancia todos los aspectos que el jugador debe entender y conocer para disfrutar plenamente del juego. El tutorial es la sección que contiene la información sobre la mecánica del juego y los controles. Por lo general, es la parte que quieren omitir los jugadores impacientes.

Dado que el Leap Motion brinda muchas libertades de control resulta difícil explicar con palabras cómo jugar. Un usuario puede tener muchas dudas sobre el funcionamiento del sistema. Por ejemplo puede preguntarse: ¿cómo realizar correctamente un gesto?, ¿en qué dirección debe mover la mano?, ¿a qué velocidad debe mover la mano?. Todas estas interrogantes deben ser respondidas en el tutorial puesto que de lo contrario el jugador se frustrará al no entender cómo ejecutar las acciones básicas del juego. También resulta conveniente que el tutorial sea conciso y dinámico, de forma tal que permita al jugador aprender sobre la marcha. No es recomendable extenderse en los tutoriales.

Gestos y movimientos para la navegación por menús

El objetivo que se persigue al diseñar una Interfaz de Usuario es permitir que un jugador pueda interactuar con la computadora o sistema de forma sencilla, precisa e intuitiva. Las particularidades de control que brinda el Leap Motion permiten la implementación de dos tipos de elementos en las Interfaces de navegación: Botones Convencionales y Escenas. Por ejemplo, podemos incluir en el videojuego un Menú compuesto por una serie de botones, como es habitual, y hacer click en ellos usando algún gesto o movimiento. Otra opción que podemos implementar con este dispositivo es mostrar la información en Escenas independientes y acceder a ellas mediante algún gesto o movimiento. Este diseño sin botones se ajusta más a la naturaleza del dispositivo pero requiere instrucciones precisas sobre cuáles son las Escenas disponibles y cómo acceder y navegar por cada Escena.

Para ver la historia de nuestro videojuego The Rainbow Machine sólo tienes que barrer el dedo en el aire, de un lado a otro, y será el equivalente de hacer click en el botón Continuar. Barriendo el dedo en el aire vas pasando por las diferentes Escenas que conforman la historia del juego.

Decisiones de entrada e interrupción de lectura de datos

Otro factor a definir cuando desarrollas para Leap Motion son las acciones que ocurrirán cuando el dispositivo detecta las manos y cuando deja de detectarlas. El jugador empieza a interactuar con el sistema cuando posiciona sus extremidades en el rango de alcance del dispositivo y cesa cuando se aleja de dicho rango. En tal sentido, el desarrollador deberá tomar decisiones respecto a las situaciones que afectan el sistema. Por ejemplo, debe considerar que el jugador puede retirar las manos rápidamente fuera del alcance del dispositivo y volver a introducirlas. ¿Cómo reaccionará el juego en presencia de esos casos límite?.

Para ejemplificar el proceso supongamos que el jugador conduce un avatar por la pantalla a través de un camino y retira las manos, ¿qué ocurre?. Hay que tomar decisiones respecto a eso: ¿el avatar se mantiene completamente visible en el lado de la pantalla por donde retiró las manos?, ¿el avatar sale de la pantalla junto con las manos del jugador?, ¿al detectar un movimiento brusco el avatar se detiene?, ¿si el jugador retira las manos el juego se pone en pausa?, son algunas de las cosas que hay que decidir al diseñar el juego.

Por otro lado, también será necesario tomar decisiones cuando el dispositivo detecte nuevamente las extremidades. Por ejemplo, el desarrollador deberá definir si el avatar se moverá hacia donde están posicionadas las manos del jugador o si el avatar permanecerá inmóvil hasta que el jugador no posicione las manos sobre él.

Esta toma de decisiones resulta tan crítica para la experiencia de juego que la empresa Leap Motion agregó funciones específicas para estas detecciones en las versiones más recientes del SDK.

Falta de unificación de controles

Por último, otro de los aspectos críticos inherentes a la mecánica de juego y la Interfaz, lo representa la falta de unificación de los comandos de control. Como sabemos, cuando desarrollamos para el Leap Motion tenemos total libertad para asociar gestos y movimientos a acciones concretas del Gameplay y la Interfaz. Esto puede dificultar el entendimiento del uso de los controles por parte de los usuarios, por cuanto no existe una forma estándar para llevar a cabo tareas que son rutinarias y comunes entre videojuegos.

Puede ocurrir que, en un determinado videojuego, un usuario acceda a las opciones del menú haciendo el gesto de barrido de un dedo en el aire, y en otro videojuego este gesto no sirva para el mismo propósito. En contraste, con los periféricos convencionales el entendimiento de la Interfaz por parte de los jugadores es más rápido porque los comandos de control son más limitados y tienen una semántica estándar. Por ejemplo, un jugador principiante puede aprender rápidamente que al pulsar un botón del Mouse accede a las opciones del Menú e incluso puede iniciar una partida. Ese conocimiento es aplicable a otros videojuegos de ese estilo controlados con ese periférico.

Estos son algunos de los aspectos críticos que como desarrollador deberás afrontar al crear alguna App o videojuego para el Leap Motion o cualquier otro periférico similar. Espero que esta información les sea de ayuda.

Enviar comentario

via Cristalab http://ift.tt/1poqxqU