domingo, 30 de agosto de 2015

Plataformas 2D - Doble Salto y Marcadores de Suelo

Siguiendo con el anterior tutorial, este sera la continuacion, ahora crearemos un script de doble salto y le colocaremos restricciones, también verificaremos el suelo para que podamos crear una colisión mejor. Actualizare con un nuevo sprite y mejorando algunos aspectos.

1.- En el tutorial anterior comenzamos poniendo un boxcollider2D para este ejemplo lo cambiaremos por un Circlecollider2D primero tendremos que removerlo.




2.- Ahora colocaremos nuestro Circle Collider en un punto que quede el circulo casi para tocar el suelo usando por supuesto las herramientas de mover collider.


3.- Ahora crearemos un GameObject Vacio, para ello le daremos en el menu GameObject > Create Empty, le asignamos un nombre por ejemplo marcadorSuelo y lo colocamos por debajo del personaje y le daremos un marcador para identificarlo.





4.- Ahora que ya tenemos nuestro marcador se lo asignaremos al jugador para que se vuelva hijo al igual a la cámara para que cuando movamos a nuestro jugador la cámara se mueva junto con el.


5.-  Ahora compondremos el script agregando nuevas funcionalidades, le damos doble clic y agregamos el siguiente código.



ControlarJugador.cs

using UnityEngine;
using System.Collections;

public class ControlarJugador : MonoBehaviour {

 //variable para saltar
 public float alturaSalto;

 //variable para la velocidad del movimiento
 public float velocidadMovimiento;

 //Agregaremos un transform para asignarlo con el gameobject vacio
 public Transform marcadorSuelo;

 //El radio del marcador del suelo
 private float radioMarcadorSuelo;

 //El Layer que crearemos del suelo 
 public LayerMask layerSuelo;

 //variable booleana para identificar si esta en el suelo o no
 private bool estaEnSuelo;

 //variable booleana para el doble salto
 private bool dobleSalto;

 // Use this for initialization
 void Start () {
 
 }

 //funcion que se usa cuando usamos fisica
 void FixedUpdate()
 {
  //para verificar el suelo
  estaEnSuelo = Physics2D.OverlapCircle(marcadorSuelo.position, radioMarcadorSuelo, layerSuelo);
 }
 
 // Update is called once per frame
 void Update () 
 {
  //condicion de doble salto
  if(estaEnSuelo)
  {
   dobleSalto = false;
  }

  //MOVIMIENTO DEL PERSONAJE

  //Saltar, usamos la barra espaciadora para saltar
  //ahora verificamos con nuestro gameobject si esta tocando el suelo
  if(Input.GetKeyDown(KeyCode.Space) && estaEnSuelo)
  {
   //mando a llamar a mi funcion saltar
   Saltar();
  }

  //Aqui si cumple las condiciones podra realizar el doble salto
  if(Input.GetKeyDown(KeyCode.Space) && !dobleSalto && !estaEnSuelo)
  {
   //mando a llamar a mi funcion saltar
   Saltar();
   dobleSalto = true;
  }

  //Mover a la derecha, usamos la tecla D para movernos a la derecha.
  if (Input.GetKey(KeyCode.D)) 
  {
   GetComponent<Rigidbody2D> ().velocity = new Vector2 (velocidadMovimiento, GetComponent<Rigidbody2D>().velocity.y);
  }

  //Mover a la izquierda, usamos la tecla A para movernos a la izquierda.
  if (Input.GetKey(KeyCode.A)) 
  {
   GetComponent<Rigidbody2D> ().velocity = new Vector2 (-velocidadMovimiento, GetComponent<Rigidbody2D>().velocity.y);
  }
 }

 //Funcion que nos hace saltar
 public void Saltar()
 {
  GetComponent<Rigidbody2D>().velocity = new Vector2(GetComponent<Rigidbody2D>().velocity.x , 
   alturaSalto);
 }
}

6.- Ahora en nuestro script tendremos que asignarle nuestro marcadordesuelo que es nuestro game object para ello seleccionamos nuestro gameobject y se lo asignamos en la parte donde dice marcadorSuelo de nuestro Script.


7.- Una vez hecho eso crearemos dos layer nuevas el cual se llamaran Jugador y Suelo respectivamente.



8.- Ahora en nuestro jerarquía seleccionamos todo el nivel creado y  le asignamos el layer de Suelo.


9.- Ahora nos vamos a nuestro script y en la parte donde le dimos la variable layerSuelo ahi colocaremos el layer Suelo.


10.- Ahora, el marcador de suelo es un indicador para saber cuando estamos tocando el suelo, el cual nos servirá para poder la interacción con nuestro nivel, el gameobject vació colisiona con el suelo y nos manda un valor para poder realizar la condición del doble salto, si queremos verificar esta variable nos vamos en la parte de arriba del inspector y le daremos en modo debug y presionaremos play para ver en acción esta variable, podemos darnos cuenta al presionar al jugador y dirigirnos al  script, recuerda regresarlo como estaba para no perderte.




13.- Ya que tenemos todo, probamos para saber como nos quedo. En el siguiente ejemplo realizaremos la animación básica del personaje, saltar, quieto y correr(jump, idle, run).


Practica siempre para ir mejorando, la repetición y la constancia nos ayudan a mejorar, recuerda cada vez lo harás mejor, si te equivocas esta bien, permitirse equivocarse es la clave de mejora continua, así que permítete equivocarte mas seguido.

Si te gusta este sitio y deseas que esto continué vivo tu apoyo sera importante, puedes dar clic en la publicidad si lo deseas o puedes donar algo en Patreon si puedes permitírtelo, con esto el proyecto empezara a tener un objetivo y dejara de navegar sin rumbo y empezara a convertirse en una comunidad que ayudara unos a los otros, saludos y excelente día.

Plataformas 2D - Mover y Saltar personaje

Aprenderemos a crear elementos basicos de un juego de plataformas para ello primeramente realizaremos un proyecto donde el personaje se mueva en ambas direcciones y pueda saltar en un suelo que crearemos, veremos asignacion de fisica y scripting 2D sin mas comenzamos.

1.- Creamos un nuevo proyecto y le asignaremos que queremos en 2D a continuacion una captura.



2.- Crearemos 2 carpetas en una guardaremos los Sprites y en la otra el Script como muestro a continuacion.



3.- Ahora agregraremos nuestros sprites, para ello necesitamos uno que sea el jugador y otro para el suelo.



4.- Ahora cambiaremos las propiedades para poderlo manejar en unity como se muestra a continuacion, ambas le daremos en pixel per unit a 70 en ambos casos y le daremos en el boton de appy para guardar los cambios.



5.- Agregamos nuestros sprites a la escena si es necesario componer tamaños aplicar esos cambios.


6.- Ahora agregaremos la fisica para ambos sprites, para ello seleccionamos un sprite y le daremos en el boton de AddComponent del inspector y nos situaremos en Physics2D y en BoxCollider para que colisionen entre ambos objetos, aplicar para ambos.



7.- Ahora al personaje principal le agregaremos otro componente de fisica tambien, pero en esta ocasion sera un rigidbody2D.



8.- Cambiaremos algunos parametros del RigidBody para poder trabajar con este ejemplo, para ello seleccionaremos los que muestro a continuación, el primer ejemplo es para una versión anterior de unity y la siguiente es la actualización, se usa en unity 5.3 en adelante, ahora se utilizan los constraint
.





9.- Ahora podemos ver si el resultado es correcto, para ello le daremos en reproducir, si todo va bien el sprite de nuestro personaje principal rebotara con nuestro suelo, para ello intentamos subir un poco nuestro personaje para dar este efecto.


10.- Ahora que hemos probado, crearemos un C# Script en la carpeta de scripts y lo llamaremos ControlarJugador






11.- Le daremos doble clic para abrir el MonoDevelop e introduciremos el siguiente script.(CODIGO DESACTUALIZADO)




Pueden probar este código. 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ControlarJugador : MonoBehaviour
{
    //variable para saltar
    public float alturasalto;

    //variable para la velocidad del movimiento
    public float velocidadMovimiento;

    public Rigidbody2D rb;

    // Start is called before the first frame update
    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    // Update is called once per frame
    void Update()
    {
        //MOVIMIENTO DEL PERSONAJE

        //Saltar, usamos la barra espaciadora para saltar
        if (Input.GetKeyDown(KeyCode.Space))
        {
           rb.velocity = new Vector2(rb.velocity.x, alturasalto);
        }

        //Mover a la derecha, usamos la tecla D para movernos a la derecha.
        if (Input.GetKey(KeyCode.D))
        {
            rb.velocity = new Vector2(velocidadMovimiento, rb.velocity.y);

        }

        //Mover a la izquierda, usamos la tecla A para movernos a la izquierda.
        if (Input.GetKey(KeyCode.A))
        {
            rb.velocity = new Vector2(-velocidadMovimiento, rb.velocity.y);
        }
    }
}


12.- Ahora que hemos guardado nuestro script se lo asignaremos a nuestro personaje solo con seleccionar a nuestro personaje, despues buscamos nuestro script y lo arrastramos hasta el inspector.



13.- Ahora que hemos asignado el script le asignaremos valores a nuestras variables globales que declaramos, le daremos valores hasta que se ajusten a nuestro gusto para darle forma a la velocidad y al salto.


14.- Ahora si le daremos en reproducir para ver como nos quedo y si no cambiarle algunos valores, recordar que en nuestro script le asignamos para movernos las teclas A y D ambas para izquierda y derecha y para saltar la barra espaciadora. En la siguiente parte revisaremos lo del doble salto y marcadores en el suelo para poder mantener una restricción en el salto del personaje y tener indicadores o banderas para poder realizar nuestro código de manera mas efectiva.


Practica siempre para ir mejorando, la repetición y la constancia nos ayudan a mejorar, recuerda cada vez lo harás mejor, si te equivocas esta bien, permitirse equivocarse es la clave de mejora continua, así que permítete equivocarte mas seguido.

Si te gusta este sitio y deseas que esto continué vivo tu apoyo sera importante, puedes dar clic en la publicidad si lo deseas o puedes donar algo en Patreon si puedes permitírtelo, con esto el proyecto empezara a tener un objetivo y dejara de navegar sin rumbo y empezara a convertirse en una comunidad que ayudara unos a los otros, saludos y excelente día.

jueves, 27 de agosto de 2015

Declarando Texturas y Sprite en SFML

1.- Crearemos un programa donde declararemos una textura y le asignaremos al sprite para despues mostrarlo en pantalla.


Main.cpp

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

using namespace std;

int main()
{
 sf::RenderWindow ventana(sf::VideoMode(800, 600), "Texturas y Sprites");

 //Creo mi textura
 sf::Texture textura;

 //asigno mi textura
 if (!textura.loadFromFile("Raptor.png"))
 {
  cout << "Error al cargar Raptor.png" << endl;
 }

 //Una vez creada la textura podre asignarselo a mi Sprite
 sf::Sprite sprite;
 sprite.setTexture(textura);

 while (ventana.isOpen())
 {
  ventana.clear();
  sf::Event evento;

  //para mostrar el sprite
  ventana.draw(sprite);

  while (ventana.pollEvent(evento))
  {
   switch (evento.type)
   {
   case sf::Event::Closed:
    ventana.close();
    break;
   }
  }

  ventana.display();
 }
} 
 

Eventos LostFocus y GainedFocus en SFML

1.- Crearemos un evento de ventana que enfoca y desenfoca cuando le damos fuera de la ventana y cuando le damos en la ventana.


Main.cpp

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

using namespace std;

int main()
{
 sf::RenderWindow ventana(sf::VideoMode(800, 600), "Eventos de Ventana");

 while (ventana.isOpen())
 {
  sf::Event evento;

  while (ventana.pollEvent(evento))
  {
   switch (evento.type)
   {
   case sf::Event::Closed:
    ventana.close();
    break;

    //Evento LostFocus y GainedFocus
   case sf::Event::LostFocus:
    cout << "Perdida de enfoque" << endl;
    break;

   case sf::Event::GainedFocus:
    cout << "Recuperar enfoque" << endl;
    break;
   }
  }

  ventana.clear();
  ventana.display();
 }
} 

Evento Resized en SFML


Main.cpp

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

using namespace std;

int main()
{
 sf::RenderWindow ventana(sf::VideoMode(800, 600), "Eventos de Ventana");

 while (ventana.isOpen())
 {
  sf::Event evento;

  while (ventana.pollEvent(evento))
  {
   switch (evento.type)
   {
   case sf::Event::Closed:
    ventana.close();
    break;

    //Evento Resized
   case sf::Event::Resized:
    cout << evento.size.width << " : " << evento.size.height << endl;
    break;
   }
  }

  ventana.clear();
  ventana.display();
 }
} 

domingo, 23 de agosto de 2015

Accediendo a Miembros Privados de la clase base en Visual Studio 2013


Caja.h

#pragma once

class Caja
{
public:
 explicit Caja(double tv = 1.0, double anv = 1.0, double alv = 1.0) :
  m_Tam{ tv }, m_Ancho{ anv }, m_Alto{ alv } {}

 //funcion para calcular el volumen del objeto caja
 double volumen() const
 {
  return m_Tam * m_Ancho * m_Alto;
 }

private:
 double m_Tam;
 double m_Ancho;
 double m_Alto;
};


CajaJuguetes.h

#pragma once

#include <cstring>
#include "Caja.h"

class CajaJuguetes : public Caja
{
public:
 char *m_Contenidos;

 explicit CajaJuguetes(const char *str = "Juguetes") //Constructor
 {
  size_t tam{ strlen(str) + 1 };
  m_Contenidos = new char[tam];
  strcpy_s(m_Contenidos, tam, str);
 }

 CajaJuguetes(const CajaJuguetes &caja) = delete;
 CajaJuguetes operator=(const CajaJuguetes &caja) = delete;

 ~CajaJuguetes() //Destructor
 {
  delete[] m_Contenidos;
 }
};


Main.cpp

//Usando una funcion para heredar de la clase base
#include <iostream>
#include "CajaJuguetes.h"

using namespace std;

int main()
{
 Caja miCaja{ 4.0, 3.0, 2.0 };
 CajaJuguetes miCajaJuguetes;
 CajaJuguetes miCajaLegos{"Lego"};

 //muestra la cantidad de memoria que los objetos requiren
 cout << "miCaja ocupa: " << sizeof miCaja
  << " bytes" << endl
  << "miCajaJuguetes ocupa: " << sizeof miCajaJuguetes
  << " bytes" << endl
  << "miCajaLegos ocupa: " << sizeof miCajaLegos
  << " bytes" << endl;

 cout << "El volumen de miCajaLegos es: " << miCajaLegos.volumen() << endl;

 system("pause");
 return 0;
}

Clases Derivadas en Visual Studio 2013


Caja.h

#pragma once

class Caja
{
public:
 double m_Tam;
 double m_Ancho;
 double m_Alto;

 explicit Caja(double tv = 1.0, double anv = 1.0, double alv = 1.0) :
  m_Tam{ tv }, m_Ancho{ anv }, m_Alto{ alv } {}
};


CajaJuguetes.h

#pragma once

#include <cstring>
#include "Caja.h"

class CajaJuguetes : Caja
{
public:
 char *m_Contenidos;

 explicit CajaJuguetes(const char *str = "Juguetes") //Constructor
 {
  size_t tam{ strlen(str) + 1 };
  m_Contenidos = new char[tam];
  strcpy_s(m_Contenidos, tam, str);
 }

 CajaJuguetes(const CajaJuguetes &caja) = delete;
 CajaJuguetes operator=(const CajaJuguetes &caja) = delete;

 ~CajaJuguetes() //Destructor
 {
  delete[] m_Contenidos;
 }
};


Main.cpp

//Clases Derivadas
#include <iostream>
#include "CajaJuguetes.h"

using namespace std;

int main()
{
 Caja miCaja{ 4.0, 3.0, 2.0 };
 CajaJuguetes miCajaJuguetes;
 CajaJuguetes miCajaLegos{"Lego"};

 //muestra la cantidad de memoria que los objetos requiren
 cout << "miCaja ocupa: " << sizeof miCaja
  << " bytes" << endl
  << "miCajaJuguetes ocupa: " << sizeof miCajaJuguetes
  << " bytes" << endl
  << "miCajaLegos ocupa: " << sizeof miCajaLegos
  << " bytes" << endl;

 cout << "El tamanio de miCaja es: " << miCaja.m_Tam << endl;
 miCaja.m_Tam = 10.0;

 system("pause");
 return 0;
}

Estructuras en Visual Studio 2013


#include <iostream>

using namespace std;

struct Rectangulo
{
 int izquierda;
 int derecha;
 int arriba;
 int abajo;
};

//Prototipo de la funcion para conocer el area del rectangulo
long area(const Rectangulo &rect);

//prototipo de la funcion para mover el rectangulo
void moverRectangulo(Rectangulo &rect, const int x, const int y);

int main()
{
 Rectangulo jardin{ 0, 0, 100, 120 };
 Rectangulo alberca{ 30, 40, 70, 80 };
 Rectangulo casita1, casita2;

 casita1.izquierda = 70;
 casita1.arriba = 10;
 casita1.derecha = casita1.izquierda + 25;
 casita1.abajo = 30;

 casita2 = casita1;

 moverRectangulo(casita2, 10, 90);

 cout << "Las coordenadas de casita2 son: " << casita2.izquierda << " , "
  << casita2.arriba << " y " << casita2.derecha << " , "
  << casita2.abajo << endl;

 cout << "El area del jardin es: " << area(jardin) << endl;
 cout << "El area de la alberca es: " << area(alberca) << endl;

 system("pause");
 return 0;
}

//funcion para el area del rectangulo
long area(const Rectangulo &rect)
{
 return (rect.derecha - rect.izquierda) * (rect.abajo - rect.arriba);
}

//funcion para mover el rectangulo
void moverRectangulo(Rectangulo &rect, const int x, const int y)
{
 int tam{ rect.derecha - rect.izquierda };
 int ancho{ rect.abajo - rect.arriba };

 rect.izquierda = x;
 rect.arriba = y;
 rect.derecha = x + tam;
 rect.abajo = y + ancho;

 return;
}