5.2 Creando un Nuevo Script.
Vamos a crear un Script llamado “BasicOperations”, después, lo vamos a añadir como un “Componente” de nuestro objeto del juego “GameObject”, por último, vamos a quitar cualquier otro componente que sea instancia de algún Script distinto.
Ahora vamos a abrir nuestro Script en el editor de código; otra forma de abrir los archivos de código es haciéndolo desde la ventana “Inspector” (cuando existe una instancia de nuestro Script añadida como componente), solo hay que hacer clic sobre el pequeño engrane que se encuentra en la esquina superior derecha del componente y elegir “Edit Script”.
5.3 Adiciones y Sustracciones.
A continuación, comenzaremos a realizar operaciones matemáticas sencillas usando Variables y Constantes. El primer paso es tener nuestro Script “BasicOperations” abierto en el editor de código.
Para realizar las Operaciones “Adición” y “Sustracción”, además de las Variables, usamos los Operadores Aritméticos (los símbolos que definen la acción a llevar a cabo):
-
Para la Adición: “ + ” (símbolo de “más” o de “positivo”)
-
Para la Sustracción: “ – “ (símbolo de “menos” o de “negativo”)
Operación "Adición".
Vamos a dar de alta los siguientes Miembros de nuestra Clase (Variables y Constantes):
public int primerValor; public const int segundoValor = 10; int resultadoOperaciones;
Nota: Cuando damos de alta una Variable, podemos asignarle un valor o no (en este caso, las variables primerValor y resultadoOperaciones fueron dadas de alta sin un valor en específico; al ejecutarse el código, estas variables iniciarán con el valor de “cero”, y este valor se mantendrá hasta que exista alguna línea de código que las modifique). En el caso de las Constantes, siempre deben darse de alta con valor asignado, de lo contrario se generará un error (ver el siguiente ejemplo, donde se da de alta la Constante “segundoValor” sin asignarle un valor).
Ahora, vamos a escribir lo siguiente para que nuestro método “Start” se vea así:
void Start () {
resultadoOperaciones = primerValor + segundoValor;
Debug.Log("Resultado de la Adición = " + resultadoOperaciones);
}
Guardamos nuestro código y cambiamos a la Interfaz de Edición de Unity.
En Unity, si hacemos clic sobre “GameObject” (dentro de la ventana “Hierarchy”) y vemos sus Componentes (dentro de la ventana “Inspector”), nos aparecerá lo siguiente:
Podemos ver, que en el componente “Basic Operations” (que es la Instancia de nuestra Clase “BasicOperations”) muestra un campo llamado “Primer Valor”. Este campo es la Variable “primerValor” que dimos de alta dentro de nuestro Script; y se hace visible dentro de la Interfaz de Edición de Unity por tres razones (que siempre se deben cumplir juntas): es una Variable, se dio de alta con el Modificador de Acceso “Public” y la Clase que contiene a esta variable pertenece a “MonoBehaviour”.
Nota: La Constante “segundoValor” aunque también se dio de alta con el Modificador de Acceso “Public”, no se muestra en la Interfaz de Edición de Unity por ser una Constante (y no una Variable).
El que podamos ver nuestra Variable en la Interfaz de Edición de Unity es algo muy útil para nosotros; ya que esto significa que podemos modificar su valor desde este entorno sin tener que abrir el editor de código.
Antes de realizar algún cambio, vamos a ejecutar nuestra escena. La Consola nos mostrará lo siguiente:
Se indica un resultado igual a “diez” (que es el valor de nuestra Constante “segundoValor”) porque nuestra Variable “primerValor” tiene un valor de “cero”.
Detenemos nuestra escena.
Ahora sí, vamos a cambiar el valor para nuestra Variable “primerValor” (de “0” por “40”):
Al volver a ejecutar nuestra escena, vemos que la Consola nos muestra:
La Operación “Adición” se llevo a cabo correctamente (40 + 10 = 50).
Operación "Sustracción".
Después de detener nuestra escena, abrimos el editor de código y hacemos una modificación para que ahora se realice una “Sustracción” (primerValor - segundoValor):
void Start () {
resultadoOperaciones = primerValor - segundoValor;
Debug.Log("Resultado de la Sustracción = " + resultadoOperaciones);
}
Guardamos nuestro código y cambiamos a la Interfaz de Edición de Unity.
Ya en Unity, ejecutamos nuevamente nuestra escena (sin realizar otros cambios). La Consola de Unity nos mostrará:
Podemos ver que la “Sustracción” se llevó a cabo correctamente (40 – 10 = 30).
Nota: Los valores asignados a Variables tipo “Public” dentro de la Interfaz de Edición de Unity, sobrescribirán a aquellos que se encuentren dentro del editor de código (aunque la Variable sea dada de alta con un valor en específico dentro del editor de código, si le cambiamos dicho valor dentro de la Interfaz de Edición de Unity, este nuevo valor será el utilizado al ejecutarse el código).
Operaciones con Datos Tipo "String".
Ahora vamos a modificar un poco a los Miembros de nuestra Clase, dándolos de alta con las siguientes características:
public string primerValor; public string segundoValor; string resultadoOperaciones;
Y nuestro método “Start” debe quedar:
void Start () {
resultadoOperaciones = primerValor + segundoValor;
Debug.Log("Resultado de la Adición = "+resultadoOperaciones);
}
Guardamos nuestro código y cambiamos a Unity.
Ahora los componentes de “GameObject” se verán así:
En el campo “Primer Valor” escribiremos “Cadena “ (con un espacio al final).
En el campo “Segundo Valor” escribiremos “de Caracteres“.
Al ejecutar nuestra escena, la Consola nos mostrará:
Podemos ver que la “Adición” de Variables tipo “String” se realizó correctamente.
Nota: En el caso de la “Sustracción”, no se puede realizar con Variables tipo “String” (no como lo hicimos con la “Adición”).
5.4 Multiplicaciones y Divisiones.
Para realizar las Operaciones “Multiplicación” y “División”, además de las Variables, usamos los Operadores Aritméticos (los símbolos que definen la acción a llevar a cabo):
-
Para la Multiplicación: “ * ” (símbolo “asterisco”)
-
Para la División: “ / “ (símbolo “diagonal” o “barra”)
Para ver como se realizan estas Operaciones, vamos a hacer lo siguiente:
Operación "Multiplicación".
Es necesario modificar nuevamente a los Miembros de nuestra Clase:
public float primerValor; public int segundoValor; int resultadoOperaciones;
Lo que queremos hacer es, Multiplicar las Variables “primerValor” y “segundoValor”, pero como se puede ver, estas dos Variables están definidas para trabajar con Tipos de Datos distintos (la primera es tipo “float” y la segunda tipo “int”). Además, el resultado de esta operación debe ser almacenado en una Variable tipo “int” (“resultadoOperaciones”). Si escribimos la operación tal cual, tendríamos el siguiente mensaje de error:
Este tipo de mensaje se muestra porque “no podemos usar una Variable tipo “float” en una operación donde el resultado que se espera es tipo “int”.
Para solucionar estas situaciones, es necesario que todos los términos usados en nuestras operaciones sean del mismo tipo. Por ello, dentro de nuestro método “Start” escribiremos:
void Start () {
resultadoOperaciones = (int)primerValor * segundoValor;
Debug.Log("Resultado de la Multiplicación = " + resultadoOperaciones);
}
Al escribir “(int)primerValor” estamos indicando que, aunque esta Variable sea tipo “float”, para esta operación se debe considerar como “int”.
Guardamos nuestro código, cambiamos a Unity, y en la ventana “Inspector” con “GameObject” seleccionado escribimos:
- “5.5” para “Primer Valor”
- “10” para “Segundo Valor”
Ejecutamos la escena, y la Consola de Unity nos mostrará:
El resultado obtenido es “50”, pero “55” es el valor que esperábamos; esto sucede porque al usar “(int)primerValor”, no se está tomando en cuenta al componente “decimal” del valor de nuestra Variable (al ser “5.5”, solo se toma en cuenta al valor entero “5” y se descarta el componente decimal “.5”); ya que es una operación de valores tipo “int”, esta se realiza como “5 * 10 = 50”.
Si cambiamos los valores de la siguiente manera:
- “12” para “Primer Valor”
- “5” para “Segundo Valor”
Y ejecutamos nuestra escena:
Podemos ver que la Operación “Multiplicación” se realizó correctamente (12 * 5 = 60)
Si modificamos a los Miembros de nuestra Clase:
public float primerValor; public int segundoValor; float resultadoOperaciones;
Y también modificamos el contenido del método “Start”:
void Start () {
resultadoOperaciones = primerValor * segundoValor;
Debug.Log("Resultado de la Multiplicación = " + resultadoOperaciones);
}
Podemos ver que no se nos manda mensaje de error alguno (esto es porque, un valor tipo “int” si puede ser parte de una operación con resultado tipo “float”).
Al guardar nuestro código y después ejecutar nuestra escena, veremos:
La Operación “Multiplicación” se realizó correctamente (12 * 5 = 60)
Operación "División".
Ahora seguiremos con la Operación “División”, para esto, vamos a modificar a los Miembros de nuestra Clase como sigue:
public int primerValor; public int segundoValor; float resultadoOperaciones;
Y también modificamos el contenido del método “Start”:
void Start () {
resultadoOperaciones = 10.5f / 2;
Debug.Log("Resultado de la División = " + resultadoOperaciones);
}
Como podemos observar, en este caso no estamos involucrando a las variables “primerValor” y “segundoValor” para realizar la Operación “División”, estamos ocupando solo valores numéricos; cabe destacar que, como el resultado de esta Operación es almacenado en la Variable “resultadoOperación” (tipo “float”), los valores numéricos con “decimales” deben incluir el sufijo “f” para ser tomados como tipo “float” (así “10.5f” es reconocido como “float”), de lo contrario se tomaría como otro Tipo de Dato que no es compatible con la Variable “resultadoOperación” (con los valores numéricos “enteros” no hay problema alguno, estos siempre son reconocidos como “int” y no hay necesidad de modificación alguna).
Al guardar nuestro código y después ejecutar nuestra escena, veremos:
La Operación “División” se realizó correctamente (10.5 / 2 = 5.25)
Volvamos a modificar a los Miembros de nuestra Clase como sigue:
public int primerValor; public int segundoValor; int resultadoOperaciones;
Y también modificamos el contenido del método “Start”:
void Start () {
resultadoOperaciones = primerValor / segundoValor;
Debug.Log("Resultado de la División = " + resultadoOperaciones);
}
Guardamos nuestro código, cambiamos a Unity, y en la ventana “Inspector” con “GameObject” seleccionado escribimos:
- “70” para “Primer Valor”
- “2” para “Segundo Valor”
Y ejecutamos nuestra escena:
La Operación “División” se realizó correctamente (70 / 2 = 35).
Operación "Módulo".
Por último, vamos a ver la Operación “Módulo”. Esta se define como la obtención del “Residuo” de una “División”.
Su Operador Aritmético es “%” (símbolo “porcentaje”).
Su aplicación es muy amplia dentro de la programación. El ejemplo más común de su utilidad es “ayudar a reconocer si un número es par o impar”. Sabemos que un número se considera “par” si es divisible por 2 y no genera residuo (en otras palabras, una división con un residuo igual a cero).
Para llevar a cabo este ejemplo, realizaremos la Operación “Módulo” de la siguiente forma:
Modifiquemos a los Miembros de nuestra Clase como sigue:
public int primerValor; public const int segundoValor = 2; int resultadoOperaciones;
Y también modificamos el contenido del método “Start”:
void Start () {
resultadoOperaciones = primerValor % segundoValor;
Debug.Log(“El Módulo de la División = “ + resultadoOperaciones);
}
Guardamos nuestro código, cambiamos a Unity, y en la ventana “Inspector” con “GameObject” seleccionado escribimos:
- “10” para “Primer Valor”
Y ejecutamos nuestra escena.
La Operación “Módulo” se llevó a cabo correctamente (10 / 2 = 5 y no hay residuo). Podemos decir que “10” es un número “par”.
Si intentamos con otro número:
- “15” para “Primer Valor”
Ejecutamos nuestra escena.
La Operación “Módulo” se llevó a cabo correctamente (15 / 2 = 7 y hay residuo = 1). Podemos decir que “15” es un número “impar”.
Nota: Más adelante, en los próximos tutoriales, veremos más ejemplos con los Operadores Aritméticos antes mencionados e introduciremos otros nuevos.
Si quieres conocer más sobre las Operaciones y los Operadores Aritméticos que se pueden utilizar, puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/language-reference/operators/#conditional-operator .