Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Primeros pasos en Unity. Moviendo objetos - Parte 2 - Contenido educativo

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 10 de septiembre de 2026 por Alvaro H.

2 visualizaciones

Ahora veremos cómo se pueden sumar vectores para mover un objeto, y hacerlo siempre a una velocidad constante. También aprenderemos el método Translate().

Más información Transcripción

Descargar la transcripción

De hecho, voy a hacer una cosa también para que sepamos que un vector, el que he creado antes, es privado. 00:00:07

Yo no tengo acceso a él, pero yo puedo crear uno que sea no público, pero sí que puedo acceder a él a través de la interfaz de Unity, como ya vimos. 00:00:17

Una variable serializada de tipo vector3, que le voy a llamar destinationPosition, es decir, hacia dónde se dirigirá. 00:00:25

Y ya está. Y no le doy nada más, no le doy ningún valor. ¿Por qué? 00:00:35

Y esto es lo bueno de las variables serializadas, igual que de las variables públicas, ya lo tenemos que saber, es que me permite dar los valores directamente en el inspector. 00:00:39

Vemos que aquí nos aparece esa variable creada y como es de tipo vector3 nos aparece con sus tres parámetros. Maravilloso. 00:00:48

¿Eso qué significa? Que yo le voy a decir, por ejemplo, desplázate 1 en x, 0 en y y 0 en z. De hecho voy a poner mi cubo en la posición 0, 0, 0. 00:00:55

Si yo cojo el vector en el que estoy ahora mismo y le sumo este otro vector, ¿qué me dará? 00:01:04

Pues vamos a comprobarlo. Y así comprobamos que efectivamente podemos sumar vectores. 00:01:13

De hecho, voy a crear otro vector que es final position, por ejemplo, de tipo vector 3. 00:01:19

se va a llamar final position 00:01:26

entonces, aquí tengo 00:01:29

la posición inicial es el vector 3 en el que estoy cuando arranco 00:01:34

pues la posición final, que es otro vector 3 00:01:40

va a ser la suma de la posición inicial 00:01:44

más, es decir, tengo la posición inicial 00:01:50

que va a ser en la que empieza el objeto 00:01:54

Tengo la de destino, que esa la voy a añadir a través de la interfaz de Unity, que es la que se va a sumar. 00:01:56

Y tengo la posición final, que va a ser la suma de una y otra. 00:02:03

¿Y cuál va a ser esta? Pues lo vamos a comprobar ahora mismo, porque lo voy a mandar a pantalla. 00:02:09

Si lo lanzo, recordamos, nuestro cubo está en posición 0, 0, 0. 00:02:12

La de destino será 1, 0, 0, 0. 00:02:18

¿Y cuál es la posición final? 00:02:23

Pues ahí me lo dice. 1, 0, 0. Es la suma entre uno y otro. De hecho, si yo por ejemplo le digo que el vector que voy a sumar va a ser de 10, 5, 2 y la posición inicial es de 2, 1, 0, pues si lanzo, ¿cuál es mi vector final? 12, 6, 2. ¿Por qué? Porque es la suma de 2 más 10, de 1 más 5, de 0 a 2. 00:02:25

Si yo quiero mover un objeto, no tengo que hacer más que una cosa, que es tomar la posición en la que está el objeto, 00:02:54

determinar otro vector al que quiero moverlo, sumarle un vector, eso me da otra posición, 00:03:01

y lo que tengo que decirle es, vale, ahora te mueves tu posición a esa nueva posición. 00:03:06

Y vuelvo otra vez a empezar el bucle. Vamos a comprobarlo y vamos a comprobar cómo efectivamente podemos animar ese cubo. 00:03:11

Lógicamente el bucle es algo que se ejecuta en cada fotograma, con lo cual yo le digo que en cada fotograma 00:03:17

primero que obtenga la posición en la que está el objeto, porque lógicamente va a ir cambiando. 00:03:24

Entonces necesito obtenerla de nuevo en cada fotograma, en cada actualización. 00:03:29

Le voy a decir dónde se tiene que desplazar. 00:03:32

¿Y dónde se tiene que desplazar? 00:03:35

A la posición final, que es un vector 3 resultante de sumar su posición inicial 00:03:37

más este vector que he creado yo aquí, que además como está serializado lo puedo poner manualmente. 00:03:41

¿Y ahora qué es lo que me queda? 00:03:48

Decirle que se mueva, como hemos hecho antes. 00:03:50

Como hemos hecho al principio, que le decíamos que se pusiese al comenzar el script, pero ahora se lo vamos a decir cada fotograma. 00:03:52

Donde decimos transformPosition es igual a este vector3 resultante. 00:03:57

Esto ya no me hace falta. 00:04:09

Cuando lance el juego, en cada fotograma, y eso tenemos que recordarlo, va a obtener la posición inicial del cubo. 00:04:11

Lo voy a empezar en 0, 0, 0. 00:04:19

A esa posición inicial le va a sumar un vector. ¿Cuál? El que tengo aquí. 00:04:22

Y, por ejemplo, le voy a decir que se desplace 1 en X, 0 en Y y 0 en Z. 00:04:26

Es decir, se va a mover en el eje X. 00:04:30

Y le va a dar un vector resultante, es decir, ahora mismo le daría 1, 0, 0. 00:04:32

Pero es que en el siguiente fotograma mi cubo está en el 1, 0, 0. 00:04:36

Así que le dirá, bueno, pues ahora muévete al 2, 0, 0. 00:04:39

Y ahora al 3, 0, 0. Y ahora al 4, 0, 0. 00:04:42

Resultado, pues un cubo a la fuga. 00:04:44

Ahí está. 00:04:48

Ha salido disparado. 00:04:49

Aquí es cuando necesitaría una cámara que lo siguiese. 00:04:50

Pero, antes de seguir, vamos con un concepto que vamos a manejar mucho a lo largo del curso, que es 00:04:53

¿cuánto se está moviendo este cubo? 00:04:58

Pues bien, para responder a esa pregunta, lógicamente, tenemos que pensar en fórmulas matemáticas, 00:05:01

en el sentido de que, si le he dicho que cada fotograma se desplace 1 en X, 00:05:05

y yo, por ejemplo, me estoy moviendo a 48 fotogramas por segundo, 00:05:09

significa que cada segundo se va a desplazar 48 en X. 00:05:12

Pero, ¿qué pasa si mi ordenador va lento y bajo el número de fotogramas por segundo? 00:05:15

Paso a 24. Pues entonces mi objeto se moverá a 24 unidades por segundo en X. 00:05:19

Conclusión, se mueve más lento. Eso es inasumible. 00:05:26

Así que tenemos que buscar una fórmula en la que la velocidad de movimiento 00:05:30

dependa del número de fotogramas por segundo. 00:05:33

¿Eso cómo lo conseguimos? Pues con un parámetro muy interesante 00:05:36

que se llama Time, Delta Time. 00:05:40

Para que vayamos acostumbrándonos, si yo le pregunto a Unity 00:05:44

que me busque todo lo que tiene de time, veréis que hay muchas cosas que nos 00:05:47

permite jugar con el tiempo. Y entre ellas una de las más importantes, esta. Y 00:05:53

si le preguntamos qué es, nos dice que es cuánto tiempo ha pasado desde nuestro 00:05:59

último fotograma. ¿Qué significa? Que si yo me estoy moviendo a un fotograma por 00:06:05

segundo y le pregunto a time delta time, me dirá que 1, ha pasado un segundo entre 00:06:09

mi último fotograma, pero si me estoy moviendo a dos fotogramas por segundo, me dirá que 00:06:14

ha pasado medio segundo, uno partido de dos. Y si me estoy moviendo a diez fotogramas por 00:06:18

segundo, pues una décima de segundo. Y esto es muy importante porque si yo multiplico 00:06:22

mi movimiento por ese parámetro y compensará en función del rendimiento del juego. Vamos 00:06:26

a comprobarlo. Si yo a esta final position le digo que es esto, pero multiplicado por 00:06:33

lo que hemos visto, el deltaTime, estoy consiguiendo lo que acababa de decir. 00:06:41

Se mueve a más o menos velocidad. ¿Veis? 00:06:48

¿Queremos que se mueva más rápido? Pues nada, queremos una variable 00:06:52

a la que pueda acceder de tipo float 00:06:54

llamada speed. Cubo yo valor inicial sea 0. 00:06:58

¿Eso qué significa? Que si yo 00:07:04

a mi posición final, que es un vector 3, 00:07:05

Lo multiplico por deltaTime, pero a su vez eso lo multiplico por mi variable de velocidad, que además es una variable pública. 00:07:10

¿Qué es lo que obtengo? Ahí está. 00:07:21

Si ahora le doy al play veréis que no se mueve. ¿Por qué? Porque lo estoy multiplicando por cero. 00:07:24

La velocidad es cero. 00:07:28

Pero de nuevo, lo maravilloso de poder modificar los parámetros en el tiempo de ejecución. 00:07:30

podemos ponernos encima de la variable 00:07:35

veréis que salen dos flechitas indicando 00:07:37

que podemos cambiar su valor y ahí vamos 00:07:39

sube la velocidad y vemos que 00:07:41

el cubo se acelera, se acelera más 00:07:43

o incluso si le doy un valor 00:07:45

negativo 00:07:47

pues lógicamente estoy multiplicando un vector por un número 00:07:48

negativo, es decir, su inversa 00:07:51

y como casi siempre ocurre 00:07:53

hay una forma mejor de hacer las cosas 00:07:55

y en ese sentido recomiendo siempre 00:07:57

explorar el scripting reference 00:07:59

el manual de referencia de los scripts 00:08:01

de Unity para descubrir o buscar si lo que estamos haciendo lo estamos haciendo bien 00:08:03

o lo podemos hacer mejor. 00:08:09

Lo que hemos aprendido para mover objetos no es la forma adecuada de mover objetos. 00:08:11

Sencillamente lo he usado para también aprender otros conceptos como es los vectores, la suma 00:08:15

de vectores o incluso para empezar a movernos con soltura en el código. 00:08:19

Pero si nos vamos, por ejemplo, a la página, como he dicho, de Unity y buscamos el método 00:08:23

transform veremos que tiene por supuesto unas propiedades asociadas y unos 00:08:29

métodos que si no son son útiles pues los podemos usar son públicos y están 00:08:33

hechos para facilitarnos la vida y de hecho entre ellos si buscamos hay muchos 00:08:37

pero veremos que hay uno que es el método translate y qué es lo que hace 00:08:42

ese método mover el objeto es decir que eso que hemos hecho vamos a decir un 00:08:46

poco a lo bruto pues unity lo tiene ya resuelto para que lo hagamos de forma 00:08:51

más fácil y lo vamos a comprobar. Si me voy al código que tenía asociado a mi cubo manteniendo 00:08:56

la variable de velocidad, fijémonos que eso que antes he hecho con varias líneas y además con un 00:09:01

poco de comedura de coco, pues lo voy a hacer sólo en una sola línea. ¿Cómo? Accediendo efectivamente 00:09:05

a la clase de transform de mi objeto, en este caso a mi componente transform y siempre os recuerdo 00:09:12

que aquí os aparecerán una serie de métodos y atributos y entre los métodos por supuesto está 00:09:18

el método translate. Y ese método nos pide 00:09:24

que un vector, hacia dónde voy a 00:09:30

desplazarlo, y ahí es donde yo tendría que darle un vector al que me 00:09:34

desplazo. Podría incluso declararlo aquí y decirle new vector 3 00:09:38

pero no lo voy a hacer. ¿Por qué? Porque de nuevo vuelvo a recordar lo que 00:09:42

acabo de decir. Siempre hay una forma mejor de hacerlo, o casi siempre. 00:09:46

Y si me voy al scripting reference de Unity y le pregunto 00:09:50

¿Qué métodos tengo yo para mi vector 3? 00:09:54

Lo busco, me voy a sus propiedades, a sus atributos, y fijaros lo que encuentro aquí. 00:09:57

Yo puedo definir un vector 3 al vuelo y pasarle directamente un parámetro, decirle back, 00:10:05

pues entonces él va a generar un vector 3 que esté en esa posición, o en esta, 00:10:12

si quiero que vaya hacia abajo, o hacia adelante, o hacia la izquierda, 00:10:17

o incluso que se desplace uno en todos los sentidos 00:10:21

o incluso uno que es un vector 3 en 0, 0, 0 00:10:25

¿qué es lo que quiero ahora mismo? 00:10:30

pues que se desplace por ejemplo hacia la derecha 00:10:32

con lo cual yo puedo directamente en mi Unity decirle 00:10:34

muévete en un vector 3, ¿cuál? 00:10:39

el que te voy a crear ahora mismo 00:10:41

punto, dándote un atributo 00:10:43

¿cuál? right 00:10:45

ahí está 00:10:47

Y lo dicho, igual que le digo derecha, le puedo decir arriba, abajo, hacia adelante, hacia atrás. 00:10:49

Y aquí se aplica lo mismo que hemos visto antes. 00:10:54

Por la velocidad, por el atributo time, deltaTime. 00:10:56

Y si nos vamos a Unity y lanzamos este script, veremos que, modificando la velocidad, el efecto es exactamente el mismo que habíamos conseguido antes. 00:11:06

pero eso sí, usando una sola línea de código 00:11:18

así que de nuevo, repito 00:11:25

investigad porque a menudo las cosas son más fáciles de lo que pensamos 00:11:27

bueno, y con esto la verdad es que ya le podemos echar imaginación 00:11:32

nos faltaría añadir interactividad 00:11:35

que eso lo dejaré para un siguiente cursillo 00:11:37

donde veamos, por ejemplo, decir 00:11:40

pues cuando le doy a la izquierda se mueve a la izquierda 00:11:41

cuando le doy a la derecha se mueve a la derecha 00:11:44

o cuando le doy a mis cursores acelera o decelera 00:11:45

con un máximo o con un mínimo, como hemos visto 00:11:49

en fin, pues eso, que ya 00:11:52