#Script Mirar a otro objeto #unity3d #javascript C#

El siguiente Script está basado en propiedades básicas predeterminadas por Unity, mediante la cual podemos hacer que la cámara o un personaje siga por así decirlo con la "vista" a otro objeto.

#Script Colisión o Collision GameObject #unity3d #javascript

La colisión o collision en #unity3d es la acción por la cual un gameobject u objeto choca con otro. Luego de este encuentro se puede indicar que el mismo desaparezca o que realice otra acción por ejemplo bajar vidas. ¿Pero como hacer para que se active la colisión cuando toca otro objeto y este no le cae encima?

Ejemplo tomado del sitio oficial de Unity3d - Sección Tutoriales.

En #unity así como existe el OnTriggerEnter para el ingreso en zonas sensibles, existe también el OnCollisionEnter. Este permite activar la acción cuando el elemento entre en contacto con otro. Pero deben tener en cuenta que esto solo funciona cuando el elemento que tiene el script cae y toca el otro. O por lo menos a mí solo me funciona de esa forma. 

Para lo cual he recolectado un video tutorial de Will Goldstone en el cual ejemplifica lo indicado.

En el ejemplo que vimos el cubo posee el script y se activa al chocar el cubo con el plano. El script que se usa en este video es el siguiente. La acción Debug.Log("mensaje"); sirve para enviar un mensaje por consola, en este caso para validar que el cubo toca el piso.

* JS

-------------------------------------------

function OnCollisionEnter (col : Collision)
{
    if(col.gameObject.name == "prop_powerCube")
    {
        Destroy(col.gameObject);
    }

}
-------------------------------------------

Pero que pasa si no queremos que la colisión se active cuando cae el objeto sobre el player sino cuando es tocado por el player o cuando este lo roza. Por ejemplo cuando un enemigo nos ataca.

Para solucionar este inconveniente debemos de usar el siguiente Script en JS o JavaScript para que al momento que el player toque un objeto este comience a enviar un mensaje. Por ejemplo si deseamos que cuando el player toque una pared esta le quite vidas, o para que cuando el enemigo colisione con el player este le quite vidas también.

* JS

-------------------------------------------

function OnControllerColliderHit ( hit:ControllerColliderHit  ){

if( hit.gameObject.tag == "Enemigos"){

Debug.Log ("me están matando");

}

}

-------------------------------------------

Con este script estamos indicando que cuando el Player colisione con el objeto de tag Enemigos se envíe el mensaje. Como observar en este caso quien posee el script es el Player y necesitar crear los tags necesarios para los enemigos, objetos u otros a usar.

Si no sabes como crear tags puedes revisar el siguiente link. 

#Script cambiar textura skybox #unity3d #javascript

En el desarrollo de videojuegos llega un momento en el cual es necesario cambiar la textura que posee el skybox o cielo por otra diferente al activar un objeto o entrar a un nivel diferente. 

Ejemplo: cuando deseamos que al pasar por una zona sensible el cielo se oscurezca o se aclare.

En el siguiente script en Javascript indicaré de forma sencilla como afectar la textura del Skybox.

* JS

-------------------------------------------

var mat1 : Material;

var mat2 : Material;

function OnTriggerEnter () {

      RenderSettings.skybox = mat2;

}

function OnTriggerExit () {

      RenderSettings.skybox = mat1;

}

-------------------------------------------

El Script posee dos variables de tipo "material" en el cual almacenaremos nuestra textura del cielo o del skybox. Es necesario indicar que el material debe de contener las 6 texturas para que el efecto visual sea el apropiado. 

Estos materiales se activaran al momento que entramos o salimos de una zona sensible y en el código RenderSettings accedemos a la opción skybox. Que es idéntico al hacerlo por medio del menú principal en la opción de Edit / RenderSettings.

Y con eso ya tenemos el script que al ingresar a la zona sensible se muestre el material 2 y al salir se muestre el material 1. Osea que se cambie el cielo al entrar a la zona.

#Script boton touch salir juego #unity3d c# - game touch button

Cuando se elaboran juegos para dispositivos móviles como Android o IOS siempre es necesario elaborar el botón de salir de la aplicación para permitir al usuario regresar al uso normal de su teléfono.

El siguiente script está codificado para su uso TOUCH o TÀCTIL.



El lugar donde se coloque el botón de salir puede ser en el menú, así como también en cada paso de un nivel a otro. Esto permitirá al usuario regresar a su dispositivo sin ningún inconveniente y sobretodo si molestia.

El siguiente código se encuentra desarrollado en C#.

* C#

-------------------------------------------

using UnityEngine;

using System.Collections;

public class boton_salir : MonoBehaviour {

public GUITexture boton;

void Update () {

if (Input.touchCount > 0) {

for (int i = 0; i < Input.touchCount; i++) {

Touch t = Input.GetTouch (i);

if (t.phase == TouchPhase.Began) {

if (boton.HitTest (t.position, Camera.main)) {

Application.Quit();

}

}

}

}

}

}

-------------------------------------------

Como pueden observar en el código la sentencia para salir de la aplicación es : Application.Quit();
Se ha creado una variable para almacenar la textura del botón. Y en el Update se valida la acción de tocar la pantalla, en otras palabras se valida el touch.
El primer if sirve para el funcionamiento de la opción touch. Y el segundo y tercero sirva para validar que el botón sea el que se haya presionado. Por eso la validación if (boton.HitTest (t.position, Camera.main))

#Script muestra vida #unity3d c#

En el post antrior indicaba como hacer una barra de vidas por medio de JS. En este  post indicaré como realizar un HUD de vidas pero basado en texturas. En otras palabras los famosos corazones de vida que disminuyen en los videojuegos al momento que un enemigo nos ataca.

El script que se muestra a continuación está elaborado en C#. Para lo cual hemos de crear dos script, uno para mostrar los corazones en pantalla y otro para disminuir los corazones al ingresar a la zona sensible.

Para el desarrollo del ejemplo he utilizado la opción de GUITexture de la barra de Herramientas. Gameobject/Creater Other/ GUI Texture. Esta opción generará una textura en pantalla la misma que podemos asignarle la textura que deseamos mostrar. La textura a mostrar van a ser los 3 corazones que se muestra en la imagen.

El primer script que escribiremos será el que se encargue de validar si la variable vida ha disminuido y de ser así que cambie a la textura de dos corazones, un corazón y ningún corazón. Como el script se encuentra en c# favor tener el consideración el nombre del archivo para que no genere conflicto al copiar el script. El archivo lo llamaremos "hud_corazones".

* C#

-------------------------------------------

using UnityEngine;

using System.Collections;

public class hud_corazones : MonoBehaviour {

public GUITexture  image;

public Texture2D  Image_01; 

public Texture2D  Image_02;

public Texture2D  Image_03;

public Texture2D  Image_04;

public static int vida = 3; // variable vida

void Update () {

if (vida ==3) {

image.texture =  Image_01;

}

if (vida ==2) {

image.texture =  Image_02;

}

if (vida ==1) {

image.texture =  Image_03;

}

if (vida ==0) {

image.texture =  Image_04;

}

}

}

-------------------------------------------

Como se observa en el script se han creado varias variables de tipo Texture2D para almacenar las diferentes texturas cada vez que van disminuyendo las vidas. Adicional se adicionó una variable de tipo int llamada vida, en esta variable almacenaremos las vidas. Y como se observa en la funcion Update ( en c# void Update) hemos de validar si vida es = 3 se muestra la textura con 3 corazones, y si llega a 0 se muestra la textura sin corazones. 

Vista del GUITexture con los dos script.

Hasta este punto ya hemos desarrollado todo lo que necesitamos para que funcione. Nos tocará crear un cubo que sirva de enemigo para que al momento de entrar en el, este afecte a la variable vida y la disminuya y así que se muestren menos corazones.

El script para disminuir las vidas lo llamaremos "enemigo" y también se encuentra escrito en c#

* C#

-------------------------------------------

using UnityEngine;

using System.Collections;

public class enemigo : MonoBehaviour {

void OnTriggerEnter () {

hud_corazones.vida = hud_corazones.vida - 1;

}

}

-------------------------------------------

Y con eso hemos terminado.

Si tienes alguna duda o consulta no dudes en comentar.

#Script Barra de vida #unity3d - Health Bar

En todo videojuego existen diferentes formas o maneras de mostrar las vidas del player o enemigos. Por lo tanto he considerado importante realizar un script basado en JS (javascript) el cual muestre por medio de una barra, las vidas del personaje principal.

Como se indica en la parte superior este script está realiazado en JS.

En primera instancia lo que debemos de tener en consideración es la relación existente entre los siguientes scripts. Primero debemos de crear el entorno en el cual nuestro player se va a ver afectado por el enemigo.

En mi caso he elaborado un plano, un cubo (enemigo), y el player (Primera Persona). Se pueden optimizar los scripts a realizar pero en mi caso he elaborado 3 Scripts para que se aprecie la mecánica.

El primer Script "muestra_vidas" se lo colocaremos a la cámara o a un gameobject vació, puesto que este script permitirá que se muestren las texturas de la vida del player. Este script posee la variable progress en la cual almacenaré la vida total del player. Las variables de tipo Texture2D sirven para adicionar las texturas de la barra de vida y la del fondo de la barra. Las texturas a usar pueden estar en formato PNG.

Adicional se han aumentado variables de tipo float que permiten almacenar el tamaño de la pantalla a visualizar y realizar una operación matemática para devidir la pantalla en cinco partes iguales. Pero esto se explicará en otra publicación.

*JS

------------------------------------------------

var progress : float= 0;

var progressBarEmpty : Texture2D;

var progressBarFull:Texture2D;

static var ScreenX:float;

static var ScreenY:float;

static var AnchoxPantalla: int;

static var AltoxPantalla:int;

function OnGUI () {

//barra vacia (posicionx,posiciony, ancho, alto)

GUI.DrawTexture (Rect(ScreenX*0.1,ScreenY*0.1,400,140), progressBarEmpty);

//barra llena

GUI.DrawTexture (Rect(ScreenX*0.55,ScreenY*0.65,progress,20), progressBarFull);

}

function Update (){

AnchoxPantalla=Screen.width;

AltoxPantalla=Screen.height;

ScreenX = (Screen.width)/5;

ScreenY=(Screen.height)/5;

progress = PlayerStat.vida; //llamo a la variable vida que se encuentra en el script PlayerStat

}

------------------------------------------------

La función OnGUI dibujará en la pantalla la barra de vida y el fondo. Como se ha comentado el GUIDrawTexture mostrará la textura almacenada en progressBarEmpty, y en otra línea se mostrará progressBarFull, la barra que se irá debilitando apenas el player reciba daño.

La variable progress almacenará el valor total de las vidas, osea que al principio esta tiene 250 vidas, pero por cada daño esta va a bajar 50pts. Si revisamos el GUIDraw de la progressBarFull, nos damos cuenta que en el ancho no tenemos un valor fijo, sino que el ancho va a estar guiado por los puntos de la vida.

Hasta este momento solo hemos mostrado las barras de vida pero no poseen interacción con el player. Para lo cual crearemos el segundo script llamado "PlayerStat" en este script creamos la variable vida que almacenará el total de la vida del player. Aquí realizamos el cálculo del daño, donde la funcion Update valida al momento que vida sea 0 se active la funcion dead (cambio de nivel), y para resetear la variable vida luego le asignamos los 250pts. Este Script se lo ponen al player.

*JS

------------------------------------------------

static var vida = 250;

function Update (){

if(vida <= 0){

Dead();

}

}

function Dead(){

Application.LoadLevel("enemigo 2");

vida = 250;

}

------------------------------------------------

El último script a realizar lo llamaremos "baja_vidas" Este script lo tiene el enemigo, y en este le indicamos cuanto es el daño que va a ocasionar. En mi caso he simplificado el ejemplo usando el OnTriggerEnter a un cubo.

En este script lo único que se realiza es cuando entra a la zona sensible la variable vida es restada por 50pts.

*JS

------------------------------------------------

function OnTriggerEnter () {

PlayerStat.vida = PlayerStat.vida -50;

}

------------------------------------------------

Y con esto hemos elaborado nuestra barra de vida. Debemos de tener claro que cuando llegue "vidas"a cero se cambiará de escena. La misma mecánica se puede usar para restar vidas al enemigo u otros elementos.

Si tienes alguna duda o consulta no dudes en comentar.

#Script para pausar el juego en #unity3d - Pause a game

El siguiente Script es de uso frecuente en los juegos, puesto que con este podemos pausarlo y luego continuar jugando. En el script a continuación se indica como mostrar la textura al momento de la pausa.

En el Script se permite al usuario pausar el juego al presionar la tecla "P". Es necesario indicar que al momento de parar el tiempo, el player también dejará de moverse. Se puede reemplazar por cualquier tecla donde indica "KeyCode.(letra)" pero es necesario al momento de escribir la letra que esté en mayúscula. En el caso de no usar por medio de una letra, puede cambiar la sentencia por otra condición.

*JS
----------------------------------------------
function Update () {
    if (Input.GetKeyDown (KeyCode.P)) {
         Time.timeScale = 1.0-Time.timeScale;
         Time.fixedDeltaTime = 0.02 * Time.timeScale;
    }
}
----------------------------------------------

El timeScale se usa para efectos de movimiento lento. Cuando el timeScale es 1.0 el tiempo pasa más rápido que en el tiempo real. Cuando es 0.5 el tiempo pasa 2 veces más lento que el tiempo real. Si es de 0 el juego se detiene si todas sus funciones trabajan con velocidad de fotogramas independientes.

Si deseas aumentarle al código la opción de mostrar un mensaje al momento de la pausa, deberíamos de adicionar una variable de Boolean (verdadero y falso) y la función OnGUI para mostrar la textura o texto.

La variable textura es de tipo Texture2D para almacenar la textura a mostrar. Si observan en el siguiente script en la función update se aumentó una línea que valida si muestra es verdadero o falso. Dependiendo de ese valor de "muestra" se activará la función OnGUI, la cual crear un cuadro con los valores de (230,130,400,400) estos valores corresponden a (x, y, ancho y alto) y la "," seguida de la variable indica que se muestra la textura. Si se desea mostrar un texto en vez de una textura se debe de modificar el GUI.Label y al final poner el texto seguido de comillas.

*JS

----------------------------------------------

var textura : Texture2D;
var muestra : boolean;

function Update () {
    if (Input.GetKeyDown (KeyCode.P)) {
         Time.timeScale = 1.0-Time.timeScale;
         Time.fixedDeltaTime = 0.02 * Time.timeScale;
         muestra=!muestra;
    }
 
}

function OnGUI(){
if(muestra){
    GUI.Label(Rect(230,130,400,400), textura); // muestra textura
    GUI.Label(Rect(100, 100, 50, 30), "Pausa"); // muestra texto
    }
}
----------------------------------------------

#Script #Unity uso de video como textura

Para usar la opción de video se debe de contar con la versión Pro de Unity. En Unity los videos son considerados como texturas animadas (tiene lógica), los formatos de videos aceptados son: mov, mpg, mpeg, mp4, avi, asf
En el caso de exportar para IOS este usa solo las extensiones de mov, mp4, mpv y 3gp
En el caso de exportar para Android este acepta las siguientes extensiones: H263 , H264 AVC, MPEG-4 SP, VPS

En el caso de Android el sitio web oficial de Unity (Documentacion/Manual) indica que el videoTexture no son compatible y que en lugar de esa opción se ofrece la reproducción de Streaming de pantalla completa utilizando la opción Handheld.PlayFullScreenMovie.

El uso de videos en unity es un poco complejo, hasta el momento no se puede usar de forma fácil el canal alfa de un video, lo único que se puede hacer es cambiar es el "shader" del video y poner "Particles/Aditive" y de esa forma parece que el video tiene la propiedad del alfa.

Una vez cargado el video en nuestro proyecto debemos de probar que se reproduzca el mismo. Para reproducir el video seleccionamos el archivo y en el "Inspector" se habilita la opción de Play (icono).
Si al dar clic en Play el video se reproduce no existe ningún problema, si el video no se reproduce puede ser por incompatibilidad con la extensión del video.

Luego de tener el video en nuestro proyecto el proceso más sencillo es asignárselo a un cubo o a un plano para que en este elemento se reproduzca. El video no se va a reproducir hasta que no usemos un script. Para lo cual he desarrollado algunos ejemplos en Javascript :  para ejecutar el video, cambiar a otra escena al finalizar el video y el ejemplo tradicional de unity que viene en la documentación.

Con esta línea de código indicamos que se reproduzca el video.

renderer.material.mainTexture.Play();

En el Script que visualizaremos a continuación se ha creado una variable de tipo MovieTexture para almacenar el video a ejecutar. A esa variable de video le hemos indicado que el loop (repetición de animación) se encuentra activo o true. A la variable se la activa la opción Play o en su defecto Stop.

Script JS
----------------------------------------------
var movTexture : MovieTexture;

function Update(){
movTexture.loop = true;
renderer.material.mainTexture = movTexture; // Se indica que la textura se asigna a esa variable
movTexture.Play();
}
----------------------------------------------

Se puede realizar una pequeña variación en el Script superior para validar cuando el video se termine de reproducir cambie de escena. Para lo cual usaremos las funciones Start y Update. En la funcion Start indicaremos que se ejecute el video, y en la funcion Update consultaremos si el video no se está reproduciendo cambie de escena. Como se observa en el Script ya no se usa la opción del loop del video.

Script 2 JS
----------------------------------------------
var movTexture : MovieTexture;

function Start(){
  renderer.material.mainTexture = movTexture;
  movTexture.Play();
}

function Update(){
if (!movTexture.isPlaying)Application.LoadLevel("NombreNivel"); //el signo "!" se lee Sino
}
----------------------------------------------

Este es el Script tradicional que encontramos en la página de Documentación de Unity, en el cual por medio de la barra de espacio o tecla "Jump" procedemos a poner Play al video, en el caso de ser presionada de nuevo el botón "Jump" el video se pondrá en pausa. A este mismo script le podemos hacer una variación y cambiar el Update por OnTriggerEnter u OnTriggerExit y aplicarlo a zonas sensibles.

Script 3 JS 
-------------------------------------------
function Update () {
    if (Input.GetButtonDown ("Jump")) {
       if (renderer.material.mainTexture.isPlaying) {
            renderer.material.mainTexture.Pause();
        }
        else {
            renderer.material.mainTexture.Play();
        }
    }
 
}
-------------------------------------------

#Script elaboración de #menu en #unity3d

Cuando nos encontramos elaborando un juego nos es siempre necesario elaborar el menú respectivo de la aplicación tanto para escoger niveles, para cambiar de escenas o para salir.

A continuación indicaré el proceso necesario para elaborar el menú y su salto a las respectivas escenas siguientes.

La imagen pertenece a un mini juego que realicé para El Telégrafo referente a la participación de Ecuador en el Mundial Brasil 2014.

Para poder elaborar el menú puedes realizar los botones de dos formas por medio de #GUITexture o por el uso de #planos. En mi caso lo vamos a realizar por medio de planos.

1. Colocamos los planos necesario en el escena, en mi caso vamos a colocar 4 planos para el botón empezar, instrucciones, marcador y créditos.

Para incluir los planos, seleccionamos en el menú la opción GameObject/Crear Objeto/ Plano

* Es necesario que el objeto a usar sea plano, esfera, cubo o lo que sea tenga la propiedad del Collider.

2. Creamos el script en este caso llamado menú, el script está creado en JS

*-JS-*
----------------------------------------------------------------------------------------
var btn_empezar : boolean;
var btn_instrucciones : boolean;
var btn_creditos : boolean;
var btn_back : boolean;
var btn_marcador : boolean;


function OnMouseDown (){
if (btn_empezar == true){
Application.LoadLevel("nivel1");
}
if (btn_instrucciones == true){
Application.LoadLevel("instrucciones");
}
if (btn_creditos == true){
Application.LoadLevel("creditos");
}
if (btn_back == true){
Application.LoadLevel("menu");
}
if (btn_marcador == true){
Application.LoadLevel("score");
}
}
----------------------------------------------------------------------------------------

Como pueden observar en el script se han creado variables de tipo "boolean" para cada nivel. Estas variables nos servirá poder usar el mismo script para todo el menú sin necesidad de crear un script para cada cambio de nivel.

Otro punto importante a considerar es que la acción va a ser cuando se de presione cada uno de los planos con el mouse, empieza a validar que botón se presionó y procede al cambio de escena.

3. Hasta aquí es lo más complejo de todo, ahora lo que toca es poner el script a cada plano que hace de botón, y dar check en el script para indicarle que botón es.

Nueva opción de inmersión al 100% con #Unity

Sixense, empresa famosa por desarrollar controladores de movimiento en entornos virtuales busca conseguir que cualquier persona pueda elaborar juegos 100% inmersivos, indiferente del nivel de programación.

Dicha empresa ha creado un kit de desarrollo llamado SixenseVR SDK que se integra con Unity y Unreal Engine, dos de los más populares software para videojuegos. Desde Sixense han desarrollado este software para que sea compatible con STEM, sistema de realidad virtual que facilita hasta cinco puntos de movimiento, cuenta con gafas, sensores en cada extremidad, por lo tanto la inmersión en el juego es total.

SixenseVR es una API multiplataforma que utiliza datos de posición y orientación de los sensores de movimientos conectados a la cabeza (casco) y manos. Utilizando datos del sensor conectado a la cabeza se puede posicionar cada una de las manos con precisión dentro del campo de visión del usuario, garantizando la coordinación mano-ojo casi perfecta.

Visita SixenseVr SDK

#Script activar y desactivar diferentes camaras #Unity

Para poder activar y desactivar cámaras en Unity se puede realizar de forma simple con el siguiente Script en el cual asignamos las diferentes cámaras a usar y por medio de una tecla procedemos a cambiarla.

Este tipo de efecto se visualiza con mayor frecuencia en los juegos de carros en los cuales podemos cambiar a diferentes vistas como frontal, lateral, superior o posterior.

Script JS
--------------------------------------------------------------------------------------
var cam1 : Camera;
var cam2 : Camera;

function Start() {
//activo y desactivo las camaras necesarias
    cam1.enabled = true;
    cam2.enabled = false;
}

function Update() {

    if (Input.GetKeyDown(KeyCode.C)) {
    //al presionar la tecla c se activa la camara desactivada y se desactiva la otra camara
        cam1.enabled = !cam1.enabled;
        cam2.enabled = !cam2.enabled;
    }

}
--------------------------------------------------------------------------------------

También se pueden activar las cámaras de la siguiente forma

--------------------------------------------------------------------------------------
function Update () {
   if (Input.GetKeyDown ("2")){
      camera1.camera.enabled = false;
      camera3.camera.enabled = false;
      camera2.camera.enabled = true;
   }
   if (Input.GetKeyDown ("1")){
      camera1.camera.enabled = true;
      camera2.camera.enabled = false;
      camera3.camera.enabled = false;
   }  
   if (Input.GetKeyDown ("3")){
   camera3.camera.enabled = true;
   camera2.camera.enabled = false;
   camera1.camera.enabled = false;
    }
}
--------------------------------------------------------------------------------------

#script Activar animaciones en modo Mecanim #unity3d

Luego de haber revisado mi otra publicación con respecto a "Animación con #Sprite en #Unity o animación con secuencias de imágenes 2D" procederé a indicarte como activar las animaciones realizadas con sprite por medio de un script.

En la publicación anterior llegamos hasta animar cada movimiento.

Luego de haberlos realizado debemos de relacionar cada movimiento con el otro, y para poder realizar eso debemos de seleccionar el movimiento que da paso al otro, o en otras palabras seleccionar la animación previa a la siguiente. En mi caso voy a proceder a relacionar todas las animaciones con animacion_espera o conocido como idle.

Para poder relacionarlas como se indica en la imagen debemos de dar clic derecho sobre la animación_espera y seleccionar la opción "make transition" y arrastrar la fecha con la animación que deseamos relacionar.

Y así proceder a relacionar cada una de las animaciones con las otras, es necesario indicar que la dirección de la flecha indica que animación se ejecuta luego.

Es importante indicar que animación es la principal. Reconocer la animación principal es fácil puesto se pone de color naranja. Si la animación de color naranja no deseamos que sea la principal podemos dar clic derecho en otra animación y seleccionar "set as default" para que sea la principal.

Luego de realizar ese proceso, necesitamos crear variables para validar en qué momento se debe de realizar que animación. Animator acepta variables de los siguientes tipos : Float, int, bool, trigger. En el caso de este ejemplo hemos seleccionado Bool o booleano que sirve para la variable verdadero o falso.

Como se observa en la imagen superior he procedido a crear tres variables camina, golpe, y salto de tipo bool que se encuentran desactivadas, para que cuando se activen se active la siguiente animación.
En cada una de las líneas de transición entre cada animación debemos de asignarle que variable debe de afectar a que animación, para así por ejemplo solo se ejecute la animación_salto cuando la variable salto sea verdadera.
Pero antes se debe de confirmar que en la animación principal o por defecto se encuentre activa la opción Solo en todas las animaciones relacionadas, con esto estamos limitando que solo se ejecute la animación cuando se valide la variable.

Cuando seleccionemos cada línea de transición podemos observar que animación se ejecuta previo y después. Y así mismo en la parte inferior encontramos la sección de "conditions o condiciones" en la cual al desplegar el box podemos encontrar nuestras variables creadas. En cada línea que une a las animaciones activaremos las variables respectivas y en el valor indicaremos "true o verdadero". Por ejemplo si queremos activar la animación del golpe del personaje iremos a la línea que une a idle con animacion_golpe y asignaremos la variable golpe con el valor true.

Y ahora toca crear el script que de valor de positivo a cada variable para que se ejecute la animación, por ejemplo que cuando aplastemos la barra espaciadora nuestro personaje salte. El script a continuación se encuentra en C#. Claro este script debe de poseerlo nuestro player.
El script se encuetra comentado para mejor comprensión.

C# "Activa Animacion"
----------------------------------------------------------------------------------------
using UnityEngine;
using System.Collections;

public class activa_animacion : MonoBehaviour {

Animator ani; //esta variable guardará el animator

void  Start (){

ani = GetComponent<Animator> (); //aquí asignamos el animator a la variable
}


void  Update (){

if (Input.GetButtonDown ("Jump")) {
// si se presiona la barra de espacio se activa la variable salto y se le dá valor positivo
ani.SetBool ("salto", true); // con esta línea se activa la animación
}

if (Input.GetButtonDown ("Horizontal")) {
ani.SetBool ("camina", true);
}


}
}
----------------------------------------------------------------------------------------

Animación con #Sprite en #Unity o animación con secuencias de imágenes 2D

Cuando deseamos elaborar un videojuego tipo 2D un factor importante es conocer el funcionamiento de los sprite en unity.
A continuación indico de forma breve como se procede con el trabajo de importación de sprite en Unity.

Antes que nada es necesario conocer que los sprite son en otras palabras secuencia de movimientos de algún objeto o personaje populares en las consolas de videojuegos como Nintendo en 1978.

Para importar una secuencia de sprite debemos de colocar el archivo PNG dentro del proyecto de unity e indicarle que esta imagen pertenece al tipo de textura de sprite.

Si vas a importar movimiento por movimiento puedes trabajar con el sprite mode single, para que sea una sola imagen pero si vas a trabajar en un solo png con una secuencia de movimientos debes de cambiar del sprite mode single a Multiple y dar clic en el botón Sprite Editor.

En mi caso he seleccionado una imagen de secuencia de movimientos de internet y la imagen posee varios movimientos. Al dar clic en Sprite Editor se habilitará una nueva ventana que te permitirá realizar el corte por slice de cada uno de los movimientos, y así te evitas tener que poner movimiento por movimiento, y unity lo hace complemente rápido por tí.

En este venta posees la opción en Slice de realizar de forma manual dibujando el recuadro en cada elemento, o usar la opción automática de unity y dar clic en slice y automáticamente unity selecciona los elementos, siempre es bueno revisar que los cortes sean los correctos. luego de haber arreglado los cortes de ser necesario procede a dar clic en "apply" y se procederán a generar la secuencia por cada imagen en la vista project.

Ahora el proceso a seguir es realizar la animación incorporando la posición inicial de la animación en la scena, y luego crear la animación en la opción "window/animation". Luego de crar la secuencia fluida de la animación procederemos a crear todas las animación que tiene el personaje.

Para adicionar al mismo personaje más animaciones puedes dar clic en el nombre de la animación en la ventana de animación, y se habilitará la opción "Crear nuevo clip".

Luego de crear todas las animaciones necesarias puedes revisar cada una de estas en la vista Animator y proceder a crear la secuencia y las validaciones respectivas para que se active cada animación en el momento necesario. Eso será materia de otra publicación.

Si deseas revisar esta publicación en video puedes verla en el siguiente link de donde yo tomé como base para realizar esta entrada. https://www.youtube.com/watch?v=Kq4MkZDlTQY

Les dejo la imagen del sprite para que pueden hacer sus pruebas.

Unity: inconveniente con "the animation clip used by the animation component must be marked as legacy" y script para animación

Para el uso tradicional de animaciones en Unity nos encontramos con el siguiente mensaje de error: "the animation clip used by the animation component must be marked as legacy" esto indica que el método del script está llamando a una animación la cual no es "legacy" sino que se encuentra como "mecanim".

Este inconveniente se da desde las versiones superiores a 4.3 en Unity.

En mi caso he querido hacer que al ingresar a la zona sensible de un cubo, este tenga una ligera animación.

El script usado es el siguiente en JS
------------------------------------------------------------------------
var  objeto: GameObject; //Objeto que se desea animar
var animacion : String; //animación a efectuar

function OnTriggerEnter(){
objeto.animation.Play(animacion);
}
------------------------------------------------------------------------

Este script lo debe de usar la zona sensible a la cual el player ingresará, y las dos variables deben de ser llenadas con el objeto que se desea animar. El objeto que se desea animar debe de tener la propiedad de BoxCollider (o cualquier otro tipo de collider) el mismo que debe de tener activo la opción Is Trigger, y además debe de tener un componente de "Animation" con la animación que se desea ejecutar.

Ahora vamos a revisar el mensaje de error que nos sale al momento de ejecutar y nos indica que la animación no es "Legacy". 

Al visualizar este mensaje debemos de seleccionar la animación, ir al menu de la parte superior del Inspector, dar clic y seleccionar Debug.

Luego cambiar en el tipo de animación de 2 (mecanim) que viene por defecto desde la versión 4.3 en adelante a 1 (legacy).

Y con ese cambio solucionado el inconveniente. Ya no sale el mensaje de error, y se efectúa la animación al entrar a la zona sensible.

Información adicional: El sistema de animación Legacy es un sistema previo al Mecanim, y es compatible con versiones anteriores de unity y por lo tanto todavía está disponible. Este sistema también es conocido como de acciones heredadas.

El sistema Mecanim es más actualizado y dispone de fácil flujo de trabajo y configuración de las animaciones de personas humanoides (en este caso no aplicaba), tiene también la posibilidad de aplicar animaciones de un modelo de personaje a otro, vista previa de las animaciones.

En lo personal he trabajado con Mecanim para animación de personajes, y con Legacy para animación de objetos en el juego como bloques, esferas y cualquier otra cosa que no son personajes.

Paquete Asset Lava Unity

Para cuando necesites crear LAVA en tu proyecto de #Unity, te adjunto el siguiente link del cual puedes descargar un Asset.

https://www.dropbox.com/s/2q5gtge5zl0k1zu/LavaPackage.unitypackage

Script Unity - Mostrar una textura como mensaje de texto, al ingresar a una zona sensible

Muchas ocasiones es necesario mostrar un mensaje de texto al ingresar a una zona sensible, que sirva como advertencia, en este caso lo he elaborado por medio de una imagen que hace las funciones de textura la misma que se mostrará  en la pantalla.

Script #JS

var showMessage : boolean;

var  textura : Texture2D;

function OnGUI(){

   if(showMessage){

      GUI.Label(Rect(10,10,100,20), textura);

   }

}

function OnTriggerEnter(){

   showMessage = true;

}

function OnTriggerExit(){

   showMessage = false;

}

El Script de la parte superior se lo asigna al Player, puesto que es él, el que ingresa en el trigger.

Script Unity - Muestra partícula al explotar

Uno de los elementos mas necesarios al momento de desarrollar juegos es la aplicación de partículas para simular explosiones, por lo cual adjunto un script sencillo.

Para comprender el funcionamiento del script es necesario primero crear la partícula, y luego de haberla elaborado tal como la necesitamos, insertarla en un "prefad" para poder llamarla en la función.

Script JS

_________________________________________________________________________________

var particula : ParticleEmitter;

function OnCollisionEnter (col : Collision) {

  Instantiate(particula, transform.position, transform.rotation);

  Destroy(gameObject);

}

En el cual la variable "particula" va a contener la particula creada, en este script se muestra la partícula y luego se destruye el objeto, pero solo funciona cuando colisiona.

Es necesario que la partícula posea dentro del Inspector las siguientes componentes.

• Ellipsoid Particle Emitter
• Particle Animator
• Particle Renderer