Glosario de programacion - glantucan/puzzle_game GitHub Wiki

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

Una expresión es un conjunto de valores, variables, operadores y/o funciones que expresan otro valor, después de ser evaluada. Ejemplos: 5+4, vida - daño, dañoBase + Mathf.Range(1, 5), gameObject.GetComponent<Collider>() Las sentencias suelen estar compuestas por expresiones.

(En los lenguajes basados en clases, como C#, también se les llama métodos).

En esencia, son bloques de código a los que se les pone nombre. Este nombre nos permite ejecutar ese bloque de código desde cualquier lugar del código de la clase (también desde fuera de la misma si se ha definido como pública).

void CreateBullet() {
	GameObject bulletInstance = Object.Instantiate(bulletPrefab);
	bulletInstance.transform.position = this.transform.position;
	Mover bulletMover = bulletInstance.GetCOmponent<Mover>();
	bulletMover.release();
}

La llamada a la función se puede repetir tantas veces como se necesite. Esto hace de las funciones una de las herramientas más utilizadas para evitar repetir código.

Habiendo definido la función del ejemplo anterior podemos ejecutarla en cualquier parte de la misma clase escribiendo:

CreateBullet();

Cada vez que incluyamos esta línea de código en el programa se ejecutará el cídigo dentro del bloque de la función, creando una nueva bala.

Las funciones pueden recibir información a través de parámetros. Esto permite enviar valores y referencias a la misma en el momento de su invocación. Ejemplo:

void CreateEnemy(GameObject enemyPrefab, Vector3 position) {
	GameObject enemyInstance = Object.Instantiate(enememyPrefab);
	enemyInstance.transform.position = position;
	EnemyAI enemyBrain = enemyBrain.GetCOmponent<EnemyAI>();
	enemyBrain.searchPlayer();
}

Esta función permite crear enemigos de un tipo y en una posición concretos que serán especificados al llamar a la función:

this.CreateEnemy(bigBossPrefab, new Vector3(10F, 0F, -10F));

Los parámetros (enemyPrefab y position en el ejemplo) son variables locales de la función. A diferencia de las variables normales, a las que se les asigna valores usando el operador de asignación =, sus valores se toman de la instrucción de llamada a la función. Serán los que se incluyan entre los paréntesis y en el mismo orden en el que se especifiquen. Así, al llamar a la función de esta manera.

this.CreateEnemy(bigBossPrefab, new Vector3(10F, 0F, -10F));

es como si hubieramos hecho al mismo tiempo:

enemyPrefab = bigbossPrefab;
position = new Vector3(10F, 0F, -10F);

Para que todo funcione correctamente los tipos de los valores que se pasan a la función y los de los parámetros definidos en la declaración de la misma deben coincidir.

Las funciones con parámetros permiten hacer una función más versátil, más abstracta, porque podremos reutilizarla en más ocasiones pasándole diferentes valores para sus parámetros.

Las funciones también pueden devolver un valor. Esto es útil cuando el bloque de código de la misma calcula o produce un valor que necesitamos utilizar para otra cosa después de llamar a la función:

float CalculateDamage(DamageControl attacker, LifeManager victim) {
	float attack = (attacker.strength + attacker.currentWeapon) * attacker.accumulatedAttackBonus;
	float defense = (victim.strength + victim.armor + victim.weaponParry) *
					victim.accumulatedDefenseBonus;
	float totalDamage = attackDamage - defense;
	return totalDamage;
}

Lo que hace que la función devuelva el valor total del daño es su última instrucción que empieza con la palabra clave return. Para que no haya errores de compilación el tipo del valor devuelto debe coincider con el tipo de retorno (float en este caso) especificado delante del nombre de la función. Cuidado cualquier instrucción detras de la que contiene el return no se ejecutará. return devuelve el control al lugar desde el que se llamó a la función. Fíjate en que si una función no devuelve nada (no tieneinstrucción return)
Este tipo de funciones se suelen invocar de un modo ligeramente diferente, ya que normalmente querremos guardar el valor que devuelven en una variable o utilizarlo directamente en otro cálculo:

float damageTaken = this.CalculateDamage(enemy, this.life);
this.life.lifePoints = this.life.takenDamage - damageTaken;

(Ver explicación en Símbolo).

Palabra clave (Ver explicación en Símbolo).

(Ver explicación en Símbolo).

Son las funciones que definen los comportamientos y acciones posibles de las instancias de una clase. En C# se puede considerar sinónimo de función.

(Ver explicación en Símbolo).

(Ver Valores y referencias).

Una sentencia de un programa es una orden explícita al programa que puede estar compuesta por una o más expresiones, una definición de variable, etc. y que acaba en punto y coma.

Los símbolos son los elementos más pequeños que el compilador entiende de un lenguaje de programación y que tienen significado para él. Son el equivalente de las palabras y los signos de puntuación en los lenguajes humanos. Se clasifican en:

• Palabras clave:
  Son palabras que ya tienen significado específico dentro del lenguaje y no pueden ser utilizadas para nada más que lo predefinido (no se pueden usar como variables o nombres de función). Ejemplos: class, public, private, return, int, string, bool, ...

• Identificadores: Son palabras que inventa el programador para dar nombre a las variables, funciones o clases que crea dentro de su programa. Por ejemplo, en:

  int edad = 25;

La palabra edad es el identificador que se ha inventado para dar nombre a la variable que se utiliza para guardar la edad de un personaje. Para que un identificador sea válido no debe empezar por un número o caracter especial (con excepción del guión bajo _).

• Operadores: Tienen, como las palabras clave, un significado específico dentro del lenguaje pero además, como su nombre indica, realizan operaciones sobre uno o más valores y producen como resultado otro valor. Ejemplos: +, -, ., ...
  No tienen por qué corresponderse con una operación matemática o lógica: Por ejemplo, el . cuando se encuentra entre un identificador de objeto y otro de variable, sirve para obtener el valor de esa variable dentro de dicho objeto:

  Debug.Log(player.name);
  

• Literales: Son símbolos que sirven para crear valores al vuelo. Los números y las cadenas de texto, cuando se escriben explícitamente en un programa, son literales: Ejemplos: "Hola mundo", 5, 3.1415F, ...

• Separadores: Son caracteres especiales que sirven para separar y delimitar valores, sentencias, bloques de código, etc. dentro de un programa. Ejemplos: ;, ,, {, }, ...

Determina el tipo de valores que se pueden asignar a una variable. Aunque en C# no es necesario especificarlo en la sentencia de declaración de la variable, conviene hacerlo, porque así el compilador nos alertará cuando estemos intentando asignar un valor a un tipo de variable con el que no es compatible.

Cuando el valor de una variable es primitivo la variable contiene una copia del valor. Cuando el valor de una variable es un objeto en realidad lo que contiene la variable es una referencia a ese objeto.

Los valores se clasifican en tipos para hacer un uso eficiente de la memoria, que el compilador pueda detectar si una asignación a una variable es correcta y también que el programador pueda definir sus propias estructuras o clases de información.

Los valores en un programa pueden de los tipos predefinidos por el lenguaje, que se corresponden con los tipos simples más utilizados: números, cadenas de texto, booleanos, ... La mayoría de los valores predefinidos se pueden expresar de forma literal ("Hola mundo", 5, 3.1415F, true, ...).

El programador también puede crear sus propios tipos de valor. La forma más habitual de hacerlo es crear una clase. La clase estará compuesta de propiedades de tipos predefinidos u otros tipos creados por el programador y métodos o funciones que especifican las operaciones que se pueden realizar con los valores de este nuevo tipo.

Por otro lado los tipos de valor se clasifican en tipos valor y tipos referencia (Ver Valores y Referencias). Esta distinción es muy importante porque afecta a como se comportan al copiarlos o pasarlos como argumento de una función.

Son los tipos de valor más simples que se pueden utilizar en un programa (números, cadenas de texto, booleanos, ...) y ya están predefinidos en el lenguaje de programación. Los más comunes son:

• Números: En total, hay nueve tipos de números, pero los que vamos a utilizar son dos:

  • int:
    Puede expresar valores de los números enteros positivos, negativos y el cero.
  • float: Puede expresar valores de números decimales, positivos, negativos y el cero.

• Texto:

  • char:
    Puede expresar valores de un sólo caracter de texto. Para escribir un valor de este tipo de forma literal hay que rodearlo con comillas simples. Ejemplo: 'h'
  • string: Expresa cadenas de texto con varios caracteres. Para escribir un valor de este tipo de forma literal hay que rodearlo con dobles comillas. Ejemplo: "Hola mundo!"

• Lógica (se usan sobre todo en condicionales):

  • bool:
    Sólo puede expresar dos valores: true (verdadero) y false (falso).

Ver Símbolo

Es una pieza de información completa. En un programa se puede expresar de forma literal, a través de una variable que lo contenga, de una expresión que al computarse produzca el valor, o de una llamada a una función que lo devuelva. Los valores se clasifican en tipos.

Cuando distinguimos entre valores y referencias nos referimos a que un valor es el dato en sí que se está almacenando en la memoria y una referencia es un enlace o puntero al dato. Por defecto, hay ciertos tipos de valor que siempre serán tipo-valor, mientras que otros siempre serán tipo-referencia y cuando lo almacenemos en una variable estaremos, en realidad, guardando un enlace dicho valor.

Son de tipo-valor todos los tipos predefinidos en C# que veremos en el curso.

Son de tipo-referencia la mayoría de los objetos (siempre que sean instancias de una clase).

Los valores tipo-valor se copian al asignarlos a una variable. Por ejemplo:

int a = 5;
int b = 5;

Aunque coloquialmente decimos que a y b tienen el mismo valor, en memoria son dos valores diferentes que contienen el mismo dato, un 5. Si asignamos el valor de a a b, copiamos el valor de a en la variable b.

int a = 5;
int b = a;

Ahora existe dos copias del dato 5, la asignada a a y la asignada a b. Si modificamos el valor de b, el de a permanece inalterado:

int a = 5;
int b = a;
Debug.Log(a); // -> 5
Debug.Log(b); // -> 5

b = 10;
Debug.Log(a); // -> 5
Debug.Log(b); // -> 10

En realidad esto es lo que uno espera, pero es importante recalcarlo para compararlo con lo que ocurre con los valores tipo-referencia.

Sin embargo los valores tipo-referencia no se copian al asignarlos a una variable, se copia sólo la referencia. En C#, las instancias de cualquier clase son valores tipo-referencia. Los gameobjects en Unity son instancias de una clase. Por ejemplo:

GameObject goA = this.gameobject;
GameObject goB = this.gameobject;

Las variables goA y goB contienen una referencia al mismo gameobject. Aunque intentamos copiar goA en goB:

GameObject goA = this.gameObject;
GameObject goB = goA;

sólo existe una instancia de ese gameobject. Lo que hemos copiado es la referencia al mismo.

Esta distinción entre valor y referencia puede parecer banal, pero no lo es. En algunos casos no hay diferencia al trabajar con referencias:

GameObject goA = this.gameObject;
GameObject goB = goA;
Debug.Log(goA.name); // -> "player"
Debug.Log(goA.name); // -> "player"

Pero si intentamos cambiar nombre del gameobject almacenado en goB sin cambiar el nombre del gameobject almacenado en goAnos daremos cuenta de la diferencia:

GameObject goA = this.gameObject;
GameObject goB = goA;
Debug.Log(goA.name); // -> "player"
Debug.Log(goA.name); // -> "player"

goB.name = "Pepe";
Debug.Log(goA.name); // -> "Pepe"
Debug.Log(goA.name); // -> "Pepe"

Los dos gameobjects acaban teniendo el mismo nobre porque en realidad no hay dos gameobjects, hay dos referencias al mismo gameobject.

Esta distinción se introdujo originalmente en los lenguajes de programación para ahorrar memoria. Ciertos tipos de dato, especialmente los definidos por el programador con una clase, pueden llegar a ocupar una memoria considerable, y por eso no se copia el valor sino su referencia al valor (que internamente se representa con un número, ya que se corresponde con una dirección de memoria).

En C# todos los tipos de valor predefinidos que vamos a utilizar son tipo-valor. Sin embargo, cuando crees una clase, todos los objetos o instancias de la misma serán valores tipo-referencia. También casi todos objetos de la API de Unity son tipo-referencia. Si quisieramos realizar una copia completa del objeto, tendríamos que crear una nueva instancia y copiar una por una todas sus propiedades. De todos modos, no es habitual tener que hacer esto. Cuando lo es la API de Unity proporciona una función que permite clonar el objeto, como en el caso de GameObject.Instantiate().

Aunque no vamos a estudiar como se hace en este curso, existen formas de crear objetos tipo-valor. Por ejemplo, los Vector3 de Unity son tipo-valor, porque el tipo Vector3 se ha definido como una estructura usando struct en lugar de usando class.

Por eso los vectores sí que se pueden copiar. Y aunque no sepas como crear estructuras, conviene que te fijes en la documentación de Unity si un tipo de objeto está definido con struct para saber si se pueden copiar y como se van a comportar sus copias.

Es un contenedor de información al que el programador puede asignar valores y que el programa puede modificar a lo largo de su ejecución. Internamente este contenedor se corresponde con un espacio en la memoria del computador. Tiene un identificador o nombre que se puede utilizar para referirse a su valor actual en cualquier momento y un tipo que determina el tipo de información que puede contener.