All content in this course uses:

Crea un script personalizado de movimiento para que John Lemon se desplace y gire usando el sistema de física de Unity.

El personaje del jugador: Parte 2

 Ahora que has pasado tiempo desarrollando el personaje del jugador para tu juego, estás listo para crear un script personalizado para controlar sus movimientos.

explorar el script por defecto que se produce;

construir un vector el mismo que puede usarse para cambiar la posición del personaje;

aplicar movimiento y rotación horizontal y vertical a tu personaje;

verificar que tus cambios trabajen con el sistema de física de Unity.

Cuando hayas terminado, John Lemon estará listo para caminar sigilosamente a través de una casa embrujada.


En el tutorial previo comenzaste a trabajar en el Prefab JohnLemon añadiendo un sistema para animarlo y componentes para hacerlo trabajar con el sistema de física. ¡Ahora vas a crear un componente personalizado: tu primer 

Un script es un documento de texto que contiene una serie de instrucciones para la computadora. Comúnmente a estas instrucciones se les llama código. Las instrucciones están escritas de tal manera que la computadora pueda entenderlas, en este caso usando el lenguaje de programación llamado 

C# define la manera en la que las instrucciones están escritas y algunas de las palabras que se usan. Afortunadamente, las palabras que se usan a menudo tienen el mismo significado en C# del que tienen en inglés. Por ejemplo, la primera palabra con la que nos toparemos en C# es «

» (usando)—esto quiere decir que el script está escrito usando código de algún otro lugar. Otro ejemplo es «

» (público), lo cual significa que cualquier cosa puede acceder a algo. Hay demasiados ejemplos de analizar, pero en estos tutoriales explorarás cada uno de ellos cuando se presenten.

Todos los scripts que escribirás para este proyecto tomarán la forma de 

 (Comportamientos únicos). MonoBehaviours son tipos especiales de 

 que pueden ser anexados a GameObjects, tal como se puede hacer con los componentes. Esto se debe a que son un tipo específico de componente que tú mismo puedes escribir.

Los scripts comparten algunas similitudes con los Prefabs (Prefabricados):

Un script se crea como un Asset (recurso), igual como se hace con un Prefab.

Añadir un script a un GameObject como un componente es realmente una ejemplificación del script, al igual que el añadir un Prefab a una escena es una ejemplificación de ese Prefab. 

Sin embargo, los scripts son diferentes en muchos aspectos ¡Vamos a entrar en materia para aprender más sobre esto!

Continuación del personaje del jugador

Primero, crea tu nuevo script como un Asset (Recurso):

) en la ventana Project (Proyecto). Haz clic en la carpeta y escoge 

en C#). Ponle el nombre «PlayerMovement» a tu script. 

Ojo: Los scripts que se van a usar como un componente necesitan que su 

 en el mismo script. Cuando Unity crea un archivo 

, le da el nombre de una clase que es igual al primer nombre que se le dio al Asset. Aun así, cuando se cambia el nombre del Asset, el nombre de la clase no cambia.

2. Selecciona tu scrip y mira la ventana Inspector. Deberías ver el siguiente código:

». Esto es lo que define el nombre de la clase. Si tu 

 Asset y luego crea uno nuevo llamado PlayerMovement. 

 Asset, ábrelo para editarlo. Puedes hacer doble clic en el Asset o hacer clic en el botón «Open...» en la ventana Inspector. 

s no se hace dentro de Unity —en su lugar los 

s se abren en otro programa llamado Visual Studio. Una vez que esté abierto podrás editarlo.

 por defecto que puedes ver en Visual Studio ahora. 

 Las tres primeras líneas de código son:


 (directrices de uso). Te permiten usar código implementado en otro lado dentro de este archivo 

. Por ejemplo, la palabra «MonoBehaviour» en la línea siguiente no se podría usar si no tuvieras «using UnityEngine» aquí. En la mayoría de los casos, las directrices de uso que Unity incluye por defecto son suficientes; por ende, no necesitas preocuparte mucho acerca de ellas. 

. Las clases son como planes para ejemplificaciones que se llaman Objetos u 

. Cuando una clase es ejemplificada (por ejemplo, al anexar un 

 como un componente a un GameObjet), esa ejemplificación se llama un 

. Los objetos son los cimientos del código ¡y existen a través de todo el trabajo que ya has hecho! 

Las clases que ya sabes y con las que estás familiarizado incluyen Animator, Rigidbody, GameObject y Transform. Ya están en tu código. Otra manera en la que podemos pensar sobre las clases es que son fábricas en las que se toma una materia prima, se hace algo con ella y que luego produce un resultado. Regresaremos a la analogía sobre las fábricas con otros elementos de código.

La línea siguiente es simplemente una llave abierta: { 

En esta serie de tutoriales las llamaremos 

. Las llaves son un elemento esencial del lenguaje C# porque definen 

. Los bloques de código son líneas de código que existen entre una llave de apertura y una de cierre. Las llaves siempre deben estar en pares. 

Para la declaración del bloque de código, la llave de cierre está al fondo, pero también hay dos bloques de código más dentro de la declaración. Los dos bloques de código que están contenidos dentro de la clase están sangrados. La sangría no es algo técnicamente necesario, pero es muy útil para definir dónde el código empieza y dónde termina.

Cualquier texto que esté precedido de una barra doble, como esta, se llama un comentario. Un comentario es cualquier cosa que quieras que sea ignorada completamente por la computadora. En la mayoría de los casos funcionan como una especie de etiqueta para explicar algo sobre el código que los rodea. En este caso, el comentario da una explicación breve de lo que está declarado debajo suyo.

 Después del comentario está el comienzo de la primera declaración de método:

Vamos a regresar a la analogía de la fábrica. Si una clase es una fábrica; entonces, un método es una máquina dentro de esa fábrica. Los métodos pueden asimilar datos, ejecutar una operación y luego emitir (o regresar) datos. 

Todas las declaraciones de métodos tienen el mismo formato:

. Esto es el tipo de datos que se va a emitir una vez que el método acabe. En este ejemplo el tipo de retorno es 

. Esta es una palabra especial de C# que significa «nada»—el método no retorna nada, literalmente. 

Después del nombre hay un par de paréntesis. En esta serie de tutoriales los llamaremos paréntesis. Entre los paréntesis, los métodos tienen una oportunidad de declarar qué tipo de datos quieren asimilar. Estos trozos de datos se llaman 

. Ya que no hay nada dentro de los paréntesis, no hay ningún parámetro declarado. 


Estos tres elementos (el tipo de retorno, el nombre y los parámetros) forman la 

 de un método. En la mayoría de los casos, un método puede tener cualquier firma que quieras. Sin embargo, las clases MonoBehavior pueden usar algunos métodos especiales los que necesitan tener firmas específicas. Estos métodos especiales no necesitan invocarse desde tu código. En su lugar Unity los invoca en momentos específicos. El método Start es un ejemplo de esos métodos especiales. Se invoca tan pronto como el GameObject en el que está comienza, lo cual es usualmente tan pronto como empieza la Scene. Esto lo hace la opción ideal para hacer cosas que no quieras repetir, como la configuración.

 Después de la firma del método Start hay un bloque de código. Esto define todo el código que se ejecuta cuando se invoca el método. El invocar un método es cómo se usa el método (harás esto más adelante). Para regresar a la analogía de la fábrica: la declaración del método es cómo funciona la máquina en la fábrica e invocar el método es como realmente se usa la máquina. 

A la firma de declaración de método seguida del bloque de código se los conoce juntos como una 

. Los términos «declaración de método» y «definición de método» se intercambian mucho cuando se habla de C# porque ocurren al mismo tiempo. La diferencia realmente solo importa en otros lenguajes (tal como C++). 

 Ahora es un momento oportuno para hablar sobre el orden en el que se escriben las cosas en una clase. Siguiendo con la analogía sobre las fábricas y las máquinas, no importa dónde estén las máquinas dentro de tu fábrica, pero el orden en el cual las máquinas ejecutan sus operaciones en muy importante. 

En C# no importa en qué order los métodos se declaran en una clase, pero el orden en el que los métodos se ejecutan sus operaciones importa mucho. 

 son otro comentario y otra definición de método. 

es otro método especial para MonoBehaviors. Se invoca en cada marco, antes de algo sea reproducido en la pantalla.

Ahora que tienes un entendimiento básico de algunas de las partes del 

¿Cómo puedes crear tu primer script (PlayerMovement)?


 PlayerMovement necesita tomar el ingreso o las entradas que hace el usuario y traducirlo al movimiento del personaje.

Lo primero que necesitas hacer es obtener algunos datos del sistema de ingresos de Unity (Unity's input system). El 

 necesita verificar lo que ocurren con los ingresos todo el tiempo y desde que Update se invoca en cada marco, tiene sentido verificar los ingresos allí. Pero ¿qué es lo que específicamente necesita verificar? 

Tiene sentido mover al personaje usando las 

 necesita verificar los valores de esas teclas específicas en el teclado. Podría verificar si alguna de esas teclas está siendo pulsada individualmente o no y decidir lo que el personaje debería hacer (o no), pero hay una alternativa que lo hará un poco más fácil. 

 (input manager) que define varios botones y ejes que pueden encontrarse a través de su nombre. Por ejemplo, tiene un eje llamado 

, el cual es representado por las teclas A y D y las flechas izquierda y derecha. Entonces, al verificar eso la computadora del jugador podría decidir si el personaje se mueve hacia la izquierda o la derecha.

Escribe el código para crear tus variables

¡Vamos a empezar! Añade la línea siguiente dentro de los corchetes del método Update:

Si las clases son fábricas y los métodos son máquinas en esas fábricas, las 

 son cajas que contienen las cosas en esas fábricas. Es decir, las variables son una manera de guardar datos. Los datos que necesitas guardar es el valor del ingreso del eje horizontal. En Unity los ejes de ingreso regresan un número entre -1 y 1 —este tipo de dato se llama 

 o float. Un dato de punto flotante representa un número con decimales.

Hay algunas partes importantes sobre la sintaxis o estructura de esta línea de código:

 significa que se debe asignar lo que sea que esté a la derecha (el resultado de un método) a la variable a la izquierda (una variable nueva de tipo float). 

 entre Input y GetAxis le permite a la computadora acceder algo dentro del objeto anterior (GetAxis es un método dentro de Input; por lo tanto, para ir de Input a GetAxis se usa un punto). 

El código de C# está constituido de cosas llamadas instrucciones. Cada instrucción contiene una o más instrucciones para la computadora y pueden considerarse oraciones. Los dos puntos marcan el final de la instrucción y funciona como un punto al final de una oración.

¿Cómo podemos crear variables para los ejes horizontal y vertical?

Vamos a explorar lo que hace tu código más detalladamente:

Tienes la clase Input y estás navegando a través de la clase para encontrar el método que se llama GetAxis. Entonces estás invocando ese método al poner paréntesis tras su nombre. No obstante; al contrario de Start y Update, GetAxis tiene un 

 —un dato que necesita para ejecutar su tarea. Específicamente, GetAxis necesita el nombre del axis para el cual está tratando de encontrar un valor. Estás tratando de encontrar el valor del eje horizontal aquí; por lo tanto, se lo has dado como un parámetro. 

El tipo de dato para este tipo de información se llama una 

. Esto se refiere a una cadena de caracteres, por ejemplo, una palabra o una oración. Al poner marcas de discurso alrededor de la palabra Horizontal, le estás diciendo a la computadora que debe tratarla como una cadena. 

Una vez que la computadora ha obtenido los valores del eje necesitará guardarlos en algún lugar. A la izquierda de la invocación del método has introducido una nueva variable llamada horizontal y la has configurado a que sea igual al valor que se encuentra de GetAxis.

Luego, añade otra línea de código para encontrar el valor del eje llamado 

Ahora tienes los valores para los ejes horizontal y vertical. El siguiente paso es combinarlos dentro de un 

, de esa manera pueden usarse para cambiar posición.

¿Cómo creaste esa variable?

En Unity, el espacio en 3D se representa con tres coordenadas las cuales hacen un vector. El tipo de dato que representa un vector en Unity se llama 

. Esto es lo que representa la posición de un GameObject y necesitarás hacer un Vector3 que representa ese cambio. El movimiento que el usuario representa es fundamental para esta clase y lo podrías necesitar para otras cosas también.

Con esto en mente, es importante considerar el 

El ámbito de la variable es el área de código donde puede utilizarse. Usualmente esto es tan simple como el bloque de código en el cual está declarado. Por ejemplo, ambas variables de punto flotante (floats) que acabas de declarar (horizontal y vertical) están en el ámbito para el método Update entero porque ese es el bloque de código donde fueron declaradas. Se dice que son 

Si quieres usar una variable en muchos métodos diferentes, puedes crear variables fuera del ámbito del método. En cambio, estas son locales a la 

Añade la siguiente línea sobre las definiciones de los métodos:

La nueva línea de código está instruyendo a la computadora que cree una variable tipo Vector3 llamada 

 que puedes usar donde quieras en la clase PlayerMovement (Movimiento del jugador).

¿Pero qué significa esa _m al principio del nombre? Esto es parte de algo que se llama una 

. Las convenciones de nomenclatura se usan para identificar un objeto o la clase de un objeto. En este proyecto usarás las convenciones internas de Unity. Todas las variables comienzan con una letra minúscula pero las palabras que le siguen comienzan con una mayúscula —esto se llama 

, las cuales comienza con el prefijo m_ y todas las palabras comienzan con una letra mayúscula. Esto se llama 

. Las variables de instancia o miembro de dato son aquellas que pertenecen a una clase antes que a un método específico. La parte m_ de una variable privada de instancia viene de que son variables «miembro».

¿Cómo podemos hacer un vector?

Ya que tienes una variable para guardar el movimiento de tu personaje, necesitas configurar un valor para ella. Desde que esto puede cambiar en cada marco, necesitas configurarla cada marco —deberías hacerlo en el método Update.

En el método Update, después de que las variables vertical y horizontal hayan sido creadas, añade la línea siguiente:

Los vectores en un espacio de 3D tienen tres valores —el método 

 (configurar) le asigna un valor a cada uno. Tiene tres parámetros, uno para cada coordenada del vector. El vector de movimiento ahora tiene un valor del ingreso horizontal en el eje horizontal, 0 en el eje y el ingreso verticales en el eje z. También hay una f después del 0 en el segundo parámetro, la cual le dice al computador que trate este número como un dato de punto flotante o 

Ahora necesitas resolver un pequeño problema. El vector de movimiento está compuesto de dos números que pueden tener un valor máximo igual a 1. Si el valor de ambos es 1, la longitud del vector, (que también se conoce como su magnitud) será más de 1. Esta es la relación entre los lados de un triángulo que se describe en el teorema de Pitágoras.

Esto significa que tu personaje se moverá más rápido diagonalmente que si lo hace a lo largo de un solo eje. Para asegurarte de que esto no ocurra, necesitas asegurarte de que el vector de movimiento siempre tenga la misma magnitud. Puedes hacer esto al 

. Normalizar un vector significa mantener la misma dirección del vector, pero cambiar su magnitud a 1.

 siguiente debajo de la línea que escribiste anteriormente para llamar a un método en el mismo vector:

 Este ejemplo incluye un espacio entre obtener las entradas y configurar el vector de movimiento. Esto no es importante, solo hace que se vea más ordenado 

Configura los valores de tu variable

Ya que has creado un vector de movimiento, hay otras tareas que necesitan hacerse en cada marco. Necesitas decirle a la computadora que haga lo siguiente:

Dile al componente Animator si el personaje está caminando o no.

Obtén una rotación para el personaje desde una entrada del jugador (de manera similar a cómo obtuviste su movimiento).

Aplica movimiento y rotación a tu personaje

Vamos a comenzar con el componente Animator.

¿Cómo se identifica si hay entradas del teclado del jugador o no?

Si hay alguna entrada del jugador en el teclado entonces tu personaje debería caminar y si no hay entonces debería quedarse quieto.

 Para comenzar, necesitas escribir una línea de código que determine si hay entradas horizontales o no. Añade el siguiente cóidgo después de la línea que normaliza el movimiento del vector:

» (la que puede ser true o false) y le estás dando el nombre de ithasHorizontalInput (Tiene entrada horizontal). Luego estás configurándola a que sea igual al valor que regresa un método. Este método se llama Approximately (aproximadamente) y es de la clase Mathf. Toma dos parámetros de tipo punto flotante y regresa una variable tipo «bool» —verdadero si los dos puntos flotantes son aproximadamente iguales y falso si no lo son. Por lo tanto; en este escenario, el método regresará el valor true si la variable horizontal es aproximadamente cero. 

¡Pero espera! Hay otro carácter en esta línea con el que no te has topado antes: el signo de exclamación de cierre en frente de la invocación del método. Este es el 

 e invierte una variable tipo bool poniendo true a false (verdadero a falso) y false a true (falso a verdadero). Esto significa que hasHorizontalInput se configura a true (verdadero) cuando la variable horizontal no es aproximadamente igual a 0. Es decir, hasHorizontalInput es verdadero cuando horizontal no es cero.

 Pero no solo te debe importar el eje horizontal. Añade una línea similar para el eje vertical:

This line is doing exactly the same thing, but for the vertical axis.

Esta línea está haciendo exactamente lo mismo, pero para el eje vertical.

 Ahora sabes que cuando obtienes entradas en los ejes, necesitas combinarlos en una sola variable tipo «bool». Añade la siguiente línea de código:

Esta línea crea otra variable tipo bool llamada isWalking, la cual está configurada a los valores de hasHorizontalInput o hasVerticalInput. Las dos líneas verticales son los 

. Esto compara la variable bool en cada lado. Si uno de ellos, o si ambos son verdaderos; entonces, es igual a true. De otra manera es igual a false. Eso significa que si hasHorizontalInput o hasVerticalInput son verdaderos; entonces, isWalking es true y si no lo son, es false o falso.

¿Cómo se configura el componente Animator (animador)?

Luego, necesitas decirle al componente Animator si el personaje debería estar caminando o no usando la variable tipo «bool» que acabas de crear. Para hacerlo, necesitas acceder al componente Animator. 

Pero, espera un momento, ¿por qué necesitas hacer algo especial para acceder al componente Animator cuando no necesitaste hacerlo para invocar métodos en Input o Mathf? Esto se debe a que los métodos Input y Mathf son estáticos. 

 son métodos que se invocan en el tipo de una clase en vez de uno de los casos de esa clase. No hay necesidad de tener un solo caso de la clase Input para determinar el valor de los ejes porque Input es un concepto más global. Por definición, los métodos que obtienen esos valores son estáticos. De la misma manera, la clase Mathf está llena de métodos auxiliares (métodos que ayudan a otro método a ejecutar su tarea) los que no involucran ningún dato específico para un caso específico de Mathf; por lo tanto, esos métodos también son estáticos. 

Sin embargo, toma en consideración tu variable m_Movement. Tuviste que configurar valores específicos para ese caso en particular de Vector3; por lo tanto, esos métodos no son estáticos. The important thing to remember is that static methods are called using a type name and non-static methods (or 'instance' methods) are called using an instance name.

¿Cómo se crea una variable para guardar una referencia hacia el componente Animator (Animador)?

Antes de que puedas acceder al componente 

 necesitas configurar una referencia que apunte hacia ello y esto se obtiene a través del método 

(Obtener componente). Esta referencia se usará a través de la clase y no solo en un solo método. Tiene sentido mantenerlo como una variable de instancia (igual que el vector de movimiento); de tal manera que su ámbito sea local a la clase.

En la parte superior de la clase, encima de la declaración del vector de movimiento, pero debajo de la declaración de la clase, añade la siguiente línea 

Ojo: En este ejemplo los comentarios encima de los métodos Start y Update no han sido removidos. Si quieres podrías hacerlo, pero no es necesario —los comentarios no afectan el código en manera alguna.

9. ¿Cómo se hace una referencia que apunte  hacia el componente Animator?

Has creado una variable para guardar una referencia al componente 

, pero hasta ahora no has configurado algún valor para esta variable y está vacía. Cuando una variable está vacía de esta manera en C#, se dice que es 

 (nula). Cuando pueda haber una referencia, pero no hay una, la referencia es 

No quieres que haya una referencia nula aquí y por eso necesitas configurar la referencia de manera adecuada. También necesitas poder acceder al componente 

en cualquier método; por lo tanto, sería bueno que configures la referencia tan pronto como sea posible.

Uno de los métodos que se invocan primero en un MonoBehaviour es el método Start que exploraste anteriormente en este tutorial; de tal manera, tiene mucho sentido que configures la referencia allí. Agrega la línea siguiente al método Start: 

  Esta línea de código usa sintaxis que ya hemos visto y otra que es nueva:

La variable a la que estás asignándole valor está a la izquierda.

El nombre de un método está a la derecha (pero no tiene nada escrito antes).

Hay signos de mayor que y menor que alrededor del Animator, antes de los paréntesis que has visto antes.

¿Cuál es el significado de esta referencia?

Primero, ¿por qué no hay una clase antes de GetComponent (Obtener componente)? Cuando añadiste esto antes, estabas accediendo métodos en otros objetos (por ejemplo, el método Normalize en el vector de movimiento). Sin embargo, GetComponent es algo a lo que ya tienes acceso, es parte del MonoBehaviour y ya que tu clase es un MonoBehaviour, ya tienes acceso a ella.

Luego, los símbolos mayor que y menor que. Estos han sido añadidos porque el método GetComponent es 

. Un método genérico es aquel que tiene dos configuraciones diferentes de parámetros: 

. Los parámetros enlistados entre los símbolos de mayor y menor que son los parámetros de tipo.

En este escenario, GetComponent necesita saber qué 

 de componente buscas. Si buscas un componente Animator, el tipo de parámetro es Animator. La línea de código dice, «obtén una referencia que apunte hacia el componente de tipo “Animator” y asígnaselo a la variable llamad m_Animator».

¿Cómo se configura el isWalking parámetro de tipo Animator?

Ahora que tienes una referencia que apunta hacia el componente Animator, puedes usarla para configurar el IsWalking parámetro de tipo Animator que creaste en el tutorial anterior.

Añade la línea de código siguiente debajo de la creación de la variable isWalking en el método Update:

 usando la referencia al componente Animator que acabas de configurar. El primer parámetro es el nombre del parámetro Animator al que quieres asignarle un valor y el segundo es el valor que les quieres asignar. Es importante que prestes atención a la ortografía y el uso de mayúsculas y que los copies exactamente; de otra manera, el método no sabrá a cuál de los parámetros Animator debe asignarle un valor.

¡Esto es todo! Has configurado el valor del parámetro Animator.

¿Cómo se configura la referencia que apunta hacia el componente Animator?

Vamos a echarle un vistazo a la tarea que necesita completarse en cada marco: la creación de una rotación para tu personaje.

En este juego el personaje debería poder caminar solo hacia el frente y necesita mirar hacia la misma dirección en la que se mueve. Sin embargo, si John Lemon se voltea rápidamente hacia la dirección que quieres se verá un poco raro; por ende, necesitas que sea un poco más despacio. Pero ¿cuánto deberías retardarlo?

Una manera más fácil de plantear esta cuestión es considerar la velocidad en la que el personaje debe voltearse.

Para ver esta velocidad, necesitas crear una nueva variable.

Añade la siguiente línea a la parte superior de la clase, encima de la variable de instancia:

 antes de la declaración de la variable. En Unity, las variables de instancia públicas aparecen en la ventana Inspector y pueden ser modificadas.

También has usado la caja de camello (en vez de PascalCase, con su prefijo m_). Esto se de be a que la variable es pública y las convenciones de nomenclatura de Unity usan este formato para las variables de instancia públicas. Las convenciones de nomenclatura pueden ser muy útiles, pero no hay una razón técnica por la que las adoptamos.

  ¿Cómo puedes calcular el forward vector (vector delantero) de tu personaje?

Recuerda que necesitas que el personaje mire hacia la dirección de su movimiento. Todos los componentes Transform tienen un vector delantero y un buen paso intermedio sería calcular lo que quieras que sea el 

Añade la línea siguiente de código al final del método Update:

Es una línea de código muy larga y parece muy complicada, pero incluye muchas cosas familiares. Vamos a analizarla paso por paso:

Este código crea una variable Vector3 llamada desiredForward (dirección delantera deseada).

Esto configura el retorno de un método que se llama RotateTowards (rotar hacia), el cual es un método estático de la clase Vector3. RotateTowards toma cuatro parámetros —los primeros dos son de tipo Vector3 y son los vectores que se rotan desde y hacia un punto respectivamente.

El código empieza con transform.toward (transformar hacia) y apunta hacia la variable m_Movement. Transform.forward es un acceso rápido al componente Transform y obtiene su vector delantero.

Los siguientes dos parámetros son la cantidad entre el vector de arranque y el vector meta: primero, el cambio en el ángulo (en radianes) y luego el cambio en magnitud. Este código cambia el ángulo al multiplicarlo por

 (tiempo por tiempo delta) y la magnitud por 0. 

Time.deltaTime es el tiempo que ha pasado desde el marco anterior (puedes pensar sobre esto como el tiempo entre marcos). Entonces ¿por qué necesitas multiplicar turnSpeed por eso?

El método Update se invoca en cada marco y si tu juego está rodando a 60 marcos por segundo; entonces, eso significa que este método será invocado 60 veces en un segundo. Habría un cambio muy pequeño en cada invocación; de tal manera que, a lo largo de 50 marcos tu obtendrás el cambio que quieras por segundo. ¿Pero qué pasa si un juego rueda a 30 marcos por segundo? Solo la mitad de las invocaciones del método se harían en ese tiempo; por lo tanto, solo la mitad del giro habría sucedido. No quieres que el número de marcos por segundo afecte cuán rápido gire tu personaje —eso no sería nada bueno.

¿Qué pasaría si en vez de un cambio por marco, estás lidiando con un cambio por segundo? Eso haría las cosas mucho más fáciles. Para hacerlo, necesitas multiplicar cualquier cambio que quieras por segundo por la cantidad de tiempo que toma un marco. Esto es exactamente lo que hace esta línea de código.

11. ¿Cómo puedes crear una rotación para tu personaje?

La variable turnSpeed es el ángulo en radianes que quieres que el personaje gire por segundo. Esto se multiplica por Time.deltaTime para obtener lo que el personaje debe girar en este marco. Los radianes son una medida diferente para un ángulo. Son similares a los grados, pero son una medida más natural. Un círculo tiene 2π dentro; por lo tanto, aproximadamente 6. Tu personaje siempre va a tomar el giro más corto; entonces, lo máximo que tu personaje giraría serían 

Dado que, una turnSpeed de 3 significa que le toma a tu personaje cerca de un segundo para hacer un giro completo. Eso es muy lento. Una velocidad de giro de 5 significaría que le toma cerca de medio segundo para un giro completo, lo que es muy lento. Vamos a probar un valor de 20 y ver qué te parece —la puedes cambiar luego, si quieres.

Cambia la línea que declara la variable turnSpeed en la parte superior de la clase a:

  ¡Ahora tenemos un vector para la dirección en la que quieres que mire tu personaje!

Luego, necesitas usar el vector para obtener una rotación y guardarla; de esa manera, puedes usarla cuando quieras. Vas a guardarla al igual que lo hiciste con el vector de movimiento; por ende, tiene sentido declarar esa variable aquí.

Añade la siguiente línea debajo de la línea que declara el Vector3 llamado m_Movement:

 son una manera de guardar rotaciones; ellos evaden algunos de los problemas que conlleva guardar rotaciones como un vector 3D. Este tutorial no los explora en detalle —el saber qué son y que se usan para guardar rotaciones es todo lo que necesitas saber por el momento.

Les has dado al Quaternion un valor por defecto de Quaternion.identity. Normalmente, las variables que son parte de la clase (variable de instancia o miembros) en vez de ser parte de un método específico son configuradas a su valor por defecto cuando se crea un caso de la clase. Por ejemplo, el valor por defecto de un Vector3 es tener los valores de X, Y y Z configurados a 0. Ocurre lo mismo con un Quaternion. Sin embargo, mientras que tiene sentido tener un vector cero (ya que indica que no hay movimiento), un Quaternion cero no tiene mucho sentido. Configurar este valor de Quaternion.identity simplemente le da un valor que indica que no hay rotación, lo que tiene mucho más sentido como valor por defecto.

Ya que has creado una variable de rotación, ahora puedes configurarla. Añade la siguiente línea debajo de la creación de la variable desiredForward:

Esta línea simplemente invoca el método LookRotation y crea una rotación que mira en la dirección del parámetro que se ha pasado.

¿Cómo se ajusta la variable turnSpeed (Velocidad de giro)?

¡Casi has terminado! El último paso es aplicar el movimiento y la rotación a tu personaje. Hay muchas maneras en las que puedes hacerlo, pero desde que el personaje necesita ser parte del sistema de física, necesitas mover el Rigidbody en vez de usar cualquier otra técnica.

Unity Version 2020.3