Mecanim: Creando Script de Saltar en Unity 5+

1.- Crearemos un script para poder manejar la funcionalidad de Idle a Jump y de Jump a Idle, primero crearemos una carpeta llamada script.

2.- Ahora dentro de la carpeta le daremos clic derecho Create > C# Script y lo llamaremos "AnimacionSaltar".

3.- Una vez creada nos llevara al editor que tiene por default unity que es MonoDevelop

4.- Ahora insertaremos el siguiente código.

AnimacionSaltar.cs

using UnityEngine;
using System.Collections;

public class AnimacionSaltar : MonoBehaviour {

 //Creamos una variable de tipo Animator para controlarlo desde aqui
 private Animator animator;
 
 void Start ()
 {
  //Dentro de Start direccionaremos nuestro animator para poderlo usar
  animator = this.GetComponent<Animator>();
 }

 void Update () 
 {
  //Cuando presionemos la barra espaciadora cambiaremos de Idle a Jump
  if(Input.GetKey(KeyCode.Space))
  {
   //Establecemos el tipo de parametro que usamos en este caso bool
   //y le asignamos el nombre del parametro
   animator.SetBool("Saltar", true);
  }

  else
  {
   animator.SetBool("Saltar", false);
  }
 }
}

5.- Regresamos a la escena en unity y nos aseguramos que el personaje este en la posición 0, 0, 0 en el inspector.

6.- Una vez hecho esto seleccionamos nuestro personaje y nos vamos al inspector, le daremos clic en "Add Component" y nos situaremos en Miscellaneous > Animator o en el menú de arriba le daremos Component > Miscellaneous > Animator con esto agregaremos un nuevo componente de tipo Animator.

7.- Ahora agregaremos el controller, para ello nos vamos a la carpeta Animator, y seleccionamos y arrastramos dentro del componente Animator en la parte de Controller.

8.- Ahora toca el turno del script, nos vamos a la carpeta script, seleccionamos el script y los arrastramos al inspector.

9.- Le daremos play y mantendremos la barra espaciadora y soltaremos para probar nuestro salto.

Mecanim: Transiciones en Unity 5+

1.- Para empezar con las transiciones debemos de establecer con que estado trabajaremos, para esto usaremos Idle, debe de estar marcado de color naranja, si no estuviera marcado siempre podemos darle clic izquierdo y seleccionar "Set as layer Default State" y se pondrá naranja.

2.- Ahora realizaremos la transición para ello seleccionamos el Idle le damos clic y le daremos en Make Transition, con esto nos saldrá una flecha, seleccionaremos Jump para que nos quede unido la transición y vaya del Estado de Idle a Jump.

3.- Ahora que hemos hecho la transición tendremos que crear parámetros para que pueda cambiar de Idle a Jump, existen 4 parámetros Bool, Trigger, Int y Float para este ejemplo usaremos un  parámetro de tipo Bool, para ello en la esquina superior izquierda debajo del símbolo de un ojo se encuentra otro símbolo "+", le daremos ahí para agregar el parámetro de tipo bool y lo llamaremos "Saltar".

4.- Si seleccionamos la flecha de la transición podemos ver las propiedades en el inspector

5.- Ahora en el inspector en la parte de abajo vemos una pestaña que dice conditions, aquí pondremos el tipo de condición del parámetro que acabamos de crear. seleccionamos en el signo "+" para agregar el parámetro Saltar y dejamos a true.

6.- Ahora realizaremos la transición del lado inverso de Jump a Idle.

7.- Y en la condición agregaremos Saltar pero esta vez cambiando a false.

Mecanim: Creando Animator Tree en Unity 5+

1.- Creamos una carpeta que se llamara Animator.

2.- Entramos en la carpeta y ahora si crearemos nuestro Animator Controller para ello con clic derecho en Create > Animator Controller y lo llamaremos controlador.

3.- Una vez creado le daremos doble clic, con esto abrirá la ventana de Animator.

4.- Ahora iremos a la carpeta de animaciones y arrastraremos la animación de Idle, una vez que lo coloquemos observaremos que la caja de "entry" estará asignando una flecha hacia Idle lo cual quiere decir que es la primera animación en entrar, también observamos que Idle esta de color naranja esto por que sera la animación con la que empezaremos.

5.- Ahora repetimos la misma operación para jump, podemos mover las cajas para acomodar la escena, en este caso jump se tornara en color gris ya que tomo Idle como default para empezar a animar.

En la siguiente parte veremos las Transiciones.

Mecanim: Creando Animaciones en Unity 5+

1.- Una vez que hemos cargados nuestros sprites crearemos otra carpeta que se llamara Animación.

2.- Tomaremos todas las imágenes seleccionadas de la carpeta Idle y la  arrastraremos a la escena, con esto nos creara una animación.

3.- Nos saldrá una ventana donde le daremos un nombre a la animación, para ello nos situaremos en la carpeta de animaciones y una vez ahí llamaremos a la animación Idle y guardamos.

4.- Veremos en pantalla la imagen, si le damos play podemos ver la animación, ya que cuando creamos una animación con este método le asignamos un componente de tipo Animator al cual se le

asigna a nuestro sprite de la animación creada.

5.- Ahora nos iremos a la carpeta de animaciones y observamos los siguientes archivos. El primero es la animación que acabamos de realizar el del símbolo de play y el otro que tiene símbolo de un esquema, esto es un animator tree que se creo al iniciarse la animación.

6.- Si seleccionamos nuestro sprite en la escena veremos entre sus propiedades en el inspector un componente Animator y veremos asignado un Controller que se crea al hacer la animación, por default se crea un tree animator y se le asigna.

7.- Aprenderemos a realizar un animator tree mas adelante asi que para ello quitaremos el componente dandole clic derecho y remover componente y eliminaremos el tree animator el del simbolo de un esquema en nuestra carpeta animaciones.

8.- Una vez hecho esto realizaremos la otra animación de Jump, para ello nos situamos en la pestaña del menú en Window y le daremos Animation con esto nos abrirá la ventana para realizar animaciones.

9.- Nos situamos en la parte superior izquierda de esta ventana justo arriba del botón "add property", existe un botón desplegable, le daremos clic ahí y nos aparecerá si queremos crear un nuevo clip y le daremos en ese botón.

10.- Nos situamos en la carpeta de Animaciones y le daremos un nombre, le pondremos Jump y creara la animación.

11.- Ahora nos vamos en la carpeta de Sprites y luego Jump seleccionamos todas la imágenes y las colocamos en la ventana de Animation, esto nos creara la animación de jump, cambiaremos el numero de sample a 12.

12.- Si nos situamos en la carpeta de Animaciones podemos ver que se creo la animación pero se volvió a crear el animator tree y si seleccionamos nuestro sprite podemos ver que se volvió a asignar el componente, los removeremos haciendo el paso 7.

El la siguiente parte crearemos el Animator Tree

Mecanim: Cargando Assets en Unity 5+

1.- Creamos un nuevo proyecto en unity 5+ en 2D

2.- Creamos una carpeta Sprites donde colocaremos nuestras imágenes

3.- Dentro de la carpeta Sprites crearemos 2 mas llamadas Idle y Jump

4.- Dentro de las carpetas colocamos las imágenes de cada animación correspondiente a su nombre.

En la siguiente parte crearemos las animaciones de nuestro personaje.

Redes en SFML

1.- Creamos un nuevo archivo en SFML

2.- Lo rellenamos con el siguiente código.

Main.cpp

#include <SFML\Graphics.hpp>
#include <SFML\Network.hpp>
#include <iostream>
#include <string>

#define TILE_SIZE 40.f

using namespace std;

int main()
{
 //Establesco la conexion
 sf::TcpSocket socket;
 string entradaConsola;
 cin >> entradaConsola;

 if (entradaConsola == "host")
 {
  sf::TcpListener escucha;
  escucha.listen(45000);
  cout << "Esperando la conexion..." << endl;

  if (escucha.accept(socket) != sf::Socket::Done)
  {
   return -1;
  }
 }

 else
 {
  //en la segunda pantalla tendremos que introducir la IP en este caso de manera local seria 127.0.0.1
  cout << "Intentando conectar..." << endl;
  
  //El tiempo de salida se establece en 10 segundos. si nada sucede aborta
  if (socket.connect(entradaConsola, 45000, sf::seconds(10)) != sf::Socket::Done)
  {
   //No pudo conectar por alguna razon y aborta
   return -1;
  }
 }

 //Creo mi ventana y ajustamos la escena para este proyecto
 sf::RenderWindow window(sf::VideoMode(640, 480), "Redes en SFML");
 window.setFramerateLimit(60);

 socket.setBlocking(false);

 sf::Vector2f tamFigura(TILE_SIZE, TILE_SIZE);
 sf::RectangleShape figuraLocal(tamFigura);
 sf::RectangleShape figuraRemota(tamFigura);

 //GameLoop
 while (window.isOpen())
 {
  //Eventos
  sf::Vector2i direccion;
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

    //Moveremos los cubos cada quien con su direccion
   case sf::Event::KeyPressed:

    if (event.key.code == sf::Keyboard::W)
    {
     direccion.y += -1;
    }

    else if (event.key.code == sf::Keyboard::A)
    {
     direccion.x += -1;
    }

    else if (event.key.code == sf::Keyboard::S)
    {
     direccion.y += 1;
    }

    else if (event.key.code == sf::Keyboard::D)
    {
     direccion.x += 1;
    }

   default:
    break;
   }
  }

  //Checa los nuevos paquetes
  sf::Packet paquete;

  if (socket.receive(paquete) == sf::Socket::Done)
  {
   sf::Vector2f posicion;
   paquete >> posicion.x >> posicion.y;
   figuraRemota.setPosition(posicion);
  }

  //Actualiza el frame
  if (direccion.x != 0 || direccion.y != 0)
  {
   figuraLocal.move(direccion.x * TILE_SIZE, direccion.y * TILE_SIZE);
   sf::Packet paquete;
   paquete << figuraLocal.getPosition().x << figuraLocal.getPosition().y;

   if (socket.send(paquete) != sf::Socket::Done)
   {
    //Se manejan los errores de posible salida del otro jugador
    return -1;
   }
  }

  //Renderizamos
  window.clear();

  window.draw(figuraLocal);
  window.draw(figuraRemota);

  window.display();
 }

 return 0;
}

3.- Una vez hecho eso abrimos otro nuevo documento y copiamos el código tal como esta.

4.- Ejecutamos uno de ellos

5.- Saldrá la pantalla de la consola, espera una cadena para introducir.

6.- En esta primera ventana introduciremos la cadena host

7.- La primera vez te saldrá que si permites que se establezca la conexión y le das aceptar, entonces la pantalla de la consola esperara al siguiente jugador.

8.- Ahora ejecutaremos la otra aplicación y nos volverá a salir la ventana de la consola, en esta ocasión nos comunicaremos con el servidor, le introduciremos la dirección IP, para este ejemplo se hizo de manera local introduciendo 127.0.0.1

9.- Le damos enter y nos aparecerá que esta intentando conectar.

10.- Si se realizo de manera local aparecerán 2 ventanas de juego con los personajes.

11.- Si nos paramos a una ventana y movemos con las teclas W, A, S, D se moverá unos de los personajes el que esta de manera local y si nos vamos a la otra pantalla y movemos podemos observar que se mueve el otro que es el remoto.

Version OpenGL en SFML

Main.cpp

#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(640 , 480), "Version OpenGL en SFML");
 window.setFramerateLimit(60);

 sf::ContextSettings settings = window.getSettings();
 cout << "Version OpenGL: " << settings.majorVersion << "." << settings.minorVersion << endl;

 //GameLoop
 while (window.isOpen())
 {
  window.clear();

  //Eventos
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

   default:
    break;
   }
  }

  window.display();
 }

 return 0;
}

Manejador de Assets 3.0, Agregando Fuentes

ManejadorAssets.h

#ifndef MANEJADOR_ASSETS_H
#define MANEJADOR_ASSETS_H

#include <SFML\Graphics.hpp>
#include <SFML\Audio.hpp>
#include <map>
#include <string>

class ManejadorAssets
{
public:

 //constructor
 ManejadorAssets();

 //funcion estatica para obtener las texturas
 static sf::Texture &obtenerTextura(std::string const &nombreArchivo);

 //funcion estatica para obtener el sonido del buffer
 static sf::SoundBuffer &obtenerSonidoBuffer(std::string const &nombreArchivo);

 //funcion estatica para obtener la fuente
 static sf::Font &obtenerFuente(std::string const &nombreArchivo);

private:

 //mapa que me servira manejar las texturas por medio de identificadores de cadenas
 std::map<std::string, sf::Texture> m_Texturas;

 //mapa que me servira manejar los buffer de sonido por medio de identificadores de cadenas
 std::map<std::string, sf::SoundBuffer> m_sonidosBuffer;

 //mapa que me servira manejar las fuentes por medio de identificadores de cadenas
 std::map<std::string, sf::Font> m_Fuentes;

 //El manejador de assets es un singleton, esto solo es una instancia que puede
 //existir al mantener un puntero estatico en una simple instancia del manejador
 static ManejadorAssets *sIntancia;
};

#endif

ManejadorAssets.cpp

#include "ManejadorAssets.h"
#include <assert.h>

//inicializo mi instancia a 0 o nulo
ManejadorAssets *ManejadorAssets::sIntancia = nullptr;

//definicion del constructor
ManejadorAssets::ManejadorAssets()
{
 //Solo permite un Manejador de Assets si no manda una excepcion

 //macro assert que verifica si la expresion es correcta
 assert(sIntancia == nullptr);
 sIntancia = this;
}

//definicion de obtenerTextura

sf::Texture &ManejadorAssets::obtenerTextura(std::string const &nombreArchivo)
{
 auto &mapTextura = sIntancia->m_Texturas;

 //observamos si la textura esta lista para cargarlas
 auto pairFound = mapTextura.find(nombreArchivo);

 //Si esta lista regresamos la textura
 if (pairFound != mapTextura.end())
 {
  return pairFound->second;
 }

 //si no carga la textura la regresamos
 else 
 {
  //Creamos el elemento del map de la textura
  auto &textura = mapTextura[nombreArchivo];
  textura.loadFromFile(nombreArchivo);
  return textura;
 }
}

//definicion de obtenerSonidoBuffer
//Formatos de audio: ogg, wav, flac, aiff, au, raw, paf, svx, nist,
//voc, ircam, w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64
//aun no tiene soporte para formato mp3 :(
sf::SoundBuffer &ManejadorAssets::obtenerSonidoBuffer(std::string const &nombreArchivo)
{
 auto &mapSonidoBuffer = sIntancia->m_sonidosBuffer;

 //observamos si el sonido esta listo para cargarse
 auto pairFound = mapSonidoBuffer.find(nombreArchivo);

 // Si esta listo regresamos el sonido
  if (pairFound != mapSonidoBuffer.end())
  {
   return pairFound->second;
  }

 //si no carga el sonido la regresamos
  else
  {
   //Creamos el elemento del map del sonido buffer
   auto &sonido = mapSonidoBuffer[nombreArchivo];
   sonido.loadFromFile(nombreArchivo);
   return sonido;
  }
}

//definicion de obtenerFuente
//formatos: TrueType (TTF), Type 1, CFF, OpenType, SFNT,
//X11 PCF, Windows FNT, BDF, PFR, y Type 42
sf::Font &ManejadorAssets::obtenerFuente(std::string const &nombreArchivo)
{
 auto &mapFuente = sIntancia->m_Fuentes;

 //observamos si la fuente esta lista para cargarse
 auto pairFound = mapFuente.find(nombreArchivo);

 // Si esta listo regresamos la fuente
 if (pairFound != mapFuente.end())
 {
  return pairFound->second;
 }

 //si no carga la fuente la regresamos
 else
 {
  //Creamos el elemento del map de la fuente
  auto &fuente = mapFuente[nombreArchivo];
  fuente.loadFromFile(nombreArchivo);
  return fuente;
 }
}

Main.cpp

#include "ManejadorAssets.h"

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(640 , 480), "Manejador de Assets 3.0, Agregando Fuentes");
 window.setFramerateLimit(60);

 //Creo un objeto de mi manejador de assets
 ManejadorAssets assets;

 //Agregamos la fuente
 sf::Text texto("Apoya al sitio dando clic en la publicidad", ManejadorAssets::obtenerFuente("Sansation.ttf"));

 //GameLoop
 while (window.isOpen())
 {
  window.clear();

                //muestro mi texto
  window.draw(texto);

  //Eventos
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

   default:
    break;
   }
  }

  window.display();
 }

 return 0;
}

Manejador de Assets 2.0, Agregando Audio en SFML

ManejadorAssets.h

#ifndef MANEJADOR_ASSETS_H
#define MANEJADOR_ASSETS_H

#include <SFML\Graphics.hpp>
#include <SFML\Audio.hpp>
#include <map>
#include <string>

class ManejadorAssets
{
public:

 //constructor
 ManejadorAssets();

 //funcion estatica para obtener las texturas
 static sf::Texture &obtenerTextura(std::string const &nombreArchivo);

 //funcion estatica para obtener el sonido del buffer
 static sf::SoundBuffer &obtenerSonidoBuffer(std::string const &nombreArchivo);

private:

 //mapa que me servira manejar las texturas por medio de identificadores de cadenas
 std::map<std::string, sf::Texture> m_Texturas;

 //mapa que me servira manejar los buffer de sonido por medio de identificadores de cadenas
 std::map<std::string, sf::SoundBuffer> m_sonidosBuffer;

 //El manejador de assets es un singleton, esto solo es una instancia que puede
 //existir al mantener un puntero estatico en una simple instancia del manejador
 static ManejadorAssets *sIntancia;
};

#endif

ManejadorAssets.cpp

#include "ManejadorAssets.h"
#include <assert.h>

//inicializo mi instancia a 0 o nulo
ManejadorAssets *ManejadorAssets::sIntancia = nullptr;

//definicion del constructor
ManejadorAssets::ManejadorAssets()
{
 //Solo permite un Manejador de Assets si no manda una excepcion

 //macro assert que verifica si la expresion es correcta
 assert(sIntancia == nullptr);
 sIntancia = this;
}

//definicion de obtenerTextura

sf::Texture &ManejadorAssets::obtenerTextura(std::string const &nombreArchivo)
{
 auto &mapTextura = sIntancia->m_Texturas;

 //observamos si la textura esta lista para cargarlas
 auto pairFound = mapTextura.find(nombreArchivo);

 //Si esta lista regresamos la textura
 if (pairFound != mapTextura.end())
 {
  return pairFound->second;
 }

 //si no carga la textura la regresamos
 else 
 {
  //Creamos el elemento del map de la textura
  auto &textura = mapTextura[nombreArchivo];
  textura.loadFromFile(nombreArchivo);
  return textura;
 }
}

//definicion de obtenerSonidoBuffer
//Formatos de audio: ogg, wav, flac, aiff, au, raw, paf, svx, nist,
//voc, ircam, w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64
//aun no tiene soporte para formato mp3 :(
sf::SoundBuffer &ManejadorAssets::obtenerSonidoBuffer(std::string const &nombreArchivo)
{
 auto &mapSonidoBuffer = sIntancia->m_sonidosBuffer;

 //observamos si el sonido esta listo para cargarse
 auto pairFound = mapSonidoBuffer.find(nombreArchivo);

 // Si esta listo regresamos el sonido
  if (pairFound != mapSonidoBuffer.end())
  {
   return pairFound->second;
  }

 //si no carga el sonido lo regresamos
  else
  {
   //Creamos el elemento del map del sonido buffer
   auto &sonido = mapSonidoBuffer[nombreArchivo];
   sonido.loadFromFile(nombreArchivo);
   return sonido;
  }
}

Main.cpp

#include "ManejadorAssets.h"

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(640 , 480), "Manejador de Assets 2.0, Agregando Audio");
 window.setFramerateLimit(60);

 //Creo un objeto de mi manejador de assets
 ManejadorAssets assets;

 //Mando a llamar a mi sonido con mi Manejador de Assets
 sf::Sound sonido(ManejadorAssets::obtenerSonidoBuffer("sonido.ogg"));

 //Se reproduce una vez
 sonido.play();

 //GameLoop
 while (window.isOpen())
 {
  window.clear();

  //Eventos
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

   default:
    break;
   }
  }

  window.display();
 }

 return 0;
}

Reproducir Audio en SFML

main.cpp

#include <SFML\Graphics.hpp>
#include <SFML\Audio.hpp>

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(640 , 480), "Reproducir Audio");
 window.setFramerateLimit(60);

 //Creo un buffer de sonido
 sf::SoundBuffer sonidoBuffer;

 //Formatos de audio: ogg, wav, flac, aiff, au, raw, paf, svx, nist,
 //voc, ircam, w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64
 //aun no tiene soporte para formato mp3 :(
 if (!sonidoBuffer.loadFromFile("sonido.ogg"))
 {
  return -1;
 }

 //le paso mi buffer a mi sonido
 sf::Sound sonido(sonidoBuffer);

 //Se reproduce una vez
 sonido.play();

 //GameLoop
 while (window.isOpen())
 {
  window.clear();

  //Eventos
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

   default:
    break;
   }
  }

  window.display();
 }

 return 0;
}

Animacion de Sprite Simple en SFML

ManejadorAssets.h

#ifndef MANEJADOR_ASSETS_H
#define MANEJADOR_ASSETS_H

#include <SFML\Graphics.hpp>
#include <map>
#include <string>

class ManejadorAssets
{
public:

 //constructor
 ManejadorAssets();

 //funcion estatica para obtener las texturas
 static sf::Texture &obtenerTextura(std::string const &nombreArchivo);

private:

 //mapa que me servira manejar las texturas por medio de identificadores de cadenas
 std::map<std::string, sf::Texture> m_Texturas;

 //El manejador de assets es un singleton, esto solo es una instancia que puede
 //existir al mantener un puntero estatico en una simple instancia del manejador
 static ManejadorAssets *sIntancia;
};

#endif

ManejadorAssets.cpp

#include "ManejadorAssets.h"
#include <assert.h>

//inicializo mi instancia a 0 o nulo
ManejadorAssets *ManejadorAssets::sIntancia = nullptr;

//definicion del constructor
ManejadorAssets::ManejadorAssets()
{
 //Solo permite un Manejador de Assets si no manda una excepcion

 //macro assert que verifica si la expresion es correcta
 assert(sIntancia == nullptr);
 sIntancia = this;
}

//definicion de obtenerTextura

sf::Texture &ManejadorAssets::obtenerTextura(std::string const &nombreArchivo)
{
 auto &mapTextura = sIntancia->m_Texturas;

 //observamos si la textura esta lista para cargarlas
 auto pairFound = mapTextura.find(nombreArchivo);

 //Si esta lista regresamos la textura
 if (pairFound != mapTextura.end())
 {
  return pairFound->second;
 }

 //si no carga la textura y la regresamos
 else 
 {
  //Creamos el elemento del map de la textura
  auto &textura = mapTextura[nombreArchivo];
  textura.loadFromFile(nombreArchivo);
  return textura;
 }
}

Main.cpp

#include <SFML\Graphics.hpp>
#include "ManejadorAssets.h"

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(640 , 480), "Animacion de Sprite Simple");
 window.setFramerateLimit(60);

 //Creo mi objeto manejador de Assets
 ManejadorAssets assets;

 //Creo mis variables que controlaran los tiempos
 sf::Time tiempoTranscurrido;
 sf::Clock reloj;

 //Variable para determinar el tamaño de mi sprite individual
 //algunos sprite sheet las separaciones pueden variar, sera necesario probar
 //hasta ajustar bien la animacion solo en algunas excepciones
 sf::Vector2i tamSprite(76, 64); 

 //Usando el manejador de assets creo mi sprite
 sf::Sprite sprite(ManejadorAssets::obtenerTextura("sheep.png"));

 //Coloco en el primer frame la primera imagen de mi sprite
 sprite.setTextureRect(sf::IntRect(0, 0, tamSprite.x, tamSprite.y));

 //establesco el numero de frames que contendra mi imagen
 int numFrames = 7;

 //establesco una duracion de retardo para cambiar al siguiente frame
 float duracionAnimacion = 1; //1 segundo

 //coloco una posicion de mi sprite en la escena
 sprite.setPosition(100, 100);

 //GameLoop
 while (window.isOpen())
 {
  window.clear();
  
  //Regresa el tiempo transcurrido y reinicia el reloj
  sf::Time deltaTime = reloj.restart();

  //Acumula el tiempo con cada frame que pasa
  tiempoTranscurrido += deltaTime;
  float tiempoEnSegundos = tiempoTranscurrido.asSeconds();

  //obtiene el frame de la animacion actual
  int frameAnimacion = static_cast<int>((tiempoEnSegundos / duracionAnimacion) * numFrames) % numFrames;

  //establece el rectangulo de la  textura, dependiendo en que frame se encuentre
  sprite.setTextureRect(sf::IntRect(frameAnimacion * tamSprite.x, 0, tamSprite.x, tamSprite.y));
  
  //dibujo la animacion
  window.draw(sprite);

  //Eventos
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

   default:
    break;
   }
  }

  window.display();
 }

 return 0;
}

Manejador de Assets en SFML

ManejadorAssets.h

#ifndef MANEJADOR_ASSETS_H
#define MANEJADOR_ASSETS_H

#include <SFML\Graphics.hpp>
#include <map>
#include <string>

class ManejadorAssets
{
public:

 //constructor
 ManejadorAssets();

 //funcion estatica para obtener las texturas
 static sf::Texture &obtenerTextura(std::string const &nombreArchivo);

private:

 //mapa que me servira manejar las texturas por medio de identificadores de cadenas
 std::map<std::string, sf::Texture> m_Texturas;

 //El manejador de assets es un singleton, esto solo es una instancia que puede
 //existir al mantener un puntero estatico en una simple instancia del manejador
 static ManejadorAssets *sIntancia;
};

#endif

ManejadorAssets.cpp

#include "ManejadorAssets.h"
#include <assert.h>

//inicializo mi instancia a 0 o nulo
ManejadorAssets *ManejadorAssets::sIntancia = nullptr;

//definicion del constructor
ManejadorAssets::ManejadorAssets()
{
 //Solo permite un Manejador de Assets si no manda una excepcion

 //macro assert que verifica si la expresion es correcta
 assert(sIntancia == nullptr);
 sIntancia = this;
}

//definicion de obtenerTextura

sf::Texture &ManejadorAssets::obtenerTextura(std::string const &nombreArchivo)
{
 auto &mapTextura = sIntancia->m_Texturas;

 //observamos si la textura esta lista para cargarlas
 auto pairFound = mapTextura.find(nombreArchivo);

 //Si esta lista regresamos la textura
 if (pairFound != mapTextura.end())
 {
  return pairFound->second;
 }

 //si no carga la textura y la regresamos
 else 
 {
  //Creamos el elemento del map de la textura
  auto &textura = mapTextura[nombreArchivo];
  textura.loadFromFile(nombreArchivo);
  return textura;
 }
}

main.cpp

#include <SFML\Graphics.hpp>
#include "ManejadorAssets.h"

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(640 , 480), "Manejador de Assets para texturas y sprites");
 window.setFramerateLimit(60);

 //Creo mi objeto manejador de Assets
 ManejadorAssets assets;

 //Creo mis sprites
 sf::Sprite sprite1 = sf::Sprite(ManejadorAssets::obtenerTextura("frog.png"));
 sf::Sprite sprite2 = sf::Sprite(ManejadorAssets::obtenerTextura("ghost.png"));
 sf::Sprite sprite3 = sf::Sprite(ManejadorAssets::obtenerTextura("ladyBug.png"));

 //Le coloco la posicion de cada sprite
 sprite1.setPosition(10, 10);
 sprite2.setPosition(100, 100);
 sprite3.setPosition(300, 400);

 //GameLoop
 while (window.isOpen())
 {
  window.clear();
  
  //Dibujamos en la escena nuestras figuras
  window.draw(sprite1);
  window.draw(sprite2);
  window.draw(sprite3);

  //Eventos
  sf::Event event;

  //Se manejan los eventos
  while (window.pollEvent(event))
  {
   //Creo una sentencia switch para controlar muchos eventos
   switch (event.type)
   {

   //Cierra la ventana
   case sf :: Event::EventType::Closed:
    window.close();
    break;

   default:
    break;
   }
  }

  window.display();
 }

 return 0;
}

Notificaciones en android

En ejemplos anteriores hemos visto mensajes usando Toast, pero en esta ocasión veremos las notificaciones que son mensajes que quieren informar algo de mayor importancia para el usuario, sin mas aquí el ejemplo.

1.- Creamos un nuevo archivo en android

2.- Así se sera nuestra estructura para este proyecto

3.- Creamos un archivo .xml en res/layout y le llamamos notification.xml

4.- Agregamos el siguiente código.

notification.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent">

<TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Aqui los detalles de la notificacion"
        />
</LinearLayout>

5.- Ahora en src/nombrePaquete agregaremos una nueva activity llamada Notificacion.java

6.- Le agregaremos el siguiente código

Notificacion.java

package depredador1220.master.kenny;

import android.app.Activity;
import android.os.Bundle;

//import a utilizar
import android.app.NotificationManager;

public class Notificacion extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //agregamos la interfaz de la notificacion
        setContentView(R.layout.notification);

        //Creamos un objeto notification manager
        NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        //Ahora cancelamos la notificacion
        notificationManager.cancel(getIntent().getExtras().getInt("notificacionID"));
    }
}

7.- En el AndroidManifest.xml agregamos lo siguiente

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="depredador1220.master.kenny"
          android:versionCode="1"
          android:versionName="1.0">
    <uses-sdk android:minSdkVersion="13"/>
    <!--Agregamos un permison Vibrate para que nos avise con una vibracion del telefono-->
    <uses-permission android:name="android.permission.VIBRATE"/>
    <application android:label="kenny">
        <activity android:name="MyActivity">
                  <android:label="kenny">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <!--Agregamos el activity-->
        <activity android:name=".Notificacion" android:label="Detalles de la notificacion"/>
        <intent-filter>
            <action android:name="android.intent.action.MAIN"></action>
            <category android:name="android.intent.category.DEFAULT"></category>
        </intent-filter>
       <!--Aqui termina las declaraciones-->
    </application>
</manifest>

8.- Ahora toca llenar el main.xml le agregamos el siguiente código

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
        >

    <Button
            android:id="@+id/btnNotificacion"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Mostrar notificacion"
            android:onClick="onClick"
            />

</LinearLayout>

9.- Para el MyActivity,java pondremos lo siguiente.

MyActivity.java

package depredador1220.master.kenny;

import android.app.Activity;
import android.os.Bundle;

//imports a utilizar
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.view.View;

public class MyActivity extends Activity {

    int notificacionID = 1;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    public void onClick(View v)
    {
        displayNotificacion();
    }

    protected void displayNotificacion()
    {
        Intent i = new Intent(this, Notification.class);
        i.putExtra("notificacionID", notificacionID);

        //el PendingIntent carga la actividad si el usuario selecciona esta notificacion
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, i, 0);

        NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

        //Creamos la notificacion, para acceder al icono en Intellij IDEA se usa esta declaracion
        //y en android studio solo con R.drawable y el icono que contenga
        Notification notification = new Notification(android.R.drawable.ic_dialog_info ,
                "Recordatorio: Apoya al sitio dando clic en la publicidad", System.currentTimeMillis());

        //Creamos unos mensajes
        CharSequence destinatario = "Alarma del sistema";
        CharSequence mensaje = "Aqui casual con el depredador1220";

        notification.setLatestEventInfo(this, destinatario, mensaje, pendingIntent);

        //espera 100 ms, vibra 250 ms, pausa por 100ms y vuelve a vibrar por 500ms
        notification.vibrate = new long[]{100, 250, 100, 500};
        nm.notify(notificacionID, notification);
    }

}

10.-Y probamos, recuerda que la vibración la podemos experimentar mejor en un teléfono físico.