Mostrando las entradas con la etiqueta como mostrar barra de vida en unity3d. Mostrar todas las entradas
Mostrando las entradas con la etiqueta como mostrar barra de vida en unity3d. Mostrar todas las entradas

viernes, 1 de agosto de 2014

#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.

miércoles, 30 de julio de 2014

#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.