miércoles, 15 de febrero de 2012

¿El nuevo logo de Windows 8?

Veo que en Microsoft News se hacen eco de un rumor que dice que Microsoft podría cambiar su logo en Windows 8, con un estilo que se alinea a Metro. En su articulo comentan que no les gusta y que ojala sea mentira. Mi opinión es justo lo contrario, a mi me gusta mucho, tanto el estilo Metro, como este nuevo logo.

new-windows-8-logo

Viendo este nuevo logo, me viene a la cabeza el cambio que sufrió el logo de Chrome, también tirando hacia los colores solidos en vez de los degradados y brillos.

Y tu, ¿que opinas? ¿Te gusta más o menos el nuevo logo?

Actualización:

Parece que ya se conoce el logo final.

windows-8-2

Personalmente me gusta mas el primero con el que ilustro la noticia, pero este no me desagrada. Me recuerda muchísimo a Windows Phone.

martes, 14 de febrero de 2012

El reto I: Crear un juego en 15 días. Generación de enemigos.

Como ya comente en anteriores post, he parado el proceso de creación del juego por que he llegado a un punto en el que no me es posible continuar sin un terminal con el que probar el juego. El teléfono lo tengo desde hace unos días, pero estoy a la espera de poder desbloquearlo para permitir el debug.

Como la cosa esta tardando bastante mas de lo que esperaba (por culpa mía, básicamente), voy a publicar un poco del código del juego, concretamente el que se encarga de generar a los enemigos.

Mi idea de esta serie de post no era publicar código, si no comentar el proceso, pero como he dicho, como estoy tardando tanto, y me lo pidieron en uno de los comentarios ahí va.

Este método se encarga de enviar oleadas de enemigos de manera mas o menos aleatoria. Os invito a que me comentéis mejoras o cualquier cosa sobre el código.

        //Variables enemigos//
private int _numeroEnemigosEnRafaga;
private int _enemigosActualesEnRafaga;
//Determinal el número máximo y mínimo para las rafagas de enemigos.
private const int MIN_ENEMIGOS = 1;
private const int MAX_ENEMIGOS = 4;
//Tiempo máximo y mínimo de espera entre enemigos.
private const int MAX_TIEMPO_REFAGA = 4;
private const int MIN_TIEMPO_REFAGA = 1;
//determinal por que lado han aparecido los ultimos enemigos.
private int _ultimoLado;
//Tiempo entre enemigos dentro de la rafaga
private float _intervaloEntreEnemigos = 700f;
private float _intervaloSiguienteRafaga;
//Temporizador de tiempo entre enemigo dentro de la rafaga
private float _temporizador;
//Temporizador tiempo entre rafagas.
private float _temporizadorRafagas;
//estado de la rafaga.
private bool _estaEnRafaga;

private void SetEnemigos(GameTime gameTime)
{
_temporizador += gameTime.ElapsedGameTime.Milliseconds;

//Si no esta en rafaga, se genera una nueva rafaga de enemigos.
if(!_estaEnRafaga)
{
//intervalo de tiempo entre enemigos por defecto;
_intervaloEntreEnemigos = 700f;
_enemigosActualesEnRafaga = 0;
//se recuperan cuantos enemigos van a aparecer en la rafaga.
_numeroEnemigosEnRafaga = random.Next(MIN_ENEMIGOS, MAX_ENEMIGOS);
//Se cambia el lado por el que apareceran los enemigos.
_ultimoLado++;
//Intervalo de tiempo para la siguiente rafaga
_intervaloSiguienteRafaga = 1000f * random.Next(MIN_TIEMPO_REFAGA, MAX_TIEMPO_REFAGA);

//Se añade algo de aleatoriedad al tiempo entre enemigos.
int variadorTiempoEntreEnemigos = 100 * random.Next(MIN_TIEMPO_REFAGA, MAX_TIEMPO_REFAGA);
int signoRandom = random.Next(1, 3);
_intervaloEntreEnemigos = signoRandom == 1
? _intervaloEntreEnemigos + variadorTiempoEntreEnemigos
: _intervaloEntreEnemigos - variadorTiempoEntreEnemigos;
}

if(_enemigosActualesEnRafaga < _numeroEnemigosEnRafaga)
{
_estaEnRafaga = true;
//Si no ha pasado el tiempo suficiente entre enemigos no hacemos nada.
if (_intervaloEntreEnemigos > _temporizador)
{
return;
}

//Se lanza al enemigo por el lado correspondiente.
if (_ultimoLado % 2 == 0)
{
Enemy enemigo = enemies.Where(e => e.IsVisible == false).Skip(0).Take(11).FirstOrDefault();
if (enemigo != null) enemigo.IsVisible = true;
}
else
{
Enemy enemigo = enemies.Where(e => e.IsVisible == false).Skip(11).Take(11).FirstOrDefault();
if (enemigo != null) enemigo.IsVisible = true;

}
_enemigosActualesEnRafaga++;
_temporizador = 0f;
}
else
{
//Se acaba la rafaga.
//Comienza el contador para la siguiente rafaga de enemigos.
_temporizadorRafagas += gameTime.ElapsedGameTime.Milliseconds;

if (_intervaloSiguienteRafaga > _temporizadorRafagas)
{
return;
}
_temporizadorRafagas = 0;
_estaEnRafaga = false;
}
}



Y este método es llamado en cada update:

 /// <summary>
/// Animates each enemy and allow them to kill the player.
/// </summary>
private void UpdateEnemies(GameTime gameTime)
{

SetEnemigos(gameTime);

foreach (Enemy enemy in enemies)
{
enemy.Update(gameTime);

// Touching an enemy instantly kills the player
if (enemy.BoundingRectangle.Intersects(Player.BoundingRectangle))
{
OnPlayerKilled(enemy);
}

// Falling off the bottom of the level kills the player.
if (enemy.BoundingRectangle.Top >= Height * Tile.Height)
{
enemy.OnKilled(enemy);
}
}
}

LINQ, buscar elementos en un listado

Continuo con la sección de capsulas de código, donde sin entrar mucho en detalle, pongo trozos de código con una funcionalidad muy concreta.

Hoy vamos a “jugar” un poco con LINQ y las expresiones lamda, y vamos a usar la potencia que nos ofrecen para facilitarnos un poco a la hora de encontrar elementos dentro de un listado del tipo IEnumerable con unos cuantos ejemplos concretos.

LINQ nos ofrece varios selectores a la hora de obtener los valores.

Where: Devuelve todos los valores que coincidan con el criterio seleccionada.

Single: Solo devuelve un valor, pero generara una excepción en el caso de que el criterio de selección devuelva null o mas de un valor. Si no estamos seguros de que el criterio de filtrado siempre vaya a devolver un valor podemos usar SingleOrDefault, que devuelve null en caso de no tener ningún resultado. Si no estamos seguros de que vaya a devolver solo un valor, tenemos que usar Where, o tenemos la opción de usar First.

First: Devuelve el valor del primer elemento que coincida con el criterio de filtrado. Aquí también témenos la opción de usar FirstOrDefault.

Unos ejempolos:

            string busqueda = "criterio";
List<string> Lista = new List<string>();

//SINGLE
string result = Lista.Single(s => s == busqueda);

//WHERE
IEnumerable<string> results = Lista.Where(s => s == busqueda);

//FIRST
string result = Lista.First(s => s == busqueda);




¿Sencillo verdad?


Pero que pasa si el listado que tenemos es por ejemplo de una clase propia que hemos creado nosotros. Tenemos el Cast<T>


Un ejemplo:

var imagenBorrar = imagenes.Items.Cast<ImagenGaleria>().Single(i => i.Id == _idImagenBorrar);
imagenes.Items.Remove(imagenBorrar);




Eso es todo por hoy, espero que os sirva.


Nos leemos!



viernes, 3 de febrero de 2012

Nokia Lumia 800, primeras impresiones

Por fin ayer el mensajero llamo al timbre de mi casa para traerme lo que con tantas ganas esperaba desde hacia un par de semanas, mi nuevo y flamante Smartphone con Windows Phone 7.5, el Nokia Lumia 800.

Llevo muy pocas horas usándolo, ya que además aún no lo llevo encima por que la portabilidad de compañía aún no se ha hecho, pero quería escribir mis primeras impresiones, y dentro de un par de semanas escribiré otro post con lo que me va pareciendo con un poco mas de uso, que es cuando realmente se ven las cosas, tanto las buenas como las malas. Voy a separar estas impresiones en dos post, uno para el terminal, y otro para el sistema operativo (lo queria hacer todo en uno, pero saldría algo muy largo y pesado de leer).

He de decir, que llevo un par de años usando un HTC Desire con Android, así que todas mis comparaciones van ha ser usando este terminal como referencia, ya que nunca he tenida un IPhone (solo he visto el de gente que conozco).

Lo primero que me llama la atención al sacarlo de la caja, es su pantalla y los acabados, no voy a hablar aquí de cosas técnicas, que para eso hay muchas páginas por ahí que lo harán mucho mejor que yo, pero se nota que han cuidado mucho el aspecto, la pantalla ocupa casi todo el espacio y se integra muy bien con la estructura del teléfono, da la sensación de que es una pantalla mucho más grande de lo que luego en realidad es, además me da la sensación de que pesa ligeramente mas que mi anterior terminal, del mismo tamaña aproximadamente, y esto me da una buena sensación de robustez.

Los acabados laterales son redondeados y los extremos superior e inferior planos. La base es de una sola pieza, si bien esto hace que parezca mucho mas robusto y además queda muy bien, también es verdad que hace que tenga una de las características que menos me gustan de IPhone, no se puede sacar la batería. Espero que dentro de un año no se rompa, por que ya sabemos que las baterías son uno de los puntos débiles de los Smartphone, aparte de no durar mucho (que esto ya lo valoraré dentro de un par de semanas en este terminal), suelen estropearse pronto, y al cabo de un año duran menos de un día (no siempre, claro, pero si muchaaaas veces).

nokia_lumia_800

En la parte superior tiene un Jack para los cascos, el conector USB para cargarlo y la ranura para la sim. El conector USB y la ranura sim están bien protegidas por unas tapitas que quedan totalmente integradas en el terminal. En el lateral derecho encontramos los botones para el volumen, el bloqueo y el encendido/ apagado. No hay mucho que decir de esto, son de color metálico.

En la parte inferior tenemos un altavoz, la verdad es que suena muy bien, pero le encuentro un pequeño inconveniente a que este puesto ahí. Normalmente, cuando jugamos a algún juego, giramos el teléfono y lo ponemos en modo horizontal. Al hacer eso, con la mano se tapa el altavoz y por lo tanto el sonido se resiente mucho.

Junto con el terminal me venia una funda de silicona, que siempre es un detalle y unos cascos, que aún no he probado, pero que tienen muy buena pinta.

Así pues, la primera impresión es muy buena, a ver como evoluciona a lo largo de un par de semanas.

Mañana, mi opinión del sistema operativo.

Nos leemos!

miércoles, 1 de febrero de 2012

Diponible en castellano el número de enero de MSDN Magazine


Ya esta disponible en español el numero de enero de MSDN Magazine.
Si eres desarrollador, o pretendes serlo, es de lectura casi obligada, por lo menos los artículos que más te interesen. En este número puedes encontrar cosas muy interesantes sobre el desarrollo para Windows Phone y HTML5, entre otras cosas…