Bienvenidos de nuevo, mis compañeros desarrolladores de juegos.
En este video, en realidad vamos a poner a usar las entradas que creamos
y vamos a ver lo importantes que son las variables.
Entonces ahora cuando corremos nuestra ganancia,
notarás que no sólo nos quedamos ahí parados.
No tienes nada en la consola.
Cuando presionamos la tecla WASD,
podemos ver que nuestro jugador se mueve a la izquierda,
derecha, izquierda, arriba, abajo.
Y no sólo eso, si yo aumento la velocidad de movimiento,
ahí vamos, Somos mucho más rápidos.
Entonces no sólo movemos al jugador con las llaves,
también podemos controlar lo rápido que se movió.
Entonces bueno, dicho eso,
no perdamos más tiempo y empecemos.
De acuerdo, entonces ahora que tenemos los insumos listos,
vemos cómo funcionan.
Es hora de empezar realmente a mover al jugador.
Como lo prometimos.
Abramos el guión aquí mismo.
Y sigamos adelante y eliminemos estos debug dot log.
Estos estaban justo aquí también.
Haznos creer que esto realmente está funcionando.
De acuerdo, entonces lo primero que tenemos que hacer es
tener acceso a la posición transformada del jugador.
Entonces vamos a seguir adelante y hacer clic en Transformar.
Y puedes ver aquí lo útil que ya es Visual Studio.
Nos está diciendo cuál es la transformación.
Por lo que la transformación que va a escribir en este momento es el transporte adjunto a este objeto de juego.
¿ Qué objeto de juego?
Es el objeto del juego que tiene el script del controlador del jugador en él.
Y si miramos atrás aquí,
hacemos click en la capa.
En cualquier momento ahora hacemos clic en el jugador.
Podemos ver que el controlador de jugador está unido al jugador y
la transformación que está en el GameObject no juegan como esta.
Por lo que estamos accediendo a esta transformación específica.
Por lo que de vuelta aquí,
volveremos a escribir transform,
pulsa Tab para completar la posición de punto de palabra.
Se puede ver que se puede acceder a la posición, a la escala,
la rotación, a todo lo que está disponible en la transformación.
Y escribimos posición.
Ahora, esto va a ser igual a un nuevo vector tres.
Y va a ser,
digamos por ahora solo 0.1 f.
Y también podemos escribir punto 1 f Esto significa 0,
y mantendremos el eje z en el mismo lugar. Eso lo ahorraremos.
Ahora bien, podría estar pensando ¿por qué Vector3
no simplemente dijimos que no queremos modificar esto?
Bueno, si pasamos por encima de la posición,
se puede ver que la posición espacial mundial de la transformada como vector tres,
que también puede pasar por las documentaciones y ver que en realidad es
la posición transformada de cualquier objeto,
independientemente de si estamos usando 3D,
2D 1D, Eso es imposible,
pero se obtiene el vector de imagen tres posición.
Siempre accedemos a la posición del vector C,
pero lo mantenemos como 0 f
Ahora el alcance no está completo,
pero lo voy a usar solo para que aprendamos a medida que cometemos errores,
voy a guardar esto.
Voy a volver aquí.
Y solo pongamos algunos valores reales aquí para que lo sepamos,
así que menos cinco y digamos que esto es minús1 salvará eso.
Vamos a correr nuestro juego y veamos. Ahí vamos.
Por lo que 0.10.1.
Ahora bien, ¿cuál parece ser el problema?
¿ No lo estamos llamando cada fotograma?
Bueno, el problema aquí es que simplemente estamos asignando este valor aquí mismo,
el nuevo vector, 30.10.10 f a la posición.
En cada cuadro no estamos aumentando la posición de transformación.
Entonces, ¿cómo vamos a empezar a aumentar?
Déjame que detenga aquí al dramaturgo.
Vamos a escribir que tomamos la posición de punto transformado del objeto del juego
y luego le agregamos el vector 0.10.1 3, cada fotograma.
Entonces vamos a ahorrar eso.
Y volvamos atrás y miremos nuestro juego,
cómo se ve ahora mismo.
Corremos el juego y ahí vas. Muy goles.
El jugador acaba de salir del edificio,
como se puede ver, como se puede ver en este momento lo que sucede aquí.
Tomamos la posición transform.py.
Asignamos en la transformación ya disponible,
pero posición más el vector 3,
y lo hacemos cada fotograma.
Entonces digamos que empezamos en 0, 0.
Tomamos 000 aquí mismo,
agregamos a este vector,
el siguiente cuadro tenemos 0.21.
Nosotros lo tomamos, le sumamos, se convierte en 0.2.
Nosotros lo tomamos, le sumamos se convierte en 0.3.
Por lo que cada cuadro lo incrementamos.
Ahora, como pueden ver, aquí hay código redundante.
Redundante significa que lo estamos usando varias veces.
Para evitar esto, simplemente podemos eliminar esto aquí mismo
y en su lugar agregar un plus detrás de los iguales.
Y esta es exactamente la misma sintaxis que antes.
Entonces si escribimos esto de nuevo,
permítanme simplemente duplicar esto.
Simplemente añadiré dos barras.
Esto se convierte en un comentario.
Y como hemos dicho,
un común no ejecuta el código,
y simplemente eliminaremos esto.
Entonces como un pequeño recordatorio de lo que significa este plus.
Entonces vamos a guardar eso.
Volveremos a nuestro juego y vamos a hacer esto un poco más pequeño,
así que vamos a añadir otro 0 y aquí,
guarde eso de nuevo en nuestro juego.
Corremos el código, el juego.
Y ahí vamos,
podemos verlo lentamente flotando lejos y otra vez, genial.
Por lo que ahora tenemos a nuestro jugador moviéndose.
Pero no queremos que estos valores sean simplemente arbitrarios.
No queremos tener 0.1 o 0.01.
En realidad queremos la entrada que hemos conseguido aquí para mover al jugador.
Entonces este será tu reto.
Tu reto es mover la posición del jugador con la entrada.
Por lo que vas a acceder a la posición de la transformación del jugador.
Vas a hacer de la posición un nuevo vector 3.
Y vas a usar el movimiento input.txt y el punto y
ya que el x e y de este nuevo vector
3 también mantendrá el eje z en 0 F. Y algunos solo un poco de ayuda extra.
Te recomiendo que pases por la documentación de Unity y veas el ejemplo.
Fueron tan amables en la empresa Unity en algún lugar
para darnos un ejemplo de exactamente lo que estamos buscando.
Así que pausa el video ahora mismo y ve a hacer el reto.
De acuerdo, bienvenido de nuevo.
Entonces si nos desplazamos hacia abajo justo aquí,
se puede ver que obtenemos la entrada horizontal,
obtenemos la entrada vertical,
y luego los ponemos todos dentro de la posición transformada.
Este es el ejemplo exacto que necesitamos y nuestra ganancia.
Entonces si volvemos aquí, en lugar de 0.01,
voy a escribir el punto de entrada de movimiento x. Voy a escribir el punto de entrada de movimiento y Y
voy a guardar todo eso.
Ahora de vuelta en nuestro juego,
ejecutamos el juego y ahora nuestro jugador no se mueve.
Si queremos moverlo a la derecha,
teníamos el Dickey se mueve a la derecha,
la izquierda, y desapareció.
Entonces como puedes ver, nuestro jugador es extremadamente, extremadamente rápido.
¿ Por qué es eso? Bueno, es porque las actualizaciones se llaman cada fotograma.
Entonces si intentamos jugar de nuevo,
déjame mostrarte a lo que me refiero.
Si miramos aquí arriba en las estadísticas,
podemos ver cuántos fotogramas por segundo tenemos.
Entonces, ¿sabes qué son los cuadros por segundo?
Si alguna vez has jugado un juego y puedes ver en este momento
son casi mil cuadros por segundo.
Estamos llamando a esto mil veces, una 1000 veces.
Estamos agregando uno,
así que estamos sumando un 1000 cada vez o cada segundo si quieres.
Entonces, ¿cómo vamos a controlar esto?
Bueno, hay una manera muy sencilla,
y eso es multiplicando esto por el tiempo.Deltatime.
Y lo que sucede ahora mismo,
tiempo.Deltatime, si pasamos sobre él,
es el intervalo y los segundos desde el último fotograma hasta el actual.
Entonces lo que esto hace es que toma el tiempo entre cada fotograma,
lo multiplicamos por éste y ahora se convertirá en velocidad de cuadro y dependiente.
Déjame mostrarte lo que eso significa.
Esto significa que cuando ejecutamos el juego,
el tiempo que tarda desde el primer fotograma hasta el segundo se suma al movimiento.
Y ahora cuando golpeamos la tecla D, ahí vamos.
Somos mucho más lentos.
Y si tuviéramos la W, nos movemos arriba, SVMs abajo, a, nos movemos a
la izquierda, nos movemos a la derecha,
y así sucesivamente y así sucesivamente.
¿ Qué tan guay es eso?
Lo que tenemos en otro plural,
que somos extremadamente bajos.
Esta no es forma de jugar un juego,
sobre todo cuando tenemos enemigos aterradores siguiéndonos.
Por eso tuvimos esta variable de velocidad de movimiento todo el tiempo.
Esto nos permitirá controlar nuestra velocidad.
Por lo que ahora también multiplicaremos esto por la velocidad de movimiento.
Eso lo salvaremos.
Por lo que de vuelta en nuestra ganancia,
podemos ver que la velocidad de movimiento es de 20.
Pongámoslo a cinco.
Guarda eso, ejecuta el juego.
Y ahora podemos movernos arriba,
abajo, izquierda, derecha, como queramos.
Qué genial es que finalmente tengamos un personaje,
un jugador que se está moviendo en un mundo que hemos creado usando código simple.
Hagamos esto 50.
Echemos un vistazo. Bueno, ahí vamos.
Incluso podemos controlar lo rápido que va.
Es decir, en serio, ¿qué tan emocionado estás?
A lo mejor sólo soy yo.
Mantengámoslo a las cinco. Creo que cinco.
No hay fibras realmente lentas. Hagamos entonces.
Sí, ahí vamos.
Entonces 10 se ve realmente, muy bonito.
Y con eso hecho,
espero que lo disfruten.
Antes de presentar el siguiente video,
notarás que en realidad todavía podemos caminar por
paredes y alejarnos, lo cual no es bueno.
Por eso en el siguiente video,
estaremos aplicando la física a nuestro jugador y haciendo que
interactúe con diversos objetos de nuestro mundo.
Con eso dicho, cuatro,
voy a asegurarme de comprometer sus cambios.
No voy a hacer con cada video porque
es algo que hay que volverse automático.
Y cada vez que hagas algo importante en tu juego,
asegúrate de escenificar todo el trabajo,
comprometer todo tu trabajo,
y te veré en el siguiente video.