Crea tu juego indie - Lección 02 - Introducción a la programación con Unity y JavaScript (1)

En la última lección ya vimos cómo funciona por encima el editor de Unity. En esta ocasión vamos a comenzar a crear nuestros propios componentes para que los GameObject se comporten como nosotros queramos.

Veremos una introducción a la variante de JavaScript que utiliza Unity, explicando de momento en qué consiste la programación orientada a objetos y qué son las variables.

Perdonad que sea tan tostona esta parte, ahora que aún estamos con los fundamentos y no hemos llegado a la lógica del juego. El próximo día cambiará eso, prometido. De momento, con leer esto y conocer (que no memorizar) cómo funciona, será suficiente. Siempre será posible usar estos posts como referencia ;)

Como en la primera lección, el vídeo estará complementado por una información más detallada y extensa en esta misma entrada, muy recomendada si eres nuevo/a en la programación.

(Muy recomendado verlo a pantalla completa en HD)

¿Deseas saber más?

Programación orientada a objetos

Como hemos visto en el vídeo, la programación orientada a objetos se basa en distribuir la lógica del programa entre varios objetos, instancias de clases (o estructuras), con miembros que pueden ser variables o funciones, además de otras clases, enumeraciones y otros tipos que veremos más adelante, cuando los vayamos a necesitar. Estas clases pueden estar heredando de otras clases. Cuando B hereda de A, se dice que B es subclase de A, y A es superclase de B. En el ejemplo hemos visto la declaración de la clase que hace implícitamente Unity si es necesario.

public class PlayerComponent extends MonoBehaviour {
// ...
}

La declaración consta de una parte básica:

class PlayerComponent {
// ...
}

Por una parte está la palabra clave class, que indica que lo que estamos declarando es una clase. A continuación iría el identificador de la clase.

Los identificadores tienen ciertas limitaciones:

• Sólamente pueden comenzar por una letra (minúscula o mayúscula) o un guión bajo,
• seguido de 0 o más letras, números, o guiones bajos.
• Las letras no incluyen letras con acentos o especiales (por ejemplo, á, Ó, ü o ñ no están aceptados)
• No pueden contener otros espacios, ni signos de puntuación, etc.

La palabra clave public antes de class indica que es una clase de visibilidad pública (hablaremos de la visibilidad un poco más abajo). La última parte, extends MonoBehaviour, indica que esta clase extiende (hereda de) MonoBehaviour. La sintaxis a utilizar es extends IdentificadorSuperclase. Una clase sólo puede tener una superclase, aunque puede tener varias subclases.

Las variables

Una variable no es más que un pequeño espacio de memoria asociado a un identificador. La forma más básica de declarar una variable en JavaScript es esta:

var Variable1;

La palabra clave var indica que vamos a declarar una variable, y a continuación le asociamos un identificador. Terminamos la sentencia con un punto y coma (;) JavaScript es un lenguaje débilmente tipado donde no es necesario especificar de qué tipo será la variable que estamos declarando. Esto es muy cómodo para hacer prototipos, porque a menudo cuando vamos a estar haciendo muchas pruebas y cambiando muchas cosas, tener que andar especificando un tipo diferente por cada cambio es bastante pesado. Sin embargo, es mucho más seguro especificar explícitamente un tipo, y ahorra bastantes quebraderos de cabeza cuando se pasa a fases más serias. Mi consejo es especificarlo siempre que sea posible, aunque eso será cosa de cada uno. Los puntos desde los que una variable será accesible se conocen como ámbito de la variable. Si es una variable de clase o de instancia, dependerá de la visibilidad (ver debajo). Si es una variable local definida dentro de una función u otro bloque (como veremos el próximo día), su ámbito es el bloque en el que se declara, desde el punto en el que se declara (aunque en JavaScript su ámbito es para el resto de la función, aunque hayamos salido de ese bloque).

La visibilidad

La visibilidad indica el ámbito de los miembros de una clase (o una estructura o un espacio de nombres, que no veremos aún). Existen cuatro visibilidades diferentes:

• Pública (public): Accesible desde fuera de la clase/instancia.
• Protegida (protected): Accesible desde la propia clase y sus subclases (y sus respectivas instancias, pero no entre las instancias).
• Privada (private): Accesible sólo desde la propia clase y sus instancias (pero no entre ellas).
• Interna (internal): Es un tipo especial del que no hablaremos aún.

Unity automáticamente reconoce las variables públicas de cada componente y permite manipularlas desde el inspector en el editor, aunque existen mecanismos para alterar esto.

El tipo de una variable

Cada variable tiene un tipo, aunque no se lo hayamos especificado explícitamente. Los tipos que puede tener una variable son los siguientes:

• Primitivos: tipos básicos de variables.
• int: Número entero.
• uint: Número entero no-negativo (el cero y los números naturales).
• float: Número decimal (de coma flotante).
• boolean: Valor lógico booleano (puede ser únicamente verdadero o falso).
• string: Cadena de caracteres.
• Otros tipos primitivos más específicos.
• Instancias de clases, estructuras...
• Arrays: Son secuencias consecutivas de varias variables de un mismo tipo. Por ejemplo, una secuencia fija de 10 números enteros. Hablaremos de ellos en los próximos capítulos.

Operadores básicos

Para trabajar con variables se usan fundamentalmente los siguientes operadores:

• Aritméticos: Operaciones matemáticas entre variables
• Entre dos números
• +: Suma de dos números
• -: Resta de dos números
• *: Multiplicación de dos números
• /: División de dos números
• %: Resto de la división entre dos números.
• Con un sólo número
• +: Como prefijo, es el propio número.
• -: Como prefijo, es la negación del número (como multiplicar por -1)
• Entre dos cadenas de caracteres
• +: Concatena las cadenas (una cadena resultante de poner una a continuación de la otra)
• Bit a bit: Son operadores para operaciones bit a bit entre variables enteras. De momento no entraremos con ellos.
• Asignación: Asignan un valor a una variable (el valor puede ser una expresión constante o una expresión entre variables y constantes).
• =: Asigna el valor de la derecha a la variable de la izquierda, si los tipos concuerdan o pueden convertirse a tipos compatibles.
• +=, -=, *=, /=, %=: Son abreviaturas de "operación-asignación". Por ejemplo:

  a += 2; // a = a + 2;
  b *= 5; // b = b * 5;

• Incremento/decremento de enteros:
• ++: Incrementa en uno un entero. Si se usa como prefijo (preincremento), primero incrementa su valor y devuelve el valor incrementado. Si se usa como sufijo (postincremento), devuelve el valor original y luego incrementa la variable. Por ejemplo:

  a = 5;
  b = ++a; // a = 6, b = 6
  a = 5;
  b = a++; // a = 6, b = 5

• --: Similar al incremento, pero decrementa en uno el valor.
• Comparación: dan como resultado un valor lógico en función de la relación entre los dos operandos:
• Entre dos valores cualesquiera
• ==: Igualdad. Vale "verdadero" (true) si ambos operandos son iguales, o "falso" (false) si no.
• !=: Desigualdad. Lo contrario que ==.
• Entre dos números
• <: Es verdadero si el primer operando es menor que el segundo.
• <=: Menor o igual.
• >: Mayor que.
• >=: Mayor o igual que.
• Lógicos: Operaciones entre dos valores lógicos.
• ||: "O" lógico. Es verdadero si uno de los operandos lo es. Falso si los dos operandos son falsos.
• &&: "Y" lógico. Es verdadero si los dos operandos son verdaderos. Falso si uno de los operandos lo es.
• !: "No" lógico. Se usa como prefijo. Es verdadero si el operando es falso, y es falso si el operando es verdadero. En otras palabras, niega su valor.

Descargas

Para descargar lo que llevamos de proyecto hasta ahora:

Descargar ARPG.rar (para descargar desde GDrive, ir a "Archivo -> Guardar como...")