Aprendiendo Videojuegos Con La Historia de Las Consolas

Aprendiendo videojuegos con la historia de las
consolas: Atari (Parte VI)

En la anterior parte de este tutorial nos quedamos pendientes de que nuestro portero de madera
colisionase con la pelota, as que ha llegado el momento de configurarlo para que esto sea posible
y, como ya aprendimos anteriormente, esto ser posible gracias a un Box Collider 2D y un
RigidBody 2D. Vamos a aadirlos a nuestro mueco de madera. (Si no recordis como se hace
volved al captulo anterior) y a configurarlos con los valores que vemos en la imagen. Con esto
tendremos un portero fuerte que no ser desplazado dentro de la portera cuando la pelota le
golpee.
En este caso vamos a tener (cuando lo programemos) un portero que estar en movimiento, por lo
que marcaremos la casilla de verificacin is Kinematic, de nuestro RigidBody 2D, ayudando as a
Unity a realizar mejor los clculos fsicos necesarios y consiguiendo que solo exista colisin con
otros objetos en desplazamiento, como la pelota, y que no se pueda chocar con el poste de la
portera que tiene un Collider esttico (Sin RigidBody). Si probamos a pulsar play y durante el
juego, lanzar la pelota contra nuestro muequito de madera veremos cmo sale rebotada, por lo
que con esto ya podemos avanzar al siguiente paso.
Queremos hacer que nuestro portero de prcticas se mueva constantemente para tratar de
dificultarnos un poco el meter el baln dentro de la portera. Para ello crearemos un nuevo Script
en C# al que vamos a llamar GoalKeeperControl, lo arrastraremos sobre nuestro mueco de
madera, y despus lo editaremos escribiendo el siguiente cdigo:
using UnityEngine;
using System.Collections;
public class GoalKeeperControl : MonoBehaviour
{
public float speed;
// velocidad de movimiento
public float limits;
// Limites del movimiento
private Transform thisTransform;
// Referencia al transform del
portero
private int direction;
// Direccion de movimiento
private float timePassed;

direccion
private float changeTime;
// Tiempo pasado desde el ultimo cambio de

// Tiempo para cambiar de direccion
// Use this for initialization

void Start ()
{
thisTransform = transform;
ChangeDirection();
// damos una direccion inicial aleatoria de
movimiento
}
// Update is called once per frame
void Update ()
{
if(Time.timeSinceLevelLoad < timePassed + changeTime){
MoveWoodenKeeper(); // mueve el portero
} else {
ChangeDirection(); // mover hacia un sitio aleatorio ()
}
}
/*----------------------------------------------------------------------* - ChangeDirection() *
* Cambia la direccion de movimiento del portero
*
----------------------------------------------------------------------*/
void ChangeDirection()
{
timePassed = Time.timeSinceLevelLoad;
direction = Random.Range(1,3);
changeTime = Random.Range (0.3f,0.7f);
para el cambio
MoveWoodenKeeper();
}
// tiempo de juego
// Numero entre 1 y 2
// Rango de tiempo aleatorio
// controla el movimiento
/*----------------------------------------------------------------------* - MoveWoodenKeeper() *
* Mueve el portero en una direccion despendiendo de la variable
direction
*
----------------------------------------------------------------------*/
void MoveWoodenKeeper()
{
switch (direction)
{
case 1: // moving right
if (thisTransform.position.x > limits)
{
ChangeDirection(); // si se mueve a la derecha debe ir a la izquierda
}
else
{
thisTransform.Translate(thisTransform.right * speed *
Time.deltaTime);
}
break;
case 2: // moving left
if (thisTransform.position.x < -limits)
{
ChangeDirection(); // si se mueve a la izquierda debe ir a la derecha
}
else
{
thisTransform.Translate(thisTransform.right * -speed *
Time.deltaTime);
}
break;
default:
break;
}
}
}
Como se puede leer en el cdigo tenemos dos variables pblicas de tipo float que posteriormente
ajustaremos desde el Inspector en Unity y que se llaman speed y limits. Estas se encargarn de
definir la velocidad a la que se mover nuestro mueco de prcticas y que limites de movimiento
tiene, que no van a ser ms que una distancia desde el centro donde se sita inicialmente hasta los
palos de la portera.
Despus, tenemos varias variables privadas. Por ejemplo thisTransform lo hemos usado
muchas otras veces y en esta ocasin tiene el mismo objetivo, servir de referencia al transform del
objeto que contiene este script (el portero) para poder usarla y acceder a dicho transform
consumiendo menos recursos por tener que buscarlo cada vez. Por otro lado, la variable entera
direction, se encargar de decidir si el mueco se mueve hacia la derecha o hacia la izquierda de
forma aleatoria. Nos encontraremos tambin timePassed, que almacenar el tiempo que llevamos
de juego en cada momento que el movimiento del portero cambia de direccin y changeTime,
encargada esta ltima de recoger un numero de segundos al azar para hacer el prximo cambio en
el sentido del movimiento y que as no cambie de forma constante y repetitiva.
En Update() vamos a mover nuestro mueco mediante MoveWoodenKeeper() si el tiempo desde
que el nivel se inici (Time.timeSinceLevelLoad es menor que la suma de timePassed +
changeTime. Es decir, si no ha pasado bastante tiempo desde que el portero hizo un cambio de
direccin sumado al tiempo en el que tiene que cambiar de nuevo. En caso contrario, cambiaremos
de direccin con ChangeDirection(), iniciando de nuevo el proceso.
La funcin ChangeDirection() se va a encargar de inicializar timePassed igualndolo al tiempo
desde que el nivel se inici (Time.timeSinceLevelLoad) cada vez que se ejecute esta funcin.
Adems, recoger un valor aleatorio entre 1 y 2 (uno derecha y dos izquierda) y lo almacenar en
direction. Para hacer esto, usamos Random.Range(), en este caso entre 1 y 3 por que al ser
enteros busca la aleatoriedad entre el nmero mnimo y el mximo-1 (es decir no incluye el 3, solo
elige entre 1 y 2). Con esta misma operacin obtenemos tambin un nmero entre 0.3 y 0.7 (a los
que aadimos una f para indicar que son float, es decir, decimales) para decidir el tiempo en
segundos que tardar en volver a cambiar la direccin del movimiento (volviendo a llamarse a esta
funcin). Por ltimo llamamos a MoveWoodeKeeper() para que el mueco ejecute el movimiento
en la nueva direccin elegida.
MoveWoodenKeeper() es una funcin encargada de mover el portero dependiendo hacia donde le
indique la variable direction, que como ya dijimos cambiar cada changeTime segundos. Usamos
pues, un condicional de tipo switch para hacer que se mueva a la derecha si direction vale 1 o a la
izquierda si vale 2. Sin embargo, tambin tenemos que tener en cuenta si la posicin x del portero
de madera ha alcanzado su lmite por la derecha (limits) o por la izquierda (-limits) recurriendo a
condicionales if que comprueben si la posicin del transform es mayor que limits o menor que
-limits. Por otro lado el movimiento en s, lo conseguiremos con thisTransform.Translate(), una
funcin que vara la posicin de un objeto cuando le indiquemos mediante sus parmetros. En este
caso para ir a la derecha usamos thisTransform.right * speed * Time.deltaTime, indicando as
que se mueva a la derecha a velocidad speed y teniendo en cuenta Time.deltaTime para que la
velocidad de movimiento no dependa de la del dispositivo en el que se dibuje. (Esto ya se explic
un poco en anteriores captulos).
Por cierto, en el inspector de Unity he configurado speed a 1.5 y limits a 0.5
Si observamos que el portero se dibuja por detrs de la portera podemos corregir su eje Z del
transform.position desde el inspector. Yo finalmente lo he tenido que poner con un valor de -0.6.
Como vemos, el movimiento del mueco no supone un reto para el jugador, que puede practicar el
tiro a portera libremente, pero s que molesta y le obliga a estar atento y hacer clculos, por lo que
creo que es el entrenamiento perfecto de cara al lanzamiento real en el modo de juego normal.
Podemos pasar entonces a lo siguiente: Reinicio del nivel.
Resulta un poco molesto tener que parar y reiniciar nuestro juego despus de cada tiro, as que
vamos a crear una solucin temporal para que podamos tirar penaltis infinitos hasta que decidamos
detener la partida. Para conseguir esto, recurriremos a
Application.LoadLevel(NombreDeEscena) para cargar la misma escena en la que estamos
actualmente. Para esto tendremos que pensar en un evento para lanzar la accin de reiniciar el
nivel, as que pudiendo elegir factores como el fin del movimiento de la pelota, pulsar una tecla u
otros muchos, nos vamos a decidir por el factor tiempo, es decir, esperaremos un tiempo desde la
pulsacin de la tecla de disparo, o si lo prefers, desde el lanzamiento a portera, dejaremos que el
usuario vea un rato como rebota la pelota o se pierde por el fondo, y restauraremos la escena
actual con el ya citado Application.LoadLevel(). Descrita la explicacin, veamos el cdigo que
introduciremos en el Script PlayerControl.
Primero necesitamos incluir dos variables privadas y una pblica. En este caso timeAfterShoot
ser pblica para poder decidir desde el Inspector de Unity el tiempo que queremos que pase para
reiniciar el nivel despus de tirar a puerta (yo he elegido 3 segundos). Las privadas sern
timeSinceShoot, para guardar el tiempo que pasa desde que se tira a puerta, y un booleano
llamado shooted, que nos avisar de que ya se ha efectuado el lanzamiento. Adems
timeSinceShoot ser inicializado a 0 y shooted a false en la funcin Start(), ya que al inicio de
juego estamos seguros de que no se ha hecho ningn disparo a puerta y necesitamos un punto de
partida.
private float timeSinceShoot; // Tiempo desde que se tira a puerta
private bool shooted;
public float timeAfterShoot; // Timepo necesario para reiniciar
void Start ()
{
timeSinceShoot = 0;
shooted = false;
...
}
Para evitar que el nivel se reinicie constantemente usaremos en Update() el booleano shooted,
que comprobar el tiempo desde que se tir a portera nicamente despus de que se haya
efectuado el tiro y lo har mediante la funcin CheckLevelRestart()
if(shooted) // El jugador tira a puerta, contemos el tiempo hasta
reiniciar
CheckLevelRestart();
Pero antes, para saber cundo se tira a puerta e iniciar el tiempo desde all hasta el reinicio del
nivel, nos vamos a la funcin Shoot() y aadimos las siguientes lneas al final:
timeSinceShoot = Time.timeSinceLevelLoad;
shooted = true;
Indicamos con timeSinceShoot, que tome como referencia el tiempo desde que empez el nivel
para ir contando segundos desde all y con shooted = true, que acabamos de efectuar un tiro a
portera.
Finalmente la funcin CheckLevelRestart() comprobar si el tiempo pasado desde el inicio del
nivel es mayor que el tiempo pasado desde el inicio del nivel al tiro a puerta (timeSinceShoot) ms
timeSinceShoot, que es el tiempo que debe pasar hasta el reinicio del nivel despus del ya
mencionado disparo a puerta. (Cargamos el nivel con Application.LoadLevel(GameScene);)
/*----------------------------------------------------------------------* - CheckLevelRestart() *
* Funcion que comprueba si ha pasado tiempo para reiniciar el nivel
* --------------------------------------------------------------------*/
void CheckLevelRestart()
{
if(Time.timeSinceLevelLoad > timeSinceShoot + timeAfterShoot)
{
Application.LoadLevel("GameScene");
}
}
Si ejecutramos ahora el juego cargara el nivel porque es el nico que tenemos, pero para hacer
bien las cosas necesitamos un poco de trabajo fuera de cdigo con Unity. Iremos a file/Build
Settings y donde pone Scenes in Build, tendremos que cargar nuestra escena actual
GameScene arrastrndola desde la ventana Project.
Como vemos, el juego sigue un poco despus del tiro y no hay una pausa, por lo que el portero
sigue movindose y saca el baln de la portera. Solucionaremos esto creando un nuevo script muy
sencillo llamado GameManager que no vamos a asociar a ningn objeto. En este script
aadiremos una variable de tipo Static para manejar estados del juego que permanecer en la
memoria durante toda la ejecucin y conservar su valor. Y es este el mejor mtodo para hacer
esto? No, pero es el ms sencillo y rpido para nuestro pequeo proyecto, aunque los expertos
programadores pueden recurrir a otro modo de hacer las cosas. Veamos el contenido de
GameManager.
using UnityEngine;
public class GameManager : MonoBehaviour
{
public enum States { inGame, Waiting};
// En juego, En espera
public static States gameState; // Estado del juego
}
Hemos utilizado el tipo enum de C# para aclarar los estados de juego. As decidimos que haya dos
estados: en juego y esperando (inGame y Waiting), usando estos para bloquear los controles y
el movimiento del portero cuando estemos en espera y para permitir continuar la partida cuando
estemos en juego.
Cundo vamos a poner el juego en espera? Pues en mi caso he decidido hacerlo cuando la
pelota est en una posicin Y determinada. Con esto, cuando haya lanzado el jugador a puerta y el
baln este subiendo hacia meta, se bloquear en cierto momento el juego impidiendo que el
mueco de madera se siga moviendo y que el usuario contine teniendo el control del personaje.
Para hacer esto vamos a necesitar otro Script que llamaremos BallScript y que enlazaremos con
la pelota (ya veremos que en un futuro prximo nos va a venir muy bien). En este script
escribiremos el siguiente cdigo.
using UnityEngine;
public class BallScript : MonoBehaviour
{
Transform thisTransform;
void Start ()
{
}
void Update ()
{
if(thisTransform.position.y > 0.2f)
{
GameManager.gameState = GameManager.States.Waiting;
}
}
Por supuesto, para contrarrestar la activacin del juego en espera, vamos a poner el estado de en
juego nada ms comience el juego, para ello dentro del script PlayerControl, dentro y al final de la
funcin Start(), aadiremos la siguiente lnea:
GameManager.gameState = GameManager.States.inGame;
Con esto cada vez que se reinicie el nivel y se invoque a esta funcin, el estado de juego se
colocara como inGame.
Como ltimo paso para bloquear el juego cuando el estado sea Waiting tendremos que colocar
condicionales en PlayerControl y GoalKeeperControl antes de ejecutar las acciones encargadas
del movimiento y el control. As, solo se ejecutar esa parte del cdigo cuando el estado de juego
sea inGame, parndose durante el resto de la ejecucin. (Pongo un ejemplo pero esto se pondra
tanto en Update y FixedUpdate de PlayerControl, como en Update de GoalKeeperControl,
dejando BallScript sin cdigo de este tipo por que queremos ver a la bola rebotar)
if(GameManager.gameState == GameManager.States.inGame)
{
horAxis = Input.GetAxis...
}
Lo siguiente para acabar el captulo de hoy va a ser comprobar si hemos marcado gol. Pero para
conseguir esto tendremos que aadir un Collider (en este caso a un objeto vaco porque queremos
que sea invisible) que ms que Collider tal como hemos visto hasta ahora, har de Trigger o
interruptor, para chivarnos cuando el baln ha entrado en una zona concreta de juego. Este tipo de
objetos no visibles se usan en juegos para activar puertas, interruptores lanzar eventos de
animacin y mil cosas ms.
Creamos por tanto un objeto vacio y le aadimos un Box Collider 2D de una medida x = 1, y =
0.17. Con estas dimensiones podemos centrar nuestro Trigger dentro de la portera, cuando ya se
ha cruzado la lnea blanca de gol y sin acercarnos mucho a los postes, para evitar un falso tanto si
los clculos fsicos de Unity son poco precisos y sealan gol cuando la pelota ha rebotado en uno
de los postes. Por cierto, llamaremos a este objeto GoalZone y es importante marcar la casilla
isTrigger del Collider, para hacer que Unity deje atravesarlo con la pelota y lo utilice como
Trigger.
Una vez lo tenemos listo, en BallScript tendremos que introducir el cdigo que detecte que la
pelota est entrando en esta zona de gol e indicar de alguna forma (temporal por ahora) al jugador
que ha marcado, pero para poder lograrlo tambin tenemos que aprender algunos conocimientos
nuevos sobre nuestro motor de juegos favorito, las etiquetas.
Las Etiquetas nos permiten marcar varios objetos bajo un nombre comn y realizar acciones con
ellos, como comprobar colisiones. Gracias a las etiquetas podemos elegir que un personaje realice
una accin o emita un sonido cuando choca con un tipo concreto de objeto y otras acciones
distintas si choca con otro objeto distinto. (Por ejemplo que la lava nos quite energa y por la hierba
podamos caminar libremente).
Para aadir una etiqueta seleccionaremos nuestro objeto GoalZone y desplegaremos en el
Inspector, al lado de Tag, hasta seleccionar Add Tag Despus, en la casilla Element 0,
introduciremos el nombre de nuestra etiqueta (en este caso tambin GoalZone) y pulsaremos
Enter. Ahora podemos ir de nuevo al inspector, seleccionando el objeto GoalZone y elegir la
etiqueta que acabamos de aadir volviendo a desplegar al lado de Tag y escogiendo esa nueva
etiqueta que habr aparecido.
Como ya tenemos una etiqueta para saber cuando el baln entre en una zona de gol, y as nos
avise, vamos a editar el script BallScript y a aadir el siguiente cdigo (una funcin aparte al final
pero dentro de la clase.
void OnTriggerEnter2D(Collider2D col)
{
if(col.tag == "GoalZone")
{
Debug.Log ("Goal!!");
}
}
Bsicamente OnTriggerEnter2D() es una funcin predefinida de Unity que responde cuando un
objeto entra en la zona del Trigger que hicimos hace un momento. Recibe como parmetro un
Collider2D que hemos llamado col y con el podemos comprobar si el objeto que ha colisionado
cuando la bola entra en la zona tiene la etiqueta GoalZone. En caso de que la bola est dentro
de GoalZone significar que el jugador ha marcado, por lo que usamos Debug.Log para escribir
en la consola de Unity el texto correspondiente (Que se pone entre comillas).
Con esto, veremos como cuando el baln entre en la portera aparecer en la consola de Unity el
mensaje Goal!! indicando que el jugador ha anotado.
En el futuro ya tendremos tiempo de hacer esto de forma mucho ms bonita, pero de momento lo
vamos a dejar as. :)
Publicado por rathsodic en 9:00 2 comentarios
Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
Etiquetas: Desarrollo, Programacin, Unity
martes, 23 de diciembre de 2014
Aprendiendo videojuegos con la historia de las

consolas: Atari (Continuacin)
En el post anterior nos quedamos con nuestro tirador de penaltis apuntando mediante una flecha.
Sin embargo, esta no tena limitaciones a la hora de girar por lo que tendremos que editar el
script PlayerControl para aadirle los lmites que deseamos.
Dentro de la funcion RotateArrow (Es decir entre las dos llaves que indican su principio y fin)
incluiremos unos condicionales con llamadas a una funcin que impide que la flecha contine
rotando.
// Limite de rotacion hacia la izquierda
// la flecha se para al entrar entre un rango de angulos dentro de la
circunferencia
if(thisTransform.eulerAngles.z >= 40 && thisTransform.eulerAngles.z < 50)
{
BlockRotation(-1);
}
// Limite de rotacion hacia la derecha
if(thisTransform.eulerAngles.z > 310 && thisTransform.eulerAngles.z <=
320)
{
BlockRotation(1);
}
Como vemos tenemos que si el ngulo de rotacin en el eje Z del Pivot Point en este caso, esta
entre 40 y 50 grados, vamos a llamar a la funcin que limita dicha rotacin pasndole un -1 para
indicar que estamos girando a la izquierda y si por el contrario el ya citado ngulo esta entre 310 y
320 grados llamaremos a la funcin indicando un 1 positivo para decirle que la rotacin est
siendo a la derecha. De esta forma tendremos la funcin BlockRotation como sigue:
/*----------------------------------------------------------------------* - BlockRotation() *
* Impide a la flecha de apuntar superar el limite de rotacion a la derecha
* ----------------------------------------------------------------------*/
void BlockRotation(int rotationDir)
{
if(rotationDir == -1)
thisTransform.eulerAngles = new Vector3(0,0,40);
else
thisTransform.eulerAngles = new Vector3(0,0,320);
}
Recibe un entero que indica la direccin en la que est rotando la flecha para apuntar (-1 a la
izquierda o 1 a la derecha). Dependiendo de hacia donde sea el giro, va a bloquear en un punto,
no dejando pasar de 40 grados a la izquierda o 320 a la derecha. ngulos que han sido
elegidos para permitir tirar al palo o fuera de portera si hacemos un mal clculo, pero para impedir
que la flecha se coloque sobre el grfico del jugador.
Qu hace la sintaxis eulerAngles? Como podemos ver es una funcin dentro de la clase
Transform encargada de manejar la rotacin a travs de las componentes x,y,z de este en grados.
Si queremos cambiar sus valores tendremos que pasarle un vector3 (de tres componentes) como
vemos en la funcin BlockRotation.
Llega el momento por fin de manejar el tiro a puerta, para lo que vamos a necesitar aadir un par
de componentes a nuestro baln. El primero ser un Box Collider 2D al que aplicaremos un
Physic Material para que pueda chocar con otros objetos en la escena y rebotar. El segundo ser
un Rigidbody 2D que nos permitir aplicar fuerzas para lanzar la pelota a puerta.
Para aadir tanto el Box Collider 2D como el RigidBody 2D, seleccionaremos nuestro objeto Ball
(el baln) e iremos al men Component/Physics2D/Box Collider 2D primero y luego a
Component/Physics2D/RigidBody 2D (bueno, el orden da igual). Una vez aplicados al objeto

podremos ver sus propiedades en el inspector mientras lo tengamos seleccionado.
El Box Collider 2D rodea el grfico con un cuadrado que ayuda a detectar las colisiones a Unity y
es el ms sencillo de configurar de los dos nuevos componentes. Para empezar tenemos que
saber que el tamao de nuestro baln es demasiado pequeo y dara problemas de clculo al
motor, por lo que vamos a usar un Size o tamao de 0.05 en X y 0.05 en Y que es el mnimo
recomendado para evitar problemas y con l que no vamos a notar diferencia. Adems hay que
destacar que, aunque para un baln puede ser normalmente ms apto un Circle Collider 2D (Con
forma de crculo) como estamos manejando pixel art, el Box Collider 2D cumplir muy bien su
funcin y consume algunos recursos menos al tratar las colisiones.
Con lo hecho hasta ahora aun no hemos terminado con nuestro Box Collider 2D, y es que
queremos que la pelota tenga un poco de rebote y no simplemente colisione y frene en seco. Para
conseguir esto vamos a crear un Physic 2D Material haciendo clic con el botn derecho en la
ventana Project y seleccionando Create/Physics 2D material, al cual vamos a llamar Bounce
Material y a guardarlo en una carpeta llamada Physics Materials para tenerlo todo ordenado.
El material que acabamos de crear va a tener una Friccin (Friction) de 1 y un Bounciness (o
rebote) de 0.1. Con esto hacemos que haya un cierto rebote pero que la friccin pare relativamente
pronto la pelota y as no salga disparada fuera de la pantalla o haga alguna cosa rara. Vamos que
queremos imitar un poco de realismo pero tampoco un comportamiento fsico perfecto.
Como ya tenemos nuestro Bounce Material lo vamos a arrastrar a la ranura Material del Box
Collider 2D de nuestro baln, con lo que este comportamiento se aplicar a la reaccin que
tendr nuestro objeto ante una colisin. (El baln rebotar contra la portera y el portero!)
Cmo configuramos ahora el Rigidbody 2D de nuestro objeto Ball? Para empezar usaremos una
masa (Mass) muy pequea, para que el golpe no sea capaz de desplazar a nuestro portero y
meterlo dentro de la portera. Aplicaremos un Linear Drag de 1.2 para ayudar al frenado de la
pelota y un Angular Drag de 0, porque no queremos que haya rotacin en nuestro grfico durante
su movimiento (bsicamente por que es pixel art y la rotacin no le va a sentar bien grficamente
hablando). Marcaremos la casilla Fixed Angle para remarcar el que no queremos que haya
rotacin y elegiremos en Interpolate el valor Extrapolate, en Sleeping Mode Start Awake y en
Collision Detection el tipo Continuous, que aunque tiene mayor coste de recursos para realizar
clculos nos va a dar mejor resultado (y nuestro juego es pequeito y podemos permitrnoslo).
Qu significa cada cosa? Interpolate es el metodo de clculo para la interpolacin, es decir, algo
as como una previsin de donde estar nuestra pelota en el siguiente fotograma(Extrapolate)
para que al motor no se le escape que vaya a haber contacto con otro GameObject. Por otro lado
Collision Detection indica el mtodo usado para calcular la colisin (Discrete o Continuous) que
indica el tiempo que Unity va a estar "atento" para calcular choques con otros objetos
(Explicaciones un poco "por encima". Para ms info o ms precisa, documentacin de Unity).
Y hemos terminado de configurar nuestro baln! Sin embargo para que funcione tendremos que
aadir la posibilidad de ejecutar un disparo desde el script PlayerControl. Es, por tanto, momento
para volver a editarlo. (Ya estabais impacientes por picar ms cdigo, eh?)
Tras abrir el Script lo primero que haremos ser aadir una referencia pblica al transform del
baln (Ball), con esto seremos capaces de acceder a dicho transform desde el Script
PlayerControl. Aadimos por tanto, la siguiente lnea debajo de la variable rotationSpeed que es
la nica pblica que tenamos hasta ahora:
public Transform ballTransform;
// Referencia al transform del balon
Al hacer esto, volver a Unity y seleccionar nuestro Pivot Point (Que es el que contiene el script
PlayerControl y el encargado de rotar nuestra flecha para apuntar) vemos que se ha aadido una
nueva casilla que espera un Transform. Arrastraremos hasta all el Game Object Ball (El baln de
futbol) indicando as al motor que es a de ese objeto del que necesitamos acceder a su
componente transform.
Podemos por fin aadir el siguiente cdigo dentro de una funcin especial llamada FixedUpdate()
void FixedUpdate()
{
// Si pulsamos la tecla espacio
if(Input.GetKeyDown(KeyCode.Space))
{
Shoot();
}
}
Aqu de forma similar a como ya hicimos anteriormente llamaremos a una funcin Shoot() que
crearemos despus, cuando se reciba el evento de pulsar la tecla Espacio. Esta vez estamos
usando Input.GetKeyDown, que detecta una pulsacin de tecla (presionar hacia abajo) pero no
que la tecla se quede pulsada (Que sera GeKey) o se suelte (GetKeyUp). Respecto al KeyCode,
este toma las teclas a partir de un nombre clave que en este caso es Space para el espacio. Pero
vamos a ver tambin como sera la funcin Shoot()
/*----------------------------------------------------------------------* - Shoot() *
* Funcion encargada de las acciones para tirar a porteria
* ----------------------------------------------------------------------*/
void Shoot()
{
// aadimos fuerza al balon
ballTransform.rigidbody2D.AddForce( thisTransform.up * Time.deltaTime * 800 );
}
Esta funcin aadir al rigidbody 2D del transform de nuestro baln (mediante AddForce) una
fuerza hacia "arriba" haciendo que salga disparado hacia portera en la direccin indicada por la
flecha. Para saber qu direccin debe seguir, tomamos la del Pivot Point (thisTransform) y lo
multiplicamos por una fuerza de 800 que es aceptable y por Time.deltaTime, para ayudar a que su
desplazamiento sea similar aunque vare el rendimiento del dispositivo. Tenemos por fin una
explicacin de por qu llamamos a la funcin Shoot anteriormente desde FixedUpdate y no desde
Update. El motivo es que Unity tiene FixedUpdate como recomendacin para llamadas a procesos
que involucren fsicas, como es el caso de aadir fuerza al RigidBody2D en la funcin Shoot(). Su
utilidad es la misma que Update pero se ejecuta a intervalos constantes y no depende del tiempo
que se tarde en cargar el fotograma como pasaba con Update. Esto lo hace ms apto para
clculos que tengan que ser ms precisos. (Como siempre en la documentacin de Unity
encontrareis una mejor y ms acertada explicacin de la mano de sus creadores).
Si ejecutamos ahora el juego y probamos a pulsar la tecla espacio nos encontraremos tres
problemas. El primero es que el baln sale disparado y se pierde por el fondo de la pantalla
atravesando todos los objetos. El segundo es que si pulsamos repetidamente la tecla espacio
aadimos ms fuerza y mandamos la pelota muy lejos (Es posible que no os deis cuenta de esto
porque la pelota ya se habr salido de la pantalla). Por ltimo, est el tercer problema que es que
la pelota no vuelve a su sitio para que podamos volver a tirar a puerta, por lo que hay que parar el
juego y volver a ejecutarlo si queremos tirar otra vez. Vamos a trabajar por solucionarlos todos,
pero como no nos dar tiempo a algunos en este post, empezaremos por el ms simple. Que la
pelota choque con la portera.
Para aadir una colisin con la portera vamos a aadir un componente Collider a la misma, pero
como esta vez no nos vale una caja, porque la pelota tiene que meterse dentro y eso lo impedira,
usaremos un Poligon Collider 2D. Este en un principio puede parecer la misma caja que el Box
Collider, pero si en la ventana Scene vamos a esta caja que rodea el grfico de nuestra portera y
pulsamos Mayusculas mientras hacemos clic y luego arrastramos sobre una linea, aadiremos
un punto que podremos colocar. As, daremos forma a los palos de nuestra meta para permitir
colisin con ellos (Para borrar usamos control y hacemos clic en alguno de los puntos). Una vez
lista la forma si ejecutamos el juego, podemos ver como la pelota se detiene al tocar alguno de los
palos.
Y aqu nos vamos a quedar por ahora. A ver si en prximos post podemos hacer que nuestro
muequito de madera se haga alguna paradita y podamos volver a intentar meter gol despus de
tirar sin tener que detener el juego. Hasta la prxima.

mircoles, 17 de diciembre de 2014
Aprendiendo a hacer juegos con la historia de las

consolas: Atari
Bienvenidos de nuevo a nuestra aventura de imitar un juego de Atari 2600 usando Unity. En el post
anterior di algunas explicaciones para cargar los grficos necesarios para nuestra primera escena
de un juego muy sencillo de lanzamiento de penaltis y suger a los lectores de esta seccin que
trataran de crear su propio pixel art. Como ya habis tenido algn tiempo para cacharrear e
intentarlo vosotros mismos hoy voy a traer la solucin para los\las mas perezosos\as. En este
enlace se puede descargar los primeros sprites necesarios para montar nuestra escena
principal de juego en Unity.
Como vemos disponemos de una series de archivos png que van a hacer las funciones de
campo de futbol (campo.png), baln (balon.png), flecha que usaremos para apuntar (flecha.png),
portera (porteria.png), un lanzador de penaltis en dos estados (jugador.png y jugador_shoot.png) y
para terminar un portero de madera que se va a mover de lado a lado para que el entrenamiento
sea sencillo pero un poco ms entretenido (portero_madera.png)
Ya vimos en el post anterior como introducir los grficos ya mencionados en Unity, pero para
dejarlo ms claro lo vemos en la animacin. Hay que arrastrar el archivo de nuestro navegador
del sistema operativo a la ventana Project.
Una vez con todo cargado en nuestra escena lo configuraremos y colocaremos cada cosa en su
sitio, primero arrastrando de la ventana Project a Hierarchy para poner los objetos en la
escena y despus ajustando su posicin movindolos con el ratn en la ventana Scene o
introduciendo nmeros en los transform de cada objeto a travs del Inspector.
Como gua puedo decir que tengo la cmara configurada en ortogrfico con un tamao de 0.8 y los
objetos en las siguientes posiciones: campo (0, 0, 0), baln (0,-0.47,-0.1), jugador (0, -0.49, -0.2),
portera (0,0.49, -0.03), flecha (0, 0.1, -0.5). Debemos saber que cuando manejamos el eje Z en
el modo 2D de Unity podemos conseguir que unos objetos estn por delante de otros. Por
eso estamos usando valores negativos, para colocar objetos delante del campo que est en Z=0.
Tambin hay que mencionar que vamos a reducir un poco el tamao de la flecha
introduciendo en sus casillas Scale correspondientes a X e Y el valor 0.95 sin preocuparnos
de la Z, ya que al ser un objeto en dos dimensiones, por lo que no tiene profundidad y no nos
importa. (El nico motivo por el que hago esto es para que aprendis a re-escalar desde el
transform, pero si tenemos los objetos desde el principio a su tamao original ser mejor.
Ahora empezamos a ver cosas nuevas despus del repaso. Adems traigo buenas noticias.
Empezaremos a programar un script en C# para que nuestro personajillo de uniforme azul pueda
disparar a puerta.
Para empezar hay un objeto que necesitamos colocar de un modo especial, la flecha. Crearemos
un objeto vacio mediante Create/Empty Object y lo arrastraremos sobre el jugador. Despus
arrastraremos la flecha sobre el objeto vacio (al que debemos dar un nombre, por ejemplo en mi
caso lo he llamado Pivot Point). De este modo el objeto Pivot Point es hijo del jugador y la flecha es
hija de Pivot Point, crendose as una relacin de herencia que hace que si movemos al jugador
sus hijos se muevan con l.
Crearemos por fin un Script en C# al que yo he llamado PlayerControl. (Es importante saber que
se distingue entre maysculas y minsculas y que el nombre de archivo del Script debe coincidir
con el nombre de la clase principal, aunque Unity ya se encarga de nombrarlo todo). Lo
arrastraremos sobre el objeto Pivot Point de la escena y dentro de l vamos a introducir el
siguiente cdigo (observad que hay una parte que escribe Unity al crear cualquier Script).
using UnityEngine;
public class PlayerControl : MonoBehaviour
{
// Public variables
public float rotationSpeed;
// velocidad de rotacion para apuntar (90 esta bien)
// Private variables
private Transform thisTransform; // Referencia al transform
private float horAxis; // Eje horizontal
void Start ()
{
// Inicializamos las referencias a los transform
}
void Update ()
{
horAxis = Input.GetAxis("Horizontal");
RotateArrow();
}
/*----------------------------------------------------* - RotateArrow() *
* Rota la flecha para apuntar desde un punto de pivote
* (En dicho punto esta este Script)
* ---------------------------------------------------*/
void RotateArrow()
{
thisTransform.Rotate(0, 0, - horAxis * rotationSpeed * Time.deltaTime);

// rotamos la flecha
}
}
Con este cdigo inicial vamos a hacer que nuestro tirador a portera pueda apuntar. Con
flecha derecha rotaremos la flecha a la derecha y con flecha izquierda lo haremos a la izquierda.
Pero, Por qu?
Tenemos una variable pblica llamada rotationSpeed de tipo float (public float
rotationSpeed) Al ser pblica Unity la va a mostrar en el Inspector si seleccionamos el objeto
jugador, por lo que podremos darle un valor desde all y testear sus efectos en tiempo real para
hacer ajustes. Eso s, hay que saber que el juego debe estar parado para que los ajustes sean
permanentes. Si estamos ejecutndolo y cambiamos algn valor, recuperar los nmeros
anteriores que tena cuando volvamos a pulsar el stop.
Las siguientes variables son privadas, es decir no se vern desde el Inspector ni sern
accesibles desde otro Script o clase. Con private Transform thisTransform estamos
declarando un objeto de tipo Transform en el que guardaremos una referencia al componente
transform del objeto que contiene el Script (En este caso Pivot Point). Hacemos esto para
optimizar el rendimiento y que Unity no tenga que buscarlo cada vez que lo vamos a utilizar
gracias a que ya lo tenemos referenciado.
Despus tenemos private float horAxis, que es una declaracin de una variable en el que
vamos a recoger el eje horizontal que Unity tiene asociado a una serie de teclas. Para saber
cules son, solo tendremos que ir a Edit/Project Settings/Input. All, en el Inspector, vemos que
aparecen los axes y en el horizontal el botn izquierdo lo identifica como negativo y el derecho
como positivo. (Las teclas son los cursores y las teclas alternativas la A y la D). Con esto cuando
pulsemos la tecla izquierda (aunque an tenemos que hacer algo de trabajo) la variable horAxis
tomar un valor negativo y cuando pulsemos la derecha, lo tomar positivo.
Llegamos ahora a la funcin Start(). Una funcin que Unity tiene predefinida y que usa
normalmente para inicializar variables. Esta se va a ejecutar una sola vez al iniciarse la escena.
As dentro de ella guardamos la referencia del transform del objeto en thisTransform como ya
habamos dicho anteriormente, escribiendo la sencilla orden thisTransform = transform.
En la funcin siguiente, es decir Update(), vemos que tenemos otra que est predefinida y que
Unity ejecuta cada fotograma. Es decir, es como un bucle principal de juego que se repetir
hasta que lo paremos. Dentro usaremos la sentencia horAxis = Input.GetAxis("Horizontal").

Para guardar el valor de las teclas del Axis horizontal en la variable horAxis. (recordemos,
negativo izquierda, positivo derecha). Por ltimo llamaremos a la funcin RotateArrow().
La funcin RotateArrow la creamos nosotros despus y la usamos bsicamente para tenerlo
todo ordenadito. Esta funcin se va a ocupar de rotar la flecha al pulsar las teclas. As, dentro
encontramos un cdigo thisTransform.Rotate(0, 0, - horAxis * rotationSpeed *
Time.deltaTime) que se encarga de dejar la X e Y fijas de nuestro transform, mientras rota
mediante la funcin Rotate a una velocidad rotationSpeed, el eje Z. Como se multiplica por el
horAxis ser negativo cuando pulsemos la izquierda y positivo cuando pulsemos la derecha. Pero
la rotacin sale al revs, por lo que pondremos un menos delante de horAxis. Respecto a
Time.deltaTime,a grosso modo es una funcin de Unity que se encarga de mantener una
velocidad constante sin importar el rendimiento del dispositivo en el que estemos ejecutando el
juego. Si queris saber ms os recomiendo bucear en la documentacin de Unity y tratar de
entenderlo, aunque puede que lo explique ms adelante porque soy un buen chico pero tengo poco
espacio para escribir. :P
El fallo de este cdigo es que permite rotar indefinidamente nuestra flecha. (En el inspector no
olvidis dar un valor a rotationSpeed o no rotar) Nosotros queremos aadirle un bloqueo para
que solo pueda girar dentro de un rango, pero como se ha hecho muy largo el post lo vamos a
dejar aqu por hoy. As adems, no se puede quejar nadie de que le hago copiar mucho cdigo.
La historia de las consolas es larga y esto nos va a llevar bastante tiempo, as que tener
paciencia (y tener paciencia conmigo porque es mi primer tutorial en detalle y estoy aprendiendo).
nimo y a seguir aprendiendo. Hasta el prximo
domingo, 14 de diciembre de 2014

consolas: Atari - Preparando Unity
Unity generalmente se abre con un proyecto anterior o uno de ejemplo, a partir de aqu hay que
crear un proyecto nuevo usando el men File/New Project
Se abre una ventana donde debemos elegir una carpeta para nuestro nuevo proyecto y luego en el
desplegable marcar la opcin 2D, ya que nuestro juego va a ser 2D y nos vamos a beneficiar del
nuevo sistema de Unity para este tipo de proyectos.
La zona donde aparecen checkboxes para importar packages no nos interesa ya que no usaremos
ninguno de los packages que trae Unity y vamos a hacer todo nosotros
Si quisiramos abrir un proyecto en vez de crear uno nuevo nos iramos, en la misma ventana
llamada Project Wizard, a la pestaa de Open Project, donde elegiramos uno de los proyectos
anteriormente abiertos o pulsaramos sobre el botn Open Other, para buscar entre nuestras
carpetas un proyecto que no aparezca en la lista por no haber sido cargado en otra ocasin.
Configuraremos ahora el tamao de pantalla eligiendo, en el men que hay justo debajo de la
pestaa Game, el icono del + que nos permite aadir una resolucin personalizada. Pondremos
aqu 190x160 que es el tamao que buscamos (Aunque se ver muy pequeo y tendremos que
verlo ampliado o a pantalla completa para nuestras partidas). En Label escribimos lo que
queramos para identificar nuestra resolucin personalizada (por ejemplo yo he puesto Atari2600) y
pulsamos OK para elegirla como resolucin del proyecto actual.
Llega el momento de insertar los recursos necesarios para nuestro juego. Desde nuestro
navegador del sistema operativo arrastramos los archivos a la ventana Project de Unity. Aqu,
para tenerlos ordenados crearemos carpetas. Por ejemplo una para las animaciones, otra para los
Scripts en C#, otra para los Sprites, otra para las escenas, etc. Para hacer esto pulsamos con el
botn derecho del ratn en la ventana de Project y elegimos Create/Folder.
Como vemos este tambin ser el mtodo habitual de crear nuevos recursos en Unity, ya que en
este desplegable encontramos la posibilidad de crear Scripts en los diferentes lenguajes,
Shaders, Prefabs (Que veremos en su momento lo que son), Materiales y un largo etc.
Una vez insertados todos los Sprites que vamos a usar tenemos que configurarlos. Para empezar,
debemos saber que Unity normalmente detecta automticamente el tipo de de recurso que hemos
introducido en el entorno, pero no es infalible, as que deberamos revisarlo. En este caso
elegiremos el tipo Sprite(2D\uGUI) en Texture Type. Despus, como son Sprites simples y no
mapas de Sprites (Que manejaremos en otra ocasin), elegiremos Simple en vez de Multiple;
nos fijaremos en que el Filter Mode sea Point, para que no nos suavice los bordes de nuestro
amado arte creado en Pixel Art y usaremos el tipo Compressed (porque no necesitamos muchos
colores).
Hay una parte que hay que explicar ms para este caso y es Max Size. En esta parte elegimos el
tamao mximo de la textura, como por ejemplo 1024. Unity se maneja mucho mejor con texturas
cuadradas, pero para este caso estamos usando Sprites y lo vamos a pasar un poco por alto, pero
adems, nuestros grficos son muy pequeos. Cuando Unity los guarde no necesitamos que
genere una textura de 1024x1024 de un Sprite que mide 20x20, por lo que elegiremos un tamao
mximo que se adapte a nuestro tamao, que en este caso sera el mnimo de 32x32. Con esto,
nuestro querido motor generar texturas de ese tamao como mximo para nuestro arte y
estaremos ahorrando recursos. Al terminar pulsamos Apply para aplicar los cambios al grfico
elegido. Debemos saber que no tenemos que ir uno por uno, si no que podemos seleccionar todos
los que queramos en la ventana Project y aplicar los cambios juntos. Pero eso s, hay que tener
en cuenta que el tamao de textura puede necesitar variacin, porque habr Sprites entre los que
hemos creado que sern mayores de 32 de ancho o de alto, por lo que tendremos que elegir un
Max Size ms adecuado como 64, 128 o el que sea ligeramente ms grande, es decir, por poner
un ejemplo: Si el campo de juego mide 190x160, el tamao de textura de 128x128 se le queda
pequeo, por lo que elegiremos 256 que es el siguiente.
Una vez configurado todo nuestro arte lo colocamos en la escena. Para hacer esto o arrastramos el
Sprite a la ventana Scene donde podremos moverlo con el ratn, o lo arrastramos a la ventana
Hierarchy, donde aparecer escrito su nombre. Cualquiera de las dos formas es vlida y generar
tanto el nombre en Hierarchy, como el objeto en Scene.
Si pulsamos en la ventana Hierarchy la tecla F2 mientras tenemos seleccionado un objeto

podemos cambiar su nombre. Por ejemplo prefiero tener las cosas en ingls y con la primera letra
en mayscula para recordarme a m mismo que es un GameObject, es decir, un objeto del juego.
Por eso he cambiado campo por Field.
Ahora tenemos que aprender alguna cosilla ms, el uso del Inspector. En esta ventana aparecen
las propiedades del objeto seleccionado, tanto si lo est en la ventana Hierarchy como si lo est
en el Project Window. Cada objeto tendr determinados componentes y podremos aadirle ms
para que tenga nuevas funcionalidades usando el botn Add Component o desde el men
Component de la parte superior de la interfaz. En el caso del campo, vemos que como es un
Sprite2D, tiene el Sprite Renderer, que se encargar de dibujar el grfico en pantalla (Ya
explicaremos ms de este componente si es necesario). El otro que podemos ver es el
componente Transform, que tienen todos los objetos en Unity, incluidos los objetos vacos, y es
que este se encarga de definir su posicin en el espacio, su rotacin y su escala a partir de su X,
su Y, y su Z. Podemos as variar numricamente esta componente del objeto seleccionando e
introduciendo nmeros en estas casillas y sabiendo que, la escala normal de un objeto es (1,1,1)
su rotacin en reposo es (0,0,0) y, teniendo el punto de pivote en el centro, la posicin central en
la pantalla se define con (0,0,0).
Y nos vamos a ir despidiendo por ahora con lo poquito que hemos aprendido, prometiendo mucho
ms (como se puede ver en las imgenes yo llevo el proyecto mucho ms avanzado, jajaja - ejem,
no vale rerse -), pero antes veamos una cosa importante, la cmara. Si seleccionamos la cmara
en el Hierarchy pulsando sobre Main Camera que ya aparece automticamente en la escena,
vemos que tiene algunos componentes ya aadidos. El componente Camera es importante
porque en l definimos como va a mostrarse la escena. Como he dicho en muchas ocasiones para
juegos 2D nos interesa una cmara Ortogrfica, por lo que elegimos Orthographic en
Projection y definimos un tamao que nos enfoque todo nuestro campo de futbol. En mi caso ha
funcionado un Size o tamao de 0.8. Respecto a los Clipping Planes indica los planos de recorte
o distancias a los que la cmara dejar de pintar los objetos cercanos (Near) o lejanos (Far).
Como veis son demasiadas cosas las que hay que tratar para entender cmo funciona todo y el
espacio aqu es limitado, por lo que si hay dudas lo mejor ser investigar un poco por la red o
preguntarme (Si tenis suerte conocer la respuesta, porque tampoco es que sea un experto).
Ahora, eso s, antes de irme debera deciros como guardar una escena, algo diferente al proyecto,
que contiene los recursos que incluisteis en la carpeta de proyecto a travs de la ventana Project
y por lo tanto ya est guardado. Las escenas son como los niveles de juego, es decir, donde vamos
a colocar los objetos. Para guardarlas elegimos en el men superior File/Save Scene y a
continuacin navegaremos a la carpeta deseada dentro de nuestro proyecto (generalmente
Scenes) escribiremos el nombre deseado (En mi caso GameScene) y guardamos. Al abrir de
nuevo el proyecto en un futuro, si queremos recuperar esa escena solo tendremos que usar Open
Scene para cargarla o hacer doble click en su nombre en la ventana Project.
Si estis pensando que soy una mala persona por no colgar el proyecto en algn sitio para
descargarlo y tener todos los recursos necesarios, debis saber que lo hago por vuestro bien y
porque quiero que practiquis y curioseis todo lo posible, adems de que ya expliqu en el post
anterior, los Sprites que necesitaremos y como crearlos. As que a trabajar sin excusas!
Etiquetas: Desarrollo, Unity
lunes, 24 de noviembre de 2014

consolas: Atari 2 parte
Estoy disfrutando mucho de esta seccin que se me ocurri recientemente, aunque admito que lo
de tener que explicar cmo lo hago todo me resulta complicado, sobre todo por el espacio limitado
del blog. Pero bueno, all vamos y lo haremos lo mejor que podamos.
Despus de practicar un poco de pixel art en el post anterior, llega el momento de hacer los
grficos necesarios para el juego que crear usando Unity. La metodologa ser la misma y vamos
a trabajar en una versin de un juego que ya hice para el curso de Unity y C# de Gametopia, el
lanzador de penaltis.
Necesitaremos dibujar un campo, centrndonos en este caso en la zona donde est la
portera donde se lanzarn los penaltis. Como sabemos que tenemos lmite de colores,
especialmente en horizontal, donde solo podemos poner 4 colores por lnea para mantener las
reglas de la Atari 2600, haremos nuestro escenario con un color verde plano y un blanco para
las lneas de juego. Es importante coger los colores de la paleta de 128 disponibles para no usar
ninguno que no fuera capaz de pintar esta vieja consola. (Hay una imagen de la paleta en el post
anterior).
El tamao del campo ser de 190x160, que es la resolucin elegida para imitar la de la
mquina que estamos homenajeando, por lo que el resto de objetos tampoco puede tener un gran
tamao. Por ejemplo necesitaremos un lanzador de penaltis y un portero que, en el modo
prctica ser un mueco de madera, as que nos ponemos a hacer un poco de pixel art.
Con un tamao de 20x20 empezamos haciendo bocetos de lo que sera la silueta, luego los
arreglamos hasta darle una forma aceptable y por ltimo coloreamos teniendo cuidado con no
usar demasiados colores, especialmente en horizontal, donde ya tenemos 2 colores por lnea del
fondo y, por lo tanto, solo podramos poner otros 2 para el personaje. Aun as se puede jugar un
poco y dejar unos grficos muy chulos. Crearemos tambin un portero y, para que haya algo de
movimiento, los animaremos con un solo fotograma, la pierna levantada despus del tiro
para el jugador y la mano estirada para tratar de detener el baln para el portero.
Podramos haber hecho que el portero se lanzara para parar el baln y acabara en el suelo, pero
entonces su posicin de tumbado nos habra dado problemas con los colores, dado que tiene
bastantes en vertical y habran cambiado a su posicin horizontal, rompiendo as nuestro lmite de
4 con facilidad.
Dibujaremos tambin una portera de un color gris, para que destaque ligeramente sobre las
lneas de juego del campo, una pelota de un solo color y una flecha que utilizaremos para
apuntar a donde va a tirar nuestro lanzador. No hay que olvidar tambin algunos textos para
hacer indicaciones al usuario y una camiseta que muestre, en una pantalla de inicio, de qu color
ser la camiseta del futbolista que este controle.
La idea de juego es sencilla para que podamos acabarlo pronto. Consistir en una tanda de cinco
penaltis donde, por turnos, haremos una vez el papel de lanzador y otra el de portero. Ganamos si
tras los cinco tiros metemos ms lanzamientos que el rival. Si hay un empate se sigue en tandas
de un lanzamiento donde, si uno mete y el otro falla, se acaba el juego con victoria del primero.
Vamos, lo que son las normas de siempre.
Para hacer el juego un poco ms largo en durabilidad (pero poco) aadiremos un modo
entrenamiento donde lanzar frente a un mueco de madera y sin lmite de tiros. (Por lo que habr
que dibujar el muequito, pero ser fcil a partir de la silueta del propio portero)
Cmo vamos a hacerlo? Pues como ya coment usaremos Unity, as que espero que la gente ya
conozca un poco de este motor, ya que tampoco me voy a poder parar mucho con l. Aun as
vamos a ver una breve introduccin al entorno para ayudarnos a entrar en materia para prximos
captulos.
Como vemos en la imagen el entorno tiene varias zonas. Aunque hay que decir que es
complemente configurable, por lo que las ventanas se pueden colocar de manera muy distinta a
como yo las tengo. Aun as, es fcil abrir y cerrar ventanas nuevas desde el men Window de la
parte superior.
1. La pestaa Game nos muestra la vista de lo que sera nuestro juego. Al pulsar el botn play se
pondr en marcha y podremos verlo en esta pequea ventana o, en caso de configurarlo para ello,
en la pantalla completa.
2. La pestaa Scene es donde colocamos los objetos de nuestro juego, los movemos, los
cambiamos de pantalla Sera como el editor de la escena. Adems en la configuracin de Unity
que yo tengo vemos que en esta zona tambin hay dos pestaas: Animator y Animation. Estas se
usan para animaciones y las veremos ms adelante.
3. La pestaa Hierarchy muestra los objetos que hay en la escena actual. Nos ayuda a
seleccionar ms fcilmente por el nombre sin tener que buscar en escenas muy complicadas,
adems de que el hecho de arrastrar un elemento a esta pestaa, hace que aparezca en la escena
de juego tambin.
4. La pestaa Project muestra los grficos, sonidos, texturas o lo que sea que hayamos cargado o
creado para usar en nuestro juego. Aqu aparecen todos los objetos, estn o no en la escena
actual. Para cargar un archivo externo basta con arrastrarlo desde nuestro navegador de carpetas
del sistema operativo hasta esta pestaa. Sin embargo, una vez cargado todo aqu, podremos
tambin crear carpetas y organizarnos. Conviene no modificar esta estructura creada desde el
propio sistema operativo por si perdemos algn enlace que Unity haya creado.
5. Inspector. Depende de la herramienta, componente u objeto seleccionado el inspector cambiar
mostrndonos sus propiedades. Aqu podremos ajustar muchos detalles y variables, aadir
componentes nuevos, etc.
6. Estos 4 botones se usan para mover el visor, mover un objeto, rotarlo, o cambiar su
tamao respectivamente.
7. Jugar, Pausar y avanzar fotograma a fotograma en nuestro juego.
8. La zona donde podremos configurar las capas y la forma de la interfaz de Unity, es decir,
como estarn distribuidas las ventanas. Las etiquetas se usan para agrupar ciertos objetos. Es algo
que tambin veremos ms adelante.
prximamente ms.
Etiquetas: Grafismo, Pixel Art, Unity
domingo, 28 de septiembre de 2014
Libros: Unity 2D Game Development

Siempre he sido un gran amante de los juegos 2D, sin importar que tengan sus grficos pixel art,
vectorial o como sea. Forman parte de mi infancia y han ocupado la mayor parte de mi vida como
desarrollador y como usuario, dejando en mi memoria (escasa, por otra parte) inolvidables
personajes desplazndose nicamente en los ejes x e y. Como consecuencia de todo esto, casi
todo el uso que he dado a Unity ha sido para crear mundos 2D, unas veces recurriendo a trucos
de cmara y quads (polgono cuadrado plano formado por dos tringulos) y otras recurriendo a las
nuevas funciones 2D del engine.
Quera profundizar en las funciones 2D de Unity y me hice con Unity 2D Game Development,
un libro de la genial editora de Packt Publishing que se dedica bastante al tema de los videojuegos,
en el que de forma resumida y entretenida (tiene algo ms de 100 pginas) nos ayudan a
desarrollar un juego de plataformas 2D en nuestro querido motor, recurriendo a las nuevas
funciones que nos harn la vida ms fcil para este tipo de desarrollos. As, entre tiempo de
proyectos, buscar un curro con el que ganarme la vida y alguna que otra partidilla de vez en
cuando, dejo pendiente tambin una lectura de principio a fin del libro, para hacer el juego que
propone y sacar alguna idea que tenga por ah dentro del gnero plataformas y poner en prctica lo
aprendido. Todo a largo plazo, porque estoy un poco ocupado, pero bueno. :P
Solo para ir comentando por encima como funciona esto del 2D en mi motor favorito, decir que se
recurre a cmaras ortogonales (se proyectan paralelamente hacia el infinito, por lo que captan los
objetos al 100% de su tamao independientemente de la distancia a la que estn situados), un
sistema de estados para controlar las animaciones, colliders 2D para controlar las colisiones de
objetos planos, y el nuevo objeto sprite, que viene a ser un Quad donde colocar nuestros grficos
bidimensionales pero se comporta de otra forma. (Ms o menos esto es el 2D de Unity).
Para despedir el post toca comentar algunas cosillas sobre esta publicacin. En primer lugar, est
en ingls, como de costumbre para este tipo de volmenes; en segundo lugar es de principios de
2014, por lo que ya hay por ah otros nuevos, concretamente estoy pendiente de uno que est por
salir, si no ha salido ya, titulado algo parecido a Mastering Unity 2D Development y que se estaba
comentando hace unos das por los foros de desarrolladores Indies. Si finalmente sale y puedo
conseguirlo (porque tardar en llegar a mi pas), lo comentar aqu, como siempre. :)

Etiquetas: Desarrollo, Libros, Unity
martes, 16 de septiembre de 2014
Juegos 3D con grficos 2D

Hace aos la revolucin llegaba con los juegos 2D cuyos grficos estaban hechos en 3D, es decir
pre-renderizados, consiguiendo que las animaciones fueran ms fluidas y el acabado grfico
tuviera un poco ms de realismo. Sin emargo, con el tiempo los polgonos se impusieron y
pasamos al 3D, movindonos no solo arriba y abajo en la pantalla si no tambin en profundidad.
Bien, pues han pasado aos desde entonces y muchos desarrolladores han cambiado esta filosofa
del 3D en juegos 2D para usar Sprites 2D en entornos 3D y conseguir as juegos con el aspecto
ms tradicional o retro movindose en distintos planos y por escenarios ms vistosos.
Actualmente los motores para crear videojuegos como Unity trabajan siempre (Se que tiene
nuevas funciones 2D, pero no trabaja realmente en 2D) en 3D, por lo que, aunque creemos juegos
con un movimiento 2D y grficos retro, los estaremos desarrollando en un completo entorno
tridimensional, con las ventajas que esto nos proporciona. Por ejemplo, podemos elegir entre una
cmara ortogonal (es decir que proyecta sus rayos hacia el infinito de forma paralela y muestra los
objetos en pantalla al 100% de su tamao sin importar la distancia hacia donde se encuentren) o
una cmara en perspectiva, consiguiendo que sprites planos se desplacen sobre fondos 3D,
pudiendo as crear proyectos tan interesantes como lo fue en su da Paper Mario.
Gracias a esta nueva forma de desarrollar juegos 2D, aunque tengamos que tener otra mentalidad,
distinta a la del movimiento bidimensional de antes, podremos aprovechar para generar mens de
juego ms dinmicos de forma sencilla, dividir nuestros personajes en piezas para animarlos por
rotacin, o dar cierta sensacin de profundidad en capas de objetos planos, muy til para los
decorados. (En la imagen podis ver el juego Teslagrad como un bonito ejemplo de todo esto)
Unity antes de incorporar sus funciones 2D permita el desarrollo de este tipo de juegos con
algunos trucos de programacin y diseo que han quedado simplificados. Y es que con unos
cuantos Quads (un polgono formado por 2 tringulos), la ya mencionada cmara ortogonal y el
desplazamiento de la textura aplicada al Quad para convertirlo en sprite y, gracias a este,
animarlo,ya tenamos todo lo necesario para recuperar los viejos tiempos de los juegos retro.
Aunque eso s, todos agradecemos la simplificacin que ha supuesto este tipo de desarrollo en las
ltimas versiones del popular motor.

sbado, 25 de enero de 2014
Memory G-Cards postmortem

Hace ya bastante tiempo que hice un pequeo juego en Flash con chicas dibujadas con un estilo
similar al Manga como homenaje al comic japons de Welcome to NHK(el cual fue una gran
inspiracin para m). Aquel pequeo proyecto me sirvi para practicar un poco el dibujo y divertirme
creando algo sencillo que pudiera terminar en poco tiempo. Por todo esto, cuando pens en dar el
paso de crear mi primer juego en solitario para Android, pens que iba a ser una buena opcin
adaptar Memory G-Cards. Se trataba de un desarrollo relativamente corto y del que ya tena la
mayor parte grfica resuelta (aunque haba que adaptarla al nuevo formato), por lo que poda
centrarme en la programacin, que era lo que ms problemas iba a darme debido a que no poda
hacer las cosas de la misma manera que en Flash, debido a que iba a usar Unity y C#, que
funcionan de manera diferente a Flash y ActionScript.
El objetivo
El objetivo de este proyecto era dar el paso de publicar en Google Play Store un proyecto creado
ntegramente por mi y as aprender el funcionamiento del sistema de monetizacin mediante
publicidad, adems de currarme un juego del que poder aprender con el tiempo viendo los errores
y aciertos. La opcin de un juego de cartas y memoria me pareci lo mejor para dar este primer
paso, pensando que podra llegar con l hasta 1000 descargas al menos, entre Octubre de 2013 y
Enero de 2014.
Produccin
La realizacin de la planificacin y documentos como el de diseo de juego fueron bastante fciles
debido a que los tena resueltos con el juego original en Flash que realic en su da. Hubo que
adaptar el formato, la forma de jugar (sustituir el ratn por los toques con el dedo en la pantalla) y
el sistema de mens.
Programacin
Algunas de las soluciones usadas en el cdigo ActionScript podan adaptarse a C#, pero otras
tenas que resolverlas de otra forma. Unity (aunque ahora tiene opciones 2D), al contrario que
Flash trabajaba en 3D y muchas cosas haba que hacerlas mediante polgonos. Adems,
evidentemente el cdigo tena que reescribirse en el nuevo lenguaje (de ActionScript a C#) y
adaptar las pantallas, formato de cartas y fondo, GUI e tems al formato mvil y tablet.
Grficos
Aunque hice algunos cambios en los fondos y nuevos mens, la parte grfica estaba casi resuelta.
Tras sustituir el formato de pantalla de un ordenador en horizontal por el vertical y ms alargado de
un dispositivo mvil, decid cambiar la forma de las cartas de rectangular a cuadrado, mostrando
adems solo la cara de las chicas (en el juego original aparecen enteras) debido al pequeo
tamao en el que se veran, dando adems, ms sentido a tener una galera de imgenes donde
desbloquear la imagen completa.
Diseo del juego

Dise el juego ponindome unas limitaciones. La principal era que no hubiese animaciones,
aunque si movimiento, con ello solo tendra que dibujar y colorear a las chicas y usar esas
imgenes para hacer un juego. Como mi memoria necesita ser entrenada, se me ocurri enseguida
recurrir al clsico juego de parejas de cartas, pero por otro lado quise aadirle algn toque que no
hubiese visto en otros juegos de ese tipo (los tems).
El candado no recuerdo haberlo visto antes (igual exista ya, no lo s) y aada un efecto
penalizador a aquellos jugadores que trataran de solucionar los niveles a lo loco, pulsando
demasiadas veces en la misma carta. Por otro lado, si recuerdo haber encontrado juegos de este
estilo que aadieran o restaran tiempo, as que recurr al clsico reloj para compensar con un poco
de azar algunas partidas, ayudando a obtener mejores records de tiempo. (El candado bloquea la
carta durante 5 segundos y el reloj nos da 5 segundos extra de tiempo).
Este estilo de juego o uno de puzle era la mejor opcin para empezar, ir aprendiendo y, con el
tiempo, meterme en proyectos ms complicados (hablando de proyectos individuales, en grupo
pretendo hacer ms cosas, pero preferira no tener que programarlas yo y dedicarme a otras
tareas).
Novedades
Cuando tena el juego listo decid que era demasiado corto. Terminarlo era sencillo, as que trat de
ajustar los records de los niveles para que superarlos no fuera cuestin de una partida. Adems,
aad un nivel extra con las que seran las gemelas de las chicas que mas me gustaban de los
otros niveles y, lo que en mi opinin alarga ms la vida del juego, unos trofeos que desbloquear a
base de esfuerzo y unas cuantas partidas.
Musica y sonido
Recurriendo a temas muy simples que ya tena compuestos y creando alguno nuevo de corta
duracin y preparado para ejecutarse en bucle, tuve resuelta mi pequea banda sonora de 3 temas
(men, pantalla de galera y seleccin de nivel).
Para el sonido grab una carta rozando con la mesa usando un micrfono y us un sintetizador de
sonidos para crear el de activacin de un botn de men, la aparicin de un candado, la de un
reloj, etc. (Eso s, tuve que retocar un poco los sonidos, un ecualizador por aqu, un compresor por
all)
Testeo
Siempre intent ir testeando el juego segn lo desarrollaba, incluso en dispositivos externos (una
tablet y un mvil). Desgraciadamente no se podan probar todos los formatos de pantalla,
resoluciones, velocidades No tengo dinero para comprar todos los dispositivos Android del
mercado! Con el tiempo he visto que a veces la pantalla se corta por los lados o la publicidad da
problemas. (Para el prximo juego espero resolver este problemilla). Por otro lado, no han
aparecido Bugs serios, aunque hubo alguno que en su momento me dio bastantes quebraderos de
cabeza y me cost resolver, como uno relacionado con el momento de pausar el juego cuando las
cartas estaban recuperando su posicin tras fallar la coincidencia de parejas.
Hubo, eso s, un pequeo fallo en el ttulo del juego que se ha quedado en muchas de las capturas
que se pueden ver en este Blog. Durante mucho tiempo no me d cuenta de que haba escrito
Memory G-Cars y me haba comido una "d"... Lo arregl a tiempo.
Resultados
Respecto a los objetivos (que ya esperaba no iba a cumplir, debido a que no soy nada bueno
publicitndome), las descargas obtenidas han sido solo un bajo porcentaje de las que deseaba
conseguir (ahora est entre 100 y 500) y parece que la publicidad no est generando beneficios,
as que tendr que seguir intentndolo para poder pagar el alquiler creando videojuegos. Eso s,
sin duda he aprendido mucho y me he sentido orgulloso de iniciar un nuevo proyecto y llegar a
terminarlo por completo.
Idiomas
Desde el principio tuve claro que no quera tener muchos idiomas para el juego para evitar
complicaciones con la traduccin, as que lo ms sencillo para m fue recurrir al ingls (ya que
todos quieren que lo hablemos pues aprovechmonos de ello)
Unity y Android
Despus del curso de Unity que hice poda defenderme en la programacin de un juego pequeito
como este, pero no haba visto absolutamente nada de Android y no me imaginaba las
complicaciones que iba a darme. Cuando empec, apenas haba documentacin sobre el tema, ya
que era muy reciente la aparicin de licencia gratuita de Unity para este sistema. Tuve as que
buscarme la vida muchas veces y aparmelas pensando cmo hacer las cosas a mi manera
(aunque he de decir que en los foros ya se empezaban a resolver muchas dudas)
Opiniones del pblico
Al pblico en general le sorprendi el pequeo toque adictivo que daban los tems a las mecnicas
clsicas, lo cual me hizo sentir muy orgulloso. Por otro lado parece que a pesar de mis esfuerzos
se qued en un ttulo que proporcionaba pocas horas de diversin. Adems, muchos me pidieron
una tabla de records online para hacer competir a los usuarios (que no tena ni idea de cmo
programar)
Marketing
No soy muy amigo de pasarme por foros, comentar, exponerme en redes sociales y en definitiva
recorrer la red para dar a conocer mis proyectos (hasta comentarlos aqu en el Blog me cuesta),
pero aun as hice un ligero esfuerzo que, evidentemente, no fue suficiente. Tampoco soy bueno
situando mis productos en el buscador de Google Play.
Puedo aprender mucho de esta parte para el futuro, pero s que me costar llegar a dominar esto
porque odio ser pesado con la gente y siempre he pensado de forma idealista que ya llegaran a
mis juegos aquellos usuarios interesados en ellos. (Adems, ahora que hago juegos sobre todo
para aprender cuesta presumir de ellos por su sencillez)
Mis habilidades como jugador
He jugado tantas veces que he descubierto buenas formas de conseguir records. La suerte es un
factor que influye ms de lo que me gustara, ya que es clave obtener relojes y que las cartas
aparezcan bien situadas al principio. Cuando fallamos las cartas tardan un segundo en recuperar
su posicin de boca abajo y no podemos hacer nada, pero si encontramos una pareja no tenemos
que esperar para tocar otra carta. As, podemos intentar ser rpidos.
Coloco aqu mis records, destacando que en el nivel 3 me encontr con una situacin en la que las
parejas estaban situadas juntas y seguidas. Fue todo tocar la pantalla a toda velocidad!
Nivel 1: 00:02
Nivel 2: 00:16
Nivel 3: 00:06
Nivel Extra: 00:38
Agradecimientos
Debo agradecer aqu a todos los que me ayudaron a probar alguna versin del juego (mis primo,
mi novia y otros familiares), a los que me aguantaron aqu delante del ordenador, viviendo como en
otro mundo mientras trabajaba en el proyecto (de nuevo mi novia y mis padres cuando trabajaba
en su casa) y a todas aquellas personas que descargaron, probaron, puntuaron, comentaron o
jugaron Memory GCards. Aunque sean poquitos a mi me hace mucha ilusin. Este es solo un
pasito ms en el camino.
Dnde conseguir el juego?

Se puede descargar gratis para mviles y tablets Android desde Google Play Store en esta
direccin:
https://play.google.com/store/apps/details?id=com.Perplex.GCards
Para encontrarlo en Google Play se puede buscar las palabras memory perplex.
Hasta el prximo Post-mortem.
Proyectos: Memory GCards Android

Hace algo as como un mes decid empezar a desarrollar para Android, y es que, aunque ya vi
publicados un par de proyectos en Google Play Store en los que he tenido participacin de
alguna u otra forma, no haba publicado nada por mi cuenta por estar orientado a otras plataformas
como Flash.
Mis dos anteriores apariciones en Google Play Store son:
Pixfrogger y Mess Puzzles
Pero ahora tocaba saber cmo funcionaba todo por mi cuenta, y para eso que mejor que un
desarrollo corto, de un mes, aproximadamente, que me permitiera aprender lo bsico sobre
publicacin, promocin, funcionamiento de la plataforma, etc. Empec por tanto a portar el
pequeo juego de memoria con parejas de cartas que tena hecho en Flash ayudndome, eso s,
de Unity.
La idea de este juego ya expliqu que surgi de un cmulo de cosas. Que estaba aprendiendo a
dibujar chicas manga intentado tambin darles un toque ms personal (por lo que tena mucho
trabajo grfico hecho), que aprend tambin como poda hacer un juego de parejas de cartas
cuando intentaba conocer a fondo la programacin en Action Script, y por ltimo, que quise hacer
un sutil homenaje a la historia narrada en el Manga y Anime de Welcome to NHK, donde el
protagonista es un hikikomori que trabaja en el desarrollo de un juego de estilo muy japons.
Con todo, me volqu en el desarrollo, adaptacin y ampliacin de la idea inicial de este juego
partiendo de los documentos de diseo que tena, aadiendo ms retos, un nivel extra y algn que
otro detalle que aada inters y durabilidad al ttulo. Por otro lado, eso s, no poda olvidar el modo
de sacar algn rendimiento econmico con el que poder seguir creando proyectos nuevos, con un
poco de suerte, cada vez ms interesantes y de ms envergadura. Tuve que integrar, por lo tanto,
un sistema de publicidad que apareciera en sitios clave, tratando de evitar que molestara al usuario
en el momento del gameplay.
Con este primer experimento realizar una evaluacin del funcionamiento de la plataforma Android
y de cmo llegar al pblico para poder hacer ms y ms juegos en el futuro, que es lo que me
encanta hacer. Y es que lo mejor de haber terminado un proyecto es empezar a planear el
siguiente.
Vamos ahora con una descripcin del juego:
Voltea dos cartas y si las chicas coinciden, encontraras una pareja. Trata de encontrarlas todas en
el menor tiempo que puedas para superar los records y acceder a las imgenes de la galera o
conseguir los retos que te harn completar el 100% del juego.
Aydate de los relojes que encontrars y te darn tiempo extra y ten cuidado con los candados que
bloquearn tus cartas temporalmente si fallas ms de 5 veces.
A los que descargueis el juego para echar unas partidas, les agradezco el apoyo y espero
que disfruteis de un rato de entretenimiento.
Memory GCards puede descargarse del Google Play Store desde el siguiente enlace:
https://play.google.com/store/apps/details?id=com.Perplex.GCards
Etiquetas: Android, Proyectos, Unity
martes, 10 de septiembre de 2013
Formacin: Inteligencia Artificial

Despus de terminar la primera parte del curso de Unity en Gametopa, hace no mucho que
comenc con el mdulo de Inteligencia Artificial. Hablamos por tanto de bsqueda de caminos,
evasin de obstculos y algoritmos de distintos tipos para conseguir que los personajes no
controlados por el usuario dentro de nuestro juego, parezcan comportarse con inteligencia y
realizar acciones en busca de cumplir objetivos concretos.
Gracias a la IA (Inteligencia Artificial), que hoy en da est bastante avanzada en el mundo de los
videojuegos, podemos conseguir que nuestros personajes controlados por el ordenador hagan
cosas como resolver un laberinto, encontrar la ruta ms corta hacia un punto, detectar al jugador y
seguirle (o huir de l), trazar estrategias de ataque y un largo etc.
Para un proyecto de videojuegos, hay que tener en cuenta que no se necesita una IA
excesivamente compleja ya que, por un lado, el jugador debe seguir teniendo opciones de ganar y,
por otro en ocasiones, demasiada complejidad, a pesar de lo que podamos pensar, hace que una
IA parezca estpida o con funcionamiento defectuoso.
Un ejemplo interesante al que estuve re-jugando cuando empec esta parte del curso de
Gametopia es el fantstico Pikmin. En este juego resulta divertidsimo ver como los simpticos
personajillos llamados Pikmins, siguen constantemente al protagonista (o los protagonistas, porque
en la segunda entrega hay 2 y en la tercera 3) y a veces tropiezan y se pierden por separarse del
grupo o acaban siendo devorados por la fauna hostil del planeta donde viven.
En fin, que por mi parte, solo algunos ejercicios ms y habr terminado, y he de reconocer que he
aprendido bastante de Unity, pero me queda muchiiiiiiisimo. Quizs cuando tenga hechos unos 50
juegos empezar a tener ms manejo :P

Etiquetas: Desarrollo, Formacin, Unity
viernes, 2 de agosto de 2013
Prototipos en Unity
Hace unos das que termin la primera parte del curso de Unity en Gametopia y estuve ampliando
conocimientos en busca de la sabidura absoluta. A pesar de todo aun me queda mucho para saber
lo suficiente de este motor para juegos (no llevo ni tres meses en serio con l), pero tena que
hacer un proyecto para que me dieran acceso a la parte de Inteligencia Artificial y, tras terminarla,
obtener mi certificado para aadir a la coleccin que yo llamo Papeles que dicen que se algo
sobre videojuegos. El caso es que soy un tipo indeciso, y cada da se me ocurra un proyecto
distinto. Quera hacer algo simple y que me divirtiera a modo de prototipo, as que pas por un
matamarcianos, un pong, un tower defense El resultado de tantas dudas y tanto cambiar la idea
de que iba a entregar ha conseguido que se me echara el tiempo encima y he acabado haciendo
un juego muy sencillo de tirar penaltis. Ya seguiremos aprendiendo y haremos cosas mejores con
tiempo.
El desarrollo de este tipo de prototipos sirven a los programadores como aprendizaje. No hay que
mirar que quede bonito y te centras en la resolucin de problemas de tipos o gneros concretos de
juegos y, con el resultado final, puedes probar que el gameplay sea divertido y el proyecto
enganche. Se observa tambin que cosas pueden cambiarse o aadirse, y que coste de desarrollo
aproximado en tiempo tendra el juego si lo terminramos como es debido.

Mis planes de futuro no incluyen la conversin de ninguno de los prototipos que he hecho durante
el curso de Unity en un juego real, ya que tengo pensada otra cosa y ahora ando en otros
proyectos que no se el tiempo libre que me dejarn, pero he observado que en este motor es muy
sencillo sustituir un cubo por un modelado ms elaborado, personalizar la interfaz y aadir detalles
como un escenario. Lo complicado es modelar, texturizar y animar todo lo que har falta. Adems,
si queremos que quede bien, lo que se dice bien, tambin habr que aadirle sonido y una buena
banda sonora. Todo es trabajo, por eso se tarda tanto en crear videojuegos

Etiquetas: Desarrollo, Formacin, Proyectos, Unity
martes, 16 de julio de 2013
Evitar el Hardcoding
El Hard-code es un trmino en el mundo de la programacin que se refiere a una mala costumbre
de poner los datos directamente en el cdigo de nuestro programa o juego.
Ahora que estoy empezando con Unity he visto que resulta muy til usar variables pblicas, a las
que se puede acceder desde el propio inspector del motor, para modificar datos y hacer pruebas de
juegos con distintos valores establecidos. De esta forma, por fin me estoy dando cuenta que hay
que huir del ya comentado Hard-code para facilitarse las cosas a medio-largo plazo.
Me explico
Imaginemos que estamos haciendo un juego de estrategia y pensamos que podra tener 12 casillas
de alto por 16 de largo. El hardcoding sera escribir ese 12 y ese 16, as como suenan,
directamente en alguna parte del cdigo cuando necesitemos especificar el tamao de nuestro
escenario. Si ms adelante decidimos que era ms ptimo tener casillas ms grandes y que haya
solo 8 x12 tendremos que bucear entre todo lo escrito y cambiar esos nmeros estn donde
estn. Por eso es una mala prctica!
En su lugar lo ideal suele ser irse a la zona de declaracin de variables de nuestro cdigo y escribir
una constante (o una variable pblica en el caso de Unity, para poder modificarla desde fuera) y
usarla despus en lugar de los datos en bruto. En el ejemplo anterior podramos, por ejemplo, tener
anchoTablero = 16 y largoTablero = 12, con lo que si hubiese que cambiarlo tenemos las variables
localizadas al principio del cdigo y resulta mucho ms fcil actualizar.
A nivel de diseo podemos probar, por ejemplo, en un juego de coches con una velocidad
determinada y cambiarla si vemos que parece exagerada y hace la conduccin imposible o si nos
ha quedado un vehculo demasiado lento. Para lograrlo Qu tal una variable pblica llamada
velocidad, a la que podemos acceder sin meternos en nuestro archivo fuente y con la que podemos
jugar para hacer testeos? (En este caso vuelvo a hablar del motor Unity, pero tambin se pueden
tener variables fcilmente localizables en todo el cdigo que escribamos sin importar el lenguaje)
Gracias a esta forma de trabajo tendremos mayor facilidad para hacer test y ajustar todas las
variables importantes de nuestro juego hasta situarlas en su punto ptimo, como pueden ser la
gravedad de un juego de plataformas, el nmero de balas o magias en juegos de accin, etc.

lunes, 8 de julio de 2013
Profundizando en el aprendizaje de Unity
Acabo de finalizar la primera parte del curso de Unity que estoy cursando en Gametopia y ahora
me toca ponerme a hacer un pequeo proyecto de videojuego con lo aprendido para acceder a la
segunda parte, la que tiene que ver con Inteligencia Artificial. Pero alguno se preguntar Eres ya
experto en Unity? y la respuesta es fcil de contestar. Todos los cursos, y no solo los relacionados
con videojuegos, e incluso los programas de formacin profesional o carreras universitarias, son
introductorios y necesitan que luego trabajemos para profundizar en nuestros conocimientos, junto
con un montn de horas de practicar y practicar para ganar experiencia. Por ello me he puesto a
buscar ms informacin sobre este motor de Juegos en Internet y he encontrado algunas pginas
interesantes para que mi aprendizaje se acerque ms a lo profesional.
Para empezar tenemos la Web de Unity con tutoriales y un manual de referencia que nos sacar
de ms de un apuro. Aqu, podremos aprender todo sobre las fsicas, importacin de modelos,
escritura de scrips en los 3 lenguajes que permite Unity e incluso ejemplos de juegos hechos. Un
sitio interesante pero, eso s, en ingls.
Para profundizar ms en la parte de cdigo tenemos un Blog (http://unityscripts.blogspot.com.es/)
muy interesante de alguien que se ha currado explicaciones de cada una de las clases que tiene
este motor con ejemplos en espaol. Lo hace todo con JavaScript, pero es bastante sencillo
convertirlo a otro lenguaje (que me parece ms interesante) como C#. Si por un casual tenis
problemas con esto ltimo hay una solucin muy buena. En esta pgina est disponible un
convertidor del cdigo JavaScript a C#.
Quedaos bien con la ltima pgina recomendada, por que tambin en la que os comento ahora se
programa con JavaScript. Aqu, tenis una Web repleta de videotutoriales sobre Unity, con
exmenes incluidos para evaluar los conocimientos aprendidos y varios ejemplos de videojuegos
hechos (por ejemplo un Mario 2D y otro 3D) e incluso de modelos a importar junto con el cmo
hacerlo. Esta ltima Web, cuyo contenido est tambin en ingls, me ha gustado mucho y en solo
un par de das me he visto prcticamente todos los videos y ya estoy haciendo los proyectos que
vienen como ejemplo (tengo unas ganas de llegar al Mario en 3D)
As, buscando material, practicando y creando juegos, seguir intentando convertir a Unity en mi
motor favorito y con el que ms cosas voy a crear, pero eso s, no quiero dejar de lado la
programacin desde cero, por que uno se acomoda y olvida las cosas ms bsicas.
Contar el resultado del curso de Gametopia cuando lo termine del todo, pero como ya adelant,
me est gustando bastante, aunque como ya digo, despus queda un largo camino de aprender y
fijar en nuestra memoria lo aprendido.

Etiquetas: Desarrollo, Formacin, Unity, Webs
sbado, 15 de junio de 2013
Aprender Unity: Esta vez va en serio
He ledo unos cuantos libros sobre Unity pero nunca llegu a ponerme con l en profundidad,
trabajando da a da y tratando de fijar conocimientos en mi memoria (mala memoria, eso s)
Siempre me echaba un poco para atrs el que hubiera una versin de pago y me limitaran cosas,
adems del hecho de que me gustan los juegos 2D y rara vez se me ocurren ideas interesantes
para juegos en 3D que sean realizables en un periodo de tiempo razonable. Por todo eso nunca
llegu a ponerme en serio con este motor y mir otras opciones como Flash para desarrollar mis
juegos (Aunque la verdad es que con tantos motores, lenguajes y software uno ya no saba con
que ponerse a crear).
El caso es que he sacado algo de tiempo libre por fin (no mucho) y he decidido apuntarme al curso
de Unity que hace Gametopia en versin Online desde hace algn tiempo. Tengo buenos
recuerdos de cmo trabajan por que ya es mi tercer curso all (Guiones y Betatester fueron los
primeros) y, por otro lado, a veces el gastarse algo de pasta en algo te obliga un poco a no dejarlo
aparcado. As que despus de haber hecho los 3 primeros temas del curso (empec ayer) me he
propuesto ponerme en serio y usar Unity como motor preferido, junto con C# como lenguaje para
programar scripts en l (antes usaba javascript).
De momento solo he mirado un poco el entorno y conseguido que un coche se mueva adelante y
atrs, recordando que quiz lo que se me hace ms pesado de los juegos 3D es tener que hacer
todos los elementos que lo componen, que llevan un trabajo doble por que tambin hay que pintar
las texturas (o triple o cudruple si nos metemos en Next-Gen).
Con el tiempo, quiero desarrollar algn jueguecillo y ver las opciones de exportacin a distintas
plataformas, profundizar ms en el lenguaje C# (si ahora voy a hacer de programador habr que
mirar lenguajes en profundidad) y sobretodo ser constante en el uso del motor para no olvidar lo
aprendido. Es lo que recomendara a cualquiera que quiera trabajar en un motor determinado,
aunque no hay que cerrar otras opciones por completo por si algn da hay que adaptarse.
Para aquellos que queris saber ms de Gametopia y sus cursos sobre videojuegos, su pgina es:
http://www.gametopia.es/
(Por supuesto tambin me he apuntado al mdulo de Inteligencia Artificial, que no quiero que mis
enemigos se queden ah parados esperando que los maten y ya est :P)

Etiquetas: Desarrollo, Formacin, Programacin, Unity
sbado, 10 de noviembre de 2012
Webs recomendadas: Eresgamer.com

Me gusta mucho la iniciativa de los responsables de este sitio, que se han unido para recopilar
informacin sobre tutoriales para el desarrollo de videojuegos y, han organizado un curso de Unity
3D a base de videotutoriales y cuestionarios. Yo mismo haba pesado hacer tutoriales de Unity,
pero el manejo del mismo me pareca demasiado sencillo y quera centrarme ms en la parte de la
programacin de scripts. Ahora, el manejo de la interfaz del motor parece que quedar cubierta con
los tutoriales de esta Web que recomiendo hoy.
Cosas buenas y malas
Una parte que no me gusta de Eresgamer es que no aconsejan empezar desde abajo ni
recomiendan a los que empiezan en esto no meterse en proyectos demasiado grades. Al contrario,
parece que se sigue fomentando el ansia de muchos novatos de hacer la competencia a empresas
grandes con cientos de trabajadores creando un nuevo World of Warcraft, Crysis 3, etc. En lugar de
esto quizs se debera recomendar a la gente empezar con pequeos trabajos para aprender y
guardarse sus obras maestras para cuando reunan la capacidad, conocimientos y medios para
poder llevarlas a buen puerto.
Por otro lado, aunque los videotutoriales de Unity, que ya han empezado a publicar, son algo
improvisados, tambin son tiles y se puede aprender de ellos. Parecen ser una prometedora
forma de introducirse en el motor y aprender a hacer nuestros primeros juegos en el futuro, as que
habr que seguirlos.
Tambin, este sitio Web, puede nacer un punto de encuentro para desarrolladores, donde
encontrar colaboradores, socios y consejos. Aunque recordemos que, para eso, en Espaa ya
tenemos stratos-ad.com, la cual es dificil de superar en este aspecto.

Etiquetas: Influencias, Unity, Webs
sbado, 26 de mayo de 2012
Unity 3.x Game Development Essentials

Otro libro ms de Unity que me dispongo a leer, y es que me hice con un buen arsenal para
empezar a meterme en un motor 3D que no me diera muchas complicaciones y me permitiera
hacer algn da juegos sencillos e interesantes de modo que pudiera coger experiencia en la
produccin (ya que uno no puede aprender en empresas tendr que hacerlo en su casa).
El volumen pertenece a la misma serie que los otros dos que coment en el Blog, solo que esta
vez se nos exige un nivel medio. (Y claro, se hacen ejemplos nuevos).
Una introduccin al mundo 3D de Unity nos prepara para la elaboracin de entornos, interfaces de
usuario, animaciones, partculas y todo lo bsico que necesitamos saber de este genial motor,
dedicando gran parte del texto a ensearnos a programar scripts en Javascript (tambin algo en
C#). As, con todo esto, iremos desarrollando algunos ejemplos de los que ya mostrar algo por
aqu cuando lo haya completado.
Y ahora, a seguir estudiando, que me van a pillar los exmenes en pleno E3 (hay que joderse) y
queda muy poquito para acabar y espero que el verano me traiga tiempo libre o trabajo. O Ambos!

jueves, 10 de mayo de 2012
Probando modelos 3D en un motor (Unity)

Estos das me he entretenido en la idea de crearme un sencillo visor de modelos 3D en Unity con
los conocimientos que tena, as que, pensando unas teclas para mover la camara y otras para
rotar el objeto, por fin poda ver un render en tiempo real de los elementos que he ido creando en
mis aos de artista 3D. Mi intencin ahora es mejorarlo cuando pueda, e incorporar la opcin de
hacer un visor de escenarios (donde nos podamos pasear en primera persona), que sera muy
sencillo, y otro para las animaciones, que adems, me ayudara a meterme ms en el arte de
animar en 3D (que lo tengo bastante abandonado).
El motivo de todo esto es mejorar mis habilidades como modelador y texturizador, probando todo lo
que vaya haciendo en el motor que tengo pensado usar para los juegos poligonales que pueda
crear, que no es otro que Unity.
Puedo comprobar como reaccionan los objetos, personajes y escenarios ante las luces, y detectar
fallos que puedan ocurrir en las zonas de unin de las texturas, los shaders, poligonos sin soldar,
etc. As, al corregir errores quiz aprenda a ver donde meto la pata habitualmente y, cuando
participe en algn proyecto sea ms habilidoso y conozca donde suele dar problemas la creacin
de arte para juegos.
Quizs cuando sepa algunas cosas ms pueda mejorar todo y hacer que el objeto gire haciendo
clic y arrastrando con el ratn, aadir luces en tiempo real, cambiarles el color Tambin es
echarle tiempo. :P

lunes, 30 de abril de 2012
Libros: Unity 3 Game Development Hotshot
Este es el mejor libro sobre Unity de los que he podido ver hasta ahora, pero tambin el que
requiere un nivel ms avanzado, tanto, que yo seguramente tendr que volver a repasarme
muchas cosas del mismo cuando tenga algunos conocimientos ms. Es largo de leer por que tiene
mucho cdigo fuente, pero como todos los otros volumenes de este estilo podemos descargarnos
toda la parte grfica con la que seguir los ejemplos, asi que no tendremos que trabajar nada de esa
parte, salvo todo el tema de exportacin desde nuestro software 3D favorito o aplicacin de
texturas (hay un capitulo en el que podrmos programar un Shader, pero se ve muy de pasada).
Los ejemplos: Hay varios ejemplos de juegos que van desde un sencillo juego de plataformas 2D
hasta un par de demos en 3 persona, siendo uno de ellos con cmara al hombro, como por
ejemplo, lo fue Resident Evil 4.
Extras: El libro cuenta con unas cuantas pginas finales donde se nos recuerda las funciones de
Unity ms importantes y tiles que vemos durante el desarrollo de los ejemplos y nos indica como y
donde obtener ms documentacin sobre ellas. Esto es tremendamente til ya que, adems de
que hay determinadas instrucciones que practicamente usaremos siempre (como Update()),
tambin hay algunas que nos ayudaran a resolver problemas que se podran hacer de otro modo
muchisimo ms dificil y menos ptimo.
Los contras: Se nos pone constantemente los dientes largos sobre lo que podramos hacer si
pagaramos por la versin Pro de Unity. Que si estas luces son mas chulas pero no estn en la
versin gratuita, que si esta herramienta nos ayuda a optimizar mejor el rendimiento de nuestro
juego pero solo est activada en Unity Pro Claro que no es culpa del autor del libro, es que hay
que pagar por usar el motor a un nivel ms profesional.
En resumen es un tomo que requiere cierto nivel en programacin y en movernos por el entorno de
Unity para sacarle el mximo partido, aunque esta muy bien explicado paso por paso y cualquier
persona podra, siguiendo las instrucciones, desarrollar los ejemplos que se proponen (eso si, sin
comprender demasiado lo que est haciendo). As que si quereis llegar un paso ms all y
aprender sobre colisiones de objetos 3D, IA, mens de juego e su interfaz, eventos, grabar y cargar
partidas y un largo etc. que tiene que ver con el mundo del desarrollo de videojuegos, merece
totalmente la pena la inversin.
Por mi parte voy a seguir profundizando ms en este entretenido y completo motor de juegos
volviendo un poco atrs, a lo ms bsico, y ya repasar lo que no recuerde de lo ms avanzado
cuando me ponga con algn proyecto concreto en el que necesite ayuda.
domingo, 15 de abril de 2012
Terminado mi primer libro sobre Unity
Y ya voy por la pgina 100 del segundo, del que ya contar algo y ensear imgenes de los
juegos que se hacen en sus tutoriales. Pero como ya he dicho (que si, en el ttulo), acabo de
terminar: Unity 3.x Game Development by Example. En el que se van haciendo varios juegos muy
sencillos (sin mucho nivel grfico ni un gran gameplay) donde se nos ensean las bases de
Javascrip para Unity, el entorno, animacin, sonido, etc. Todo se comenta de forma muy
introductoria, pero sienta las bases para que, por nuestra cuenta, podamos seguir investigando y
aprendiendo a usar el Motor.
En este volumen el 3D esta en cierto modo ignorado. Para empezar por que los juegos que se
hacen no tienen realmente un movimiento tridimensional, si no que se nos ensea a controlar con
el ratn practicamente solo en el eje xy y, en segundo lugar, por que no se nos ensea a importar
modelos desde software 3D ni tampoco a usar dichos modelos. En el nico proyecto que tiene un
desplazamiento 3D real, se hace todo por animacin, de manera que el personaje anda en 1
persona pero en forma de video, sin que nosotros lo controlemos.
(Por cierto, que se nos proporcionan todos los grficos para hacer los ejemplos en el libro)
En fin, el caso es que despus de esta introduccin al motor Unity (no descarto escribir tutoriales
cuando lo domine medianamente), y gracias a la emocin que me produce ver conferencias sobre
la industria de los videojuegos (me refiero a IDAME), he seguido aprendiendo y haciendo
ejemplos como un loco, y ya tengo varios libros ms vistos para profundizar todo lo posible antes
de plantearme un proyecto de juego en 3D propio.
Quiero acabar juegos!! A ver si encuentro ratitos libres con los estudios
mircoles, 28 de marzo de 2012
Libros: Unity 3.x Game Development by Example:

Beginner's Guide
Para volver a tener contacto con el anteriormente abandonado por mi, motor Unity, he decidido
hacerme con un buen arsenal de cursos, tutoriales y libros, adems de unos cuantos archivos de
entornos y personajes en 3D anteriormente modelados, por si llegaba el momento de usarlos. As,
mi primera opcin ha sido el volumen titulado Unity 3.x Game Development by Example que tiene
bastante buena pinta segn lo que he podido hojear.
Para empezar, como en la mayora de textos sobre Unity, se entra en materia con el entorno: Para
que sirve cada zona de la pantalla, como crear un proyecto, guardarlo, etc. Despues, tenemos un
capitulo donde se nos intenta aconsejar que entremos en razn y no empecemos creando para
nuestro primer juego, una superproduccin de las que aparecen en las consolas de ltima
generacin y nos conformemos con algo ms pequeo que podamos terminar. De esta forma, tras
todo esto, el autor empieza a entrar en materia con algunos ejemplos sencillos en los que se tratan
tanto la parte de escribir cdigo como la grfica, pero eso si, no hace mucho uso de objetos 3D y
se dedica en prcticamente todo el libro a juegos sencillos. Poco importar objetos desde software
de modelado para mi gusto. Es por esto ltimo que he empezado a buscar ms material que me
ayude en esto, por que aunque no debe tener mucho misterio importar objetos, esta claro que
conseguir que se muevan por la pantalla para crear un juego 3D es otro cantar.
Primitivas (objetos 3D que vienen creados por defecto), luces y efectos son tratados a lo largo de
todas las pginas, as que para usuarios novatos, el aprendizaje de las bases del motor est
asegurado. Y como yo soy un poco novato
En fin, como tengo necesidad de ms informacin (mucha ms). Cuando la tenga la comentar, y
si hago avances en el manejo se iran viendo por aqu.

mircoles, 3 de noviembre de 2010
Unreal III vs Unity

ltimamente me he encontrado con un dilema. Si debo aprender a usar Unreal Devkit III o Unity.
Ambos motores tienen versiones gratuitas y se usan para crear tanto juegos Indie como
profesionales, as que son bastante accesibles y adems cuentan con abundante documentacin
en Internet e incluso libros sobre su uso. Por ejemplo sobre el motor Unreal III tenemos 3 libros
titulados Mastering Unreal Technology que hablan de una introduccin al diseo de niveles (el
primero) la creacin avanzada de niveles (el segundo) y Unreal Script (el tercero) y que se pueden
comprar, por ejemplo en Amazon. En lo que se refiere a Unity destacara otro libro llamado Unity
Game Development Essentials.
El caso es que he estado probando cosillas con ambos motores y, aunque aun me queda mucho
por aprender, me ha gustado la potencia del motor Unreal y la sencillez de Unity (que para mi
gana puntos por que tiene versin para hacer juegos de Wii y se ha usado en algn proyecto para
WiiWare).
Que no se me olvide destacar que hay una Web de Unity en espaol que adems acaba de
empezar a publicar una revista gratuita para ver o descargar en Pdf. La Web se llama UnitySpain y
la revista llamada UDev est en esa misma pgina.

Aprendiendo Videojuegos Con La Historia de Las Consolas

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Aprendiendo Videojuegos Con La Historia de Las Consolas

Загружено:

Авторское право:

Доступные форматы

Aprendiendo videojuegos con la historia de las

consolas: Atari (Parte VI)

private float timePassed;

// Tiempo pasado desde el ultimo cambio de

// Use this for initialization

martes, 23 de diciembre de 2014

Aprendiendo videojuegos con la historia de las

Component/Physics2D/RigidBody 2D (bueno, el orden da igual). Una vez aplicados al objeto

// Referencia al transform del balon

Publicado por rathsodic en 23:22 0 comentarios

mircoles, 17 de diciembre de 2014

Aprendiendo a hacer juegos con la historia de las

thisTransform.Rotate(0, 0, - horAxis * rotationSpeed * Time.deltaTime);

hasta que lo paremos. Dentro usaremos la sentencia horAxis = Input.GetAxis("Horizontal").

domingo, 14 de diciembre de 2014

Aprendiendo a hacer juegos con la historia de las

Si pulsamos en la ventana Hierarchy la tecla F2 mientras tenemos seleccionado un objeto

lunes, 24 de noviembre de 2014

Aprendiendo a hacer juegos con la historia de las

domingo, 28 de septiembre de 2014

Libros: Unity 2D Game Development

Publicado por rathsodic en 12:01 0 comentarios

martes, 16 de septiembre de 2014

Juegos 3D con grficos 2D

Publicado por rathsodic en 20:40 2 comentarios

sbado, 25 de enero de 2014

Memory G-Cards postmortem

Diseo del juego

Dnde conseguir el juego?

Hasta el prximo Post-mortem.

Proyectos: Memory GCards Android

martes, 10 de septiembre de 2013

Formacin: Inteligencia Artificial

Publicado por rathsodic en 16:17 2 comentarios

viernes, 2 de agosto de 2013

aproximado en tiempo tendra el juego si lo terminramos como es debido.

Publicado por rathsodic en 18:47 2 comentarios

martes, 16 de julio de 2013

Publicado por rathsodic en 13:25 4 comentarios

lunes, 8 de julio de 2013

Profundizando en el aprendizaje de Unity

Publicado por rathsodic en 11:38 7 comentarios

sbado, 15 de junio de 2013

Aprender Unity: Esta vez va en serio

Publicado por rathsodic en 16:05 4 comentarios

sbado, 10 de noviembre de 2012

Webs recomendadas: Eresgamer.com

Publicado por rathsodic en 17:32 2 comentarios

sbado, 26 de mayo de 2012

Unity 3.x Game Development Essentials

Publicado por rathsodic en 16:16 2 comentarios

jueves, 10 de mayo de 2012

Probando modelos 3D en un motor (Unity)

Publicado por rathsodic en 23:47 0 comentarios

lunes, 30 de abril de 2012

Libros: Unity 3 Game Development Hotshot

domingo, 15 de abril de 2012

Terminado mi primer libro sobre Unity

mircoles, 28 de marzo de 2012

Libros: Unity 3.x Game Development by Example:

Publicado por rathsodic en 23:28 0 comentarios

mircoles, 3 de noviembre de 2010

Unreal III vs Unity

Вам также может понравиться