Transcripciones
1. Unreal Engine 5 Blueprints paso a paso Desarrollo de juegos de disparos espaciales: Embárcate en una aventura de
creación de juegos, como ninguna otra, con altramuces Unreal
Engine Five Desarrollo de juegos de
disparos espaciales paso a paso. Tu primer paso para convertirte en un desarrollador de juegos maestro
comienza aquí cinco. Soy Marcos, un creador con un enfoque principal en el
aspecto de codificación del diseño de juegos. Mi viaje hacia
el desarrollo de juegos ha sido impulsado por una profunda pasión por la fusión del arte
y la tecnología Esto me ha llevado a realizar estudios
extensos y dedicarme a aplicaciones
del mundo real dentro de lo real del diseño de juegos. Este
curso integral te invita a un emocionante
viaje para dominar el desarrollo de juegos usando
Unreal Potente sistema de planos
diseñado tanto para principiantes, ansiosos por explorar la capa
de desarrollo de juegos desarrolladores experimentados que buscan
perfeccionar las habilidades con
Unreal Engine Este curso promete una
rica experiencia de aprendizaje que cubre todos los
aspectos de la creación, cautivador juego de disparos espaciales Te proporcionamos un
completo paquete de recursos para impulsar tu proyecto, incluyendo todos los activos necesarios Este paquete cuenta con
un nivel espacial con una nave jugable única y
dos activos enemigos distintos Viene totalmente equipado
con 27 materiales y las instancias o re efectos partículas para
propulsores de barcos y lanzadores de armas, para efectos de sonido unpick Y prepletes de dos niveles para acto, revisión y skyboards espaciales Esta variedad de recursos está diseñada para
darle una ventaja a la hora de darle vida a su juego con elementos
visualmente impresionantes y
atractivos. El curso es una estructura
para guiar a los principiantes a convertirse en desarrolladores de
juegos competentes Comenzando desde cero, aprenderás a
aprovechar un motor real, 51 de las plataformas de desarrollo de
juegos más avanzadas para transformar tus
ideas creativas en realidad. A través de
demostraciones detalladas, obtenga una comprensión profunda de la arquitectura
y la mecánica del motor. Comenzamos por sentar las
bases para tu juego, incluido
el establecimiento del modo de juego Diseñar un menú principal dinámico e implementar un sistema de pintura de
jugadores. Pasos esenciales para preparar
el escenario para una experiencia de
juego inmersiva medida que avanza el núcleo, profundizamos en la mecánica
del juego Aprenderás a mejorar la interacción de
los jugadores con mecánicas
avanzadas de cámara y sistemas de control
intuitivos. Implemente un sistema de
movimiento robusto, anime su nave espacial y desarrolle un sistema de
disparo integral Integrar un
sistema de puntuación para recompensar a los jugadores que forman
parte del plan de estudios. Su lección está meticulosamente
diseñada para construir sobre anteriores, asegurando una base sólida
tanto en fundamentos como en técnicas
avanzadas de desarrollo de juegos La acumulación de
la puntuación te ve agregar características de
juego sofisticadas, como sistemas de misiles, implementar un sistema de puntuación
alta y crear juego sobre secuencia Llevando tu juego a
una conclusión polaca, Más que solo codificación,
Este curso te equipa con habilidades para depurar,
optimizar el rendimiento y aplicar los
toques finales que diferencian un juego destacado diseñado para individuos
apasionados Este curso ofrece insights
invaluables y experiencia práctica, independientemente de tu nivel de
experiencia. Para aquellos con un gran interés
en los juegos basados en la narrativa, considere promover su
educación con Unreal Gin Five, juegos
visuales, novedosos y
narrativos Este curso adicional
está meticulosamente diseñado
para profundizar su comprensión
del diseño de juegos narrativos,
enseñándole a crear entornos
atractivos, enseñándole a crear entornos
atractivos, dominar
las complejidades narrativas con las tablas de datos de
Anal Engine Five
e integrar a la perfección mecánicas e integrar a la perfección Ya sea que tu ambición
sea crear novelas visuales
inmersivas
o juegos ricos en narrativa, este curso
te permitirá hacer que cada decisión cuente y cada historia resuene
dentro de tu audiencia Unreal Engine Cinco
loopings, paso a paso, desarrollo de juegos de disparos
espaciales es tu puerta de entrada, convirtiendo los sueños de desarrollo de juegos en realidad con
Unreal Al final de este curso, habrás
desarrollado completamente el juego Spaceshoter, listo para ser ampliado o portado a tu Si estás preparado para embarcarte
en este emocionante viaje, aprende y diviértete.
Únete a nosotros hoy.
2. Introducción al paquete de recursos y desarrollo de UE5: Hola y bienvenidos a
Unreal Engine Five, Blueprint paso a paso Curso Desarrollo de Juegos
Space Shooter Comencemos nuestro curso
revisando nuestro paquete de recursos. Y decir algunas cosas
sobre nuestro sistema. Y claro, a la vez explicar algunas cosas sobre lo irreal y algunos conceptos básicos de scripting
de blueprint Ahora he abierto el proyecto de paquete de
recursos, y lo primero que vemos es esta ventana de aquí a la
que llamamos ventana gráfica El mapa que se
carga en este momento es el mapa predeterminado de irreal
que no vamos a cambiar Podemos ver en el outliner aquí, este es el contenido
del mundo Y podemos ver que ha poblado este mundo con algunas cosas
por defecto. Sin embargo, no vamos a usar esto. Estaremos usando, si
vamos al navegador de contenido, hay una carpeta llamada maps. Aquí abajo está el navegador de
contenido. Puedes abrirlo
con espacio de control, cerrarlo, o puedes acoplarlo. El diseño, y se queda aquí. Yo personalmente lo prefiero acoplar a veces
depende de lo que esté trabajando. Vamos a tenerlo ahora mismo. Ahora en nuestro contenido, esto es todo lo que
está en nuestro proyecto. Estas son las carpetas de contenido
que hemos categorizado aquí. Aquí podemos ver las carpetas. Ahora bien, si no puedes
ver los filtros, tal vez
sea porque no
has habilitado ningún filtro. He habilitado y
deshabilitado algunos filtros. Este es un lugar donde se los ajustes de
filtro
que ha utilizado almacenan los ajustes de
filtro
que ha utilizado para un uso rápido. Podemos restablecer nuestros
filtros por aquí. Como pueden ver, se van. Pero si hago clic,
digamos por ejemplo,
blueprint, Cualquier cosa sobre
planos, todas Si hago clic en ellos, Top filtrado. Ahora echemos un
vistazo a nuestro navegador de contenido. Aquí tenemos algunas carpetas, luego planos,
materiales, partículas, sonidos,
estáticos, mallas y texturas Correspondientemente, encontrará los activos adecuados
en cada carpeta En medidas estáticas,
encontrarás las medidas estáticas,
texturas , texturas, materiales,
materiales, partículas, sonidos, etcétera En los
planos de carpeta,
encontrarás un plano llamado sky box Ahora vayamos a nuestros mapas. Primero, pasemos a
nuestro nivel de activos. En el nivel de activos, estamos demostrando nuestras mallas estáticas, algunos materiales que usaremos, y algunas partículas, cómo estoy
usando este uso de cámara Déjame cerrar el
navegador cond para que esto sea más fácil. Ahora bien, si redactor radicalmente, puedo mover la cámara a
izquierda y derecha, arriba y abajo, rotar la cámara con W S AD, puedo moverme Editor real cubre una
variedad de movimientos en la ventana gráfica que
no vamos a pasar por todos
ellos en este momento Dentro de nuestras ventanas gráficas, estas son las partículas
que usaremos para propulsores y para
nuestro Estos son los
materiales que vamos a utilizar para nuestras balas. Aquí mismo tenemos el mensaje estático
que vamos
a usar para nuestros jugadores, jugar nave y los enemigos. Si volvemos nuestro contenido y seleccionamos el espacio,
nivel, nivel, espacio, podemos ver esto aquí que es diferente cuando
estamos probando nuestro juego. Vamos a estar usando
este patrón por aquí, pero cuando presionamos, toca el nivel, toca todo lo que
tenemos programado. Cuando paramos, presionamos la parada, o presionamos escape. Detiene la simulación. Ahora antes de
profundizar en una parte trasera, repasemos un poco nuestro sistema y qué componentes usaremos para hacerlo. Entonces voy a traer pintura, ir un poco
a través de algunos conceptos. Estaremos usando un modo de juego, pero lo que es un modo de juego para alguien que es nuevo
no tiene idea. Entonces básicamente es un tipo de plano que
estás alojando reglas de
nivel porque los modos de juego
se generan en cada Cada nivel tiene su
propio modo de juego. Cuando estás
restableciendo el nivel, si vuelves a cargar
el nivel,
entonces el juego, el
modo de juego también vuelve a funcionar Eso es una cosa importante. Puedes tener muchos tipos
de modos de juego en un juego. Además, no estás limitado a uno. Básicamente, es un
blueprint que aloja reglas de
nivel y
también cosas de servidor. Esto también es importante para el
modo multijugador. En fin, no vamos a estar
haciendo ningún multijugador. Vamos a continuar.
Estaremos usando un modo de juego. Como pueden ver, he variado algunas cosas
por conveniencia, pero conectemos los puntos. En nuestro modo de juego,
estaremos engendrando a nuestro jugador. Estaremos teniendo una regla
para engendrar a nuestro jugador. También estaremos generando el widget del menú principal.
¿Qué es un widget? Nuevamente, un widget es un
blueprint especializado para mostrar cosas de la interfaz de usuario como
si tuviera un diseñador gráfico Nos meteremos en ello cuando
avancemos nuestras lecciones. Mientras hablamos de widgets, tendremos un widget de menú principal,
un widget de juego que
albergaremos nuestro punto de mira,
nuestra barra de salud y barra de resistencia También tendremos un juego sobre
widget que alojará nuestra puntuación más alta y nuestra funcionalidad para
restablecer el juego Ahora hablé un poco sobre creación de un
sistema de desove de jugadores para jugador Así es como llamamos jugador jugador
peón personaje. Hay muchas
maneras de hacerlo. Estaremos usando player realmente por blueprint a través de eso Estaremos generando otro
acto, es
decir, un misil bala jugador Ahora la palabra aquí es actor. Si hacemos un glosario, realidad existe un
glosario
sobre estas cosas Un actor es un actor es cualquier objeto que se pueda
colocar en el nivel. Podría ser un jugador. Podría ser un yo estático. Un mes estático llano
sin un plano. Podrían ser algunas partículas. Podría ser una ubicación de
inicio de jugadores, una cámara, cualquier cosa que
se pueda colocar dentro del nivel. Es un actor como información
en jerarquía en Unreal, viene bajo el juego
como si estuviera abajo en jerarquía de sistema de
intracomunicación. Pero eso es un
poco más avanzado. En fin, otro actor
que estaremos creando es padre enemigo. ¿Por qué lo llamo un enemigo padre? Porque a través de este actor, demostraremos
al niño actor que es el enemigo disparador. Y el enemigo boom, que
serán enemigos que heredan ciertas habilidades y estadísticas
del enemigo padre Esta es otra funcionalidad. Otro glosario, un actor hijo es un actor que hereda propiedades
del actor padre Ahora vamos a tener algunos sistemas
que vamos a programar. Nuestros sistemas básicos serían,
por supuesto, nuestra puntuación más alta con un sistema de puntuación de
funcionalidad segura y de carga. Eso se contará cada
vez que matemos enemigos. A través de ese sistema de puntuación, calcularemos nuestras
mejoras como basadas en puntuación y por supuesto
un sistema enemigo. Me quedé con el sistema de salud para el final porque
íbamos a usar un componente, un componente de
plano El glosario para esto es
un componente de blueprint es un comportamiento que
podemos diseñar y adjuntarlo a múltiples actores Como queremos que el jugador y los enemigos tengan
este comportamiento, vamos a llamarlo creo, dañable en nuestra codificación Ahora creo que eso
es todo para éste. Te voy a ver
en la siguiente. Adiós.
3. Modo de juego y diseño de interfaz de usuario: Hola y bienvenidos a un
Engine Five Blueprints, desarrollo de juegos de
disparos espaciales
paso Entonces comencemos con nuestro proyecto. Como puedes ver,
el proyecto se abre en el mapa predeterminado
que está vacío. Bueno, en caso de que hagamos
algo mal en nuestro mapa, si tuviéramos nuestro mapa por defecto, podría retroceder el proyecto y
podrías abrir el proyecto. Mucho puede salir mal.
Básicamente, tenemos un mapa predeterminado vacío, y ahora vamos a
abrir nuestro propio nivel. En el navegador de contenido, en los mapas de carpetas
podemos ver el espacio de nivel. Este es nuestro
nivel principal. Esto contendrá todo lo que
vamos a crear. Vamos a abrirlo. Como decíamos, lo primero que
vamos a hacer en este nivel es tener un modo de juego que
habilite el widget del menú principal. Y crea el reproductor muestra en realidad el widget del menú principal. Hagámoslo primero. Por qué
es empezar de ahí. He creado una carpeta que yo, lo mejor es el contenido, mejor incluimos esta carpeta
en la captura o bien puedes encargar
correctamente en el contenido e ir a carpeta nueva y
crea una carpeta. Usted lo nombra interfaz de usuario. Y no voy a
nombrarlo porque ya
tengo que borra, ¿verdad Entonces puedes crear una carpeta, o vamos a usar esta para almacenar nuestros widgets como activos. Voy a escribir, hacer clic
y crear un widget. Voy a usar el widget
de interfaz. Y la plantilla que vamos
a usar es widget de usuario. Otra clase. Para nuestros propósitos,
voy a llamar a este WG. Voy a abrirlo. Voy a guardarlo
solo para guardarlo en la
memoria para que no pase nada
en la carpeta de planos Voy a escribir, dar clic
y crear un nuevo plano. Ahora como puedes ver, aquí no
hay modo de juego porque juego tiene base de
juego que
en realidad es un modo de juego, todas las clases y tipo modo de juego. Como puedes ver, este es el
juego viejo Base y juego viejo. Voy a seleccionar
éste, Aquí está. Y voy a
llamarlo Juego Base. Ahora comencemos a alojar
nuestras reglas dentro. En realidad, antes de albergar
nuestras reglas, tal vez sería prudente a nuestro nivel que
este sea el juego. Como pueden ver, tengo una pestaña
aquí llamada World Settings. No tenga esta ficha por aquí. Puedes encontrarlo fácilmente en Configuración de Mundo de
Ventanas. Puedes ver que está habilitado para mí, lo aparecerá en
otro lugar del layout, pero siempre puedes D
soltarlo donde quieras ahí. En una configuración mundial, pasaremos al modo gay. Anular donde dice no o podría estar diciendo
solo modo gay, que es el valor predeterminado. Vamos a seleccionar el modo
no o gay, nuestra propia ganancia de espacio GM, tiene algunos valores predeterminados. Vamos a cambiar
internamente el plano. Podemos cambiarlo aquí, en realidad podemos seleccionar nuestro personaje, cambiarlo todo en azul. No hemos creado
nuestro personaje, pero tiene todos los demás
caracteres predeterminados que podemos usar yendo a guardar el nivel
volviendo a un modo. Estos ajustes se encuentran
en los valores predeterminados de clase. Hay configuraciones de
clase, valores predeterminados de clase, hay algunas diferencias
de opciones entre estas dos Pero por ahora vamos a usar la configuración de
clase e ir a Clase de punto
por defecto y seleccionar. La razón por la que estamos seleccionando non
y ni siquiera nuestro personaje es que el gade es
responsable de engendrar al jugador Pero si seleccionamos aquí, significa que cuando comience
el nivel, el jugador donde queremos
especificar cuándo
va a ser engendrado el jugador Interesante es que
seleccionamos esto también aquí puedes ver que también cambió aquí. Esto afecta el plano. Pero me parece agradable saber
que los valores predeterminados de clase aquí
contiene esto aquí en cuanto a Compilando Ahora en la Viewport no
vamos a
estar agregando nada, generalmente en blueprints
en la Agregamos algunos componentes. Digamos lo que el azul,
este caso queremos que el agregue un script de
construcción de Viewport cercano Nuevamente, es algo que
no usaremos en el modo de juego. Básicamente es una herramienta para modificar el blueprint
mientras se está creando En nuestro caso, el modo de juego
se crea en del nivel, no
vamos a estar creando nada. Objeción. Lo que vamos a
usar es el gráfico del evento. El gráfico de eventos suele ser
donde va el código principal. El código del blueprint principal va a eliminar el evento
grueso porque
no vamos a estar
usando algo
que se ejecute por grosor, por fotograma Vamos a estar
usando evento start. Juega esto cuando esto corra. En nuestro caso, cuando el nivel corre porque parte del nivel cuando comienza el juego,
haz algo. Lo que vamos a hacer,
vamos a crear, vamos a arrastrar desde
aquí y crear ige Esta es nuestra
línea de ejecución desde aquí. Eso, ¿qué hago cuando estoy en juego? Un widget, lo que llamo a
este widget o crear widget, Wig línea conectada. Este nodo de creación requiere una clase de widgets,
algunos valores predeterminados. Tiene algunos valores predeterminados. Y el widget que
creamos, G menú principal. Ahora cuando tienes un
montón de widgets, no
puedes simplemente escribir
lo que quieras. Si escribía el menú principal, podría ver el menú principal del widget Vamos a seleccionar
esto para una clase. ¿Qué widget debo crear? Básicamente, esto es lo que significa. También cuenta con dueño. Si tenías un
juego multijugador local, por ejemplo, o incluso en un juego multijugador, puedes mostrar widgets
de otros jugadores. Hay
que especificar qué jugador hace este widget es propiedad, a
quién pertenece. Ahora solo vamos a usar el controlador get
player controller. Esto da una referencia
a nuestro controlador. Ahora no vamos a estar
creando un controlador, vamos a estar usando
el controlador predeterminado. Y como puedes ver,
tiene un índice de jugadores para juegos multijugador locales, puedes especificar al jugador por un índice, muchos métodos. Creamos el widget, ahora cuando creas un widget, en realidad
tienes que
agregarlo a la ventana gráfica Al igual que add on, lo que ve
el jugador, hay un nodo para eso
llamado add to Viewport Pero ya no vamos a
estar usando este nodo. nos lo vamos a
quedar. Vamos a desconectarlo. Me desconecto presionando
Alt y clic izquierdo. Lo que vamos a estar haciendo es
hacer clic derecho
sobre el valor de retorno, que podemos ver que el menú principal tipo G, referencia de objeto. Ahora objeto es un
término grande en programación. Esto se llama programación
orientada a objetos. No vamos a entrar en
informática en este momento. Este valor de retorno vamos
a promover a una variable. ¿Qué es una variable
que alguien podría preguntar? Una variable es algunos datos almacenados. Hay muchos tipos de tipos
de variables. Almacenan datos. Básicamente,
puedes manipular estos datos más tarde y hacer
algo con ellos. Básicamente, la mayoría de las
cosas necesitan ser variables. La mayoría de las cosas con las que
quieres hacer algo. Nombremos nuestra variable
WG en la referencia del menú, porque esto es hacer referencia
al menú del widget Podríamos agregar esto
nuevamente para agregar Viewport. Como puede ver, el
S R codificado por colores. Pero no podemos agregar
el controlador del juego a la ventana gráfica porque este retorno no
nos da valor de retorno Borrar la
referencia del objeto controlador como podemos ver aquí. En realidad menú principal,
widget de referencia de objeto. Podríamos conectar esto aquí. Ahora, como dijimos, queremos agregarlo a Viewport Y la razón por la que no lo estamos
agregando así es porque queremos hacer algunas
otras cosas al mismo tiempo. Por ejemplo, desde el controlador
del reproductor que controla toda la entrada y todo lo que
viene del jugador. Queremos configurar mouse en realidad, voy a copiar y pegar
esto y conectar esto aquí. Voy a traer esto
aquí si estamos mostrando el ratón mientras
estamos jugando o no está controlado por el controlador de
reproducción. Ahora voy a poner esto en
verdad y conectar esto aquí. Ahora sería malo
drogar cables así. Lo que voy a
hacer es que voy a traer aquí de nuestras variables, creamos esta nueva. Voy a traer
esto por aquí. Y si solo suelto mi mouse, voy a conseguir dos
opciones para
configurarlo o para conseguirlo y quiero conseguirlo. Pero para una manera rápida de hacerlo, si estás presionando control, estás obteniendo, si
estás presionando, estás configurando algo. Vamos a eliminar esto
y conectar esto por aquí. Ahora bien, ¿cómo llamo a esta
pieza de código de aquí? Porque si lo conecto
a la línea de ejecución, correrá todos juntos. Se irá ejecución,
ejecución, ejecución. Va a correr esto también. Pero no quiero ejecutarlo
bien cuando comienza el juego. Quiero poder ejecutarlo cuando quiera.
¿Cómo hago eso? Como podemos ver, esta es una obra de teatro, esta es la palabra clave
aquí es la parte del evento. Lo que vamos a estar
creando es un evento personalizado. Si escribo evento personalizado como
puedes verlo, déjame hacerlo de nuevo. Evento personalizado y ver Odd, Evento
personalizado, evento personalizado. Digamos esto. Mostrar menú principal. Voy a conectar esto aquí. Cuando se ejecuta show main menu, hará estas dos cosas. Mostrará el
mouse y
agregará la referencia del menú principal, realidad el menú principal en la ventana gráfica usando la referencia del menú
principal Ahora hay una cosa más. Ayuda al sistema
a definir qué es, qué estamos
controlando ahora mismo, dónde tenemos nuestro enfoque. Como si estuviéramos
centrándonos en el menú principal o en el juego. Ahora mismo, aunque
estemos en el juego, ¿tenemos el foco en un
widget o estamos jugando? ¿A dónde debo enviar
realmente esta entrada que estoy recibiendo? Esto se llama set input. Ahora puedes ver que
hemos establecido el modo de entrada, el modo Juego y el modo I, el juego encendido. Y U solo configuro el modo de entrada yo solo ahora mismo queremos yo solo porque estamos
en el menú principal. Vamos a conectar
esta ejecución aquí, que foco de Widgit. Nos está preguntando, vamos a
poner nuestro Widgit va a hacer
doble clic realmente aquí, crear un nodo de reencaminamiento y hacer doble clic de
nuevo
y nuevo
y Siempre podemos
enderezar las conexiones haciendo clic derecho
desde donde queremos
comenzar la parte de enderezamiento Y seleccione cómo esto no
es recto. Podemos volver a hacer, lo
mismo aquí, esta vez revisa
el nodo de reencaminamiento, todo está
bien, pero a veces
estas cosas Cuando estás codificando,
normalmente no lo haces, luego vienes después
y arreglas todo. Ahora, bloqueo del mouse en modo. Este
modo de bloqueo del mouse tiene que ver con bloquear el mouse en la
ventana gráfica en un widget específico Y necesita un sistema más
intrincado para ser utilizado,
así como entradas de flash Necesita
cosas específicas en la entrada, configuraciones
específicas para ser utilizadas. Ahora mismo vamos
a estar usando esto también. Cuando se ejecute este evento, ejecutará todos los, y agregará nuestro
menú principal a la ventana gráfica Y mostrará nuestro ratón. De hecho vamos a
llamarlo en el evento, comenzar a jugar. Voy a mostrar menú principal. Estamos llamando a esta
función evento. Esta función que está
llamando a este evento. En realidad creo que esta es suficiente
información para ésta. Te voy a ver en
la siguiente. Adiós.
4. Funcionalidad del menú principal: Hola y bienvenidos a Real
Engine Pipe Blueprint. Desarrollo de juegos de
disparos espaciales paso a paso. En la última lección,
dejamos con la
creación del mini sistema show
menu. Y lo llamamos en comenzar a jugar después de que
creamos el widget. Ahora continuemos con ir
a nuestro menú principal de widgets. Como podemos ver, ya hay una diferencia en este widget. Lo tenemos en el menú del widget
titular derecho, podemos ver una diferencia. Esto no se parece en absoluto
a cuando abrimos
este plano El plano del modo de juego
se parece a la mayoría de los planos. Tenemos esta ventana gráfica por
aquí que cerramos aquí. Vemos una cosa diferente
como podemos ver aquí arriba. Es diseñador y gráfico. Si vamos a la gráfica, podemos ver nuestro sistema gráfico, incluso gráfico. Pero tenemos un poco diferente, bueno, el boleto
del evento es en realidad común, pero los otros dos son diferentes. Queremos poner atención
a esto ahora mismo. Vayamos al diseño.
Hablemos del diseñador. Aquí es donde hacemos
los looks de nuestro widget. Cómo se verá el widget. Tenemos un montón de
primitivas por aquí, como componentes de audio, primitivas
comunes, bordes,
botones, un montón de cosas Lo que necesitamos ahora mismo
, a través de esta lista, vamos a buscar
canvas. ¿Qué es una brújula? Un comvass es algo que
nos permite diseñar en función del
tamaño de la pantalla Diseñar nuestras cosas basadas, o un tamaño específico
de la pantalla. Pero ahora mismo tenemos
un comvass de pantalla completa. En este comvass,
vamos a traer botón, voy a dibujar un botón aquí Ya ves puedo colocarlo
donde quiera en la pantalla. Permítanme borrar esto por un segundo. Si solo tuviera un botón es solo un botón puede
definir su tamaño, pero puedo definir en qué parte de
la pantalla quiero que esté. Voy a deshacer esto y tener los cavas para poder
definir la posición En realidad, no quieres un
botón, yo quiero botones, los quiero dentro de la caja
horizontal, vertical,
vertical. Pero el botón no está
dentro de la caja vertical. Siempre puedo traer el
botón no así, sino de aquí dentro de
la caja vertical. Pero también puedo, si
borro este, haga clic
derecho en el botón y
diga envolver con cuadro vertical. Ahora mismo la jerarquía cambió. Botón es la segunda caja
vertical primero. Lo mismo sería si solo rastreara el botón dentro de la caja. Dos formas de hacer una cosa, hay muchas maneras de
hacer algunas cosas. Dos botones, como decíamos, tomando el botón,
copiando el botón, o podríamos ir duplicados, podríamos crear el mismo
efecto que queremos botones tres
botones dentro de aquí. Esto no se verá muy
bien si se trata solo de botones que se pueden ver uno
encima del otro. Vamos a ponerlos fuera de ella. Voy a traernos Pacer.
Vamos a traer un Espaciador. Ahora quiero este espaciador
dentro de la caja, y digamos entre
los dos botones. Pero en realidad vamos a
poner también un espaciador, copiar pegado, y
poner un espaciador arriba Y copiar y pegar de nuevo, y poner un espaciador debajo. Ahora asegúrate de que los espaciadores estén dentro de
la caja vertical. Ahora vamos a nombrar estos botones. Llamemos a esto Juego de Inicio,
Juego de Salir. Le dimos nombres a nuestros patrones, pero esto no quiere decir que
este nombre aparezca por aquí. Para ello, llevemos un texto. Voy a colocarlo
dentro de los botones excavados. Déjalo caer encima del botón. Se mete dentro del botón, puedes ver que dice bloque de
texto bloque de texto Derecha. Ahora, si
vamos a los detalles, todo tiene sus propios detalles. Por aquí, los espaciadores tienen detalles. Caja vertical tiene detalles
sobre el texto de los detalles. Podemos ver por aquí que
dice texto de contenido. Vamos a elegir
esto y decir empezar de nuevo. Mientras que en la siguiente
vamos a decir que ganamos, todavía no
se ven
bastante bien aquí. Tenemos que
decirles cuanto tamaño obtienen en esta
caja vertical, ¿cuál es su tamaño? En este cuadro vertical,
voy a seleccionarlos. Todos ellos. Y. Sin seleccionar el texto. Estoy así que tenemos que cerrar
esta jerarquía y seleccionar la razón es si estamos
seleccionando el texto
al texto tiene diferentes
detalles por aquí. Cuenta con diferentes opciones. No tiene lo común porque está dentro del botón. Si traigo el texto fuera del botón y está
dentro de la caja vertical, tendría los mismos
detalles. Hagámoslo. Ya ves que también tiene
pudín y tamaño. Mismos detalles pero si
lo pongo dentro del botón, el contexto de este detalle
cambia y realmente es una máquina muy cuidada seleccionándolos todos y presionando campo, ya
empezaron a
verse bien espaciados. Lo que tenemos que cambiar
ahora es el tamaño de qué tan grande es la caja vertical, ¿dónde se coloca en nuestra pantalla? Lo que vamos a hacer es que de hecho podemos seleccionar
los anclajes desde aquí Esto es, es una definición
de cómo lo configuramos, relativo al espacio de pantalla, el widget, podemos
definirlo con los puntos, este
símbolo por aquí. Pero también hay una
lista por defecto por aquí que dice, quiero anclarla en la parte superior. Quiero anclarlo en
este lado a pantalla completa. Hay un montón de estados
por defecto. Vamos a usar el del
medio de esta manera. También podemos definir el tamaño de esta caja un poco más fácil. Digamos que el
tamaño x de él es 400 y el tamaño Y es 300. Eso suena genial.
Vamos a posicionarlo. Ahora se ve que está compensado porque nos estábamos
moviendo, yo lo estaba moviendo. Voy a restablecer la posición. Y se puede ver
que su dirección y ubicación original está siendo pivotada desde esta
esquina de aquí En base a esta esquina, queremos
ir a mitad de camino en la dirección x -200 y a la mitad en la dirección
y menos 150 Y ahora tenemos una buena
posición o nuestro widget. Veamos qué hemos
creado hasta ahora,
porque ahora mismo tenemos
una representación visual y en base al código que
hemos escrito por aquí, realidad
deberíamos
ver algo. Porque cuando iniciamos el juego, creamos el widget y lo pondremos en pantalla con el cursor
show mouse. Vamos a completar un paso más. Vamos al
botón Juego rápido. Ahora en los botones, tenemos que hacer
clic es variable primero, así podemos manipular
algunas cosas. Ya ves cuando hago
clic es variable, esta lista apareció por aquí. Las cosas extra en clicked
on, presionado on liberado. Lo vamos a hacer en liberado. Sería una mejor táctica en
este momento para usar liberado. Algo sucede en el
lanzamiento del juego rápido. Para el lanzamiento del juego Quick, acabamos de salir de un juego. Seleccionamos juego rápido, capa específica de
Quit Game. No necesitamos a nadie que esté
jugando, simplemente deje el juego. Vamos a compilar,
ahorrar en nuestro nivel. Juguemos nuestro widget ya está aquí. Iniciar juego, juego rápido. Comienza el juego.
No debería hacer nada más que dejar el juego. Se cierra nuestro juego Entonces funciona. Bien. Creo que
este es un buen punto de parada. Tengamos un descanso
aquí y
continuaremos en la siguiente. Adiós.
5. Conceptos básicos de los planos para los jugadores: En la última lección, nos detuvimos con
la creación de la funcionalidad del juego
rápido y de hecho
probamos nuestra mecánica
para mostrar el widget. Sin embargo, nuestro botón
de inicio del sistema no funciona. Arreglemos esto. Ahora
vamos al modo de juego aquí. A medida que alojamos el programa, código del menú
principal,
albergaremos el código de menú Hyde. Voy a escribir, dar clic y
traer otro evento personalizado. Voy a llamar a
este evento Menú Principal. Ahora lo que queremos que suceda aquí, queremos lo contrario de esto. Queremos mostrar
el cursor del ratón apagado. Queremos establecer la entrada
en el modo de juego. Y queremos eliminar
de Viewport. ¿Cómo hacemos esto? El
primer paso es fácil. Vamos a copiar
el controlador del jugador en vez de verdadero, vamos a convertir
este lingote en falso El siguiente paso
requerirá un nuevo modo. Como demostramos antes, establecer el modo de entrada, yo solo, también
hay un juego de modo
de entrada establecido. cariño, ya que nuestro juego
no tiene ningún widget
que vaya a usar el
enfoque de usuario, esto nos queda bien. Cómo eliminar de Viewport. Ahora, no hay realmente
eliminado de Viewport, hay un remove de parent Voy a tomar nuestra referencia de
widget, voy a copiar pegado aquí, y voy a
escribir eliminar parte Hay otra opción. Había una opción
para establecer estabilidad. Hacemos la visibilidad
oculta o colapsada, lo cual es una
técnica diferente para nuestros fines. Eliminado de padre
está bien. Un detalle importante
a notar sobre esto, o incluso si usamos
la visibilidad, es que nuestra referencia mantendrá
la referencia hasta que se cierre
el modo de juego. Así, estaremos alojando, tendremos la
referencia del widget aunque se elimine
del padre. O establecer su visibilidad
para colapsar de oculto. Además de ocultar el menú principal. Lo siguiente que debemos hacer es crear un evento o una función. Nos quedaremos con
los eventos ahora mismo. Para engendrar al jugador, voy a crear
un evento personalizado y llamarlo Spawn Ahora no vamos a estar archivando esto porque lo
primero que debemos hacer es usar el botón para
llamar a estas funciones. Por aquí,
voy a volver a nuestro menú principal y voy a comprobar es variable
al inicio abajo. De esta manera nuevamente, expongo la funcionalidad
de estos eventos. Y vamos a estar
usando el evento de lanzamiento. Cuando estamos presionando
la partida de inicio, lo que queremos hacer
es engendrar al jugador y ocultar el menú principal Ahora como hacemos esto cuando
estamos en este widget, que no tenemos estas
funciones como si
llamo Ocultar menú principal desde
aquí, no aparecerá. No hay menú principal Ocultar en
la lista. ¿Cómo hago eso? Bueno, ya que estamos
usando el modo de juego. El modo de juego, como dije, es un plano muy específico
contenido dentro del nivel Real nos da un buen nodo
llamado get game mode, pero esto devuelve un tipo de modo de juego
general, como puedes ver, referencia de objeto
basada en modo de juego. Esto devuelve qué
modo de juego está usando este nivel. Pero en un tipo de
referencia que
no podemos usar para
usarlo para compararlo. En realidad, si es nuestro modo de juego necesitamos usar un
nodo llamado casting. Así que vamos a costar al juego
GM GM Space cuando queremos comparar objetos. Si son algo que
usamos, generalmente casting nodos. Hay muchos más
detalles sobre el casting, pero eso no está en
nuestro alcance en este momento. Vamos a conectar
la ejecución y estamos preguntando cuándo empieza el jugador. El juego se está presionando es el modo de
juego, nuestro juego Ode. Sí, vamos
a hacer algo. En realidad no vamos a hacer
nada, no
nos importa si no es
nuestro juego, no hagas nada. Cuando estamos lanzando
al modo juego. Cuáles son los beneficios que
tenemos de esto es que estamos obteniendo algunas acciones
basadas en el modo de juego. Como podríamos llamar acciones
específicas desde el
widget de referencia del menú principal. Por ejemplo, podemos llamar
cosas desde el
propio widget o desde el controlador
del reproductor. Llamamos
cosas específicas para el ratón. Aquí podemos llamar
cosas específicas que hemos creado en nuestra clase de juego espacial
GM. Desde aquí podemos engendrar jugador. Vamos a sacar de
aquí del juego. Ya ve el error
que cometí. Dibujé una línea de la ejecución. La ejecución no sabe con
quién estoy hablando ni de dónde necesito
obtener alguna información. Nuevamente, el tema
sensible al contexto aquí. Bueno, no es un
problema, es por diseño. Si estoy dibujando del juego, voy a escribir Menú principal. Y lo estoy consiguiendo si
lo llamé desde aquí, menú principal. Porque ve dice que esto
pertenece al juego espacial GM. Estoy pinchando,
no conecta esto. Va a dar un error. Dice que esto es, no
sé de dónde es esto. Pero si conectamos esto aquí, también funcionaría. Compilar y guardar. Ahora vamos a
probarlo. Espacio, presione Reproducir. Si presiono Iniciar juego ahora mismo, jugador
spawn
no hará nada, pero el menú principal
debería desaparecer Hago clic aquí, se ha ido. Esta parte también funciona. Con esto, hemos creado una bonita configuración para comenzar nuestro juego. Ahora es el momento de comenzar a
crear nuestro personaje. Vamos a la carpeta Blueprint,
vamos a escribir,
Click e ir a la
clase Blueprint y seleccionar un Ahora, ¿cuál es la diferencia
entre todas estas cosas? ¿Por qué? Antes creamos un
juego de todo tiene una función específica el actor es como la
clase más general que podamos tener. Un peón es algo que podemos
poseer y recibir aportes. Una mejora del peón
sería personaje que sería, incluye la capacidad de caminar Dice porque tiene el componente de movimiento del
personaje, es más para el personaje real. Pero como estamos
usando una nave espacial, vamos a estar usando peón Entonces voy a seleccionar
peón y lo voy a nombrar BP player space Como puedes ver,
tiene un ícono
diferente al modo de juego también. Esto es un Pon, dice. Pero claro puedes poner tus propias miniaturas usando algunas herramientas que
tiene real para tamaño de miniaturas,
pulgar, modo Dd, miniaturas en tiempo
real que
puedes reproducir con
las miniaturas puedes reproducir con
las Abramos la nave espacial. Estamos de vuelta en la visión que
teníamos antes, los widgets. Tenemos una vista, tenemos
un script de construcción, tenemos un gráfico de eventos Eso es. Desde
lo básico vemos tenemos valores predeterminados de clase, ajustes de
clase Ahora hay un montón de cosas
que no dijimos sobre la ventana gráfica y
no vamos a estar usando script de
construcción Estoy cerrando esto. Vamos a estar usando la
vista y la gráfica de bandas. Ahora como este
no es un modo de juego, se
trata de una presentación de
un actor en el mundo. Aquí tendremos que
construir nuestra nave. Aquí es donde vamos
a estar viendo nuestra nave. En este panel de aquí, podemos ver un botón
llamado Componentes. En realidad podemos ver el título Componentes
y un botón agregar. Estos serán una lista
de nuestros componentes. Dentro del plano, lo que contiene
el blueprint
de los componentes Esto puede ser casi cualquier cosa. Como incluso puede ser
otro plano. Se llama plano infantil. Yo creo. Niño, déjame ver. Sí. Lo cual puede ser otro
plano por sí mismo. Pero antes de hacer
eso,
hablemos de una regla que es muy específica para nuestro caso
con el bloqueo de pases. La colisión solo se
ve afectada por la raíz. Si tuviéramos otra
colisión dentro del estanque, no estaría bloqueando
físicamente. Hay muchas formas de evitar
que funcione, pero por defecto no funcionará. Podría registrar calores de
colisión, podría registrar superposiciones de
colisión, pero no bloqueará Lo que vamos a hacer es que
vamos a agregar caja de colisión. Voy a hacer de esta caja de
colisiones nuestra raíz. Lo segundo que
vamos a agregar sería una malla estática que
representará a nuestra nave. Selección de la malla estática. Nuevamente, en
panel de detalles por aquí. Vamos a ir a
malla estática y seleccionar nuestro barco. ¿Cuál nave espacial? Bien, es un poco más grande. Ahora, como hemos seleccionado
como raíz la caja, y no es una
raíz predeterminada n, bajamos la nave. Se puede ver que esta caja no
tiene la extensión, la escala. No tiene
nuestra herramienta de báscula o nuestra herramienta móvil o
una herramienta de rotación. Esto se debe a que
esta es la raíz, este es el plano en sí Déjame llevar esto a la ubicación
original. Vamos a ir
a la ubicación y seleccionar el botón Default por aquí, fue a 000. ¿Cómo hacemos esta caja
tan grande como la nave, donde hay esta extensión de
caja por aquí que vamos a
hacerla un poco más grande. Quizá mucho más grande. ¿Demasiado grande? Creo que está bien. Sí, está bien. Y
voy a hacer más grande de esta manera. Creo que está bien.
También esta talla. Vamos a redondear estos números. 650-65-0540, digamos 190. Ahora bien, esta es nuestra colisión de
bloqueo físico. No quiere decir
que aquí es donde nos vamos a
dañar porque
vamos a especificar el daño que debe
estar en el propio cuerpo. Esto es un poco
más alto, no importa. Podríamos traer el barco
un poco más bajo, pero podría crear
algunos otros problemas. Lo vamos a dejar a los 000. Ahora vamos a compilar y veamos. En realidad, pasemos al
modo de juego en player spawn. Vamos a engendrar,
así es como traemos al mundo a otros
actores Seleccionamos una clase y engendramos a
ese actor en el mundo. Por aquí tenemos una transformación. Si reticamente podemos dividirnos, se
puede ver transformador contiene
tres vectores diferentes La ubicación de la transformación de desove, la rotación y la escala Algunas cosas para colisión y algunas otras opciones que no vamos
a usar ahora mismo. Supongo que de nuevo tenemos una clase
como la hicimos en widgets. Cuál, qué widget
estábamos generando o creando. Vamos a seleccionar a
nuestro jugador aquí, nave nave espacial para transformar Vamos a usar 000. Ya que nuestro mundo está siendo suficiente, Empecemos por el medio. Nos vamos a transformar. Vamos a ver el resultado. Pasamos al nivel espacial,
presionamos play, y si presiono Iniciar juego, en realidad
estamos viendo
algo generado Creo que esto es
suficiente para éste. Es un buen momento para tomar un descanso y vamos
a continuar en el siguiente. Adiós.
6. Mecánica y control de cámaras: Hola y bienvenidos a Unreal
Engine Five Blueprint, paso a paso Space
shooter game Desarrollo En la lección anterior,
dejamos las cosas con observación de nuestro
barco de desove desde adentro Esto sucede porque no
tenemos cámara y no estamos
poseyendo también nuestra nave No estamos diciendo que esta
sea la nave controlada, aquí es desde donde estamos
controlando el juego. Arreglemos estas cosas. Vayamos a nuestra nave espacial en la vista y agreguemos nuestro sprint Un brazo de resorte es un componente agradable
para sostener la cámara. Lo estamos usando como un
boomstick de cámara o
algo así porque tiene este bonito atributo
de longitud de brazo objetivo, lo que aumenta el tamaño del brazo de
resorte vamos a unir
a esta cámara de brazo de resorte Puedes ver la jerarquía aquí. Tenemos el brazo de resorte
como niño es la cámara. Se puede ver un poco
interior que el otro. Tiene este Arno que cuando lo tenemos
cerrado, no muestra Cuando lo tengamos abierto, podemos ver la jerarquía en el brazo de resorte, pongamos algunos valores por defecto. En primer lugar, lo
primero debería ser la longitud de 2000. Esa es una distancia agradable basada
en el tamaño de nuestro barco. Debería ser a la altura 1,000 Vamos a darle una
rotación de menos diez. Vamos a compilar y guardar. Ahora si vamos a jugar
y presiono play, verás que no pasó nada. Mira lo que está pasando.
Agregamos la cámara. ¿Por qué no nos muestra? Bueno, tenemos que poseer esto para
decirle al juego que
este es nuestro jugador. Usa esta cámara básicamente. Al comenzar a jugar.
Voy a Broll, ya que esto es
lo que controla nuestro personaje y tenemos que
decirle al jugador Controller, ¿a quién estamos poseyendo Estamos poseyendo nuestro
propio objetivo ¿es quién? Controlador de jugador que
va a poseer. Player Controller
va a poseer en Po. ¿A quién estamos poseyendo en Po? Vamos a mecanografiar self y vamos a conseguir
una referencia a uno mismo. El controlador del jugador
posee este plano. Vamos a conectar
esta ejecución. Vamos a golpear play. este momento si presiono play
y presiono Iniciar juego, podemos ver que el
problema de la cámara está solucionado. Tenemos algunos avances, pero no está haciendo nada. Hagamos que las cosas sucedan. Hemos poseído al
jugador cuando lo engendramos. Cuando engendramos al jugador, lo hemos poseído. Cuando esto sucede,
el juego de inicio se
dispara cuando éste se genera y al instante se
posee a sí mismo Pasemos a hacer algo
muy sencillo ahora mismo. Empecemos a mirar alrededor
como antes de
movernos, empecemos a mirar a la izquierda, derecha estaba de arriba hacia abajo
y todo. ¿Cómo vamos a
hacer esto? Vamos a necesitar algunos insumos. Ahora, no vamos a estar usando el sistema de entrada mejorado, ya que no vamos
a estar cambiando, vincula, o cambiando claves, ni hacer
ninguna acción complicada. Todo será
en forma digital, no analógica. Esto significa que si presiono
algo, pasa algo y
si solto algo, entonces pasa otra cosa. No tenemos intermedios
de como si tuviéramos un pad de juego que va 0-1
con todos los valores intermedios Esa es una forma analógica de entradas. Ya que tenemos una forma digital, vamos a obtener nuestro mouse,
X, Y. Estas son
entradas estáticas básicamente. Es bueno para probar, es bueno para hacer que las cosas sucedan solo con esta
mente y nada más. Como podemos ver, tiene un valor de retorno y
un nodo de ejecución. Este valor se denomina valor de eje. Ahora estos dos eventos
se disparan constantemente. Constantemente nos están
dando el resultado del movimiento
del ratón X
y el movimiento del ratón. Lo que vamos a
hacer es que vamos a usar estos dos ejes del ratón y los
vamos a utilizar para controlar la
rotación de nuestra nave. Si hacemos clic en la parte superior aquí o hacemos clic en
los valores predeterminados de clase, podemos ir a los valores predeterminados de la
categoría pon y decimos usar rotación del controlador Pitch. Usa la rotación del controlador, necesitamos que los dos estén habilitados. Nuevamente, puedes encontrar esto
desde los valores predeterminados de clase o desde la parte superior de la
jerarquía anterior, realidad la jerarquía
en la puñalada del componente Ahora lo que queremos hacer es
decirle al peón que
cada vez que nos movemos sobre X,
estamos sumando, cuando estamos avanzando en Y,
estamos sumando en Y.
En realidad sumando o
restando en base la dirección
en el
eje que se mueve el ratón Lo que vamos a hacer es
controlar tu entrada. Este es un nodo que solo agrega entrada a la rotación del
controlador. Como dice de
nuevo el genial Tp sobre por qué
vamos a usar la entrada de tono, Ambos nodos
necesitan un valor. Este valor sería
nuestro ratón constante, dando valor, va a
compilar, va a guardar. Pasemos a nuestro nivel,
presione Jugar Iniciar juego. Ahora puedes ver que en realidad
puedo moverme ahora como
puedes decir si lo estás probando al mismo tiempo que la y está invertida. pronósticos incómodos para esto serían, sería multiplicar este,
este valor, este
valor del eje y con menos uno Ahora nos da un valor
opuesto. Otra cosa es que
fue un poco demasiado rápido. Lo que podemos hacer es
multiplicar nuevo con otro número, y hacerlo también en la x
Lo que hice fue copiar el nodo de
multiplicación y pegarlo. Lo que hice fue copiar el nodo de
multiplicación y pegarlo Voy a conectar esto
aquí. Conecta esto aquí. Voy a establecer
los valores a 0.05 0.5 Es la mitad
del valor original. Tendríamos juego de media
sensibilidad. Ahora la sensibilidad,
como pueden ver, se ha bajado
mucho y hemos fijado la rotación invertida. Ahora la cámara está un
poco adelantada. Creo que tal vez
deberíamos colocarlo un
poco más al revés. O vamos a colocarlo un
poco más al revés. Vamos a inclinar también el menos diez. Además del ángulo
del brazo, la cámara obtiene una rotación extra
menos diez. Esta zona se ve mucho mejor. Estamos rotando, en realidad podemos ver el mundo ahora claro, si giras hacia arriba, puedes ver que
hay un bloqueo de cardán, como se le llama, eso está
impidiendo un giro de 360 Pero eso es beneficioso
porque sería muy fácil ir al turno completo. Esto hará que el
jugador sea muy fácil. Creo que esto es para éste. Te voy a
ver en la siguiente. Adiós.
7. Descripción general del movimiento de los personajes: Hola y bienvenidos de nuevo
al motor real Five. Desarrollo de juegos de
disparos espaciales paso a paso. En la lección anterior,
terminamos con
la creación de la rotación del personaje
donde miramos solos. Agregamos el boomstick de la cámara
y la cámara e
hicimos, nos permitimos
ver nuestra nave finalmente en un ángulo correcto Ahora en esta vamos a estar agregando algo de
movimiento a nuestra nave. Pero antes de hacer eso, déjame traer pintura y
garabar algunas explicaciones En primer lugar, ¿cómo vamos a estar moviendo nuestro personaje? Podríamos estar estableciendo la ubicación de nuestro
actor, esto es ubicaciones. Podríamos estar estableciendo
nuestra ubicación más o menos alguna distancia. Y podríamos estar moviendo
al personaje de esta manera. No vamos
a estar haciendo esto. Lo que en cambio vamos a estar haciendo es que
vamos a estar usando, en realidad volvamos a
un proyecto por un segundo. En los componentes, hay un
componente con comportamiento para nosotros ya hecho con
un de cosas extra. Se llama carga en movimiento, pont
flotante, movimiento. Como podemos ver, tiene
valores de aceleración, velocidad y valores de variables y atributos
para jugar con. No vamos a estar
usando la mayoría de ellos, pero es un sistema bastante agradable para controlar ponts que están
flotando en el espacio, por ejemplo Como puedes ver,
aquí
hay una descripción completa con más información. Ahora volvamos a nuestros duales con este componente de
movimiento flotante Digamos que tenemos nuestra nave aquí. Esto es, nuestro barco, No lo parece, pero lo es. Tenemos un movimiento hacia adelante. Movimiento hacia atrás, digamos recto desde la izquierda, desde la derecha. También tendremos un movimiento
de arriba y abajo. Esta sería nuestra W,
Esta sería nuestra A. Esto sería, esto
sería D, para arriba. Vamos a estar usando
la barra espaciadora y para abajo vamos a estar
usando el botón de control. Otra cosa.
Si estamos en el espacio y tenemos una nave espacial y
estamos avanzando hacia adelante, y al mismo tiempo estamos presionando hacia atrás No deberíamos movernos. Lo mismo debería
suceder cuando estamos presionando hacia la izquierda y hacia derecha al mismo tiempo cuando
ambos están activos Cuando ambos están inactivos, la velocidad en este eje debe ser cero y la
misma en este. En realidad, esto sería
mejor para mostrarlo en código. Creo que tendría un
poco más de sentido. Comencemos nuestra codificación. Contamos con nuestro componente
móvil flotante. Voy a traerlo al lado este espeso evento porque nuestro
movimiento va a estar sucediendo. Deberíamos comprobar que nuestro
movimiento se está moviendo. ¿No nos movemos
así debería suceder cada fotograma del componente de movimiento
flotante, vamos a arrastrar entrada. Esto nos dará nuestro movimiento. Ahora bien, si lo dejamos en
cero, no va a hacer nada. Pero hagamos un ejemplo. Si ponemos 100 en
X y presionamos play, entonces voy a
expulsar para mostrarlo. Podemos ver que
nuestra nave espacial es películas cómo hice esto ahora mismo. Si presionas hacia fuera y
estás expulsando en la ventana gráfica y tienes esta cámara gratuita
para ver tu mundo Si presiono play, mira no
estoy poseyendo el personaje porque me
expulsan del Puedo navegar por ahí y ver qué está pasando sin jugar
realmente. Como podemos ver, si
pongo 100 en X, se mueve hacia X
con una velocidad de 100. Ahora aquí es donde las cosas comenzarán a ponerse
un poco complejas. Pero antes
de hacer lo complejo, podría haberte asustado un
poco, pero está bien. Vamos a
explicar todo. Antes de llegar a
las cosas complejas, hagamos algunas entradas, como hicimos para mousex y mousey Vamos a
llamar al teclado, vamos a
llamar al teclado, tengo que encontrarlo. Aquí está. Y vamos a traer un teclado y la pizarra. Y vamos a necesitar
también marca de espacio y en teclado, control izquierdo. Espero que cortes toda
la búsqueda. Trajimos nuestro teclado izquierdo. Empecemos a hacer
algunas variables para decir si está presionada
o si no está presionada. Vamos a estar
usando lingotes. Para ello, vamos
a necesitar 123456 lingotes. Esa no es la mejor manera, pero es la forma en que
vamos a estar en esta. Voy a hacer 12345. Voy a nombrar el primero. A se presiona, se presiona, lo siento, se presiona D, voy a tener W's. Y eso es descanso y espacio. Es descanso. Una más, sólo
copié pegada y me fui Bien, algunos tienen capital, No. Déjame arreglarlo muy rápido. Traamos nuestras variables
aquí con setters. Voy a arrastrar y soltar con al presionar y estamos
consiguiendo setters. El uno es verdadero, el
otro es falso. Creo que podemos copiar y pegar esto. Ya que hemos creado
las variables aquí, en realidad
podemos enderezar una variable y
reemplazar la referencia W. Rápido y fácil, podemos hacer todas estas conexiones, teniendo en cuenta
que cuando se presiona es sí. Cuando no se presiona es no. Vamos a
sustituir esto por. Reemplazar esto con también vamos a hacer D repeticiones. Vamos a hacer lo mismo con la barra espaciadora y vamos a hacer lo
mismo para el control. En este momento tenemos nuestros insumos hechos fácilmente
para probar nuestra mecánica. Envolvamos todo esto un
poco más y pongamos un comentario Entradas
configurando entradas Grapas. Vamos a dar
click en Mostrar Burbuja, para que podamos verla desde muy lejos, lo que hace este código de aquí. Volvamos a
las cosas complejas. Pero sabes qué, creo que esto necesita
un poco de más análisis para ser explicado. Esto es para éste. Te voy a
ver en la siguiente. Adiós.
8. Desarrollo de funciones de movimiento: Hola y bienvenidos a Real Engine Five Blueprint Paso a Paso Space Shooter
Game Development En la lección anterior, dejamos con decir que vamos a dejar la parte
aterradora para esta lección. Agregamos algunas entradas. Dijimos que vamos a estar explicando las
matemáticas aterradoras por aquí, lo que en realidad no
da tanto miedo, para ser honesto. Déjenme volver a traer pintura. Lo que vamos a
hacer es, como dijimos, esta es una dirección
hacia adelante, hacia atrás. La dirección arriba y abajo,
la dirección izquierda, derecha. Este es un vector, en realidad tenemos un vector de
tres o dos puntos. Un punto matemático, bueno, básicamente en real es una
colección de tres números. Eso es básicamente
lo que es, cómo lo usamos. Hay muchas maneras de
usar tres números. Digamos que la x de
nuestro vector es la W, Digamos que el cable de
nuestro vector es a y D, y la z de nuestro
espacio vectorial, par y control. Vamos a estar calculando
cada uno de ellos por separado. Entonces vamos a estar sumando
todos estos a un vector para obtener la dirección total de nuestro movimiento,
nuestra velocidad total. Si estamos, digamos en uno aquí, y estamos avanzando
menos uno aquí,
y esto es cero, y esto es cero, entonces nos estamos moviendo diagonalmente hacia esta dirección,
uno menos uno Vamos a esta acción. En realidad,
sigamos con la acción. A veces estos ejemplos
son mejores en acción si
sumamos todas estas preguntas matemáticas y que estamos teniendo. Si nos estamos moviendo
hacia arriba, hacia atrás ,
hacia abajo aquí, vamos
a estar creando un desastre. Lo que vamos a hacer es que vamos a
crear una función. Ahora bien, ¿cuál es la diferencia entre una función y un evento? Hay muchas diferencias. Una de las
diferencias más prácticas sería que funciones no pueden hacer cosas de
tiempo como
no podemos hacer un retraso
dentro de una función. No existe tal. Podemos fijar el retraso
a otras cosas. Esto es cosas mucho más
complejas, pero en eventos normales
podemos hacer retrasos, retrasar esta cantidad de tiempo
antes de que sigas adelante. Podemos jugar con el tiempo básicamente, mientras que en las funciones esto es casi imposible de lograr. Se pueden tener muchas funciones
y retrasos entre ellos. Pero dentro de la función no
hay algo que se
pueda hacer fácilmente. Todo estará en
esta función también, esta función
será una función pura. Lo que esto significa, permítame
deshacer clic en esto por un segundo. Si voy a llamar a
esta función por aquí, vas a
arrastrar y soltar. Aquí podemos ver que tiene
una línea de ejecución. Esto, eso se llama hablar, jugar, jugar, correr
y comenzar a jugar. Se está ejecutando después de este evento. Después de esta función, ejecutará esta función y seguirá haciendo
otras cosas si la tenemos
como una función pura. Se puede ver que es muy
similar a esto. Nos da un resultado ahora mismo. No lo hemos dado para decirnos. Hagamos esto en salidas
cuando estemos seleccionando la función interna
o externamente. Déjame volver a
la gráfica desde aquí. Desde dentro de la función, podemos ver que hay entradas
y salidas de manera efectiva. Además en la salida, crea órdenes y
conecta en realidad, la línea de ejecución,
un nodo de retorno. Ahora podemos ver que hay un nuevo parámetro
como nodo de retorno, como salida en esta función. Esto puede considerarse
como una caja negra. Algo pasa por dentro
y solo obtenemos un resultado. Vamos a traer
esta función por aquí. Vamos adentro. Vamos a nombrar esta función.
Llamemos a este movimiento matemáticas. El nodo de retorno. Necesitamos
tenerlo no como lingotes, sino como vector Porque el vector es lo que
vamos a conectar aquí. Para conectar esto aquí, vamos a nombrar este vector también al movimiento. Había movimiento, magnitud, tal vez, porque
en realidad vamos a poner aquí también la velocidad. Estoy mal, no
vamos a estar poniendo la
velocidad aquí porque nuestra velocidad está controlada por nuestro componente de
movimiento flotante. No estamos haciendo una ubicación establecida, estamos usando el componente
móvil flotante. Vamos a necesitar
tres nuevas variables. Vamos a tener 123. Van a ser
del tipo vector. Si lo hice muy rápido, puede hacer clic en un tipo de variable y cambiar el tipo de variable. O puedes hacerlo desde
este panel de aquí. Y seleccione el
tipo de variable aquí. Nombremos estas variables.
Nombrémosle este. Adelante hacia atrás. Esto será L R, ¿verdad? Esto sería de arriba abajo. Este resultado sería que esta dirección de movimiento sería el resultado de sumar
tres vectores. Otra forma que podríamos haberlo
hecho es que cada uno de ellos sea un entero o un flotador. Estaríamos agregando
cada uno por separado, pero una adición de vectores
es lo mismo. Voy a conectar esto aquí ahora tenemos que poblar
el spector Los voy a traer
con Alt para ponerlos. Pongámoslos en orden. Realmente no
importa el orden, porque esta adición
ocurre instantáneamente En realidad, sucede después de que
hayamos calculado todo esto. Realmente no importa
en qué orden hagamos esto. Bien, necesitamos algo de espacio. Bien, comencemos
con B. voy a traer y se pone una condición y lingotes Esto quiere decir que si
ambos son verdaderos, si ambos son falsos, si uno de ellos es verdadero
y el otro no lo es, entonces esto devuelve falso. Ambos tienen que ser fieles,
para darnos un verdadero resultado. En cualquier otro caso, esto nos
daría un resultado negativo. Queremos lo contrario
de esto también. Vamos a copiar y pegar esto
y poner delante de ellos. ¿Qué significa esto?
Esto quiere decir que si esto es sí convertir un no, esto es un no,
conviértelo en un sí. Voy a traer el final también. Ahora fíjate que pongo el nudo, el reverso de los
lingotes, antes del final Porque digamos por ejemplo, si lo pongo después del final, no me daría
los mismos resultados. Por ejemplo, si W era
verdadero y no lo era, esto devolvería un negativo. Y poner el nudo aquí lo
haría positivo, pero debería haber
sido negativo. Esta es la razón por la que
solo invertimos las dos. Entonces estamos agregando
el final porque las operaciones lógicas
cambiarían el resultado. Este tipo de comprobaciones se
denominan puertas lógicas. Es un gran capítulo
sobre cómo usarlos, cuáles son los
usos más comunes y todo. Es parte de la informática, es algo muy interesante. Ahora mismo tenemos
nuestras dos condiciones. Tenemos dos condiciones. Nuestra primera condición dice, ¿se presiona WNS al mismo tiempo? Y la segunda
condición en realidad es decir ¿WNS no está
presionado en absoluto? No se presiona nada de ellos. Si es uno de los otros, deberíamos hacer algo
que voy a llamar puerta lógica, puerta lógica. Esto significa que si esto es cierto o
esto es cierto, haz algo. ¿Qué vamos a hacer con
esta pregunta de aquí? Porque esta es una pregunta de
complejidad agradable, pero no demasiado compleja, pero no
es solo un lingote Vamos a estar seleccionando un
resultado para nuestra dirección B. Voy a arrastrar desde
la dirección B y escribir select. Como puedes ver,
tenemos dos opciones. Seleccione plano y seleccione vector. Ambos son iguales. La diferencia es que
si elijo seleccionar, me da un comodín aquí. Porque tal vez quiera seleccionar en
función de algo
diferente a un lingote Podría querer seleccionar
en función de un entero. Podría querer seleccionar
en función de la enumeración. Select se puede utilizar con
diferentes condiciones. Además, si conecto el
resultado del O aquí, automáticamente cambiará
el comodín a un lingote Ahora bien, si esta condición es cierta
por alguna de estas razones, nuestra dirección debería permanecer cero. Debería permanecer cero en la dirección F B porque podríamos estar
presionando en otra cosa. Si es cierto, es cero. Si no es cierto,
vamos a seleccionar de nuevo. Esta vez voy
a usar el
vector select y se puede ver que tiene pick a toma en mente
que este pick a, verdadero está aquí,
lo falso está aquí, mientras que aquí es lo contrario. Falso está aquí,
donde la verdad está aquí. Dicho esto, llevemos
esto un poco al revés. Vamos se presiona. No necesitamos
preguntar si se presiona, porque si hemos pasado
este cheque por aquí, entonces solo nos importa una de
las otras dos direcciones. Si esto es cierto, entonces
vamos a seguir adelante. Si esto no lo es, esto es cierto, vamos a estar
retrocediendo. Si esto no es cierto, vamos a seguir
adelante. Ahora, necesito explicarme
algunas cosas más. Esta es una oportunidad maravillosa
para explicar la dirección mundial versus local.
Vamos a explicarlo. Ahora, dijimos que ahora tenemos un movimiento
hacia adelante, di un ejemplo de uno
menos uno en nuestro plano Contamos con un sistema de coordenadas. Por ejemplo, cuando
colocamos la cámara, el resorte de la cámara, dijimos que va a
ir 1,000 en el eje Z. Bueno, este 1,000 se basa en el centro de nuestro plano
en su propio sistema de coordenadas Pero cuando estamos en el mundo, este sistema de coordenadas no
es lo mismo. El mundo tiene su propia ubicación. Es relativo al mundo y
relativo al plano. El relativo al plano, lo
estamos llamando la ubicación
relativa Y la otra es
la palabra ubicación. Existe esta diferencia
entre estos dos. No queremos estar agregando más una dirección hacia
el eje x o y. Cualquiera que sea lo que consideremos adelante
dentro del plano, queremos estar sumando el
forward basado en el Unreal nos ha proporcionado
una función solo para esto. Se llama get at
forward vector. Tenemos a nuestros actores
adelante vector. Esto quiere decir que si no
estamos presionando a S, deberíamos estar avanzando. Si estamos presionando,
deberíamos estar retrocediendo. Para ello, sólo vamos a multiplicar por menos uno
para negar el valor Como puedes ver aquí, tenemos vector multiplicado
por vector porque si una multiplicación de tipo nos
da esto por defecto No se preocupe. Podemos cambiarlo nos ha dado este sistema también. Que podemos cambiar
esto desde aquí haciendo clic
derecho y seleccionando
el tipo que sea compatible. Vamos a seleccionar
entero y hacer un menos uno. Y conecta esto aquí. El avance y
retroceso debe estar listo. Ahora mismo, si vamos a jugar, no
estoy viendo ningún movimiento. Vamos a averiguar por qué es esto. Creo que tenemos que conectar la matemática de movimiento con
el factor de entrada. Si juego ahora, juego de
cresta, en realidad estamos, pero hay un poquito, nos estamos moviendo demasiado lentos
para que este fondo pueda decir
que nos estamos moviendo. Pero cómo podemos probarlo, en realidad
podemos ir
dentro de la boca. Podemos conectar
digamos el vector hacia delante en
dirección F B compilar. Vamos a presionar play de nuevo. Si podemos ver que se mueve. Si conectamos el
menos a
la dirección B, lo opuesto al delantero, volvemos a jugar y estamos rechazando y
se está moviendo hacia atrás Sí, nuestra nave se está moviendo. Simplemente no lo podemos ver todavía. Bien, voy a
compilar y guardar. Creo que esto es
suficiente información. En las próximas lecciones,
vamos a completar los otros
dos movimientos. Te voy a ver en
la siguiente. Adiós.
9. Visualiza el movimiento con rastros de partículas: Hola y bienvenidos de nuevo
a un motor cinco, paso a paso desarrollo de juegos de
disparos espaciales. En la última lección, dejamos con la creación del movimiento de
ida y vuelta, que fue la parte difícil de
explicar lo que estamos haciendo. En esta lección,
vamos a estar completando el siguiente en
el movimiento de izquierda a derecha
y al movimiento de la zona alta, pero va a ser muy fácil Sólo estamos pegando esta
lógica por aquí. Comencemos con esta copia y peguemos esta lógica por aquí. Voy a conectar
esto con L R, y vamos a estar cambiando nuestras W y S por A's y D's. Vamos a estar reemplazando
todo por A
y D. Esto realmente no importa el orden aquí porque va a
ser el mismo resultado. Vamos a estar
cambiando esto también a D, podría revertirse. Ahora la única diferencia es que en lugar de usar el vector
actor forward, vamos a estar usando
el vector correcto. Si esto se presiona, creo que esto es opuesto. Vamos a
comprobarlo ahora mismo. En realidad, ¿sabes qué?
Necesitamos tener un sistema, algo visual para ver
que nos estamos moviendo. Creo que es momento de
agregar algunas partículas. Volvamos a nuestra vista
y seleccionemos
nuestra malla estática Necesitamos dos niños para
meter dos partículas. Vamos a,
vamos a agregar cascada porque estas partículas del viejo sistema de cascada. Vamos a duplicar esto. Vamos a llamar al
primero rastro que queda. Y voy a
arrastrarlo desde el lado izquierdo. En realidad, pongamos
el otro, bien. Voy a seleccionar de nuevo
el sendero a la izquierda, voy a moverlo justo
al borde de esta ala, tal vez un poquito
dentro del ala. Cuando la partícula
se está poniendo a cero, no muestra tanto No es donde lo quiero
y un poquito por dentro. Sí, creo que eso es perfecto en todos los lados
que puedo verlo ahora, para el camino correcto. Voy a copiar
esta ubicación por aquí. Selecciona el
sendero correcto y pegarlo. Ya que estamos
hablando del eje Y, sólo
voy a seguir en estos
momentos. Debido a que he seleccionado
el rastro aquí, automáticamente
agregó y también nombró el componente a la partícula
que había seleccionado. Esto es algo que lo
real hace si estás seleccionando
lo correcto y lo estás agregando, automáticamente crea la referencia
aunque sea una malla. Si es un
sonido de partículas o lo que sea. Ya que tenemos la ubicación copiada antes de que
podamos pegar
realmente, copio y pegar otra cosa. Tengo que rehacer esto. Podría haber
presionado rápidamente deshacer muchas veces y hacerlo así
y copiar y pegar la ubicación. Pero a veces los
choques irreales cuando estás haciendo múltiples acciones de deshacer
se pueden hacer con un
poco de moderación No lo sobreaprietes. Esperar a
que se completen las acciones. Coloco el tráiler
en el lugar correcto. Copiar, colocar la ubicación, quitar el menos el rastro
fue al otro lugar. Ahora mismo, si presionamos sí, tenemos senderos, tenemos senderos. Podemos ver que nos estamos moviendo. Podemos ver que nos estamos
moviendo. Eso es genial. Pero A y D se invierte como sospechaba.
Vamos a cambiar. Esto se presiona a A se presiona y presiona
Inicio. Es correcto. Genial. Tenemos movimiento.
También rastreos. Ahora ves que el rastro se
está manchado un poco. Esto está sucediendo
debido al desenfoque de movimiento. Si vamos a Configuración del proyecto,
es Configuración del proyecto,
tecleamos desenfoque de movimiento
en Configuración predeterminada, Motion Blair Engine Rendering,
y eliminamos esto Auto guarda, no
guardamos nada, simplemente lo
cerramos y guarda
la configuración y pulsamos play. Ahora mismo podemos
ver que nuestros senderos no
son tan brumosos como
antes Genial, ahora sigamos con la
adición de las entradas del eje z. Voy a copiar esta
base otra vez. Voy a conectar esto aquí. Voy a cambiar este espacio. Y este control estamos, vamos a hacer esto aquí. Yo
controlo, creo que en vez de
vector derecho o vector delantero, vamos a conseguir un vector. Ahora bien, lo real nos da sólo
una dirección en su eje. Cuando nos da la derecha,
no nos da la izquierda. Cuando nos da el delantero, no
nos da el revés. Es muy fácil crearlo. Si tienes uno, solo
te niegas y
obtienes lo contrario Aquí vamos a
estar usando el vector acup para el espacio del eje.
Y dejó el control. Vamos a probar esto. Presiona control Z, baja. Si presiono espacio, sube. Tenemos un buen
movimiento por aquí. Creo que esto es para éste. Te voy a
ver en la próxima. Adiós.
10. Animación y control de barcos: Hola y bienvenidos de nuevo a
Real Engine Five Blueprints, desarrollo de juegos de
disparos espaciales
paso En la última lección,
terminamos con nuestro movimiento. En esta, empecemos a hacer nuestro movimiento un
poco más interesante, un poco más animado. Lo que vamos a hacer en
este es que vamos a estar rotando el barco un
poco hacia este lado, un poco hacia este
lado mientras nos movemos. Hagámoslo. Lo primero que debemos hacer
es almacenar la rotación de nuestras naves. Cuando me refiero a rotación, la rotación
relativa
dentro del plano Esta es otra
razón por la que no
usamos la nave para un
colisionador base o una raíz Lo teníamos como componente. Una mejor práctica sería
tenerla también como actor infantil, a lo mejor
que
tendría su propia colisión y no tendría esta caja de
colisiones por aquí. Pero por ahora va a
servir bien a nuestros propósitos. Vamos a almacenar nuestra
rotación de nuestra nave. Queremos que esto esté sucediendo al principio del juego cuando
iniciemos el juego. Almacena la variable. Vamos a conseguir
la malla estática, y vamos a conseguir la rotación. Esto podría ir en el guión de
construcción, también por si acaso se
presiona el momento en
que toma algún movimiento o algo
gira la nave. Pero aquí está bien. Ahora mismo vamos a promover esta rotación relativa a una variable y
conectarla aquí. También nombró a la variable
para nosotros, pero vamos a poner, vamos a cambiar el nombre de esto para que original capitalice la rotación relativa
del cuerpo original Nombremos nuestra medida estática, la medida estática del cuerpo. Voy a ponerle nombre a este cuerpo. Ya terminamos con esto. Ahora bien, ¿cómo vamos
a lograr esto? Nuevamente, vamos a
estar usando el tickivent. Vamos a estar
haciendo algunas preguntas similares a ésta, en una similar, las mismas
preguntas en un modo diferente. Pero antes de empezar a
hacer preguntas, pongamos aquí una secuencia. La secuencia es un nodo muy especial. Nos ayuda a mantener el código
también un poco más organizado. Estamos haciendo esto,
estamos haciendo eso, estamos haciendo la otra cosa. Pero no dejes que el
nombre te confunda. No quiere decir que vaya
a esperar para terminar esta acción. Digamos que tenemos un
montón de acciones en el cero y luego tenemos un
montón de acciones en entonces una. No esperaría a terminar
las acciones en entonces cero. Se dispararía entonces
uno sólo en una orden. Pero lo más probable es que esté sucediendo
instantáneamente, no significa que los
disparará en orden. Pero instantáneamente no espera a
que
termine
la línea de ejecución y luego dispara
la segunda El tercero, el cuarto, simplemente dispara uno
tras otro. Para ello, vamos
a necesitar algo, como decíamos, no
deberíamos colocar todo
en la gráfica de eventos. Deberíamos crear una
función para esto. Voy a crear una función. Llámalo rotar recto. No sé si
es cuando es recto. Sí, vamos, vamos a explicar las cosas con nuestros nombres de funciones. Aquí mismo, vamos a
necesitar estas reglas por aquí. Y D reglas, estos son los botones que
estamos usando para guardar ahora. No vamos a
estar usando un select, vamos a estar
usando una rama aquí. Esta es una declaración if. Si esto, haz eso, si el otro, el otro, voy a conectar la condición y conectar
la rama por aquí. Tenemos la misma
condición si no estamos, básicamente, si no nos movemos, si ambos están presionados o ninguno de ellos está presionado, no
nos estamos moviendo, es verdad, esta condición no vuelve
verdadera, entonces es falsa, y estamos probando en qué
dirección nos estamos moviendo. Ahora el nodo que
vamos a estar necesitando para completar esta acción va a
ser relativo al cuerpo. También va a ser relativo en la rotación del
plano, no del mundo Vamos a poner
conjunto de rotación relativa porque estamos moviendo el cuerpo
relativo al plano, no relativo al mundo que voy a conectar
por aquí Mueve esto un poco hacia arriba. Ahora cuando dije que
no se puede poner tiempo cosas en una función y decir que es
un poco más compleja, vamos a demostrar esto. Ahora hay una no llamada R inter, hay R interpretar dos
y R interpretar constante, que significa interpolación ¿Qué es una interpolación? Una interpolación es una
función que determina los valores desconocidos entre dos datos
conocidos para conocer puntos En definitiva, permítanme traer
la interpolación. Tenemos una rotación actual y una rotación objetivo basada
en una velocidad y tiempo. Obtenemos el resultado entre
estos dos puntos. Por ejemplo, para nuestra corriente, vamos a usar get rotation,
nuestra rotación actual como lo que es la rotación
relativa actual de
este cuerpo, ya que no estamos presionando nada en este momento
en este escenario, la condición es que
no estamos presionando nada. El objetivo debe ser la rotación
original del cuerpo. Como pueden ver, en estos momentos estamos haciendo algo basado en el
tiempo. Dentro de una función delta time es la tasa de cambio
entre fotogramas. Eso podría no decir mucho. Si lo multiplicamos por, digamos por ejemplo,
un valor de velocidad, hace que nuestro movimiento
sea
irrelevante para el tiempo delta Pero no vamos a llamar a esto en lo profundo, solo
vamos a estar usando
los segundos delta mundiales, que es la tasa de cambio
entre cada fotograma del mundo Para
la velocidad de
interpolación, cuanto mayor sea
la velocidad, más lenta será esta tasa
de cambio. Este
resultado de interpolación será. Ahora mismo vamos
a poner una velocidad de uno. Vamos a pasar
al falso puñetazo. Esto se mantendrá
casi exactamente igual con un cambio
de lo que es nuestro objetivo. Vamos a eliminar esto. En realidad, no
voy a borrar esto, sólo
voy a desconectarlo. Porque lo que queremos hacer es que la rotación original le dé
un rango en izquierda y derecha. Voy a combinar
dos rotadores, uno para la izquierda y
otro para el derecho La combinación, la B, que estoy agregando
debe tener una selección. Estoy combinando el original
con más el desplazamiento de la derecha o más el desplazamiento
de la izquierda basado en una regla. La regla será, si A se presiona ahora sólo tenemos que hacer
es dar el offset. Para calcular el desplazamiento, vamos a utilizar la rotación del cuerpo
original. Voy a copiar y
pegarlo por aquí. Y voy a combinar, voy a copiar otra vez. Voy a combinar con
digamos 15 y -15 Ya que se está presionando A, en realidad esto debería estar
arriba, debería estar arriba. Y ve a A. Y esto debería ir aquí, la rotación original. Lo estamos compensando con
15 grados en cada lado. Si se presiona A, estamos sumando a la rotación
relativa, esa cantidad basada en la corriente, obtenemos una nueva rotación. Combinemos y guardemos. Empecemos. Y no pasa nada porque supongo que no
he llamado a esta función Voy a llamar a esta
función por aquí, la pila, guardar, presionar play. Está funcionando. Estamos teniendo la nave moviéndose izquierda e inclinándose hacia la izquierda Moviéndose a la derecha e
inclinando hacia la derecha. Cuando dejamos todo,
vuelve a estar en posición. Ahora mismo nuestro movimiento se volvió
un poco más animado. Tenemos una animación ahora. Lo único que
no me gusta mucho es que cuando estoy inmóvil, puedo ver si
no me estoy moviendo para nada, puedo ver estas líneas A algunos le puede resultar aceptable, pero tampoco me gusta mucho lo
visual. Desactivemos eso. Volvamos a la gráfica. Vamos, vamos a obtener la velocidad
del actor si nuestro
actor no se mueve, trae aquí una rama
si no se mueve, porque esto
nos da la velocidad. Si no se mueve, es cero
si el tor no se mueve. Consigamos los dos senderos y setibilidad los conecta a ambos Este nodo puede tomar
más de un objetivo. Vamos a conectarlo. En realidad, no
necesitamos una sucursal aquí. Podemos simplemente bullying aquí. Si esto es cero, entonces
no nos estamos moviendo, es contrario. Entonces es invisible, no se mueve. En realidad, si se mueve,
entonces es visible. Voy a conectar esto aquí, y esto está listo. Voy a presionar Start. Estoy rotando. Sin líneas. Me estoy moviendo. Tengo líneas. Genial. Creo que esto es para éste. Te voy a
ver en la próxima. Adiós.
11. Introducción al sistema Stamina: Hola y bienvenidos de nuevo a
Unreal Engine Five Blueprints, desarrollo juegos de
disparos espaciales
paso a paso En el último video,
dejamos con la creación algunas animaciones
para nuestra nave espacial Giramos a la izquierda y a la derecha
cuando estamos estrafando. Golpeamos la visibilidad de los senderos cuando no
nos movemos. Por supuesto, si quieres, puedes desconectar esto y
los senderos
serán visibles siempre en éste. Vamos a crear algunas mecánicas de
movimiento más. Lo que vamos a crear es un sistema de gestión de resistencia y un
sistema de sprint ¿Cómo lo demostramos
en un espacio sin fin? Porque si no tienes referencia de puntos y es
solo espacio vacío, realmente
puedes decir con
qué velocidad vas. Déjame dibujar mi, nuestra
nave espacial otra vez. Digamos que volveré a hacerlo
como un avión, porque eso es lo
único que puedo dibujar. Bueno, la lata es una enorme
sobreestimación de mis habilidades. Digamos que este
es un espacio y tiene propulsores aquí, aquí y aquí Lo que haremos es
usar una partícula. Que cuando estamos corriendo, cuando estamos impulsando o metro,
o cualquier uso del espacio, hará
que las
partículas parezcan más grandes También jugaremos con el
campo de visión de la cámara. Al igual que si nuestra cámara está por aquí y tiene este campo de visión, la
vamos a aumentar
un poco. Parecerá que
estamos esprintando. Como si nos estuviéramos moviendo más rápido. ¿Cómo vamos a
estar logrando esto? Ahora traemos una nueva
capa, oculta esto. Usaremos un nuevo insumo
que llamaremos sprint. En realidad, no vamos
a llamarlo de nada. El turno a la izquierda,
esto es a la izquierda ****, este es turno a la izquierda que cuando lo
presionemos habilitará, bueno, déjame teclear
mejor, habilitar sprint. Y vamos a desactivar el sprint cuando estas
acciones estén sucediendo. Vamos a estar
usando una línea de tiempo. Línea de tiempo, ¿Cuál
es la línea de tiempo? Es una manera de realizar manipulaciones
centradas en el tiempo a los actores que
están en escena Básicamente lo que hacemos es correcto, la forma en que lo vamos a
usar es usando una curva con un eje de tiempo
y un eje de valores. La línea de tiempo nos
dará los datos, la salida del valor
basado en la curva que
vamos a crear. En realidad, no va a ser una curva. Creo que esta vez
será sólo una cosa lineal basada en ese punto que nuestra
línea de tiempo nos dará eso. Como ahora está en 0.25 el
valor es 0.2 por ejemplo. Esto nos va a dar en base al tiempo. Con base en este valor,
aumentaremos el tamaño de las llamas y el campo de
visión de la cámara. Ahora además de eso, tendremos un sistema que estará usando
un temporizador. ¿Qué es un temporizador? Un temporizador es uno de los mejores
sistemas que ofrece un real para activar
partes específicas de frío a la vez. Pero no se basa en thick, porque grueso corre muchas
veces por temporizadores de cuadro, podemos especificar que
corre como 0.1 eso es par, corre diez veces por segundo. Mientras que tenemos,
digamos por ejemplo, 60 FPS, corre 60
veces por segundo. Ejecutar algo
tantas veces menos, en
realidad está creando
un rendimiento enorme. Bueno, para no impactar
lo contrario del impacto, porque si se estaba
ejecutando en la garrapata, eso va a estar causando
un impacto en el rendimiento. Si se ejecuta con un temporizador, causa menos impacto en
el rendimiento. Tendremos un Tim.
Déjame borrar esto. En el temporizador, lo que vamos
a estar haciendo es que
vamos a más o menos resistencia Esto es un si nuestro actor
está corriendo o no,
si imprime, vamos a estar
añadiendo a la resistencia,
a la recuperación de aguante Si es la impresión,
vamos a estar reduciendo la resistencia. Todo esto necesita de alguna manera
para pasar al jugador. La forma en que vamos a
hacerlo es muy sencilla. Simplemente crearemos
una barra de progreso para II que estaremos llenando la barra o reduciendo el relleno de la barra
en función de nuestro valor de resistencia Ahora comencemos. En primer lugar, vamos a
necesitar una nueva interfaz de usuario. Así que voy a nuestra carpeta
I carpeta y voy a con razón puedo crear un nuevo
widget de widget de usuario. Y llamaremos a
esto G Gameplay, porque es un
widget para el gameplay. Ahora de nuevo, sería mejor
tener muchos widgets para
cada aspecto de esto. Pero para nuestros propósitos, estaremos alojando todo en un solo widget cuando inicie
el reproductor. Como decíamos, alojaremos este
widget dentro del reproductor. De nuevo, voy a
estar usando una brújula. Si tuviéramos muchos otros widgets, por ejemplo,
los encontraríamos al usuario creado. Al igual que podemos encontrar el menú principal. Puedo traer como
el menú principal aquí. Lo mismo sería
para la barra de resistencia, la barra de salud, si
las tenemos en diferentes widgets Pero por ahora, como dije, aquí
vamos a estar alojando
todo. En primer lugar,
queremos una barra de progreso. Voy a traer esto
aquí. Voy a hacerlo un poco más grande
y ponerla aquí. Voy a anclarlo en realidad
con solo mirarlo. A lo mejor aquí puede ser
un poco grande. Sí, creo que esto
está bien por ahora. Veremos cuando estemos
jugando en el archivo y guardemos, lo cierro por error. Veamos de hecho esta parte para que veamos si se ve bien. Alojemos esto en nuestro
widget en Begin Play, vamos a hacer ocho widgets. Como lo hicimos en modo juego, estábamos creando el widget del menú
principal. Estábamos usando un reproductor on, que es nuestro controlador. Ahora te preguntarás por qué no me estoy
poniendo yo aquí en jugador. Como puedes ver,
no lo saca a relucir. Necesita ser una referencia de
controlador. No puede ser un actor, un peón, o un actor Voy a estar conectando el controlador de
juego para clase. Voy a traer
la jugabilidad de G y voy a
estar promocionándola a una variable y llamaré a esta jugabilidad G
variable. Entonces voy a
agregarlo a Viewport. Ahora si todo
ha sido exitoso, si empiezo el juego, podemos ver tu
barra de aguante por allá Sí, genial. Ahora en la jugabilidad de Widget, podemos establecer algunos colores, cómo es Barbin Field y
algunos detalles adicionales por aquí Pasemos al estilo, y
vamos a seleccionar un color de
fondo. En realidad sólo vamos a jugar con el tinte por aquí. No vamos a
estar usando una imagen, vamos a hacerla
un poco amarilla. Vamos a cambiar el alfa 2.3 Es un poco
transparente como podemos ver aquí. Ya se volvió transparente. Lo siguiente que vamos a hacer
es que en realidad aumentemos un poco
el porcentaje de campo, para que podamos ver la otra barra. El azul está bien. Pero como
tenemos los amarillos, sigamos con los amarillos. mejor este color de
aquí quizá haga esto un
poco transparente. Además, el alfa
será 0.7 tal vez punto 0.6 está bien. Vamos a compilar. Comprobemos que esta barra de
progreso es una variable. Vamos a nombrar esta
barra de progreso B, Subrayar resistencia. Nuevamente, puede ser cualquier cosa, nitro, lo que queramos. Pero además, siempre es
aguante cada vez que hacemos, realmente no
importa de todos modos Ahora en la gráfica, vamos a ir
a funciones y crear una nueva función y llamar a esta actualización barra de resistencia En realidad, barra de resistencia. Porcentaje de resistencia. Te lo explicaré un
minuto por ciento. Ahora bien, si aquí obtenemos la barra de
resistencia, necesitamos una forma de alimentar La forma el nodo que estamos usando para
eso se llama set percent Se necesita un valor en
porcentaje por aquí. Ese por ciento no es a 100, es un flotador 0-1 lo
que significa que 0.0 es 0.1 es 100 Si tuviéramos 0.5 sería 50% Ahora vamos
a conectar este nodo por aquí en porcentaje a la
función en porcentaje. Esto quiere decir que cada vez que
estamos llamando a esta función, tenemos que dar un porcentaje. Y le pasa ese valor a
nuestro nodo aquí y funciona. Ahora puedes encontrar esto se
llama entrada en una función. Si hacemos clic en las
funciones y vamos a entradas, podemos verlo sobre ser creado para nosotros como lo teníamos
en la función pura. Las salidas, como si
hago clic en salidas, va a crear una salida, un nodo de retorno, lo que nos da una salida y tiene
ese valor por aquí. Lo podemos ver también aquí. Salidas, nuevo parámetro. No vamos a estar usando esto,
voy a estar borrándolo, compilando y guardando ahora. Creo que esto es para
éste y
vamos a estar continuando con el
sistema en la siguiente. Adiós.
12. Implementación de la mecánica de sprints: Hola y bienvenidos de nuevo a
Real Engine Five Blueprints, desarrollo de juegos de
disparos espaciales
paso En la última, creamos la representación visual
de nuestra barra de resistencia, barra Nero o lo que sea También creamos una
función a la que
vamos a estar llamando para
actualizar el porcentaje. Ahora en esta
vamos a seguir
haciendo las entradas y algunas
de las mecánicas sprint. Voy a hacer
click derecho y dejar turno. Este es el botón que vamos a estar
presionando para sprint. Ahora antes que nada,
necesitamos una variable para poder diferenciar
entre nosotros corriendo o no Voy a crear un lingote
que se llama sprinting. Nuevamente, puedes agregar variables
desde aquí, agregar variable, y luego puedes cambiar sus tipos por
aquí o por aquí. Ahora, vamos a
poner esto primero aquí, pero a medida que
avanzamos, vamos a cambiar cómo está sucediendo el orden
lógico. En primer lugar,
no estamos corriendo cuando
estamos presionando el botón Cuando estamos soltando
el patrón, no
estamos corriendo Pero solo porque
declaramos algo que está pasando con un nombre no significa que en realidad
algo esté sucediendo. ¿Recuerdas cuando estamos usando movimiento de punto
flotante para decidir la velocidad que
estamos moviendo en el mundo? Dijimos que aquí hay un montón de más información
que podemos cambiar. Una de ellas es la velocidad máxima y otra es la aceleración
y desaceleración. Ahora como nuestra velocidad máxima
es menor que las dos, esto significa que
vamos instantáneamente a la velocidad. No hay aceleración
ni desaceleración. Voltear impulso es otra cosa. En fin, hay mucho de aquí lo que vamos a hacer es
que cuando estemos corriendo, voy a conseguir este movimiento
flotante Con arrastre y control, voy a establecer velocidad Fueron mil 200 digamos. Más del doble 2500. Ahora cuando estamos presionando turno, estamos diciendo que está imprimiendo y estamos configurando
la velocidad máxima. Veamos qué hicimos.
¿Podemos notar la diferencia? Me mudo normalmente. Estoy corriendo quizá un
poco por el efecto, pero no podemos notar
ninguna diferencia Ya que tenemos esto creado, sigamos adelante y
agreguemos algunos senderos. Vamos a estar usando
un sistema de partículas que se llama Thruster Su sistema en cascada es del
sistema heredado, el antiguo. Funcionará bien para nosotros
aquí en la ventana gráfica. Vamos a estar
seleccionando el cuerpo porque queremos que
se adhieran al cuerpo, como cuando el cuerpo gira, queremos que
roten con el cuerpo. No los vamos a poner
como un niño de la caja, vamos a ponerlos
como un niño del cuerpo. Voy a presionar agregar componente del sistema de
partículas. Ahora, debido a que aquí había seleccionado
el propulsor, automáticamente agregó el
componente como Si no fue por
ti, siempre puedes, simplemente seleccionando el propulsor, seleccionando el componente
aquí, la partícula aquí Voy a rotar esto a 90 grados y
voy a traerlo de vuelta. Puede estar aquí en realidad
esto es un poco, es un poco grande
para una llama inicial. Entonces voy a seleccionar el
candado aquí en la báscula, para que
escale uniformemente y lo haga 0.25 Sí, para movimiento inactivo
y movimiento simple. Creo que esto va a estar bien. A lo mejor quieres más grande, pero yo lo dejaré ahí. Voy a
duplicarlo. Copiar y pegar. Y pon uno aquí. Voy a pegar de nuevo
y poner uno por aquí. Voy a duplicar
este y poner el menos por aquí. A lo mejor son un
poco pequeños, así que voy a
seleccionarlos a todos. Poner 0.5 Sí, esto se ve
un poco mejor. A lo mejor arrastra esto por aquí. Sí, puedes jugar
tanto como quieras para que se vea como quieras. Voy a dejar de
hacerlo en un segundo. Sí, creo que es mejor. A ver. Sí, esto ya
se ve mejor. Ahora, comencemos manipular las llamas para, pongamos primero el sprint
dentro de las entradas Ahora para eso vamos
a usar una línea de tiempo. Como decíamos, voy a
escribir click y decir timeline. Ya nos permite
renombrar la línea de tiempo. Vamos a decir L Sprint. Y voy a crear
dos eventos personalizados. Eventos personalizados. Voy a nombrar a
un Start Sprint y al otro Stop Split. Hablemos donde
conectamos estas cosas. Líneas de tiempo, hacen algo con el tiempo y nos
dan un valor. Aún no tenemos el valor, pero hablemos de
las líneas en ejecución. Tenemos juego y
juego desde el principio. Esto significa que jugará desde el inicio de la
línea de tiempo. Juega desde el principio. juego continuará
en función de la hora actual
de la línea de tiempo. Porque estaba jugando
al 50% y al revés, pronto volvemos a jugar, pero está en 3.30%
30% Seguirá a
partir de ese 30% hacia adelante Lo que queremos conectar es jugar cada vez que presionamos
Shift o lo soltamos. No jugamos necesariamente desde el
principio, sino que jugamos desde el punto de carrera
actual. Lo mismo que
vamos a hacer con parada
inversa, por supuesto, es
simplemente parar donde quiera que estés. Reverse fend es desde
el final del tiempo. Ahora hay un conjunto nuevo tiempo
y tiempo, un nuevo tiempo aquí. Lo que realmente hace es
como si tenemos un tiempo 0-50 y fijamos nuevo tiempo
30 y empezamos a jugar,
jugar desde, empezar a jugar,
comenzará a partir de ese momento, comenzará desde 30 y
seguirá jugando a partir de eso O si estamos dando marcha atrás,
va a estar retrocediendo a partir de esas líneas de tiempo. Además, los puedes encontrar en los componentes
de las variables. De hecho, podemos establecer un
nuevo tiempo a partir de aquí. También hay otras opciones como set rate, set play rates. Si queremos extender, como si tuviéramos un temporizador de cero a uno y quisiéramos
durar 3 segundos, estaríamos un tercio. Pero estos son usos más
extensos de la línea de tiempo. No vamos a estar
haciéndolos ahora mismo. Tenemos un efecto start sprint
y un efecto stop sprint. Estamos jugando desde el momento
actual y estamos retrocediendo del
momento actual cuando los llamamos. Todo este tiempo. Estoy hablando establecer tiempos y los
valores y todo. Pero, ¿dónde ponemos todo esto? ¿Dónde eso pusimos todo esto? Porque aquí
no hay nada que se pueda configurar para hacer eso. Bueno, en realidad, cronogramas. Puedes hacer doble clic sobre ellos. Abren su propio pequeño
panel por aquí tienen un montón de opciones como la longitud
total de la línea de tiempo, si
la línea de tiempo usa el último fotograma clave, veremos en un
momento qué
es esto si se están jugando
automáticamente o
están siendo llamados desde eventos como los
estamos llamando aquí. Si es un bucle y otras cosas, tiene este
botoncito de aquí que se llama camión, camión. Como camión que estamos fijando el tiempo y los
valores que queremos. Hay diferentes
tipos de camiones. Vamos a estar
usando un camión flotante. Cuando hacemos clic en él, nos
da la oportunidad de
renombrarlo. A esto le vamos a llamar sprint. Y ahora tenemos nuestro
valor de tiempo en el valor x, nuestro valor flotante en el y. si controlo haga clic aquí. Si da clic aquí, creo puntos. Estos puntos pueden ser manipulados y si ves cuando los muevo, valor del
tiempo cambia y el valor cambia
también el valor flotante, pongamos uno a cero del valor 01 al formar cinco valor uno Ves que fue por encima de nuestra
visibilidad, está por aquí. Ahí están estos dos botones
que son maravillosos. Dice zoom para ajustar horizontal
y zoom para ajustar vertical. Al ir a presionar,
podemos ver nuestra pendiente. Voy a seleccionar ambos
valores manteniendo el turno. El segundo, ves que
estos valores están seleccionados. Si hago clic derecho sobre ellos, nos da una interpolación clave Ahora mismo está en lineal. Si selecciono auto, hace esta bonita
curva por aquí. Siempre podemos cambiar la
curva en función de nuestras necesidades. Lo que voy a deshacer
ahora mismo y usar la curva automática, estamos, ya terminamos. Cuando dije usa el último fotograma clave. Nuestro último fotograma clave está en 0.5 Si lo
dejo como es la
longitud es de 5 segundos, voy a mantener el control
y mi mouse se bajará. A ver si vamos a la marca de
cinco segundos por aquí. La línea de tiempo termina aquí. Esto significa que esto correrá 0-5 Si selecciono el último fotograma clave, correrá a 0.5 Ese
es nuestro último fotograma clave También podría cambiarlo aquí 0.5 Lo verás
autoajustado esta parte que se
desvanece por Prefiero usar los últimos fotogramas clave porque podría cambiar las cosas, así que no tengo que cambiar
la longitud cada vez, pero eso es una preferencia. Ahora ya ves cuando
volví a la gráfica de eventos, ahora nuestra línea de tiempo tiene
este sprint alfa. Cuando este lugar, este valor cambia en función de cuánto tiempo se está reproduciendo
la línea de tiempo. Hablemos de lo que tenemos. En el lado
de exportación de la línea de tiempo, tenemos un evento de actualización. Esto se ejecuta siempre y cuando se esté ejecutando la
línea de tiempo. Esto se actualiza,
lo que sea que queramos
hacer terminado es cuando la
línea de tiempo haya terminado. Hablaremos de
dirección en un segundo. Sprint alpha es el valor que hemos establecido
dentro de la línea de tiempo. Vamos a acercarnos muy bien, 0-1 en esta cantidad de tiempo Como pueden ver cuando
muevo el ratón aquí, me da un valor
basado en el tiempo. Este valor aquí se está
exportando desde sprint alfa. Ahora bien, la dirección es si vamos hacia adelante
o hacia atrás. Y es del tipo
enumeración que es un tipo especial, digamos tipo de
variable en real, no en, en programación
en general Eso nos da una lista
predeterminada. Pongamos aquí un signo igual y veamos las opciones
adelante, atrás. Significa que si va con dirección de juego
o dirección inversa, podemos saber en actualización
o sin terminar, en qué dirección
está jugando o estaba jugando la línea Voy a eliminar esto porque no lo
vamos a usar. Lo que vamos a
usar es que voy a traer todas las
partículas del propulsor por Cluster una base de propulsador,
Custer zero thruster tres Como ves cuando los creé. Nombre real para mí, no
es el mismo nombre
que siempre podemos nombrar. Propulsión izquierda, impulsora derecha,
propulsora media. Pero esto está bien
para nosotros en estos momentos. Lo que voy a hacer
con ellos va a
establecer a escala mundial tres D. Voy a conectar todos
estos nodos por aquí. Escala de nuevo, escala
es lo que hicimos en la
variable de escala Viewport aquí A lo mejor eso va a
desbloquear esto y poner esto en 0.25 Sí, creo que esto es mejor. Déjame seleccionar cada una de ellas. 0.25 tal vez no lo es. Sí, está bien. Está bien. Voy a conectar
actualización para establecer escala mundial. Ahora bien, ¿cómo voy
a cambiar con base en el alfa, el valor aquí? Digamos que tenemos el valor
predeterminado de 0.25 0.5 y 0.5 ¿Cómo puedo hacer esto? Ya que tenemos un cambio de escala, queremos basado en
un impulso para hacerlo, hay un
nodo especial para esto. Este nodo se llama nodo. Tenemos los vectores. También hay, en general, hay muchos laboratorios,
significa de a a B. Básicamente, esto es
lo que interpola
entre a a B
basado en un alfa Aquí vamos a conectar
nuestro alfa, ya que conocemos nuestros valores, vamos a hacer
0.25 0.5 0.5 B estamos, digamos 0.5 vamos a
mantener lo mismo. Y 1.5 tenemos a estos
valores un poco. Así es como los resolvemos. Cuando tienes algo, siempre
debes jugar un poco con
los valores. Ve cuál encaja mejor en
tu funda. Siéntete libre de cambiar cualquiera de los valores a los
valores que te gusten. Ahora mismo. Dijimos que vamos a estar haciendo algo
con la cámara también. Vamos a estar cambiando
el campo de visión. Voy a traer la cámara, voy a poner campo de U. voy a conectar
esto aquí de nuevo. Tenemos que establecer
aquí un valor que va a ser un valor flotante de alerta. Voy a crear nuestro nodo de
lectura aquí, conectar esto a alfa, hacer otro nodo de salida roja aquí. Nuestro campo de visión predeterminado, podemos verlo en los detalles
de la cámara es 90, que creo que es un campo de visión
predeterminado normal. Voy a poner alfa 90 para B. voy a poner 110 gratis. Por supuesto, para cambiar cualquier valor. este momento nuestra cámara desde un ángulo de 90 grados va
a un ángulo de 110 grados. Vamos a probar esto. En realidad tenemos que conectar estos dos eventos en sprint izquierdo. Vamos a iniciar el lanzamiento del efecto de
impresión. Vamos al efecto sprint. Voy a
compilar. Juguemos. Me estoy moviendo, estoy, me
muevo, estoy esprint. Sí, parece que la cámara
va hacia atrás, las llamas son cada vez más grandes. Creo que esto es para éste, te
voy a mandar a continuación. Adiós.
13. Sistema Sprint y gestión de la resistencia: Hola y bienvenidos de nuevo
a Andrea Lynching, cinco planos paso a
paso desarrollo de
juegos de disparos espaciales En la última, iniciamos
la mecánica del sprint. De hecho hicimos las
visuales del sprint. Me di cuenta de que olvidé un detalle
muy importante. Estamos aumentando la velocidad mientras que nunca
estamos disminuyendo la velocidad. Yo solo voy a copiar y pegar
esto por aquí y conectar esto y volver a mil 200
que era nuestro valor predeterminado. Sí, ahora mismo estamos corriendo y podemos dejar Las visuales, nos estamos deteniendo, pero la velocidad no estaba cambiando Ahora continuemos con
nuestro sistema de resistencia, como ¿cuánto tiempo
podemos estar corriendo Porque ahora mismo
estamos corriendo, pero es indefinido Para ello, vamos a
estar usando el temporizador que
explicamos desde el principio. Juega evento al final aquí. En realidad hagamos un evento personalizado que llamaremos
los temporizadores de inicio. Tendremos este
evento Start Timers, porque probablemente tendremos dos o tres
veces más para disparar,
para la regeneración de salud,
tendremos más temporizadores para poner en fila desde el
inicio del evento de juego. Voy a llamar a los temporizadores de arranque. Para ser honesto, voy
a poner una secuencia antes del widget de creación para
hacer las cosas seguidas. Y más claramente, voy a poner el widget y
lo voy a encomiar, widget aquí en el 10 Entonces uno, voy
a llamar empieza. Ahora vamos a traer G
aquí va a estar bien. Temporizadores de arranque. ¿Qué hacemos? Vamos a llamar a un temporizador
establecido por evento. Algunas otras funciones con temporizador. Si viste en el
breve diálogo de
allí, había otras funciones como establecer temporizador por nombre de función. Configura el temporizador para nextek. Cada uno tiene su propio evento de nombre de función de
usabilidad. Tienen algunas
pequeñas diferencias, pero también por el bien de depuración, sería más fácil
depurar algo que tenemos un evento y
podemos ver qué se está ejecutando. Entonces teniendo un temporizador
que ejecuta una función, el temporizador por función
funcionaría como aquí. Tenemos que crear un
evento personalizado y nombrar este evento. Sprint. Sprint. Sprint. En realidad, no tiene que ver con la primavera, tiene
que ver con la resistencia Región de regeneración de resistencia. Si tuviéramos una función
llamada region, usaríamos el
set Tim function name y function
name the stamina Este temporizador se ejecuta, ejecuta
la función de sello de región. Cada vez que lo hemos dicho, sería
difícil depurar esto porque cada vez que se ejecuta, entraría aquí
mirando fuera de las cosas. A lo mejor tenemos más
funciones que estaría entrando dentro de
otras funciones. Creo que es más fácil
comenzar con eliminar cosas, configurar temporizador por evento ya
que es más fácil de seguir. Ahora. Ahora además del primer pin que acabamos de analizar
un poco. El evento o el nombre de la función. En realidad, déjame traer de
nuevo el temporizador de función. Hablemos de un
poco del resto. Ahora bien, una diferencia básica
que podemos ver instantáneamente además de estos dos controladores, digamos nombre de evento
o función, es que el
nombre de la función tiene un objeto. Esto significa que puedo ejecutar
la función de otro blueprint del que
tengo una referencia,
widget, modo de juego, o lo que sea Puedo tener una referencia de un objeto que
pueda tener una referencia de todas sus funciones en un
temporizador, en este plano Esta es una de las diferencias
entre estos dos. Ahora sobre los puntos en común, tenemos tiempo en ambos, y el hacer un ciclo es con qué frecuencia, cuánto tiempo esperar antes de
ejecutar al delegado, como dice en segundos Lo mismo en la
otra facción, el looping, si queremos que esto sea un ciclo
así es interminable, hazlo todo el tiempo y lo
mismo en la Hay algunas otras estadísticas
que son un poco más avanzadas de las que no hablaremos con ellos en este momento, no las
usaremos. Voy a borrar esto aquí. Vamos a tener un
tiempo de 1 segundo y
va a estar looping para nuestro sistema, necesitaremos dos variables Voy a crear uno y voy a
crear otro. Creo que es momento de
categorizar esto un
poco antes de nombrar y seleccionar los tipos
de estas variables Pongamos la
anterior en algunas categorías, en ADS y espacio, aquí
vamos a crear
una categoría que se llama, digamos, inputs. Voy a arrastrar y soltar
todo esto en entradas. Además de ganar bajando,
siempre puedo cambiarlo desde aquí. Tiene algunas otras categorías,
la categoría de fallas, básicamente la nueva
categoría que acabamos de hacer. Ahora estos tres quizá
los pusieron en una categoría de movimiento. Voy a poner esto también aquí en realidad voy
a poner está imprimiendo aquí. Y aguante a dos
nuevas variables. Estas dos nuevas variables
serían de entero, en realidad
van a ser de tipo, una de ellas sería stamina y la
otra sería x stamina Voy a traer estas variables por
aquí y voy a traer un setter de
la aguante actual Cuando el temporizador está funcionando cada 1 segundo
y está en un ciclo, comprobando
constantemente, significa que ejecuta
constantemente esta
función cada 1 segundo Queremos estar comprobando si
estamos corriendo o no. Para seleccionar qué valor
vamos a establecer. Aquí, voy a seleccionar Nodo. Como lo hicimos anteriormente,
nuevamente dos opciones. Seleccionar flotador y solo seleccionar
seleccionar tiene el comodín. Y el flotador selecto solo nos
da un lingote. Recuerda que estos son
opuestos en comodín. Bueno, si seleccionas un
lingote en comodín y fas aquí está arriba
y cae Cuando estoy seleccionando
quiero preguntar si en realidad estoy
corriendo, voy a correr
desde aquí Consigue el sprint
y conéctate aquí. Si estoy corriendo, elige A. Si no estoy corriendo, elige B. No voy a
necesitar esto por ahora Lo voy a poner aquí, aguante
actual plus,
y resistencia actual menos Cuando no estamos corriendo, estamos agregando resistencia En realidad, cuando estamos corriendo, estamos reduciendo la resistencia Ahora aquí voy a
poner valores estáticos de uno y los voy a promover a una
variable, la más uno, voy a
llamarla región stamina,
promover región estrella variable porque la tasa
es cada 1 segundo El valor de cuánto sumamos por segundo se va a
colocar aquí. Ahora mismo es una.
Ambos son uno, pero si quisieras cambiar, este valor puede ser diferente. Y cuando promovemos
esto a una variable, podemos llamarlo valor de resistencia Ponemos esto debajo de aquí
y esto debajo de aquí. Cada uno de ellos se puede establecer
por separado para un valor predeterminado. Voy a compilar esto ahora. Podemos ver que
ambos están en el valor uno. Necesitamos una resistencia actual. Lo que voy a
hacer, voy a poner la resistencia máxima en diez En comenzar a jugar aquí en el relativo
original, rotación relativa del cuerpo original. Voy a establecer la resistencia actual a
la resistencia máxima. En realidad establecer obtener lo que sea
nuestra resistencia máxima predeterminada es, está llegando a ser nuestra resistencia
actual Otro ingenioso truco que
cuando empiezas a tener algunos valores que quieres estar configurando por defecto
y cosas así, siempre
puedes Dr no importa cuántos
nodos o qué nodos realmente hace Delay no se usaría en esta situación y algunos
otros nodos de todos modos, puedes hacer clic en ellos
y colapsar para Todo esto está dentro de
esta función. Voy a nombrar esta
función Defaults. Ahora dentro de esta función, tenemos el ajuste de la rotación
relativa del cuerpo original y la resistencia actual Bien, volvamos
a nuestro sistema. Estamos reduciendo la resistencia o
estamos agregando resistencia
en función de si estamos corriendo cada
1 segundo que estamos Pero esto va a seguir agregando resistencia aunque vayamos
por encima de nuestro valor máximo. Para lograr detenerlo al valor máximo. Podríamos hacer si esto es igual al valor máximo y luego
podemos ramificar y decir, no
hagas esto más
o detengas el tiempo. Pero lo que vamos a usar
es otro nodo que es
un nodo matemático
llamado Plump Plot Ahora lo que hace la pinza, obtiene un valor y
tiene un minimax Y dice que este es el valor mínimo que este
valor puede devolver, y este es el valor máximo. Aunque esto da,
digamos que tenemos un máximo de uno y
esto da cinco, devolverá uno. O si fuera menos cinco, volvería cero. Voy a usar este nodo
y conectar esto aquí, hacer algo de espacio para
nuestro valor máximo. Vamos a
conectar la resistencia. Sea lo que sea que fijemos max, esto lo agrupará
para no superarlo, y si estamos reduciendo la resistencia, no irá por debajo Creo que tenemos mucha
información en esta. Creo que este es un
buen punto de ruptura. Te voy a ver
en la siguiente. Adiós.
14. Finalización del sistema de Sprint: Hola y bienvenidos de nuevo a
Unreal Engine Five Blueprints, desarrollo juegos de
disparos espaciales
paso a paso En la última,
creamos lo básico para nuestro mecánico de manejo de
resistencia Hicimos un temporizador en el que
está looping basado. Se ejecuta cada 1 segundo. En cada iteración resta o suma
a la resistencia actual,
con sujeción de nuestro valor a
máxima resistencia con sujeción de nuestro valor a
máxima Esto significa que no puede ir por debajo cero o por encima del valor máximo. En esta, vamos a
estar actualizando el widget y vamos a completar la mecánica de regeneración de
resistencia Vamos a traer nuestra referencia de
widget y la función que creamos
dentro del widget. El, lo siento, widget equivocado. El tiempo de actualización en un porcentaje. Vamos a
llamarlo desde el jugador. Ya que tenemos la
referencia del widget que
almacenamos en la reproducción inicial, cuando se creó el widget
a partir de esta referencia, voy a llamar a la
función update stamina Por ciento Por ciento, voy a dividir la resistencia actual
con la resistencia máxima. Ahora bien, esto es un
poco de espagueti. A lo mejor si hacemos algo más de espacio, podemos traer esto aquí arriba, podría verse un
poco mejor. En fin, al dividir estos dos, obtenemos un valor 0-1 que
es nuestro porcentaje Ahora lo siguiente que debemos hacer, voy a llamar a una secuencia
y hacer dos preguntas. La primera pregunta sería, si la resistencia es cero, nuestra resistencia actual Si es así, queremos
dejar de correr. El código que tenemos por aquí, en realidad
necesitamos
usarlo dos veces ya que creamos la función predeterminada establecida
aquí que superponemos esto. Y luego hacemos clic derecho
y creamos función. Lo mismo que vamos
a hacer con éste. Podemos llamar a esta función. Tenemos escribiendo el código
una vez y lo llamamos dos veces. Voy a hacer clic en
contraer la función. Voy a ponerle nombre a
esto Stop Sprinting. Voy a copiar esta función, y si nuestro
cero de estampación es cierto, deberíamos dejar Ahora la siguiente pregunta que
voy a hacer es que, nuestra resistencia actual
es
igual a la resistencia máxima La razón por la que estoy haciendo la
pregunta es porque si lo es, entonces todo este temporizador no debería
estar funcionando porque está consumiendo recursos para
iniciar y detener un temporizador. Dentro del código,
tenemos este valor de retorno por aquí que devuelve
una estructura de asa de temporizador. Voy a promocionar
esto a una llegada y llamarlo Mano de Aguante Con este asa de aquí
podemos excavarla y dejarla caer. Aquí podemos llamar al temporizador de pausa, o podemos llamar al temporizador de post. Ahora mismo tenemos que
pausar el temporizador. Pero como estamos
pausando el temporizador aquí, cuando estamos presionando
turno para comenzar a correr,
arrancamos el Voy a traer esta
variable por aquí también y decir timer by handle. Para manejar un temporizador, utilizamos esta
variable de asa de temporizador, si eso tiene sentido. Ahora mismo deberíamos poder
ver alguna visualización. Vamos a jugar
Esperó una garrapata para
mostrarnos que nuestro cuerpo está lleno. Estoy usando aguante.
Está consumiendo, no
estoy usando aguante No consume,
regenera el sistema funciona. Solo necesitamos
arreglar esa cosa al principio que necesitamos
actualizar por ciento de resistencia Voy a copiar esto y max stamina e ir
a nuestro set defaults Voy a colocar esto aquí, voy a usar esta
aguante actual. Compilar y guardar. Sí, claro que no funcionó porque estamos
creando el widget. Más adelante, vamos
a cortarlo a partir de aquí, donde creamos el
widget. Comenzar. Jugar. Voy a actualizar esto después de ir a traer aquí
la resistencia actual Conecta esta obra. Está actualizado. Estoy usando aguante. Dejo de usar aguante. Sigue moviéndose. Nada lo
consume. Uso de resistencia. Sí, funciona. Esto completa nuestro
sistema de sprinting, lo que sea. Te veré en
la siguiente donde iniciaremos la mecánica de
tiro. Adiós.
15. Conceptos básicos de focalización y disparo: Hola y bienvenidos de nuevo a
Real Engine five Blupints, desarrollo juegos de
disparos espaciales
paso a paso En el último video,
terminamos nuestro sistema de resistencia,
nuestro sistema de resistencia sprint Vamos a comentar un poco. Voy a poner un
comentario aquí para llamarlo. Pongamos esto
realmente dentro de aquí, porque hay insumos, ellos son el mousex y mousey Llamemos a esto
efectos sprint línea fina. Llevemos esto debajo de
nuestro temporizador de primavera. Ahora aquí, este es
nuestro evento tick. Entonces vamos a llamar
al primero movimiento, el segundo es visual. Bien, ahora todo está
un poco más comentado. Vamos a mantener esto para
comentar al final porque
agregaremos más cosas. Ahora hablemos un poco sobre
el sistema de tiro. No voy a volver a dibujar
una nave espacial. Esta será nuestra
nave espacial esta vez. Digamos que tenemos el arma por aquí y queremos
disparar desde el arma. Tenemos nuestra cámara aquí arriba. ¿Por qué digo que tenemos la cámara? Porque la cámara,
esta es nuestra ventana gráfica. Este es el campo de visión tal y como lo describimos en
la mecánica sprint. Esto es lo que ve la cámara. Siempre podemos obtener
el centro de lo que
la cámara lo averiguará. Desde ese centro,
seremos una línea hacia el
centro de la pantalla. A esto se le llama línea de rastreo. Nos pondremos más
técnicos al respecto más adelante. Estaremos filmando una línea
de rastreo desde el centro de la pantalla hasta una distancia de nuestro campo de tiro
máximo. Con esta línea,
determinaremos si
estamos pegando a algo en alguna parte. ¿Tenemos un objetivo?
¿Por qué vamos a hacer esto? Porque cuando estamos
disparando desde nuestro arma, si nos paramos disparando
una línea recta, el centro de
la pantalla y la línea recta de nuestro
arma no serán los mismos, no
serán la misma posición. Podemos decirle a esta pistola que esté disparando
hacia el objetivo. Ese es el final de esta línea. Pero si encuentra algún
enemigo en el medio, como este tiroteo aquí y este tiroteo aquí es un
ángulo de disparo completamente diferente, tendremos que recalcular,
básicamente, ¿esta
línea encontró No, entonces dispara por aquí. Al final, esta
línea encuentra algo? Sí, lo hizo, está aquí. Nuestro arma recalculará el
ángulo de disparo para nosotros, parecerá que está
disparando siempre al blanco Empecemos por crear esta línea desde la
cámara en nuestro proyecto. Vamos a ir
a nuestro evento tick. Vamos a agregar la nueva
rama en nuestra secuencia. Para ello, vamos a
necesitar una variable más. Vamos a llamar a
esta dirección R. Va a ser
del tipo vector. Voy a traer un
setter a esta variable. Voy a
conectarlos dos a éste, lo
mejor bajarme un poco. Ahora vamos a traer una cámara, porque de la cámara queremos, donde está apuntando al punto
medio de la pantalla. De la cámara, voy
a sacar el vector forward. Dondequiera
que esté mirando la cámara. Obtenemos a lo que es el vector
forward. Voy a multiplicar esto
con el alcance de mi arma. Ahora bien esto es una multiplicación de vector
por vector, pero podemos cambiar
esto a otro tipo Voy a
cambiarlo a entero, hago esto 50,000 Vamos a
promoverlo a una variable y
llamar a este rango de primaria. Ahora a partir de esta cámara
voy a conseguir la ubicación mundial. Voy a sumar
estos dos valores. Voy a establecer esto
como mi dirección objetivo. Lo que estamos haciendo aquí, déjeme explicarlo un poco. Tenemos nuestra cámara.
Esta es nuestra cámara. Y tiene una dirección hacia delante. Tiene una dirección hacia delante,
esta dirección. Digamos que es 0.1 0.0
porque tenemos x, y, y z, tenemos más uno en y Entonces si este es el vector
forward, estoy multiplicando esto por rango 0.1 0.0 Si lo multiplico con esto, va a convertir en esto aquí Entonces este es un rango. Dice que si estás
en esta dirección, ve aquí, 50 mil adelante. Entonces estamos agregando a esto la palabra ubicación de la cámara. Este 50,000 digamos que
somos 1.0 0.1 nos
facilita las cosas. Este será nuestro último Resultado
será en 1.50 mil. Se trata de un K011. Siempre que apuntemos, estamos apuntando 50,000 adelante a esto más
la palabra ubicación. Nos da el punto final. Esto es lo que hicimos aquí. Este es nuestro primer objetivo. Digamos que tal vez la dirección del objetivo no
es el
nombre correcto, es solo objetivo. Creo que esto es para éste. Dijimos muchas cosas. Vamos a continuar
en la siguiente. Adiós.
16. Desarrollo de mecánicas de tiro: Hola, bienvenidos de nuevo al
motor real Five Blueprints. Desarrollo de juegos de
disparos espaciales paso a paso. En la anterior,
dejamos con la creación nuestro objetivo como ¿cuál es nuestro primer objetivo
frente a la cámara? En esta
seguiremos con el trazo de línea del que
estábamos hablando. Esta línea invisible que nos
decimos si pegamos a algo. Sigamos,
vayamos a nuestro proyecto. Y luego el siguiente nodo que
necesitaremos es trazo de línea cuatro. Ahora vamos a
trazar cuatro objetos. Hay otras trazas de línea
también como por canal, que es como canal
específico de visibilidad. Esto lo explicaremos en un segundo. Las esferas que tienen
una forma diferente, es una forma esférica. En realidad podemos,
en lugar de una línea, una esfera, usemos una esfera. Traza objetos por esfera. Trazo de esfera para objetos. Esto que es lo
mismo que trazo de línea para objetos con una pequeña diferencia de
que no es una línea, es una esfera que damos es, voy a borrar esta traza de
línea para objetos. Voy a usar esta traza de
esfera para objetos. Ahora vamos a explicar
algunas cosas aquí. Inicio es donde comienza el rastro
es donde termina el rastro. Para el final, tenemos nuestro
objetivo para el inicio. Vamos a usar la
ubicación de la cámara que se muestra un ritmo de copia este año y se
conectó para comenzar. Ahora está este radio. Así de grande es básicamente nuestra
esfera. Voy a poner un valor de diez. Estamos llegando a una parte
más importante. Dice por aquí, tipos de objeto, vamos a estar
promocionando esta variable, pero esto nos da la
oportunidad de platicar. ¿Qué son los tipos de objetos
y qué son las colisiones? Vayamos a nuestra ventana gráfica, donde tenemos nuestro barco
y nuestra caja de colisiones Básicamente, las colisiones en
Unreal son una forma de referirse a la detección de contacto o intersección entre
objetos en el juego O si seleccionamos la malla
estática o la caja, aquí
hay una categoría
llamada colisiones, que tiene muchas propiedades, de detalles con los que jugar Vamos a
repasarlos
un poco con algunos
detalles, pero no mucho. La simulación
genera evento de calor se trata de generar eventos de calor
mientras que la física ocurre. Lo podemos ver en el
Tooltip por aquí. Y el material físico es un
poco más complejo. Materiales físicos, se pueden tener respuestas basadas en el material
físico de cualquier material como
se podría
decir concreto y tener
una respuesta especial sobre la anulación o
el material físico que existe, generar eventos de
superposición. Sí, esto es un
poco más avanzado. Los sistemas generan eventos de superposición si la caja de colisión está
generando algún evento, solapamiento o incluso hit
creo que está incluido en
este personaje paso adelante. Como dice la descripción emergente, se trata de que la mecánica de
movimiento del personaje intenta pisar algo No es si puedes caminar sobre la cosa cuando has aterrizado de un salto sobre ella o algo así. Ahora, presets de colisión. Esta es una bonita lista que real ha creado para nosotros
con algunos presets Pero siempre podemos hacer
una colisión personalizada. Los presets están
afectando estas cosas. A continuación tenemos la
colisión habilitada que es consulta no se puede estar seguro cómo se pronuncia esto
y las colisiones de física Podemos elegir entre
habilitar algunos de ellos, deshabilitar algunos de ellos
o no colisionar en absoluto Ahora tipo de objeto,
esto es lo que puede ser de interés nuestra construcción
de lo que estamos haciendo. El tipo de objeto es un canal
de básicamente es una lista. Es un mecanismo utilizado para categorizar diferentes
tipos de objetos y definir cómo
interactúan entre
sí en términos de colisión No otras partes de programación, sino en términos de colisión. Cómo
interactúan entre sí. Por ejemplo, cuando
tenemos un mundo estático, ¿qué hace con
la dinámica mundial? Aquí, dice bloquearlo, por ejemplo, voy a
revertir esto a lo que era Estanque básicamente, eso es todo. Esta bonita caja de aquí. Haga clic para abrir la documentación. Si haces clic en él, hay
un análisis muy detallado sobre colisiones
de Epic games Muy buena. Ahora
vamos a continuar. Tenemos tipos de objetos. ¿Para qué sirve este rastreo de esferas? Para los tipos de objeto que
vamos a usar, vamos a compilar para
habilitar los valores predeterminados y vamos a agregar
un tipo de objeto sería dinámico mundial. Nuestro rastro es la búsqueda objetos que del
tipo mundo dinámico. Una cosa más tal vez
sobre las colisiones, y me detendré con eso, es que podemos crear
nuestros propios tipos de objetos Si vamos a Ajustes del Proyecto
y vamos a colisiones, aquí
hay colisiones, canales de objetos Podemos crear nuevos canales de
objetos y luego podemos crear
nuevos canales de rastreo. Aquí hay algunos ajustes preestablecidos. Podemos ver si creo
nuevo canal de objeto, decimos mi personalizado
P, no comp. Si compilo primero ves mis personalizados por
aquí y tiene las colisiones
por defecto De todos modos, siéntase libre de
explorar el sistema ya que es un sistema necesario para proyectos a
mayor escala. Va a eliminar este. Vamos a continuar. Por supuesto. Se me olvidó explicar
una cosa más. Complejo de trazas. ¿Qué es
este botón de aquí? Cuando vamos a un yo estático, digamos por
ejemplo una nave espacial Algunas medidas estáticas
tienen simple colisión. Si vamos a mostrar y
decir simple colisión, podemos ver simple
colisión aquí. Algunos de ellos también tienen colisión
compleja la
cual se puede ver. Es mucho más detallado. Siempre es mejor usar simple colisión si
la masa estática tiene, pero siempre podemos
generar alguna forma de colisión simple a través de
estas opciones por aquí. No vamos a pasar por
eso ahora mismo. Vamos a continuar. No
vamos a estar usando complejo ahora. Actores para ignorar, actores
para ignorar una matriz. Nuevamente, no hemos
hablado de arrays, pero como
colisiones de objetos, promoví Ves este símbolo por
aquí con muchas cajas pequeñas. Esto simboliza una matriz. ¿Qué es una matriz? Es una lista. Básicamente, se puede ver aquí, agregué uno muchos más. Déjame rehacer esto. Eso es lo que es este NarraA. Tiene algunas reglas específicas
sobre la manipulación de esta lista. No necesitamos pasar de ellos
ahora mismo porque no
vamos a usarlo en esta lista. Podemos poblarlo con actores para ignorar,
no lo vamos a usar. Ahora, algunas cosas más
interesantes. Dibujar tipo de depuración. Esto dice, ¿por cuánto tiempo
debería durar la línea de depuración? ¿Cuál es la línea de depuración?
Nos muestra nuestro rastro. En realidad, vamos a
demostrar esto. Lo tenemos, si
lo pongo para un fotograma, queremos ignorar el tiempo de
auto 5 segundos. Vamos, podemos ver esta
esfera de bandeja que comienza desde nuestra cámara y termina en
nuestra vida útil máxima de bala de longitud de
bala. Se puede ver aquí, parte
de la cámara y termina por allá. Vamos a continuar. Ignorar a uno mismo es ignorar el plano
en sí, trazar el color Esto es para la cámara. Si cambio esto, el color de la línea de depuración cambiaría. Si calentara algo
después del evento de calor
, obtendría el segundo color. A éste se
lo voy a dejar, eso no importa. A lo mejor podemos darle al radio de la esfera un valor un
poco más grande. Hagámoslo 20. Eso son
2,200 Tiene un punto por aquí Hablemos de las
salidas ahora mismo. Los insumos,
hablamos del tiempo de sorteo. ¿Cuánto tiempo se dibujan
las líneas
de depuración en los valores devueltos? Tenemos la
línea de ejecución, claro, tenemos este calor de salida, y el valor de retorno, el valor de retorno
es si calentaba algo. Preguntemos a esta
primera sucursal de Cola, igual que el rastro le pegó a algo. Ahora mismo
no tenemos nada en el mundo. Las encuestas siempre se activarán. Pero como tenemos que analizar
un poco nuestro evento de calor, creo que dijimos suficientes
cosas para este. Analizamos
colisiones, creamos nuestra
línea de traza de esfera como vimos aquí Seguiremos en
la siguiente. Adiós.
17. Mejora de la orientación y la mira: Hola y bienvenidos a
Engine Five Blueprints, desarrollo de juegos de
disparos espaciales
paso En la última,
creamos nuestro rastro de línea. Explicamos algunas cosas sobre
colisiones, tipos de objetos y algunas cosas sobre las
listas llamadas matrices que
tienen reglas especiales
para manipular Ahora, habíamos agregado una sucursal aquí, déjenme agregarla. Estaba revisando algunas cosas. Hoy, vamos a
hablar un poco sobre nuestro resultado de calor. Cuando calentamos algo, cuando nos dirigimos algo, ¿qué es esto que
estamos recibiendo a cambio? Ya ves que dice calor. Lo que es una estructura es un tipo de variable especial que puede contener muchos tipos de
variables diferentes en su interior. Es como una lista personalizada
de las cosas que queremos. Facilita la
manipulación de datos y la reutilización de datos. Es una buena manera de almacenar información que sabemos que es información
específica va a ser necesaria. Muchas veces, estructuras, generalmente cuando tenemos una
estructura podemos romperla. Esto significa mostrarnos
qué datos contiene. Estamos rompiendo el resultado del calor. Y podemos ver que hay un
montón de datos por aquí. Lo que queremos es el desgaste de
la ubicación si le pegamos. Algo que queremos
cambiar nuestro objetivo. Porque nuestro objetivo en
este momento es el final de la línea de huelga,
la nueva ubicación. Volvamos a nuestro
maravilloso dibujo aquí. El asombroso dibujo, en lugar de tener el objetivo
por aquí ahora mismo, decimos que le pegamos algo
por aquí o por aquí. Este es nuestro nuevo objetivo. Ahora por qué no podemos ver, porque estoy escribiendo
en la capa equivocada. Sí, si hago clic en esta capa, puedo escribir en la capa
correcta, nuestro objetivo ya no está aquí
y está en alguna parte de aquí. Si no golpeamos nada, entonces nuestro objetivo sigue siendo
esta cosa de aquí. Si no lo hacemos, no tenemos
el objetivo se queda igual. Otro dato
que debemos conservar es el calor. Voy a promover esta
variable, este actor objetivo. Voy a estar
configurando esto aquí. Ahora bien, si no pegamos nada, nuestro actor objetivo
debería quedar nulo. Nulo es una programación creo, término, no significa nada. Básicamente, esto
es algo va a regresar ya que
devolverá algo. Debido a que esta lista es
un poco grande, en realidad
deberíamos
presionar esto por aquí y ocultar la mayoría de
las cosas que no necesitamos. Con esto, hemos creado
nuestro sistema de targeting, Pero eso es todo bueno
para la programación. ¿Cómo le mostramos al jugador
que estás apuntando? Algo que sabemos que está en
medio de la pantalla. Volvamos a
nuestro juego Widget a la pestaña Diseñadores. Agreguemos una imagen. Vamos a agregar
algunos puntos de mira
ahora mismo para el pincel de imagen que
tenemos en las texturas del archivo Este punto de mira, voy a cavarlo y dejarlo caer en Voy a anclar la imagen en el centro de la pantalla. Por tamaño, yo
diría que una caja cuadrada de 100
por 100 estaría bien. La posición debe ser -50 en X y -50 en Y. Se centra Voy a compilar y guardar. Ahora cuando estamos
apuntando a algo, queremos esta imagen. Déjame presionar G.
En realidad lo hizo mamá. Solo tuve que deshacer clic en
esto para eliminar el. Tenemos que representar
al jugador que
el punto de mira está apuntando
a algo o no lo es. Cambiemos su valor por defecto a su alfa 2.50 0.5 Es un
poco transparente Vamos a par graficar
y crear dos funciones. La primera función
llamará a target. Al otro vamos a apuntar. Volvamos al diseñador y hagamos de esta
imagen una variable. Vamos a darle un
nombre. Subrayo el punto mira de nuevo para incluso
graficar en el objetivo Empecemos con
éste. Obtendremos el conjunto de imágenes cruzadas. En realidad configurarlo, establecer,
pincel, tinte de color. Voy a conectar esto
aquí que dice color delgado. No voy a
crear una variable porque esto va
a ser lo mismo. Voy a volver a dividir
este pin de estructura, porque esta es una estructura de color
pizarra Voy a dividir esto y
decir que el color va a ser, pongamos un bonito rojo. Alfa sería 0.5
Es rojo transparente. Para las reglas, solo
mantenemos el color especificado. Ahora voy a
copiar y pegar esto. Voy a ir a Target. Vamos a pegarlo.
Va a conectarlo. Voy a poner
todo en uno para que se convierta en un color blanco y transparente 0.5 alfa
0.5 Compilar y guardar. Ahora voy a volver
a nuestra nave espacial aquí en la mecánica de apuntamiento Voy a hacer
algo de espacio por aquí. Voy a traer
la referencia del widget. Desde la referencia del widget, voy a llamar a estas
dos funciones Target. Objetivo. Y
conéctelos a la línea. A lo mejor copia como esta dos veces. Esto se ve mejor ya.
De veras no me gusta esto. Podemos poner todo esto dentro una función para que no tengamos
todo este lío afuera. Y llamar a esta función sistema de
focalización
y poner un comentario. Ahora se ve bien para la
siguiente parte de nuestro mecánico, vamos a estar necesitando
una entrada de tiro. Voy a hacer click derecho
y teclear el botón izquierdo del ratón. Vamos a estar
necesitando una nueva variable. Voy a crearlo aquí. Voy a llamar a esta variable. Entonces voy a traer aquí
un setter y copiar
pegado y conectar el
prensado y el liberado en la Voy a poner a la verdad. Ahora tenemos que hablar sobre cómo va a funcionar nuestro
mecánico de disparo. Creo que este es un buen punto de
ruptura para este. Y vamos a continuar
en la siguiente. Adiós.
18. Construye la base del sistema de tiro: Hola y bienvenidos a Real
Engine Five Blueprint Paso a
paso Space Shooter
Game Development En la lección anterior,
dejamos con el arranque del mecánico de
tiro y terminamos con el
punto de mira y el resultado de calor Como dijimos. Vamos a
explicar un poco. El mecánico de tiro, no
creo que necesitemos
mucha pintura para ello, pero básicamente el
concepto es que cuando el jugador esté presionando
el botón hacia abajo, entonces, pero este disparo tendrá un retraso de retraso que volverá a disparar cuando
el botón esté Si el retraso está activo, no
queremos volver a disparar, sino esperar a que termine el
retraso. Internamente del mecánico de
tiro, estaremos comprobando si
el botón está abajo o arriba. Creo que básicamente eso es todo. Continuamos bucle continuo
de disparo siempre y cuando
el botón sea el mejor diseño de todos los tiempos. Empecemos con esto.
Vamos a crear un evento personalizado y
llamar a esta sesión. Vamos a llamarlo aquí. Cuando estamos haciendo clic,
estamos llamando
al evento de disparo láser
Now para controlar el flujo. Si deberíamos estar rehooting
o es un retraso, podría
haber muchas
formas de hacerlo. Podría haber puertas, podría ser lingotes, podrían ser estados Con las enumeraciones, lo
que usaremos es un nodo. Esto significa que, como podemos ver, hace algo una vez
y tiene una entrada de reset. En esta entrada de reinicio, vamos a llamar a
un evento personalizado. Nuevamente, evento personalizado, vamos a llamar a
este laser reset. Esto, no digas
láser, bien, resetear. Cuando queramos restablecerlo, cuando el jugador pueda volver a disparar, estaremos reiniciando esto Lo siguiente que
necesitará este núcleo
del mecánico sería un retraso. Para este retraso es nuestro
retraso de disparo, 0.2 Suena bien. Voy a promover esto a
una variable y decir CD láser. Voy a traer
esto aquí después. Después del enfriamiento,
voy a resetear. Ahora, después de que hayamos
restablecido el láser, que llama aquí,
se restablece a una vez Voy a poner una rama
y preguntar si está disparando. Si estamos disparando. Si
seguimos disparando, voy a llamar láser
láser, tiro láser. Si no estamos disparando, entonces no voy a hacer nada. Básicamente, esto crea el
bucle que cada vez que
presionamos, estamos empezando a
disparar el láser. Mientras estemos aguantando, estamos disparando el láser. Ahora vamos a demostrarle a esto
con un sonido antes de retraso, voy a tocar el sonido de disparar y nuestro ácido
está dentro de Sonidos. Éste, éste, algunos de ellos son sonidos. Algunos de ellos son los que estamos usando porque se pueden
manipular un poco Suena, no puedo.
Voy a poner esto aquí. Si voy a presionar
ahora mismo estoy disparando. Los sonidos son correctos. Y podemos ver los herederos cruzados y lo enorme, bueno, no
es enorme Es solo nuestra perspectiva la
que la hace enorme. La esfera que va
de aquí para allá, que es nuestra focalización, si poseo, de nuevo, podemos ver en el medio, creo que es momento de crear un nuevo actor que
será nuestra bala. Vayamos al contenido.
Vamos a los planos. Y haz clic derecho y crea
nueva clase de blueprint. Va a ser
del tipo actor. Ahora bien, ¿por qué actor? Porque no lo
vamos a
estar poseyendo,
es sólo una cosa en nuestro
mundo que hace algo Voy a llamar a este
VP Bulet en realidad, porque vamos a
tener balas enemigas también Voy a abrir esto,
voy a guardar todo. Ahora bien, si se abre así, siempre
puedes hacer clic en
abrir Blueprint Editor y se abrirá normalmente Esto solo estaba mostrando los valores predeterminados de clase porque no
había nada
dentro del plano Vayamos a Viewport ahora. Vamos a agregar
tres cosas por aquí. Malla asmática que
agregamos en el jugador,
como agregamos en la nave espacial de la nave estelar
del jugador Porque vamos a
necesitar esto para el cuerpo. Llamemos a esto último. Ahora voy a agregar una flecha para los propósitos de los bugging
que tal vez necesitemos saber ¿Dónde está el delantero de esto? Voy a añadir componente de
movimiento de objetos. Este de aquí.
Es para proyectiles, como la que teníamos para el jugador,
el movimiento pon flotante Para los actores, podemos agregar
muchos otros componentes, pero uno de ellos es el movimiento de
proyectiles Crea un comportamiento
de proyectil. Puede ser rebotarlo,
hacer muchas cosas. Tiene muchas
opciones por aquí. No vamos a estar usando
todos ellos en esta bala, pero vamos
a estar usando algunos, especialmente la velocidad. Vamos a compilar y guardar,
ir a nuestro arte de eventos. Vamos a eliminar estos. No vamos
a estar usándolos, creo, empezar ya. Tampoco vamos a
usar eso. Vamos a crear eventos
personalizados. Seleccionemos nuestra bala y
vayamos a su configuración de colisión. Queremos configurarlos a una costumbre. Lo único que
vamos a cambiar, en realidad vamos a
cambiar todo para
superponerse en lugar
de dinámica mundial, vamos a hacer que
sea un mundo estático. Aunque básicamente sea dinámica
mundial, queremos que sea un mundo estático. Porque para nuestro sistema, nuestra línea de rastreo
busca un significado dinámico mundial, vayamos al trazo de línea. Podría ser más fácil lo que este rastro de línea busca en
nuestro sistema de focalización, hemos dicho bola
dinámica porque decidimos que estas
serán las cosas que estamos trazando para calentar nuestras
balas no deberían ser
del mismo canal
porque no queremos que sean rastreadas como objetivos No deberíamos estar disparando
a nuestras balas. Estamos cambiando las
dos palabras estática. Esto demuestra que las
categorías son para nuestro uso. Como si no pudiéramos decidir qué
está haciendo qué y por qué. Pero también cambié que se
superpone con todo. Este es un comportamiento completamente
personalizado. El jugador puede pisar, podemos
ponerlo a no, no va a importar. Viaja mucho más rápido que nosotros, viajará más rápido que nosotros. Dicho esto, no vamos a estar haciendo la parte dañada
de la bala en este momento. Vamos a estar haciendo eso cuando
creamos a los enemigos. Pero por ahora, lo que necesitamos es la bala para ser disparada y
viajar a esa distancia. Voy a crear
un evento personalizado, Vamos a llamar a esta bala. Lo que vamos a
necesitar de bala en
spon es una dirección Voy a seleccionar entradas
y otra entrada nueva. Va a ser
del tipo vector. Voy a nombrar
este parámetro,
este vector de entrada,
en realidad dirección vectorial. Esta es la dirección en la
que queremos que vaya
la bala.
¿Cómo vamos a hacer eso? Vamos a conseguir nuestro movimiento de
proyectil y establecer la velocidad Vamos a seleccionar
esta de aquí, no la velocidad en el espacio local. Voy a estar fijando
la velocidad no en espacio
local porque queremos que
se mueva en el espacio mundial. Ahora bien, puedo conectar
esto directamente aquí, pero como esta es
sólo una dirección que vamos a estar consiguiendo
como ir hacia
ahí, no sabe con
qué velocidad va. Voy a multiplicar
esta dirección. Voy a cambiar
esto a un entero. Voy a escribir 80,000 Porque estamos en el espacio,
las distancias son enormes 80 mil parece estar bien. Voy a
promoverlo a una variable. Llama a esa velocidad de bala
y conecta esto aquí. Esto es todo lo que necesitará nuestra
bala para saber a dónde viajar
con qué velocidad. Voy a compilar y guardar. Vamos a posponer esta bala de
vuelta a nuestro jugador. Jugador de planos, nave espacial. Planos. No en el sistema de
focalización. Vayamos a disparar. Estamos tocando un
sonido y está bien, pero tenemos que estar
generando también la bala Creo que este es un buen punto de
ruptura y seguiremos en
el próximo Adiós.
19. Completar el sistema de disparo: Hola y bienvenidos a Real
Engine Five Blueprint. Desarrollo de juego de
disparos espaciales paso a paso. En la última nos quedamos con la
creación de la bala en esta, comencemos con desovar la
bala que estábamos en el ocio, disparada una vez antes del sonido Vamos a poner
una secuencia de nuevo. Por secuencia dijimos que solo
hay disparos en orden. No espera a que se ejecute esta
línea. Lo que vamos a
hacer, porque nuestra arma tiene niveles como si tuviera
tiro nivel uno y nivel dos. A lo mejor puedas crear
un nivel tres después o agregar más armas, pero por ahora sólo vamos a tener este nivel
uno y el nivel dos. Voy a agregar una
nueva variable y llamar a esta arma nivel. Va a ser
del tipo entero 0123 tanto como queramos.
Ahora esto es un desastre. Nuevamente, comencemos a poner
algunas cosas en categorías. Tenemos la generación de resistencia. Esto es el consumo de
resistencia al movimiento. Fuerza de movimiento, tiempo, asa. O podemos crear un sprint
y poner todo esto en uno, pero sólo voy a
ponerlos en movimiento. Los objetivos deben ir a disparar. Voy a ir a tiro de
categoría, movimiento
cercano, entradas cercanas. Una gama de disparos de fuego primario,
disparos de tipos de objetos, disparos de actores
objetivo,
disparos , disparos, CD láser al disparar y nivel de arma al disparar. Tal vez pariente del cuerpo original. Voy a poner eso al
movimiento también, es animación. Voy a dejar
el widget así. Vamos a llevar nuestro nivel
de arma desde el nivel de arma. Vamos a hacer
un interruptor de selección. Ahora este es un nuevo nodo. Conmutador. Switch es un nodo interesante. Puede tener muchos
tipos de entradas como switch, estas son enumeraciones. Creo que la mayoría de ellos se enciendan. Por ejemplo, si tuviéramos
una cadena y podemos escribir casos que teníamos por aquí láser o si
tuviéramos una variable que estamos
cambiando esta palabra aquí, se dispararía en base a la palabra, ahora estamos usando un entero, se dispara en base a un número. Si app 01 en realidad 0.1 solo
tenemos dos casos, nivel uno y nivel
y nivel dos. En realidad, se puede decir que
el índice de inicio parte de, digamos uno, va a ir 12. Si digo inicio índice
inicia desde 15, va a ir 15, 16. También tiene este pin por defecto
que no vamos a usar. Pongamos índice desde 00.1
basado en nuestro nivel de arma, disparará en consecuencia Ahora lo siguiente que
vamos a necesitar para disparar es ¿de dónde
estamos filmando? Voy a ir a Viewport
y voy a seleccionar el cuerpo porque los puntos de los
que voy a filmar, quiero que estén
pegados en el cuerpo Cuando el cuerpo gira, también
giran. Y voy a añadir
un nuevo componente. Y éste
será como componente. Como componente es sólo un punto. Básicamente, se puede
tener la transformación de este punto y obtener alguna
información al respecto. Estamos agregando la escena
y vamos a
nombrar a este rompecabezas uno. En realidad, voy a
copiar y pegar esto dos
veces más para las actualizaciones posteriores. Voy a poner hocico
uno delante de la nariz, tal vez un poco más bajo Sí, eso parece estar bien ahí. Y voy a poner
bozal dos aquí. Parece estar bien. Voy
a copiar la ubicación. Voy a pegarlo en el hocico tres y quitar el signo
negativo de la Y. automáticamente
irá aquí Ahora tenemos algunos
puntos a partir de los que disparar. Lo siguiente que vamos
a hacer es cero seleccionado. Esto es lo mismo que
usamos spawn player. Es el mismo actor spawn
que engendramos al jugador, ahora vamos a estar
desove nuestras balas Esta es la forma en la que estamos
trayendo objetos, trayendo objetos al mundo. Una de las formas en que
voy a seleccionar la bala bala para transformar, voy a conseguir la
escena, la del hocico Voy a conseguir la ubicación mundial. Ahora bien, esto, como dice, devuelve la
ubicación mundial del objetivo, que es el de hocico En realidad, no ubicación. El mundo transforma, transforma. Una transformación es una estructura. Básicamente podemos dividirlo. No dice estructura, pero es una estructura combinada por tres vectores que
son la ubicación, la rotación y la
escala de un actor. Si lo escribo, haga clic de
nuevo. Puedo recombinar Voy a conectar la
transformación de pared del músculo uno al engendro de los eventos
del hijo deportivo Ahora necesitamos conectar una dirección aquí como
dijimos para dar de dónde, porque estoy desove la bala en este punto del mundo Pero ¿hacia dónde voy? ¿Dónde debo
aumentar mi velocidad? Hacia donde eso lo
colocamos aquí dentro de la bala. Multiplicamos esa dirección. Estamos estableciendo la velocidad,
estamos ajustando la velocidad. Para ello, vamos a
necesitar de nuevo algunas matemáticas. Pongamos esta matemática
en una función y llamemos a esta función apuntando tal vez cálculo de dirección. ¿Bien? Voy a seleccionar
esta función y seleccionar este nodo puro por aquí. Y seleccionar una salida que
sería del tipo nombre. Voy a conseguir dirección. Voy a volver a par gráfico y traer esta función. Ahora ves que esta función es
diferente a las otras funciones. Este tiene una
línea de ejecución como ésta la tiene. Esto es por lo puro. Cuando es puro, no
tiene línea de ejecución. Cuando no es puro,
tiene una línea de ejecución. Voy a conectar esto aquí. Volvamos al interior de la
función y hagamos algunas matemáticas. Lo primero que
vamos a usar es como el vector forward que obtuvimos dentro de nuestro sistema de
targeting cuando estábamos creando
el final del objetivo. Obtuvimos este
vector get forward de la cámara. Ahora no necesitamos el
delantero, nuestro hocico. Digamos que vamos
a conseguir nuestro hocico. No necesitamos el
vector delantero del hocico. Lo necesitamos relativamente al objetivo porque sí
tenemos el objetivo. Voy a conseguir la
ubicación del hocico. Entonces voy a conseguir el objetivo también la
ubicación del objetivo, y voy a
restarle esto a Este es un vector. El resultado es un
vector que apunta desde el swing hacia el objetivo. Pero en las coordenadas mundiales, esto es sólo una dirección. No sabe dónde
gustar en las
coordenadas totales del mundo. No tiene idea. Simplemente
sabe de aquí para allá. Pero donde en el
mundo Para agregar esto, solo
voy a agregar la ubicación mundial
del hocico En realidad, esta
atracción debe ser el objetivo de
la palabra ubicación, no la palabra ubicación
del objetivo. Esto tiene que ser opuesto. Ahora parece que
estamos haciendo lo mismo. En realidad no es porque
esto nos esté dando una dirección y estamos agregando esa dirección a
la ubicación mundial. Esto nos da un desplazamiento, digamos, de este
tamaño hacia ahí. Entonces le estamos diciendo
en qué parte del mundo, para que ocurra el desplazamiento. Hagámoslo en un ejemplo. Vamos a crear un nuevo tablero, nuevo tablero, el anterior. Digamos que solo tenemos un eje
x e y. Tenemos un 0.1 inicial
Digamos 2.1 Tenemos nuestro punto de
partida aquí, Tenemos 2.1 esto
es x, esto es y Tenemos nuestro objetivo en, digamos cuatro, el
objetivo está aquí. Y 444 tenemos nuestro objetivo aquí. Lo que obtenemos cuando restamos el 4.1 del 2.1 es
cuanto es esta distancia, básicamente a que fueron
a esta distancia, estamos sumando la palabra
ubicación de esta,
este 2.3 de tamaño 2.3 debería comenzar en
1.2 en esta distancia Vamos a restar
la palabra ubicación, nuevo, para darnos esto en una escala mundial
basada dentro del mundo Entonces vamos a
normalizar el resultado, lo que nos dará un valor 0-1 A partir de eso
obtenemos una dirección Vamos a completar esto. Vamos a restar otra vez de aquí Vamos a estar restando la ubicación mundial del punto
de tiro A lo mejor nosotros conectamos esto aquí. Oh, ¿sabes qué?
Podemos simplemente copiar, no cortar. Copia esto de aquí a aquí. Y ponlo así
y cables normales. Y ahora vamos a
normalizarlo y vamos
a conectar esto aquí. Recopilamos y guardamos y
vamos a nuestro gráfico de inbern, a nuestro mecánico de tiro, y ya está conectado Esto debería estar
funcionando ahora mismo. Si mostramos
iniciarlo, no es porque no hayamos
agregado nada para
mostrarnos una bala. Hagámoslo muy rápido. Voy a seleccionar
para una malla estática, la forma cápsula estrecha. Voy a rotarlo
hacia nuestra dirección. Voy a escalarlo a 0.6 y 0.6 lo haré también,
así que está un poco
estirado para el elemento. Vamos a elegir
uno de nuestros materiales, por cierto, la malla estática. La puedes encontrar en la carpeta
estática Me de aquí. Para nuestros materiales,
voy a usar el jugador MI bullet Globe y tenemos una jugada Bullet
Express. Podemos, así que vayamos
a nuestra nave espacial. Vamos a nuestro sistema de focalización. Desmarca esto. Dibuja
el tipo de espalda a non, esta esfera no nos molesta. Estamos disparando. Déjame bajar el sonido
porque es un poco molesto. Hemos creado una toma. Nos estamos moviendo y
estamos filmando. Nuestras balas van directamente a
la mitad de nuestro objetivo. Como podemos ver cuando me mudo, ellos simplemente dan seguimiento porque la
velocidad y todo está bien. Creo que esto es para éste. Te voy a
ver en la siguiente. Adiós.
20. Componentes enemigos y sistema de daños: Hola y bienvenidos de nuevo
a Unreal Engine Five. Desarrollo de juegos de
disparos espaciales paso a paso. En la última,
empezamos a filmar cosas. Creamos esta mecánica de
tiro. Si empezamos ahora y
empezamos a disparar, realidad
estamos disparando
algunas balas sobre nuestros objetivos, en nuestro objetivo, en nuestro objetivo. Y podemos correr y disparar, y correr al mismo tiempo. Genial. Ahora en esta, creo que es el momento de
poder disparar a algo. Pero antes de hacer eso,
completemos y probemos el nivel dos. Ahora como estamos usando
hocico uno aquí, podríamos estar usando solo hocico
2.3 y recrear Pero en lugar de hacer eso, solo
vamos a optimizar esto un poco y hacer
una función de. Lo primero que
vamos a hacer es ingresar nuestro cálculo
de direcciones desde este bozal Voy a
conectarlo como entrada. Verlo creó esta
entrada conectada aquí. Y también voy a
conectar este también. Ahora podemos tener un hocico
uno externamente ajustado. Ahora lo común entre estos dos
es el hocico uno aquí Yo solo voy a conectar esto también en realidad voy a
hacer una nota re redonda aquí, mantener el hocico afuera y seleccionar todos y
crear otra función Voy a llamar a
esto láseres láser. Voy a entrar
ahora, una nueva entrada. Voy a conectar
esto por aquí. Voy a llamar a
este bozal puntos. Volver al gráfico de eventos. Voy a conectar
hocico aquí. Ahora está más ordenado. Ahora voy a
copiar esto dos veces. Copiarlo y pegarlo dos veces. Ahora voy a usar un Liplde. Para ser honestos,
no necesitamos dos de estos. Sólo necesitamos uno más. Voy a arrastrar un selecto desde el punto del hocico y traer
mis otros dos puntos de hocico Ahora voy a
conectar esto aquí. ¿Qué es un nodo flip flop? Un nodo flip flop significa que cada vez que se ejecuta,
corre primero. Después primero un BB simplemente chancletas entre
estas dos líneas de ejecución. Los vamos a conectar aquí a
ambos. Yo sólo voy a
conectar a la ESA aquí. Ahora nuestra pistola va a estar disparando una vez
desde el hocico 11, tiempo desde el hocico tres para el hocico 2.1 tiempo
de
uzzle Si desconecto el
nivel de arma y solo escribo uno aquí, en realidad
puedo probar
el arma de nivel uno. Como se puede ver,
van al blanco. Ahora bien, no estoy seguro si
es muy visible, pero la rotación de las balas va un
poco hacia el objetivo, pero no está tan bien girada. Si volvemos a nuestro plano de
bala y vamos a proyectar movimiento Movimiento del proyectil, hay esta rotación sigue la velocidad Deberíamos comprobar esto y
compilar y presionar play. Ahora podemos ver que nuestras balas
están mucho mejor rotadas. Bien, podemos
disparar desde el nivel cero, podemos disparar desde el nivel uno. Ahora el nivel tres sería
una combinación de esto. Compilar y guardar. Comentemos éste. También llámalo, pongamos esto ella aquí. Voy a traer
esto dentro de entradas. Sólo voy a
bajar el comentario. Ese es uno, compilar y guardar. Es hora de hablar un
poco de nuestros enemigos. Al principio dijimos
que vamos a usar a un actor padre para usarlo
con actores infantiles. Lo que esto significa,
básicamente tendremos un actor base que
será nuestro padre. Tendremos algunos actores
hechos de este actor. Eso tendrá sus
propias propiedades, pero mantendrán
propiedades comunes del actor padre. A lo mejor esto necesita una doble M. No
estoy segura. En fin, las propiedades comunes van
al actor padre y luego creamos hijos. Esto es padre, tal vez la
ortografía es incorrecta. No importa que
vamos a tener un enemigo. Llamemos a este boom enemigo. Tendremos otro enemigo que disparó lo que hará el enemigo Boom. Boom Enemy encontrará
dónde está el jugador e irá directamente sobre el
jugador como una explosión En realidad, cuando el enemigo toque al jugador,
entonces explotará Y a ambos daños daños, el jugador se dañará y el enemigo boom
quedará destruido. Ahora el otro enemigo, va a tener un comportamiento que cuando tengamos al jugador, elegirá un punto aleatorio
alrededor del jugador para moverse. Si está a cierta distancia, comenzará a disparar. El patrón de disparo será la ubicación del jugador más y menos de esta
ubicación alrededor. Al igual que vamos a crear
un efecto aleatorio. Ahora todos los, comenzaremos con la
creación de las cosas comunes. El plano padre. Vamos a averiguar qué va a tener
el padre. Lo común que
todo utilizará
sería una malla estática para
representar la nave. Digamos, no estoy
seguro de cómo se deletrea. Decir malla estática, una flecha para decirnos la dirección
y el sistema de salud. Ahora como notas, no
hemos hecho un sistema de salud
para, para el jugador también. Este será un sistema
que estaremos adjuntando a los
enemigos y al jugador. Esto se llama
componente de plano y es lo mismo que el movimiento
del proyectil
o el componente de movimiento
flotante que hemos utilizado Pero este será un componente
que creamos y
queremos adjuntar este comportamiento
a algunos otros planos Este es el trabajo de componentes a adjuntar a los planos
y dar un comportamiento Creo que es un buen punto de
partida para agregar esto. Para crear esto primero
podemos agregarlo al jugador, configurarlo y luego seguir
adelante con los enemigos. Antes de dejar algunos
otros atributos comunes que tendrá el padre que
tendrá el plano
padre serían variables de
velocidad, como qué tan rápido
se va a mover el enemigo Una variable de punto que podría ser Xp o como podamos
llamarla, apunta ahora mismo. Variable de daño. Una variable de daño por
colisión, esto sería todo del
tipo float o integer. La razón es porque estos
son solo puntos estáticos que queremos establecer
como algunos valores predeterminados. Y tal vez ciertos enemigos
podamos por su cuenta, como en el plano infantil Los estaremos cambiando
si es necesario. Pero si los tenemos
en el padre, siempre
podemos establecer
un valor predeterminado para cada variable de estas. Vamos a cerrar la pintura. Volvamos a nuestro proyecto. Vaya al navegador de contenido,
vaya a Blueprints
y haga clic derecho en Crear
nueva clase Blueprint Ahora de esta lista, tenemos este componente actor. Un componente actor es un componente re utilizable que
se puede agregar a cualquier actor. Esto es lo que estamos usando. Componente actor, llamemos a
este sistema de salud P C. En realidad dañar
cualquier cosa que tenga esto puede dañarse y
puede perder algunos en puntos. Digamos y abramos esto. Ninguna diferencia especial
entre un blueprint y un componente blueprint es que aquí no tenemos una No podemos estar sponing componentes, pero no podemos estar agregando
componentes como
podríamos en el blueprint
en la lista de componentes En este sistema,
vamos a estar usando dos variables y básicamente
una salud y una salud actuales. Todo lo demás será modular. El actor al que
pertenece este
componente se obtendrá automáticamente. No necesitamos una
referencia para eso. Por ejemplo, cuando nosotros, cuando queríamos mostrar los
cursores en targeting en el player targeting aquí teníamos una referencia
al widget Teníamos una referencia
a los widgets. Entonces podemos llamar a la función de
widgets y decir, no apuntar o hacer que la función target ejecute
la función target. Qué pasa cuando no
tenemos referencia, porque vamos
a estar adjuntando este plano a cualquier actor Bueno, para eso
vamos a conseguir dueño, lo que significa básicamente a qué
actor de planos pertenezco? Y esto
nos dará ese retorno. Para especificar el actor
necesitaríamos emitir a un actor. Pero como dijimos cuando estábamos haciendo la
comparación en el menú principal, si nuestro modo de juego es el modo de juego del juego
que hemos seleccionado, esto estaba devolviendo un objeto. Fue durante una
clase general de un modo de juego. Especificamos
eres este modo de juego, podríamos ser castings jugador nave espacial y obtener si nuestro dueño es la nave espacial
y luego Pero cuando queremos hacer las cosas sin especificar a quién pertenece
la referencia. Las técnicas de valor
que podemos utilizar para pasar este mensaje a los actores de que no sabemos
qué actores son. Dos de ellos que estaremos
explorando serían el bind on
damage event, interfaces de
planos Pero creo que esta es suficiente
información para ésta. Creo que deberíamos detenernos aquí, tomarnos un descanso, y continuar
en el siguiente adiós.
21. Componente dañable y salud del jugador: Hola y bienvenidos de nuevo
a Real Engine Five. Desarrollo de juegos de
disparos espaciales paso a paso. En la
lección anterior, platicamos un poco sobre nuestros enemigos y cómo funcionará el sistema. Y empezamos a
trabajar en el BPC, el componente blueprint
dañable que estaremos agregando a nuestro jugador
y a nuestros enemigos Terminamos
hablando un poco sobre eventos
Bind e interfaces de
blueprint Consigamos y veamos qué
hacen en acción. En primer lugar, vamos a crear
una interfaz de blueprint. Mira como hacemos esto, escribimos, click, vamos a categoría
blueprint Aquí, hay una interfaz de
blueprint. Ahora voy a nombrar a
este I comunicaciones. Las comunicaciones de planos no importan, de
verdad. El nombre. Puedes ponerle el nombre que
quieras. Vamos a abrir esto ahora. Ves, esto abre un plano muy diferente al
que estamos acostumbrados Esto tiene los detalles por aquí. Sólo tiene funciones, no tiene variables. Esto es lo que son las funciones de
hosting. Hagamos una función,
tiene una por defecto. Vamos a nombrar esta actualización el. Si tenemos esta función
llamada update on, como pueden ver, no puedo
poner ningún código aquí. Esto se debe a que tenemos que
hospedar esto en planos. En otros planos,
podemos poner entradas y salidas como antes en
cualquier otra función que hayamos creado Hagámoslo. Pongamos dos, en realidad necesitamos 21
sería salud. Va a ser
del tipo flotador. El otro sería lingotes. Y vamos a estar preguntando
si el objetivo está muerto. Se va a quedar lingotes. Ahora tenemos las dos
entradas en esta función, pero no podemos poner
ninguna otra llamada. Como dije, esto es
porque tenemos que
alojarlo dentro de otros planos Si digamos a partir de
aquí esta función, necesitamos compilar y la
función está actualizada sobre. Puedo mandar este mensaje aquí. El dueño debería tener
algo que ver con ello. Si eso tiene algún
sentido. Estoy mandando un mensaje a alguien. Realmente no
sé quiénes son. Yo sólo tengo una idea general que es una referencia de acto u
objeto. No es el jugador de planos. No es el enemigo plano. No es la bala del plano. Cualquier actor está recibiendo
este mensaje. Si el actor tiene
que hacer algo con ello, tiene que saberlo. Ahora, ¿cómo lo sabe el
actor? Bueno, vamos a, digamos la nave espacial
jugador de la BV Y vamos a
valores predeterminados de clase, Ajustes de clase. En la parte inferior aquí,
dice interfaces, interfaces
implementadas. Voy a agregar y
voy a agregar el BI. Ahora que agregué, puedo compilar. Y cuando compila, veo que
ha aparecido una nueva categoría A. Aquí, dice interfaces. Si abro esto, tendrá la función que
creamos en B. Viene de nuevo, para resumir, para agregar una
interfaz de blueprint a un actor, vamos a Configuración de Clase, vamos a Implementar Interfaces, y presionamos Agregar, y
agregamos nuestra interfaz De esta manera exponemos
las funciones, o podemos crearlas como eventos si no
tienen una salida del
blueprint de interfaz que hemos creado en este momento Esto nos permite llamar a
cualquier propietario que funcione. Y si el dueño lo tiene,
va a hacer algo. Eso lo podemos hacer con cualquier
acto u objeto de referencia. Cuanto más trabajes con lo real, más estos
sistemas se convertirán en segunda naturaleza y los
entenderás más. Ahora lo siguiente que llamamos, en realidad fue lo primero de
lo que
hablamos fue de encuadernación, algo a esta
referencia general de un actor. Si es un vínculo, consideramos que hay muchos
eventos para ligar. Se trata de eventos que son
comunes a todos los actores. Actor comienza, se superpone, se superpone. Considéralo como funciones
prefabricadas. Comportamiento prefabricado con guión
en el actor de clase. Para nosotros, llamaremos
eventos vinculantes, tomaremos cualquier daño. Vamos a traer esto aquí. No vamos a necesitar
esto todavía, en realidad. Vamos a eliminarlo. Ahora, los eventos bind ocurren
en eventos, o acciones, o funciones que
son por defecto, existen de irreales También podemos crear algunas cosas sobre nuestros eventos y unir cosas. Ahora es un poco
más avanzado. Como podemos ver aquí en evento, tiene este icono que podemos ver ambos comunes en cualquier evento, como si vamos a algún evento, vamos a ir al barco jugador. En realidad, como pueden ver, está aquí con la línea de tiempo. Además, este evento lo tiene. Además, así es como
vinculamos eventos. No lo tenía claro
cuando estábamos haciendo esto. Esta es la forma en que
estamos vinculando eventos a algunas cosas de aquí. Si llamo al evento, verán
que es un
poco diferente porque este evento representa
un evento de cualquier daño. Si voy a mi jugador
y hago clic derecho, vamos a acercarnos y escribir cualquier daño hay
este evento, cualquier daño. Como pueden ver, este tiene el mismo tipo
Outcus que este, con la excepción de este actor dañado que es una referencia al
actor que se dañó Ahora vamos a crear dos
funciones, dos nuevas funciones. Al uno lo llamaremos, al otro lo
llamaremos quitar salud. También agregue dos variables
del tipo float. El uno sería la salud de los padres. El segundo
sería salud máxima. Podríamos haber eliminado en una función y
decidir de alguna manera con un lingote o simplemente
restando en
un símbolo matemático más,
que en un símbolo matemático más, realidad es Pero en aras
de una depuración fácil, deberíamos hacer dos funciones Ahora, en la primera, vamos a establecer la curva
dos menos el daño de entrada. Conecté esto aquí y
voy a nombrarlo mucho, siento, en el pin de abajo. Porque si pongo esto, la
subducción va a estar equivocada. En el de arriba. Voy a
agregar salud actual. Ahora tenemos que agrupar esto. Recuerda la pinza que
estamos estableciendo un valor mínimo y un valor máximo como límites sobre el resultado de
este valor de esta acción. Para la salud máxima,
voy a establecer la salud máxima. Después de esto, voy a
conseguir dueño del dueño. Voy a llamar al dueño de la actualización. Voy a conectar esto aquí y voy a conectar
la salud actual aquí. Para eso sólo voy a
comparar es igual a cero. Si esto es cierto,
entonces volverá true y compilará y guardará. Ahora en Add Health, vamos a hacer lo contrario. Vamos a Salud actual
y vamos a sumar. Ahora en esto no importa
sino solo por el bien de la visibilidad haciendo cables. Cierto, voy a ceder entre, nuevo tenemos que agruparnos esto Voy a copiar
esto. En realidad voy a copiar todo esto otra vez. Voy a pegar
esto y conectarme. Conéctate este año.
A lo mejor hacer algo de espacio. Sí, se ve bien.
Y voy a conectar esto también aquí. Estas funciones están listas para
agregar salud o eliminar la salud. Ahora vamos a la gráfica. Cuando estamos vinculantes algo
en tomar daños sería re. Voy a traer aquí el
quitarle la salud. Voy a agregar esto aquí. Y es que este
será nuestro BPC dañable. Este será el componente que
dice que este artículo de aquí tiene salud y cada vez que recibe
daño se está quitando
del charco de salud. Cambiemos el nombre de esta Renta Encuentra de Daños, Compilamos y Ahorra. Ahora agreguemos la salud, antes que nada, a
nuestro barco jugador. Ya llamamos a
cualquier evento de Daños. Ahora necesitamos agregar nuestro componente como lo hicimos en
el movimiento de punto flotante. Nosotros vamos a hacer lo mismo. Vamos a ir Componentes, y ahora vamos a
escribir BPC Damageable Ahora bien esto es dañable, nuestro personaje es Pero si selecciono la
BBC dañable como seleccionamos el estanque
flotante y
tiene algunos atributos por aquí,
algunos detalles lo mismo tiene algunos atributos por aquí, algunos detalles Tenemos solos, tenemos dos
variables que necesitamos establecer, Salud
actual y salud máxima. Voy a poner ambos a diez ahora nuestro personaje tiene diez en vivo
ahora, evento cualquier daño. En realidad no necesitamos
hacer nada en el evento ningún daño porque esto es
lo que hemos atado por aquí Siempre que este actor
desencadene esto, porque esto es un componente
de ello, lo activará. Vayamos a nuestro jugador.
Voy a borrar esto. Sin embargo, lo que vamos a necesitar
es nuestra función de interfaz porque creamos aquí y dijimos que no
podemos poner ningún código. El código viene
dentro del reproductor. Voy a hacer doble clic en él. Creó un evento
automáticamente. Si tuviera una salida
automáticamente, pasaría a funcionar. Pero creo que esto es
suficiente para éste. Vamos a
continuar en la siguiente. Adiós.
22. Arquitectura de planos enemigos: Hola y bienvenidos de nuevo a
Annual Engine Five Blueprints. Desarrollo de juegos de
disparos espaciales paso a paso. En la anterior,
terminamos nuestra BBC,
nuestro componente blueprint, Damageable Vincamos el evento sobre cualquier daño recibido y
eliminamos la salud. Creamos una función
para agregar salud también, agregamos a nuestro jugador. Entonces dijimos que
nuestra salud actual, los valores
máximos de salud, nos
quedamos con actualizar dueño. Vamos a continuar. En primer lugar, deberíamos preguntar si
nuestro jugador está muerto. Ir a la sucursal aquí
y crear esta rama. Estamos preguntando, ¿está muerto
el jugador? ¿Cierto? Si el jugador está muerto, vamos a crear una
función llamada Spooky Name Vamos a conectar esta
función por aquí más tarde. Podemos llenar esta función
cuando sea necesario. Ahora cuando el jugador no está muerto, lo que deberíamos hacer
es de alguna manera mostrarle al jugador que tiene
algo de salud Para hacer eso, vayamos a nuestra U.
Yo jugaría juego,
iría a pestaña de diseñador. Y copiemos esta
parada en un bar, vamos a colocarla un
poco arriba, asegurémonos de que es el lugar donde vamos
a anclarla así. Cambiemos los
colores a un poco de verde. La opacidad de Pilin,
también algo verde. Bonito. En realidad el fondo
debería ser rojo, creo. Verde. Sí, esto tiene más
sentido. El fondo rojo y
el primer plano verde. Ahora, voy a renombrar este bar Health Bar B Health Park. Voy a ir a graficar y
como creamos un porcentaje establecido, ¿qué se actualiza? Tam por ciento. Vamos a duplicar
esto y vamos a llamarlo actualización por ciento. En lugar de tener resistencia PB, voy a hacer click derecho sobre él. En realidad, no puedo hacer esto. Árabe. Sí, voy
a borrarlo y traer esta parte de salud PB. Y esta función está completa. Volvamos a
nuestra nave de jugadores. Y en la rama falsa
del propietario de actualización, vamos a obtener la
referencia de nuestro widget. Y vamos a
establecer set, perdón, Actualizar por ciento de salud ahora 4% voy a traer la
BBC dañable para que pueda obtener Max Health porque el jugador no
tiene una variable Está dentro del componente. Voy a obtener el componente, obtener de él la
variable de salud de Max. Voy a dividir con la salud. Esto nos dará el porcentaje. Comentemos esto. Vamos a comentar,
actualizo todo eso. Vamos a probar. Presionemos play.
Podemos ver una parte de salud. Sin embargo, no se ha actualizado, porque no hemos recibido
ningún daño. Arreglemos esto. Entonces vayamos a nuestro barco ahora donde creamos el widget como actualizamos
para pisar fuerte por ciento, haremos lo mismo por la salud Vamos a conseguir
esto un poco por aquí desde el widget. Voy a llamar a Update Health. Dibujaremos de
esta subdivisión. Y traer el BPC y
obtener la salud actual dividido por obtener salud, compilar y ahorrar Trae esto aquí en
esto aquí. Todo bien. Compilando guardar. Por fin es momento de
comenzar con nuestro enemigo. Ya que hemos completado
nuestro ingrediente faltante, el sistema dañable para la salud, este momento vamos a crear un plano de que
tenemos una malla estática,
una flecha, el componente de salud, y algunas variables
para los puntos de velocidad o x p. Como quiera
llamarlo por el Vamos a hacerlo en el navegador de
contenido Abrir
planos. Haga clic con el botón derecho. Nueva clase de plano
de actor tipo. Ahora bien, si tuviéramos una IA
controlando este árbol de IA, estaríamos, eso significaría estar sobre, porque un controlador de IA
posee p. Pero como estamos controlando a los actores
en base al movimiento para localizar el
movimiento vectorial básicamente, y algunas reglas simples, no
necesitamos eso. Por lo que serán de tipo actor. Vamos a nombrar a esto
BP Enemy Parents. Y vamos a abrirlo ahora. Vamos a agregar un Ce estático. Vamos a nombrar
el cuerpo enemigo. Ahora vamos a agregar una flecha no palentada, a
la malla ranurada Y vamos a agregar
nuestro PPC dañable. Vamos a darle una salud actual de ocho y salud de ocho. Compilar y guardar.
Vayamos a la gráfica par. No vamos
a necesitar todo esto. Vamos
a necesitar agregar nuestra interfaz
ya que nuestro BPC tiene esa interfaz
y nos envía un mensaje Y vamos a
usar eso,
vamos a agregar los pops de interfaz. Si no agregáramos la interfaz, lo único que
pasaría es que este actor recibiera el mensaje
y no pasaría nada. Voy a compilar y guardar. Voy a seleccionar
nuestra malla estática. En la malla estática iré a Comenzaré evento de
componente de superposición. Antes de continuar con el
componente comenzamos a superponerse, comprobemos que
las colisiones de este cuerpo son dinámicas de guerra pero
lo está bloqueando todo Vamos a hacer colisión
personalizada,
vamos a configurarlo para que bloquee solo el peón y superponga todo lo demás
que voy a compilar, digamos que en realidad no
se superponga todo No hay necesidad
porque en el momento en que nos superpongamos estaremos
destruyendo a este actor. Superponga todas las dinámicas mundiales para que nuestro sistema de objetivos de bala pueda detectarlo y eso está hecho. Ahora, ¿cómo sabemos que
superpusimos al personaje? Este es un evento de superposición. Nos da componente de superposición,
otro componente. El componente de superposición se
trata de nuestro componente, otro actor actor,
estamos superponiendo. Otro componente es el
componente del otro acto. Ahora, hay algunos
detalles más sobre aquí lo que queremos que se moleste con ellos porque
no los vamos a usar. ¿Ese componente, esta etiqueta. Si eso es cierto,
entonces haz algo. Si eso no es cierto,
entonces no hagas nada. Estamos trayendo aquí una
declaración if. Vamos a necesitar nuvariable, la que dijimos, colisión,
Damas, para establecer un valor por defecto o qué cantidad de daño vamos a necesitar
cuando estamos Vamos a hacerlo a flote
y llamarlo Daño por Colisión. Vamos a compilar para
darle un valor por defecto. Y el
valor por defecto debería ser uno. Compilar de nuevo, chocamos con el cuerpo del
jugador. ¿Qué pasa? Ahora aplicamos daños. Este es un nodo listo hecho de Unreal para pasar información de
daño Es el que
usamos cuando
lo atamos en el componente, en cualquier daño recibido,
tomamos cualquier daño. Cuando estamos aplicando
daño de un enemigo, éste desencadena este. Aquí vamos a conectar los daños por
colisión. Para el actor de daños, vamos a conectar
al otro actor. Si un instigador es una forma de
pasar información, por ejemplo, quien hizo el daño
o causador de daños
también se puede pasar alguna
información extra, dos diferentes El controlador que fue
responsable de este daño y el objeto real que causó el daño que
causó el daño. Se trata de formas de pasar otra
información y tipo de daño. Si tuviéramos clases para el tipo
Damas, pero
no vamos a estar usando esto. Nuevamente, valor de retorno,
el daño real terminó como si esta fuera una función con un
nodo de salida en nuestro jugador, tendríamos algo
a cambio después de hacer esto. Después de aplicar daño, vamos a crear
otra función mantener la muerte, y la vamos a agregar aquí. Vamos a entrar en la función muerte. Lo que vamos a hacer
cuando un enemigo es volcado, vamos a engendrar
emisor en Por la ubicación,
vamos a obtener una ubicación co. Si quisiéramos generar
un sistema de Niágara,
usaríamos el sistema de desove en el lugar Ya ves que también está en el Niágara. Mientras que el medidor de lapso
está en los efectos. Vamos a seleccionar
la explosión. Vamos a hacer la
escala un poco más grande. Vamos a destruir actor. Vamos a compilar y guardar. Creo que esto
sería por éste. Dijimos muchas cosas
en la siguiente, vamos a crear
el primer enemigo. Adiós.
23. Primer diseño y movimiento de enemigos: Hola y bienvenidos a un
Engine Five Blueprints, desarrollo de juegos de
disparos espaciales
paso En la última, creamos el padre enemigo y
creamos el sistema. ¿Qué sucede cuando el enemigo se superpone con nuestro cuerpo de jugador Ahora vamos a crear un sistema
cuando el enemigo realmente muera. Cuando él aquí es salud aquí. Cuando es salud aquí se
ha ido a cero. En nuestra BBC Damageable
que podemos agregar en cualquier cosa que
queramos que se dañe Cuando estamos quitando salud, estamos llamando al
propietario de actualización al padre enemigo. Agregamos esta
interfaz y la
vamos a usar haciendo
doble clic sobre ella, creando este evento. Lo único que
queremos comprobar de verdad,
es, ¿esta cosa está muerta? Voy a la sucursal
y voy
a conectar esto aquí, los muertos. Si es verdad,
voy a llamar a la muerte. Ahora estamos listos para
crear al enemigo, el primer hijo de
este plano Voy a guardar y compilar. Haz esto, voy a seleccionar PP, Padre
Enemigo, haz click derecho sobre él. Y en la parte superior aquí dice
Create Child Blueprint Class. Ahora voy a
llamarlo Enemigo. Voy a abrirlo. Ahora se puede ver que este plano ha
heredado la flecha, el cuerpo enemigo, el BPC,
dañable, y Ahora en realidad hay dos cosas más que necesitamos
agregar al enemigo padre. Necesitamos agregar dos variables
más. Uno de ellos se va
a llamar Speed, va a ser
el tipo integer, y el otro
va a ser puntos. También va a
ser el tipo entero. Ahora hemos terminado
con el enemigo padre, vuelta al enemigo boom. Ahora necesitamos velocidad, claro, porque este enemigo
se va a mover. Pero antes de hacer eso,
usemos el yo estático que
tenemos para un enemigo. Voy a ir a medidas estáticas. Y voy a seleccionar
enemigo B y agregarlo aquí. Ahora bien, si este enemigo se
estuviera moviendo hacia nosotros, estaría un poco rancio Para que sea un
poco más interesante, solo
agregaremos un componente
giratorio. diremos
a la rotación que esté en el eje y, en menos 180 en lugar del eje Z. Girará de esta manera. Ahora, el uso de un
componente de rotación tiene muchas habilidades
y atributos. Queremos utilizar el espacio
local porque no
queremos que rote
basado en el mundo. En realidad solo queremos
rotar el cuerpo en Begin play. Voy a conseguir este componente de movimiento
giratorio. Es un componente como
es el BPC dañable, solo existe por defecto Vamos a establecer la actualización de
este componente para establecer el componente actualizado. Voy a conectar esto para
comenzar a jugar por el componente, voy a elegir
el cuerpo enemigo. Ahora bien esto no gira
a todo el actor
, solo gira este cuerpo. Esto es todo bienes,
pero no se mueve. Hagámoslo mover, ya que recibir daños y hacer daño al chocar se hace en el padre Aquí, sólo necesitamos el movimiento. Lo haremos en tick. Entonces mueve cada fotograma y el movimiento
parece más natural. No se puede establecer en la ubicación
estableciendo la ubicación del actor, y el nodo establece la ubicación del actor. Ahora para la nueva ubicación
interpretaremos para nuestro objetivo. Vamos a conseguir la ubicación de
nuestros jugadores. ¿Cómo lo hacemos cuando no
tenemos referencia al jugador? Aquí, vamos a presionar click
derecho y obtener jugador. Esto no importa
qué personaje tengamos. Podría ser cualquier personaje. Es el
peón controlado en ese momento. Vamos a llegar al lugar. A partir de esto, vamos
a conectarlo a target. Ahora nuestro enemigo se mueve
hacia el jugador. Ahora necesitamos
conectar ese tiempo. Voy a
conectarlo al evento. Esto depende velocidad de fotogramas de
los actores
a partir de la velocidad inter. Queremos que la
variable de velocidad de los padres que en realidad
no tenga un valor predeterminado. Vamos a establecer un
valor predeterminado de 500. Y vamos a establecer el valor por defecto dos puntos también. Vamos a
ponerlo en uno. Compilamos y guardamos
ahora estas variables. Los queremos en nuestro carácter, pero nuestro primer enemigo, pero no podemos verlos. Hay una opción aquí arriba donde dice My Blueprints Add, y tiene este icono aquí son las opciones para esta pestaña aquí, variables heredadas. Si hago clic en esto, podemos ver todas las
variables heredadas en base a esto. Pero también tiene la
replicación, la renderización, y muchas otras que son variables heredadas de
las variables de tipo actor. Ahora podemos ver las colchonetas de
colisión, la velocidad y los puntos, y de hecho
podemos manipularlos. Queremos manipularlos, solo
usamos la velocidad para
conectarlo aquí aquí. Antes de probar,
revisemos nuestras colisiones. Vamos a la dinámica
mundial de mis padres. Esto podría ser
no, realmente no importa. Consulta personalizada y superposición dinámica
del mundo de la física. Todo aquí debería ser
igual porque hereda. Bien, ahora vamos a
nuestro jugador, selecciona la casilla. Ahora la caja debe ser personalizada. Nuevamente, la estática debería
superponerse a todo, tal vez excepto una estática que
debería bloquear la física de consultas. Ahora en el cuerpo, el cuerpo debe superponerse a todo
y debe ser peón En realidad no quienes estudian, porque nuestros cuerpos son peón Entonces debería tener p
tipo de objeto física coreana. Esto podría ser no,
todo se ve bien. Vamos Juego de Inicio de Prueba. Y no hay
enemigo en el mapa. Traamos al mapa a un enemigo. Digamos también de todo. Juguemos. Aquí está el enemigo. Creo que está bastante claro
que se mueve hacia nosotros. Sin embargo, no en la
rotación correcta. Si voy en esta dirección, no gira para mirarnos. Eso es algo que
vamos a arreglar la siguiente lección. Si le disparamos, nuestras
balas no hacen daño. Aún no lo hemos programado
, ni están siendo destruidos. Pero si ves que su
camino parece recto, que no es recto, en
realidad está
penetrando a nuestro enemigo. Y parece que es recto. Ves derribar aquí. Parece que va hacia arriba, lo que en realidad va detrás del enemigo.
Y así se ve. Ahora bien, si dejamos que el
enemigo nos ataque, obtenemos algún daño, ¿verdad? Sí, creo que esto
es para éste. Ahora hay un montón de errores. ¿Por qué ocurren estos errores? Digamos que el acceso, el
no intentar leer la propiedad establece la ubicación del actor
en nuestro enemigo del boom de BP. Todos estos errores son iguales. Estos son los errores
que se están creando porque
no engendramos al enemigo, solo lo
colocamos en el nivel y está
buscando a un jugador Y aún no hemos
pulsado Iniciar juego, No puede encontrar un jugador. Y dice error
no puede encontrar al jugador. Cuando empezamos este
error deja de ocurrir. Pero no vamos a estar colocando
enemigos así, y estos errores no
van a suceder. Déjame borrar al enemigo. Sí, estoy seleccionando al enemigo. Eliminar guardar. Y esto es para éste. Te voy a mandar a continuación. Adiós.
24. Funciones comunes de los enemigos: Hola y bienvenidos a Unreal
Engine Fight Blueprint. Desarrollo de juegos de
disparos espaciales paso a paso. En la última lección con la
que terminamos, en realidad no terminamos, pero creamos a nuestro enemigo pero no pudimos
dañar al enemigo. Hagámoslo. Vamos a nuestra bala de jugador
y seleccionemos nuestra malla estática y el evento
de superposición de inicio. Ahora una cosa más que
deberíamos hacerle de nuevo
al padre enemigo de BP
es poner un tirón Vamos a ir a los valores por defecto de
clase del padre enemigo
BP y
buscar remolcador y usar un remolcador Vamos a copiar esto. Necesitamos esto para nuestras balas. Si vamos a nuestras balas, vamos a preguntar, ¿el
otro actor tiene este tirón No el componente esta
vez sino el del actor. Aquí voy a pegar enemigo. Si tiene una T,
queremos aplicar daño, el actor de daños
será el otro actor. Hagamos algunos nodos reales. Digamos que estamos haciendo
un daño de 18 de salud, ocho disparos y el
enemigo morirá. Para que sea un
poco más elegante, vamos a posponer el medidor de
nuevo, una ubicación La ubicación sería
la ubicación del actor. De hecho, podríamos encontrar una manera de donde sea preciso estaba el calor. Pero como estamos destruyendo
al actor después de esto, va a ser a escala fina.
Dejémoslo en uno. Seleccione la explosión de partículas. Después de esto vamos
a o compilar y guardar. Juguemos. En realidad
necesito traer un enemigo, digamos un poco más lejos. Y bajar el volumen. Juega. Iniciar el juego. Podemos ver a nuestro enemigo. El objetivo también se pone rojo. No lo comprobé antes de
que tengamos a nuestro enemigo. Viene hacia nosotros
con una mala rotación. Cuando le estamos pegando,
se está destruyendo. Me faltaron algunos tiros ahí. Bien, el enemigo es un
poco pequeño cuando los vimos. Podríamos querer que se
hagan un poco más grandes. Ahora tenemos otro problema, que nuestro enemigo no nos
enfrenta cuando
viene hacia nosotros. Necesitamos una manera de hacer que
el enemigo rote hacia nosotros porque vamos a usar
esto en el otro enemigo para, bueno, no es lo ideal. Pero es una buena
manera de demostrar nuestra función de biblioteca,
una biblioteca de funciones. Qué es una biblioteca de funciones, cómo tenemos las coms, la interfaz de blueprint
que creamos Funciona aquí dentro para
que los planos los compartan, pero la función se estaba
llenando dentro de los
otros planos Ahora es lo contrario de esto. Es una biblioteca con
funciones que estamos sintiendo en la biblioteca. Tienen algunas limitaciones. Entonces estas funciones se
pueden compartir entre todos los blueprints
que vamos a ir a blueprint y
blueprint click
derecho También hay
diferencias de biblioteca de macros entre estos dos, pero vamos a usar la
función en este momento. Voy a nombrar a
este juego espacial P L. La abrí y ya
creó una función para nosotros. Cambiemos el nombre de esta función. Gira hacia la capa. Ahora vamos a
necesitar algunos insumos aquí. Déjame explicarte algunas de
las reglas aquí cuando
obtenemos el controlador de capa
por ejemplo. Necesita un objeto de contexto mundial. Significa, ¿a dónde pertenece
esto? En qué contexto estamos consiguiendo un mando de juego como son
estas funciones, no
sé nada de
nada. Tenemos que darles
algún contexto mundial. Voy a traer
esto externamente y voy a nombrar a
este controlador aquí. Estamos conectando
el controlador ahora, porque es un objeto, podemos conectar
prácticamente todo. Sería imprudente conectar algo más que un
controlador aquí mismo Podría respaldar mucho a todo el
sistema y aplastarlo. Vamos a verificar si
esto es válido, es válido porque si no es válido,
no debería estar
comprobando rotaciones o lo que sea porque nuestro
jugador pudo haber muerto Esto nos dará también
hacia quienes estamos rotando. Esto nos dará
básicamente lo controlado. Lo conseguiremos hacia el
jugador desde aquí, obtendremos la ubicación de la pared,
obtendremos la ubicación del actor. Ahora tenemos hacia donde
debemos crear quien rota. Entonces vamos a
necesitar otra entrada. Este será actor. En realidad vamos a nombrar a
este actor. Ahora a partir de esto vamos a conseguir, en realidad obtener una rotación también. Vamos a ser rotación
sectorial. Vamos a estar configurando esta rotación de
actores
hacia el jugador. Aquí. Vamos a hacer inter, esta vez dos, no
es constante. Cuanto más lejos esté, más rápido girará. Necesitamos un objetivo, en realidad necesitamos conectar también delta time e inter speed. ¿Qué tan rápido
vamos a estar girando? ¿Cómo encontramos el
objetivo de la rotación? En real, hay un
buen nodo llamado punto. Mira la rotación. Tenemos un inicio y un objetivo, y nos da una rotación. El inicio del
objetivo son las ubicaciones. Nuestra ubicación objetivo
es la ubicación de nuestro estanque. Nuestra ubicación de inicio
sería del actor. Ubicación del actor. La ubicación del actor, la ubicación del
control encendido nos da, con este nodo, nuestro objetivo, dónde debería estar mirando. Ahora bien, debido a que esta es
una biblioteca común, como decíamos, una biblioteca de funciones, biblioteca funcional
común, podemos llamar a esta función desde todas partes. Podemos llamarlo padre enemigo. Podemos llamarlo
jugador como un ataque. Haga clic en el jugador y escriba
adelante rotar hacia el jugador. Podemos obtener esta función. Se puede ver que es un
poco diferente. Se ve un poco
diferente a los demás. Aquí es más delgado. Nos da la estética de esto
es algo diferente. Una función, función de biblioteca. No queremos
llamarlo a nuestro jugador, Queremos llamarlo
a nuestro enemigo boom, en nuestro evento tick
rotar hacia jugador. Hagamos algo de espacio aquí. Vamos a conectarnos al controlador. Vamos a conseguir
controlador de jugador a nuestro actor. Vamos a ponernos a
sí mismos para tiempo delta. Vamos a usar segundos
delta. Y para inter velocidad, bueno esa es una llamada de juicio. A mí me gusta el número diez. Me pareció que gira
muy bien. Probemos si nuestro
jugador gira. Esto debería estar constantemente
mirándonos. Vamos más rápido, sigue el ritmo. El enemigo constantemente está
mirando a nuestro jugador. Sólo podemos ver los
lados cuando
en realidad estamos viendo sus lados. Bien, lo matamos. Creo
que es suficiente para esta. Te voy a
ver en la siguiente. Adiós.
25. Desarrollo de tiradores y enemigos: Hola y bienvenidos a Unreal
Engine Five Blueprint Paso a
paso Space shooter Desarrollo de
juegos Anteriormente terminamos
con nuestro enemigo boom, El enemigo que se mueve cerca de nosotros. Y cuando choca
con nosotros, explota. Y en esta, comencemos
con nuestro enemigo tirador. Pero antes de hacer eso, me di cuenta de que en Puck, tenemos un punto de mira más pequeño
cuando estamos jugando No se ve tan grande. En realidad,
ya lo he cambiado. Pero también
lo haremos más pequeño. Debe haber un
enemigo en el mapa. Sí, ya está. Es
por ello que tenemos tantos errores. Vamos a WG Gameplay y cambiemos el cursor por
el cursor pequeño Después de hacer eso,
debemos cambiar como su posición a -25
e y posición a -25 y el tamaño a 50 X
y 50 Y. Compilar y guardar. Vamos a presionar play. Salva el nivel también, sin el enemigo, este objetivo
parece un poco mejor. Mucho mejor en realidad.
Ahora sobre nuestro nuevo enemigo. Hablemos un poco de nuestro
nuevo enemigo. Consideremos que
tenemos a nuestro jugador aquí. El enemigo va a engendrar
en algún lugar de aquí. Ahora su comportamiento. Tendremos un área. Imagina un área alrededor
del jugador con máximo
realmente medio en esa área. Coloreemos esto todo amarillo. ¿Qué hará el enemigo? El enemigo tomará una
posición aleatoria dentro de esa área. Este será su objetivo para moverse. Cuando el enemigo se mueva aquí, se detendrá y
comenzará a disparar
hacia nuestro jugador. Después de eso, elegirá una nueva posición donde sea
y se trasladará allí. Aunque la posición sea por aquí y tenga que
pasar por el jugador, pasará por el
no por el jugador, intentará pasar por ahí. Ahora esta va a ser
nuestra IA para el enemigo. Vamos a crearlo.
Vamos a nuestro navegador de contenido. Vamos a Blueprints. Haga clic derecho y seleccione Clase
Blueprint. En realidad, lo que
vamos a hacer es otro hijo del padre enemigo de
BP. Voy a
hacer click derecho sobre Padre Enemigo y crear una clase de
plano hijo Ahora voy a nombrar a este
BP así enemigo y abrirlo. Voy a traer
esto también aquí arriba. Guárdalo, y ve a
realmente Viewport. Ahora seleccionemos Cuerpo y
vayamos a nuestras mallas estáticas. Y selecciona enemigo A y dragón. Déjalo caer en malla estática. Ahora bien, este voto enemigo es un poco
más alto de lo que queremos. Voy a bajar un poco. Ahora vamos a un usado en
el barco jugador, Aquí está. A medida que usamos los puntos de
bozal del jugador, algunos componentes de escena que en realidad
es solo un punto Como usamos esto para
desovar balas, lo
mismo vamos
a hacer por nuestro enemigo Voy a agregar un, voy a llamarlo hocico uno, voy a pegarlo, copiarlo, pegarlo dos veces más Número uno vamos a ir aquí. Ya casi estamos aquí. Esto no es chasquear exactamente en el medio,
realmente no importa Pero si queremos,
podemos cerrar aquí los puntos de chasquido y
simplemente moverlo manualmente Sí, eso es perfecto. Pasemos al número dos. Tráelo aquí. Bien, y voy a copiar ubicación
e ir a tres. Pégala. Quitar la X esta vez menos, porque estamos en el eje X, podemos ver aquí
desde la línea roja. Vamos a moverlo aquí. Esto ya está listo. No vamos a usar esto. Vayamos a nuestro evento tick. Vamos a usar
comenzar, jugar después. Lo primero que suelda, gire hacia
según nuestra función común. Esta es una de las razones por las que lo
hicimos común, por lo que podemos usarlo muchas veces. Aquí voy a obtener per, en una regla general, función
común
se estaría ejecutando en tick. Pero este es uno pequeño y
nuestro juego es muy sencillo. Esto va a ser simplemente bueno. Por ejemplo, para actor, voy a seleccionarnos a nosotros
mismos para delta time. Voy a conectarme a
delta segundos inter velocidad. Pongamos una
cantidad diferente esta vez. Pongamos uno, en realidad 15. Ahora lo siguiente que debemos hacer, deberíamos preguntar si lo
estamos, vamos a usar una sucursal y vamos a
usar una condición. Voy a llevar esto a falso y luego
promoverlo a una variable. Porque si esto es
cierto y lo promuevo, se guardará default
el verdadero valor. Voy a hacerlo
falso y promoverlo, el valor predeterminado es falso. Y voy a
llamar a este lingote movimiento porque tenemos una etapa en movimiento y
una etapa de rodaje Esto hará la
diferenciación porque como
tenemos dos etapas, solo
podemos hacer una sola de las preguntas y ¿se
mueve o no se mueve? Si se mueve, vamos
a establecer la ubicación del actor. Ahora aquí vamos
a interpretar de nuevo. Vamos a elegir la interpretación
constante es interpolación vectorial,
o interpretar es interpolación de
rotadores Hay algunos más. Para actual, vamos a conseguir la ubicación del
actor.
Estos son actuales. Para target, vamos
a necesitar calcular el objetivo Como dijimos alrededor del jugador,
no lo haremos aquí. Crearemos una función para esto porque necesita
ejecutarse en momentos específicos. Como aquí, cuando esto es cierto, ya debería
conocer nuestro objetivo. Vamos a promocionar
este nombre de variable. Esta ubicación objetivo la
tenía ya hecha. Hubo un accidente
en el motor para reiniciar vector variable ubicación
objetivo, vamos a ir y
conectar delta time a
delta segundos de
la garrapata para velocidad. Vamos a conseguir nuestra velocidad variable
padre y conectarla aquí. Recuerda que si esto no se nota, siempre
lo
podemos encontrar desde aquí arriba. Mostrar variables heredadas. Ahora digamos que estamos
barriendo también. Las colisiones importan. Nos estamos
moviendo hacia esta ubicación. ¿Qué sucede cuando
llegamos a nuestro destino? Pongamos una condición de rama. Obtendremos la ubicación del actor es igual a nuestra ubicación objetivo. Ahora bien, esta cosita de
aquí es una tolerancia a errores. Debido a que estamos
comparando con vectores, podemos tener una tolerancia de error. Podemos poner esto en
uno o lo que sea. También podemos tenerlo al
azar con grandes valores. Es un poco más de
R y D de donde se. Entonces, si llega
al objetivo o no, pero no importa ahora mismo, lo
tendremos así. Si hemos llegado a
nuestro destino, entonces deberíamos dejar de movernos. Voy a girar moviéndome
a agujeros de inmediato. Cuando esto se ejecuta,
esto deja de correr. Esto no pasará de aquí. Ahora necesitamos otra función, pero voy a
hacer que sea un evento. Necesitamos un evento aquí para, Así que voy a hacer un evento
personalizado y nombrarlo. Dispara, voy a llamarlo aquí ahora porque
queremos estar seguros de que
esto no volverá a correr. Vamos a hacer una vez nota
aquí sólo dispara una vez. Voy a hacer un
evento personalizado para restablecer esto una vez. Voy a resetear el nombre. Entonces porque aquí queremos complejar las reglas y
queremos filmar una vez y
podemos resetear cada vez que estemos
filmando desde aquí. Ahora hablemos del rodaje, pero hablemos de cómo sentimos esto. Vamos a crear una función. Llamemos a esta función
seleccionar ubicación. Cuando estamos seleccionando el
siguiente movimiento la ubicación, significa que ya
hemos disparado. Entonces lo primero que
debemos hacer es reiniciar, reiniciar, disparar, disparar. Ahora lo siguiente que
debemos hacer es jugador. Este es nuestro objetivo. Necesitamos nuestro objetivo. Ante todo,
vamos a preguntar ¿es válido? Porque si el
jugador no es válido, esto significa que el jugador ha muerto. Y si el jugador ha muerto, no
deberíamos estar buscando
una ubicación cerca del jugador. Se crearía un
problema es válido. Ahora lo siguiente que necesitamos es llegar a la ubicación
del jugador. Desde esa ubicación
vamos a estar fijando
la ubicación objetivo. Pero no vamos a estar
poniéndonos directamente a esto, porque cuando hicimos esto
en el enemigo anterior, hace que el enemigo vaya
directamente al jugador. Vamos a crear un cuadrado
hipotético. mejor, Sí, tal vez
un hipotético cuadrado alrededor del
jugador porque lo que vamos a hacer es conseguir una unidad, en realidad solo un vector unitario
aleatorio No, obtener esto
nos da un vector unitario aleatorio
con una longitud de uno. Podemos considerar esto, nuestra dirección
en base a esta ubicación. Si agrego estos dos, si agrego esto también, si
este es el centro, consigo algún punto a su alrededor, una dirección aleatoria a su alrededor. Ahora bien, si multiplico
esto con un entero,
puedo obtener un punto de aquí con una dirección de ahí a una distancia del
entero que estoy multiplicando, voy a usar aquí y rango, voy a seleccionar
un mínimo de 10,000 15,000 Eso básicamente
nos da un punto de
cualquier dirección alrededor de nuestro
jugador en este Vamos a establecer esto en
la ubicación objetivo. Después de establecer la ubicación
objetivo, vamos a establecer el
movimiento a true. En este momento estamos listos para movernos. Ahora bien, esta función debería
llamarse al inicio del juego. Voy a conectar
esto a Begin Play. Cuando el enemigo comienza,
cuando es pons, obtiene una ubicación y
que le permite moverse Cuando llega a su
destino deja de moverse. Y disparos. Ahora en realidad podemos demostrar esto
poniendo un retraso aquí. Hagamos que sea un retraso de
dos segundos. Después vamos a
seleccionar la ubicación de la mudanza. Esto volverá a correr, en realidad, porque voy a
poner un retraso aquí también. Voy a hacer que sea
una de cinco segundos. Porque al jugar esto se
ejecutará instantáneamente ya que lo
tenemos en el mapa pero el
jugador no estará en el mapa. Esto desencadenará, no válido. Juguemos.
Debería comenzar a moverse. Sí lo es. No me voy a mover. Se mueve pero no me
está mirando. Mírenme. Experimenté un poco mi cuenta y descubrí
cuál es el problema El problema es que esta malla
también está avanzando en nuestra dirección
equivocada Si lo hacemos enfrentar 90
grados, ¿dónde está la flecha? 90 grados.
De otra manera giré la flecha, esto sería -90 creo que
esto solucionará nuestro problema Sí. Y nuestro problema está arreglado. Siempre nos enfrenta. Era cuestión de pivote de la malla estática.
No es un gran problema. Ahora se mueve por sí solo. No tenemos muchos puntos de referencia si tuviéramos 23 de ellos. Déjame traer algo más juego. Mira, esto da un
poco de miedo ahora. Todos se están moviendo. Están obteniendo puntos
aleatorios alrededor,
abajo, arriba,
están en todas partes. Si conseguimos más,
estarán en todas partes. Creo que esto es para éste. Te voy a
ver en la siguiente. Adiós.
26. Mecánica de tiro con enemigos: Hola y bienvenidos de nuevo
a Unreal Engine Five, desarrollo de juegos de
disparos espaciales
paso En la anterior,
terminamos con nuestro enemigo, nuestro enemigo disparador. En realidad completamos el
movimiento del enemigo disparador. En esta vamos a seguir con el mecánico de
tiro. Vamos dentro del plano
y vayamos a nuestro tiroteo.
Va a eliminar esto. En realidad me voy a quedar con esto, voy a
desconectarlo porque vamos
a usar estos nodos. Voy a borrar
el retraso desde
la jugada inicial,
volver a filmar. Ahora lo que vamos
a crear aquí es básicamente un
bucle personalizado con un retraso. Se ejecuta en intervalos específicos. Lo que vamos a
usar es una rama. Vamos a hacer
un cómo hacer a. vamos a crear
dos variables, ambas
serán enteras, no 64. Sólo jugando enteros.
Voy a llamarlo Shots, Shots. Voy a compilar y
voy a hacer tomas seis. A lo mejor seis es demasiado,
tal vez tres. Voy a preguntar, ¿son iguales los
tiros y los tiros? Si son iguales,
establezca los disparos actuales cero y seleccione un
nuevo punto móvil. Ahora bien, si no son iguales, deberíamos aumentar
los tiros actuales. Voy a copiar y
pegar esto aquí. Ahora esto se podría hacer en make a plus one points
set current shots, pero también se puede hacer
con incremento en Ahora, antes tuve algunos problemas
con esto. No sé por qué no debería haber tenido siempre me preparo de esta manera. Ahora, ¿qué estamos haciendo cuando
estamos aumentando el tiro? En primer lugar, deberíamos preguntar
si el jugador sigue vivo. Vamos a obtener el
controlador de capa como es válido. Quise obtener controlador porque un jugador siempre
tiene un controlador que es válido incluso si el
controlador no es válido. Si el peón no es válido, si el jugador no
controla un peón, el controlador sería Voy a es válido conectar esto aquí y
vamos a nuestro tiroteo. Para eso necesitamos un nuevo actor. Necesitamos la bala del enemigo. Voy a ir a clase
Blueprint, seleccionar uno nuevo actor, y voy a
nombrar a este enemigo del PP Pero ahora podríamos usar la bala del jugador
como padre y mantener algunas cosas iguales
y cambiar algunas cosas. Pero prefiero tener un
diferente para el enemigo porque tal vez
queramos actualizarlo más tarde a
otras cosas completamente otras. Voy a abrir esto,
voy a agregar una malla estática. Voy a agregar movimiento de
proyectiles. Ahora en movimiento de proyectiles, ¿se lo hice al jugador Tenemos que apagar la gravedad. Voy a abrir los jugadores movimiento del
proyectil en la bala gris
Proyecto escala de gravedad debería ser cero con nuestra velocidad Realmente no le
afecta eso, pero debería ser cero. Voy a compilar y guardar. Vayamos a bala enemiga
y volvamos también gravedad de. A cero y compilar y guardar. Ahora nuestra malla estática debería ser, por defecto, es dinámica de pared. Lo que vamos a hacer es hacer personalizado y seleccionar pared
estática y solapamiento. Todo compilar y guardar. Esto debería ser suficiente, no
necesitamos hacer otra cosa. Vamos a ir de hecho a nuestro
jugador bala otra vez. Copiemos este evento por aquí. Bala en velocidad de desove y movimiento de proyectiles
y velocidad de bala Vamos a Bullet
y péguelo aquí. Ahora ves que no
tiene la velocidad que puede obtener del movimiento del
proyectil Como pueden ver,
existe pero la velocidad de bala, no existe
en este plano El evento se acaba de
crear con copiar y pegar. Para crear esto,
vamos a escribir click y crear una velocidad de bala
viable. Crea una variable para nosotros que no tiene aunque
un valor predeterminado. Yo compila, es cero. Vamos a establecerlo en 8,000
Compilar y guardar. ¿Cuánto cuestan nuestros jugadores? 8,000 Sí, es la misma velocidad. Ahora tenemos el evento
que necesita una dirección. Y lo multiplicamos con velocidad de
bala y le da la velocidad al movimiento del
proyecto. Ahora el siguiente comportamiento que
necesitamos, en realidad podemos
encontrarlo en el padre
del padre enemigo enemigo. Aquí es cuando
chocamos y transferimos ese daño se le ha
aplicado al jugador Voy a copiar
todo esto e ir a bala enemiga
y pegarla aquí. Ahora pide la muerte porque en el padre enemigo
tenemos la función de muerte. Vamos a decir que no hagas nada. Como puede ver,
puede demostrarnos que esta función no existe
porque no nos importa. Vamos a eliminar esto
y solo vamos a de actor ahora por daños por colisión solo
vamos a poner
uno en daño base. Y eso es todo. esto en componente comenzar a
superponerse con cuerpo enemigo. No tenemos una
malla estática llamada cuerpo enemigo. Voy a seleccionar nuestra malla
estática en componente, comenzar superposición,
seleccionar este evento. Voy a transferir todo aquí y eliminar este. Vamos a sacarlo a colación. Creo que esto se hace cuando
la bala apunta a un jugador. Hará daños
y se destruirá a sí misma. Ahora otra cosa que estas balas tienen un problema es que cuando vamos al mundo, si empezamos a disparar, déjame bajar un poco el
sonido. Si empezamos a filmar, puedes ver a los
actores por aquí. Que están
aumentando constantemente. Si esto va por mucho tiempo, entonces tendremos un problema. Todo va a empezar a
conseguir frame lag porque estos actores en realidad siguen
adelante para siempre y para siempre, como que no hay que detenerlos. Lo que vamos a hacer es que les vamos
a fijar toda una vida. Una forma sencilla sería
un retraso en comenzar a jugar. Digamos un retraso de 15
segundos y destruir actor. Sabemos que las balas dejan 15 segundos y luego
son destruidas. Hay otra manera de
hacer exactamente lo mismo. Si vamos a los valores predeterminados del clúster
y buscamos la vida, tenemos vida útil inicial Como dice en la punta de herramientas, este es el tiempo que vive el
actor antes de morir. Cero es para siempre. Vamos a establecer estos 2
segundos, tal vez cinco. Hagamos lo mismo con
la bala del jugador. Vayamos a encuestas vida
y pongamos esto a cinco. Compilar y guardar.
Ahora nuestras balas serán por 5 segundos y se
destruirán a sí mismas. En un juego más, listo construido, crearías
un sistema de tracción donde estás generando
las balas al inicio
del
nivel y luego estás usando cierta cantidad de
balas y en lugar de destruir a los actores, estás escondiendo
y regresando a algún lugar del vacío Sigamos con
nuestro evento ahora que
tenemos nuestra bala terminada. Tenemos nuestro
evento de velocidad y tenemos la parte de daño y deja
una cantidad específica de tiempo. Ahora aquí vamos a necesitar una secuencia porque
vamos a estar disparando
desde tres puntos. Podría haber una manera de
hacerlo con una matriz, pero tenemos algunas reglas ciertas para el número uno y el
número dos puntos. Lo haría un
poco más complejo. A lo mejor para algunas personas
más fáciles de depurar. Prefiero tener las cosas un
poco más expandidas visualmente, pero porque todo necesita ser comprimido
al mismo tiempo, así que no tenemos una
gráfica que sea interminable. Vamos a crear
una función y llamar esta bala de tiro
para esta función. Vamos a engendrar actor de, traer algunos actores al
mundo que estamos desove Además voy a
seleccionar bala enemiga, aquí está para la transformación. Voy a dividir esto. En realidad lo que voy a hacer es que voy a conseguir un canto aquí, un hocico, y conseguir una ubicación
mundial Y conecta esto
aquí el objetivo. Voy a traerlo como pin de
entrada en la función. Voy a borrar el hocico. Ahora tenemos el mismo evento
de bala encendida. Entonces de bala,
necesitamos una dirección. Ahora no tenemos objetivo. No tenemos una puntería. Ahora es más fácil
conseguir la dirección porque el único objetivo
que tenemos es el jugador. Voy a usar el punto, mirar rotación, sabemos
la ubicación del jugador. Pero porque queremos disparar no directamente al jugador solamente, sino alrededor del jugador. Voy a traer
esto como insumo también. Voy a ponerle nombre a este objetivo. En realidad, voy
a nombrar al
primero y a este objetivo. Ahora voy a
seleccionar este objetivo. Conecte esto al
objetivo para el inicio. Va a ser la palabra ubicación del componente de
escena. Vamos a estar uniendo
el componente del hocico. Ahora de la
mirada fina a la rotación, voy a avanzar
directamente hacia ahí. Y voy a conectar esto a
dirección para esta
sería una función. Así que volvamos
ahora a la gráfica. El primero es fácil. Voy a traer
la poleta de tiro,
digamos el hocico ¿Cuál es el del medio? Sí, esto se ha movido un poco porque
roté al actor. Vamos a ponerlos de nuevo, esto prueba un punto
que esto debió haber sido engendrado al cuerpo Y no ser libre
así en el plano. Puedes ser padre de ellos en
el cuerpo si quieres. Si estás contento
con sus lugares. Los voy a dejar
así, está bien. El del medio es el hocico uno. Voy a conectar desde
hocico uno el objetivo sería. Vamos a jugar con la ubicación del
actor y
conectemos esto aquí. Esto empeña una bala desde el medio hacia nosotros. Vamos a
crear el segundo. Voy a copiar y pegar esto. Lo único que
deberíamos estar cambiando es que deberíamos sacar de esto, se llama Random Point. En caja delimitadora, creamos
una caja alrededor del jugador, digamos obtener un punto
alrededor del jugador Básicamente hacemos una caja de 500,500.500. Creo que
sería suficiente. Voy a conectar
esto con el objetivo. Voy a cambiar
hocico uno a hocico dos. Voy a copiar y pegar esto. En realidad, no necesito esto. Si lo conecto aquí, esto se ejecutará dos
veces y dará un valor. Cada vez que se solicita
esto, da un valor diferente. Si quisiéramos que esto diera
el mismo valor a ambos, deberíamos haber promovido
a una variable y usar esa variable en
estos dos objetivos. Porque si conectamos
esto, siempre dará
una cantidad diferente. Ahora el hocico dos debería ser
eliminado del inferior. Y el hocico tres se debe agregar del hocico dos.
De hocico tres Ahora voy a comprobar, hacer otro sobre la secuencia. Y voy a
llamar a un nodo de retardo. El retraso debe ser 0.2 suena bien. Y voy a, así que de nuevo, esto va a correr todo
esto simultáneamente. En 0.2 segundos,
volverá a correr disparar, si el disparo actual no es máximo, agregará uno
al disparo actual. Volvió a disparar hasta
llegar a tiros. Cuando alcanza tomas, establece tomas actuales en cero, selecciona un conjunto de
puntos de película moviéndose para marcar, maneja el resto. Voy a compilar y
guardar y vamos a probar. Eliminé el retraso desde el
principio para que no podamos probar. Vamos al enemigo. Pongamos un retraso aquí, 30 segundos, 123 empiecen a moverse. Todos dispararán
al mismo tiempo, no lo sabrán casi a la
misma hora porque se están moviendo en diferentes lugares o no van
a disparar en absoluto. Esta también es una opción. Realmente se están alejando
más de mí. Comprobemos por qué sucede
esto. Voy a ir a
los planos enemigos. Voy a seleccionar cualquiera de ellos. No importa. Está
llegando a su destino. No está llegando a su
destino. Decía que disparó. Creo que la razón
es muy sencilla. Si vamos a nuestra bala, aquí no
hemos seleccionado una malla
estática. No he seleccionado
una medida estática. Vamos a seleccionar una
medida estática para nuestra bala. Vamos a ir a mallas
estáticas y formas, y vamos a usar esta forma de
esfera por aquí Ahora esto es un
poco grande para una bala. Lo hacemos un poco más pequeño. Voy a
bajarlo un poco. Digamos que el tamaño debería
ser al menos la mitad de esto, incluso tal vez más pequeño,
pero hagámoslo la mitad y veamos cómo
nos consigue. Para el material. Deberíamos cambiar el material. Pero es el material aquí es un material. Sólo necesito refrescarme. Vayamos a los materiales
y seleccionemos esto. Mi bala resplandeciente enemigo. Ahora deberíamos poder
ver algunas balas. Creo que 123 Cada
enemigo se mueve. En caso de que aún no
hayan llegado a la posición. Se están moviendo un
poco despacio a través de esto. Están tan lejos. Nos dispararon, nos
murimos. Sí. A lo mejor podamos hacer la distancia un poco más baja porque esto
está un poco lejos. Creo que si me
acerco a ellos, realmente esparcido por ahí después de
que dispararon, este me disparó. Creo que aunque lleguemos a cero, no
tenemos ningún
programa sobre la muerte. Realmente no
importa si me disparan. Sí, va por debajo de cero, así que ni siquiera se actualiza. Probablemente ya me morí. Sí, están un poco
lejos. Arreglemos esto. Vamos al enemigo donde estamos seleccionando
movimiento aquí. Bajemos los mil
1,500 Tal vez eso sea bajo. Hagámoslo 2000. Comprobemos de nuevo. Esto es un poco demasiado cerca. No tendrás tiempo
para escapar de esto. Vamos a aumentarlo a 5,000 8,000 8.500 Creo que
esto sería suficiente Creo que esto es para éste. Te voy a ver
en la siguiente. Adiós.
27. Mecánica de desove de enemigos: Hola y bienvenidos a un Blueprint
de Engine Five. paso a paso del juego de disparos espaciales Desarrollo paso a paso del juego de disparos espaciales sobre el anterior. Y fue una larga.
No voy a mentir. Terminamos nuestro enemigo de tiro. Ahora, en realidad
eliminemos a estos enemigos. Y borré la esfera del cielo. Eliminemos a estos enemigos. ¿Algún otro? Empecemos con nuestro sistema de
desove. Vamos a nuestra nave espacial. Vamos a la gráfica de eventos. Vamos a una nueva zona. En realidad, necesitamos temporizadores porque vamos a
tenerlo en un temporizador. Vamos a crear un evento temporizador. Configura el temporizador por evento. Ahora bien, este no va a ser un temporizador de aspecto como este lo es. Este temporizador, lo vamos a
estar llamando internamente, va a funcionar solo. ¿Por qué vamos a
hacer eso? Porque queremos un tiempo aleatorio. Voy a hacer un rango de bloqueo
aleatorio. Voy a seleccionar 2 segundos
y digamos 6 segundos. Entre 2 segundos y 6 segundos, este temporizador se activará solo. Ahora voy a crear un evento personalizado y
llamar a este span. O a partir de aquí voy
a volver a hacer una secuencia. Ahora tenemos que estar
llamando a este temporizador. Entonces voy a crear
otro evento de cliente y llamar a esta forma de spawn Voy a conectar esto aquí, en realidad lo que este temporizador no
debería estar conectado a los temporizadores porque esto
no necesita estar habilitado. Sólo tenemos que llamarlo una vez. Voy a
tenerlo por separado aquí. No necesita correr
porque si corre con esto, comenzará a
desovar de inmediato Podríamos querer poner un retraso
entre cuando queremos
engendrar y comenzar
y la jugada Probablemente correremos un retraso. Para eso, voy a
agregar otra sucursal. Aquí vamos a retrasar. Digamos que el retraso
será de 3 segundos. El jugador se familiariza, serán los controles
dados 4 segundos. Entonces vamos
a spa spawn wave. Esto iniciará este temporizador
interno. Lo primero que
vamos a salvar de nuevo. Cuando el temporizador genera un enemigo, comienza de nuevo para generar otro enemigo en 2-6 Ahora vamos a
crear algunos contadores. De nuevo, voy a hacer una rama y voy
a sumar dos variables. Llamemos al primero en
realidad vamos a entrar más probablemente el nivel uno actual va a ser el tipo entero uno, este va a ser
un entero también. Voy a comparar
esto con si igualan, Si son iguales, no
hagas nada. No obstante, si no son iguales, vamos a engendrar
actor de clase Vamos a seleccionar a nuestro enemigo
boom para transformar. Voy a dividir esto. Voy a conseguir la ubicación del actor, obtener un vector de unidad aleatorio. Multiplica esto con un rango que quiero
engendrar a nuestros enemigos Eso sería,
digamos que tal vez demasiado. 25,000 25.000 sonidos porcinos. Y voy a añadir estos dos. Voy a configurar esto para
engendrar transformación. Ahora lo que hicimos de nuevo
aquí es obtener nuestra ubicación, obtener nuestra dirección aleatoria desde nuestra ubicación
con este año plus. Y multiplicar
en realidad, más año, lo cual está completamente equivocado. Queríamos multiplicar con un entero y conectar esto Aquí multiplicamos el rango desde una dirección y en base a
esta ubicación en el mundo, estamos engendrando un enemigo Ahora, ¿cuál es la nueva parte aquí? La parte nueva aquí es
que vamos a
atar a la muerte, a la destruida. Cuando este actor está
siendo destruido, ve de nuevo un
evento que estamos vinculando pero es
general en los actores. No es que tengamos una función con es sobre destruida
del actor. Vamos a evento personalizado. Vamos a decir esto,
es un empate de nivel uno de muerte. Ahora en el nivel de muerte uno, establece a nuestro
enemigo actual en menos uno. Podemos hacer algo de espacio
cuando este es el máximo uno, T menos uno, podemos volver a
generar enemigos Lo siguiente que debemos
hacer es después del bind, debemos hacer lo
contrario de esto. Voy a conectar esto
aquí menos y
voy a hacer más uno. estamos atando a la muerte, que cuando se une
reducir uno, el conteo. Después, aumentamos
en uno el conteo. Ahora bien, si quisiéramos ser
un poco engañosos, podríamos agregar una
ola de generación instantánea cuando muere un enemigo Si agregamos aquí, activará instantáneamente el temporizador de engendro de onda de
sierra, como en el momento en que muere un enemigo se recreará a sí mismo No vamos a hacer
eso porque el juego podría ser un
poco más difícil de esta manera. Vamos a mover esto
un poco más hacia arriba. Vamos a copiar y pegar
este código exactamente igual. Vamos a
conectar esto aquí. En lugar de corriente enemiga de nivel
uno, vamos a promover
esta variable, corriente enemiga de
nivel dos. Vamos a
promover esta variable también nivel dos enemigo max. Vamos a
eliminar estos dos y simplemente hacer clic derecho reemplazar variable nivel uno enemigo con nivel dos
actual y el máximo. También reemplázalo
con nivel dos máx. Esto seguirá igual, la clase
cambiará a tirador. Tenemos que rehacer este empate de nivel dos de
muerte. Vamos a reemplazar estas
variables también con nivel dos corriente, nivel dos corriente, y también las dos las
clicadas en el lado equivocado Esto completa nuestro sistema de
desove. Ahora vamos a probarlo.
Presionemos Play. Comienza en 3 segundos. Deberíamos ver actores desovar
aquí, que no lo son. Vamos a ver por qué. Una ola. Es muy sencillo porque no
hemos establecido valores predeterminados. Pongamos diez enemigos máximos, y el nivel dos,
enemigos máximos también diez. Compilar y guardar. Empezar de nuevo. Los enemigos están desove.
No puedo ver dónde, pero puedo ver los cors Oh ahí está. Creo
que eso es sí, eso es un enemigo. Lo destruimos. Ese es
otro enemigo. Un montón de HP. A lo mejor se estaba moviendo y no
pude golpearlo tan bien. En realidad, cómo le pusimos un
HP al enemigo tirador. Vayamos al enemigo tirador y comprobemos el BPC Dañable Tenemos ocho, es
un valor por defecto. Tiene salud.
Sí, está funcionando. Tenemos un sistema. Veamos que está pateando
la cantidad correcta de actores. Tenemos 15. Debería ir a 35 sin que los
enemigos disparen. Si empiezan a disparar,
irán más. Pero siempre hay
otra manera de probarlo, ya que no estamos
destruyendo a ningún enemigo. Podríamos presionar para expulsar. Podríamos ir a la lista
aquí y decir diez actores. Podríamos decir diez actores. Aquí hay un actor. Es en las raíces. Sí. Los actores son
un poco más pequeños y nos faltan muchas balas. Hagamos
un poco más grandes a los actores. Voy a ir al sistema
de spawn y seleccionar para la escala 333 Lo mismo para el otro, tal vez el engendro un
poco demasiado lejos. Voy a hacer esto tal vez
15 mil Es un poco más. Acción tres segundos actos de
regla. Son más grandes, podemos dispararles fácilmente, ¿verdad? Esto en realidad es
detectar nuestras balas, lo cual no es un gran problema para resolver ningún tipo
de error como este, solo
vamos a
hacer uno es válido aquí. Creo que esto lo
arreglará. ¿Es válido el actor? Porque como estaba
describiendo el error que estamos describiendo, estaba pendiente de matar
o era basura. Entonces fue destruida.
Pero por alguna razón requirió de un evento. Se solicitó un evento, un evento de colisión, matar
enemigos, matar enemigos. A ver, no hay errores. Creo que esto está bien. Creo que esto es para éste. Te voy a
ver en la siguiente. Adiós.
28. Implementar la partitura y la muerte del enemigo: Hola y bienvenidos a Unreal
Engine Five Blueprint, desarrollo juego de
disparos espaciales
paso a paso En la
lección anterior, creamos un sistema de desove y estamos disparando jugadores. No jugadores. Nosotros los PNC's, nos están
disparando. Eso es que no hay otro punto. Vamos a crear punto. Lo que vamos a estar
creando es un sistema de puntos. Vayamos al jugador ahora. Ya que tenemos acceso
cuando muere un enemigo, debemos crear una
función para sumar puntos. Voy a presionar
más a las funciones, y vamos a hacer que
una función sume puntos. Para ello,
necesitaremos una nueva variable. Hagamos una nueva variable
y llamémosla puntos. Vamos a estar fijando
estos puntos por aquí. Vamos a estar sumando
los puntos actuales, que en realidad es
puntos a una variable. Esa variable tiene que
venir externamente porque cada enemigo tiene sus propios puntos. Llamemos a estos puntos
variables también en
realidad en los puntos entrantes. Necesitamos una manera de demostrarle
estos puntos a nuestro jugador. Iremos a nuestro widget. Añadiremos nuestra
variable de texto sobre los cavas. Vamos a establecer su posición en la esquina
superior derecha. Vamos a establecer la posición x. Hagámosla un
poco más grande. En realidad, pongámoslo
aquí en 120. Suena bien. 50, 50 podría ser bueno
para la posición x. Vamos a moverlo a,
esto se ve bien. Menos 150 en el y 50 para el texto. Vamos a poner en cero. Por ahora, vamos a hacer
justificación al centro. Veamos cómo se ve. ¿Y si viene triple dígitos
123? Sí, se ve bien. Se ve bien. Ahora vamos a
establecer esta variable, nombrar a este texto
subrayado puntos Vayamos a nuestra gráfica y creamos variable una nueva función
y llamemos puntos de ajuste. Dentro de esta función,
vamos a obtener nuestra variable de texto y establecer texto. Conecta esto aquí
y el en texto, vamos a
conectar esto aquí. Estas actualizan nuestros puntos, nuestra salud hizo como nuestro objetivo
y todas estas cosas. Ahora vamos a nuestro Plan de Juego,
Consigue nuestra
jugabilidad de Widegit
y Vamos a conectar
esto de aquí a aquí. Cada punto que estamos recibiendo
actualiza nuestra puntuación. Ahora bien, ¿cómo obtenemos
los puntos entrantes? Vamos a la basura. Tenemos una referencia
al actor destruido, pero no sabemos cuál es este
actor. ¿Qué hacemos cuando no sabemos
quién es exactamente este actor? Dijimos que tenemos algunas formas de
comunicar mensajes que no
son acto específicos. Lo que vamos a usar
es una interfaz de blueprint. Vamos a usar el
que tenemos ahora mismo. Vamos a entrar aquí
y crear una nueva función. Y vamos a llamar a esta
función la petición caliente. Vamos a dar una
salida y vamos a
hacerla entera y a llamar a estos puntos. Ahora vamos a
compilar y salvar, e ir a nuestro padre,
enemigo, enemigo, padre. Vamos a ir a interfaces, ya ves que esto tiene los
puntos de solicitud que acabamos de crear, pero es de un
color diferente al de este. Esto se debe a que se trata de una
función con una salida. Si me duplico la gripe, obtenemos esta función. Voy a conectar puntos aquí y esto está hecho.
Compilar y guardar. Volver al jugador nave espacial atar muerte obtener puntos Simplemente olvidé cómo lo nombramos. ¿Qué son los puntos de solicitud de BI? Estoy solicitando los puntos. ¿Cuántos puntos
me da esto? Voy a llamar a nuestra función de
puntos publicitarios después. Voy a conectar
estos puntos aquí. Como se puede ver una diferencia. El objetivo aquí tiene lo
destruido en actor. Porque estamos
solicitando puntos al actor destruido ya que un objetivo de
puntos tiene nosotros mismos. Voy a compilar y guardar. Veamos esto en la obra. Encontremos a un enemigo. Debería
haber borrado el cero, los ceros extra, porque
ahora mismo no dice nada Debería decir uno. No lo hemos hecho por el
segundo enemigo. Por eso. Vamos a copiar y pegar esto por aquí. Conecta esto clics por accidente. Conecta esto aquí, más
abajo, compila, guarda, juega. En realidad, antes de
jugar, eliminemos también los ceros adicionales en el widget Cuando tienes 10,
se convierte en uno para hacerlo a las 00:01 Habría algunas reglas sobre
agregar ceros extra Anexar manipulación de
un nodo de variable de cadena. Estoy matando enemigos,
voy a anotar anotación. La puntuación está funcionando bien. Tenemos una partitura. Ahora
tenemos una manera de decirnos a cuántos enemigos
hemos matado, por ejemplo. Podemos ir en nuestro sistema de desove y decir que cuando nuestro punto, vamos a conseguir puntos es
mayor que ocho, rama aquí, conecta esto aquí Si esto es cierto sólo entonces, sólo entonces engendrar el nivel
al enemigo instantáneamente En base a nuestros puntos,
tenemos una mecánica de
desove más interesante Ahora, ¿y si hiciéramos lo
mismo por nuestras armas? Hicimos lo mismo para las actualizaciones. Creo que deberíamos detenernos
aquí en la siguiente. Deberíamos crear un
sistema para nuevas armas. Adiós.
29. Introducción al sistema de misiles: Hola y bienvenidos de nuevo
a Unreal Engine Five. Paso a paso Space
Shooter desarrollo de juegos. En la lección anterior,
terminamos con nuestro sistema de puntuación y
hablamos de crear
un sistema de actualización. Pero en realidad, antes de
pasar al sistema de actualización, deberíamos crear nuestra
arma final, el misil. Lo cual será un arma un poco avanzada
porque va a ser un misil homing.
Déjame borrar esto. Hablemos un poco
sobre el misil homing. Estará compuesto a partir de una malla estática que
representará nuestro misil y una partícula que
estará representando el
humo del misil. Ahora además de eso,
tendremos una colisión. Hagamos que circule
alrededor del misil. Cuando explota el misil, cualquier enemigo atrapado dentro
del círculo moriría Tendremos un segundo círculo. A lo mejor es una, esa
no es una buena representación
de un dibujo, ¿es ahora? Pero de todos modos, servirá. Tendremos un segundo círculo, uno
mucho más grande en realidad, que usaremos para decirle
al misil si hay un enemigo
dentro de este círculo. Si no has argumentado, entonces vete, este es tu objetivo. En realidad, haz de esto un objetivo. Este es el objetivo de todos modos. Si el misil no
tiene objetivo porque el homing, en realidad, quizá debería
haber comenzado con eso Cuando el jugador dispara, el misil adquirirá un objetivo si
tenemos en el alcance. Si no tenemos
algo en el alcance, no
va a tener objetivo. Si está viajando,
el segundo círculo estará detectando si
hay un objetivo cerca. Básicamente, eso sería todo. Vamos a hacerlo. Vamos
a ir en planos. Ir a escribir
click Crea un actor tipo azul en clase y llámalo misil BP y ábrelo. Empecemos a construir.
Voy a presionar Agregar. Voy a agregar, empujar por malla estática. Voy a usar tilt. Voy a usar la pipa de forma. Creo que el delantero es la x. Agreguemos una flecha. Sí, los delanteros X.
Voy a rotar esto. No tiene cono, pero realmente no
importa la entrega de la carga útil. Voy a también en realidad voy a desapaciguar la flecha, voy a restablecer su
rotación en la carretera Voy a agregar componente de
partículas niágara para este sistema. Vamos a usar
el rastro de misiles. Voy a moverlo de nuevo aquí. Creo que está centrada,
se ve bien. Ahora tenemos nuestras imágenes de misiles. Lo siguiente que voy a
agregar es un componente de esfera. Componente de esfera.
Colisión de esfera. Esto es algo que no
dije en la pintura. Vamos a tener
esta colisión al
frente para verificar si calentamos algo que queremos conseguir la
superposición de colisión de la malla. Vamos a ser de
la esfera de enfrente. Esta es otra forma de
obtener calores de colisión. Sin usar la malla, voy a engendrar la
esfera desde el Aga. Tengo que hacer clic en Default
antes de agregar algo. Porque si he
hecho clic en cualquier otra cosa, lo agrega como en jerarquía Hace que el clicado
sea el padre. Voy a hacer click en Default. Y en realidad voy a, voy a copiar y pegar
esta esfera, agregar algo. Voy a restablecer su ubicación, tal vez un poco más alto. Esto está bien. Voy a escalar, en realidad.
No voy a escalarlo. Voy a extender
el radio a 5,000 Esta será la esfera que detecte para
nuestro sistema de homing Y voy a
nombrar esta colisión. Voy a copiar y pegar
la primera esfera, otra vez cero, la x
llama en el centro. Y voy a
cambiar su radio a 3 mil Tal vez eso sea
un poco grande. Está bien, es demasiado grande para 2000. Así será la esfera que mata a todos los
enemigos alrededor. Quizás otra vez, es un
poco demasiado grande, pero es un mundo grande. Deberíamos estar comprobando que
las colisiones en
las esferas se superponen
dinámicas dinámicas mundiales dinámicas Hagamos esto personalizado, hagamos que la pared sea estática
y superpongamos todo. Y también hacer lo mismo aquí pared
personalizada estática,
superponer todo. Sin compilación de colisiones
físicas. Mismo. Pasemos en realidad a
un componente más. Vamos a agregar un
movimiento de proyectil porque queremos que este misil se mueva
de apagar la gravedad No de la
malla estática, lo siento, sino del compuesto del
componente proyectil Guardar. Vayamos a la gráfica par. Empecemos por crear
una función en la que matemos a todos los enemigos que están dentro del. Nombremos a esta esfera
el área dañada. Voy a nombrar esta
función Área de daños. No aplicar realmente mucho. Voy a conseguir mucho área. Voy a conseguir que todos se
superpongan actores. Ahora este nodo de aquí obtiene todos los actores que están
dentro de esta esfera. Podemos filtrarlo por una clase, pero no nos importan las clases. Queremos todo lo
que hay aquí dentro. De esta lista
vamos a abordar, buscar cada bucle y
conectar esto aquí. Esto regresa como una referencia de objeto
actor. Y vamos a preguntar si este
actor tiene una etiqueta que era. Vayamos a padre enemigo. Entérate esto, aquí hay un enemigo
padre. Aquí está. Por defecto la etiqueta era enemiga
con mayúscula E. Recuerda, esto distingue entre mayúsculas y minúsculas Volvamos a nuestro
misil y tecleemos esto. Aquí vamos a ramificar aquí, vamos a hacer una pregunta. Si el actor tiene un enemigo, vamos a estar
aplicando gran parte de esto. A lo mejor no debería haber
dicho esta función, apliqué daño.
Aplicar daños AOE. Vamos a conectar elemento
para aplicar daño. Entonces, si el actor tiene una etiqueta enemiga, estamos aplicando
daño a este actor. Después de haber aplicado el
daño, deberíamos destruir. Pero hagamos una
explosión visual en realidad. Aquí. Vamos a generar un
metro en el lugar Porque un misil que no
explota, ¿no es divertido? Voy a usar
explosión para la báscula. Pongamos 2010 20
creo que va a estar bien. Ubicación. Vamos a conseguir ubicación Ahora
volvamos a par gráfico. Lo siguiente que debemos hacer es ir a nuestro movimiento de
proyectiles En el movimiento de proyectiles,
hay algunas opciones. Las opciones que queremos
es acerca de hacer un homing por aquí que somos que el
proyectil es homing o Esto lo queremos establecer en tiempo de ejecución. Tiene algunas propiedades extra como homing,
aceleración, magnitud Pero como dice la punta de la herramienta, esto está limitado por la velocidad máxima, que se establece aquí. Ahora, la velocidad y la velocidad
son cosas diferentes. Ambos se utilizan para
describir la cinemática. Pero la velocidad se refiere a un cambio de objeto en la distancia
con respecto al tiempo, mientras que la velocidad se refiere
a un cambio de objeto en el desplazamiento con
respecto al tiempo. En fin, detalles, creo que esto es para
éste y vamos a poner estas
parábolas en la siguiente y hacer que este
sistema funcione, ¿de acuerdo? Adiós.
30. Mecánica de misiles homing: Hola y bienvenidos a Unreal
Engine Five blueprint paso a
paso desarrollo de
juegos de disparos espaciales En el último terminamos con la puesta en marcha de nuestro misil. Creamos algunas colisiones para detección de homing,
para daños en el área. Agregamos el movimiento del
proyectil. También creamos una
función que daña todo lo que se encuentra
dentro del área de daño. Ahora fijemos los detalles
de nuestro proyectil. Vamos a seleccionar el movimiento del
proyectil. Utilizaremos 20,000 para la velocidad
inicial y
también para la velocidad máxima. Ahora por debajo de eso, está
esta categoría de homing. Tiene la habilidad tickable. Este lingote que
dice es homing o no por debajo de él es homing Esto significa cómo,
digamos por ejemplo, qué tan rápido estamos volteando
en términos de lamentos hacia el objetivo que
tenemos, un homing Ahora para que el homing funcione, necesitamos tener también un objetivo
que estemos estableciendo usando el movimiento del proyectil
y establecer Ahora antes de que vayamos a establecer objetivo, pongamos aquí también 20,000 en magnitud de
aceleración. Pero no vamos a tomar esto a partir de ahora. Desde el principio haremos una función que
estará habilitando esto. Seleccionemos estos dos,
vamos a crear una función, nombrar este conjunto homing. Entremos ahora a esta función, antes de establecer el homing,
debemos establecer la velocidad a cero, sea cual sea la velocidad que quiebre el
proyectil Comienza con el homing. Ya que tenemos nuestra
magnitud al 2000, al instante
intentará ir a nuestro objetivo y adquirir
la máxima velocidad. Ahora lo siguiente que
debemos hacer es que set set es proyecto homing Aquí es donde tomamos ese lingote que
encontramos en los ajustes
aquí en la categoría homing
es proyectil homing Así es como lo habilitamos porque queremos por
defecto estar apagados. La razón por la que queremos que por
defecto esté apagado es porque cuando no tenemos objetivo, el misil debe ir
simplemente directo hasta que algo choca con el detector y luego
adquiere un objetivo Hagamos esto un
poco más bonito. Conéctalo como aquí, y voy a poner esto aquí. Sí, está bien. Componente objetivo de Homing. Ahora bien esta es
una interesante porque si pasamos por encima del mouse sobre él, veremos que requiere de
un componente, objeto débil. Hay mucha definición
sobre esto, lo que significa un
objeto débil y todo. Pero sigamos en componente, requiere de un componente. Lo que tenemos de nuestro jugador
cuando apuntamos a algo, es una referencia de actor. Tenemos este actor objetivo, no
tenemos un componente. Pero vamos a crear esta referencia de
actor sin poblarla aquí
en el misil Blueprint para crear
una nueva variable. Vamos a llamarlo Target. Voy a seleccionar el
tipo actor de actor. Será nuestra
referencia ahora mismo, esto está vacío, pero pronto
estaremos poblando Pero no importa
si está vacío o no. Al igual que con los eventos vinculantes, hay ciertas
cosas que podemos hacerle a los actores que son
generales para todos los actores. Una de las cosas es
componente por clase. Podemos especificar la
clase aquí que se
vería componente. Ahora podemos conectarnos aquí. Como puedes ver,
marca correctamente. Pero si voy con probar con esto, no quiere
porque dice actor referencia objeto no es compatible con componentes pecado. Ahora sabemos que nuestros actores tienen un componente syn
porque nuestro padre,
enemigo, sí, padre, tiene este default visto
root ya que muchos de los blueprints tienen
raíces predeterminadas como Ahora siempre podemos anular esto, pero nuevamente la mayoría de las
veces tendrá componente raíz. Ahora podemos ver que este valor de
retorno como dice busca Component
Array y devuelve primer componente encontrado
de la clase específica. Por lo general, el primero
es siempre un componente, la raíz es un componente. Vamos a compilar y guardar. Esto sería establecer
nuestro objetivo de homing. Antes de irnos, tenemos que
explicar que hay un cierto problema con objetivos de
homing usando el componente de objetivo
homing Si nuestro misil tiene suficiente velocidad y digamos que este
es nuestro objetivo, siempre
existe la posibilidad de que, digamos que el misil
se mueva
así y quiera
alcanzar el objetivo. Que va tan rápido
que no alcanza el objetivo. E intenta regresar y conseguir no alcanza el
objetivo y sigue yendo casi orbital alrededor del objetivo y nunca
golpeando realmente el objetivo. Para evitar esto, cuando
apuntemos a algo, crearemos un sistema
separado para hacer que el misil vaya directamente
a ese objetivo. Cuando está detectando un objetivo, entonces estará usando este sistema
de búsqueda para hacer esto Iremos a gráfico de eventos. Iremos al evento tick, y haremos una rama, haremos que la condición sea negativa, la
promovemos a una variable
y la llamaremos tormenta. Ahora esto,
haremos un movimiento con ubicación
establecida para la ubicación. Lo haremos en constante con una velocidad de en realidad creo que 50,000 en este caso porque se basa en
delta sería mejor. El objetivo sería nuestra variable
objetivo para la que
obtendremos ubicación. Nuestra corriente será nuestra ubicación de actor
get. La ubicación de los actores
compilan y guardan. Ahora por si acaso
nuestro objetivo está muerto, vamos a comprobar
si esto es válido, si el actor es válido. Porque si el actor no
es válido
significa probablemente que
hayan sido destruidos. Ahora bien, si no es válido, lo vamos a hacer, una vez que vamos a
dar vuelta al homing personalizado, vamos a encender el detector de colisión
homing, porque vamos a
apagarlo cuando tengamos un objetivo La forma en que vamos
a
apagarlo, no va a generar eventos de
solapamiento. Mientras que ahora en realidad, si no tenemos un objetivo, vamos a buscar un objetivo. Básicamente, vamos a
crear esta parte que cuando algo
entra en la esfera, establecemos el objetivo
que está dirigiendo a ese objetivo al comenzar la superposición de la colisión del
detector de localización Vamos a hacer una pregunta, ¿el actor tiene
la etiqueta enemiga? Un enemigo estaba deletreado
con enemigo E mayúscula. Si lo hace, debemos verificar. En realidad, podemos hacer una vez la pregunta si ya es homing. Si es el homing personalizado, si tuviéramos el target
desde el principio, no
deberíamos encontrar un nuevo target, ya que vamos al target
personalizado, para ser honestos Deberíamos crear
un evento personalizado, dicho colisión y
llamar a ese evento aquí. Entonces, si tenemos un target, entonces esto se ejecutará de nuevo porque aquí vamos a
crear un evento personalizado, Restablecer búsqueda o target. Si encontramos un nuevo objetivo, llamamos reset search o target. Si este objetivo que
aquí adquirimos es destruido también, restablecerá la búsqueda. Ahora lo siguiente que debemos hacer es establecer
nuestro objetivo de búsqueda. Vamos a poner nuestro
objetivo a este actor. Hagamos que algunos nodos rojos se conecten así
y se vea mejor. Y después de que nos fijemos el objetivo, deberíamos establecer el homing, ¿verdad? Vamos por un segundo
dentro aplicamos daño AOE. Aquí hay una casa fija. Por alguna razón
voy a borrar eso. Esta última parte aquí que
explotamos la partícula
y destruimos Quizá lo necesitemos de nuevo. Vamos a hacer una función de ello va a ir
colapsar función. Llama a esta función.
Ahora nuestro misil tiene un objetivo que podemos
establecer desde el exterior. O puede adquirir un objetivo
que consigue cuando está viajando. Y cuenta con
detección de colisiones homing. El objetivo entra en colisión de
detección de homing. Creo que es un buen punto de
parada aquí. En la siguiente
vamos a completar lo que sucede cuando realmente nos
encontremos con el objetivo. Y vamos a enviar
la información
al misil que se está
lanzando desde nuestro jugador, para que
pueda cazar un objetivo o decidir que
ya tiene un objetivo. Adiós.
31. Finaliza la integración de misiles y jugadores: Hola, y bienvenidos a
Engine Five Blueprints. Paso a paso Juego de
disparos espaciales Desarrollo. En la lección anterior,
completamos nuestra mecánica de homing. Si tenemos un objetivo desde el principio
mecánico que estamos reiniciando en caso de
que ese objetivo muera,
estamos restableciendo la detección de
homing Y cuando la detección de homing
choca con algo, lo establecemos como objetivo Y estamos habilitando a la mecánica
homing que se hereda en el movimiento de
proyectiles Ahora vamos a crear el mecánico. Somos el misil
del jugador. Voy a borrar esto. Voy a crear un evento
personalizado y llamar a esto, creo que esta es la ortografía. Yo puedo verificar eso. Eso es todo de todos modos. Misil de lanzamiento de misiles. Aquí vamos a necesitar
dos insumos. El primero
sería nuestra velocidad hacia donde por si acaso no
tenemos objetivo. El segundo sería blanco. Voy a ponerle nombre a este objetivo. Va a ser de tipo, la
referencia del objeto de referencia. Ahora vamos a estar promocionando esta variable O, en realidad. Voy a
llamarlo velocidad objetivo. Y voy a promover esto. En realidad, no
necesito promover esto, ya
tenemos un target. Voy a estar
configurando esto aquí. Ahora, de nuevo, voy a
preguntar si esto es válido. Justo lo siguiente que debemos hacer es decirle
al misil, si chocas con
algo, entonces explotas Vamos a estar usando
la esfera que no nombramos. Voy a llamar a esto detección
de explosión. No sé, misiles. Es algo así como impactarnos, algo
así, se llama. De todas formas, vamos a estar usando detecciones
de explosión, inicio de
colisión, Vamos a preguntar si el
otro actor tiene la etiqueta enemiga. Si el actor tiene la
otra etiqueta enemiga, entonces lo haremos una vez
sin restablecer esta Vamos a
llamar a nuestra función, aplicar daños AOE, esto
llamará a nuestra muerte Ahora vamos a compilar y guardar. Creo que hemos terminado
con este plano. Vayamos ahora a nuestra nave de jugadores. Porque con una gráfica, vamos a las entradas. Porque para disparar
el misil necesitamos una nueva entrada o una entrada. Vamos a usar ratón, botón
derecho, botón derecho, botón
derecho del ratón. Vamos a necesitar
algo de espacio extra. Va a aumentar el comentario. Voy a traerlo aquí abajo. Cuando estamos presionando,
estamos usando una rama para hacer una pregunta. Vamos a apagar la condición y
promoverla a una variable. Vamos a nombrar esta
variable tiene misil. Ahora bien, si tenemos un misil, primero
debemos decir que ya
no tenemos misil
porque lo disparamos. Entonces vamos
a posponer un per de clase que es nuestro misil porque
lo estamos trayendo al mundo, estamos respondiendo
y con razón, la transformación Y
dividiéndolo por la ubicación que
vamos a usar hocico uno, esa ubicación
mundial Voy a conectarlo aquí
para la clase, nuestro misil. Ahora después de que engendremos el misil, deberíamos
lanzarlo misil almuerzo Para el actor de velocidad y objetivo, vamos a utilizar de nuestras variables de disparo,
el actor objetivo. Para la velocidad, tenemos una función llamada cálculo de
dirección. Vamos a usar esta
función para el objetivo. Vamos a usar
el bozal. Esta es la función
que desvía
nuestra velocidad en base al hocico que estamos
disparando y no en base la cámara después de
lanzar el Sonido En realidad o antes
y poner nuestro misil. Sonido que creo que
podemos encontrar. Sonidos. No, no, esta que
no tiene una que, vamos a usarla tan fácil. Ahora, después de que estemos
tocando Sound podemos hacer un delay, promover esta variable. En realidad, hazlo
punto para las pruebas. Y promover variable
y decir CD de misiles. Después, vamos a
establecer tiene misil a verdad. Nuevamente, ahora podemos
probar nuestro misil. Ahora esto es un poco más grande. Haz el comentario hasta
aquí y está bien. Sí, compilar. Vamos a jugar. Disparan un misil. Eso es una bala. No he
puesto el misil en verdad. Pongamos el misil a
verdad. Tenemos un misil. Vamos a estar
configurando eso a través nuestro sistema de subir de nivel. En la siguiente lección, probablemente esté disparando un misil. Va completamente
mal, ¿de acuerdo? Tenemos un enemigo alrededor, pero el enfriamiento
en realidad funciona como. Y el misil, creo que
vi algo mal todo bien. Va a los enemigos. La rotación es un
poco rara. Si tengo candado,
va directamente y no hace ningún
daño. Probablemente. No fijé un número en daños. Sí, vamos a ver esto. Vamos a misil. Veamos la velocidad objetivo. Aquí estoy sumando, vamos a multiplicar, esto debería ser un entero de
multiplicación Digamos 20 K. Por
eso
iba en una
dirección extraña porque estábamos sumando a
la velocidad objetivo. Así fue y siempre hacia una cierta dirección
desde nuestro daño. Tenemos el AOE de aplicación. Sí, es cero. Hagamos este diez.
Compilar y guardar. Creo que deberíamos arreglarlo. Sí,
aunque no la rotación. Movimiento de proyectiles. Tenemos una variable llamada la
rotación sigue la velocidad. Vamos a estar usando
eso. Vamos a usar esa variable
y volver a jugar. Sí. Parece estar teniendo la velocidad
correcta. Veo enemigo fue al enemigo. Si no apunto al enemigo. Sí, va para el enemigo. Genial. Apuntemos a
uno directamente. no hay enemigos, entonces ahí está, directamente. ¿Esto, Louis
piensa que es genial? Bien, creo que esto
es para éste. Te voy a ver en la próxima. Adiós.
32. Interfaz de usuario de misiles y sistema de actualización: Hola y bienvenidos de nuevo a
Unreal Engine Five Blueprints, desarrollo juego de
disparos espaciales
paso a paso En la lección anterior,
terminamos con nuestro misil. Pero
queda una cosa del misil. Deberíamos indicarle al
jugador cuándo tiene un misil y cuándo
no tiene un misil. Vayamos a nuestro juego de widgets. Y vamos a agregar una imagen. Vamos a traer
esta imagen por aquí. Vamos a anclarlo amablemente. Primero en realidad,
seleccionemos nuestra imagen. Llamemos a esta
imagen CD de misiles. Para el pincel tenemos en
nuestras texturas icono de misiles. Vamos a usar esto aquí. Vamos a hacer su alfa a 0.5 Hagamos la imagen
un poco más grande, creo que este tamaño fino. Comprobemos cómo se ve. Jugar. Sí, lo podemos ver. Volvamos al widget. Ahora hagamos de esto
una variable y vayamos a la gráfica y
creemos dos funciones. Una función tiene misil y la otra función
estaría fuera de misiles milla. Ahora vamos a conseguir nuestra
imagen que acabamos de crear. Debería haber usado un frente y un subrayado
la visibilidad aquí. Deberíamos convertir esto en oculto, porque no vamos a empezar
con los misiles. Sería una
actualización lo que sucede. Voy a compilar y guardar. Voy a volver al reproductor en realidad
al widget y dentro de la
función fuera de misil, voy a conseguir el CD de misiles. Y voy a establecer, voy a dividir
esta estructura. Voy a seleccionar un
color cuando estemos fuera. Va a ser de color rojo. El alfa va a ser 0.5 voy a copiar esto
e ir a Has Missile y pegarlo y cambiar el color a blanco y 0.5 alpha
compilation guardar Y voy a
volver a jugar. Voy a ir a nuestro botón
derecho del ratón. Después de t, voy a obtener
nuestra referencia de widget. Voy a salir de misil. Cuando disparemos fuera de misil, voy a copiar el widget e ir al final después del retraso. Y como misil,
hagamos el sistema de actualización. Habilitamos nuestro misil. Desconectemos esto por defecto. Vayamos a nuestro sistema de puntos porque nuestros puntos
definen el XP. Es lo que es un sistema común aquí, este no tiene burbuja. Vamos en nuestra
función en puntos. Después de sumar puntos,
vamos a usar los puntos. Voy a
traerlos aquí mismo. Una copia pegada. Voy a
hacer en realidad no desde puntos, desde la línea de ejecución
voy a encender. Ahora una cadena es un carácter, es cualquier carácter numérico o no, o puede ser un símbolo como signo de
interrogación, explicación. Mark puede ser cualquier carácter, pero para nosotros en este momento
va a ser solo entero en switch on string. Podemos poner algunas opciones aquí. Solo necesitamos en realidad, podemos nombrarlos como queramos. El primero, digamos que va a ser en el nivel cinco, pienso en el nivel ocho. Sí. Si está por encima del nivel
ocho. Nivel nueve, probablemente. Volveremos a generar al segundo
enemigo a puntos. Digamos que en el nivel
11 hacemos algo. Digamos que en el nivel cinco
habilitamos misiles. Entonces vamos a hacer que
tenga misil verdadero. Vamos a obtener
el widget y obtener un CD de misiles y establecer la
visibilidad en true. Es por ello que lo hicimos visible por defecto
antes de darle la vuelta. Ahora a través de como un nivel cinco, obtenemos el misil y
vemos el widget. También, debemos tocar
un sonido sonoro a D. El sonido que podemos encontrar en los sonidos. Este suena como
un sonido de actualización. Vamos a usar esta ya. Un nivel en 11, deberíamos
aumentar nuestro nivel de armas. Voy a conseguir
nivel de arma de variable. Lo tenemos en categoría de tiro, yo voy a hacer u más uno también. Voy a configurarlo
al mismo tiempo conectarlo
al sonido. Entonces probemos esto
, compilemos y guardemos. Juguemos. Ahí están nuestros enemigos. Aquí está nuestro enemigo. Un enemigo. ¿
No tenemos misiles? Voy a hacer clic en un
misil. No hay ninguno. Dos enemigos abajo. El enemigo está abajo.
Cuatro enemigos abajo. Déjame bajar el
sonido por un segundo. Cinco enemigos abajo. Y
conseguimos el misil. Ahora puedo disparar misiles largos. Enfriar. Bien, ocho enemigos. Ahora a la nueve, debería comenzar a generar
las operaciones de los enemigos de tiro, tenemos el nivel 11, tenemos las nuevas balas Aquí están los nuevos enemigos. Nosotros también los estamos destruyendo. No les
voy a dar oportunidad de disparar. Démosles
oportunidad de disparar. Disparando a estos enemigos, empiezan a disparar ya. El juego es un poco fácil. No hay mucho
diseño al respecto, pero supongo que
dado el tiempo suficiente, puedes perder en
cualquier juego probablemente Sí, todo funciona. Oh, bien. Ahora creo que esto
será por éste. Te voy a
ver en la siguiente. Adiós.
33. Game Over UI y animación: Hola, y bienvenidos a Unreal
Engine Five Blueprints. Paso a paso Juego de
disparos espaciales Desarrollo. En la anterior, creamos nuestro sistema de actualización en puntos
con nuestro switch on string. Ahora hagamos que el juego sea un poco más interesante
haciéndolos X enemigos, también un poco
más grandes, más grandes más. Cuando actualicemos nuestra arma, deberíamos mejorar a nuestros
enemigos para digamos 13, 15. Conectemos esto aquí. En realidad lo que podemos hacer es
también cambiar nuestro CD láser. No obtener sino establecer de 0.2 a 0.15 deberíamos
un poco más rápido. ¿Por qué cambia esto?
Porque de alguna manera deberíamos poder perder. Porque creo que con
la anterior puesta en marcha, no
podíamos perder nunca cuando
perdemos. ¿Qué pasa? Tenemos un juego sobre pantalla. Empecemos con nuestro
juego sobre pantalla. Vamos al navegador de contacto. Vamos a la carpeta UI. Hace mucho que no visitamos la
carpeta. Vamos a hacer clic derecho y
vamos a crear un nuevo widget. Este va a
ser un widget de usuario. Y vamos a llamarlo G Game over. Vamos a entrar en él. Ahora para esto, necesitaremos un lienzo. Vamos a necesitar una imagen. Hagamos que esta imagen se
estire a toda la pantalla. Ancla a toda la pantalla. Volvamos su color a negro. Está bien. Ahora
vamos a necesitar un texto. Pongamos este texto en la parte superior. Vamos a establecer su tamaño en 500. Se ve bien. Reiniciemos la posición a menos a 50 de por qué la queremos un poco un
poco más baja, tal vez. En realidad, vamos a
escribirme el texto diciendo que esto es un poco
pequeño, hagámoslo más grande. Digamos 100. Genial se ve bien, vamos a hacerlo centro. Hagamos la talla y 100. Sí, puede sentir 100. Pongamos la posición y. 200. Sí. Parece un buen lugar
para nuestro juego terminado. acabó el juego. Bien, ahora vamos a
necesitar una caja vertical. En realidad una caja horizontal. Vamos a traerlo en la lona. También pongámoslo en el medio. Vamos a establecer el tamaño igual
con el juego por encima de 500.100. Posición menos 250
posición, digamos 380. Dentro de este cuadro vertical, vamos a usar
dos variables de texto. No voy a copiar y pegar
porque tiene mucha configuración aquí y queremos menos. Voy a copiar y pegar esto. Voy a nombrar una
partitura y la otra sería nueva partitura. Y la forma en que
estarían archivando, me voy a poner a
sentir el primero en
uno y el segundo cayó
en 0.5 Ahora cuatro alineación. El segundo debe ser
central alineado horizontalmente. Centrales, alineados verticalmente. Y el segundo debe sentirse horizontalmente,
alineado verticalmente. Ahora vamos a escribir aquí, anoto. De hecho, pongamos
la justificación a la izquierda, al lado derecho. En esta vamos
a escribir doble cero. Vamos a establecer la
justificación. Ya está puesto a la izquierda. De hecho, pongamos
un espacio después de esto. Este símbolo de aquí. O, lo moví. mí me gustaría esto un
poco más a la izquierda, pero esto es demasiado. Podría traer un espacio aquí. También, poner entre estos
dos y hacer que se pele y 0.1 tal vez menos 0.05 100 puntos. Sí, creo que esto se ve mejor. Ahora, voy a usar
otra caja horizontal. Voy a traerlo
dentro de la lona. Vamos a hacerlo un poco más grande porque esto va a
ser el alojamiento de nuestros botones. Voy a hacer 800. Puedo comprar 100. Y está bien. Voy a anclarlo
al centro de la pantalla. Para X, voy a hacer menos F cien, tal vez -100 150 Vamos a llevar a los botones uno
para empezar y otro para rápido. Pongamos algo de texto
en estos patrones. Llamemos a este menú principal
en el otro botón. Llamemos a esto dejar de fumar. Ahora ambos, ser text debería estar por defecto,
pero los botones, vamos a traer un espaciador entre estos dos botones y hacer que sienta que
ya se ve mejor. Ahora bien, el cuadro horizontal de puntuación alta debería ser una variable porque
queremos ocultar esto. Digamos que voy a anotar bar, Vamos a ocultar la
visibilidad. También el puntaje debe ser capaz. Vamos a subrayar ahora. Vamos a
necesitar una animación para que el fondo se desvanezca. Voy a abrir animaciones. Voy a seleccionar
una animación. He seleccionado la imagen afuera porque esto es lo que
quiero estar animando. Estoy agregando un pad de animación. Voy a seleccionar esta
animación y añadir un camión. Ahora cuando estoy agregando un camión, estoy obteniendo la variable de imagen porque la he seleccionado. Este es nuestro camión de animación. Para ello, voy
a presionar Plus y añadir pista de opacidad de render Al principio,
debería ser cero, digamos que en 0.75
debería ser uno. Esto completa nuestra animación. Voy a dar click en el
camión de Render Opacity e ir a sus propiedades y establecer que
cuando termine, mantener estado Cuando esta animación
termine de reproducirse, se quedará oscurecida, no
volverá
a ser Comencemos a codificar.
Vamos a la quiebra. No necesitaremos
el pre constructo, necesitaremos el constructo. Cuando construyamos, voy
a traer nuestra animación. Está en la categoría animaciones. Voy a jugar animación. Ahora, voy a poner
esto en una secuencia, pero antes continuamos con lo primero
de la secuencia, porque el segundo
será play animation. Aquí guardamos los valores. Al defecto, están bien. Vamos a hacer estos
patrones por aquí. Vamos a
hacer menú y es una variable que voy
a hacer patrón también salir y también es una
variable para ambos. Vamos a usar
el evento no prensado. Vamos a traer
el primero. Voy a traer el
segundo también para dejar de fumar, simplemente
dejaremos el juego. Para el menú principal,
solo recargaremos el nivel. Cómo hacemos eso, usamos un comando llamado open level por nombre. Ya que es el mismo nivel que
podemos antes de eso obtener nombre del nivel
actual
y conectarlo para asegurarnos de eliminar el
prefijo está marcado, nuestro quit y nuestro
menú principal está completado Lo siguiente es acerca de
cómo hacemos el puntaje. ¿Cómo sabemos
sobre una puntuación alta que requerirá un sistema de
ahorro de carga? Esto es para éste. Te voy a
ver en la siguiente. Adiós.
34. Sistema de alta puntuación y ahorro: Hola, y bienvenidos a Real
Engine Five Blueprint Paso a
paso Space Shooter
Game Development En la última, creamos
el Game over Widget, que tenía los textos de puntuación alta y los botones
que programamos. Y dijimos que para usar la
nueva función de puntuación alta, necesitamos el juego seguro. Vamos a Even Graph
e iniciemos este proceso. En realidad, antes de
ir a Even Graph, necesitamos crear un objeto guardado. ¿Qué es un objeto seguro? Un objeto guardar es un blueprint, un blueprint especial
que representa el archivo que se guardará en la computadora en
el disco duro Si escribimos, da clic y
vamos a la clase Blueprint, buscamos el mismo objeto En realidad solo guarda juego, podemos ver el juego de guardar objetos. Vamos a seleccionar
esta y nombrarla, digamos lúpulos de objeto de juego,
SGO, juego espacial Ahora abramos este plano. Se puede ver aquí como en blueprints de
componentes, no
tenemos una vista
ni nada porque esto solo guarda datos para los
datos que queremos guardar Crearemos una nueva variable
aquí y la llamaremos puntos. Va a ser del
tipo entero que será, eso es lo
que estamos ahorrando. Sólo un entero con
los puntos de nombre. Vayamos a nuestro
juego de J en realidad, antes de que se
juegue la animación, deberíamos preguntarnos, ¿existe el mismo juego? Ahora aquí se requiere un
nombre de ranura y un índice de usuario. El índice de usuario para nosotros es cero porque solo
tenemos un jugador. Tenemos, no tenemos múltiples
usuarios en esta computadora. Para el nombre de la ranura, esto tiene que ser lo mismo en todas partes donde
usemos el nombre de la ranura. Voy a nombrar a este G one en realidad juego espacial SGO
sin subrayado Al final, el juego espacial SGO uno. Voy a promocionar esto
a un nombre de ranura variable. Parece un buen nombre
para esta variable. Ahora voy a crear dos
eventos, evento personalizado uno, lo
voy a llamar guardar juego, el otro lo voy a llamar evento personalizado primero
lo
voy a llamar lote. Ahora desde el, ¿existe el juego de
guardar? Voy a llamar a una sucursal.
Si existe un juego guardado, voy a cargar juego. Si no existe,
voy a salvar juego. Ahora vamos a llenar estos dos eventos. Empecemos con un juego de carga. Como va a ser más sencillo, estoy cargando juego desde slot. Voy a usar nuestra
variable de nombre de ranura. Entonces voy a lanzar
al juego espacial GO. Quiero ver si este
juego que cargué, es de nuestra clase. Si no lo es, no
hacemos nada porque no
tenemos otra clase. Pero si es cierto,
vamos a promover esto
a una variable que denominó como
para nosotros como GO Space Game. A partir de esto voy
a conseguir sumar puntos, en realidad conseguir puntos
y
ascender a una variable tenemos
almacenados los puntos. Ahora voy a comparar si estos puntos son más pequeños que
nuestros puntos de jugador. Ahora voy a
lanzar esta vez para ver si es nuestra nave espacial P player Voy a lanzar a
jugador nave espacial. Podemos conectarnos o simplemente podemos hacer clic
derecho y
convertirnos a puro cast. A partir de aquí voy a puntos. Voy a conectar esto aquí. Ahora bien, si los puntos de juego seguros
son más bajos que nuestros puntos, entonces voy a hacer una
rama y llamar a juego seguro. Esto será para
nuestra función de juego de lote. Ahora para nuestro juego seguro, vamos a crear
un objeto de juego. Porque aunque ya exista un
juego seguro, estaremos operando
con el nuevo. La clase objeto debería
ser nuestro juego seguro. Ahora el valor de retorno
vamos a estar promocionando como variable,
pero como lo
tenemos, solo vamos a estar
configurando la variable que ya tenemos aquí. No necesitamos lanzar porque
sabemos la clase que estamos creando y el valor de retorno
de aquí es nuestro juego seguro. No tiene sentido el casting. Cuando estábamos cargando, no
sabemos qué clase de
juego seguro estamos cargando. Sólo lo estamos cargando.
Por eso estamos lanzando. Ahora voy a conseguir puntos. En realidad no
voy a conseguir puntos. Voy a establecer puntos porque estamos
salvando estos puntos. Voy a establecer puntos. Voy a copiar y pegar
esto de la
nave espacial de nuestros jugadores que estamos obteniendo puntos de
la nave espacial de los
jugadores Voy a hacer de
esto un elenco puro. De nuevo, voy
a conectar puntos. Aquí estamos fijando
al juego seguro los
puntos de nuestro jugador. Voy a establecer los
puntos variables que tenemos. También a estos puntos. Para completar el proceso de progreso
del juego guardado, necesito guardar el juego en la tragamonedas. La ranura que
vamos a usar es el nombre de ranura que hemos guardado en este nombre de ranura
variable. Ahora esto va a
salvar nuestro juego seguro. Este es el juego Eliminar en la ranura. Guardar juego en tragamonedas. Una tragaperras de juego. Sí, no está en la
ranura, es la ranura de dos. Pero el inglés puede causar errores. Requiere, como puedes ver, un objeto de juego seguro o
un objeto de juego seguro. Vamos a conseguir nuestra variable, un juego seguro porque lo
promovimos. Aquí, el juego seguro
que estamos creando. Y estamos pasando esta
información al jugador, señala este mismo objeto, guárdala en la ranura. Ahora, aunque la ranura ya
tenga un juego seguro, la sobrescribirá. Lo siguiente que debemos hacer
es actualizar nuestra puntuación más alta. Porque si
hay una puntuación alta, deberíamos mostrarla a la pantalla. Vamos a crear una función, llamarla puntuación alta. Vamos a obtener nuestra partitura variable de
texto y establecer texto desde aquí. Vamos a conseguir que nuestros puntos se
conecten en texto
va a convertir de forma automática nuestro
entero en un texto. También vamos a conseguir
la barra de puntuación alta, la caja vertical, déjame nombrar la barra de puntuación
alta por aquí, y hacerla visible. La parte por defecto aquí es
visible, no la vamos a cambiar. Y volvemos al gráfico de eventos. Y después del juego seguro, vamos a llamar a nuestra
función nueva puntuación alta. Esto completa nuestro juego seguro
y nuestro sistema de puntuación más alta. Vamos a probar nuestro sistema. Vamos a compilar y guardar. Presionemos play.
Empecemos. Encontremos a un enemigo. Tenemos ese retraso en 3 segundos. Necesito bajar el
sonido. Es demasiado alto. Maté a dos enemigos. En realidad debería morir. Ahora mismo, voy
a ser precipitada contra los enemigos
para obtener algún daño. Ese es el problema.
No puedo morir. No hemos hecho el
sistema de muerte en la función muerte. Del plano del jugador
que habíamos creado. Hagamos que algo suceda. Lo primero que debería pasar, debemos desactivar las entradas. Vamos a conseguir el controlador
del reproductor, vamos a llamar entradas
deshabilitadas. El jugador no puede
presionar nada. Voy a conectar esto al controlador
del jugador y
los objetivos deberían ser uno mismo. Ahora lo siguiente que debemos
hacer es poner en marcha el tiroteo, si
acaso en
realidad está encendido. El tercero que debemos hacer es
establecer actor oculto en juego. Ahora, ¿por qué estamos configurando
el juego oculto del actor? Porque no queremos destruir
al actor. Porque queremos obtener
la variable
de puntaje de este actor en
el juego sobre skin. En lugar de destruir al actor, sólo
vamos
a esconder al actor. Ahora vamos a una explosión
en el lugar. La ubicación será
nuestra ubicación get actor. Después de esto, deberíamos
estar generando nuestro widget. Crear widget para clase. Vamos a estar seleccionando
nuestro juego sobre el jugador. Vamos a conseguir
Player controller, vamos a agregar al puerto. También vamos a establecer una colisión de puerta a desactivada. Este actor ya no tiene
colisión. Compilamos y guardamos. En realidad aquí podríamos
destruir al actor. Porque desde que creamos
el widget y lo
agregamos a Viewport en la creación, obtendrá toda esta
información necesaria y ejecutará la misma carga Pero si quieres
estar seguro de que esto sucede al 100% también podemos ir a nuestra nave espacial jugador
y promover una llegada yendo Elimine el setter aquí. Voy a conectar
esta variable
por todas partes donde tenemos que
conseguir la nave espacial En esta variable voy
a ser expuesto sobre spawn y set intenso editable
como jugador BP nave espacial Cuando estemos sponing
esto vaya sobre el jugador, seleccionemos el juego de
clase sobre Ya ves cuando lo estoy desove, pide
que se llene esta
variable Debido a que seleccioné
exponer en spawn aquí, voy a poner auto, esta clase se hace referencia aquí y va a contener
la información En realidad, pongamos el reactor y vayamos a jugar. Matemos a un enemigo. Entonces nuestro puntaje más alto
será uno y vamos a morir. Eso es demasiadas Sus
podríamos haber hecho bajar su nueva puntuación más alta, diez. Tenemos un nuevo puntaje alto. No estamos swading mouse,
eso es algo que arreglar. Yo, veo que hay
un montón de errores. También establecemos la
rotación del actor cuando morimos. Probablemente no puedan
encontrar al actor. La rotación tiene este problema que está en la biblioteca de
funciones comunes de. Por eso, porque estamos recibiendo controlador y estoy
preguntando si esto es válido. Si conecto el peón
controlado, entonces esto
eliminaría nuestro error Juguemos de nuevo,
comencemos el juego. En realidad, antes de comenzar, fijemos la vida
máxima en algo más pequeño. Aquí está el peón, Tenemos vida, la tenemos en lo dañable Sí, pongamos la vida a
uno, la vida máxima a uno. Vamos a golpear play. Inicio
juego cero puntuación. A ver si morimos
instantáneamente. La puntuación va a uno. Si tenemos una nueva puntuación alta, no, ninguna nueva puntuación alta. Ahora vamos a
hacer trampa un poco y vamos a poner puntos a 11. Se convertirán en 12. Cuando muero por el primer enemigo, ahí está el enemigo. Aquí hay un enemigo desde el
principio, eso podría ser. Es porque el marcador fue de 11. Nuevo puntaje alto, 11.
Nuestro sistema funciona. Se acuerda de la puntuación
anterior y registra una nueva puntuación alta Ahora no estamos dando una oportunidad
al jugador de sobrevivir, aunque esquive una, no
podemos hacer que el juego sea interminable Para ello, vamos a crear un
sistema de regeneración para el jugador. Y vamos a hacer
esto en la siguiente. Adiós.
35. Toques finales y corrección de errores: Hola y bienvenidos a Unreal Engine Five
Blueprint paso a
paso Space Shooter
Game Development En la última lección,
terminamos nuestro juego sobre pantalla. Y U, terminamos nuestro sistema
de puntuación más alta. En esta vamos a agregar una regeneración
al jugador. Esta regeneración,
tendremos dos reglas simples. Si el jugador
no está disparando o si el jugador no se mueve,
entonces regenera la salud. Si el jugador está
disparando o moviéndose, entonces no regenere la salud. Vamos a venir aquí a nuestros temporizadores y
vamos a ir un poco más allá y establecer temporizador por evento. Ahora vamos a crear un evento personalizado y
llamarlo por región. Recuerda, estamos ejecutando nuestros temporizadores en el evento de juego
inicial, la regeneración
comenzará a hacer un ciclo, porque va a
ser un temporizador de loops desde el principio un tiempo que tendremos 0.1
diez veces por segundo Vamos a poner
una rama tras evento de región de
vida por condición vamos
a tener un lingote O Esto significa que si uno es verdadero o el otro es
cierto, danos verdad. Si es falso,
vamos a conseguir flotando,
flotando para nuestra BBC Damageable Vamos a llamar a Salud. ¿Cuál era el nombre salud? Por la cantidad
vamos a poner uno. Ahora bien, esto sería
para la región, pero necesitamos las condiciones. La primera condición
sería la velocidad. Estamos comprobando si
el actor se mueve, la velocidad es cero, entonces no deberíamos
estar regenerando En realidad, deberíamos
estar regenerando, aquí
vamos a poner
un nudo pull Si esto es cero, devuelve falso porque
ponemos el nudo, si cero devuelve verdadero, nudo lo hace falso,
corre desde aquí. Ahora si estamos disparando, creo que tenemos una variable para esto también devuelve true,
No regenerar. Esto estará completando
nuestro sistema de regeneración. Vamos a encomiarlo, y pongamos algunas burbujas y
algunos comentarios más Esto es desove estelar,
y esto es inicio. Bajemos esto a dos. Pongamos aquí juegos de hornear y ollas. Creo que esto está mal. La ortografía podría ser
mejor, podría no ser. Vamos a probar nuestro sistema. Vamos a Plearly con el juego. Vamos a golpear Empezar de nuevo. El sonido. Los enemigos deberían estar desove. Déjame hacer una pantalla completa. He engañado con la partitura, no hay alguna trampa Y tengo una sola vida. Eso no es bueno.
Estemos matando enemigos. No tenemos las actualizaciones ahora porque empezamos
con puntos máximos. Bien, arreglemos esto.
Hacer trampa y handicaps. Arma nivel cero, ir a 0.0 dañable Digamos salud. Vamos a compilar y guardar. ¿Teníamos algún
mensaje de error? No llegó a ver. Voy a ir al Registro de mensajes de
ventana. No. Eso es bueno. Probablemente si ocurriera un mensaje de
error, probablemente
sea cuando morimos, lo que podemos llamar un error
controlado. Como un error que sabemos de
dónde viene. No afecta
realmente mucho a nada. Sí, a veces estos
errores pueden ocurrir. No es que estén bien para irse, pero sí,
no afectan el nombre. Pero siempre es mejor
tener un código sin errores. Ellos, estamos matando
cosas. Tenemos un misil. Estamos, vamos a conseguir algunos daños. Leemos otra cosa.
Vamos a conseguir algunos daños. Bien, la regeneración
es bastante rápida. Podríamos haber dicho
una
cantidad un poco menor en este momento. Estoy inmóvil. Sí, es lo suficientemente rápido. Verás, me estoy poniendo plena salud. Veamos si esto me dispara qué tan rápido esta
generación general comparada con el daño de
las armas disparadas. Esto se mueve un poco despacio. Podríamos aumentar su velocidad. Oh, veo algunas balas
atravesando. Probablemente estaba tan
lejos de lo que estaba sobre mí, por eso. Bien. No estaban en el rango. Pensé que habían sido destruidos. A lo mejor nuestro alcance para la
explosión es un poco pequeño para nuestro mapa. Sí, tal vez podríamos
hacerlo más grande. ¿Qué pasa si debo aquí? Bien, entonces, ¿qué pasó ahí? Enemigo era, que los
delanteros detrás de mí. El misil de balas. Intenta ir atrás primero. Sí, necesitamos un
ratón sobre el juego. Arreglemos estos problemas. Tenemos algunos errores. Ya ves que es la ubicación del actor establecida. Probablemente cuando morimos,
bala en desove pendiente, matamos cuando morimos Algunas cosas,
siempre podemos ir ahí, ir a esta ubicación de actor set. Probablemente quiera
preguntar si p es válido. Dijimos que este es
nodo válido y conectado. Este error desaparecerá. Es cuestión de tiempo
encontrar dónde se necesita esto. No perdamos el tiempo ahí. Vayamos a nuestro juego de nuevo. Comienza a jugar y construir. Consigamos el
controlador del reproductor y configuremos. Así cursor del ratón. Conectemos esto con la verdad. Doy clic en esto
resolverá el problema del cursor,
compilará y guardará. Una última cosa que
deberíamos hacer
sería agregar un componente de audio. Selecciona este componente de audio, y de nuestros sonidos selecciona
este, el de música. Ahora nuestro juego tiene prueba de reproducción de
música. Cuando empezamos, empieza la música. Enhorabuena por
el régimen hasta el momento, y espero que
hayan disfrutado de este curso. Hay muchas
maneras de optimizar y jugar con la mecánica
y actualizar los sistemas. A lo mejor hacer algunas balas más. Hacer otro sistema de armas. Hay muchas
cosas que
puedes hacer, hacer más enemigos. mejor un reto
sería hacer que los enemigos caigan una cantidad de
misiles como drop amo. Y tienes una cierta
cantidad de Amo. Irías como posponer
actores en el mundo. Y lo que estás haciendo son colisiones cuando el
jugador choca con él, cuando el jugador termina
choca con él,
cuando el jugador lo cuando el jugador Haz este tipo de cosas. Podrás experimentar y aprender,
ampliar tus conocimientos. Muchas gracias por
seguirnos. Adiós.