Fisicas unity

Como manejar físicas en Unity (Evento)

Hola bienvenido/a a la nueva sección de eventos, publicaremos un evento cada 15 días. Estos son videoconferencias en vivo explicando algún tema en particular sobre el desarrollo de videojuegos en Unity.

Nota: Instalar Zoom meeting antes de la hora del live.

Se explicará como se debe utilizar correctamente las #colisiones 2D / 3D, #Rigidbody, #materiales físicos, etc. Además de prevenir los problemas más cometido en este área del desarrollo de #videojuegos.
Viernes 25 de agosto, 10 am Argentina.
Únete desde : https://zoom.us/j/448235588

Aprende a desarrollar una IA para tus NPCs parte 5

inteligencia artificial Unity (IA)

Hola a todos, bienvenidos a una nueva edición de como desarrollar una IA para tu NPC en Unity. Como había prometido hoy vamos a ver como rotar y mover nuestro personaje para que siga a nuestro player o jugador.Bien lo primero que debemos hacer es borrar las paredes que teníamos puestas de la edición anterior, los sensores dentro del NPC los desactivamos. (Para desactivar un objeto se debe destildar el check que se encuentra al lado de su icono y nombre). Una vez hecho esto debemos crear un cubo y nombrarlo Player, este mismo lo colocamos en alguna parte del escenario.Ya teniendo listo el escenario, vamos a la pestaña de proyectos y creamos un nuevo C# script dentro de la carpeta scripts y colocamos el siguiente código.

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

public class RotateToTargetAndMove : MonoBehaviour {
    public GameObject target;
    public float speedCharacter = 8.0f;

	void Update () {
        Vector3 pointA = gameObject.transform.position;
        Vector3 pointB = target.transform.position;
        Vector3 direction = pointB - pointA;

        float distance = Vector3.Distance(pointA, pointB);
        Debug.Log("Distancia:" + distance);

        Ray ray = new Ray(pointA, pointB);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

        if (Input.GetKey(KeyCode.Mouse0))
        {
            transform.LookAt(pointB);
            gameObject.transform.position += gameObject.transform.forward * 
            speedCharacter * Time.deltaTime; 
        }
	}
}

Como podrán ver es un código similar a las primeras ediciones, ahora vamos a pasar a explicar el código detalladamente.

inteligencia artificial Unity (IA)

 

Explicación del código

public GameObject target;
    public float speedCharacter = 8.0f;

La primer variable es la que ya habíamos creado en ediciones anteriores es para almacenar el objetivo del NPC, en este caso va a ser el Player, y la segunda variable determina con que velocidad se moverá el NPC.

Vector3 pointA = gameObject.transform.position;
        Vector3 pointB = target.transform.position;
        Vector3 direction = pointB - pointA;

Ahora definimos las 3 variables típicas de las ediciones anteriores las cuales usamos para determinar la dirección.

float distance = Vector3.Distance(pointA, pointB);
        Debug.Log("Distancia:" + distance);

Utilizamos nuevamente las variables declaradas anteriormente para determinar la distancia entre el NPC y el Player.

 

Ray ray = new Ray(pointA, pointB);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

Creamos un rayo a modo depuración para poder verlo en la pestaña de escena.

if (Input.GetKey(KeyCode.Mouse0))
        {
            transform.LookAt(pointB);
            gameObject.transform.position += gameObject.transform.forward * 
            speedCharacter * Time.deltaTime; 
        }

Este es el código nuevo, creamos un condicional que nos dice “si presionamos el click izquierdo del mouse…” nos rotamos en dirección al player (transform.LookAt(pointB)) y luego nos movemos en dirección a él con una velocidad determinada.Puesta en marcha Ahora borramos todos los scripts que estaban añadidos a nuestro NPC y agregamos el script que acabamos de crear. En la variable target debemos arrastrar el Player. Luego de eso estamos listo para probarlo.Bueno eso es todo espero que les haya gustado.
Nos vemos en la próxima edición en la cual les enseñare:

 “Como mejorar el movimiento del NPC”. 

Si te gusto este post comenta y comparte.

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Aprende a desarrollar una IA para tus NPCs parte 4

inteligencia artificial Unity (IA)

Hola a todos, bienvenidos a una nueva edición de como hacer una inteligencia artificial en Unity. Como había prometido hoy les traigo como desarrollar sensores para la detección de obstáculos en el entorno.Para comenzar vamos a ir a nuestra pestaña de proyectos, carpeta scripts, creamos un nuevo C# script y escribimos el siguiente código.

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

public class CoordinatesSensors : MonoBehaviour {
    public GameObject sForward,sBackward, sRight, sLeft;
    private GameObject obstacle;
	
	void Update () {
        Forward();
        Backward();
        Left();
        Right();
	}
    void Forward()
    {
        Vector3 point_A = gameObject.transform.position;
        Vector3 point_B = sForward.transform.position;
        Vector3 direction = point_B - point_A;
        float distance = Vector3.Distance(point_A, point_B);

        Ray ray = new Ray(gameObject.transform.position, sForward.transform.position);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

        RaycastHit[] hit;
        hit = Physics.RaycastAll(ray);

        if (hit.Length > 0)
        {
            foreach (RaycastHit h in hit)
            {
                obstacle = h.transform.gameObject;
                Vector3 posObstacle = obstacle.transform.position;
                Vector3 directionObstacle = posObstacle - point_A;
                float distanceObstacle = Vector3.Distance(point_A, posObstacle);
                Debug.Log("adelante " + h.transform.gameObject.name + " a distancia: " 
                + distanceObstacle);
                Debug.DrawRay(ray.origin, directionObstacle * 1.0f, Color.magenta);
                break;
            }
        }
    }
    void Backward()
    {
        Vector3 point_A = gameObject.transform.position;
        Vector3 point_B = sBackward.transform.position;
        Vector3 direction = point_B - point_A;
        float distance = Vector3.Distance(point_A, point_B);

        Ray ray = new Ray(gameObject.transform.position, sBackward.transform.position);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

        RaycastHit[] hit;
        hit = Physics.RaycastAll(ray);

        if (hit.Length > 0)
        {
            foreach (RaycastHit h in hit)
            {
                obstacle = h.transform.gameObject;
                Vector3 posObstacle = obstacle.transform.position;
                Vector3 directionObstacle = posObstacle - point_A;
                float distanceObstacle = Vector3.Distance(point_A, posObstacle);
                Debug.Log("atras " + h.transform.gameObject.name + " a distancia: "
               + distanceObstacle);
                Debug.DrawRay(ray.origin, directionObstacle * 1.0f, Color.magenta);
                break;
            }
        }
    }
    void Right()
    {
        Vector3 point_A = gameObject.transform.position;
        Vector3 point_B = sRight.transform.position;
        Vector3 direction = point_B - point_A;
        float distance = Vector3.Distance(point_A, point_B);

        Ray ray = new Ray(gameObject.transform.position, sRight.transform.position);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

        RaycastHit[] hit;
        hit = Physics.RaycastAll(ray);

        if (hit.Length > 0)
        {
            foreach (RaycastHit h in hit)
            {
                obstacle = h.transform.gameObject;
                Vector3 posObstacle = obstacle.transform.position;
                Vector3 directionObstacle = posObstacle - point_A;
                float distanceObstacle = Vector3.Distance(point_A, posObstacle);
                Debug.Log("derecha " + h.transform.gameObject.name + " a distancia: " 
                + distanceObstacle);
                Debug.DrawRay(ray.origin, directionObstacle * 1.0f, Color.magenta);
                break;
            }
        }
    }
    void Left()
    {
        Vector3 point_A = gameObject.transform.position;
        Vector3 point_B = sLeft.transform.position;
        Vector3 direction = point_B - point_A;
        float distance = Vector3.Distance(point_A, point_B);

        Ray ray = new Ray(gameObject.transform.position, sLeft.transform.position);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

        RaycastHit[] hit;
        hit = Physics.RaycastAll(ray);

        if (hit.Length > 0)
        {
            foreach (RaycastHit h in hit)
            {
                obstacle = h.transform.gameObject;
                Vector3 posObstacle = obstacle.transform.position;
                Vector3 directionObstacle = posObstacle - point_A;
                float distanceObstacle = Vector3.Distance(point_A, posObstacle);
                Debug.Log("izquierda " + h.transform.gameObject.name + " a distancia: " 
                + distanceObstacle);
                Debug.DrawRay(ray.origin, directionObstacle * 1.0f, Color.magenta);
                break;
            }
        }
    }
}

Bueno como podrán apreciar para los que están siguiendo esta saga, este código es muy similar al que ya habíamos visto en la edición anterior salvo algunos cambios. Básicamente lo que hicimos fue separarlo de alguna manera y lanzar un rayo en cada dirección.

Explicación del código

Ahora pasamos a explicar los cambios que hemos realizados en el código.

public GameObject sForward,sBackward, sRight, sLeft;

Lo que hemos hecho acá es dividir la variable target en 4 variables llamadas sensor+dirección, por ejemplo sIzquierda o en su traducción al ingles sLeft.

void Update () {
        Forward();
        Backward();
        Left();
        Right();
	}

Ya no tenemos escrito todo nuestro código en el método Update, sino que creamos 4 métodos individuales y los llamamos desde el Update.

void Forward()
    {
        Vector3 point_A = gameObject.transform.position;
        Vector3 point_B = sForward.transform.position;
        Vector3 direction = point_B - point_A;
        float distance = Vector3.Distance(point_A, point_B);

        Ray ray = new Ray(gameObject.transform.position, sForward.transform.position);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);
       //Continua...

Este es uno de los métodos individuales para cada dirección, en este caso es para la dirección hacia adelante. Lo único que modificamos en esto es cambiar la variable target por la variable correspondiente a la dirección del método en donde estamos.

inteligencia artificial Unity (IA)

 

Puesta en marcha

 

Bien, ya tenemos nuestro código listo pero aun no esta funcional, ya que debemos hacer algunos cambios en nuestra escena.Primero antes que nada tenemos que crear paredes a modo de obstáculos que servirán a nuestro NPC para detectar su entorno, pueden tener o no la misma forma que presentamos en la imagen.Segundo debemos crear 4 cubos dentro de nuestro NPC, a estos cubos le debemos sacar la colisión, desactivar el mesh renderer para que no se vean y colocarlo a 4 unidades de distancia desde el NPC. Es decir que debemos tener estos 4 cubos como hijo de nuestro NPC.Para colocarlo en 4 unidades seria de esta manera cuboDerecha (x=4), cuboIzquierda (x=-4), cuboAdelante(z=4), cuboAtrás(z=-4).Tercero para poder visualizar los sensores solo en la vista de escena, debemos cambiarle el icono a cada uno de ellos, esto se hace haciendo click en el cubo celeste que esta junto al nombre del objeto en la pestaña inspector.Y por último debemos borrar nuestro antiguo script de nuestro NPC, agregar este script y asignarle los 4 cubos según correspondan a sus direcciones.
Bueno eso seria todo espero que les haya gustado, nos veremos en la siguiente edición. Si te ha gustado el post no te olvides de comentarlo y compartir.
Siguiente edición Como rotar y mover nuestro NPC hacia el waypoint.
curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Aprende a desarrollar una IA para tus NPCs parte 3

inteligencia artificial Unity (IA)

Hola a todos bienvenido nuevamente a una nueva edición de como desarrollar una inteligencia artificial en Unity. Como lo prometido es deber, hoy vamos a ver como detectar obstáculos entre el NPC y el waypoint. Lo primero que tenemos que hacer es ir a nuestra pestaña de proyectos , ir a la carpeta de scripts y crear un nuevo C# script. Luego de eso escribimos el siguiente código:

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

public class RaycastArrayObstacles : MonoBehaviour {
    public GameObject target;
    private GameObject obstacle;
	
	// Update is called once per frame
	void Update () {
        Vector3 point_A = gameObject.transform.position;
        Vector3 point_B = target.transform.position;
        Vector3 direction = point_B - point_A;
        float distance = Vector3.Distance(point_A, point_B);

        Ray ray = new Ray(gameObject.transform.position, target.transform.position);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

        RaycastHit[] hit;
        hit = Physics.RaycastAll(ray);

        if (hit.Length > 0)
        {
            foreach (RaycastHit h in hit)
            {
                obstacle = h.transform.gameObject;
                Vector3 posObstacle = obstacle.transform.position;
                Vector3 directionObstacle= posObstacle -  point_A;
                float distanceObstacle = Vector3.Distance(point_A, posObstacle);
                Debug.Log("Primer obstaculo " + h.transform.gameObject.name + " a distancia: " 
                + distanceObstacle);
                Debug.DrawRay(ray.origin, directionObstacle * 1.0f, Color.magenta);
                break;
            }
        }
	}
}

Como podrán ver el código no es muy distinto al anterior, si se habrán dado cuenta que es una simple modificación del código de la edición numero 2. Es por lo cual antes de continuar debemos sacar el antiguo script de nuestro NPC y agregarle el que acabamos de crear.

Explicación del código

RaycastHit[] hit;
        hit = Physics.RaycastAll(ray);

Declaramos un array de variables de tipo RaycastHit con el nombre de hit. En dicho array almacenamos todas las colisiones que pueda tener nuestro antiguo rayo de detección llamado ray.

if (hit.Length > 0)
        {
            foreach (RaycastHit h in hit)
            {
                obstacle = h.transform.gameObject;
                Vector3 posObstacle = obstacle.transform.position;
                Vector3 directionObstacle= posObstacle -  point_A;
                float distanceObstacle = Vector3.Distance(point_A, posObstacle);
                Debug.Log("Primer obstaculo " + h.transform.gameObject.name +
                " a distancia: " + distanceObstacle);
                Debug.DrawRay(ray.origin, directionObstacle * 1.0f, Color.magenta);
                break;
            }
        }

inteligencia artificial Unity (IA)

Comprobamos si existen al menos una colisión que nos impida avanzar en la dirección de nuestro rayo. Si eso es cierto, recorremos a través de un foreach (estructura repetitiva similar a for) todas las colisiones almacenadas en nuestro array hit. Como a nosotros no nos interesan todas las colisiones vamos a trabajar únicamente con la primera que nos está obstruyendo el paso.A la variable obstáculo le asignamos el objeto que contiene la primer colisión. Creamos una variable de tipo Vector3 para almacenar la posición del obstáculo, también otra variable del mismo tipo para almacenar la dirección del mismo.Declaramos una variable de tipo flotante que almacene la distancia entre el NPC y el obstáculo, luego de eso imprimimos en consola el nombre del objeto obstáculo y su distancia ,para luego dibujar el rayo correspondiente a esa acción en la pestaña escena. Por ultimo y no por eso menos importante un break , el cual sirve para detener la búsqueda de colisiones una vez encontrada la primer colisión.

Bueno mis queridos seguidores eso es todo por hoy, en la próxima edición veremos:

“Sensores cardinales”.

No se olviden de comentar y compartir si les ha gustado esta edición.

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Aprende a desarrollar una IA para tus NPCs parte 2

inteligencia artificial Unity (IA)

Hola a todos bienvenidos nuevamente a la segunda edición este emocionante saga sobre inteligencia artificial aplicada a videojuegos. Como había prometido hoy vamos a ver como calcular la distancia y dirección entre el NPC y su respectivo waypoint. Lo primero que debemos hacer es crear un nuevo C# script en la pestaña de proyectos (Nota: si tienes una carpeta para scripts o programación debes crearlo ahí dentro.)Luego escribimos este código:

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

public class RaycastPointToPoint : MonoBehaviour {
    public GameObject target;
	
	void Update () {
        Vector3 pointA = gameObject.transform.position;
        Vector3 pointB = target.transform.position;
        Vector3 direction = pointB - pointA;

        float distance = Vector3.Distance(pointA, pointB);
        Debug.Log("Distancia: " + distance);

        Ray ray = new Ray(pointA, pointB);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);
        
	}
}

Como podrán apreciar este código es mas corto que el de la edición pasada. Recuerden, una vez escrito este código debe ser asignado su NPC (nota: si no tienen un NPC, creen una esfera para hacer la prueba).Lo que debe hacer este código es calcular la distancia y dirección entre ambos, y lanzar una linea de depuración para que veamos su comportamiento.

inteligencia artificial Unity (IA)

 

Explicación del código

Antes que nada les recuerdo que el nombre del archivo debe coincidir con el nombre de la clase principal.

 public GameObject target;

Dicho esto, lo primero que hacemos es crear una variable publica de tipo GameObject llamada target, en esta variable se almacenará el waypoint actual.

Vector3 pointA = gameObject.transform.position;
        Vector3 pointB = target.transform.position;
        Vector3 direction = pointB - pointA;

Declaramos 3 variables locales dentro del método Update de tipo Vector3 , este tipo almacena 3 valores flotantes etiquetados como x,y,z. A la primer variable le asignamos la posición de nuestro NPC ,a la segunda variable la posición de nuestro waypoint y por último a la tercer variable le asignamos la dirección. Para calcular la dirección entre 2 vectores basta con restar el primer vector al segundo.

 float distance = Vector3.Distance(pointA, pointB);
        Debug.Log("Distancia: " + distance);

Ahora creamos una variable local de tipo flotante llamada distancia a la cual le asignamos la distancia entre el NPC y el waypoint. Para hacer este calculo nos ayudamos de un método que nos provee Unity el cual pueden apreciar en el código. Luego de esto mostramos en consola el mensaje “Distancia: el valor de la variable”.

Ray ray = new Ray(pointA, pointB);
        Debug.DrawRay(ray.origin, direction * 1.0f, Color.red);

Antes de finalizar este script creamos una variable de tipo rayo llamada ray, en la cual decimos que este rayo sea desde el NPC hasta el waypoint. Después de eso, dibujamos este rayo en la pestaña de escena con un color rojo. Para dibujar este rayo lo primero que debemos hacer es decirle su origen, hacia donde se dirige y en que color va a estar representado.
Eso seria todo por hoy espero que les haya gustado y servido. Por el momento no estamos detectando nuevos waypoint ni obstáculos solo lo estamos calculando para luego utilizarlos en la siguiente edición.No te olvides de comentar y compartir.

En la próxima edición se verá la detección de obstáculos.
curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Aprende a desarrollar una IA para tus NPCs parte 1

inteligencia artificial Unity (IA)

Hola a todos bienvenidos a nuestra primer edición sobre inteligencia artificial para videojuegos. En esta guía mostraremos a modo de ejemplo como se realiza una IA en Unity. Si bien hay varias técnicas que se pueden utilizar en este motor, como el sistema de navigation que trae incluido el engine , pero en este caso vamos a hacer una programación basada en waypoint (puntos de camino).

Creación de WayPoints

Lo primero que debemos hacer es crear un nuevo proyecto en Unity. Crear un nuevo C# script en la pestaña de proyectos. (Recuerden tener su pestaña de proyecto bien organizada con carpetas de scripts, prefabs, scenes, entre otras). Una vez creado vamos a escribir el siguiente código.

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

public class NavPointCreator : MonoBehaviour {
    public int id;
    GameObject wp;
	
	
	void Update () {
        if (Input.GetKeyUp(KeyCode.Space))
            CreateTarget();
	}
    void CreateTarget()
    {
        if (wp != null)
            Destroy(wp);
        GameObject waypoint = GameObject.CreatePrimitive(PrimitiveType.Cube);
        waypoint.transform.position = new Vector3(Random.Range(7.0f, -7.0f), 0.03f, 
        Random.Range(7.0f, -7.0f));
        waypoint.name = "Waypoint " + id;
        id++;
        waypoint.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
        //waypoint.GetComponent<MeshRenderer>().enabled = false;
        wp = waypoint;
    }
}

Explicación del código C#

Para resumir lo que hace este código es simplemente crear un cubo en un punto aleatorio dentro de un rango, si el cubo esta creado lo destruye y crea otro en otra posición. Esto sirve para crear los destinos u objetivos para nuestro NPC, lo que le dará un comportamiento más natural a comparación de un comportamiento lineal o por animación.Ahora pasamos a una explicación mas detalla del código.
“`public int id;GameObject wp;“`Declaramos una variable publica de tipo entero llamado id, la cual usaremos para identificar cada waypoint. También declaramos una variable privada de tipo GameObject nombrada wp, la cual contendrá al objeto cubo que representa al waypoint.

void Update () {
        if (Input.GetKeyUp(KeyCode.Space))
            CreateTarget();
	}

Si tocamos la tecla espacio llamará al método de crear objetivo.

void CreateTarget()
    {
        if (wp != null)
            Destroy(wp);
        GameObject waypoint = GameObject.CreatePrimitive(PrimitiveType.Cube);
        waypoint.transform.position = new Vector3(Random.Range(7.0f, -7.0f), 0.03f, 
        Random.Range(7.0f, -7.0f));
        waypoint.name = "Waypoint " + id;
        id++;
        waypoint.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
        //waypoint.GetComponent<MeshRenderer>().enabled = false;
        wp = waypoint;
    }

Por último tenemos el método crear objetivo. Primero se comprueba si wp no esta vacio , en ese caso se destruye el wp existente, luego se crea un cubo nuevo en una posicion aleatoria dentro de un rango , se le asigna un nombre incluyendo en él su id, se le asigna un tamaño de 0.5 y luego se guarda el nuevo waypoint en la variable wp.Existe un código comentado que sirve para ocultar la parte visible del cubo, ya que a fines prácticos nosotros no queremos ver los waypoints de nuestros NPC’s.
Bien eso sería todo, espero que les guste, no se olviden de comentar y compartir si les gusto el post.

En la siguiente edición como detectar la distancia y dirección para que el NPC se dirija al waypoint.
curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Taller de videojuegos (Material para profesores)

hola a todos hoy damos el comienzo a un taller de programación de videojuegos. Cabe destacar que este taller esta orientado para adolescentes a partir de los 14 años. Aunque esto no limita que si deseas hacerlo puedas hacerlo teniendo una edad inferior a la establecida. Esta esta edad se impone para dar entender al publico de el porqué de la manera de enseñar los contenidos.
Sin mas vueltas vamos a nuestra primera presentación.

Taller de programación de videojuegos

Bueno una vez que ya hayan visto las 6 presentaciones , que por cierto son bastante cortas. Les explico que el objetivo de subir este material es facilitarle un poco la teoría a los profesores de Unity. Anteriormente establezco que el material esta diseñado para alumnos menores de edad, por lo cual el material es rápido , al grano y explicado de la manera mas coloquial posible.

Espero que les sirva , en caso de que no seas profesor y lo hayas leído ten en cuenta que el material no se explica por si solo , es tan solo un apoyo teórico para que los alumnos puedan recordad ciertos temas explicados en clases. Saludos y hasta la próxima.
¿Buscas un curso sobre cómo aprender a desarrollar videojuegos con Unity?

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Scripting C# : Properties

Hola a todos hoy les voy a enseñar como utilizar Properties en C#.
Los properties te permiten acceder a una variable privada de otro script , definiendo si solo quieres que sea leída o si también puede ser modificada desde un script externo.

Primero creamos un script C# con el nombre de “PJ”, luego escribimos lo siguiente:

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

public class PJ {
    int health = 5;

    public int vida {
        get
        {
            //Debug.Log("internal: "+ health);
            return health;
        }
        set
        {
            health = value;
        }
    }
}

Ahora creamos otros script con el nombre de “GameController” y copiamos lo siguiente:

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

public class GameController : MonoBehaviour {
    PJ player = new PJ();
    int health=10;
	// Use this for initialization
	void Start () {
        Debug.Log("gameController:"+health);
        Debug.Log("Pj:" + player.vida);
        player.vida = health;// set
        health = player.vida/2;// get
        Debug.Log("gameController:" + health);
        Debug.Log("Pj:" + player.vida);

    }
}

Bien , lo que deben hacer ahora es arrastras el GameController a un objeto vacío en una escena nueva. Al darle play veran en la consola algo como esto:

  • gameController:10
  • Pj:5
  • gameController:5
  • Pj:10

Como podran ven el valor de gameController se inverte con el de Pj. Para entender esto vamos a explicar que hicimos paso por paso.


Comencemos por el script Pj:

  • Borramos el MonoBehaviour de la clase
  • Creamos una variable privada de tipo entera con el nombre de health ,con un valor asignado de 5.
  • Creamos el properties ( public int vida) significa que es publico , devuelve un entero y su nombre es vida.
  • Recuerden que un properties es una variable por lo cual debe ir en minúsculas y no debe llevar paréntesis.
  • Abrimos y cerramos llaves , dentro de estas definimos el get y set . Cada uno de ellos con sus llaves correspondientes.
  • Dentro de get debe ir el return que es el valor que tiene que devolver, como ya lo habíamos definido arriba debe ser un valor entero , es por eso que devolvemos la variable entera (int) health.
  • Dentro de set debe ir la variable privada a la que estamos accediendo y le asignamos “value” donde esta el valor que fue asignado a vida.

Seguimos por el script GameController:

  • Creamos una variable de tipo Pj (nombre del otro script) con el nombre player y le asignamos una nueva instancia del mismo. Es decir creamos un Pj dentro de la clase GameController. Aunque les recomiendo saber sobre instancias antes de mirar este tutorial.
  • Creamos una variable privada de tipo entera con el nombre de health y le asignamos el valor de 10.
  • En el método Start imprimimos varios mensajes en consola con la sentencia Debug.Log.
  • Asignamos en la linea 12 al properties vida el valor de health de GameController, que en este caso es 10.
  • En la linea 13 asignamos a la variable health de GameController el valor del properties vida dividido 2 , ya que en la linea anterior habíamos cambiado su valor a 10.

Bueno espero que hayan entendido pronto actualizare este post con mas ejemplos de properties , así que no dejen ve verlo.

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Unity Ads: Como colocar publicidad a tu videojuego

Unity Ads: Como colocar publicidad a tu videojuego

hola a todos hoy les traigo un pequeño tutorial sobre como agregar publicidad a tu videojuego para Android o IOS. El proceso es bastante sencillo.
Paso 1:
Dirigirse a la Unity Ads Service  , y entrar en el botón “Comienza a monetizar ahora”. Te dirigirá al inicio de sesión de unity service, solo debes iniciar sesión o si aun no tienes cuenta debes crearte una. (Se inicia con la cuenta de Unity).

Ads Unity publicidad

Paso 2:

Una vez iniciado sesión , te aparecerán los proyectos ya existentes que tienes. En caso de no tener ninguno , debes crearte uno y seguir las instrucciones. (Este paso no lo explico ya que es muy sencillo). Luego , cuando te muestre tu proyecto en la pestaña “projects”, entras en el proyecto haciendo click sobre él.

Ads Unity publicidad

Paso 3:

A estas alturas estarás en una pantalla en donde se encuentras 4 pestañas , plataforma , estadísticas, ajustes e instrucciones.(Como se muestra en la captura)

Ads Unity publicidad

Paso 4:

Ahora nos dirigimos a la pestaña instrucciones. En esta pantalla , hay 2 apartados , integración fuera de Unity o integración dentro de Unity. En este tutorial enseñaremos como hacer al integración dentro de Unity.

  1. Descargar el Assets de Unity Ads ( enlace )
  2. Copiar tu ID de juego, que lo encontramos en la pantalla anterior en la pestaña plataformas.

Ads Unity publicidad

 

Nota: Dentro del proyecto de Unity , debería quedarle algo mas o menos similar a la captura.

Ads Unity publicidad

 

Paso 5:

En este ultimo paso , debemos crear un script dentro de Unity para poder utilizar el plug in de Unity Ads. En este tutorial mostraremos un ejemplo en C#. Donde se encuentra “0000000”, usted deberá poner su ID de juego.

using UnityEngine;
using UnityEngine.Advertisements;
using System.Collections;

public class SystemAds : MonoBehaviour
{
    bool _startAds = false;
    void Start()
    {
        #if UNITY_IOS || UNITY_ANDROID
            Advertisement.Initialize("0000000", false);                          
        #endif
        
    }
    void Update()
    {
        #if UNITY_IOS || UNITY_ANDROID
        if (UnityAds.isShowing==false && _startAds==true)
        {
            _startAds = false;
        }
        #endif
    }

    public void ShowAds() // metodo externo para llamar a las ads
    {
        #if UNITY_IOS || UNITY_ANDROID
        StartCoroutine(ShowAdWhenReady());
        #endif
    }
    IEnumerator ShowAdWhenReady()
    {
        while (!Advertisement.IsReady())
            yield return null;

        Advertisement.Show();
        _startAds = true;
        
    }
}

Nota: Para poder probar las ads antes de publicar el juego , ir a la pestaña de ajustes y habilitar el modo prueba. Luego de comprobar que todo funcione correctamente , desactivarlo. Tenga en cuenta que demora en activarse los verdaderos anuncios y es probable que por unas horas no tengan ningún anuncio funcionando.

Bueno espero que les haya gustado este pequeño tutorial. Espero que les sirva. Nos vemos y hasta la próxima.

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Como hacer un buen marketing para tu videojuego

Hola a todos , bienvenidos y gracias por visitarnos. En  el día de hoy les presentamos una guía sobre como hacer un buen marketing , aunque se que hay muchísima información respecto a esto; el enfoque que vamos a tener en este post es muy poco encontrado en otras webs, al menos en español.

Al hablar de marketing todos piensan en ventas , en imágenes y videos vistosos , en mucho dinero para invertir en ads de redes sociales , etc. Pero realmente ¿eso es lo que queremos lograr? ¿Nos da el resultado que nosotros estamos buscando? Es muy probable que no. Pero ¿porqué?, si estoy haciendo todo lo que dicen las paginas de marketing y los grandes líderes del sector publicitario. Es sencillo , vender un videojuego , es muy distinto a vender un curso, un auto , o cualquier servicio. ¿Cual es la diferencia? si las conceptos se pueden aplicar a cualquier producto (eso es lo que te venden todos los marketers).

Un videojuego tanto sea para android , ios , web , pc o cualquier consola , su objetivo no es vender el juego en si , sino es atrapar al cliente dentro del juego. ¿Te parece loco? No , no lo es. No nos sirve a nosotros tener 10 mil descargas si solo de esas 50 permanecen instaladas. Pero ¿qué paso acá?, ¿mi juego es tan malo? Hay dos motivos generales por lo cual pasa ese acontecimiento tan triste. El primero es que tu juego no tiene calidad suficiente como para atraer a la gente. El segundo tu juego si tiene la calidad , pero has llegado al publico equivocado. Es como querer venderle unos guantes de boxeo a un futbolista. Ese va a ser tu margen de ventas.

¿Porqué he llegado al publico equivocado? Por lo general el sistema de ads , para los que son nuevos, te trae gente equivocada. Para utilizar correctamente los ads , se tiene que ser lo mas especifico posible, no importa que salga un poco mas caro o llegues a menos publico, mientras ese publico sea el correcto. Aunque este post no se trata de enseñar como utilizar correctamente las ads, para eso hay mucho material y me parece innecesario hacerlo. Solo tengan en cuenta ese detalle antes de invertir en su campaña de ads.

 

Conceptos generales

Bien vamos a repasar los conceptos generales , conceptos que podemos encontrar en cualquier web.

marketing oranfy
Imagen de nuestro juego

Titulo: De tener un titulo seo o un titulo aso para móviles. Esto es todo lo que nos dicen , con eso prometen explicar la clave del éxito , aunque la mayoría de nosotros no sabe hacer un titulo seo eficiente o aso. Todos nos ponemos a investigar sobre seo que la mayoría de las técnicas son para webs no para juegos, o investigar aso , que en si te dices una cosa y otra, pero al menos en mi persona veo que todos hablan de lo mismo.

Imágenes: Las imágenes tienen que ser “promocionales” , con una calidad estupenda , llamativas , que resalte lo mejor de tu juego. Pero si pones una captura real de tu juego eso no vende , necesita hacer “marketing” , para que sientan el deseo de jugar al juego. Entonces , ¿les estoy vendiendo algo que no es? No , para nada (dicen ellos) solo les despertas el deseo por probar tu juego una vez dentro del juego ya los tienes. En realidad cuando están a dentro del juego si les has vendido algo muy fascinante y por dentro no lo es; en 2 segundos el cliente eliminará el juego y te dejara un comentario horrible.

Ahí esta su gran estrategia de marketing para vender. Están en lo cierto de que no se debe vender con capturas únicamente,  porque no llaman demasiado la atención del cliente, pero si deben haber algunas para que el cliente sepa como es el juego antes de descargarlo o comprarlo. Dirán , puff esto es algo muy básico y muy visto por internet, si pero he visto muchísimos juegos que únicamente tienen imágenes promocionales de diferentes características de su juego y no muestran como es el juego real.

Videos: Con un super video promocional que te cuesta un par de miles de dolares , le vendes a dios y a la madre santísima. Si , es cierto . El video promocional es uno de los que mas venden y los que mas despiertan esa necesidad por querer jugar a tu juego. Nuevamente repito que debe haber un gameplay real, ya que en la actualidad todos los usuarios saben de este truco publicitario y no se dejan guiar únicamente por el trailer.

Bueno me imagino que todos estos conceptos ya los habías leído antes en otras webs, esta repleto de copias de estos mismos métodos. Al igual que los métodos de monetización tanto sea compra , pago dentro del juego o por publicidad. En fin , no vine a hablar sobre eso, después de dar este pequeño pantallazo vamos a comenzar con el post.

 

Como hacer un correcto maketing para tu videojuego

Indagando por internet he encontrado muchísimos métodos , algunos mas efectivos que otros; pero comencé a combinarlos y poco a poco pude armarme un especie de mapa de marketing que se los describiré a continuación. (Nota: Es probable que muchas de lo que voy a decirles ya lo sepan)

Marketing de videojuegos: Se divide en varias partes.

  • Juego.
  • Tienda.
  • Herramientas.
  • Periodicidad de publicación.
  • Material necesario.
  • Plan de marketing.
  • Tips de tienda.
  • Comunicaciones.

Como podrán apreciar son 8 ramas en donde vamos a explicar en cada una de que trata y que hay que hacer en ella.

Juego: Este es el mas sencillo de todo , es la ficha técnica de nuestro juego.

  1. Localización (idioma).
  2. Analítica de juego ( como analizar a la competencia).
  3. Análisis de respuesta ( como analizar nuestro avance).
  4. Analítica de ventas ( como analizar nuestras ganancias).
  5. Enlaces sociales ( como analizar nuestra presencia en redes sociales).

Tienda: Es tan sencillo como saber a que plataforma/s va a estar destinado nuestro juego.

  1. App Store (iOS , TvOS).
  2. Google Play.
  3. Steam.
  4. Windows Store.
  5. Xbox.
  6. PlayStation.
  7. Facebook.
  8. Web.

Si bien hay muchas mas plataformas que esas , pero esas son las principales.

Herramientas:

  1. MailChimp ( newsletters automatizado).
  2. AppAnine ( monitorizar apps).
  3. Trello ( administrador de proyecto).
  4. Analitycs.
  5. Gameconfs (Eventos).
  6. Keywords ( KeywordPlanner , google trends , keywordtool, sensortower.com, appcodes.com , searchman.com , searchads.apple, onelook , apptweak).
  7. Hootsuite (planificador de publicaciones).

Como estas herramientas podrías listas muchas mas , para diversas actividades pero no quiero que se extienda aun más este post.

marketing redes sociales

 

Periodicidad de publicación:

  1. Una vez a la semana ( Blog personal , Linkedin, Forums, Twitch , Reddit).
  2. Dos o mas veces a la semana (Facebook, Twitter , Google plus, Instagram).

Antes de pasar al siguiente punto me gustaría hacer un apartado para facebook y twitter , así están mas orientado en lo que deben hacer. Tuve en cuenta de que la mayoría de los juegos actuales son en ingles o tiene la posibilidad de cambiar su idioma a ingles. Sabiendo esto , vamos a la lista.

Facebook:

  • Fanpage.
  • Grupos indies (indie groups) “Estos se detallas a continuación”.
  • Indie Game dev (#screenshotsaturday)
  • Promote your indie game
  • Indie game players ad developer
  • UnityIndieDevs
  • Indie game developers – game marketers
  • indiegamedevelopersunshine
  • Unity 3D
  • Indiedevhangout
  • Indie Game Dev Discussion
  • indiegamesmarketing
  • Indie Game Promotions (#ScreenShotSaturday)
  • Independent Game Developers
  • Unity3Dgame developers

Estos son algunos de los grupos que yo publicaría si necesito difundir mi juego.

Twitter:

  • #indieDevHour  (Miércoles 7 pm, UK time)
  • #ScreenShotSaturday
  • #MadeWithUnity (Viernes)
  • #IndieGame
  • #unity3d
  • #gamedev
  • #Indiedev
  • #IndieFeatureFriday
  • #UnityTips (Martes)
  • #IndieGameDev
  • #EpicFriday

Bueno estos son algunos de las hashtag que se utilizan para difundir en twitter, espero que les sirva.

Material necesario:

  • Trailer ( duración máxima 1.30 min , el logo de la compañia al final , resaltar los primeros 15 segundos).
  • Gif (Concentrarse en una cosa, corto y bonito , el bucle gif debe ser perfecto).
  • Imágenes ( Capturar solo el núcleo del juego).
  • Sitio web.
  • Kit de prensa.
  • Fanpage.
  • Twitter.
  • Indie DB ( base de datos).
  • Blog.
  • Engine Blog (MadeWithUnity).
  • Un slogan clave en la imagen clave / obras de arte.
  • Lista de deseos de periodistas.
  • Construye las 5 mejores características de tu juego.
  • Encuentre el punto de venta ( compare su mejor característica con la de su competidor para identificar el punto de venta único).
  • Resuma su juego en una oración.
  • Personalizar la línea de asunto (email).

Estos son algunos de los materiales más importantes a la hora de difundir tu videojuego.

Plan de marketing:

  • AMMA en reddit el día del lanzamiento.
  • Calendario de publicación.
  • Crear una línea de tiempo.
  • Modelo de negocio.
  • Medición.
  • Presupuesto.
  • Geografía.
  • Plataformas / Tiendas.
  • Audiencia objetivo (Sexo , Edad).
  • Competidor ( Quien es mi competidor  / Qué de valor ya está sirviendo mi competidor).
  • Cliente (Quién encontraría valor en el juego / Qué clientes no satisfecho vienen de mi competidor / Qué te llamaría la atención / Por qué descarga tu juego y no otro).

Este es un pequeño plan de marketing muy general , como para que tengas una guía de por donde empezar.

Tips de tienda:

  • Titulo localizado.
  • Descripción localizada ( Qué genero es / Como funciona el juego / Cuáles son las mejores características / Donde está el reto / Por qué es mejor que otro juego / La primera o segunda oración son las más importantes que escribirás).
  • Imagen localizada.
  • Metadatos y palabras clave localizados.
  • Encuentre las palabras clave adecuadas ( Relación / Competencia / En lugar de “carta de amor” o “carta a escribir”, utilice el amor, la carta, la escritura /  No es necesario usar plural / Búsqueda de hashtags relacionados con tu juego / Siga los perfiles de sus competidores en las redes sociales y lea lo que dicen sus seguidores / Siguiendo otros grandes perfiles relacionados con su nicho y viendo lo que sus seguidores están diciendo).

Algunos pequeños tips nunca están de mas y sobre todo cuando se trata de las tiendas.

Comunicaciones:

  • Días para enviar correos ( Martes y Miércoles).
  • Tenga en cuenta las zonas horarias.
  • Venda su historia tanto como el juego.
  • Contenido del correo ( Descripción corta / Enlace al trailer / Enlace al kit de prensa / Enlace al juego /No olvide incluir su punto de venta único / Personalizar la línea de asunto / Pedir comentarios).

El email marketing es muy importante , es muy común dejarlo en el olvido. Por eso les recuerdo usarlo , si se sabe usarlo puede ser una herramienta muy poderosa.

marketing
PD: Así he terminado después de hacer este post.

Bueno eso es todo por hoy , espero que les haya gustado . Un saludo y hasta la próxima.

¿Te gustaría aprender a desarrollar videojuegos con Unity?

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Cursos gratis en desarrollo de videojuegos con Unity

Hola a todos , hoy tenemos el primer post sobre cursos en desarrollo de videojuegos en Unity. Me imagino que dirán ¿Otra vez? Pero si ya me ofreció comprar un curso. Yo te digo que esperes y no saques conclusiones tan rápidamente.
Hoy les traigo 4 cursos completos totalmente gratuitos. Si , leyeron bien completamente gratis.

Creación de videojuegos con Unity 3D

Este es el primero de los cursos gratuitos , también el mas antiguo y mas completo de todos. Como podrán apreciar el curso tiene mas de 28 mil alumnos. Pero , ¿porqué tiene tanta cantidad de alumnos? Sencillo es un curso inicial que recorre todos los aspectos de unity desde 0 , sin necesidad de conocimientos previos. El curso tiene una duración de 16 horas de video , duplica esas horas para calcular las hora que te tomará desarrollarlo completamente entre ver el video , aprender lo visto y ponerlo en práctica.

Si el curso es tan bueno ,¿porqué es gratis?. Claro no es todo color de rosa , es gratis porque es muy antiguo , por lo que surgen 2 grandes inconvenientes , que algunas técnicas este obsoletas por la nueva version de Unity 5 y que los videos no tienen mucha calidad.  Me refiero en calidad de video , no a la calidad del contenido del video. Es ese el motivo por el cual esta gratis , si crees poder ignorar esos defectos te invito a que lo chequees , de todas maneras es gratis, si no te gusta te vas y listo.

Cursos gratis en desarrollo de videojuegos con Unity
Pulsa en la imagen para ir al curso

Curso acelerado de creación de videojuegos

Bien , este es el segundo de los 4 cursos gratis que ofrecemos en este post. Todos ellos hechos por nuestras propias manos. Este curso tiene una duración de 3 horas , como el mismo nombre lo dice es un curso intensivo que te enseña a codificar de una manera muy agresiva , por lo cual recomiendo , si no sabes nada de códigos , mírate primero el curso anterior. Razón por la que es gratuito , parte del contenido esta obsoleto por la version de Unity utilizada en los videos.

Cursos gratis en desarrollo de videojuegos con Unity
Pulsa en la imagen para ir al curso

Curso avanzado de Unity 3D

Aquí está el tercer curso de esta lista , en este caso es un curso bastante completo , se trata de seguir un proyecto final que habíamos iniciado en el primer curso de este post. Este curso tiene una duración de  horas , se centra en lo que es la programación en Unityscript (Js). Razón por la cual esta gratuito , algunos códigos estas obsoletos por la version de Unity usada en el video.

Cursos gratis en desarrollo de videojuegos con Unity
Pulsa en la imagen para ir al curso

Cómo desarrollar videojuegos para móviles

Bien , hemos llegado al final de esta lista. Con unos de los curso que en su momento fue muy bueno pero como todos estos cursos ya quedaron antiguos por eso están gratis. Este curso tiene una duración de 5 horas y te enseña como compilar para android , detectar touch , multiples touchs, como hacer un swipe con el dedo en 4 direcciones. La verdad que me gustó mucho este curso lastima que unity cambio tanto. Sin embargo , fue para mejor.

Cursos gratis en desarrollo de videojuegos con Unity
Pulsa en la imagen para ir al curso

Bueno espero que les haya gustado este post y que puedan disfrutar del mismo.

Tip: Maximizar vista previa del inspector

Tip: Maximizar vista previa del inspector

Hola a todos , en el día de hoy les traigo un nuevo tip. En donde explica como maximizar la ventana de pre-visualización. Que nos muestra unity en el inspector cuando seleccionamos un modelo , material o animación. Esto puede resultar muy útil cuando son modelos o animaciones detalladas. Y necesitamos verlos mas grande para poder apreciar el detalle. También, necesitamos comprobar si esta o no correcto antes de importarlo a nuestra escena de Unity.

Si les gusta esta serie de tips y no han logrado verlos todos , le dejare el enlace de la lista de reproducion.

¿Te gustaría aprender más sobre Unity?

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Dungeon Traps

Paquete: Dungeon Traps

Hola amigos , en el día de hoy les traigo un nuevo paquete de recursos para desarrollar videojuegos en Unity.  En esta occasion se trata de un paquete gratuito sobre material gráfico para trampas de Dungeon o calabozos. Todos los elementos son de baja poligonización (low-poly) , con una estética cartoon muy agradable visualmente. El paquete consta de 14 trampas con modelo , texturas y su respectiva animación de cada una. A decir verdad que es un muy buen paquete para ser gratuito , les recomiendo a quienes pueden llegar a utilizarlo que lo hagan.

¿Es recomendable utilizar assets descargados?

Si , es recomendable. Aunque depende de la situación en la que estemos desarrollando. Si eres un programador solitario y necesitas assets esta obligado a hacerlo. Sin embargo , en este caso no te recomiendo hacer un juego en esas condiciones. Ya que , no podrás conseguir todos los assets que requieres en un mismo lenguaje visual. Pero , ¿que es un lenguaje visual?. Un lenguaje visual , es un mismo estilo gráfico . Una armonía visual que comunica a todos los assets que pertenecen a un mismo mundo , a un mismo videojuego.

Entonces , ¿es o no recomendable?

La descarga de assets es buena para ahorrar tiempo en caso de que estén bien hechos y se adecue a tu lenguaje visual que ya has implementado en tu juego. Por ejemplo: No vas a poner unos arboles de alta calidad junto a otros assets como casas , vallas  hechos por ti , de baja calidad. Ya que se notará a la legua que los arboles no fueren hechos por ti. Y créeme que no vas a querer que eso lo sepa el usuario final.

Dungeon-Tramps

Dungeon-Tramps

Bueno espero que les haya gustado , no se olviden de compartir en sus redes sociales y de suscribirse si aún no lo has hecho. Hasta la próxima.

Tutorial “Realtime GI” parte 2

Resolución en tiempo real

Hola a todos aquí les traigo en español el tutorial oficial de Unity sobre “ realtime resolution”. Espero que les guste. De antemano les pido disculpa si en alguna ocasión la traducción no se entiende o es errónea. Si más para decir , vamos al tutorial:
(Para versión: 5.5 – Dificultad: Intermedio)

Se requiere haber leído la parte 1 de este tutorial : enlace

Cuando se configura una escena para la iluminación mediante “Precomputed Realtime GI”.Una de las primeras decisiones que se deben tomar. Es determinar la resolución en tiempo real predeterminada de su escena. Resolución en tiempo real es el número de texels de mapa de luz real (píxeles de textura) en tiempo real utilizados por el mundo de Unity.

Resolución en tiempo real se puede observar o establecer en la ventana de iluminación, de la siguiente manera:

  • Abra la ventana Iluminación (Window > Lighting) y, a continuación, seleccione la pestaña Scene.
  • Asegúrese de que la “Precomputed Realtime GI” esté activada marcando su casilla de verificación.
  • Observe la propiedad “Realtime Resolution” debajo de la casilla de verificación Precomputed Realtime GI.

Realtime GI

Ventana de iluminación de Unity que muestra la configuración global de la resolución en tiempo real de escenas.

 

Elegir una resolución en tiempo real adecuada

Al configurar una escena es importante tener alguna idea de la escala de unidad que su proyecto necesitará. Podría ser que en su proyecto una unidad es un metro, un pie o un centímetro. Las unidades Unity no tienen una equivalencia por defecto en la escala del mundo real. Por lo que depende del usuario decidir qué representa una unidad.
En nuestro proyecto de ejemplo hemos decidido que una unidad es equivalente a 1 metro. Ciertos conceptos de física asumen lo mismo. Por ejemplo, la gravedad se representa en unidades por segundo como un valor predeterminado en Unity. Suponiendo que una unidad es equivalente a 1 metro . Es por lo tanto una buena configuración para un escenario de juego del mundo real.

A menudo la resolución en tiempo real de tu escena puede determinarse a partir de la escala de tu mundo de juego. Por ejemplo, ¿es su escena pequeña, pero el interior ricamente poblado con un montón de variación en “bounced lighting”?. En este caso, las resoluciones de mapa de luz es más alta, como 2-3 texels por unidad .Podrían justificarse para capturar esta iluminación más detallada o de “alta frecuencia”.

Tal vez su escena es un gran ambiente al aire libre. Donde la escala mundial es considerablemente más grande. Usted puede tener superficies que son cientos o incluso miles de unidades en el área con poca variación para modificar el color de la “bounced lighting”. En casos como estos, una resolución que sea apropiada para capturar los detalles de iluminación presentes en una escena interior. Sería un desperdicio cuando se aplicara a través de las extensiones grandes y menos destacadas de un entorno al aire libre.

Estaríamos desperdiciando valioso tiempo de CPU y memoria disponible por tener que almacenar y actualizar texels de mapa de luz que no están contribuyendo mucho a la apariencia general de la escena. Lo que es más importante, para los propósitos de este tutorial, estaríamos aumentando el número de texels de mapa de luz que deben ser considerados durante el precomputo de iluminación. Esto puede tener un impacto enorme en tiempos precomputación.

En el caso de un entorno exterior, una resolución de mapa de luz apropiada puede estar entre 0.5 -1 texels por unidad para objetos grandes dentro de la escena, o 0.1 – 0.5 texels para el terreno.

 

Resolución GI en tiempo real  vs. mapas de luz tradicionales

Los valores de resolución en tiempo real requeridos por el “Precomputed Realtime GI” de Unity . Son órdenes de magnitud menores que las densidades de texels tradicionales de mapa de luz. Esto se debe a que sólo estamos captando la iluminación indirecta en estos mapas de luz. Y esto tiende a ser muy suave o “baja frecuencia”. Cuando se utiliza la “Precomputed Realtime GI”, las sombras nítidas normalmente se proporcionan por sombras en tiempo real en lugar de mapas de luz de alta resolución.
El uso de valores que parezcan apropiados en las técnicas tradicionales de lightmapping – digamos 30 texels por unidad – probablemente resultará fallos o de otra manera no completado. Los valores más adecuados son alrededor de 2 – 3 texels por unidad para escenas interiores, y 0.5 – 1 para ambientes al aire libre. Esto es suponiendo que estamos trabajando con una escena escala humana. Con un tamaño de unidad de 1 unidad = 1 metro. Si la escala mundial fuera sustancialmente diferente, estos valores tendrían que ser ajustados en consecuencia.

Scenario Realtime Resolution
Interiores 2 – 3 texels por unidad
Exteriores 0.5 – 1 texels por unidad
Terrenos 0.1 – 0.5 texels por unidad

Valores apropiados suponiendo un mundo de escala humana con 1 unidad que representa 1 metro.

Al configurar inicialmente la resolución en tiempo real de nuestra escena, estamos especificando la resolución predeterminada, para objetos estáticos dentro de nuestra escena. El nuevo GameObjects con un MeshRenderer marcado como Lightmap Static en la parte superior del Inspector. Usará este valor hasta que se modifique de otra manera.

Además de elegir la resolución en tiempo real para toda la escena. También tenemos la opción de cambiar la resolución del mapa de luz por objeto. En los casos en que necesitamos la fidelidad adicional ofrecida por resoluciones más altas, podemos aumentar selectivamente este valor. En general, es menos trabajo establecer la resolución más común como predeterminado de escena. Y, a continuación, aumentar manualmente la resolución en aquellos objetos que necesitan más detalles de iluminación. Discutiremos los enfoques para modificar la resolución por objeto más adelante en el tutorial.

 

Configuración de la resolución en tiempo real de nuestra escena

Si desea seguir adelante, estaremos trabajando en la escena LightingTutorialStart incluida con el Tutorial de optimización de iluminación vinculado en la parte superior de esta página.
En nuestro escenario de ejemplo, tenemos un ambiente al aire libre con un terreno de tamaño medio de un color razonablemente constante. Para ello, una baja resolución en tiempo real de 0,5 texels por unidad. Esto sería suficiente para capturar la iluminación rebotada de otros objetos en la escena.

Sin embargo, también hay una serie de casas de madera. Estos son mucho más detallados. Como hay muchas más casas que objetos de terreno en la escena, debemos establecer la resolución en tiempo real para que sea apropiada para las casas. Podemos entonces modificar la resolución utilizada por los objetos del terreno individualmente. Esto reducirá la cantidad de trabajo necesario al preparar nuestra escena. Con esto en mente, vamos a utilizar un valor de 1 texel por unidad mundial para nuestra resolución por defecto en tiempo real.

  • Abra la ventana Iluminación (Window > Lighting) y seleccione la pestaña Scene.
  • Establezca el valor de  “Realtime Resolution” en 1.

Teniendo en cuenta que hemos decidido que la escala de nuestra escena sea 1 unidad = 1 metro, esto significa que un único texel de mapa de luz creado por el “Precomputed Realtime GI” de Unity equivaldrá a 1x1m de tamaño. Esto puede parecer muy bajo, pero recuerde que sólo estamos captando la luz indirecta. Sombras nítidas y especularidad de la iluminación directa serán proporcionados por luces en tiempo real en la escena.

Bueno , eso seria todo por el día de hoy , si te ha gustado este tutorial no olvides subscribirte (aquí) para ser notificado por correo cuando publiquemos la siguiente parte de este tutorial. (Se publicará una parte por semana).
¿Te gustaría aprender más sobre Unity?

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.

Unity 5.6 beta ya está disponible

Nuestra última versión beta incluye un editor mejorado , características 2D, mejor rendimiento gráfico, un nuevo reproductor de video y soporte para Facebook Gameroom y Google DayDream.

Estamos muy contentos de anunciar el lanzamiento de Unity 5.6 beta. La versión beta está disponible para todos los usuarios de Unity. Incluidos los usuarios de la Personal Edition (gratis).

Esperamos que sus proyectos se beneficien de las muchas características y mejoras en la versión 5.6 beta. Esperamos sus comentarios y entregamos lanzamientos cada vez más pulidos durante este ciclo beta.

Compruebe las notas de la versión para obtener una lista de los problemas conocidos.

 

Únete a nuestro proceso de prueba beta

Si aun no forma parte de nuestro “Programa Beta“, es sencillo comenzar. Vaya a nuestra sección de pruebas beta en Unity3d.com .Consulte la guía y descargue el instalador para obtener acceso.

 

Si experimenta problemas en la versión beta

Si experimenta problemas con la versión 5.6 beta. Le recomendamos que presente un informe de errores utilizando el Unity Bug Reporter .Accesible a través del menú Ayuda en el editor y publicarlos en los Foros Beta.

 

¿Qué hay en la versión beta 5.6?

Soporte para Vulkan – Llega el rendimiento gráfico al siguiente nivel.

Vulkan es una nueva generación de gráficos y API de cálculo. Este proporciona acceso de alta eficiencia y multiplataforma a GPUs modernas en plataformas de escritorio y móviles. Está diseñado para aprovechar los múltiples núcleos de la CPU al permitir que múltiples subprocesos se ejecuten en paralelo. Esto significa una mayor velocidad con la reducción de la sobrecarga del controlador y la carga de trabajo de la CPU. Dejando a la CPU libre para hacer cálculos adicionales o renderizado. En total, hemos visto una mejora del rendimiento del renderizado hasta el 60% con Unity. Sin tener que lidiar con ningún detalle de la API de Vulkan.

Unity caracteristicas

En la versión 5.6 beta, use Vulkan. Para llevar el rendimiento gráfico al siguiente nivel. En la versión final, Vulkan se ejecutará en Android, Windows, Linux y Tizen.

 

Mejoras gráficas:

El código de colisión de partículas para colisionadores 2D . También ha sido completamente reescrito utilizando la nueva biblioteca SIMD, lo que resulta en un aumento significativo de rendimiento.

 

Nuevo reproductor de vídeo con reproducción de 4k y soporte de 360 grados

La versión 5.6 beta contiene un reproductor de vídeo completamente nuevo reconstruido desde cero con el rendimiento en mente, por lo que puede soportar vídeos de 360 VR y suavizar la reproducción de 4K. Su objetivo es utilizar las capacidades de hardware de vídeo tanto del editor como de las plataformas de destino. Cuenta con compatibilidad de hardware H.264 / AAC disponible en una amplia variedad de plataformas y la implementación de software VP8 / Vorbis para situaciones en las que no es posible o deseable usar H.264 / AAC. El soporte para otros códecs se agregará en el futuro. El reproductor de vídeo simplemente funciona como un nuevo componente de objeto de juego para reproducir películas en su escena para proporcionar experiencias de video interactivo de inmersión en 360 grados. Para ver una demostración de cómo funciona, compruebe la keynote de Unity 2016:

 

Nuevas funciones para Unity Collaborate

Para aquellos que no están familiarizados con Unity Collaborate, es un nuevo servicio basado en la nube que permite a los equipos pequeños ahorrar, compartir y sincronizar su proyecto Unity, por lo que el equipo está siempre al día. Es fácil de usar para que todo el equipo pueda contribuir al proyecto, independientemente de su ubicación o función, mejorando así el flujo de trabajo de manera significativa.

Sobre la base de los comentarios de los clientes de Betas anteriores, hemos añadido algunas de las características más solicitadas, incluyendo publicación parcial, que permite a los usuarios publicar los archivos seleccionados; Anteriormente, tendría que publicar todos los archivos cambiados a la vez.

Con Ignorar archivos también puede ignorar archivos y directorios en su proyecto que no desea enviar al proyecto, y la nueva característica de reversión le permite abrir la ventana Historial de colaboración y en tan sólo unos clics revertir los cambios en tu preferencia.

 

Soporte de iOS para informes de rendimiento de Unity

Unity Performance Reporting recolecta automáticamente errores de aplicación, a través de dispositivos y plataformas, por lo que es más fácil para usted y su equipo encontrar y resolver problemas en tiempo real. El informe de rendimiento de Unity 5.6 beta captura e informa de los fallos registrados en los juegos de iOS. Se espera soporte para más plataformas en el futuro. Por ahora, pruebe Informes de rendimiento en su proyecto Unity. No se requiere ningún código, simplemente haga clic en el botón Activar para “Informes de rendimiento” en la ventana Servicios.

Unity caracteristicas

 

Soporte de Google VR Daydream & Cardboard

La versión beta admite Google Daydream nativo. Para obtener un rendimiento y latencia óptimos de la plataforma, nos integramos con el Daydream NDK para aprovechar los modos de reproyección asíncrono y VR de la plataforma.

En comparación con el SDK de Google VR para Unity publicado en Google I / O, ahora ofrecemos un flujo de trabajo más optimizado, optimizaciones significativas y latencia reducida. No se necesitan prefabricados, scripts o modificaciones manuales para empezar, simplemente habilite VR y agregue Daydream como una plataforma específica para comenzar a crear sus propios mundos virtuales.

También hemos facilitado la entrada y salida del modo VR para que sus aplicaciones se puedan expandir fácilmente al público de Google VR. También puede tener su aplicación destinada a Google Cardboard con soporte nativo. Las aplicaciones que apuntan a Cardboard funcionarán en dispositivos antiguos para que pueda llegar a tantos usuarios como sea posible. En este momento, el apoyo de Cardboard es exclusivo de Android con soporte para iOS Cardboard que viene pronto.

Si está interesado en conocer más acerca de Google Daydream con Unity, consulte la presentación Unite 2016 Daydream.

 

Soporte para Facebook Gameroom

Con Gameroom, Facebook ha introducido una forma más fácil para los desarrolladores de traer juegos de alta calidad a la PC, y aprovechar al máximo la CPU y la potencia nativa de la GPU como una aplicación para PC dedicada separada del feed de noticias.

Con la versión beta, puede implementar sus proyectos en la nueva aplicación de escritorio de Facebook Gameroom para Windows como reproductor nativo de Windows o en Facebook.com con el soporte WebGL de Unity.

Todo lo que necesitas viene integrado con Unity de forma gratuita, desde compartir contenido con amigos de Facebook hasta administrar compras en la aplicación. Incluso puedes subir tus creaciones para que sean alojadas por Facebook directamente desde el Editor de Unity.

Unity caracteristicas

Unity características

 

Próximamente en 5.6

Tenemos varias otras características que vienen en el ciclo 5.6  que no son parte de esta versión beta. Lo más destacable es el nuevo Progress Lightmapper para mapas luminosos que proporcionan iteraciones rápidas y ETA predecible

Cuando lanzamos Unity 5.0, reemplazamos a Beast con Enlighten tanto para la iluminación global horneada como en tiempo real (GI). La nueva solución para paneles de luz se basa en la tecnología líder del sector, lo que aumenta el rendimiento del “bake”.

El progresivo mapa de luz mejora en gran medida el flujo de trabajo para “bakear” la iluminación en una escena, y hemos añadido un ETA en la barra de progreso, por lo que es fácil ver cuándo terminará el “bake”.

Para ver el lightmapper progresivo en la acción compruebe hacia fuera el keynote de Unity 2016.

En beta 2 vamos a añadir modos de luz. Los modos de luz están reemplazando la iluminación de modo mixto, proporcionando formas flexibles y eficientes de combinar sombras “bakeadas” y en tiempo real. Esto viene con la capacidad de “bakear” sombras, proporcionando sin fisuras “sombras en tiempo real”. El resultado será una alta reducción en la distancia de sombra en tiempo real para un mayor rendimiento. Se ha añadido sombra en tiempo real para cada tipo de luz y ruta de representación.

También hemos rediseñado la ventana de iluminación para una mejor usabilidad, y hemos añadido una nueva ventana Light Explorer para agilizar el trabajo de los artistas de iluminación.

Como anteriormente habíamos mencionado, Unity 5.6 saldrá en su versión definitiva en el 2017.
PD: Pedimos disculpas si en ciertas ocasiones la traducción no es correcta o no se entienda.

¿Te gustaría aprender más sobre Unity?

curso sobre desarrollo de videojuegos en unity
Pulsa en la imagen para ir al curso.