Transcripciones
1. 00 Introducción: Esto es lo que vas a construir un completo dispararlos en el motor Unreal cinco
completamente en plano Soy Rob, y sobre
estos 27 temas, esta serie te llevará
de una base de código vacía a un juego jugable terminado Crearemos nuestro propio movimiento de jugador
totalmente personalizado con independencia de velocidad de fotograma, usando el sistema de
entrada mejorado y cubriendo cosas como la detección de
colisiones en profundidad Estaremos implementando las clases de
peón para los enemigos
y los aviones de jugador con
un enfoque en la herencia, por lo que una clase base, que
alimenta cada tipo de barco, agregando un sistema de proyectiles
que funcionará para ambos lados, una sola clase, que
es totalmente personalizable Incluso las clases de desove que
creamos se
configuran con una arquitectura que
manejará enemigos y fondos, y puedes extender
esto como quieras También echaremos un
pequeño vistazo a cosas como diseño y simplemente exprimiremos el juego con efectos de
partículas,
audio, movimiento de cámara
e incluso knock backck Vamos a agregar un ciclo de juego
completo, así que al final de esto tienes un
juego jugable,
incluida tu interfaz de usuario Puedes jugar, morir,
reiniciar o salir. El foco va a estar
en hacer las cosas correctamente. Vamos a estar viendo arquitectura
limpia, sistemas
reutilizables y entendiendo realmente
por qué algo funciona o no en lugar
de simplemente copiar las notas. Cada decisión se explica. A propósito estaré omitiendo características
integradas
dentro de Unreal, y luego te diré por qué
tomamos esa decisión Cuando algo es contrario a la intuición, lo
llamo y todos los activos que
necesitas para
seguir proporcionan
todos los activos que
necesitas para
seguir y obtener estos
resultados finales, que
significa que solo puedes
enfocarte en la programación y
bajar esa buena estructura del proyecto esa buena estructura del proyecto. Yo he manejado
el arte por ti. El proyecto de tu clase
va a ser este juego terminado
completamente pulido, jugoso y listo para
expandirse en una pieza de portafolio, junto con cualquier nueva característica
que decidas agregar Podría haber nuevos
enemigos, armas, un sistema de puntuación,
lo que quisieras. La arquitectura se
va a
diseñar de una manera
para que usted construya y extienda. Por ejemplo, he tomado
el proyecto para que se
vea así
en el espacio de un par de meses
y agregando un montón de nuevas características y activos
a un proyecto extendido. El primer video
va a estar cubriendo la configuración del proyecto. Tengo
muchas ganas de verte ahí.
2. 01: Configuración: La mayoría de los proyectos irreales se vuelven imposibles de navegar
en un mes. Los activos van a estar dispersos por todas partes, sin convenciones de
nomenclatura, y terminas gastando la mayor parte del tiempo buscando en
lugar de construir cualquier cosa He creado esta serie con intención de
arreglarlo desde el principio. Te estaré ayudando a
construir un
rodaje completo desde cero, donde cada tema se
centrará en hacer las cosas correctamente. Esto es buena estructura,
buen naming, buena arquitectura,
habilidades que
transferirán a cualquier proyecto en el
que trabajes Estaremos trabajando para
construir el juego que puedas ver en
segundo plano aquí
basado en el contenido oficial creado por Epic en su paquete de
ejemplos de contenido. Si esto es algo que te
atrapa el interés, entonces vamos a ponernos en marcha y
establecer esa base Primero, te recomiendo
que navegues
hasta el enlace de descarga
en la descripción. Verás dos
opciones aquí. Nosotros les hemos
disparado subrayan activos Esto contiene las
mallas y texturas de la regla en caso que quisieras modificar algo
en blender o Photoshop Entonces tienes el shoot
them up, guión bajo
tutorial guión bajo inicio, y este es el proyecto
completo Y este será el
que quieras seguir junto con los temas
que recorremos. Por defecto, esto
se proporcionará como una carpeta comprimida para usted Por lo tanto, debe asegurarse de
extraer esto en algún lugar sensato, y comenzar desde
el mismo proyecto simplemente significa que estamos trabajando
con configuraciones idénticas, los mismos activos, trabajando a
la misma escala, etc., lo que facilitará un
poco la solución de
problemas si se encuentra con problemas. Lo primero que hay que mirar dentro de la carpeta extraída, entra en la carpeta tutorial shoot them up
underscore Por defecto, el proyecto está
en Unreal Engine 4.27 para obtener máxima compatibilidad si
quisieras trabajar con una versión de motor un poco
más antigua Si como yo,
vas a estar actualizando
esto para que funcione con el
Unreal Engine cinco La actualización tarda
unos 10 segundos. En Windows, simplemente puedes
hacer click derecho sobre este
proyecto punto U justo aquí, y tienes la
opción de seleccionar
cambiar versión de Unreal Engine En el menú desplegable, elija
la versión instalada con la
que desea trabajar y luego haga clic en Bien. Ya estás listo para ir.
Actualmente estoy trabajando en Linux, así que te mostraré un enfoque
alternativo. Esto es útil, de todos modos. Esto funcionará en Windows,
y en realidad
es algo muy útil de
conocer porque esto puede
ayudarte a arreglar proyectos que de otra manera no se
abrirían debido a cosas como la falta de
complementos, problemas de conexión. Entonces para hacer esto, solo voy a hacer click
derecho sobre el proyecto
punto U. Voy a ir a abrir W, y puedes escoger cualquier editor de texto. Esto podría ser el código Notepad VS. Estaré trabajando con Zed, y podemos ver aquí
del lado izquierdo, si nos fijamos en la asociación
Motor, nos está diciendo que
esto se hizo con 4.27. Podemos simplemente cambiar esto. Voy a estar
trabajando con 5.6, que probablemente esté
desactualizado para cuando estés viendo esto,
pero estará lo suficientemente cerca. Con eso hecho, como
con cualquier editor de texto, solo
podemos guardar esto. Podemos cerrar la ventana,
y ya está listo para funcionar. Para comenzar el proyecto,
simplemente hacemos doble clic en
el proyecto punto U, y esto comenzará a
cargarse en segundo plano , atic en Linux, hacer
doble clic en un proyecto U por defecto en realidad no
inicia el motor Unrel Si quisieras ese tipo
de integración junto con mi instalador personalizado de
UnrelEngine, esto hará cosas
como encontrar todas las versiones descargadas o
instaladas localmente de Unreal, agregarlas a un lanzador
automático aquí, y podemos simplemente ir e Impress Okay,
y podemos cargar el lanzador
bastante estándar que normalmente obtendrías
con el No es realmente el
tema principal de lo que vamos
a estar pasando, así que voy a proporcionar un enlace
adicional a esto. Puedes comprobarlo en
la siguiente descripción. Voy a estar proporcionando los scripts de forma
totalmente gratuita, para que también puedas
descargarlos. Y eso solo irá
más en profundidad de lo que
necesitaba hacer para poner
Linux en funcionamiento,
listo y funcionando bastante perfección con
el motor UnRel Ahora que estamos dentro de Unreal, tu interfaz puede verse un
poco diferente a la mía dependiendo de la versión con la que
hayas decidido trabajar Epic tiende a reorganizar las cosas más o menos cada vez que alguien
se aburre un poco Pero solo podemos enfocarnos
en los conceptos, no en los botones exactos
y en las ubicaciones. Definitivamente existirán, y estarás listo y
funcionando lo suficientemente rápido. Lo primero que hay que
revisar es el navegador de
contenido o
el cajón de contenido, que se encuentra en la parte inferior
izquierda. Aquí es donde vive todo
en tu proyecto. Podemos hacer clic en esto y podemos
ver la estructura de nuestro proyecto. Dentro de la carpeta de contenido, hay una subcarpeta que
coincide con el nombre del proyecto, que es el tutorial de
guiones bajos para disparar, y esta es la convención de nomenclatura
recomendada por Epic para proyectos y estructuras de En ese entonces, tenemos una carpeta de
activos que contiene cosas como nuestras mallas,
texturas y materiales Tenemos una carpeta de planos
para nuestro código y lógica, y tenemos una
carpeta Mapas para nuestros niveles Esta es una estructura simple, pero escala a
cualquier tamaño de proyecto. La otra cosa que puede notar si está
navegando por algunas de las carpetas son cosas como
las convenciones de nomenclatura
que se han elegido Tenemos cosas como MM
underscore texture, que significa material
maestro Entonces tenemos subrayado MI, sea cual sea el material para el que sea, y esa es una instancia material Si vamos a las texturas,
tenemos cosas como nuestro héroe plano de subrayado T,
y eso es T para textura El lugar del que
supongo que todas estas convenciones de nomenclatura no son
aleatorias Todos estos se basan
en el estilo AA. Quieres Google eso, lo
puedes encontrar aquí,
así que solo podemos buscar
Guía de estilo, y estamos
buscando la página de Github, la primera que acaba de llegar. Un enlace para esto también estará en la
descripción a continuación. Nombrar las cosas es
supuestamente uno de los problemas demasiado duros
en la informática, y esto soluciona uno de
esos problemas para ti Yo recomendaría marcar
esto como referencia. Y entonces cada vez que estés
creando un nuevo tipo de activo, si no estás seguro de cómo
llamarlo, revisa aquí y a través de la repetición,
esto se automatizará. Sin embargo, es un
recurso muy bueno. Proporciona prácticamente
todo lo que puedas desear. No hace falta que recuerdes
todo a la vez. Aquí hay
bastantes cosas. Pero si miramos hacia abajo las convenciones
generales de nomenclatura, tenemos cosas como
mallas de esqueleto, sería SK Bob El material para Bob
sería M nscore Bob, textura para Bob sería T
subrayado Bob, y así sucesivamente Si nos fijamos en los planos,
tenemos cosas como el guión bajo BP, y luego
también podemos verificar cosas como la estructura de archivos y
carpetas Así que exactamente como he
mencionado aquí, el nombre del proyecto, y luego todas las carpetas en una configuración
algo lógica y
significativa. Entonces este es realmente el crecimiento sagrado de cómo estructurar
tus proyectos, cómo mantener las cosas ordenadas y
cómo organizarte a medida que avanzas. Para comenzar, necesitamos un nivel
principal para trabajar con él. Antes de sumergirme en
eso, hay algo quiero hacer y
presentarte solo para que
las cosas sean un
poco más fáciles
para que veas mi pantalla, pero esto puede ser útil para
que sepas, también. Entonces voy a subir a la configuración de
edición justo aquí en la parte superior de la pantalla e
ir a las preferencias del editor. Aquí es donde podemos
cambiar diferentes características sobre cómo
se presenta el editor, los atajos,
los enlaces de teclas y cosas así se pueden encontrar aquí Lo que
quiero cambiar es la escala de aplicación aquí. Sólo voy a
cambiar esto a 1.25. Esto es puramente porque
tengo
una pantalla bastante grande configurada, por lo que puede parecer un poco
estirada y los botones pueden parecer un poco pequeños
para que los sigas. Entonces como he dicho,
esto es opcional, pero es útil
saber que esto existe. Y hay muchas más
cosas que puedes hacer dentro de las
preferencias del editor para modificar el aspecto general de tu editor si algo no es del todo adecuado para
que trabajes Sin embargo, esto ahorra automáticamente, así que solo voy a cerrar
la ventana, y
ahora podemos entrar en la creación de
nuestro primer nivel. Esto es agradable y sencillo. Podemos ir al lado
superior izquierdo. Tenemos nuestro botón de archivo, y
aquí tenemos la opción de crear un nuevo nivel. Una cosa a tener en cuenta son
los atajos. Podemos ver todas las teclas
de método abreviado. nuevos niveles son algo con lo que
tendemos a jugar bastante. Entonces este podría ser
uno que valga la pena recordar desde el principio para
ahorrarle un poco de tiempo. Dentro de la nueva ventana, solo
vamos a
seleccionar el nivel básico, no el mundo abierto. Eso va a ser demasiado complejo para lo que
necesitamos ahora mismo. Y también tarda más en
cargarse en el editor cada
vez que inicias la copia de seguridad. Entonces haremos doble clic en Básico, y ahora estamos dentro de
nuestro nuevo nivel básico. Entonces asegurémonos de que hemos guardado esto
correctamente, también. Por defecto, esto se
llama Sin título, es
decir, que aún no lo hemos
guardado. Esto no está almacenado. Si cerramos el proyecto y
volvemos , perderemos nuestro progreso. Entonces vamos a presionar
Control en S dentro de la ventana gráfica aquí,
Controlando S para guardar Vamos a caer en la carpeta del tutorial Shootm up, ir a la carpeta Mapas, y
llamaremos a ésta principal Podemos dar el nombre
justo aquí abajo. Presiona Guardar o Entrar, y
eso se guarda automáticamente. Dentro del cajón de contenido, podemos ir a nuestra carpeta Mapas, y podemos ver que nuestro
mapa está justo aquí. Lo rápido de notar. UnRel usa la palabra map y level
indistintamente Lo mismo, dos nombres diferentes porque claro, lo hace. Podemos ver que aquí, de
hecho, a esto se le llama nivel, pero cuando hagamos
uso de esto más adelante, Unreal nos pedirá
que fijemos un mapa específico Otra cosa a tener en cuenta y otra cosa con la que
estaremos trabajando bastante a menudo es el cajón de
contenido. Entonces, en lugar de presionar
el botón aquí abajo en la parte inferior
izquierda constantemente, podemos presionar Control en el espacio, y esto alternará el cajón de
contenido abierto y cerrado. Y esta parte es
realmente importante. Aquí es donde los principiantes
siempre pierden su trabajo, o al menos
piensan que lo hacen hasta que regresan y
consiguen algo de ayuda. Sin este paso, cerrarás tu proyecto, lo volverás a abrir y te encontrarás
mirando un mapa del mundo vacío y
abierto o algo
que no esperabas ver Tu etiqueta principal aún
existe, pero Unreal no sabe que
debería estar abriendo por defecto Entonces para cambiar este
comportamiento,
vamos a ir a la configuración
del proyecto. Iremos a editar y
luego a la configuración del proyecto. En el lado izquierdo,
en la categoría superior, queremos encontrar la opción de
mapas y modos. Y luego en el lado derecho, ve el mapa de inicio del editor. Cambia este menú desplegable de plantilla predeterminada a nuestro
mapa principal que acabamos de crear, y esto le dice al motor
Unrel qué nivel abrir cuando lanzas el proyecto por
primera vez También podríamos establecer
el mapa predeterminado del juego aquí para que sea principal también. Esto determina lo que ve
el jugador si
realmente empaquetas el juego y le das esto a
alguien más para que juegue. Todos estos ajustes se guardan automáticamente,
para que podamos cerrar esto. Podemos reabrir el proyecto, y esto significa que
regresarás exactamente
donde lo dejaste
siempre y cuando hayas tenido oportunidad
de guardar el
mapa en el que estás trabajando Entonces esto puede parecer mucho trabajo
extra y mucho platicar
solo para el primer tema. Pero estos fundamentos
realmente se componen. Un proyecto organizado se mantendrá manejable a las
10 horas de trabajo,
100 horas, incluso 1,000 horas, mientras que un
proyecto desordenado simplemente no lo hace Y ese es realmente
el objetivo y el enfoque de todo este enfoque
basado en proyectos. Las cosas pueden tardar un
poco más, pero al final, entenderás
lo que estás haciendo y
ojalá te quites
algunas buenas prácticas y harás que tus
proyectos futuros sean mucho más intuitivos y
fáciles de trabajar. Pero con eso dicho, los
cimientos están bien establecidos. La estructura del proyecto,
la convención de nomenclatura y los ajustes están
configurados correctamente El siguiente tema será
crear nuestro peón jugador, que es algo que realmente
puedes controlar Y como he aludido,
quiero que aprendas
realmente lo que estás
haciendo a medida que atraviesas Una de las mejores
formas de aprender no es simplemente
seguir paso a paso. Una vez que sientas que
entiendes algo, intenta extenderlo. Incluso por algo
tan simple como
lo hemos hecho ahora, agrega tus propias carpetas, cambia el nombre de algunas cosas, y
solo demuéstrate a ti mismo que entiendes el
patrón, no solo los pasos. Te estaré guiando
en eso a lo largo del transcurso de lo que
estamos haciendo de todos modos, pero solo hay
tanto que puedo hacer, y gran parte del trabajo
vendrá del autoaprendizaje. Si haces cambios
que funcionan bien,
déjalos caer en los comentarios
y discusiones a continuación. Y si crees que entiendes algo y ves a alguien publicando una pregunta
que crees que puedes responder,
intenta responderla. Explicar algo
que acaba de aprender es una de las formas más rápidas
y mejores de bloquear realmente la
nueva información y asegurarse de que no lo
olvide en el futuro
3. 02 - PlayerPawn: Los proyectos ya se configuran, y
necesitamos algo para
comenzar realmente a controlar. Al final de este
tema, tendremos un peón de jugador con vigilias.
Aún no se moverá. Eso vendrá a continuación, pero
entenderemos exactamente cómo y por qué Unreal decide
engendrar cosas y dónde Una de las cosas centrales en
el desarrollo es planificar con anticipación y realmente
pensar cuál es tu objetivo
actual y
cómo lograrlo. Entonces, simplemente,
por los videos, sabemos que queremos estar controlando
a este pequeño personaje en
un pequeño plano azul, para asegurar que nadie
se quede atrás. Si eres completamente
nuevo en todo, no
quiero lanzar jerga
completa por ahí. Entonces voy a mostrar algunas cosas
realmente básicas. El avión que estamos viendo es algo
llamado malla estática. Entonces si vamos a las mallas de
activos, podemos ver aquí esta
es una malla estática de nuestro pequeño personaje
en el plano azul Entonces queremos estar
controlando eso. Si lanzáramos eso
directamente al nivel, no
seríamos capaces de
controlar una malla estática. Necesitamos hacer este
código basado y usar un tipo de clase
de blueprint por lo menos
para que esto funcione Dentro de Unreal, esto se
conoce como peón, algo que podemos
poseer o tomar el control de,
esencialmente, sólo un tipo
especial de actor Así que sigamos adelante
y creamos nuestro peón correctamente con nuestra buena estructura de
carpetas Entonces voy a entrar en
nuestra carpeta Blueprints. Dentro de aquí, queremos
crear una nueva carpeta. Podemos hacer clic derecho y
buscar la nueva opción de carpeta aquí. Tiendo a usar el
atajo
Control Shift y N para crear allí una nueva
carpeta. Entonces N para nuevo. Voy a cambiar el nombre de
esta carpeta a CR. Esta será nuestra
mecánica de juego principal o características de juego. Y luego dentro de esta estructura de carpetas
grandes, si hacemos clic derecho, queremos subir a la opción de
clase blueprint justo aquí, y esto nos permitirá
crear un nuevo blueprint, y podemos ver una gama de
diferentes opciones Y aquí es donde la
comprensión de la jerarquía de
clases de Unreal puede comenzar a ayudar En definitiva, todo lo que está dentro de UnRel hereda de
algo llamado un objeto Esto es solo un contenedor de datos, la clase más simplificada a la
que tenemos acceso. Muy a menudo entonces vemos
algo llamado actor. Todo en el
nivel en este
momento es en la raíz misma una clase de actor. Tendremos actores de malla estática, actores de
cámara, actores de luz, pero todos son
actores en su raíz. Agrega una presencia física
en la parte superior de los datos del objeto, que es una ubicación,
rotación y escala a la que se hace referencia
como una transformación. Y entonces los peones con los que
vamos a estar trabajando no son más que un actor con la
funcionalidad que hay que poseer Verás en algunos tutoriales, usarán algo llamado
una clase de personaje en su lugar, y eso sería
exagerado por lo estamos buscando hacer
con este shoot up. Los personajes incluyen cosas como mecánica de
caminar, la gravedad, colisión de
cápsulas,
cosas realmente diseñadas para personajes humanoides que
caminan a pie Vamos a estar
haciendo una nave espacial, así que en realidad no
necesitamos nada de eso Y viene con una
gran cantidad de gastos adicionales que necesitaríamos para trabajar activamente. Entonces es posible que veas otros tutoriales
creando cosas como un controlador de tanque usando
una clase de personaje, y aquí es justo donde
ser consciente de cosas como esta
te permitiría considerar que
esa puede no ser la mejor solución para lo que
estás tratando de crear. Debido a que los peones son un actor
bastante usado o un tipo de clase, podemos ver que en realidad está
aquí arriba en la sección común, así que podemos hacer clic en esto y esto creará una nueva clase de
peón para Y queremos llamar a este
BP subrayado base de peones, porque esta será
la clase base para
cualquier clase relacionada con peones que
creamos en el futuro, permitiéndonos reutilizar parte de la lógica para
nuestros enemigos, también, nombrándola por lo que es en general,
no solo por
lo que se supone que debe hacer antes que nada,
que va
a estar funcionando
como la clase de se supone que debe hacer antes que nada,
que va
a estar funcionando
como Antes de ir más lejos,
otro rápido a un lado aquí, rápido, arreglo de calidad de vida. UnrelEngine tiene algunas opiniones
fuertes sobre la administración de ventanas,
y en su mayoría están equivocadas Entonces, para arreglar una de las cosas
que está a punto de suceder, si hacemos doble clic para
abrir nuestro plano ahora, esto simplemente creará
una ventana flotante prácticamente
en cualquier parte de la pantalla Esto puede ser bastante molesto. Significa que las
ventanas pueden perderse detrás de otras aplicaciones
y cosas así. Entonces si volvemos a subir a editar
y luego las preferencias del editor. Mismo lugar que
te mostré anteriormente donde cambié la escala de aplicación. Como he mencionado,
podemos hacer muchos arreglos y cambios en la calidad
de vida. Quiero encontrar está bajo editor
de activos ubicación abierta. Queremos cambiar
esto de default, que está abierto donde sea, y vamos a cambiar
esto a ventana principal. Puedes probar diferentes
cosas y ver cuál puede funcionar mejor para ti. Me gusta
bastante ventana principal. Es como trabajar
en un navegador web, entonces,
donde cada nuevo archivo, blueprint, asset, sea lo que
sea con el que estés trabajando Cada vez que abras una nueva ventana, creará una nueva pestaña y los
acoplará como
marcadores en la parte superior Así que de nuevo, esto
guarda automáticamente, podemos cerrar esto, volver al cajón de contenido, y luego hacer doble clic nuevamente
para abrir la base de la cacerola. puede ver que se abre aquí, que es exactamente lo que quería. Si has hecho lo mismo que yo, donde es posible que hayas
abierto esto dos veces, es posible que te reciban con esta vista
simplificada de solo datos Y eso está perfectamente bien.
No necesitamos entrar en pánico. Estos son todos los detalles de la clase que se nos
presentan esencialmente
en forma de texto o desplegable. Para volver al editor de planos
completo, solo
queremos esta línea
azul de textura, el editor abierto de cuatro planos, y eso nos llevará de vuelta
a donde queremos Bien, entonces hay mucha
información con la que podría
cargarte ahora mismo, pero probablemente te
olvidarías de la mayor parte. Entonces vamos a tomar una especie de forma
más orgánica y natural
para aprender el motor irreal Solo vamos a
trabajar con nuevas características, y las voy a presentar a medida que
avanzamos y a medida
que lleguen a ser relevantes. Lo primero que podemos
ver en este momento es que estamos en el gráfico de eventos en
esta pestaña justo aquí. Aquí es donde
colocamos nuestra lógica y código. Vamos a
volver aquí más tarde. Por ahora, si hacemos clic sobre
sobre el punto de vista, esto es simplemente algo similar
donde podemos mirar alrededor y ver cómo será nuestra
clase de blueprint Las clases de blueprint normalmente están compuestas por diferentes componentes, cada uno con sus propias
características y funcionalidad En el lado izquierdo, podemos
ver el panel de componentes, y queremos agregar nuestra
representación visual ,
esa malla estática. Entonces, si presionamos ad y
buscamos malla estática, podemos
verlo justo aquí. Esa va a ser
la primera parte
del rompecabezas que estamos
tratando de resolver. Con la malla estática seleccionada, en el
lado derecho de la ventana, podemos ver nuestro panel de detalles. Esto nos dice todo sobre el componente que
actualmente hemos seleccionado. Podemos ver que tenemos un desplegable
aquí para la malla estática, y esta es la representación
visual que queremos establecer. Sabemos que queremos que este
sea el avión azul, así que encontraremos al héroe del avión
y seleccionaremos ese. Dentro de esta ventana gráfica, solo estoy usando la rueda del mouse
para desplazarme hacia adentro y hacia afuera. Si presionamos Alt y clic izquierdo, podemos arrastrar
y ver el modelo, y si presionamos el botón derecho
y
arrastramos alrededor del mouse, podemos cambiar lo que
estamos viendo. Haga clic en el medio del mouse y mueva Will Dolly o Pan,
creo que eso es llamar Y esto es
lo básico de tipo de navegar alrededor de
esta ventana gráfica y también la vista del mundo más adelante cuando llegamos a construcción de
niveles y
cosas así Otra cosa que es útil
saber es que si presionas F cuando tienes algo
seleccionado, te enfocas en. Entonces eso es F para el enfoque. Ahora, lo que acabamos de
crear es nuestra malla estática, y podemos ver de nuevo en
el panel de componentes, tenemos algo llamado raíz
de escena por defecto. Esto es mostrar la estructura del
actor, y cada actor necesita
al menos una raíz de escena predeterminada, un punto en el espacio donde se adjunta
todo lo demás. La raíz de escena predeterminada que
tenemos es solo un marcador de posición, por lo que podemos agarrar nuestra malla estática, y podemos arrastrar nuestra malla estática a la
raíz de escena predeterminada y soltarla Así que la pierna izquierda y ahora hemos hecho nuestra malla estática lo que se conoce como
el componente raíz, por lo que el elemento base de nuestra clase de
jugador o nuestro peón Otra cosa, cuando
llegamos a una etapa que pensamos que estamos bastante
contentos con el progreso, tenemos que asegurarnos de
meternos en un buen hábito de golpear compilar y guardar. Esto solo asegúrate de
que si algo se estrella, entonces
no perdamos nuestro trabajo. Y compilando solo
verificamos errores y
captamos las cosas temprano Así que ahora tenemos nuestro
peón con visuales. Pero claro, si
vamos y presionamos play, no vamos a estar viendo
esto todavía porque no le
hemos dicho al motor
Unreal que lo use Y podemos usar alguna entrada estándar de juego en
primera persona aquí. Entonces FUE y D te
volarán por ahí. Q y E
te moverán arriba y abajo, y por supuesto, el
ratón mirará a tu alrededor. Pero, claro, esa no es exactamente la funcionalidad que
estamos buscando. Entonces, en el siguiente tema,
arreglaremos esto
mirando el marco de juego
del motor Unreal Le estaremos diciendo al motor
Unreal exactamente qué engendrar y dónde
queremos que Una vez más, si estás
experimentando por tu cuenta, lo que siempre recomendaría, intenta agregar otros componentes
a la clase de peones Algo tan simple
como una luz puntual, un sistema de partículas por defecto, solo para ver qué
sucede cuando se unen cosas a diferentes
partes de la jerarquía. Ese tipo de experimentación es realmente como conseguirás que
estas cosas se peguen.
4. 03: marco de juego: Con el peón construido,
hemos pulsado play, y ya lo hemos visto
en modo play, en realidad
terminamos volando
alrededor de lo que se llama
el peón predeterminado. Entonces
tenemos que cambiar esto. Unreal spawns es por defecto y ha ignorado por completo la
clase que hemos hecho Para arreglar esto correctamente, necesitamos entender realmente
cómo framework de
Unreal'sGame
decide qué generar,
dónde, y luego podemos decirle qué hacer en
su Entonces, para empezar, un poco
de un panorama conceptual, nuevamente, déjame mostrarte lo que realmente está sucediendo
detrás de escena. En primer lugar,
voy a volver a la ventana principal y presionar play. Dentro de Playode, aquí es
donde podemos volar por ahí. Algo que es realmente
útil saber es que puedes presionar F ocho para expulsar del juego Así que todavía estoy en modo de juego. Pero ya no estoy controlando
el porno predeterminado. Ahora estoy esencialmente de
vuelta en
modo editor para poder usar WAS y D, clic
izquierdo del ratón para mirar alrededor, y puedo ver lo que
sucede durante el juego. Si miramos al outliner del
lado derecho, podemos ver algo
llamado default porn zero Eso es lo que en realidad hemos
estado controlando en el nivel. Y de hecho, todo lo
resaltado en amarillo por aquí ha sido generado por el marco de juego de UnrelEngine No colocamos ninguno de
estos en el nivel. Entonces, cuando presionamos Play, UnRel
sigue una cadena específica. Primero,
comprobará si hay un modo de juego, y si no has configurado uno,
usará una opción predeterminada. El modo de juego
decidirá entonces qué peón generar. Y nuevamente, si no
has especificado uno, usa el valor por defecto, que literalmente se
llama peón por defecto Y eso es actualmente lo que
estamos controlando en lugar de nuestro avión porque nunca
le hemos dicho a Unreal
que use esa clase de avión Así que presionemos Escape
para salir del modo Play, y podremos comenzar a tomar el
control de nuestro proyecto. De vuelta en la carpeta principal. Entonces, si realmente no estás
aquí, los planos centrales dentro del cajón de
contenido, queremos crear una
nueva clase Blueprint misma manera que antes, haz clic derecho y sube a la clase Blueprint Y esta vez queremos crear una base de modo de juego tipo off. Le daré a este el nombre de BP Underscore Game Mode base Y un modo de juego es esencialmente algo que podemos pensar como titular
de una regla. Le dice a NRLEngine qué
clases usar para todo, qué pan generar, qué
controlador usar,
qué Hud mostrar, qué Hud mostrar, Si hacemos doble clic para
abrir nuestro modo de juego, podemos ver que esto se parece un poco
a un plano normal Podríamos entrar en la sección de gráfico de
eventos de código si quisiéramos, pero todo lo que
queremos está en realidad del lado derecho
en el panel de detalles. Podemos ver aquí esas
cosas que acabo de mencionar, el tipo de
controlador predeterminado de Hud están todos
expuestos justo aquí Lo que estamos
buscando es nuestra
clase porno predeterminada justo aquí. Podemos
bajar esto y cambiarlo a BP Underscore porn base Eso es prácticamente todo lo que
tenemos que hacer aquí mismo. Podemos presionar Compilar y guardar para asegurarnos
de que todo eso esté actualizado. Y de hecho podemos cerrar el modo
de juego por ahora. Voy a mantener esto abierto para dar un poco de ejemplo visual de
algo en un momento, pero eso es
prácticamente todo lo que necesitamos
hacer dentro de nuestro modo de juego. Como era de esperar, el solo hecho crear el
modo de juego no es suficiente. Ahora tenemos que decirle
al proyecto que realmente
haga uso de él. Entonces, si volvemos a la opción de edición en la
parte superior izquierda, vamos a volver a ir a la configuración
del proyecto. Y en realidad estamos mirando
hacia atrás a donde estábamos anteriormente, mapas
y sección de modos. Puedes ver en el lado
derecho, tenemos el modo de juego predeterminado es solo uno llamado
Game Mode base. Y si dejamos esto aquí abajo, en realidad
podemos ver
lo que estaba usando. Entonces estaba usando una clase Hod
predeterminada,
la clase de peón predeterminada, la cosa que literalmente nos hemos visto volando, el controlador del jugador
por defecto, y así sucesivamente No podemos
cambiarlos, razón por la cual necesitábamos una
clase personalizada con la que trabajar. Si bajamos esta opción, podemos cambiar esto a BP
subrayado Base del Modo Juego Podemos ver que esto ya está liberado. Y lo importante
es que ahora ha cambiado esto
para que sea nuestra base de peones de
subrayado BP Lo único que quería
mostrarles muy rápido es que si cambio esto aquí,
podría dejar caer esta. Lo cambiaré
por algo completamente único. Cambiamos esto al personaje
de Arc Vz. De hecho, podemos ver que
la clase de modo juego que hemos creado
en segundo plano, así que tenemos nuestra base del modo de juego BP
Underscore se actualizó en segundo plano
para que también sea Arc Vz Si hacemos clic en esto
aquí y cambiamos este de nuevo a BP
subrayado base de peones, solo
quería
resaltar que estos están completamente conectados ahora Entonces, si
aquí cambiamos algo, eso se
actualizará en nuestra clase Blueprint Y si cambiamos algo
en nuestra clase Blueprint, eso cambiará en la configuración de
nuestro proyecto si lo tenemos
conectado justo aquí Con eso hecho, podemos
cerrar la configuración del proyecto, asegurarnos de que compilamos
y guardamos el modo de juego. Si estás
jugando con cosas, vuelve al nivel principal,
presiona play, que es O y P, el atajo para ingresar al modo de reproducción. Y ahora estamos como que
en el avión. De hecho, estamos
literalmente en el avión. Entonces otro problema que resolver,
pero nos estamos acercando. Si has estado colocando las cosas manualmente antes en el medio, si estás
jugando con cosas, es
posible que tengas otros planos
en el nivel como. Asegúrate de deshacerte de esos solo para que
no haya confusión, pero podamos
ver lo que está pasando. Presionamos play
entramos en modo play, y luego si presiono F
ocho para volver a saltar, se
puede ver que ahora en realidad ha generado un avión
para que nosotros controlemos El principal problema es que
estamos dentro de él. Solo quería destacar
otra cosa que está sucediendo con el marco de
juego, y ese es el uso
de nuestro inicio de jugador. Así se puede ver eso
justo aquí en el nivel. Y en el outliner, podemos ver que se llama aquí
el jugador Inicio Esto es lo que
buscará el framework para confirmar dónde
quieres
generar realmente el peón que
quieres controlar Entonces, si muevo esto a
algún lugar muy atrás, me muevo todo el camino hacia
el espacio abierto de aquí. Si presiono play,
todavía estamos desove el avión, pero ahora estamos desove
a la intemperie Entonces otra vez, algo
útil para conocer. Si no tenemos uno de
estos, podemos eliminarlos, pero Unreal ahora necesita
adivinar dónde queremos
engendrar lo nuestro Y no es realmente
adivinar solo para mostrar lo que sucede
con este escenario Si me muevo en el viewpot, solo
estoy usando Right
Mice click para mirar alrededor y luego W AS y D para volar en
función de donde estoy buscando Si presiono play, podemos ver que el avión
ahora solo va a generar la última posición que mi
cámara estaba en la ventana gráfica Así que de nuevo, algo que
acabo de ver tropezar nuevos desarrolladores porque puede no quede muy claro qué estaba haciendo el
jugador start, sobre todo si estás trabajando en un proyecto donde podrías
tener algo así como un personaje en tercera persona o un
personaje en primera persona con gravedad, estarás trabajando en
el nivel,
diseñarás algunas cosas,
presionarás play, y luego
caerás repentinamente por el espacio, evitando
por completo el nivel y estarás un poco confundido. Y eso es solo porque probablemente
te hayas deshecho de tu inicio de jugador. Unreal no sabía dónde
generar tu personaje predeterminado, así que se elige el último lugar en el
que estuviste en el editor Si seguiste
por aquí, podemos ir a este
botón Agregar en la parte superior. Podemos buscar un
jugador que empiece justo aquí, y podemos simplemente dejar caer uno de
estos de nuevo en el nivel. Agradable y fácil,
volvemos a donde estábamos. Así que eso solo deja un problema es que estamos mirando
por el lugar equivocado. Esto solo significa que
necesitamos una cámara y necesitamos decirle a Unreal
cuál usar Para ello, tenemos que volver
a la base porno de subrayado BP Si realmente no
tienes esto abierto, recuerda eso en
el cajón de contenido, así que controla en el espacio y
haz doble clic en la clase base porno. Como he mencionado, la mayoría de
las clases solo están
compuestas por numerosas cantidades
de componentes, cada componente tratando de llenar un rol específico o caso de uso. En este caso, queremos que
un componente
de cámara mire nuestra coincidencia estática. Antes de agregar una cámara,
voy a agregar algo llamado un brazo de resorte solo
para presentarlos. Entonces, si presionamos anuncio por aquí, podemos buscar brazo de resorte.
Haremos clic para agregar esto. Y esto es básicamente
un stick que
sostendrá la cámara a
una distancia fija. También puede manejar
cosas como colisiones, acercando la cámara cuando
golpeamos paredes y
tratando de evitar cosas. No vamos a necesitar ese nivel de
complejidad para nuestro juego, pero es útil saber
que estas características existen. Otro uso muy útil
del brazo de resorte es que evita que
necesitemos
afectar directamente el desplazamiento, la posición y la
rotación de la cámara. Entonces lo vamos a quedar
solo por esas razones. Con el brazo de resorte
aún seleccionado, vamos a volver
al botón Agregar. Vamos a
buscar una cámara. Y queremos seleccionar la cámara
por defecto aquí en la parte superior. Se puede ver que esto
se acaba de colocar en la cámara al final
de la primavera um. Esto nos da un
poco de tiempo para centrarnos en el motor
Unreal y la forma en
que trata la jerarquía Ya hemos visto
el hecho de que la malla estática ahora está
clasificado como la raíz de la costura Entonces, donde quiera que vaya la raíz de la costura, todo lo demás
sigue, incluida rotación, la ubicación y la escala. El resorte um se clasifica entonces como un hijo de la malla estática, y la cámara es un
hijo del resorte um Entonces lo que esto significa es que si agarro el componente de resorte um y luego cambio algo
en la rotación, por ejemplo, sé que
quiero que la cámara mire 90 grados hacia abajo en
la malla estática. Eso será -90 grados. Podemos ver que la
cámara hereda esa rotación que
le he dado a la primavera um Hago el resorte um más grande, así que voy a
bloquear la ubicación, y voy a hacer esto
del tamaño de diez, podemos ver que la cámara
también se vuelve diez veces más grande. Ahora bien, no escalamos la cámara
y saltamos um de esta manera, pero solo quería
mostrar cómo
funciona la jerarquía dentro de irreal
con los componentes Sin embargo, queremos la
rotación de la cámara, así que recomendaría una rotación
de algo así como -90, así que tenemos la cámara mirando hacia
abajo en el reproductor Si presionamos play, podemos ver
cómo será esto. Entonces tal vez un poco demasiado cerca, eso podría ser algo
difícil de ver lo que está pasando
con los enemigos y proyectiles durante el juego El zumbido primaveral tiene
otra característica, que nos ayudará con esto Se llama la longitud del brazo
objetivo, y se puede ver de nuevo
en el panel de detalles. Entonces, como he mencionado,
con la malla estática, cuando tenemos
algo seleccionado, el panel de detalles es solo toda
la información sobre los componentes que actualmente
has seleccionado. El zumbido de primavera tiene
este valor llamado longitud del brazo
objetivo,
que es esta línea roja, y podemos establecer esto en
algo así como 1,200, y eso sería aproximadamente
donde queremos que esté esto Entonces podemos presionar
Reproducir, y podemos ver que podemos ver un poco
más de la pantalla. Volveremos y refinaremos cosas como esta un
poco más tarde de todos modos. Pero por ahora, eso va a
estar perfectamente bien. Una vez más, cuando hayas realizado
cambios con los que estés contento, asegúrate de que golpeamos
Guardar, y tenemos esto luciendo algo más
como un tirador de arriba hacia abajo. Entonces, si has estado
siguiendo y prestando atención, ahora
hemos visto que
si no le decimos al motor Unreal
qué mapa usar, usa un mapa algo aleatorio Si no le decimos
qué modo de juego usar, usa un modo de juego predeterminado. Y si no le dices a
ese qué peón usar, usa un peón predeterminado Pero probablemente hayas
notado que no
le dijimos qué cámara usar, pero sabe usar la
cámara que acabamos de agregar. Entonces, como que rompe esa regla que he
estado destacando. En esto funciona, sin embargo, todavía
se reduce al comportamiento del
marco de juego. Cuando el marco posea por
primera vez un peón, mirará dentro
de esa clase y verificará si hay componentes de
la cámara Estoy simplificando
esto un poco, pero es esencialmente el
proceso que se toma Si encuentra una cámara,
entonces la usará por defecto. Si no encuentra una
cámara en tu jerarquía, entonces creará
una cámara por defecto, y esa posición en la
que la pone simplemente pasa a ser cero,
que en nuestro caso, está directamente dentro
de la malla plana, razón por la
cual estábamos
mirando el interior del cuerpo. Así que de nuevo, ahora
podemos ver por qué estábamos mirando el interior
del avión y cómo
lo hemos anulado para ahora mirar
hacia abajo en el Sin embargo, el mismo tipo de patrón
que todo lo demás. El framework tiene sus procesos
predeterminados, y lo importante es que ahora
estamos más conscientes de que o
tenemos la
opción de
anularlos o convivir con ellos. Con eso hecho, ahora
controlamos qué genera, dónde genera y qué
cámara miramos El marco está funcionando para
nosotros en lugar de contra nosotros. Y nuevamente, puede que se
sorprenda de cuántas personas
terminan trabajando contra el marco
desde hace bastante tiempo. Algo más con lo que me he familiarizado
bastante cuando los estudiantes simplemente se sumergen de
cabeza en los proyectos cuando llegue
a ver el proyecto
después de que hayan trabajado
en él por un tiempo ,
tendrán soluciones para tendrán soluciones ver a través de cámaras
específicas obligando a que los peones se
activen en ciertos puntos, básicamente rompiendo el marco y combatiéndolo Cuando sea posible, podemos usar muchos
de estos conceptos básicos del marco, y en realidad nos ayudan
más de lo que nos obstaculizan Por supuesto, todavía
no tenemos movimiento. Actualmente solo tenemos un peón que ahí se sienta y una
cámara para mirarlo. Entonces eso sería
lo siguiente, agregar movimiento. De hecho te voy
a mostrar la manera
incorrecta de agregar movimiento primero porque es lo que verás en muchos tutoriales diferentes. Después de que lo hayamos visto,
voy a mostrarte cómo solucionar esos problemas, para que
sepas a qué buscar. Si quisieras
volver a experimentar , la pequeña recomendación, aunque todavía estamos bastante temprano
en los temas sería intentar ajustar la distancia o el ángulo de la
cámara, tal vez ir por una configuración ligeramente
diferente para el ángulo en el que estás
mirando hacia abajo en el avión. Se puede agregar una segunda cámara y ver qué pasa. ¿
Cuál elige? Y si estás haciendo cosas
así, empieza
a tratar de describir lo que estás notando que está haciendo
el framework, qué está haciendo que
no esperas, o lo que estás
entendiendo al respecto
5. 04 - LegacyInput: Antes de que el jugador
pueda moverse, Unreal necesita saber lo que presionan
los jugadores Eso podría ser teclas del teclado, sticks de
controlador, disparadores. Todo esto fluye a través
del sistema de entrada. Unre toma esos enlaces y convierte en valores de entrada, y lo leemos para
nuestro sistema de movimiento Entonces el primer paso
será entender cómo funcionan realmente esos valores. Para comenzar, vamos a
estar haciendo esto a través del sistema de entrada heredado
que va de la vieja escuela. Para encontrarlos,
queremos volver
a la configuración de nuestro proyecto. Así que vamos a subir a
editar y proyectar ajustes. Vamos a ir un
poco más abajo de
lo que teníamos antes. Y podemos ver aquí
tenemos la sección de entrada. Como he mencionado, esto
es una especie de vieja escuela, e incluso hay una
advertencia aquí sobre el sistema de entrada heredado que
ahora está en desuso.
Esto está bien. Todavía es útil saberlo
porque es probable que te encuentres con proyectos
que todavía usan esto. Muchos ejemplos y proyectos por ahí siguen
utilizando este sistema. Tener dos
tipos diferentes de entrada aquí. Tenemos nuestros
mapeos de acción, que son binarios. Estos son
presionados o no presionados, perfectos para cosas como fuego, interactuar, saltar, etc. Luego tenemos nuestras asignaciones de ejes, y estas convierten
la entrada del jugador en valores continuos de punto
flotante Perfecto para el movimiento.
Entonces por esa razón, vamos a ir a agregar un
nuevo mapeo de ejes justo aquí, y vamos a nombrar este
movimiento a la derecha. Debido a que
aquí tenemos
este valor de escalado que podemos cambiar para las diferentes entradas que
proporcionamos , llamaremos a
este movimiento correcto. También controlará el
movimiento hacia la izquierda
haciendo de la otra entrada
un valor negativo. Desde este desplegable, podemos
encontrar cualquier entrada que queramos. Estas podrían ser tus prensas de
teclado, mouse, gamepad, cualquiera que sea
el caso Algo que no
sabía desde hace muchos años cuando estaba usando el motor
unrel es esto En realidad es un botón.
Si hacemos clic en esto y presionamos la tecla D, por ejemplo, eso
rastreará la siguiente entrada como D, y eso sería perfecto
para movernos a la derecha. Si presionamos el botón más,
podemos agregar otra encuadernación. Voy a presionar esto
nuevamente y luego presionar A, así que ahora tenemos nuestro movimiento
hacia la izquierda Lo único que he
mencionado es que por defecto, este es
un valor positivo. Si cambiamos esto a un valor
negativo, entonces menos uno, eso permitirá que la entrada nos
mueva en dirección hacia la
izquierda Si quisieras
vincular diferentes claves al mismo enlace de entrada, solo
podemos agregar dos
más como ejemplo. Podemos agregar uno para
la flecha derecha y otro para la flecha izquierda. Nuevamente, cuando nos movemos a la
izquierda, solo queremos asegurarnos de que sumamos el valor
negativo a éste. Sistema simple y
lo suficientemente flexible para lo que
tenemos que hacer ahora mismo. Al igual que con todo
antes, esto se
guarda automáticamente para que podamos cerrar
la configuración del proyecto, volver al cajón de contenido, volver a
usar el control en el espacio como resumen del atajo y volver
a la base del porno Si todavía estás dentro
de la ventana gráfica, vamos a querer pasar
a pestaña
del gráfico de eventos ahora Entonces esa que
mencioné, aquí
es donde
va a ir nuestra lógica,
y eso es lo que vamos a
estar haciendo enseguida Aquí, podemos ver algunos nodos diferentes
ya en la gráfica, y solo estoy dando clic derecho
y arrastrando para moverme Primero, podemos ver que tenemos
nuestro nodo start play, y este fis solo una vez
cuando presionamos Start A continuación, tenemos nuestro
tick de evento en la parte inferior, y este evento se dispara continuamente mientras
el juego se está ejecutando. Es posible que escuches a la gente
decir cosas como si
evitáramos usar
tick de eventos a toda costa, pero eso es un poco
simplificando Para funcionalidades como el movimiento, donde queremos
que eso sea suave y receptivo o movimiento de cámara, física, cosas así, es exactamente donde debe estar la
lógica. Solo tenemos que
asegurarnos mantenerlo limpio y eficiente. Entonces finalmente, tenemos el acto del
evento para comenzar a superponerse. Esta es una verificación de superposición, una verificación de colisión para toda
la clase. En nuestro caso, eso podría ser
cualquier cosa, desde la malla estática, el componente de resorte um
o el componente de la cámara. Es un poco vago, así que tiendo a no usar esto y luego
manejaremos colisiones por
componente Para que podamos agarrar este, presionar eliminar, y
nos desharemos de eso. Para demostrar lo que está haciendo el mapeo de
ejes, vamos a
bajar un poco, así que estoy haciendo clic derecho y
arrastrando para mover la gráfica Quiero hacer clic aquí,
y vamos a
buscar ese enlace de entrada que
hicimos hace apenas un momento. Yo he llamado al mío Mover a la derecha. Aquí tenemos dos
opciones diferentes. Tenemos el evento del eje
y el valor del eje. El evento crearía algo que se
parece mucho al eventic proporcionando este pin de ejecución para que podamos impulsar la
lógica futura a partir de esto La diferencia con
el valor del eje es si hacemos clic en este. Esto proporciona solo
este alfiler verde. Ese pin verde es un valor flotante
o un valor de punto decimal, y esto proporcionará un valor dependiendo de
lo que estemos presionando. Si no estamos presionando
nada, obtenemos cero. Si estamos presionando a la izquierda,
obtenemos menos uno, y si estamos presionando
a la derecha, obtenemos uno positivo. De hecho, puedo mostrarte eso en una demostración realmente simple, y se lo recomiendo a cualquiera que esté aprendiendo nuevas partes
del motor Unreal Vamos a sacar de
este pin de ejecución aquí, arrastrarlo a la
gráfica y soltarlo, y luego vamos a
buscar la palabra print string. Entonces esto solo va a proporcionar un mensaje de depuración en nuestra pantalla, en el lado izquierdo
si presionamos play. Entonces podemos ver que
por aquí está actualmente spamming la ventana
con la palabra hola Ahora bien, para evitar que eso sea
spam porque esto se está ejecutando 120 veces por segundo, queremos bajarlo, cambiar la duración
a 2 segundos. Esto se está
imprimiendo actualmente por 2 segundos, y lo convertiremos en cero. Esto entonces se convierte en una impresión más
constante por aquí, así que ahora solo está
imprimiendo la palabra hola. Obviamente, no
queremos que esto diga hola. Queremos que esto nos muestre
lo que se está presionando. Entonces voy a tomar
el valor float aquí, tirar de este pin, y soltar
esto en el instring El motor Unreal
es lo suficientemente inteligente como para convertir automáticamente nuestro flotador en una cadena de texto
por lo que este es un sesgo legible Entonces, si
le pegamos a compilar
y jugar de nuevo, se puede ver ahora esto
está imprimiendo cero, que es porque no estoy
presionando nada en absoluto. Si presiono la flecha izquierda, imprime menos uno,
la flecha derecha, obtengo uno positivo y
lo mismo para A y D. Así que podemos ver que está funcionando. Tenemos
algo pasando aquí. Entonces, al imprimir el valor se
muestran los datos, pero sigue siendo solo un número en lo que a nosotros
respecta. Entonces, hagamos algo muy rápido para que este
efecto sea algo visiblemente Todavía no vamos a agregar
movimiento. Vamos a llegar ahí
en un tema separado. Si sacamos de nuestra cadena de
impresión, sin embargo, así que este pin de ejecución aquí y buscar conjunto Act
escala tres D. Queremos este nodo justo aquí, y todo lo que vamos a hacer
es que vamos a afectar la escala general de nuestro actor en función de la
dirección que estamos presionando. Para ello,
sólo vamos a necesitar un poquito de espacio en el medio. Así que sólo estoy moviendo algunos
nodos por aquí. Vamos a mantener las
matemáticas muy, muy simples. Esto es completamente
descartado y solo para visualizar partes
del concepto aquí Podemos tomar nuestro
actor de set escala tres D, sin embargo, y podemos controlar esto por la dirección
que estamos presionando. Entonces podemos hacer que la escala
del actor sea cero menos uno o uno. Y si agregamos alguna entrada analógica, podríamos hacer que ese valor
esto sea realmente simple. Vamos a tomar nuestro
get move que valoramos aquí, así que voy a agarrar esto, presione Control en D para duplicar. Y sólo vamos
a enchufar esto aquí. Entonces como dije, de verdad,
muy simple. Esto no va a ser útil para ningún tipo de escenario de caso de
uso real. Solo quería familiarizarte un
poco con un poco de blueprinting antes de sumergirnos en el movimiento Pero si golpeamos compilar,
esto solo asegura que todo haya sido revisado
por errores y funcionando, presione guardar para que no perdamos
ninguno de los avances. Y una cosa que creo que
voy a hacer es volver
a editar y luego a la configuración
del proyecto. He conectado mi gamepad, y si volvemos a desplazarnos hacia abajo
hasta la sección de entrada, solo voy a agregar
una nueva entrada aquí, haga clic en este botón, y solo estoy moviendo el
stick analógico hacia la izquierda Entonces el stick analógico izquierdo, me he movido sobre el eje X,
que es izquierda y derecha. Podemos dejar esto como un número
positivo si
quisiéramos invertir el movimiento
analógico. Entonces, por ejemplo, si jala a
la izquierda, entonces me movería a la derecha. Entonces por eso es posible que queramos
sumar un valor negativo. Pero debido a que el análogo tiene
un rango completo de movimiento, y lo suficientemente inteligente como para saber tomar la
dirección correcta como positiva, y la dirección
izquierda automáticamente se le dará este valor negativo. Para que podamos cerrar esto.
Podemos entrar en juego moode Hemos roto el
avión en este momento. Entonces, por el momento, estamos
imprimiendo cero en la parte superior. que significa que estamos pasando
el número cero a la X, Y y Z de la escala de nuestro avión,
razón por la cual no podemos verlo. Si presiono A, entonces estamos
invirtiendo el tamaño, así que estamos viendo el
fondo porque ahora estamos haciendo plano la escala
de este negativo Y si presiono D, estamos haciendo que la escala del
avión sea positiva. La razón por la que quiero
usar el stick analógico es que podemos visualizar esto un poco más para que pueda obtener algunos movimientos suaves con solo
mover el stick analógico. Si ves el número en
la parte superior, esto va entre cero y menos uno porque me estoy
moviendo hacia la izquierda. Y si lo muevo a la derecha, vamos entre
cero y uno positivo. Entonces solo una especie de visualización
de cómo podemos hacer uso de estos valores y enchufar esto en alguna lógica
realmente simple. Nuevamente, estamos consiguiendo
otra conversión. Esto es tomar nuestra
dirección de movimiento, así menos uno, cero o uno, multiplicando eso contra todas
estas propiedades de escala Así que las
propiedades de escala e irreales. Tienes la X, Y, y Z. solo para visualizar esto para
algo sencillo como un cubo Vendré aquí solo
para mostrarte esto. Si quisiéramos
cambiar las propiedades o la escala de este objeto, podríamos tomar el eje X solos, y se puede ver que se está
haciendo más largo. Podríamos escalar en el
eje y para hacerlo más amplio. Y nuevamente, podemos cambiar el eje
z para que sea más alto. Tan agradable y simple, y eso es
realmente todo lo que estábamos haciendo aquí en el código, pero
solo estamos normalizando esto Entonces todos ellos son cero, ya sea menos uno o uno,
basado en la entrada. Entonces como dije, código
completamente inútil,
completo tiro a la basura, pero ojalá eso haga que
la entrada y cómo
podemos utilizar ese valor un
poco más comprensible. Con eso hecho, hemos confirmado que nuestro aporte está funcionando. El porno en sí todavía no se mueve. Esa parte va
a ser la siguiente en venir. Y en el siguiente
video, convertiremos esta entrada en algún movimiento
real del jugador.
6. 05: PlayerMovement: Pero configurado y probado, es
hora de hacer que el
avión realmente se mueva. Advertencia justa de nuevo, todavía
vamos a estar haciendo las cosas de
la manera equivocada primero marco dependiente del
movimiento con una especie de movimiento ágil,
llenar, pero va a funcionar Y tal vez te estés preguntando por qué estoy enseñando
a sabiendas lo incorrecto Esto se debe a que este código exacto aparecerá en muchos lugares. Esto es de los épicos ejemplos de contenido
oficial, que significa que lo verás
en otros tutoriales que hacen referencia a que
proyectos más antiguos puedes heredar, y estoy seguro en
muchos otros lugares Cuando me di cuenta de eso,
decidí que esta sería una oportunidad
perfecta para llevarte a un punto al final de este video donde
verás el error, entenderás por qué sucede y
sabrás cómo solucionarlo. Así que tenemos que estar todavía dentro de nuestra base de peones de subrayado BP De hecho, podemos deshacernos de todo el código que
tenemos en este momento. Nos desharemos de esta
escala e imprimiremos cadena. Eso fue sólo para
demostración y depuración. Para el movimiento, esto
es realmente sencillo. Solo tenemos que considerar esto como tomar nuestra dirección de movimiento. Vamos a agregar algún tipo de velocidad
variable un
poco más tarde, y queremos
compensar la ubicación de nuestro avión cada tick. Podemos hacer esto
tirando del eventi,
el pin de ejecución justo aquí Vamos a
buscar algo se llama locación del actor set. Y este será
nuestro nodo, que está impulsando y controlando
directamente hacia dónde nos movemos. Para que esto funcione, necesitamos
calcular un desplazamiento, teniendo en cuenta la ubicación actual del
avión y luego dónde queremos que esté. Podemos hacer eso usando
otra función incorporada. Podemos hacer clic derecho
en el gráfico de eventos, y voy a
buscar la ubicación de Get actor. Si pasamos el cursor sobre estos cuando los
estamos encontrando también, en caso de que no
lo supieras, puedes ver consejos de
herramientas sobre lo que hacen
estas funciones Entonces esto vuelve a la ubicación
de los componentes raíz, que sabemos que es
nuestra malla estática, esencialmente diciéndonos dónde
estamos en cualquier fotograma dado. lado de esto,
vamos a sacar de este pin vectorial el pin
amarillo justo aquí, y vamos a
buscar el símbolo más, o puedes escribir add y
queremos el nodo AD. Podemos hacer algunas matemáticas vectoriales realmente
simples. Entonces lo que tenemos
aquí es nuestra
posición actual más un desplazamiento igualará donde queremos
estar para que podamos enchufar
esto directamente. Un problema al que nos
enfrentamos en este momento es que
queremos
controlar directamente el eje Y. Entonces, cuando estés
trabajando con Unreal, voy a volver
al nivel solo para un ejemplo
rápido aquí Cuando se trata de
direcciones y movimiento, si alguna vez no estás seguro de en
qué dirección quieres moverte, simplemente
podemos hacer algo
como agarrar nuestra malla Deja esto en el nivel, y
obtenemos este widget aquí, que nos mostrará las
direcciones que
puedes mover dentro de Unreal Lo principal para tratar de
recordar desde el principio, el rojo, que es el eje X está
adelante en el mundo. Y, que es verde es derecha e izquierda en el
mundo o de lado, y Z, que es azul,
está arriba y abajo. Eso es bastante útil porque Unreal Engine hace código
de color estos Entonces, si miramos en
el panel de detalles a la derecha, podemos
ver aquí tenemos X, Y y Z, y eso
tiene un pequeño icono de píldora muestra rojo, verde y azul. Tenemos lo mismo para
rotación y escala. Y como he mencionado brevemente antes, estas tres variables, la rotación de ubicación y escala son solo una
estructura que conforman la trans y cada una de estas
variables como la ubicación, y es solo una estructura de valores individuales de
punto flotante. En el ejemplo en el que he demostrado que se basa este
proyecto, el avión obviamente se mueve de lado a lado y solo de lado a lado, algo así como viejos invasores espaciales, y estamos tratando de
recrear eso, así que sabemos que necesitamos
movernos en el eje Y. Así que de vuelta dentro de nuestro código, eso significa que necesitamos
exponer de alguna manera esta variable aquí. Súper simple de hacer. Podemos hacer click
derecho sobre el pin amarillo, y tenemos esta opción
para dividir el pin de estructura. Y por eso
mencioné que a estas se les hace referencia como estructuras. Vienen en muchas formas
diferentes, pero normalmente son solo una combinación de
diferentes variables, haciendo un tipo específico de variable con un caso de uso
diferente. En este caso, es la ubicación para el movimiento
tridimensional. Si dividimos el pin de estructura, puede ver que éste
se revierte luego a sus valores individuales de punto
flotante, la X, la Y y la z, y ya
tenemos nuestro
movimiento configurado Ese es nuestro movimiento a la derecha, que solo
podemos enchufar al eje Y. Entonces, lo que estamos haciendo
ahora es que estamos tomando nuestra ubicación actual,
y cada fotograma, bien
estamos agregando uno, cero o menos uno a la dirección. Entonces, si presionamos play, podemos ver que ahora tenemos algún
tipo de movimiento. Entonces A y D me harán
mover a izquierda y derecha, al igual que los arokis de izquierda y derecha Entonces estamos un paso más cerca de
donde queremos que esté. Ahora bien, esto sí nos pone en una pequeña situación
aquí donde ahora
tenemos un problema donde este es
un juego dependiente de framerate Entonces
te voy a mostrar algunas cosas sobre
las repercusiones
de esto y cómo puedes probar y
ver esto por Entonces, por el momento,
recuerda que estamos moviendo una unidad por cuadro si
estamos presionando un botón. Entonces, si estoy corriendo a
120 cuadros por segundo, eso son 120 unidades por segundo. Un motor rL calcula
unidades en centímetros. Entonces esto actualmente se
mueve
alrededor de 120 centímetros/segundo Ahora bien, si vuelvo
al modo de juego, voy a entrar aquí a
la ventana principal, y voy a
presentarte algo llamado los comandos de la consola, donde podemos ejecutar
comandos simples para probar cosas. También me voy a
deshacer rápidamente de este avión de prueba de aquí. Así que de vuelta dentro de un Playmode, haz clic en la
ventana gráfica para asegurarte tienes el
control total de Y quieres
encontrar la llave Tilda. En la mayoría de los teclados, esto está al
lado de la fila de números. Si presionas la tecla Tilda, puedes ver que
aparece una pequeña consola en la parte inferior de
la pantalla por aquí Voy a habilitar un comando de consola realmente
simple, que se indica espacio FPS. Si presiono Enter, podemos ver al
lado derecho de la pantalla. Ahora estoy mostrando el número de fotogramas que estoy ejecutando por segundo. Voy a presionar la tecla
Tilda otra vez, y voy a
escribir T dot max FPS o One Word y luego espacio, y luego voy
a establecer esto en 30 Ahora podemos ver en el
lado derecho que ha tapado mis marcos a 30
cuadros por segundo. Ahora solo considerando lo que
mencioné hace un momento, si a 120 cuadros por segundo, estaba moviendo 120
unidades por segundo, esto ahora significa que
obviamente me estoy moviendo a 30 unidades por segundo. Entonces estamos jugando el mismo juego, tenemos el mismo código de
movimiento, pero el movimiento es
drásticamente diferente Si pongo esto de nuevo arriba
voy a destapar esto a 300. Estoy corriendo a unos 300 FPS. Podemos ver que ahora
en realidad nos estamos moviendo considerablemente más rápido porque ahora estoy
moviendo 300 unidades por segundo. Voy a poner esto de nuevo a 30 y se
puede ver el contraste. Ahora, probablemente puedas empezar a
ver por qué esto no es lo ideal. Y esto es lo que denominamos dependencia de la velocidad de
fotogramas cuando un juego se ejecuta específicamente
basado en el hardware. Por lo que los jugadores con
sistemas más rápidos se moverán más rápido y los jugadores con
sistemas más lentos se moverán más despacio. Es un bicho que se envía en muchos
más juegos de los que cabría esperar. Entonces, antes de ponernos a
movernos y
mirar hacer lo que se llama independencia de velocidad de
fotogramas, vamos a ajustar el resto de nuestro código de movimiento
por ahora para que tengamos todo con
lo que trabajar Por el momento, mover
solo una unidad por cuadro obviamente
no es demasiado notable, así que vamos a querer
multiplicar nuestra velocidad por un valor. Eso lo podemos hacer muy
fácilmente. Nuevamente, trabajar con matemáticas dentro de planos
es relativamente sencillo Podemos sacar de nuestro flotador
aquí lo que queremos multiplicar contra. Arrastra
eso a la gráfica. Busca el asterisco, el símbolo multiplicar
o tipo multiplicar, y podemos enchufar este
resultado a la Y. Esto significa que ahora
tomaremos nuestra dirección movimiento
multiplicada por una velocidad de movimiento, que podemos establecer en algo
aleatorio por ahora como diez, y este será nuestro nuevo desplazamiento que aplicará
cada fotograma individual Así que ahora nos estamos moviendo más rápido,
pero todavía vamos a tener ese problema de
independencia de velocidad de fotogramas donde si cambio la velocidad de
fotogramas a la que me estoy ejecutando, ahora
me estoy moviendo mucho más rápido. Entonces eso se está volviendo
aún más notorio. Yo solo quería
enfocarme aquí también. Lo que acabo de crear aquí es lo que nos referimos
como un número mágico. Este número ese contexto, cuando vuelvo a esto
dentro de un mes o dos, es muy probable
que se
olvide exactamente lo que representaba
este número sin mirar atrás
a través del código. Te doy la pregunta,
¿por qué fueron estos diez? ¿Por qué no fueron 100? ¿Por
qué no fueron mil y así sucesivamente Para paliar esto un
poco, y otra vez, centrándonos en esa buena
práctica de programación y tratando mantener nuestro código ordenado
desde el principio. Vamos a sacar de
este pin verde aquí, y voy a hacer
algo llamado promover esto a una variable, y se puede ver la opción justo aquí para promover
esto a una variable. Entonces vamos a dar click sobre esto. En el lado izquierdo es
donde viven las variables. Podemos tomar este nombre, y le
cambiaré el nombre a velocidad de
movimiento. Entonces ahora de un vistazo,
por lo menos, esto nos da alguna idea de
lo que está haciendo este valor. Entonces esta es la velocidad a la que
esperamos movernos, multiplicada por una dirección que se agrega a nuestra ubicación activa. Comienza a leerse un
poco más como una novela en una página, y te haces una idea de lo que va a hacer
el código, incluso sin
investigarlo a fondo, que es lo que
queremos que
haga nuestro código , se vuelva legible por humanos. Entonces tenemos nuestra variable de
velocidad de movimiento. Podemos golpear compilar aquí arriba, solo para
verificar que esto tenga el número diez
rellenado porque
ya teníamos ese valor
como número mágico. De vuelta al error de
velocidad de fotogramas, entonces. Tenemos
que asegurarnos de que independientemente de la velocidad que esté funcionando nuestro
sistema, que obtengamos el mismo
tipo de movimiento. Esto no es solo por
el resultado del jugador, sino como diseñador,
cuando estamos haciendo nuestro juego, estamos
afinando todo. Queremos que todo se
sienta tan suave,
reactivo y receptivo
como esperaríamos. Afinamos todo el juego
para jugar de una manera específica. Y obviamente, eso
va a estar completamente arruinado si
alguien que lo está jugando en un sistema que es el doble de
rápido que el nuestro obtiene un resultado
diferente. Lo que necesitamos para esto es
algo llamado Delta segundos, a
veces referidos como Delta simplemente el número
de segundos que han pasado desde
el último fotograma. En lugar de usar
este pin aquí para nuestro cálculo,
porque, por supuesto, tendría alambres superpuestos
y comenzaría a introducir código de
espagueti. Vamos a
hacer click derecho en la gráfica, y vamos a
buscar Delta segundos. Puedes ver aquí
tenemos la opción, obtener segundos World Delta, y podemos enchufar esto
y hacer uso de esto. Simplemente,
queremos tomar todos
los valores que
tenemos aquí y multiplicar esto contra nuestros segundos
Delta. Así lo mismo otra vez. Buscaremos
multiplicar, enchufar esto, enchufaremos el cálculo
al resultado, y nos estamos
acercando a lo que queremos. Ahora, permítame
demostrar rápidamente lo que Delta seconds está
haciendo realmente y lo que representa el
valor. Una manera muy rápida de
hacer esto. Quiero tirar una cadena de impresión
como la que hemos visto antes. Pondré esto a cero
por la duración, agarraré el nodo Delta seconds, duplicaré esto, enchufaré esto solo para que podamos
ver lo que está imprimiendo. En mis 300 FPS, no
vamos a usar este número, así que voy a
rematarlo a 120. A 120 FPS, estamos obteniendo
un valor alrededor 0.008 segundos
entre cada fotograma Si vuelvo a tapar esto a 60, veremos que esto
desciende a 0.016 Y entonces si
bajamos esto más a 30, vamos a obtener
un número de 0.033 Así que aproximadamente, no exactamente, sino aproximadamente la mitad del número cada vez que bajamos
la velocidad de fotogramas a la mitad. Y así es como esto es
útil y cómo esto soluciona nuestros problemas
dependientes de la velocidad de fotogramas. Si estás corriendo a 30 FPS, cada fotograma te mueve más lejos, pero estos son pasos más grandes, pero estás dando menos
pasos por segundo. Mientras que a 120 FPS, cada fotograma te mueve menos. Estos son
pasos más pequeños, pero estás dando cuatro veces más pasos dentro de eso. Y con lo que terminamos
es que la distancia total por segundo se queda
aproximadamente igual. Y esto es si estás
corriendo a 30 FPS o 120 FPS. Obtenemos independencia de velocidad de fotogramas, y esta es la diferencia
entre un juego que se siente justo en todo el hardware, comparación con personas que tienen diferentes experiencias en sistemas de gama
alta o inferior. Una cosa a tener en cuenta, porque ahora
estamos multiplicando nuestros valores por este número
increíblemente pequeño, la velocidad que estamos
moviendo obviamente
va a sentirse mucho más lenta,
muy lenta, muy lenta, Entonces tenemos que entrar y dar cuenta de esto en
la velocidad de movimiento. Voy a aumentar
esto a algo como tal vez 500 en lugar de diez, hit compile and play, y se sentirá
más o menos igual. Lo principal, de nuevo, es
lo que estamos viendo es un salto 30-120 FBS Se ve más suave, pero no vamos notablemente
más rápido o más lento La única diferencia
que estamos viendo es lo suave que
se siente el movimiento debido a la velocidad de
fotogramas que estamos viendo. Entonces ese es
realmente el objetivo aquí. Entonces con eso, el
movimiento funciona. Tenemos el
problema del framework arreglado, pero realmente no está del
todo pulido. Podemos notar que es bastante
ágil cuando lo movemos. Si presionamos una dirección, estamos
instantáneamente a toda velocidad. Una vez que liberamos, nos
detienen instantáneamente. No hay aceleración,
no hay impulso. Los vehículos reales no
funcionan de esta manera. Incluso nuestros gady les
tendrán algo de peso, así que tendremos que considerar agregar algo de aceleración suave Y todo este enfoque que
estamos tomando en este momento, la ubicación del actor set. Al hacer esto, cada cuadro
no tiene integración física, ninguna respuesta de colisión adecuada,
y está perfectamente bien. Es por ello que se proporciona
en ejemplos de contenido de Epics. El patrón funciona
porque es simple, no porque sea la mejor práctica. Entonces tenemos movimientos.
Entendemos el bug de framework que
teníamos y cómo solucionarlo, y sabemos por qué este enfoque es común y por qué no es ideal. A continuación, trasladaremos los sitios. Añadiremos algo de aceleración, banca
rotacional, solo
apuntando generalmente a algo que se sienta más
como un avión. Si quisieras
probar a experimentar, siempre
podrías intentar
agregar movimiento vertical Es el mismo patrón. Simplemente use el eje diferente, el eje X en lugar
del Y o agréguelo. Es probable que tengas que
introducir un nuevo enlace de entrada, también, un pequeño consejo allí.
7. 06 - Movimiento suave: Momento, nuestro movimiento
técnicamente funciona, pero se siente muy robótico. Inicio instantáneo, parada instantánea. Abordaremos eso en
este video agregando algo de aceleración y rotación
bancaria, así que parece que en realidad estás volando algún tipo de avión
Arcade. Estaremos usando algo
llamado interpolación, que es el suavizado
entre dos puntos a lo largo del tiempo Este también será el
siguiente paso para heredar los bugs dentro del épico contenido
oficial de aprendizaje Lo encontraremos, lo
reconoceremos
y lo arreglaremos un
poco más tarde. Entonces ahora mismo, el problema
es que nuestra velocidad está siendo
tomada directamente de la entrada. Justo aquí, tenemos movimiento derecha multiplicado
por la velocidad de movimiento. Entonces, si estamos presionando bien,
ese es uno multiplicado por 500. Vamos directo a la
velocidad de 500 unidades por cuadro. Si estamos presionando a
la izquierda, eso es
uno negativo multiplicado por 500, así que estamos obteniendo 500 negativos aplicándose directamente
a nuestra velocidad de movimiento. Es por eso que conseguimos esa parada
instantánea de inicio instantáneo. Por supuesto, tan pronto
como soltamos una clave, entonces estamos multiplicando
el valor por cero, así que vamos en línea recta
500-0 Para un movimiento suave, vamos a necesitar dos valores diferentes. Queremos una velocidad objetivo, que es donde queremos
estar, y necesitamos nuestra velocidad actual, que es
donde estamos en este momento. O el uso de estos para movernos
gradualmente entre nuestra velocidad actual y
nuestra velocidad objetivo. Para comenzar, podemos crear
muy fácilmente un nuevo flotador o la
velocidad actual que
vamos a estar rastreando. Podemos agarrar nuestra
velocidad de movimiento por aquí, hacer clic
derecho sobre esto o presionar
Control en D para duplicar. A esta
le llamaremos velocidad actual. Y lo que
haremos es tomar este valor que estamos calculando
justo aquí, esencialmente nuestra velocidad de movimiento, y ese será el objetivo que usaremos un poco más adelante. Si quisiéramos ordenar esto, definitivamente
podríamos hacer
esto más legible visualmente. Si muevo esto, podemos agarrar este cálculo justo aquí. Voy a presionar
Control en X para cortar esto, control en V para pegarlo arriba, sacaremos de esto aquí y promoveremos esto
a una nueva variable. Promocionaremos este
a algo que llamaremos velocidad objetivo. Y podemos enchufar
esto justo aquí. Verás por qué en un momento, esto realmente
no está cambiando
nada en este momento, pero hará que las cosas solo sean
un poco más legibles. Ahora, además de simplemente
esconder cosas para que tengamos un poco
más de espacio para trabajar, recuerden que necesitamos rehok nuestra velocidad objetivo que ahora
estamos calculando La única diferencia es
que esencialmente
le hemos dado un nombre a este pin. Así que de nuevo, es sólo un
poco más legible. Vamos a agarrar
nuestra velocidad objetivo. Y si simplemente dejamos
esto directamente sobre el pasador de flujo Y que ahora
está expuesto, eso automáticamente lo
conectará para nosotros. Algo que
me verás hacer con bastante frecuencia, también, es lo que acabo de
hacer ahí. Entonces estos pines nosotros
tipo de cables estaban flotando
un poco alrededor. Si agarras un montón de nodos, presiona una señal que alineará automáticamente
los cables por ti. Para que podamos mantener las cosas un
poco más ordenadas a medida que avanzamos. Otra cosa que es útil
saber es que si pasas cursor sobre el pin justo
aquí, por ejemplo, y presionas una señal sin
realmente agarrar las notas, tomará el nodo
que está conectado, y
los alineará también Entonces no es algo que
absolutamente tengas que hacer, pero solo
lo estoy mencionando porque me doy cuenta de que hago este tipo
de con memoria muscular, así que voy a hacer esto mientras
estoy hablando a veces. Y solo quería que
supieras los atajos
que estoy usando. Bien, así que volvamos
al tema principal. Queremos
suavizar este movimiento con una interpolación
flotante Si hacemos clic derecho en el gráfico de
eventos de aquí, vamos a
buscar F interp dos Esta es una
interpolación basada en flotación a un cierto valor. Podemos ver aquí algunas
cosas que se dieron. Entonces comenzamos con
nuestro valor actual, que es, como mencioné,
donde estamos ahora. El objetivo es donde queremos
estar para llenarlos directamente. Ya tenemos estos valores y se les nombra en consecuencia. Para que podamos tomar nuestra velocidad actual y dejar caer esto por
aquí en corriente. Entonces vamos a pasar
de nuestra corriente y vamos a alcanzar
nuestra velocidad objetivo. Así que solo arrastramos y
soltamos eso, también. Se puede ver que entonces necesitamos
enchufar el tiempo Delta. Entonces tenemos los segundos
Delta aquí. Voy a seleccionar esa
, presionar control, efectivamente, duplicar con mi
mouse aquí abajo, y podemos enchufar esto
en los segundos Delta. El tiempo Delta aquí mantiene la tasa de fotogramas de interpolación E independiente tipo de
con algunas peculiares Pero nuevamente,
volveremos a eso cuando veamos ese problema, y lo
abordaremos más adelante. Y luego finalmente,
tenemos la interp esto es controlar la
rapidez con la que aceleramos hacia la velocidad objetivo
que se nos da Los valores más altos aquí significan
una respuesta más rápida. Valores más bajos significan que se sentirá
un poco más flotante. Voy a comenzar con
el valor de cuatro, que ha funcionado perfectamente
bien en las pruebas. Y entonces, claro,
no queremos ningún número mágico en nuestro código. Entonces
vamos a tirar de aquí. Vamos a promover
esto a una variable. Le voy a dar a este
un nombre sensato algo así como movimiento
interpretar velocidad. Entonces ahora tenemos los
cuatro F interp dos. El resultado de esta
interpolación se
convertirá en nuestro nuevo valor de velocidad
actual Muy importante aquí.
Vamos a necesitar darnos un
poco más de espacio. Voy a quitar la
cadena de impresión por aquí. Ya no vamos a
necesitar eso, y vamos a pasar esto justo
por aquí por nueve. Vamos a evitar
cualquier código de espagueti, y vamos a mantener
las cosas ordenadas a medida que avanzamos. Esto tendrá que
calcularse aquí arriba. Necesitamos nuestra velocidad objetivo primero, así que el valor que sabemos que
vamos a estar pegando. Y también tenemos que establecer ahora. Entonces usando un nodo
como este configurando el valor de nuestra velocidad actual. Algo que no creo haber cubierto todavía es que tenemos formas
alternativas de llevar nuestras
variables a la gráfica. Si mantenemos pulsada la tecla de control
en el teclado y agarramos, por ejemplo, la velocidad
actual y arrastramos esta a la gráfica,
esto proporciona un nodo. Este nodo delgado se
llama getter. Básicamente aporta el
valor. Podemos leer esto. Es conseguir el valor para nosotros. Si sostenemos Alt y volvemos a hacer
lo mismo, agarramos la velocidad actual y arrastramos esta a la gráfica,
pero ahora sosteniendo Alt. Esto es proporcionar
algo llamado setter. Entonces esto
es lo contrario. Esto nos permite escribir
al valor que tenemos aquí. Entonces esto nos
permite leer el valor. Esto nos permite
escribir al valor. Queremos mantener la versión escribible aquí
a la velocidad actual, así que me voy a
deshacer del getter Y aquí queremos tomar
nuestro valor. Como acabo de decir, así será rastreada nuestra
velocidad actual. Así que vamos a enchufar
esto a la velocidad actual, y solo tenemos que
asegurarnos de que conectamos los pines de ejecución justo aquí. Y solo para tratar de concluir esto y asegurar que esto tenga sentido, porque agradezco que esto pueda parecer un
poco confuso. Necesitamos saber, en primer lugar
, qué estamos presionando y a qué velocidad
estamos tratando de llegar, razón por la
cual actualmente estamos fijando primero la velocidad objetivo. Entonces, si imaginamos que estamos calculando esto desde
el primer fotograma, ya
sabemos ahora que nuestra velocidad
objetivo es el movimiento multiplicado por o más exactamente nuestra
dirección por la velocidad de movimiento, multiplicada por Delta, así que
obtendremos un valor de 500 multiplicado por lo que sea que nuestro pequeño valor esté
basado en la velocidad de fotogramas. Entonces tenemos un
objetivo claro que alcanzar. La primera vez que
ejecutemos esto, obviamente, velocidad
actual
probablemente será cero. Entonces vamos a pasar de
nuestra velocidad actual de cero, así que no nos vamos a mover
en absoluto a
digamos 100 unidades de movimiento para
proporcionar un buen número claro. Vamos a tomar en cuenta el
tiempo de Dw nuevamente para mantener este marco
independiente, algo así como,
y tenemos nuestra velocidad de movimiento,
la velocidad de
movimiento de intercalación para proporcionar diferentes niveles Entonces el siguiente fotograma, obviamente, la velocidad
actual
se habría calculado en base
a esto para ser un poco mayor. Entonces vamos a pasar de
esa velocidad un poco más alta. Digamos solo dos o tres, y luego vamos a pasar
de ese valor de dos o tres, aún tratando de llegar a esas 100 unidades de velocidad a las que
necesitamos llegar. Y vamos a estar haciendo
esto continuamente a lo largo del tiempo, lo que proporcionará
ese alisado. Entonces, lo último es que no queremos usar la
velocidad objetivo directamente. Eso es solo nuestro
queremos usar cualquiera que sea la
velocidad en este momento. Entonces vamos a eliminar esta. Vamos a agarrar
nuestra velocidad actual. Y nuevamente, solo
vamos a
arrastrar esto a nuestro pin verde aquí, y eso automáticamente lo
conectará para nosotros. Y eso es todo. Eso está
prácticamente listo para comenzar y probar el movimiento suave. Así pueden ver aquí, mientras me estoy
moviendo hacia atrás y hacia adelante, el momento en que suelte la llave, tenemos un
poco de alisado sucediendo a medida que bajamos
a ninguna velocidad en absoluto. Entonces tenemos algo de desaceleración y aceleración entrando aquí Ahora porque
lo estamos haciendo con el tiempo, el movimiento puede sentirse un
poco más lento Entonces, una de las otras cosas realmente
útiles, desde promocionar nuestros números mágicos hasta variables es que solo puedo agarrar
la velocidad de movimiento. Tal vez pueda duplicar esto, así que
pondremos esto en mil porque se siente
un poco lento. No necesitaba
pasar por el código. No necesitaba averiguar
dónde estaba pasando esto. Esto está muy bien llamado,
así que sé que esto es controlar la velocidad a la
que me voy a mover. Puedo presionar play.
Puedo probar esto de nuevo, y tenemos un avión de
sentimiento completamente diferente en marcha. Entonces esto se está sintiendo mucho
mejor. Esto realmente exagera un poco más la
aceleración y desaceleración Y nuevamente, todo eso se hizo cambiando una propiedad completa
del
sistema de movimiento general simplemente agarrando la velocidad de movimiento
y tapando esto aquí Por supuesto, hemos añadido
el movimiento suave, razón por la
cual necesitábamos
hacer esa enmienda. Si quisieras jugar con cosas podrías
hacer algo similar, agarrar la
velocidad de interpolación de movimiento y ver si querías que eso tomara más o menos tiempo para llegar
a ese valor final,
esa velocidad actual a la
que estamos apuntando Entonces estos son solo una especie
de ajustes variables aquí basados en cómo quieres que
tu juego, tu avión se llene Un principio de diseño que
escuché muy temprano y que
siempre se me ha pegado es siempre tratar de exagerar la variable Entonces, si no estás seguro de lo
que están haciendo, o
no estás seguro de si
querías que fuera mucho más rápido o mucho más lento es el doble o el triple del
valor que estás trabajando. Podría establecer este 4-12 porque primero quieres
golpear un extremo,
averigua si eso funciona,
si es demasiado alto,
demasiado bajo, y luego
refinarlo en el medio Entonces puedo ver que casi se
siente bastante ágil otra vez. Hay algo de aceleración y desaceleración, pero no mucho Entonces, lo que podría querer
hacer es tonificar esto de nuevo a seis porque definitivamente 12
es demasiado alto, y aquí nos estamos sintiendo un
poco mejor. Ahora, como dije, para mí,
me gusta bastante la sensación
de esto a las cuatro, pero solo un principio general de
diseño es llevar el valor
a un extremo, doble, triple, medio algo, cualquiera que sea el caso, y rápidamente
podrás afinar
en lo que querías que se sintiera tu
propiedad. Para mis propósitos, voy a mantener la velocidad de
interp de movimiento en cuatro, y podemos pasar
a la siguiente función Entonces ahora sumando la rotación
bancaria. Esto en realidad va
a ser muy sencillo. Es esencialmente una repetición
de lo que acabamos hacer con algunas funciones ligeramente
diferentes. Esencialmente, a medida que nos
movemos de lado a lado, queremos que el avión se incline
un poco para que se sienta un poco más
como un avión real. Un rápido repaso
en el eje aquí. No creo que haya tocado
esto en otoño todavía. Voy a agarrar una malla
estática muy rápido. No necesito seguirme. Esto es sólo para visalizar
lo que estamos haciendo. Voy a presionar E dentro
del mirador para
entrar en modo de rotación, y podemos ver nuestros ejes aquí. Entonces ya he mencionado antes, tenemos esta transformación,
la ubicación, rotación y escala que
conforma la posición en el espacio mundial para nuestro actor.
Las ubicaciones muy sencillas. Tenemos X, Y y Z, que
es hacia adelante, hacia los lados,
y hacia arriba y hacia abajo. Rotación, es
relativamente simple. Lo mismo.
Tenemos tres colores. Tenemos el rojo, el verde y el azul, entonces la
X, la Y y la z,
pero si pasamos el cursor sobre
estos, podemos ver
aquí que en realidad tienen
sus propios nombres únicos. pero si pasamos el cursor sobre
estos, podemos ver aquí que en realidad tienen
sus propios nombres únicos Tenemos el rollo, el
pitch, y el le. Ahora bien, esto no
importa demasiado, pero si alguna vez intentas
modificar estas características, agrega tu propia funcionalidad,
y ni siquiera estás seguro de qué ejes debería estar
girando o algo así Solo quería
mostrarte un ligero visual aquí que en
realidad es muy sencillo de averiguar. Entonces, en este caso,
quiero que el avión se incline en una dirección
basada en cómo se mueve. Entonces, si intento solo
algunas cosas al azar, si pruebo la verde
y veo qué hace esto, podemos agarrar el
valor verde por aquí y simplemente deslizaré esto
para que esto gire. Y podemos ver que esto nos
da una especie de rotación arriba y abajo
del avión aquí. Esto probablemente sería bueno si estás
avanzando y retrocediendo. Tal vez podrías agregar un
poco de esto para exagerar el movimiento de
ir hacia adelante y hacia atrás Si agarro la z y
hago lo mismo, solo agarrando
los que conozco no funcionan para empezar, saquen
estos del camino Podemos ver que esto gira
alrededor de los ejes del avión. Así que de nuevo, no va
a ser muy útil a menos que estemos haciendo cuatro
tonos o algo así. Entonces el que
queremos usar
va a ser el eje X aquí. Entonces a medida que nos
movemos de
izquierda a derecha, vamos
a querer inclinarnos ligeramente y rodar así, en función de
la dirección que vamos. Entonces así es como podrías entrar
muy fácilmente, jugar con los
diferentes widgets aquí, rotar en cierta
dirección y ver a
qué eje querías
aplicar la rotación. Como dije, eso fue sólo
para demostración visual. Eliminaré la malla estática. Volveremos a la base de la sartén. Mueva esto un
poco y podremos volver a seguir adelante con la rotación. Para la rotación aquí, tenemos un par de
funciones muy similares que ya hemos usado. Vamos a sacar de
la ubicación del actor del set, y probablemente puedas adivinar que vamos a
buscar algo llamado rotación de actores de set. Eso es algo muy parecido,
actualizaciones a la rotación, y esto va a ser
cada fotograma porque
lo estamos lanzando en el eventi Ahora, vamos a querer usar una función muy similar también, queremos usar una
interpolación para Ahora para la rotación, no
usamos la interpretación F, vamos a usar
algo llamado interpretar dos. Así que estamos haciendo clic
aquí. Busca interp dos, y para rotación, y
tomaremos este justo aquí La otra razón por la que lo estamos
haciendo de esta manera, potencialmente podríamos agarrar solo un solo
valor flotante porque solo
queremos
hacer esto en la X. Podríamos hacer algo muy similar aquí y usar una interpretación F. Ahora, mantengo esto
en línea de paridad para
alinearse con el proyecto de ejemplos de
contenido de Unreal Engine Entonces así es exactamente
como lo han hecho. Han utilizado una interpretación F para la ubicación y una
interpretación R para la rotación. Entonces quería volver a mostrar,
el código que existe y cómo podemos arreglarlo por si
acaso surgieran preguntas, por qué estamos haciendo esto de manera
ligeramente diferente. Pero lo principal aquí, esto es muy útil
aún porque podemos ver que obtenemos las mismas propiedades que
necesitamos para alimentarnos. Tenemos una rotación actual, entonces donde estamos en este momento, tenemos una rotación objetivo hacia
donde queremos rotar. Y tenemos el tiempo Delta para hacer que esta velocidad de
fotogramas sea independiente, nuevamente, en especie de. Y entonces tenemos
la velocidad de interp, que es el alisado entre Así que la corriente es
realmente muy simple. Tenemos otro ayudante
muy similar a lo que hemos usado antes. Si hacemos clic derecho
en el gráfico de eventos y buscamos Obtener rotación de
actor. Esto proporcionará, al igual que la ubicación del
actor get que hemos utilizado, la rotación del actor
en este fotograma dado. El objetivo es una especie de número arbitrario
aleatorio, y digo que solo porque
todo el ejemplo épico ha hecho es que se ha tomado
la velocidad actual, así que voy a controlar arrastrar la velocidad
actual a la gráfica para obtener la velocidad actual que estamos moviendo y multiplicarla
por un valor. Entonces vamos a tirar de
aquí, seleccionar multiplicar. Y creo que el suyo era
algo así como 1.5. Entonces vamos a tomar
cualquier velocidad que estemos moviendo, ya sea un valor positivo
o negativo, multiplicar eso por 1.5. Y ese será el
objetivo hacia el que queremos rotar sobre el eje x. Algo que
quería presentarles. Ya lo hemos visto aquí. El uso del pin de
estructura dividida para tomar nuestro vector de tres puntos en sus puntos flotantes individuales. El rotador es exactamente el mismo. Podríamos simplemente hacer clic derecho en pin de estructura
dividida y tomar
esto en las X Y y Z. Esto puede ser algo
desordenado cuando
tienes tantos
flotadores diferentes Entonces, una cosa que
puede ser bastante útil, y más que nada, esto es realmente solo
por orden de código es que sacaremos
del objetivo aquí y
vamos a buscar algo llamado make Queremos esta
opción de abajo justo aquí, y hace tal como
su nombre indica. Es hacer un rotador a partir de
una X Y y Z individuales. Mantiene estos dos flotadores por sí mismos,
tan fáciles
de leer, y nos permite simplemente enchufar
nuestro valor aquí a la X, solo una manera diferente de llegar a la misma meta que
hemos hecho antes Ninguno de ellos es
menos o más eficiente, y en realidad puede reducirse a lo que es más legible
en cierta instancia. Esto no diría que
es demasiado ilegible, porque es sólo un vector que hemos dividido. ¿Dónde está esto? Ya hay
un montón de flotadores, y dividir más
flotadores en eso solo se volvió un
poco Como hemos visto
anteriormente, queremos que nuestro resultado final sea la
nueva rotación que tenemos aquí, así que voy a tomar
esa interpolación y enchufar eso
al nuevo resultado Y eso solo nos deja con
un par de cosas que llenar. Entonces queremos nuestro tiempo Delta, así que voy a venir aquí, tomar un get world delta segundos, presionar Control ID por aquí para
duplicar eso y enchufar eso. Y entonces solo necesitamos
nuestra velocidad de interpolación. Entonces, de nuevo, eso
se está moviendo en el medio. Estoy probando, creo, un valor de alrededor de unas diez
funcionó muy bien, y este es uno de esos valores
que solo volverás y ajustarás para que la rotación se
sienta exactamente como quieres Nuevamente, no hay números mágicos, así que sacaremos de aquí,
promoveremos una variable. Dale a éste el nombre de velocidad de interp de
rotación. Y con eso estamos
prácticamente listos para ir
a ponernos a prueba esto. A pesar de que una cosa
simplemente me llamó la atención. Esto esencialmente está actuando como un factor de inclinación o fuerza de inclinación, en lugar de tener este número
mágico también vamos tirar de aquí,
remoto a variable. Yo solo iré con el factor Tilt, y eso ahora
está listo para probar. Entonces podemos golpear
compilar, presionar play, y podemos ver que sí
tenemos algo bancario. Ahora sí tenemos otro
tema, que olvidé por completo
iba a pasar. Entonces vamos a arreglar eso en un momento, pero la banca, la
rotación de hecho está funcionando. Entonces ahora que potencialmente
le he dado a todos el mareo por movimiento, la cámara está
bancando con el avión. Eso lo hemos confirmado,
por lo menos. La razón por la que ocurren
problemas con la cámara es la cámara hereda la
rotación del padre Realmente hemos visto esto
en la jerarquía. Las cámaras unidas
al resorte um, el brazo de resorte a
la malla estática, y estas están siguiendo toda
la rotación y ubicación aplicada al puré estático.
Esto es realmente sencillo de arreglar. Y una de las razones por las que
quería usar el resorte um, simplemente
me olvidé de marcar esto
con el resorte um seleccionado en el panel de detalles
al lado derecho, este componente único nos
brinda una solución. Epic sabía que este tipo de cosas
serían un problema potencial. Así que aquí nos han dado
algunas casillas de verificación. Podemos desmarcar el
tono heredado, U y rotación. Recuerda los nombres para las
X Y y Z de rotación. Entonces, si los desmarcamos,
esto básicamente es decir, no permitas que el brazo de
resorte siga la rotación del componente
padre Y debido a que las cámaras un
niño del brazo de resorte, eso también se aplicará
al componente infantil de
la cámara. Entonces si golpeamos
compilar,
pulsamos play, podemos entrar y podemos ver que
podemos ver muy bien la rotación. Y no estamos consiguiendo ese movimiento de
cámara
potencialmente nauseabundo que
tuvimos hace apenas un momento Otra cosa que acabo de darme cuenta con el resorte um seleccionado, todavía
tenía esto marcado,
también. Hacer prueba de colisión. Si has tenido algún problema
donde la cámara parece estar moviéndose o siendo
metida en el
suelo o algo así, eso es potencialmente
porque tienes la prueba de colisión ocurriendo ¿Qué está pasando aquí
solo para visualizar esto? Si se detecta algo entre la cámara y
lo que está mirando aquí, así que algo con
colisión en ella
en este punto en
el brazo de resorte rojo, donde está
ocurriendo la
prueba de colisión. Si algo pasa por
eso, ahí es donde la
cámara va a intentar moverse automáticamente fuera
del camino o agacharse detrás de algo
para evitar esa colisión. Realmente útil para cosas como juegos en
tercera persona donde es posible que tengas la cámara
rozando contra una pared, y se acercará un
poco más
al jugador. Entonces esa es una característica
bastante agradable. En un juego como un shoot up como estamos creando, sin embargo, podemos tener problemas
donde la cámara se vea nerviosa si proyectiles o rastros y cosas
así se están pasando a través de la
cámara, la línea de la Y de nuevo, esto es
algo más que se ve en proyectos
para principiantes
donde la cámara está poco retorcida o falla. Probablemente sea
porque tienen algún tipo de prueba de colisión ocurriendo entre la cámara
y lo que estás viendo. Entonces vamos a apagar esto. No vamos a necesitar eso para
este tipo de juegos. Con eso hecho, la
cámara se mantiene nivelada. El avión bancos de forma natural,
se siente mucho mejor. Entonces ahora finalmente
llegamos a ver dónde se rompe un poco el ejemplo de
Epic. Solo quería mencionar que esto no
se está arrojando sombra al proyecto de ejemplo o
Epic ni nada por el estilo. Simplemente estoy mencionando
esto porque me doy cuenta de que esta es una oportunidad de
enseñanza perfecta, algo que está
tan ampliamente cubierto utilizado por tantos canales
tutoriales diferentes, yo incluido,
vas a ver código que está roto incluso de fuentes
oficiales. Entonces, saber eso y poder
estar
atento a eso va a
ser súper valioso. Entonces el problema que estamos teniendo
en este momento es si
vamos a jugar modo. A alta velocidad de fotogramas, voy a volver a poner mis estadísticas de velocidad de fotogramas Entonces 120 FPS, esto se
ve un poco bien. Sin embargo, si vuelvo
a bajar esto a 30 FPS, enfócate en cuánto se está aplicando la
rotación. Entonces nuevamente, puedes ver que este no es solo un caso de uno de
ellos luciendo un poco más suave y uno de
ellos luciendo un
poco menos suave debido
a la velocidad de fotogramas. Esto es literalmente una
diferencia en la mecánica, mismo código, misma entrada, rotación
completamente diferente. A 30 FPS, casi estamos rotando el ala
por el suelo, dependiendo de qué tan lejos esté
el avión del piso. Y esta es una de esas cosas. Ni siquiera es romper la jugabilidad. Pero si has configurado un
sistema para que se vea súper suave, y se ve exactamente como
quieres que parezca
el más atractivo para
el jugador pero
luego alguien en un sistema de especificaciones más bajas juega y es recibido con
el segundo resultado Obviamente te vas
a decepcionar, no
van a conseguir la
experiencia que pretendiste. Y por eso es
realmente importante enfocarse en esto. Y esto es lo que
quise decir con este error existe en ejemplos de
contenido oficial de Epics, mismo código, mismo problema, enviado en la documentación real Y es por eso que confiar ciegamente
incluso en ejemplos oficiales, incluso la
documentación de la primera piedad puede tener errores Así que siempre pruebe casos de borde y busque
cosas como esta. Eso es lo que realmente estoy
tratando de cruzar. Tocado anteriormente,
va a ser un poco demasiado largo
para este tema. Entonces esto es algo
que vamos a arreglar un poco más tarde, y estaremos reconstruyendo el sistema de
movimiento por completo Pero por ahora, sólo vamos a reconocer que el error existe. Esto todavía está perfectamente
bien para trabajar con él. Es una base perfecta
para construir más. Volveremos y
vamos a reelaborar el sistema de movimiento por completo, y arreglaremos todos los
errores cuando vayamos a través Y ahora que hemos visto
la rentabilidad por no usar números
mágicos, tenemos
nuestra velocidad de movimiento,
controlando qué tan rápido puedes ir, la velocidad de interp de
movimiento, que es rapidez con la que
alcanzas esa velocidad, nuestro factor de inclinación en cuanto bancos el avión a las
diferentes velocidades, y luego incluso la velocidad de
interpolación de rotación, también, que es lo rápido que llegamos
a esos valores de inclinación. Todo esto es sintonizable
sin tocar la lógica. Si quieres una acción
arcade ágil, podemos aumentar
la velocidad de interp Si quieres un
espacio lento y flotante, puedes bajarlo. La sensación del juego es
entonces todo viniendo de los números. Entonces
podemos dejar eso ahí. Tenemos un movimiento suave, algo satisfactorio
con algunos buenos bancos. Y sí, está el error de velocidad de fotogramas al
que vamos a volver, pero al menos
lo sabemos, y lo arreglaremos más tarde. A continuación, podemos actualizar
al sistema de entrada mejorado. Este es el reemplazo
moderno de Unreal para el sistema de entrada heredado
que estamos usando actualmente Si quisieras
experimentar, como ya he dicho, ahora
tienes todos esos
valores listos para jugar. Intenta agregar un poco más de
tono a la rotación y potencialmente agregarlo
con los movimientos hacia adelante. El mismo patrón, eje
diferente
tanto para la rotación
como para el movimiento
si todavía solo tienes esto
yendo en una dirección.
8. 07: Mejorada entrada: Configuración de movimiento y trabajo
a un punto comprobable. Recuerde que el
sistema de entrada heredado que hemos estado usando eso como he
mencionado, está en desuso. La entrada mejorada es
el reemplazo moderno. Hay un poco
más de configuración inicial, pero es significativamente
más flexible Obtenemos cosas como esquemas de control
intercambiables en caliente, zonas muertas
integradas, en caliente, zonas muertas
integradas revinculación de tiempo de
ejecución, todas las
cosas que tendrías que codificar tú mismo usando
el Entonces comencemos a migrar de nuevo. La primera diferencia principal es que
el sistema de entrada mejorado en realidad tiene su
propio conjunto de clases. Así que navega de nuevo a
la carpeta de planos, haz clic
derecho aquí o presiona Control Shift en n para
crear una nueva carpeta, y llamaremos a esta entrada La entrada mejorada divide
las cosas en dos partes. Tenemos nuestras acciones de entrada, que define lo que puede suceder cosas como disparar, mover, reiniciar. Y luego tenemos algo
llamado contextos de mapeo de entrada, que definen qué botones activan las acciones
mencionadas anteriormente, proporcionando una separación
de preocupaciones. Y la razón por la que esta
separación resulta útil, esto permite que los
esquemas de control cambien sin necesidad de volver a cablear toda
la lógica del juego En código, simplemente podemos llamar
al sistema de entrada para cambiar
entre los controles de menú, controles de
juego,
controles del vehículo, cualquiera que sea. Pueden compartir las
mismas asignaciones de acción con los botones específicos, pero pueden ejecutarse bajo
diferentes contextos Una línea de código, y
tenemos todo cambiado. Dentro de la carpeta de entrada,
vamos a hacer clic derecho, y voy a ir a la categoría
Entrada justo aquí. Podemos ver que tenemos la sección
de acción de entrada, así que crearemos una de estas. Dale a esto el nombre de
IA Underscore Fire. Seleccionaremos este
Control mamario , de hecho, para duplicar. Necesitamos dos más de estos, así que
duplicaremos esto dos veces, y llamaremos a un movimiento de subrayado de
IA y al otro reinicio de
subrayado de IA A continuación, queremos abrir nuestra clase de mudanza de guiones bajos de
IA. Haremos doble clic para abrir
esto. Y lo principal que queremos mirar es justo aquí, tenemos el tipo de valor. Por defecto, esto está configurado en booleano
digital o ball, y esto es muy similar
a lo que configuramos en la configuración del proyecto con
las asignaciones de acción Tenemos que eliminar estos de todos modos. Vamos a volver a
Edit, ajustes del proyecto. Volveremos a bajar a la entrada. Y solo por contexto, el booleano
digital que ya sea on o off hubiera sido si creáramos un
mapeo de acciones aquí Por ejemplo, podríamos haber
creado algo llamado fuego, atado esto a un botón, y haber tenido este disparo cada vez que
queríamos llamar proyectil Mientras estemos aquí, también me
voy a deshacer de
las asignaciones de acción solo para que no
nos quede nada Esto también causará un
pequeño error en nuestro código, pero esto hará que
las cosas sean fáciles de encontrar y perfeccionar cuando estemos
haciendo nuestra actualización de código. Así que simplemente presionaremos Eliminar para deshacernos de nuestras
asignaciones de acceso, también Nuevamente, eso
ahorra automáticamente podemos cerrar esto y volver
al subrayado de IA Tanto nuestras acciones de entrada de fuego como de
reinicio. Estos dos necesitan de los bulliones
digitales, razón por la
cual no
he abierto estos Están perfectamente
bien por defecto. O estamos presionando el botón de
disparo o no lo estamos. Es lo mismo para
el botón de reinicio. Para el movimiento, sin embargo,
queremos bajar esto, y queremos usar
este eje un flotador D, esencialmente proporcionando
lo mismo que un mapeo de ejes, proporcionando un valor
de uno negativo a uno positivo o cero si
no se está presionando nada. Entonces ese es el único cambio
que necesitamos hacer dentro de nuestra acción de entrada. Podemos presionar Guardar.
Podemos cerrar esta, y podemos volver
a nuestra carpeta de entrada. Entonces ahora queremos llegar
a nuestro contexto de mapeo. Esto va a ser qué
botones disparan, qué acciones. Si hacemos clic derecho en
la carpeta aquí, vamos a volver
a la sección de entrada, y esta vez crearemos
un contexto de mapeo de entrada. La convención de nomenclatura
va a ser IMC. Subrayar, y luego el nombre de la cosa de la que esto
será responsable Solo tendremos un tipo de entrada en este proyecto más
sencillo. Entonces llamaré a este
principal para nuestro aporte principal. Haga doble clic para abrir esto, y podemos ver la forma en que funciona. Ahora bien, este tipo de
está representando la configuración del proyecto que
estábamos editando antes. En la parte superior
izquierda, queremos hacer clic en este botón más
y desplegarlo hacia abajo. Necesitamos hacer que cada una de
estas entradas sea única, razón por la
cual esto se está clasificando
actualmente, por lo que no podemos agregar
más asignaciones hasta que tengamos algunas
propiedades únicas en esta Si bajamos esto, podemos ponerle esto a Ia subrayado fuego Y luego si bajamos
la categoría justo aquí,
aquí es donde podemos comenzar a hacer el mismo tipo de mapeo
que vimos antes. Entonces, si quería que la funcionalidad
de
fuego se llamara en la Barra espaciadora, puedo presionar el botón aquí, presionar Barra espaciadora, y
tenemos una unión Si también quería que reaccionara
al clic izquierdo del mouse, puedo hacer click aquí y
hacer click izquierdo del mouse. También haré lo mismo una última vez para el gamepad Voy a presionar de
nuevo el botón y presionar el botón de la cara
inferior, el botón A en el gamepad,
y tenemos ese límite Así que ahora tenemos tres botones diferentes o
tres entradas diferentes, que pueden llamar a la función fire cuando
lleguemos a implementar eso. Queremos volver a hacer lo
mismo para nuestras otras acciones de entrada. Entonces presionaremos el plus. vincular algo
al reinicio. Esto va a ser agradable y sencillo,
así que voy a hacer esto primero. Lo mismo otra vez, podríamos tener potencialmente R para reiniciar, y tal vez voy a añadir
uno para el gamepad,
también, y voy a hacer de
este el botón de inicio Entonces ese es el botón especial de la cara
derecha. Solo para anotar, estoy usando el
turno a la izquierda y presionando las flechas, y eso colapsará
todo de nuevo hacia arriba. Si quieres algunos
atajos aquí, mantén presionada la tecla Mayús, pulsa el botón izquierdo,
y podrás ver que despliega cada elemento
individual Así que una manera rápida y agradable de tener
las cosas ya sea desplegadas o colapsadas ordenadamente cuando estamos pasando por estas
diferentes asignaciones El mapeo final que quería crear va a
ser el movimiento. Entonces agregaremos uno más
de estos. Vamos a unir esto a I Un movimiento de subrayado Vamos a bajar esto. Y nuevamente, vamos a querer
agregar algunas claves aquí. Si empezamos de la misma
manera que lo hicimos anteriormente, vamos a hacer clic en
el botón aquí, presionar D para tener un movimiento de derecha
predeterminado, y luego hacer clic en
otro, presionar A para obtener nuestro movimiento a la izquierda. Ahora bien, aquí es donde las cosas
cambian un poco, y esto es exclusivo de la configuración de entrada
mejorada. A pesar de que tenemos estos establecidos
como un eje de una dirección, un valor de punto flotante para
nuestro movimiento de subrayado IA, se
puede ver que en realidad
no tenemos ningún valor flotante para cambiar
aquí para invertir la A para
hacer que las cosas se muevan hacia la izquierda En cambio, aquí es donde
entran los modificadores con el sistema de entrada
mejorado Entonces, si hacemos clic en el
signo más en el modificador, puede desplegarlo hacia abajo,
y se puede ver un montón de
funcionalidades útiles pre incorporadas. Podemos agregar cosas como
zonas muertas para sticks analógicos, escalares
automáticos y
cosas así,
que se pueden aplicar
a la entrada El Único que queremos está justo aquí, así que queremos negar el valor Se va a establecer por defecto a
uno. Si negamos eso Esto es lo que
nos da uno negativo. Tan agradable y sencillo de usar solo un enfoque ligeramente
diferente. Voy a hacer lo
mismo otra vez. Sólo voy a añadir dos más. Uno para la flecha derecha.
Uno para la flecha izquierda. Vamos a añadir ese mismo modificador
en la flecha izquierda. Y luego finalmente, voy a
sumar una entrada final por jugada, y volveré a mover el stick
analógico izquierdo. Ahora, aquí
pasa lo mismo. No necesitamos agregar
aquí los negados porque Unreal sabe que un stick analógico tiene un potencial izquierdo y otro derecho en el eje x, automáticamente devolverá uno
negativo cuando
empuje esto hacia la Eso es todo listo y
listo para entrar dentro del movimiento de
subrayado de IMC Entonces le
pegaremos a Save y podremos cerrar éste. No necesitaremos volver a editar
nada ahí dentro. Entonces, esto puede haber parecido
un poco tedioso. Como he mencionado,
tiene un poco
más de una configuración inicial,
pero solo necesita
configurarlo más de una configuración inicial, una vez, y estos activos
se pueden copiar a otros
dos proyectos muy fácilmente si encuentra que está
usando patrones similares Y lo principal es
que en proyectos más grandes, esto comenzará a ahorrarle
mucho más tiempo ya que es mucho más flexible que
el sistema de entrada heredado. Ahora queremos volver a saltar a nuestra clase basada
en el porno. Este es otro en el
que realmente necesito que te concentres porque
este es el paso que a menudo todo el mundo olvida con el sistema de entrada mejorado El contexto de mapeo existe, pero nada lo está
usando todavía. Y a diferencia del sistema de entrada
heredado, nuestro
sistema de entrada mejorado debe vincularse explícitamente a una clase. Podemos hacer esto muy
fácilmente, y este es el paso que
a menudo todo el mundo se olvida de hacer Desde el inicio de la reproducción,
podemos hacer clic derecho
en algún lugar cerca de aquí, y vamos a
buscar el controlador G player
construido en función. El controlador del reproductor es
lo que está recibiendo la entrada directamente de nuestros dispositivos
físicos, alimentando eso en irreal
y decidiendo cómo
administrar eso a través de la sartén
que pueda estar controlando Esto también puede aplicarse a la IA, por lo que esta sería
la entrada que la IA está dando al peón de IA
controlada Desde el controlador,
vamos a sacar del pin aquí y
vamos a buscar algo llamado subsistema de reproductor local de
entrada mejorada G. Nombre realmente ágil
ahí. éste justo aquí
con la F rosa, así que esto está indicando que
esta es una función. Simplemente va a estar
devolviendo un cierto valor, que es esa entrada mejorada, subsistema jugador
local. Y a partir de aquí, esta es la
función que realmente necesitamos. Vamos a llamar al contexto de mapeo de
anuncios. Agradable y claro. Podemos ver exactamente qué
va a hacer esto. Esto será agregar un contexto de mapeo
específico, el que
acabamos de crear para vincularnos a la clase en la
que nos encontramos actualmente. Así que nos aseguraremos de que conectemos estos con el pin de ejecución, bajemos esto aquí abajo el contexto de mapeo
que queremos usar, y solo tenemos el que
tenemos IMC subrayado Man La forma en que puedes
estar usando esto, aunque, como he mencionado, es que puedes tener un controlador específico más
avanzado, que está rastreando lo que podrías estar haciendo durante el juego
a través de tu juego. Durante los momentos de juego, esto
sería asegurarse de que el contexto de mapeo esté
usando el IMC de juego, y es posible que tengas algo así
como un menú principal IMC, también, para que
puedas navegar con el teclado en tu menú principal Cuando el jugador presiona
pausa o escape, el controlador del jugador
sería responsable de cambiar el contexto de mapeo para pasar
del juego al menú. Y aquí es donde esto se vuelve
realmente, muy flexible. Como he mencionado, un
poco exagerado para el tipo de proyecto
que estamos creando, pero es útil saberlo,
y realmente puedes construir sobre esto en
cualquiera de tus proyectos Y lo que realmente
quiero
volver a conducir a casa , este paso es crítico. He visto a tanta gente
configurar todo a la perfección. Tienen todos
sus aportes configurados. Toda la
funcionalidad de movimiento estaría funcionando correctamente. Presionan play y
no pasa nada. Te pasas una hora depurando, y luego finalmente te
das cuenta de que
olvidaste vincular el contexto de
mapeo Entonces no seas esa persona.
Entonces, lo último que queremos hacer aquí es reemplazar el
insumo heredado que teníamos. Si presionamos Compilar, porque hemos eliminado la entrada heredada
de la configuración del proyecto, esto es lo
que quise decir que en realidad obtendremos un error
o advertencia muy útil aquí abajo. Ahora nos dice
que se trata de hacer
referencia a algo que
es un eje desconocido. Si presionamos aquí este texto
subrayado, eso realmente
nos llevará directamente a donde
ocurren esos problemas. Tan agradable y fácil. Y todo lo que tenemos que hacer
es agarrar este nodo que ya no existe en
la configuración del proyecto. Presiona eliminar. Podemos hacer clic
derecho aquí, y queremos buscar
nuestro movimiento de subrayado IA Lo mismo, muy similar a la entrada heredada.
Obtenemos dos opciones. Obtenemos los eventos de acción, que crearían un nodo
como este donde tenemos un pin de ejecución y
la variable float, o podemos usar la acción axis
aquí, el valor de acción. Lo mismo que
el valor del eje que teníamos anteriormente. Entonces
seleccionaremos esta. Esto nos dará solo
el valor de punto flotante, y podemos enchufarlo de nuevo. Entonces el código en sí es
prácticamente idéntico. Nada ha cambiado
realmente. Es solo la forma en que
vamos a configurar la entrada mejorada para alimentarnos
esa información. Eso hace que la transición sea
relativamente fluida, y toda nuestra lógica de movimiento
seguirá siendo exactamente la misma. Si presionamos play,
podemos probarlo. Entonces A y D están haciendo
lo mismo, izquierda y derecha, y este
es el stick analógico nuevamente. Entonces todos trabajando exactamente
como esperaríamos. Todo lo que hemos tenido que hacer es
actualizar la capa de entrada debajo de nuestro
código central. Y eso es todo. Ahora tenemos el sistema de entrada
mejorado en nuestro proyecto, completamente configurado, que tomó un poco
más que la configuración de entrada heredada, pero es mucho más flexible
y definitivamente vale la pena. adelante usaremos más funciones,
como
los
eventos de incendio para disparar, activar
entradas sostenidas en un bucle y luego también el botón de reinicio de
disparo único El siguiente tema que
queremos abordar, aunque va a ser
nuestros límites de juego. Ahora mismo, podemos
volar hacia la afinidad, lo cual no es realmente genial
para ningún tiroteo. Y, por supuesto, si
quisieras experimentar, puedes intentar agregar
cosas como modificadores de zona
muerta para
la entrada del thumbstick, ver cómo podrían funcionar los temporizadores o pulsos usando la funcionalidad
incorporada No se requiere código y solo
algo con lo que jugar.
9. 08 - Límites: Nuevo sistema de entrada, todavía tenemos este problema donde
actualmente podemos volar hacia el infinito. Eventualmente, le darías algún tipo de problema de
precisión de punto flotante, pero mucho antes de eso,
el juego se volvería injugable y, lo que
es más importante, bastante aburrido Para este tipo de juegos,
vamos a querer una cámara fija y algunos muros límite,
algunos muros invisibles. La cámara que tenemos actualmente está
unida al peón, y para una toma de ellos, una cámara de nivel
simplemente tendría más sentido Entonces, si volvemos a la base de pan de subrayado
BP, podemos agarrar la selección de control
del brazo de resorte, la cámara, y
simplemente eliminaremos estos Si presionamos play, ahora estamos de
vuelta dentro de la nave, así que tenemos ese problema de
vuelta, pero estamos a
punto de
arreglarlo prácticamente de inmediato. Lo principal es
que ahora estás al tanto del framework de juego y ya sabes por qué estamos
mirando el interior de nuestra nave. Si no, entonces
retrocede algunos temas. Si volvemos
al nivel principal, solo
queremos agregar una cámara. A la parte superior, justo
encima de la ventanilla hay un pequeño cubo,
que es nuestro botón de agregar Si bajamos esto, queremos
buscar la opción cámara. Muchas de las opciones
aquí tienden a mover categorías cada pocas versiones
irreales, por lo que la búsqueda puede ser
un poco más rápida porque la vida es demasiado corta
para estar buscando cámaras Uno que queremos es
nuestro actor de cámara. Esto se dejará
caer directamente al mundo si
seleccionamos esto. La cámara va
a necesitar mirar
dónde
va a desovar el jugador, y ya sabemos de nuevo por
el framework de juego cómo estamos manejando eso y
dónde va a ser eso Así que un buen rápido,
atajo aquí para ti. Si agarras el inicio del jugador, que es donde aparece el
jugador, vamos a
ir al panel de detalles en
el lado derecho, hacer clic
derecho en la propiedad de
ubicación, y podemos copiar la
ubicación real del inicio del jugador Si agarramos la cámara,
haremos lo mismo, pero vamos a hacer
clic derecho aquí y
vamos a pegar la propiedad
que acabamos de proporcionar. Por lo que ahora tenemos la
cámara directamente en el punto de inicio
del jugador. También queremos darle algo de rotación a
esto. Entonces dentro de la ventanilla podemos presionar F para enfocarnos
en la cámara Si quisieras, puedes entrar en modo de
rotación y puedes
usar los widgets justo aquí. Ahora sé por nuestras necesidades, solo
queremos rotar la cámara -90 grados
sobre el eje Y. Entonces voy a hacer esto desde
el panel de detalles, y ahora estamos mirando
directamente al piso. Esto puede estar un
poco demasiado cerca. Entonces lo siguiente que
vamos a querer hacer es mover la cámara hacia
arriba en el eje Z. Entonces nuevamente, si agarramos
el valor Z aquí, colocaré un valor de 2,400 Creo que esto es similar a
lo que teníamos anteriormente. Ya podemos ver que vamos a estar mirando directamente hacia abajo al inicio del jugador y dónde va a desovar el
avión Puede que no se sienta tentado a presionar play y ver qué pasa La razón es sencillamente, ¿y si tuviéramos cinco, siete,
20 cámaras en la escena? ¿Cómo sabría
cuál elegir? Al igual que con las otras reglas
que
estamos estableciendo, queremos tener el control de
esto y configurarlo manualmente. Entonces con el
actor de cámara seleccionado, solo
queremos buscar
en este panel justo aquí, en el panel de detalles,
queremos buscar algo llamado Activación de
Autoplayer Podemos ver que tenemos
esta opción aquí. La activación automática para el jugador está
actualmente establecida para deshabilitar. Si bajamos esto
y seleccionamos al jugador cero, este será el
primer y único jugador en nuestro juego para un jugador. Así que ahora el framework sabe
usar la cámara que
acabamos de seleccionar. Si presionamos play,
podemos ver eso. Tendremos que hacer
algún ajuste para que todo se
centre correctamente, pero ahora estamos buscando
más o menos dónde queremos estar. Entonces con la
colocación de la cámara, vamos a querer que el jugador esté más cerca
de la parte inferior de la pantalla, algo así como
invasores espaciales y nuevamente, recreando
algo la configuración en los ejemplos de contenido de los
que vamos El problema con el
editor y la usabilidad aquí es que el inicio del reproductor no tiene ninguna visualización. Por lo que será un
poco difícil ver dónde va
a desovar
realmente las naves
del jugador y
posicionar la cámara en consecuencia Entonces un truco rápido aquí que
quería introducir, podemos agregar una
esfera o forma temporal, algo así para mostrar por
dónde empieza el jugador es. Si vamos al
botón Agregar aquí arriba, podemos ir a nuestra opción de formas. Sé que todavía tengo
la ubicación almacenada desde el inicio del jugador
antes cuando copié eso. Voy a deshacer la
búsqueda de Autoplayer aquí, clic
derecho y pegar la ubicación del
reproductor de inicio Y yo mirando esta esfera, que está directamente en
el inicio de los jugadores. Si volvemos a agarrar al actor de
cámara, esto nos ha ayudado
porque ahora podemos ver exactamente qué
va a estar viendo la cámara. Presionando F,
volveré a subir para
mirar exactamente a la cámara y no podemos
arrastrar esto a su lugar. Entonces, si llevamos la
cámara hacia adelante o podríamos traer a los
jugadores arrancan hacia adelante, cualquiera de ellos estará
perfectamente bien. Lo principal es que
queremos que el barco
jugador esté más o menos aquí abajo. Entonces esa es una manera agradable y
fácil de poner las cosas en posición
agradable y rápidamente. Si agarro la esfera,
puedo borrar esto. Obviamente, no queremos
que eso se quede en el laboratorio. Se puede presionar play y los jugadores más cerca de donde
queríamos que estuviera. Otro consejo de la cámara
que solo quería
mostrar muy rápido es si
agarramos la cámara de nuevo, mientras estás jugando
alrededor de las cosas. Si no querías que esta ventana de
demostración
se desactivara automáticamente cuando
seleccionas otra cosa, podemos elegir este pequeño icono de
pin aquí abajo, y eso fijará esta
ventana a tu ventana gráfica. Entonces, si necesitabas entrar,
mueve a los jugadores
comienzan a algo alrededor para ver lo que
sucede a través de la
vista de la cámara, otro rápido consejo ahí de que
podamos mantener esto en
pantalla temporalmente. Cuando quieras que esto
desaparezca, solo
podemos presionar el pin nuevamente, y eso se desanclará
de la ventana gráfica Solo un par de cosas
para comenzar a sentirse cómodo
y con las que familiarizarse. Voy a agarrar otra
forma justo aquí. Creo que
lo he mencionado un par de veces, pero si presionas F con
un objeto seleccionado, te estás enfocando en el
objeto que quieres mirar. Puede hacer clic para luego rotar
directamente alrededor del objeto. Y otra cosa
que puede ser bastante útil es que si estamos colocando
algo como esto, podemos sostener un shift, hacer click izquierdo en la dirección del widget,
y luego arrastrar esto. Entonces, si comenzamos a
arrastrar un objeto aquí y luego presionamos Mayús, esto
se estaba moviendo, en
realidad podemos tener la cámara en el visor seguir rastreando el
objeto que estamos Bastante útil si estás
intentando tocar algo y no
querías seguir moviéndolo,
moviendo la cámara,
moviéndola de nuevo, y así sucesivamente. Entonces solo algunos consejos rápidos ahí, familiarizándose
con el viewpot Ahora vamos a querer empezar a mirar los límites. Una vez más, desde el botón Agregar, vamos a
buscar algo aquí llamado volumen de bloqueo. Podemos ver cómo tenemos la
opción de bloquear el volumen. Seleccionaremos
esa, y lo que nos
dan es este cubo invisible. Esto va a representar
nuestro muro invisible, y solo queremos
colocarlo a través del nivel para bloquear donde el jugador o los enemigos puedan golpear. Para poner esto en su lugar, voy a hacer lo
mismo otra vez. Voy a
hacer click derecho y pegar la ubicación del
inicio del jugador . Eso nos va
a poner aquí abajo. Para esta, podemos poner esto en el lado izquierdo de nuestra zona de juego, lo que sé por
pruebas sería un buen punto de negativo 1,240 Eso colocará esto un poco más. Listo perfectamente
fino en el eje Z. Esto es lo suficientemente alto como para que el avión
choque efectivamente con esto Si ponemos esto en la ubicación
X de cero, eso pondrá este
tipo de medio
del nivel en el eje Ford. Y entonces lo que queremos
hacer aquí es escalar la caja para cubrir toda
la extensión. Ahora bien, una forma en la que
podrías hacer esto es
hacer que el eje X
aquí sea mucho más largo. Eso va a cambiar la caja. Eso es una especie de estirar
al actor real. Cuando estamos trabajando con
cosas como volúmenes, tenemos otra opción. Así que voy a establecer esto de nuevo a la manera ideal en que vamos a estar trabajando con estos en realidad es cambiar la
configuración del pincel aquí. Entonces este es el tamaño de la caja que actualmente
tenemos en este momento, que es de 200 centímetros alrededor. Entonces, si configuramos esto en algo
mucho más grande en su lugar, solo
agregaré un
par de ceros aquí Así que tendremos una
caja de 20,000 unidades solo para asegurarnos de que estamos encapsulando
toda la zona de juego y un poco más,
probablemente mucho más Pero eso está perfectamente bien. La razón por la que queremos
hacer esto es que esto está cambiando la escala del componente real dentro,
este componente de caja de cepillo. Mientras que este valor aquí arriba es la escala de todo el actor
real. Entonces, si podemos mantener este
uniforme y limpio a la una, entonces si alguna vez necesitábamos
verificar las cosas en código, es un poco
más fácil trabajar con él. Y otra vez, solo mantiene nuestra
estructura un poco más ordenada. Mientras estemos
aquí abajo, solo haré que la altura sea un
poco más grande. Así que es posible que queramos
establecer esto en algo así como 1,000 en la Z solo para
asegurarnos de que
definitivamente estamos bloqueando
absolutamente todo. Algo más que puede resultar
un poco confuso es, si es un
poco difícil de ver, sí
tenemos opciones para
cambiar la opacidad, podemos agregar un volumen
sombreado de visualización, y luego podemos comenzar a ver
dónde está el cubo real Nuevamente, esto no se
muestra en modo juego, pero sí se muestra
a través de la cámara, lo
que hace que sea un
poco más fácil de ver. Y lo principal
es poder
medir dónde ocurrirá realmente el
volumen de bloqueo. Con eso hecho, solo
voy a presionar Control en D después de seleccionar el
volumen de bloqueo que hemos configurado. Voy a poner esto en 1,240, así que tenemos esto en el
lado derecho del campo de juego Entonces en el YX está aquí. Y sólo para que sea visible,
como el lado izquierdo atado, sólo
voy a
desplazarme hacia abajo. Encienda el volumen
sombreado de la pantalla, y estos serán ambos y se verán iguales. Tenga en cuenta también. Creo que cuando
duplicamos cosas, Unreal intenta mover al actor
duplicado varias unidades cualquier manera para que
no se superpongan completamente Entonces puedes ver que en
el volumen del lado derecho, tenemos algunas compensaciones en la X. Esto en realidad no
causaría ningún problema Pero solo para calmar las
voces y mi cerebro, voy a poner esto de nuevo a
cero y todo otra vez, agradable y ordenado y
bien mantenido. Con una serie de
cambios como ese realizados,
es posible que desee
presionar Control Shift y S para guardar todo en lo
que hemos estado trabajando. Entonces ahora podemos entrar a playodes. Vamos a estar mirando a
través de nuestra cámara. Va a ser un
poco difícil de ver porque aquí no podemos ver el volumen de unión
real. Entonces, si quisiéramos probar
las cosas y asegurarnos saber exactamente cuándo podríamos
estar atravesando una pared, otra opción, un
poco larga aquí es que podríamos volver a las formas.
Podríamos agregar un cubo. Quiere bajar a la configuración de
colisión en el panel de detalles en
el lado derecho, y solo para asegurarnos de que solo
vamos a estar comprobando contra
nuestro volumen de bloqueo, podemos seleccionar el ajuste preestablecido de
colisión justo aquí y convertirlo
en ninguna colisión. Veremos más a la colisión
un poco más tarde, pero esto es solo para
conseguir algo visual. Entonces otra vez, voy a volver
a los detalles, pegar esto en la ubicación, y poner esto -1,240 Por velocidad y
simplicidad, solo
mantendré esto aproximadamente del mismo tamaño. No necesita ser exacto, así que vamos a agarrar el cubo. En el eje Y, necesitamos hacer
estas dos unidades en la Y para obtener aproximadamente el tamaño de nuestro volumen de
bloqueo y nuevamente, vamos a hacer esto mucho
más grande en la X para que abarque todo y
más grande nuevamente en la Z. No
necesitamos ser
tan cuidadosos Aquí. Lo principal,
es sólo algo visual para que podamos ver si y cuándo el jugador estaría
atravesando la pared, para que
podamos ver eso aquí. La razón principal es
que sabía que la colisión no
estaría funcionando, y solo quería eliminar de
inmediato el hecho de que
efectivamente estamos pasando por
el área de unión, que debería estar
colisionando con nosotros La razón por la que
quería presentarle esto, ya que sabía que esto
iba a pasar, esto nos da un poco
de ejemplo sobre cómo podemos ir sobre la depuración Esto es muy importante
en el desarrollo, realidad entender
cómo resolver problemas, trabajar las cosas y
averiguar qué está pasando. Ya tipo de contestado
uno de los problemas. Lo primero es que no
hubiéramos sabido
si solo
volamos por ahí si
realmente hubiéramos atravesado
la pared o no. Entonces ya descartamos el hecho de que
no estamos llegando al muro. Podemos llegar al
punto de la pared e ir más allá y no se
produce ninguna colisión. Entonces esa es una opción de la lista de verificación
completamente marcada. Si agarro el volumen de bloqueo la izquierda aquí,
intentaremos arreglarlo primero. El primer sospechoso podría ser las propiedades de
colisión que
acabo de mostrarte. Entonces, en el lado derecho
en el panel de detalles, volveremos a bajar a
las propiedades de colisión. Bajo colisión, podemos ver que este preset está
configurado en pared invisible. Si bajamos esto, podemos echar un
vistazo a lo que esto significa. Y esto va a ser un panorama muy breve
de la colisión. Nuevamente,
habrá mucha más profundidad sobre esto que viene en temas futuros. Pero por ahora, todo lo que necesitamos
saber tenemos tres tipos
diferentes. Tenemos Ignorar,
solapar y bloquear. Ignorar hace
lo que pensarías. Ignora todos los demás
colisionadores e interacción. Superposición es
buscar dos cosas que estén en el
mismo espacio físico, pero que no se toquen físicamente con cosas como la física
y bloqueándose entre sí. Y luego tenemos
bloque, que serían dos objetos físicos
impactándose entre sí y tratando de apartarse unos a
otros para que no habiten el
mismo espacio físico En definitiva, el muro invisible se
configura exactamente como lo queremos. Está listo para bloquear absolutamente
todo en el mundo. Entonces ese es nuestro segundo
sospechoso, por cierto. Sabemos que estamos
llegando al muro y sabemos que el
muro tiene colisión. Lo siguiente es que vamos a
ver la colisión de las cacerolas. Entonces, si vamos
a la clase peón, iremos a la malla estática, y la colisión en
este momento se está
manejando en la malla estática Entonces en el panel de detalles, nuevamente, vamos a querer desplazarnos hacia abajo y encontrar la colisión. Desplegaremos los ajustes preestablecidos de
colisión, y podemos ver que esto está
configurado para bloquear todos los dinámicos Ahora bien, esto en realidad no
importa. Nuevamente, lo importante
de estas casillas de aquí. Esto está marcado para bloquear
absolutamente todo también. Y si volvemos
al mundo muy rápido, vamos a obtener un
curso acelerado muy rápido sobre colisión aquí, podemos ver que el muro
invisible está configurado para ser su tipo de objeto se
establece en estática mundial. La pornografía en sí está ambientada
en la dinámica mundial. Entonces esto está buscando bloquear los objetos estáticos
del mundo, y esto busca bloquear los objetos dinámicos
del mundo. Entonces, mientras esos dos
estén buscando interactuar, deberíamos ver algún bloqueo
físico. Entonces ese es el tercer
sospechoso, por cierto. La colisión porno
en realidad se configura correctamente. Y eso realmente deja lo
único es que
probablemente hayamos hecho algo
mal en nuestro código. Y alerta de spoiler, ya
sé que ese es el problema. Entonces, si bajamos al gráfico de
eventos del evento, vamos a pasar a nuestra
función de ubicación de actores establecidos aquí. Y esta es una de esas
cosas en las que
sería bastante difícil depurar de nuevo y realmente saber que
este es el problema sin realmente haber
experimentado esto. Dos cosas a tener en cuenta
aquí son el barrido
y los booleanos teletransportados
en la llamada de función Si pasamos el cursor sobre el barrido, podemos ver aquí la descripción que obtenemos es si barremos la
ubicación de destino desencadenando superposiciones en el camino.
Esto es realmente importante. También controlando
si nos detenemos antes
del objetivo si algo
está bloqueado por algo. Esta es la parte realmente importante aquí es que si no
tenemos esta marcada habilitada, entonces no vamos a estar comprobando que nuestra posición esté bloqueada, lo que significa que no
vamos a golpear nada En definitiva, tener barrido
desmarcado es técnicamente una especie de teletransportarnos a la
ubicación en la que queremos estar Entonces, si marcamos esto,
presionamos compilar y guardar, volveremos y volveremos a probar. Ahora podemos ver cuando hemos
sobrevolado ,
ahora estamos siendo bloqueados. Así que no hemos necesitado
cambiar ninguno de los presets de
colisión Nos meteremos en esos
un poco más tarde. Eso significa,
también, que la pared del
lado derecho estará funcionando porque está configurada
exactamente de la misma manera, así que está perfectamente bien. Fue simplemente una cosa muy
simple, muy fácil de pasar por alto
en nuestro código Así que quería incluir
eso solo porque, como he mencionado, las cosas
no siempre salen perfectamente, y sí necesitas
estar cómodo solo un poco depurando y tratando de volver a
trabajar a través de
las cosas que lógicamente crees que podrían
ser parte del problema Esta es una de esas cosas que termina siendo un
problema muy común. Es realmente fácil de
perder. Realmente difícil de depurar si no sabes
lo que estás buscando. Pero si eso hubiera fracasado, incluso yo como desarrollador experimentado,
habría estado un poco fuera de caminos de pensamiento
potenciales por los que
podría haber pasado, y habría tenido
que simplemente haber ido a Google o RDI o a Google o RDI o
algo así
e intentar encontrar allí si alguien tenía
un problema similar Así que solo un rápido ordenar
con los límites ahora. Voy a volver a entrar.
Voy a deshacerme de este cubo blanco de aquí. Eso
fue sólo para la visualización. Ahora sabemos que estamos
desove en el lugar correcto, y estamos siendo
bloqueados por
las dos paredes de aquí.
Entonces con eso hecho. La cámara está fija. Ahora está
en su lugar donde lo queremos. Se establecen los límites, y
cuando comencemos a agregar enemigos, ellos detectarán los muros
y rebotarán entre ellos. Obviamente, una vez que hayamos
implementado ese código. Antes de eso, sin embargo, vamos a empezar a buscar materiales, más tipo de
elementos visuales de nuestro proyecto. Podremos personalizar
el aspecto de nuestras naves para que todos los enemigos no se vean idénticos al jugador. Como siempre, si
quisieras experimentar, por el momento, solo
prueba algo sencillo. Intenta agregar un límite superior e
inferior, especialmente si
ya tienes algún movimiento
hacia adelante y hacia atrás. Una vez más, mismo
proceso, diferentes ejes, solo para familiarizarte y
probar cosas diferentes.
10. 09 - Instancias de materiales: Momento, si saltamos
directamente a crear a nuestros enemigos, se verían exactamente
como nuestro jugador. Mismo avión azul, no hay manera de diferenciarlos
realmente. Por eso entran nuestros
materiales, lo que nos permite envolver diferentes
colores e imágenes alrededor nuestros tres modelos D
para
diferenciarlos y agregar algo de variedad. No estaremos creando
materiales desde cero, ya que esa sería su
propia madriguera para conejos. Y como he mencionado,
estamos enfocados principalmente en la programación, prácticas y proyectos,
las tres Ps. Pero te voy a mostrar
cómo podemos crear variaciones de
color a partir de lo que realmente
he proporcionado. Si bien no vamos a crear
nuevos materiales desde cero, sí
quiero mostrarles los
materiales que ya tenemos. Si entramos en los materiales de la
carpeta de activos, como ya he tocado anteriormente con las convenciones de
nomenclatura, tenemos algunas cosas
aquí que mirar Tenemos dos subrayados MM
el agua y la textura, y tenemos cuatro subrayados MI, que son las instancias
materiales Mm, que es un prefijo
para material maestro. Aquí es donde ocurre la lógica del
shader real. Abrimos la base de textura, no
vamos a estar editando
nada aquí, pero solo
quería mostrarte algo de la terminología y detalles con los
que familiarizarte. Si nos movemos hacia el
lado izquierdo de la gráfica aquí, esto es muy parecido al gráfico de
planos que podemos simplemente hacer clic
derecho y arrastrar
alrededor para movernos Lo principal que tenemos son tres entradas de muestra de textura. Tenemos el color base,
que es nuestro mapa de colores,
los azules, la veta de la
madera, la pintura. Y todo esto está tomado del mapa de
Ubi en el modelo tres D. Entonces tenemos nuestra textura
normal o el mapa normal que agrega detalles de
superficie sin geometría, esos baches, nervaduras, líneas de
panel, y así sucesivamente, todo fingido manipulando cómo la
luz rebota El final importante
es la textura ORM. En este caso, esto es algo
que he creado personalmente, y tengo un flujo de trabajo ligeramente
diferente. He creado esto como un ORME
específicamente esta vez. Se trata esencialmente de
cuatro imágenes en escala de grises agrupadas en un solo
archivo de textura, La razón principal de esto es que todos los datos dentro de ellos pueden extrapolarse
a través Esto ahorra memoria, y es solo un poco
más fácil trabajar con él. En este caso, el canal rojo
es la oclusión ambiental. Aquí es donde la luz
luchará por llegar. El canal verde es rugosidad, creando una superficie lisa de espejo versus mate en
diferentes áreas El canal azul es
metálico. Esto es binario. Esto es metálico
o no metálico, y el
canal Alfa es emisivo, mostrando qué partes brillarían Algo que es útil tener cuenta cuando se
trabaja con materiales es que en lugar de simplemente tener esta
representación esférica aquí, podemos cambiar lo que se
muestra en este viewpot con un práctico truco de editor Si abrimos el dibujo de contenido y entramos en la carpeta de mallas, toma una malla que te gustaría visualizar con tu material En este caso, va
a ser el héroe llano. No necesitamos hacer
nada con esto. Solo necesitamos que esto
sea seleccionado. Podemos volver
al material y unil recordando lo que actualmente
hemos seleccionado dentro
del cajón de contenido Puede cambiar la representación, la visualización
de nuestro material aquí para ser cosas como un
cilindro, un plano, un cubo. Y luego específicamente
este icono de ladrillo aquí. Si tienes una malla estática,
seleccionada, y hacemos clic en esa, nos dará una
representación, visualización de nuestro plano o la malla que actualmente tenemos seleccionada en el sorteo de contenido. Entonces esto puede ser bastante
útil para visualizar las cosas y ver exactamente cuál
es el responsable. Pero, ¿qué pasa cuando estás cambiando
diferentes propiedades y obteniendo esa retroalimentación
inmediata? A continuación, quiero que te concentres en estos nodos nombrados en todas partes. Estos se
denominan nodos de rearranque. Intead de cables que se extienden
a través de nuestra gráfica, algo así como un tablero de evidencia de
la teoría de la conspiración En su lugar, podemos elegir crear conexiones con
nombre solo una vez, y luego podemos hacer referencia a
estas absolutamente en cualquier lugar dentro de nuestro
Shader. Completamente opcional. No siempre verás estos usados en otros ejemplos,
pero lo hace
de nuevo, permítame mantener toda mi lógica Shader en el lado izquierdo y luego simplemente llamar a las cosas cuando las necesite
en el lado derecho Una de esas cosas
donde
existe la herramienta , entonces, ¿por qué no usarla Sin embargo, como he mencionado, no
recomendaría cambiar nada dentro del
material maestro a menos que
sepas lo que estás haciendo, o al menos
hacer un duplicado y hacer algunos ajustes
en ese para que
siempre tengas algo en lo que
recurrir La razón principal es el
siguiente tema que veremos
son las instancias materiales
y la forma en que funciona
la instancia es impulsar la información directamente
de este material maestro. Entonces, si algo irrumpe
aquí, entonces
potencialmente vas a romper todas
las instancias que dependen de ello. Así que de vuelta dentro de la carpeta de
materiales, si te has movido, para ahorrar un poco
de tiempo, podemos usar un punto de partida bastante lógico. Ya tenemos un avión. Tiene la mayoría de las
texturas y todo configurado exactamente como lo necesitamos, y ese es el jugador de plano de
subrayado MI Así que adelante y agarra este
, presiona control, de hecho, para duplicar y renombrar
este para avionar enemigo, manteniendo al MI en el frente. Si hacemos doble clic
y
abrimos esto, ya podemos comenzar
a mirar instancias materiales. Podemos ver que esto
es muy diferente de nuestro material maestro. Una cosa a tener en
cuenta aquí está en el lado derecho
en el panel de detalles. Algo que debo mencionar, probablemente
estés
notando patrones aquí Cada vez que estamos en un panel,
ya sean materiales,
planos, componentes, ver
olla, cuando agarras algo, normalmente
hay un
panel de detalles que se queda por
alguna parte para darte información sobre lo que
estás viendo, que definitivamente es una de
las cosas buenas de Cuando comienzas a aprender
partes de los conjuntos de características, eso se transfiere a diferentes características dentro del motor. Pero lo que estaba a punto de decir es que si miramos el panel de detalles, tenemos el padre
siendo denotado aquí, y eso está demostrando que esta es la base de textura de subrayado MM Así que podemos
hacer doble clic en esto, y esto solo nos lleva de vuelta
al material que acabo
de mostrarles. Entonces, como he mencionado,
toda la información
viene directamente de
este material maestro. Otra cosa, sería bueno volver
a visualizar el avión. Entonces solo para recapitular, vuelve a la
carpeta de mallas, agarra el avión y presiona el ícono de ladrillo de aquí dentro
de la instancia de material Las principales cosas que queremos
cambiar son las texturas. Podemos ver que esto
es muy diferente. No tenemos ninguna información
de la gráfica o esa información de shader aquí Todo eso se
usa específicamente en el material maestro. Dentro de la instancia,
lo que tenemos en cambio son cosas que he elegido
específicamente exponer. Todas estas notas
grandes nombradas aquí, las texturas, el color de la textura. Estas son
variables parametrizadas que he expuesto para que podamos
verlas en la instancia Entonces, lo que queremos
tener en cuenta si bajamos las categorías de Dan, estas son todas las
cosas que acabo mostrar las propiedades expuestas. Al exponer estos
dentro de las instancias, obtenemos un
ambiente de trabajo realmente agradable donde
solo podemos hacer un cambio y podemos ver esa actualización de inmediato. Entonces podemos hacer eso para conseguir
nuestro primer tipo de enemigo. Si bajamos este color base de
textura, entonces la información del color, y vamos a
buscar al enemigo verde. Creo que voy a hacer verdes a
los enemigos. He proporcionado muchos colores de textura
diferentes aquí si quisieras
expandirte sobre esto y hacer tus propios tipos de enemigos. Creo que he incluido amarillo, morado, quizá naranja o rojo. Voy a ir por la textura del color base
verde, y podemos ver que de inmediato
va a cambiar nuestra información
de la llanura. La mayoría de las normales
y las texturas OIME son probablemente casi las mismas, pero sí
las exporté individualmente por textura cuando las
estaba creando Así que bien podemos seguir adelante
y agarrar la normalidad. Así que vamos a
buscar de nuevo el verde, y vamos a encontrar
al héroe verde llano. Pero esta vez, queremos
la textura normal. Y luego finalmente, vamos
a bajar la ranura de OIME, y vamos a
buscar de nuevo el verde, y solo reemplazaremos esto
para ser el héroe verde OI ME Bien. Entonces solo para
asegurarme de que eso linee exactamente los modelos que he hecho dentro de licuadora en
caso de que alguien tuviera curiosidad, y los he texturizado y horneado toda esta información
en sustancia pintor. Entonces, como mencioné, es posible que
veas flujos de trabajo similares pero ligeramente
diferentes. Todo se reduce al artista y a la persona
que los está haciendo. Lo principal a
tener en cuenta ahí, sin embargo, es que obtuvimos esa retroalimentación
inmediata. Tan pronto como cambiamos algo, no
hay recompilación, vimos la nueva textura
aplicada al material,
que es uno de los beneficios clave para las instancias de material Definitivamente no es exclusivo
de ese beneficio, y siempre debemos tratar de usar instancias
materiales
donde sea posible, donde las cosas estén compartiendo propiedades,
características y valores
similares que podamos exponer. Entonces, más allá de las texturas,
este sería un punto final perfectamente fino si estás contento con este
aspecto tal como es. Solo quería
brindar un poco más de información sobre las instancias
materiales, qué hacen y cómo
podemos usarlas. Entonces algunas de las otras propiedades
que he expuesto aquí son valores de punto flotante
o colores que podemos cambiar
directamente y anular
el color general o tinte que se está aplicando
al material o cosas como qué tan
especular es el valor Así que la especulación es
realmente fácil de ver. Si marque la especulación
aquí , esto
nos permite editar esto Y por el momento, estamos en 0.5, más o menos especularidad promedio Esta es la cantidad de luz que
rebota de una superficie, haciendo que las cosas se vean un
poco más plásticas o más
como goma cuanto más alta va
la especulación Generalmente, no tenemos nada con lo que
interactuemos
a diario que
tenga cero especularidad Entonces, comenzar en algún lugar
alrededor 0.3 o 0.5 es
algo realista. Si bajamos esto a cero, obtenemos esa retroalimentación inmediata. Quiero decir, tengo una superficie
completamente enmareada, completamente no
reflectante Si ponemos esto todo
el camino hasta uno, entonces la luz está
rebotando alrededor de esto
mucho, mucho más Así que de nuevo, puedes modificar
características como esta e intentar hacerte una idea de cómo te gustaría que se vea la
tuya También podrías
jugar con cosas como una máscara de color
o un tinte de color. Entonces si tomamos aquí la máscara
de color, esencialmente un porcentaje
normalizado 0-1 Así que cero no es enmascaramiento
y uno siendo enmascaramiento completo. Si encendemos el
color de la textura, estos dos trabajan juntos. Entonces la máscara de color está enmascarando la anulación del
color de la textura aquí. Si hago de esto algo
realmente obvio, como un color rojo y luego apago la máscara
haciéndola 100% efectiva, así permitiendo que salga el 100% del
color. Entonces cambia al valor uno. Ahora tenemos un plano completamente rosa. Entonces podemos controlar
esto muy fácilmente. Y lo realmente bueno de
esto es
que obtenemos esa retroalimentación inmediata y la actualización inmediata cuando
estamos haciendo estos cambios. Si quisieras que esto fuera un
poco más sutil
podríamos cambiar la máscara de color
a algo así como 0.5, y solo estamos permitiendo la mitad de ese color
salga a través. Llévalo de nuevo a
0.2, y estamos obteniendo solo un tinte azul muy claro
en la parte superior de nuestro avión verde. Baje todo el
camino a cero, y no vamos a tener ningún
color entrando en absoluto. Entonces acaba otra cosa para
que juegues,
junto con las diferentes
texturas que puedes usar, y luego las
propiedades emisivas funcionan de la misma manera Ahora, no tenía nada aquí para hacer brillar realmente, como faros o
algo por el estilo Entonces la emisión era más
bien una forma de darte diferentes
propiedades con las que jugar. Si enciendo la fuerza emisiva, tenemos que darle a esto un
valor más que cero Y entonces si encendemos
el color emisivo, por el momento, es negro Ahora obviamente, el
negro es solo cero, cero, cero en el valor RGB. Entonces, si multiplicamos el
negro por uno o 100, todavía
vamos a conseguir el
negro, que no es nada. Entonces necesitamos darle un
color a esto si cambiamos esto a algo así como un
amarillo o un naranja, y tal vez necesitemos aumentar un poco más
la fuerza. Y esta es una de
esas cosas en realidad donde como estaba explotando
diferentes texturas, algunas de ellas, me di cuenta que no
tendría ningún uso para
un canal emisor lleno de texturas Entonces, si quisieras jugar
alrededor de la propiedad emisiva, puedes querer
entrar en la textura OME aquí y volveremos
a cambiar esto al plano azul Avión aquí son azules.
Vamos a
tener que bajar de tono esto
sólo un poquito. Tal vez pero hay algo
más como uno o 0.5, así que no está
anulando completamente el color Y puedes hacer que todo el
avión brille un poco aquí. Entonces, también tienes control sobre la propiedad emisiva Como ya he dicho, desafortunadamente, no
pensé en
modelar en algunos
faros antes de tiempo, pero quería meter
las propiedades emisivas para que puedas hacer brillar todo
el plano
y divertirte Podría ser útil si quisieras animarlo
volando o algo así Podrías tenerlo parpadeando entre su
color normal y, como, un rojo antes de
que ocurra la explosión, una idea. Yo sólo para ayudar a visualizar lo que está pasando aquí
y cómo están funcionando estas texturas, especialmente el OIME Me doy cuenta de que podría
ser bastante confuso. Sólo voy a apagar
esto, y voy a poner atrás porque no
quiero anular ninguno de estos. Y voy a
volver la textura a verde para
el OIME como sé, esa ha sido
horneada específicamente para esta propiedad de color Solo quería mostrarte muy
rápidamente a través de las texturas
y lo que está pasando. Entonces cuando digo estos han sido horneados en diferentes canales, si entramos en la carpeta de
texturas, y encontraremos que
realmente no importa cuál para ser honesto. Sólo podemos encontrar
al héroe azul llano y voy a
abrir el canal OIME Entonces normalmente, en la mayoría de las texturas, colores y todo lo que estamos viendo aquí
vienen de los canales RGBA todos siendo
combinados a la vez Si te quitas algo, todo
lo que vas a terminar es un poco
fangoso de colores raros como este donde rojo y azul sumados
obviamente nos darán morado Rojo y verde nos darán una especie de
color naranja y así sucesivamente. Entonces no lo usaríamos de esta manera. Con el proceso ORME, es
un poco diferente. Y esto es porque lo que he
hecho, en el canal rojo, esta es nuestra oclusión ambiental Entonces cualquier cosa que sea
blanca esencialmente no está bloqueada por ningún otro
elemento del modelo. Entonces la luz nos está
impactando completamente, y entonces cualquier cosa que
vaya hacia el gris o negro tiene algún tipo de oclusión de otra
parte del modelo,
algo así como el cojinete de la braguita y Y va a aplicar
un poco de falso sombreado ahí para
enfatizar las sombras En el canal verde,
esta era nuestra aspereza. Entonces nuevamente, pasando de esencialmente
un valor de cero a uno, diferentes áreas parecen
ser más ásperas como estas áreas de aquí están proporcionando
algún tipo de detalle aproximado, mientras que estas van
a ser mucho más suaves. El azul era el metálico, así que de nuevo, eso era metálico
o no. Entonces estos serían el
frente de la hélice. Hay algunas pequeñas piezas
metálicas en las ruedas y otras
pequeñas características como esa. Y luego
se ha horneado el canal Alfa , y como
puedes ver aquí, esto es esencialmente todo
el cuerpo
del avión que ha sido horneado
en el canal emisor Entonces, al
sacar esta información y
multiplicarla contra nuestras propiedades de
color y cosas así
en el material, podemos manipular elementos
específicos modelo a través
de
nuestros canales de textura Entonces es una
forma inteligente de hacer las cosas. Ahorra en la memoria
y nos da un poco más de flexibilidad
dentro de nuestros materiales. Solo un par de cosas antes de terminar sobre este tema. Si querías
jugar con más materiales, solo para mostrarte
algunas formas diferentes de
crear diferentes instancias de
material. Te he enseñado cómo duplicar nuestro material original del reproductor. El control en D
duplicará eso. Si sabes que solo
quieres
hacer algo completamente nuevo, un material completamente nuevo para
jugar con esos, solo
vamos al material
y seleccionaremos esto. Si ya tienes
un material maestro con el que
trabajar y querías
hacer una nueva instancia, puedes hacer clic derecho sobre
el material maestro aquí, navegar hasta la parte superior aquí y crear una nueva instancia de
material. Te daría
algo muy parecido al plano
del jugador o
lo que sea que tuviera anteriormente, y solo tendría algunos valores prellenados
predeterminados, esencialmente el mismo resultado. Entonces me desharé de éste.
No voy a necesitar quedarme con eso. Solo quería mostrarte la forma en que podrías
trabajar con estos. Diciendo eso
porque probablemente sea uno de los temas más fáciles de abordar, y no vamos a ir mucho más a fondo de lo que tenemos aquí. Definitivamente recomiendo
tomarme un tiempo entre temas para pausar los videos
y dar un paso atrás. Tal vez crear algunas
instancias de material con diferentes colores. Esto te daría la opción después de tener un enemigo verde,
un enemigo morado, un enemigo rojo, lo que se ajuste a tu
visión para el juego. También podrías intentar
darle diferentes chips, diferentes valores de secularidad, agregar un poco de una propiedad misiva
a algunos de ellos, o darles un Entonces, si realmente querías
comenzar a aprender más sobre el motor y
entender realmente lo que está sucediendo, toma esto como una
pequeña tarea entre
este tema y el siguiente e intenta crear algunas
instancias materiales en el medio. Pero con eso hecho, esas son nuestras cosas
materiales cubiertas, y estamos listos para ir
con un material enemigo que podamos comenzar a crear
nuestras nuevas clases. Usando instancias de material,
hemos podido crear esa nueva variación sin
tocar ninguna capa, usando la
clase de material padre que he proporcionado con toda
una gama de posibilidades para que las instancias
de material provengan de eso.
11. 10: EnemyMovement: Es hora de hacer algunos
enemigos. Advertencia justa, primero
estaremos haciendo esto de la manera
sub óptima. Podrías cuestionar algunas de las opciones si sabes irreal Una vez más, esto es
completamente intencional, y esta vez es para
permitirnos refacturar nuestro trabajo La refactorización es parte de
cualquier desarrollo real. Es tomar la base de código o
proyecto que ya tienes, mejorar el código que
está funcionando que
quieres conservar y eliminar lo
que no necesitas. Quiero asegurarme de tener la oportunidad pasar por esto contigo para poder mostrarte cómo hacer
que el proceso sea un
poco más indoloro Pero claro, primero,
vamos a necesitar
algo que nos permita refacturar Para ello, vamos
a crear nuestro peón enemigo. Entonces, si navegamos hasta
el cajón de contenido dentro del blueprint
y la carpeta core, vamos a
hacer clic derecho aquí e ir a la opción de clase de blueprint
y crear una nueva clase de peón Le daremos a éste el nombre
de BP Underscore peón Enemigo. Entra para abrir esto, y
esto va a ser casi idéntico a lo que
ya configuramos para nuestro jugador. Y eso es esencialmente parte
del problema inicial aquí. Vamos a estar duplicando un montón de trabajo que ya
hemos hecho Vamos a estar pasando por la
mejor solución después, pero por ahora,
vamos a construir lo que teníamos antes
con nuestro jugador. Entonces en el panel de componentes, sabemos que queremos agregar
una nueva malla estática. Vamos a agarrar
nuestra malla estática y soltar esto en la raíz de escena
predeterminada. Con la malla estática seleccionada, vamos a ir
al
lado derecho en el panel Detalles, y seleccionaremos para usar el héroe del plano de guión bajo
SM Por supuesto, no queremos que
este sea del mismo color. Y si no puedes
ver tus materiales en el panel de detalles
en este momento, simplemente
necesitamos hacer clic fuera de la malla estática, así que encuentra
el otro componente. Seleccione nuevamente la malla estática, y podrá ver que ahora tenemos
nuestro material seleccionado. El elemento cero es el
cuerpo del plano. Este es el
color principal y el detalle. elemento uno es una ranura de material
separada creada exclusivamente para
la hélice de madera. Esto nos permite hacer cosas como animación basada en
vértices a través del shader para hacer que la hélice
parezca que se está moviendo Un poco complejo
para este proyecto, pero las características ahí si
quisieras extenderlo más tarde. Si bajamos el elemento cero, queremos buscar
el material enemigo. Y por supuesto, si
tomaste esos pasos extra recomendados
entre los temas, es posible que tengas algunos
materiales diferentes para elegir. Seleccionaremos este
, y podrás ver que mi avión se ha vuelto verde, por lo que este debería destacarse frente al
modelo y material de avión del jugador por defecto. A continuación, vamos a querer agregar algo de movimiento a nuestro enemigo. Entonces, si pasamos
al gráfico de eventos, hacemos lo mismo que antes, quitamos el Acta comenzar solapamiento. No vamos a usar eso, y
podemos enfocarnos en el evento ti. Algo que siempre es útil para
entrar en los hábitos de es realmente planificar con
anticipación las características que
vas a implementar. Podríamos hacer eso, por
ejemplo, mirando el
proyecto de ejemplos de contenido en el que estamos
basando esto y desglosar la funcionalidad central y las características que tendrán los enemigos El primero es que el movimiento no es lo mismo que los jugadores. No tiene
ese impulso falso o tipo de
pseudofísica que está sucediendo Es más ágil, solo
me muevo a la izquierda, a la
derecha, y hacia abajo de la pantalla.
Entonces tenemos movimiento diagonal. Esto nos permite planificar un
poco con anticipación porque también
podemos ver las cosas cuando el enemigo choca contra la pared,
cambia de dirección. Entonces sabemos que necesitamos
hacer algo de
movimiento lateral y movimiento hacia adelante,
y cuando chocan contra
las paredes, tenemos que hacer algo para dar cuenta de
un interruptor direccional Estructurar nuestros proyectos de
esta manera
nos permite descomponer
lógicamente un problema mayor en subproblemas que van
a ser más fáciles de abordar, y podemos
golpearlos paso a paso. Entonces, para comenzar,
lo primero que vamos a querer hacer es agregar
el offset del actor, el mismo tipo de
offset posicional que teníamos antes Entonces, desde el pin
EventiceEcution aquí, vamos a
buscar Así que de nuevo, muy similar a lo que
hemos hecho en el jugador. También vamos a querer usar el mismo enfoque
para averiguar dónde se encuentra
el actor en este momento y luego agregar un offset a esto. Entonces usaremos la ubicación del actor
get, y antes haremos cosas muy
similares. Vamos a tirar de aquí
y
buscaremos add o simplemente presionaremos
el botón más. resolveremos el cálculo Primero resolveremos el cálculo antes de enchufar
algo, y luego una vez que tengamos esto
terminado y listo para funcionar, podemos conectarlo y probarlo para
asegurarnos de que estamos empezando con
el pie derecho Ya sabemos que
no queremos números mágicos, así que bien podemos
crear un par de variables que
ya puedo ver que
vamos a necesitar. El primero será un valor de
punto flotante para la velocidad de movimiento. Solo un consejo rápido aquí. crea una nueva variable aquí, por defecto, esta
será una booleana Podemos quedárnoslo
de hecho. La forma que estamos impulsando
el movimiento será verificar si
nos estamos moviendo hacia la izquierda o hacia la derecha. Entonces, ¿mientras tenemos esto? Sigamos adelante y llamemos a
este B mover a la izquierda. Entonces esto era solo para
decir que cada vez que
creas una nueva variable, se te
dará un booleano Un atajo que me gusta
tomar, sabiendo que
necesito un valor de punto flotante
para la velocidad de movimiento, similar a lo que
hemos usado antes. Podemos sacar de
este alfiler verde aquí. El verde indica que los segundos Delta es
un valor flotante. Coloca esto en la gráfica y luego haz clic en Promocionar a variable. Le daremos a éste el
nombre de velocidad de movimiento. Y esa es solo una forma rápida de
obtener una variable del tipo que estás buscando
sin necesidad de usar el desplegable y
encontrarla en la gráfica Puedes hacerlo de cualquier
manera, pero es simplemente agradable si necesitábamos un
vector, por ejemplo, podemos encontrar un vector aleatorio, colocar esto en la gráfica,
promover la variable y luego darle un nombre así. Lo único es que
tenemos que hacer alguna limpieza, así eliminaremos los nodos No vamos a necesitarlas todavía. Pero solo quería
presentarles diferentes
formas en las que puedes
trabajar con el editor gráfico
del motor Unreal El vector era solo un ejemplo, así que selecciona esto y elimina esa variable también. Y
estamos listos para continuar. Cuando se trata del
movimiento, ya hemos cubierto la
independencia de la velocidad de fotogramas y por qué la necesitamos, para que
podamos construirla desde el principio. Si hacemos clic derecho y buscamos Get Wild Delta segundos podemos usar esto en nuestros
cálculos que vienen. Para el movimiento, vamos a querer tomar nuestra velocidad de movimiento. Y si golpeamos Compilar y solo aseguramos de que esto
tenga una variable, pondremos esto en
algo así como 250. Eso estaría perfectamente
bien para las pruebas. Y como he mencionado,
vamos a necesitar dos cálculos separados. Vamos a querer uno
para el movimiento lateral y otro para el
movimiento hacia adelante por la pantalla Para el avance,
podemos tomar nuestra velocidad de movimiento. Podemos multiplicar esto por
un valor para invertir eso, así que tomaremos esto como negativo porque abajo de la pantalla, como he mencionado,
es un valor negativo, y si quisieras
subir la pantalla, ese sería un valor positivo. Entonces, el movimiento hacia adelante para el enemigo es en realidad
relativamente sencillo. Y, por supuesto, queremos
multiplicar este resultado por Delta segundos para mantener las cosas independientes a la velocidad de
fotogramas. Entonces ese sería esencialmente nuestro avance
listo para ir y probar. Para el movimiento lateral,
vamos a querer
hacer algo con
nuestro valor booleano Entonces voy a agarrar la velocidad de movimiento
y duplicar esto. Vamos a querer hacer
algo muy parecido aquí donde vamos a tomar
un nodo de multiplicación, pero obviamente no
vamos a querer multiplicar ni solo uno ni uno negativo Tenemos que convertir esto en algún tipo de operación
condicional. La forma en que vamos a usar el booleano es un palo verdadero
o falso Diríamos que o nos estamos
moviendo a la izquierda o no nos movemos a la izquierda,
así que nos estamos moviendo a la derecha. Ahora bien, si intentaste
esto, nr convertirá un booleano en una multiplicación de
punto flotante Desafortunadamente, los booleanos
solo leen como cero o uno, cero cuando es falso,
uno cuando es verdad Entonces, obviamente, eso
significaría que esto no
funcionará para nuestro caso de uso actual, porque si estamos multiplicando por cero en lugar de movernos a la izquierda, eso solo tomaría
la velocidad de movimiento, multiplicaría por
cero, lo que
cancelaría cualquier
movimiento Sin embargo, lo que podríamos hacer, si presionamos Alt y hacemos clic
izquierdo aquí, podemos usar algo
llamado nodo de selección. Entonces vamos a
tirar de aquí, buscaremos Select. Y queremos esta opción en la parte inferior. Esto
nos da algunas opciones. Si estamos trabajando
con cosas como
enteros como el comodín aquí, puedes ver que agregamos cualquier
número de Cualquiera que sea el entero que coloques aquí, así que
cualquier número entero, si colocas en un número
entero de uno, por ejemplo, podríamos darle a
esto un valor negativo aquí. Lo que queremos hacer en cambio es que vamos a tomar nuestro booleano Vamos a enchufar esto
en el índice aquí,
el comodín, y Unreal cambiará eso para que
sea un booleano para Y podemos ver que
esto ahora está configurado para ser verdadero o falso. Entonces, la forma en que
podemos leer esto para que
esto sea más intuitivo
y fácil de entender, ¿podemos decir que si queremos movernos a la izquierda,
nos estamos moviendo a la izquierda? Si eso es cierto, entonces
el valor tiene que ser negativo porque
queremos movernos en un valor negativo. Si mover a la izquierda es
igual a false, entonces no nos estamos moviendo a la izquierda, entonces queremos que el valor sea uno. Entonces, esencialmente, esto
se está moviendo a la derecha. Esto se mueve a la izquierda, y esto
va a ser positivo y
esto va a ser negativo. Así que una
forma sencilla y agradable de que podamos usar un valor booleano para esencialmente alternar
en mover a la izquierda o Y luego cuando vuelvas
a hacer lo mismo, nos tomaremos nuestros segundos Delta. Tomaremos nuestro cálculo aquí, multiplicaremos eso contra
Delta segundos para asegurarnos que ambas direcciones sean independientes de la velocidad de
fotogramas, y esencialmente podríamos
comenzar a enchufar esto Entonces solo para mantener las cosas ordenadas, voy a sacar
del pin vectorial aquí y buscar make vector. Entonces ya las hemos visto antes.
Esto solo nos dará los tres valores de
coma flotante expuestos. Adelante en unreil
está en el eje X. De lado está en el eje y,
y eso es prácticamente todo. Podemos enganchar esto.
Podríamos probar esto, y tendríamos
un enemigo en movimiento. Entonces si golpeamos compilar, guardar, volveremos al nivel principal,
solo podemos dejar caer a nuestro enemigo. Realmente no importa dónde va a
estar
esto siempre y cuando esté ligeramente arriba de la
pantalla del jugador. Voy a darle a
esto una
rotación de 180 grados sobre el eje z, así que está mirando
hacia el jugador. Y entonces podemos darle a play, y
deberíamos ver esto
moviéndose por la pantalla. Tenemos esto moviéndose en
dirección diagonal, que es la
parte inicial del problema. Entonces ese es uno de
esos pasos resueltos. Creo que me di cuenta de un
pequeño problema aquí. Parece que
vamos a estar
atravesando la pared invisible. Entonces sí, definitivamente hemos hecho que el enemigo pase el muro invisible. Creo que está justo
dentro de los límites. Como ya mencioné, algo que
es realmente fácil de olvidar, y
lo acabo de hacer de nuevo es que
queremos asegurarnos de que
golpeamos la alternancia de barrido, así que asegúrate de que
estamos barriendo, y no
deberíamos tener la misma
funcionalidad que el jugador, sino que simplemente golpearemos la pared
invisible y nos detendremos. Perfecto. Entonces esa es la
siguiente parte del problema. Ese es el siguiente paso
que tenemos que resolver. Cuando el enemigo choca contra la pared, queremos tomar esa información y alternar la dirección del
movimiento. Y ya tenemos esa configuración. Entonces nos queda nuestra jugada.
Cambiaremos eso a verdad y haremos que se muevan a la izquierda en
relación con la dirección del
enemigo. Justo antes de
pasar por eso,
quería pasar por
un poco de información sobre el
tipo general de orden de código,
cosas que podríamos
mejorar aquí, incluso antes de hacer un gran Lo he expuesto
a propósito para que
sea más legible
y comprensible Pero esto es en realidad algún código
bastante malo ya antes de que incluso nos metamos en lo que
necesitamos refacturar más tarde Ahora bien, lo primero
es que solo quiero introducir
a la gente
a comentar, que es algo que aún no
he mencionado. Si agarramos un nodo, por ejemplo, y presionamos C,
podemos hacer un comentario. Una especie de cosa de
autodocumentación destinada a recordarnos
qué era algo, por qué se está
haciendo el cálculo, cómo fue. Y también hace que las
cosas sean más legibles
a distancia. No hace falta
que comenten todo. Es posible que hayas visto a
ciertos desarrolladores compartir parte de su base de código, y es posible que
solo haya habido comentarios llenos de basura en todas partes Es posible que hayas visto cosas
como esta donde tienen una variable o algo
realmente simple como esto llamado velocidad de movimiento, y le han dado un comentario solo diciendo velocidad de
movimiento. Esto es completamente arbitrario. No hace nada.
No es útil. Y siempre y cuando estés
nombrando tus variables correctamente o con
alguna buena intención, ya
sabemos que
esta es la velocidad de movimiento porque ese es el
nombre de la variable Por lo que no necesitamos
comentar así. No obstante, si agarramos esto y lo
expandimos para cubrir
todos estos nodos, lo que
podríamos hacer es cambiarlo para decir algo como mover
dirección, avanzar. E incluso podríamos
hacer esto más útil porque si presionamos F dos para
volver a renombrar esto, también
podríamos explicar
por qué estamos usando uno
negativo como multiplicar porque este no
tiene valor No tiene un
uso real de tener una variable. Entonces es una especie de punto válido tener
aquí un número mágico, pero de un vistazo, podríamos olvidar por qué se está aplicando
uno negativo, así podríamos dejar un comentario simplemente describiendo
lo que está sucediendo. Entonces podemos decir aquí, estamos
multiplicando esto por uno
negativo para mover a los enemigos específicamente por la pantalla Entonces haz algo muy parecido.
Podríamos agarrar estos nodos, presionar C, y le daremos a
este un comentario similar. Este realmente no
requiere ninguna explicación. Creo que esto es bastante claro. Si nos movemos a la izquierda,
entonces toma el valor relacionado con qué dirección
queremos movernos. Lo principal que obtenemos al
hacer esto es que si
empezamos a alejar la gráfica, ahora
podemos ver que esta sección sin realmente
mirar el código Esta sección es para
el avance. Esto es para el movimiento lateral. Si alguna vez necesitó afilar
rápidamente y encontrar un trozo de código específico para arreglar algo o
verificarlo dos veces, sabemos exactamente
dónde estos esto es solo el uso de comentarios.
Estos pueden ser útiles. No tienes que
usarlos en todas partes, pero definitivamente lugares donde crees que podrías olvidar lo que estás haciendo si vuelves
dentro de un mes o dos. Ahora bien, el problema principal que
queremos arreglar ahora aunque, voy a eliminar
estos es que
actualmente estamos haciendo un
montón de duplicaciones. Tenemos G World Delta segundos multiplicados dos veces
aquí individualmente. Entonces, una cosa que podríamos
hacer, y esto puede no haber sido completamente
obvio para empezar, sino que en lugar de multiplicar aquí los valores individuales de
punto flotante, podemos multiplicar
contra el resultado Entonces, si tomamos los resultados de este vector make
que hemos creado, tire de aquí y
busque multiplicar. Podemos agarrar uno de nuestros segundos Get
world to Delta, presionar Control X para cortar esto y controlar B para pegar y
luego enchufar esto aquí. Y RL convierte eso en un
vector multiplicado por un flotador. Podemos tapar ese
cálculo aquí. Y entonces podemos
deshacernos de este nodo aquí, así que
ya no necesitamos este múltiplo y enchufarlo. Y podemos deshacernos
de estos dos nodos. No necesitamos estos en absoluto, y luego enchufar esto de nuevo a la Y. Así que ahora tenemos algo
un poco más ordenado No tenemos tantas
multiplicaciones pasando. Estamos tomando ahora
todo el vector, lo que llevará la
multiplicación para la X y la Y al mismo tiempo
contra nuestros segundos Delta, asegurando que todo
sea
independiente del framewright para
todo el cálculo Así que eso fue solo un código muy
rápido ordenado allí. Entonces, si golpeamos compilar y guardar, deberíamos ver que obtenemos exactamente la misma respuesta así que
nada ha cambiado. Se ve y se mueve
igual que antes. Lo último antes de dejar este tema para la
noche antes de hacer el factor Ru es que
cada enemigo va a estar empezando a moverse en la misma dirección
y a la misma velocidad, lo cual será un
poco aburrido. Si lo agregamos en un
par de enemigos, así podremos simplemente sostener Alt y arrastrar un widget aquí para
duplicar inmediatamente. Así que solo estoy sosteniendo la tecla lt, agarrando la
dirección del widget y arrastrando en una dirección que duplicará
lo que tenemos Si presionamos play, va a parecer una especie de natación
sincronizada. Todos van exactamente en la misma dirección, a la misma velocidad. Va a ser un
poco aburrido. Entonces, si retrocedemos
a la jugada de inicio, voy a mostrarte
cómo aleatorizar un booleano primero para al menos cambiar la dirección en la que los enemigos
individuales voy a mostrarte
cómo aleatorizar un
booleano primero para al menos cambiar
la dirección en la que los enemigos
individuales podrían estar moviéndose. Esto
en realidad es muy simple. Vamos a sostener Alt y arrastrar el boom mover a la izquierda junto
al evento comenzar a jugar. O simplemente podrías ponerlo en
el pin de ejecución justo aquí. Y luego de la variable,
queremos arrastrar desde el pin aquí. Voy a buscar
algo llamado bola aleatoria. Así que vamos a
obtener un booleano aleatorio y configuraremos esto
en el Tan súper simple. 50 50 posibilidades
de
movernos a la izquierda o a la derecha. Entonces, si presionamos play,
todos optaron por
ir en la misma dirección y lo
han vuelto a hacer. Podemos ver que hay algo de
aleatorización, así que eso es bueno. No siempre van a ir exactamente en la misma dirección. Entonces un pequeño
ejercicio de aprendizaje para ti. El enfoque para hacer un flotador aleatorio es
ligeramente diferente, pero tómate unos minutos, pausa
el video y ve si
puedes implementar algo similar
con la velocidad de movimiento. Así que introduce
la
velocidad de movimiento y mira si puedes encontrar alguna funcionalidad
incorporada que UNR pueda tener
para permitirnos mira si puedes encontrar alguna funcionalidad
incorporada
que UNR pueda tener
para permitirnos
sacar un valor aleatorio al punto flotante Se podría aleatorizar esto
entre algo así como 250, que actualmente es nuestro
defecto y tal vez 500, para que cada enemigo se mueva a una velocidad ligeramente
diferente Pausa el video, dale
esa oportunidad y comienza a probar qué tan cómodo
te estás poniendo con el sistema de planos Bien, entonces voy
a recorrer el camino en el que
habría hecho esto. Si enchufamos esto y ojalá lo hayas
probado porque de nuevo, estos serán realmente valiosos
para aprender a usar planos en lugar de
simplemente seguir mis pasos Pero para que tengamos
el mismo código, por lo menos o
algo de lo que pasar. Lo que haría es agarrar
mi variable de vuelo aquí. Vamos a conseguir
un piso al azar. Esto es lo único que
puede haberte desanimado, y es posible que hayas querido
pasar y probar algunas opciones diferentes. Pero en lugar de simplemente
usar float aleatorio, que solo te
daría cualquier número, esto podría ser muy
rápido o muy, muy lento. Así que no demasiado utilizable. También podrías haber probado cosas como float aleatorio de stream. Pero el que
usaría sería este flotador aleatorio en rango. Entonces, si seleccionamos este,
solo nos da dos puntos para elegir
de nuestro mínimo, que yo diría que
serían los 250, y lo duplicaremos
a 500 como máximo. Entonces algunos aviones podrían
obtener ese mínimo 250, algunos podrían obtener 500 o un valor intermedio. Y ahí vamos. Podemos ver que todos
comienzan a velocidades completamente diferentes, lo que de nuevo, solo
hará que
las cosas sean un poco más interesantes cuando lleguemos
a sumarlas y estén funcionando correctamente en el nivel, rebotando en las paredes
y cosas así Con eso, sin embargo, los enemigos se mueven y
chocan con las paredes Todavía no rebotan, y tampoco
interactuarían con el jugador. Entonces, antes del gran factor Ruf, vamos a
mirar a continuación la detección de colisiones, haciendo que las cosas realmente sucedan cuando los objetos se tocan entre sí
12. 11: EnemyCollision: Tienen enemigos que se mueven, pero
no reaccionan ante nada. Idealmente, cuando un enemigo golpea algo, necesitamos
verificar qué es. ¿Es una pared, y si es así,
entonces alternar dirección. Si es el jugador,
en realidad podemos ver de nuevo en el proyecto de
ejemplo, se aplicó daño a
sí mismo y se destruye. Entonces lo que
haremos es
destruir automáticamente al enemigo si
tocan al jugador. proyectiles van
a manejarse solos, así que pensaremos en
eso un poco más tarde Esto no va a ser un
problema a considerar aquí. Una cosa a mencionar es que
el sistema de colisión irreal es flexible y potente, lo que desafortunadamente significa que
es algo complejo Al menos cuando empiezas a
trabajar con él después de probar algunas iteraciones
diferentes de diferentes tipos de cosas
que quieres hacer con él, creo que hace clic bastante rápido, y es un
sistema bastante cómodo para trabajar Entonces, volvamos a navegar
hacia el enemigo pan. Podemos usar esto para las
pruebas. Si agarramos la malla estática y abrimos la sección de colisión
en el lado derecho, simplemente desplácese hacia abajo aquí y
encuentre nuestra categoría de colisión. Si bajamos esto, podemos ver el preset de colisión aquí.
Dejaremos caer esta. Podemos verlo configurado para
bloquear o dinámico. Entonces esta es nuestra configuración de
colisión actual. El tipo de objeto también se
establece en dinámica mundial aquí, así que ese es el canal de
colisión como el que este objeto identifica. Por eso cuando presionamos play, el enemigo se detiene en las paredes. Se trata de una
colisión física o física donde ambos se están bloqueando entre sí
y tratando de no
habitar el mismo espacio físico Ahora bien, si bajamos
este y cambiamos esto a
solapamiento o dinámico, entonces el equivalente,
pero para superposiciones, iremos y pulsaremos compilar
y jugar rápidamente Lo que veremos es que ahora vuelven a
pasar por las paredes. Ahora, bajo el capó, se está disparando
algo. Se envía un mensaje
diciendo que estos tres enemigos
acaban de superponerse al muro Pero como no es una interacción
física, es solo una notificación y esencialmente una
observación de que
estaban pasando por
el mismo espacio. Se puede
pensar en bloquear versus superponerse como
un juego de carreras. Queremos que las paredes y los alrededores
bloqueen los vehículos. Te chocas contra ellos,
te detienen. Queremos que los puntos de control se
superpongan. Obviamente queremos
saber si un vehículo ha
pasado por un puesto de control
y a qué hora pasó eso, pero no quisiéramos que esos
puntos de control comiencen a bloquear
físicamente los
autos para que no procedan Eso solo sería un
poco molesto. Entonces, si volvemos
al enemigo peón, eso fue solo para mostrar
cómo funcionan de manera diferente También tenemos la tercera
opción. Tenemos la opción de ignorar. Ahora bien, esa
probablemente sea bastante obvia. Eso configurará esto para ignorar
todo tipo de colisión. Podría hacer eso, por ejemplo, yendo a la opción de no
colisión, y aunque
parezca que esto está diciendo
que está configurado para bloquear, esto en realidad está en el código, leyendo la opción Ignorar. Ahora, no habrá
ningún mensaje despedido. Nada sabe realmente que el
avión está atravesándolo. Y esto es bueno para objetos que no necesitan ser agregados a la pila de llamadas y a la pila de
comprobación de colisiones . Tan
bueno para el rendimiento. Pero en general, vamos a
estar trabajando con solapamiento o bloqueo dependiendo de lo
que necesitemos que hagan. En este caso, podemos
establecer esto de nuevo a su valor por defecto, que
es bloque dinámico. Eso lo he hecho con
solo presionar aquí. Se puede ver la flecha pequeña. Si alguna vez quisiste restablecer
las propiedades a su valor predeterminado, podemos simplemente presionar esto,
y esto se remonta a lo que era antes de que
estuviéramos ajustando las cosas Con la malla estática
aún seleccionada, queremos desplazarnos hacia
abajo aún más en el panel de detalles de la
derecha a la parte inferior. Y
aquí tenemos estas opciones, los eventos. Ahora, no vamos a
pasar por todas ellas. Las cosas en las que estamos de nuevo, la
mayoría de las veces nos van a
interesar serán el hit on component. Esto sucede cuando dos
cosas se
bloquean físicamente entre sí y en el
componente comienzan a superponerse, y a veces en la superposición del extremo del
componente. Estos se llaman cuando
dos objetos superpuestos, ya sea entran o salen de cada uno. Así podemos obtener la superposición final
porque como hemos visto, las colisiones
superpuestas
permiten que los objetos habiten el mismo espacio físico Queremos unir
nuestro control de pared a la función de inicio de
golpe del componente on aquí. Esto crea un nuevo
evento de cliente para nosotros, por lo
que función, que llama cada vez se detecta
una colisión
en nuestra malla estática. Entonces, si recuerdas,
cada vez que hemos creado nuestra clase y teníamos esa función predeterminada que realmente no
necesitábamos la verificación de la función hit actor
que siempre hemos eliminado. Eso fue esencialmente
algo similar, pero como he mencionado,
para toda la clase. Mientras que ahora podemos afinar
y
verificar específicamente solo que la
malla estática ha sido golpeada, entonces podemos hacer
algo después. Estos nodos en realidad proporcionan
bastante información. Por ejemplo, si
hacemos clic derecho sobre el pin de estructura de golpe aquí y
seleccionamos
la opción para dividir la estructura podemos ver toda la información
que podemos recuperar cada vez que algo nos
golpea o
golpeamos algo. Podemos
averiguar la hora. Podemos averiguar si el
bloqueo fue exitoso. Podemos ver la
ubicación real del golpe y el punto de impacto. Podemos obtener cosas como
la rotación de esto, el tipo de
material físico, y así sucesivamente. No necesitamos todo esto en este
momento, pero es útil, de
nuevo, a medida que empiezas a ser más avanzado y cómodo
con lo irreal, si quieres hacer cosas elegantes
con cosas como la penetración de
balas o el tipo de resultados que ocurren
cuando dos cosas chocan, definitivamente
puedes sumergirte
aquí y ver qué hay disponible Justo a la derecha, haga clic en cualquiera
de estos pines, aunque, recombine el pin de estructura
solo para ordenar este nodo Las principales cosas con las que tendemos a trabajar cuando
trabajamos
con colisiones, vamos a querer
conocer un poco de información sobre
el otro actor, porque por el momento,
no sabemos qué nos ha golpeado Sólo sabemos que nos han
atropellado cuando esto se llama. Podría ser el
muro, podría ser un jugador, podría
ser otro enemigo. Entonces esto va a ser
útil para leer más adelante, así que bien podemos promover
esto a una variable ahora, y llamaremos a este
actor de éxito. Y es por eso que solo quería
tomarme un momento rápido para pasar por diferentes
formas que incluso
podrías considerar
acercarte a resolver este problema,
averiguando qué nos golpeó. En muchos proyectos estudiantiles con los
que reviso y trabajo, veo mucho casting porque muchos
tutoriales muy básicos que puedes encontrar en línea tienden a
volver a mostrar cómo lanzar
a otros objetos porque es una forma rápida y sencilla de
obtener información. En nuestro proyecto, esto es relativamente pequeño y
sencillo lo que estamos haciendo, así que
en realidad no se vería tan mal. Pero si tuvieras que
ir por esa ruta, podrías tener algo que
acabe luciendo así. Sólo voy a hacer un
corte rápido. Corte rápido. Como dije, esto es esencialmente con
lo que terminarías. La forma en que funciona un elenco, y
quiero presentarles
al casting de todos modos, la forma en que
funciona el casting es que cuando estamos trabajando con
nuestro otro actor, si destacamos
sobre el pin aquí, en realidad
podemos ver
lo que se está devolviendo. Entonces voy a golpear compilar. Y coloco cursor sobre la información del otro
actor Esto nos está demostrando
que esto está proporcionando una referencia de actor. La razón es que, si
recordamos de nuevo a jerarquía
de herencia de
Unrelengins, todo con lo que
podamos interactuar en el mundo que tenga
presencia física, que se transforme necesita
ser de actor Entonces, al proporcionar un pin aquí, que es el objeto más básico que podemos encontrar en
el mundo, un actor, podemos asegurarnos de que podemos
verificar contra todo y luego afinar específicamente
en qué tipo de actor, qué funcionalidad extra
y características que tiene. Ahora bien, la forma en que podrías
hacer esto, o lo he visto mucho tiempo en muchos
tutoriales es que te
enseñarán a
tomar algo así como al actor que has golpeado
y lanzamos contra eso. Y lo que esto es esto es
esencialmente una pregunta. Es decir este actor genérico, puedo ver que el
actor genérico existe. Es específicamente el
tipo de base de peones, que para nosotros es el jugador Si lo es, entonces esta es
la verdad, el sí, es una base de sartén, entonces
haz esto aquí. Entonces llamaríamos a la función
específica de la clase de jugador, que como he mencionado, es aplicar daño al jugador
y luego auto distraerse Si no lo es, así que si ya
hemos hecho ese cheque, y vuelve como no siendo
el jugador al que le hemos pegado, entonces hemos pegado a otra cosa.
Entonces iría a emitir f. Y entonces verás a la
gente hacer un segundo elenco. Entonces nos ponemos como una cascada de casting en
cascada, que es desordenada Y si nos metemos en proyectos
mucho más grandes, se
puede ver que solo tenemos
tres cosas a considerar. Pero si tenemos
cosas diferentes como camionetas y obstáculos y muchas otras cosas que
podríamos necesitar considerar,
vamos a obtener una cascada en cascada mucho
más grande Pero lo siguiente que podrías
hacer de nuevo es que vamos a volver aquí y
decir ese objeto genérico, el actor genérico, ¿es
específicamente un enemigo? Si es así, entonces
haremos las cosas del enemigo, que por el momento, no
he decidido cómo
manejaremos a los enemigos. Creo que van a pasar por
fases entre sí, pero tenemos que hacer esa función. Si no, entonces volveremos a verificar. Entonces podríamos lanzar
a algo como el volumen de bloqueo si las
cosas están bloqueando el volumen, si eso es cierto, entonces sí, hemos chocado contra una pared, y
cambiaremos de dirección. Entonces esta es una manera de
que lo veas hecho. Puede haber sido como
consideras
hacerlo si eres consciente de
lo que hace el casting. Y solo quería pasar por una especie de resumen general de por qué no vamos a
hacer esto y por qué deberíamos tratar de
evitarlo donde sea posible Es otra cosa que
se repite muy fácilmente como la
declaración general general general de nunca usar tick. Escucharás a la gente decir que
nunca uses el casting. De nuevo, eso es
realmente simplificado. Hay un montón de razones por las
que nos gustaría usar casting donde pueda ser completamente seguro y
muy barato de hacer. Está un poco fuera
del contexto para este tema. Entonces por el momento, sólo
vamos a decir,
voy a borrar estos. No vamos a estar haciendo esto
puramente porque
no queremos este efecto cascada en
cascada Donde estamos comprobando por objeto. Entonces, para mantener las cosas simplificadas, voy a
dividir esto en dos cosas diferentes para este proyecto que
prácticamente queremos verificar. Queremos verificar el muro, y queremos verificar
por el jugador humano. Creo, solo por el diseño del juego
y para que se sienta mejor, creo que voy
a dejar que los enemigos se atraviesen entre sí para
que el jugador solo tenga
que considerar en qué dirección
van entre el
impacto con las paredes. Entonces esto realmente se convierte en
ellos realmente, muy simples. Podemos hacer un
chequeo muy sencillo para empezar. Podemos hacer clic derecho
en el gráfico de eventos, y podemos
buscar Obtener peón jugador Entonces esta es una función incorporada. El motor Unreal siempre está rastreando lo que está clasificado
como el peón del jugador, que es lo que está controlando el jugador
humano Entonces, cuando presionamos
play, ese sería el barco azul. Entonces,
¿qué podemos hacer aquí? Esto evita el casting, que
es una cosa útil. No necesitamos sacar toda la información
de esa otra clase. Esto también significa
que si tuviéramos más características como dejar que el jugador elija entre cinco clases de
planos diferentes con barcos completamente únicos, nuevamente, no necesitaríamos verificar cada barco único Sólo necesitamos saber que lo que
hemos golpeado es un barco jugador, y lo sabríamos
de este cheque de aquí. Entonces podemos sacar de esta papelera, y podemos buscar dos iguales, así que solo dos signos iguales. Y sólo voy
a desenganchar esto para que sea un
poco más legible Engancha esto de nuevo.
Sólo podemos decir, ¿Es el actor de éxito? Entonces, ¿con lo que
acabamos de chocar, es eso también específicamente lo que controla el jugador Entonces podemos sacar de
nuestro booleano aquí. Podemos buscar una sucursal.
Podemos enchufar esto a nuestro pin de ejecución y un bonito simplificando el código con el que
tenemos que verificar. Entonces, si lo que
hemos golpeado es el jugador, si eso es cierto, entonces
vamos a hacer lo nuestro daño. Así que tal vez solo queramos una cadena de impresión aquí para
recordarnos que volvamos. Entonces voy a lanzar una
cadena de impresión porque no tenemos funciones de
daño y
cosas así todavía, pero voy a hacer esto grande y audaz para que cada
vez que esto suceda, esto nos recuerde que
volvamos y cambiemos el código. Entonces aquí sería donde
aplicamos daño al jugador. Y entonces la destrucción de nosotros mismos es
realmente simple Sólo tenemos que llamar a la
función destruir actor. Podemos tirar eso
aquí. Y eso es en realidad parte del conjunto de
características, ya hecho. Entonces ahora si dejara que los aviones
enemigos volaran hacia abajo, estarían listos
para aplicar daños, aunque no tenemos salud
y todo todavía de todos modos, y luego se van a
destruir a sí mismos. Ahora bien, fuera de la rama falsa, nuevo, en realidad
realmente bastante simple, eso ahora nos dice que
si vamos a permitir que los enemigos
se crucen entre sí, entonces no estamos
preocupados por eso, lo que significa que si golpeamos algo más, eso va a
tener que ser un muro. Esa es la única
otra cosa con la que
podemos chocar
en este proyecto Entonces podemos hacer eso desde
la falsa rama aquí. Y lo que queremos
hacer es que vamos a poner el movimiento let. Entonces voy a enchufar esto
en el pin de ejecución. Mueve esto aquí abajo. Y nuevamente, solo para considerar la forma en que
podrías hacer esto. Cuando te estás acostumbrando
al flujo de código, podrías tener la tentación de
lanzar un Banchon así que solo estoy agarrando
del pin de ejecución Esto conectará estos
automáticamente, y podrías hacer
algo como esto. Así que comprueba el valor de mover a la izquierda. ¿Nos estamos
moviendo actualmente a la izquierda? En caso afirmativo. Entonces, si left es verdad, entonces
queremos que esto sea falso, y si left no es cierto, entonces queremos que esto sea
volteado y convertido en verdadero Así que esa es definitivamente una
forma en la que podrías hacerlo. Pero de nuevo, solo quiero
cómo una
forma agradable y limpia de que podamos hacer esto. Entonces, si volvemos a enganchar esto aquí, podemos sacarlos por el camino. Voy a borrar
estos, de hecho, de nuestro booleano aquí,
voy a tirar,
y voy a buscar algo que se llame una bola de nudos o una no La forma en que esto
funciona es básicamente, si esto es cierto,
esto devuelve falso. Si esto es falso,
esto devuelve verdadero. Entonces podemos tomar este valor, y esencialmente
siempre va a voltear lo que sea que esté encendido el booleano
actual Entonces, si nos movemos a la izquierda, nos
hará movernos a la derecha, y si nos movemos a la derecha, nos
hará movernos a la izquierda. Entonces una
versión agradable, simple, de un liner de lo que podría haber sido una
estructura de rama extra que no
necesitábamos. Y
eso es prácticamente todo. Esa es nuestra salud
siendo
contabilizada cuando lleguemos a ese
tema un poco más tarde, la destrucción al
contacto con el jugador, y luego voltear la
dirección cuando chocamos contra una pared Entonces, si volvemos a entrar,
presionamos play, podemos ver que actualmente están
rebotando entre sí, lo cual supongo que sería una implementación
perfectamente fina, completamente depende de ti Y luego si
golpean al jugador,
podemos ver en la parte superior
izquierda, se estaba llamando
la cuerda de impresión,
y se están quitando. Entonces va a
bajar a otra vez, el diseño. Si quisieras que
rebotaran el uno del otro, podemos dejar esa
funcionalidad en. Si quieres que se pasen
por fases entre sí, lo mostraré cuando nos
adentremos más en los temas de colisión
un poco más tarde. Pero eso es todo. Ahora tenemos
una implementación de trabajo. Y como mencioné, la razón por la
que esto está funcionando es cada vez que
se detecta una colisión en esta clase ahora, ésta
se disparará automáticamente. Es rastrear toda
esa información sobre lo que se ha golpeado
y lo que ha sucedido, y luego estamos
extrapolando de esa información lo que es
relevante solo para nuestro proyecto Vamos a hacer
algo bastante astuto con los proyectiles, así que tampoco tendremos que dar cuenta proyectiles cuando
golpeen Eso va a ser manejado
en el código del proyectil. Entonces todo lo que el enemigo necesita
saber es el jugador
y las paredes, que en realidad es otro principio de
programación, que es realmente
importante, especialmente en lenguajes como C plus plus, y blueprint porque
esencialmente todavía se basa en ese flujo de trabajo en el verdadero engem El concepto general es
que tratamos de hacer una clase lo más específica
y pequeña posible. Entonces está destinado a hacer una
cosa y una cosa bien. Un ejemplo de mal código
en una clase enemiga
sería rastrear qué pastillas pudo haber tenido
el jugador, verificar cosas como qué
proyectil acaba de golpearlo, cuánto daño debería aplicar ese
proyectil,
y cosas así, porque
esa es la lógica a la inversa Todas las cosas que tengan que ver con el daño de un
proyectil deben almacenarse en el proyectil y esa información debe
transmitirse El enemigo sólo debe
estar considerando y responsable de las cosas relacionadas con el
enemigo. Y en este caso, eso es mover y golpear paredes, entidad
muy sencilla. Entonces solo otro
vistazo rápido a lo que se clasificaría como codificación
limpia es
esa encapsulación de asegurarse de que su clase, en general, la regla es, como he dicho, hacer una
cosa y hacer una cosa Sin embargo, con esa configuración
y lista, ahora
tenemos una clase completa
lista para reestructurarse Entonces, a continuación, vamos
a ver el tema de la herencia. Esta será una mejor
manera de manejar mucho código
compartido y
características que
actualmente estamos viendo en el
enemigo y en el jugador. Hemos estado duplicando
mucho trabajo, así que va a ser el
momento de arreglarlo
13. 12: Clase base de la herencia: Es hora de arreglar el desorden
que hemos hecho. Hemos duplicado la configuración de la malla. Estamos manejando
el movimiento de manera diferente, pero siguiendo la
misma lógica estructural dos veces. Esto parece
pequeño en este momento. Pero cuando lleguemos a sumar
salud, destrucción, efectos, todo esto
empezará a agrandarse. Cada característica compartida significa el
doble de trabajo para nosotros, pero también
significa potencialmente el doble de errores. Dentro de la
clase de peones también, actualmente
estamos usando
toda la malla como colisionador, lo que realmente no es ideal
para este tipo de juegos La mayoría de los tipos de
juegos de acción ICD como este en realidad usan un truco para hacer que
el jugador se sienta un poco más inteligente de
lo que realmente puede ser Cuando piensas que has
esquivado algo hábilmente, pero en realidad acabas de
raspar por eso se siente bien,
pero eso es porque tu
colisionador es probablemente un poco más pequeño que
el colisionador del enemigo Vamos a querer implementar algo
así para que nuestro juego empiece a
sentirse realmente interesante
para interactuar con él. Sólo una forma menor de manipulación
psicológica, pero hace que el juego se sienta justo, incluso cuando las matemáticas
dirían lo contrario. La forma en que resolveremos
esto es usando un
colisionador de esferas como la nueva ruta
en lugar de la malla La malla solo actuará como decoración
completamente
libre de colisiones. Ambas clases necesitarán esto, así que también
podemos construir
esto solo una vez y compartir componentes y características como esa en
todas las clases. La forma en que hacemos esto es con algo
llamado herencia. He mencionado antes,
el UnrelEngine es una pieza de software muy
basada en herencia, así que seguiremos el
mismo tipo de convenciones Básicamente significa que
podemos codificar algo una vez en lo que se llama una clase
padre o una clase base. Entonces podemos hacer
clases secundarias de eso, que heredarán todos
los componentes, las características, los
sistemas que ingresamos Por ejemplo, hemos visto a los
actores proporcionar una transformación, una
escala de rotación de ubicación en el mundo, y luego los peones toman
esa información y construyen sobre ella
con que se les da la mecánica a
poseer y muchas
otras cosas .
Ya basta de platicar. Veamos esto en acción.
Entonces empecemos a crear nuestra nueva clase base que nos
ayudará a ver el
sistema en la práctica. Si volvemos a los
blueprints y a la carpeta core, vamos a crear
algo completamente fresco Un clic derecho en la
ventana, volveremos a ir a la clase
Blueprint y
crearemos un peón completamente nuevo Voy a cambiar esto de llamarse Peón subrayado
algo a BP subrayado plano base en lugar Todos van a ser
aviones, así que
bien podemos ser claros con nuestra convención de
nomenclatura aquí Dentro de nuestra nueva clase,
subiremos a los componentes, y vamos a agregar ese componente de
esfera que mencioné. No estamos buscando a
este de aquí. Se trata de una esfera visual sólida de tres D. Sólo queremos un vínculo colisionante. Si buscamos
la palabra colisión, podemos ver aquí tenemos
algunas opciones diferentes. Queremos nuestro colisionador de esferas, que aplicará esto justo aquí, y podemos hacer
lo mismo que hemos hecho antes Podemos arrastrar esto a
la raíz de escena predeterminada para hacer de este nuestro
nuevo componente raíz. Luego podremos volver
al botón Agregar. Todavía queremos nuestra malla estática. Esto simplemente
ya no estará
manejando colisiones . Volveremos a hacer lo
mismo. Vamos a ir a nuestra
malla estática por aquí y
seleccionaremos nuestro héroe de avión de
subrayado SM Con la malla estática
aún seleccionada, podemos bajar a la sección de
colisión por aquí, y en realidad podemos
usar este menú desplegable y decirle que no haga ninguna
detección de colisión en absoluto. También podemos desactivar el
solapamiento generar eventos. Esto solo asegúrate de que
no se esté comprobando nada contra la
malla estática en ningún momento. Perfecto porque queremos que
esto sea visual. Significa que no necesita
agregarse a la pila de colisiones. Es sólo que se sentó
ahí siendo renderizado. Si seleccionamos nuestro colisionador de
esferas, también, podemos hacer un
par de cambios aquí Si volvemos a colocar esto
en el lado derecho en la sección de colisión, queremos cambiar esto
de superposición o dinámico, y en realidad podemos hacer que esto sea
más distinto que eso, y diremos que esto se
clasifique como una colisión de peones Entonces veremos que
esto cambia el preset de colisión a peón El tipo de objeto ahora se
rastrea como un peón, y se hace algunas
cosas por aquí No lo vamos a dejar en esto si quisiéramos flexibilidad total. Tomaremos esto como
el preajuste predeterminado, pero podemos personalizarlo soltando
esto nuevamente y
seleccionando personalizado. Entonces todavía tenemos
este conjunto como peón. Todavía tenemos la configuración de colisión
habilitada como queremos, y tenemos todo
esto configurado por defecto. no se superponga a Sin embargo, podemos encontrar que queremos
volver
y hacer que esto otros peones
ni bloquee otros peones, haga algo diferente
con la estática mundial, y ahora tenemos la
opción de
cambiarlos si quisiéramos.
No vamos a hacer eso ahora mismo. Lo haremos
en base a las pruebas y a ver cómo se desarrolla el proyecto Con eso hecho, esto
nos está poniendo en una muy buena
posición, sin embargo. Ahora todas las clases secundarias heredarán este conjunto. Entonces esto significa que hemos
configurado esto una vez, y realmente nunca necesitamos volver
a pensarlo. Así que ahora podemos empezar a mirar nuestra funcionalidad compartida
también en el evento grab, el tipo de cosas
que queremos
compartir entre las dos clases. Como siempre, vamos a agarrar el evento para comenzar a superponerse
y eliminar este. Y para el movimiento,
hay algunas cosas a considerar. Una vez más, puramente basado en la recreación
del proyecto de ejemplo que estamos tratando de alcanzar algún nivel de paridad hay
una pequeña característica si realmente
miras lo que está sucediendo donde los aviones y
el jugador no se mueven
ni alinean el movimiento al
inicio de ellos engendrándolo Tocan una pequeña
animación. Animan hasta la pantalla por
tal vez uno o dos segundos, y luego permiten que el
movimiento vaya de lado Entonces vamos a hacer
algo muy parecido. Vamos a congelar o pausar cualquier entrada de movimiento hasta que se despliegue esa
animación. Llegaremos a las animaciones
en la sección polaca, pero solo necesitamos otra vez, pensar con anticipación en lo que
vamos a necesitar dar cuenta y ya podemos
programarlo. Entonces comencemos con
eso. Vamos a querer hacer algunas muy simples, lógicas si y comprobar. Entonces, si sacamos de
nuestro pin de ejecución, vamos a
buscar una sucursal. Y de la sucursal, aquí podemos
tomar la condición. Promovemos esto a una
variable de inmediato. Llama a éste B,
movimiento habilitado. Pulsaremos Compilar y nos
aseguraremos de que esto esté
por defecto a true Entonces, si el movimiento está habilitado, que vamos a
querer hacer mientras
solo estamos depurando antes de
tener esa animación establecida,
yo el movimiento está habilitado, entonces permitiremos el enemigo vuele de lado a lado
y se mueva hacia abajo en la pantalla, y permitiremos que
el jugador vuele lado a lado en base a la entrada Si no, entonces eso significa que
probablemente estemos en la animación, y llamaremos a la
función falsa aquí y evitaremos que ocurra
cualquier movimiento.
Entonces esto solo nos prepara. Más adelante, cuando lleguemos
a esas características, pensando en el futuro, no
necesitamos refacturar completamente
el código de nuevo Lo siguiente es que ambas clases necesitarán algún tipo de movimiento. Pero como mencioné,
estamos programando el movimiento de
manera ligeramente diferente, así que no podemos compartir el código de movimiento
real porque no se está utilizando el mismo
tipo de movimiento. Pero lo que podemos hacer es compartir el flujo lógico y los conceptos de la
funcionalidad que necesitaremos. Podemos hacer esto echando
un vistazo a las funciones ahora. Entonces en el lado izquierdo,
tenemos esta
categoría de función justo aquí. Algo así como eventos,
podemos crear nuestras propias funciones personalizadas, y luego solo
tendremos llamada lógica cuando esa función se
llama de la misma manera que hemos estado haciendo
con eventos en el pasado. Entonces si presionamos plus aquí,
y voy a llamar a esta nueva función hemos
hecho movimiento de mango. Y puedes ver una de
las diferencias aquí y en realidad uno de
los beneficios centrales de usar funciones sobre eventos es que hacen lo mismo. Responden a ser llamados, pero aquí obtenemos nuestra
propia gráfica de funciones. Entonces está un poco
escondido, y otra vez, manteniendo las cosas bonitas y ordenadas. Ahora, en realidad no vamos
a manejar ninguna de las
funciones de movimiento aquí dentro. La forma en que se
usará esto es que vamos a anular esta función en
nuestras clases secundarias más adelante, pero necesitamos que esto exista para tener algo
a lo que llamar. Lo que sí queremos hacer es que
vamos a volver
al gráfico de eventos. Queremos tomar nuestra función de movimiento de
mango. Y sólo vamos a
dejar caer eso en el verdadero pin. Entonces, si un movimiento está habilitado, entonces vamos a llamar a la función de movimiento del
mango. Así que de nuevo, se vuelve
agradable y legible. Y cuando lleguemos a implementar esto
realmente, podemos hacernos una idea de exactamente lo que va
a estar sucediendo. Entonces esto es algo
simple por ahora. Verás que esto se despliega
y tendrá mucho más sentido cuando realmente empecemos a
implementar las cosas Esta es una de esas cosas en las
que podría intentar pasar cinco a 10 minutos describiendo
lo que haremos después, pero creo que solo
tendrá mucho más sentido simplemente implementarlo a medida que avanzamos. Otra cosa que
ambas clases simples van a necesitar al enemigo y
al jugador y jefes
o lo que sea que
quieras comenzar a heredar
de esta clase, todas
van a necesitar ser destruidas o
matadas en algún momento Así que mientras estamos aquí, también
podemos ir y
agregar otra función, y voy a llamar a esta
manejar muerte. Nuevamente, no vamos a poner
nada aquí justo ahora, sino una cosa que podemos
hacer con esta función, las cosas genéricas como todo va
a necesitar para reproducir un efecto de sonido o un
efecto de partículas cuando mueren. Eso podemos hacer aquí en
esta clase porque esa es una función
universal. Eso es algo que independientemente
del tipo de avión, todos
necesitan mostrar algún tipo de retroalimentación
cuando eso suceda. Entonces podemos hacer la
funcionalidad universal aquí. Y luego, si hay
algo único el plano individual, entonces podemos anular de nuevo la funcionalidad que está
sucediendo aquí y luego hacer algo
además de eso. Entonces solo una especie de
idea aproximada de cómo
funciona la herencia y cómo podemos hacer
uso de ese código reutilizable, ahorrándonos tiempo y
esfuerzo a medida que avanzamos. Ahora bien, lo último que
puedo imaginar que ambas clases
de avión necesitarán es la velocidad de movimiento. Y
como que ya lo sabemos. Si nos fijamos en nuestro propio código, una de las pocas cosas
que ambos tienen es si abrimos
sus dos gráficas de eventos, pan base, que es que el jugador tiene mucha más funcionalidad. Aquí hay muchas más
variables, pero sí tiene velocidad de movimiento. Y entonces la sartén es ligeramente
diferente, simplificada. Mientras que no estamos
haciendo el
check de movimiento a la izquierda en la versión del jugador, seguimos usando la velocidad de
movimiento. Entonces cosas como esta
son lo que estamos
buscando en nuestras clases base. Las cosas que hemos tenido que
implementar más de una vez es algo que
podríamos simplemente volcar directamente a la clase base. Entonces aquí, lo que voy a
hacer es crear una nueva variable llamada
esta velocidad de movimiento. Y cambiamos
éste a un flotador, él y pila, ahorra. Y en cualquier momento que podamos
necesitar usar esos
entre las clases, eso está disponible
y listo para funcionar. Nuevamente, en realidad no
necesitamos hacer uso de él todavía, pero esto es solo sentar
las bases para que tengamos una transición más suave y
agradable Y realmente, esa
es nuestra clase
base que se desarrolla tanto
como necesitamos ahora mismo Podemos regresar y
agregar cosas más tarde, pero tenemos los
componentes compartidos que necesitamos la colisión unificada, el movimiento listo para implementar en las clases secundarias individuales. Lo mismo para la muerte
y luego la
variable de velocidad lista para usar también. Así que solo para echar un
vistazo
muy rápido a cómo podemos hacer uso
de esta clase base, agregaremos la funcionalidad completa
un poco más tarde, pero una demostración muy rápida. Si volvemos a
nuestro sorteo de contenido, podemos hacer clic derecho
sobre la Base simple. Y aquí arriba,
tenemos la opción de
crear la clase infantil Blueprint Si hacemos clic en este, esto creará un nuevo
plano para nosotros. Esto heredará
todo de Base simple. Voy a llamar a este jugador de avión de
guión bajo BP. Y luego si hacemos doble
clic para abrir esta, podemos ver que esta
ahora viene preconstruida con nuestra esfera y
nuestra malla estática. También tenemos algunas otras
cosas aquí también. Si hacemos clic en la opción de anulación, podremos ver realmente
las funciones que hemos creado manualmente, manejar la muerte y
manejar el movimiento, específicamente desde
nuestra clase base. Si hacemos clic en estos, esto nos dará una
función que luego podremos comenzar a usar la
versión padres de la función, además, como he mencionado, haciendo lo
nuestro propio encima de eso. Nuestra prensa controla para
deshacerse de esa por nueve. Todavía no queremos hacer ninguna
anulación, y no necesitamos
cambiar nada todavía, pero también quería mostrarte otra forma de
que podemos ir agregando clases
basadas en las que tenemos Si vuelves al
sorteo de contenido una vez más, haz clic
derecho aquí, y esta vez, vamos
a ir a una clase de blueprint, algo que puede
no ser súper obvio Pero mucha gente piensa
que esto está restringido a clases de motores
irreales y a las
creadas por los desarrolladores
unrelengin Pero de hecho, tan pronto como
creamos una clase, en realidad
podemos encontrarlas aquí. Entonces si busco base lisa, podemos ver aquí llanura
Base es hijo de un peón y un peón como he
dicho, es hijo de un actor Y nuestro jugador llano está
en un hijo de base llana. Así que ahora podemos seleccionar nuestras propias clases de nuestra
lista de clases aquí en el editor. Entonces volveremos a seleccionar base
lisa. Seleccione éste. Y, por supuesto,
vamos a llamar a este avión
BP Underscore enemigo Entonces ambos ya están listos para funcionar a medida que comenzamos a dar cuerpo
a las cosas Solo quería
mencionar, también, que hay múltiples
formas en las que puedes hacer uso de tus clases base
cuando las tengas
listas y configuradas. Sin embargo, con eso hecho, la
clase base está lista. Como he dicho, tenemos
los componentes compartidos,
la funcionalidad compartida y la configuración unificada de colisiones. A continuación, vamos a
refacturar primero al jugador. Tomaremos el
grande, revisaremos el código grueso que
vamos a atravesar, y luego nos centraremos en
el enemigo
14. 13 - RefactoringPlayer: La clase ya está lista para comenzar.
Entonces ahora vamos a necesitar convertir a nuestro reproductor
para hacer uso de esto. Esto es lo que se conoce
como refactorización,
esencialmente reestructurando el código
existente sin cambiar lo que hace. Buscamos
el mismo comportamiento pero una mejor organización y reducir los gastos generales o reutilizados componentes de
variables y cosas así
cuando sea posible Realizado en el tema anterior por el que
acabamos de pasar, te
di instrucciones para
crear dos nuevas clases de avión. Hay otra cosa que me di cuenta en el medio
que podría ser útil estar al tanto y
de hecho nos
ahorraría un
poco más de tiempo. Entonces, lo que voy a
recomendar es que
eliminemos al enemigo simple
y al jugador llano. Para que podamos agarrar estos Shift
Select y presionar Eliminar. En realidad no hemos hecho
nada en esos de todos modos, así que no estamos perdiendo
nada, y al menos eres consciente de que esas
opciones están disponibles. Lo que sugeriría en cambio es que
si vamos a nuestra base de plano, y solo los cerraré
para no confundir las cosas, queremos hacer doble clic y abrir la clase base del plano en la
que hemos estado trabajando para
asegurarnos de que no has eliminado la clase base del plano Entonces con el avión Base todavía aquí, no
queríamos
deshacernos de esa. Lo que queremos hacer es
realmente hacer uso de las clases existentes y
simplemente moveremos las cosas
por donde necesitemos. Entonces lo primero es
enfocarnos en nuestro naming. Si nos enfocamos en el
jugador antes que nada, voy a cambiar el nombre de
éste a BP, subrayando jugador llano Y por eso
necesitábamos eliminar esas otras clases para
no tener conflictos de nombres El nombre de la clase estaba bien, pero podemos simplemente hacer
algo bastante inteligente aquí para hacer uso de lo que ya
tenemos en esta clase. Y haremos lo
mismo por nuestro enemigo. Entonces agarraremos este y llamaremos a éste BP subrayado
simple enemigo Y luego si hacemos
doble clic para abrir el jugador de avión de guión bajo BP, podemos empezar a hacer
nuestros cambios aquí Entonces, lo que pensé que
sería útil
saber es que en realidad hay
una manera realmente genial de que podamos cambiar lo que esta clase
está clasificando como su padre Entonces, por el momento, podemos ver a
la clase de padres como peón. Si venimos aquí
a la configuración de la clase y luego volvemos
al panel de detalles, podemos ver que tenemos la clase
padre aquí. El menú desplegable está configurado para peón. Si buscamos plano,
podemos cambiar eso para que ahora esté heredando de la base del plano de
subrayado BP Y esta es en realidad una manera bastante
agradable de refactorizar las cosas. Una razón es que nos
dará errores y advertencias sobre el código
que puede duplicarse. Y como que
ya podemos ver eso. Entonces, si miramos hacia
el lado izquierdo, podemos ver que tenemos
dos ensuciamientos estáticos. Cualquier cosa aquí que diga Editar en Blueprint o Editar
en C plus plus, si estás trabajando en un proyecto
C plus plus es una indicación de que esto se
hereda de una clase base Entonces, cuando veas esto, no
podemos entrar. No podemos agarrar los heredados y eliminarlos, así
que están atrapados aquí. Entonces, lo que queremos
hacer es que queremos
agarrar nuestro
subrayado de malla estática cero No necesitamos dos
mallas diferentes para nuestro avión, y podemos eliminar esta, así que simplemente borraremos eso aquí La otra cosa que podemos ver aquí es que tenemos algo llamado velocidad de
movimiento subrayado
cero en las variables Si escribimos, pincha sobre esto,
podemos ir a las referencias de búsqueda, y podemos encontrar a todos los miembros
actuales de esta clase. Si hacemos doble clic en
éste, eso nos
llevará directamente
a donde está este. Entonces, como he mencionado,
es una manera rápida y agradable poder ordenar
las cosas porque
solo podemos usar estos atajos
para saltar y encontrar las cosas restantes de las que podríamos necesitar
deshacernos. Y nuevamente, la razón por la que a
esto se le ha dado un guión bajo cero es
porque somos conscientes de que
tenemos algo llamado velocidad de
movimiento en la clase base y no podemos
tener la misma variable, aunque sea en una
versión hijo de esa clase Entonces volveremos a hacer lo
mismo. Eliminaremos esta. Simplemente eliminaremos la velocidad de
movimiento. Esto solo nos dice que actualmente
estamos usando esto, pero eso está perfectamente bien
porque sabemos dónde está eso. Y entonces lo que queremos
hacer aquí es que vamos a sacar de aquí y
buscaremos la velocidad de movimiento. Y podemos ver aquí
queremos obtener la variable de velocidad de movimiento, y esta es la de nuestra clase
base, la clase de emparejamiento. Y ahí vamos. Entonces
eso es más o menos todo. Ese es el tipo de clase
arreglado y listo para funcionar. Así que definitivamente podríamos
dejarlo aquí, pero hay algunas
cosas más de las que podemos hacer uso de la clase de padres. Entonces, lo primero
que siempre queremos dar cuenta es en
la jugada inicial, y tenemos que hacer en todas
nuestras funciones esencialmente. Pero para comenzar en nuestro start play, vamos a
hacer click derecho sobre el nodo, y queremos encontrar
esta opción aquí para agregar llamada a la función parent. Y queremos conectar
esto entre nuestra ejecución actual y la funcionalidad
que ya estamos llamando. Esto solo asegura que
los padres comiencen a
jugar a la lógica también se llama
cuando empezamos a jugar, es
decir, que si volviéramos a tener alguna lógica
universal que queramos hacer en
la clase padre, eso también se llamará. De lo contrario, esto solo
se llamará por sí mismo, e ignoraremos la versión de
los padres. Queremos hacer lo
mismo por el eventic. Vamos a escribir click
sobre esto, agregar llamada a la función
parent, y luego
simplemente conectar todo. Incluyendo los segundos Delta, tal vez necesitemos mover
algunas cosas por aquí. Y entonces podemos simplemente
enchufar esto por aquí. Y otra vez, arregla las cosas
si quisieras. Intenta ayudar a visualizar
esto por ti, la funcionalidad padre se
llamará primero. Entonces, por ejemplo, cuando nuestro
jugador se cree por primera vez, automáticamente hará
que su evento
comience a jugar
sea llamado una vez, y luego vamos
a
enviar inmediatamente un mensaje para buscar realmente en la versión principal y ver si algo está sucediendo
en ese comienzo de juego. Navega por aquí. Podemos abrir el plano padre
con este atajo aquí, y podemos ir a la jugada de
inicio por aquí, y podemos ver que no hay ningún código
real en este momento si tuviéramos
que hacer algo como sacar Sin embargo, si tuviéramos
que hacer algo como sacar
una cadena
de impresión de aquí, solo
diríamos que los padres comienzan y lo mantienen en la
pantalla por un momento. Lo que pasaría ahora
es cuando presionamos Play. Vamos a ver que padre comienza está impreso en la parte superior. Entonces podemos confirmar que
nuestra lógica padre, la lógica universal está, de
hecho, siendo llamada. Ahora el problema,
claro, es si añadimos esto a los enemigos, así que si entramos en la clase enemiga
llana, entramos en la jugada de inicio. Vamos a querer
hacer lo mismo. Vamos a hacer clic derecho, agregar una llamada de padres, y
vamos a enchufar esto aquí. Ahora, porque tenemos tres
enemigos y un jugador, vamos a ver ese
mensaje cuatro veces porque todos están llamando a
esa misma función. Por supuesto, necesitamos
hacer el mismo cambio en la configuración de la
clase enemiga. Cambia esto de
peón a base lisa. Bien. Entonces estamos haciendo lo
mismo. Sólo estamos reparando lo que esta
clase está Hit compilar. Entonces los cuatro están tomando
ese mismo proceso. Ahora bien, esto está bien, en este caso, pero aquí es donde quieres tener cuidado y empezar
a asegurarte de que estás considerando lo que
estás implementando. Entonces esto y no tendría sentido si este mensaje estuviera
diciendo algo así como, si esto fuera específico de lo que debería estar haciendo
el jugador, como gritar, yo soy el jugador Si le pegamos a compilar, eso
significa el jugador de avión, lo
llamaremos a eso, lo cual
está perfectamente bien. Pero así todos los enemigos. Entonces los tres enemigos también
están diciendo, yo soy el jugador, lo cual es
un poco confuso. Entonces aquí es donde hay que tener
cuidado con la herencia. Y por eso
sigo diciendo que
queremos nuestra
lógica universal aquí dentro. Cualquier cosa que esté
relacionada con ser un plano general
está perfectamente bien. Entonces, si esto fuera cada avión tenía anunciarse y solo decir, soy un avión, esto
estaría perfectamente bien porque los cuatro son de
hecho aviones. Como podemos ver, pero no
quisiéramos ningún código en la clase base que estuviera relacionado específicamente con el jugador. Entonces, ojalá, eso tiene sentido, y podemos
comenzar a ver cómo podemos usar la herencia y cómo
podemos compartir nuestras características, componentes y lógica
entre múltiples clases. Y así es como vamos a estar manejando las cosas
como destrucción. Podemos tener los efectos de
partículas,
los efectos de sonido todos se reproducen en la clase padre
porque eso no es específico de ningún plano. Todos necesitan ser
destruidos de alguna manera. Pero las cosas como el movimiento solo
somos un poco únicas, vamos a manejar eso en
las clases infantiles en su lugar. De vuelta al jugador llano. Vamos a terminar esto
primero que nada. Una forma muy rápida de
tomar el código, que sabemos que
ya está funcionando. Como ya he mencionado, todo lo que realmente
queremos hacer es asegurarnos de que no
tenemos esto tirado alrededor, y podemos hacer uso
de esa función que creamos hace poco tiempo Entonces si agarramos todo lo
relacionado con el movimiento, así que van a ser estos
nodos aquí, cálculo aquí, solo
estoy sosteniendo Shift y arrastrando y luego la ubicación del
actor aquí Esto sólo está
relacionado con la rotación, así que vamos a dejar
esta por ahora. Lo que queremos hacer es
que vamos a presionar Control y X para cortar, y vamos a hacer clic aquí para anular la función de
movimiento del mango. Entonces queremos la función que
hicimos antes, ese espacio vacío. Y luego vamos
a presionar el control V aquí y vamos a
enganchar todo de nuevo. Así podemos asegurar que nuestra función de
movimiento siempre
será llamada porque
estamos llamando a nuestro eventic Y si se
habilita el movimiento, entonces también se
llamará al
movimiento del mango desde ese eventic Entonces nuevamente, solo necesitamos
llamar a esta función una vez aquí, y podemos hacer uso
de esa
llamada de función en nuestras clases infantiles. Hemos movido esto, y sólo
voy a volver a entrar
en el gráfico de eventos. Vamos a mover esto por ahora, la rotación, y vamos a
enganchar esto de nuevo. Y solo probando a medida que
avanzamos, como he mencionado, esto es más para
mostrarte cómo podrías refactorizar el código por tu
cuenta si es necesario Y este es un proceso muy
común. Solo queremos probar estos
pequeños pasos a medida que avanzamos, y aún debemos tener habilitado
el movimiento. Entonces, si algo está roto,
permítanme verificar
qué podría ser eso. Si el movimiento está habilitado, si eso es cierto, estamos llamando a nuestro eventi Tenemos nuestro movimiento de mango
aquí, velocidad de movimiento. Así que me acabo de dar cuenta de que tenemos nuestra nueva
variable de velocidad de movimiento en la clase base, pero no
le hemos dado un valor a eso. Entonces, si agarramos nuestra
configuración de clase justo aquí, esto realmente nos
va a dar acceso a la
configuración de clase cuando
seleccionemos este elemento superior
aquí o la clase predeterminada Podemos ver que los valores predeterminados de clase
tienen las variables aquí, y podemos ver nuestra velocidad de
movimiento, y creo que estaba
configurando esto en
1,000 en el jugador. Así que
vamos a poner eso atrás. Y entonces deberíamos
poder ir y
presionar play y movernos. Entonces obtenemos el mismo movimiento,
obtenemos la misma rotación. Todo se siente igual. No hemos cambiado
la funcionalidad. Acabamos de ordenar
nuestra gráfica y dónde se manejan
las cosas Así que estamos asegurando que esto
se llame si y cuando
queremos y otro beneficio
realmente genial de dis ahora es que podríamos entrar. Podríamos desactivar el
movimiento habilitado, por lo que los movimientos
ya no están habilitados. Podemos presionar play, y ahora no
podemos mover el avión. Pero claro, rompe
la rotación porque
ahora nos estamos multiplicando contra un valor que realmente no hace nada Pero se puede ver que la
lógica es que estamos manejando
las cosas como
queremos que esto funcione. Y todo esto ahora se maneja
realmente en la clase base con respecto a los estados de movimiento habilitado
y desactivado, y solo estamos aprovechando
eso dentro de
la versión de jugador
de esa clase Así que asegúrate de que hacemos clic en esto. Vamos a asegurarnos de que movimiento esté habilitado
por el momento. Vamos a alternar eso
a través del código un poco más tarde cuando
lleguemos a la animación Recuerden que he dicho que no
vamos a estar agregando cosas como la rotación o fingiendo física y cosas
en la clase enemiga, razón por la
cual no estamos
reutilizando exactamente el código de movimiento Otra cosa que los
enemigos no van a tener es la lógica de rotación real que
tenemos aquí por esa razón. Algo que podríamos
hacer, sin embargo, para mantener iguales
las convenciones de nomenclatura y
el estilo general Hay otro consejo
que quería mostrar. Podemos agarrar todos estos nodos en
una selección
de desplazamiento de prensa
para agarrar estos nodos. Y luego si hacemos clic derecho sobre cualquiera de los nodos que
hemos seleccionado aquí, podemos optar por colapsar esto
a una función propia. Y sólo vamos
a llamar a éste. Probablemente puedas adivinar. A esto le vamos a llamar rotación
de un mango. Agradable y obvio. Si tenemos que bucear a través de esto y comenzar a
leer nuestro código, vendríamos del festival de base de
aviones, y podemos ver que si
el evento marca funcionando, si tenemos el movimiento habilitado, manejamos el movimiento,
y luego esto
saltará de la clase base. Entonces, una vez hecho
esto, esto
nos devolverá a nuestra clase infantil. Entonces esto ya se ha
manejado. Se llamará al pin de ejecución, y luego
comenzaremos a llamar a esto. Entonces estamos manejando el movimiento
si el movimiento está habilitado, y luego estamos
manejando la rotación, nuevamente, si el movimiento está habilitado. Exactamente los mismos resultados si
vamos y presionamos play,
nada ha cambiado. Solo estamos haciendo que esto sea mucho
más legible, mantenible Nos estamos deshaciendo de
ese código de espagueti o incluso
del potencial de que eso suceda aquí porque tenemos el control total de nuestra base de código y cómo
queríamos que esto funcionara. Estamos haciendo uso de la herencia, así que estamos ahorrando mucho tiempo cuando llegamos a
agregar nuevas características. Por el momento, esto
podría parecer un trabajo ocupado, pero
definitivamente te ahorraría
mucho tiempo a largo plazo, entendiendo qué está
haciendo esto y cómo aprovecharlo. Oce estamos aquí, si estás
dentro de la base del avión, si estás
siguiendo exactamente, podemos deshacernos de este mensaje que describe
lo que es la clase Sólo nos desharemos de
esa. Se compilar en. Enemigo se irá por ahora
y solo verificará que todo esté guardado
en la clase de jugador, y ese es el refactor
del jugador hecho Entonces se puede ver que en
realidad no fue tan doloroso. Me tomó un poco más de tiempo
sólo porque quería explicar estos conceptos y
dejarlos claros a medida que avanzamos. Si lo estuviera
haciendo yo solo, probablemente habría
sido una tarea de 1 minuto. Entonces, incluso refactorizar y reconsiderar
completamente cómo se
maneja
la estructura de las clases realmente no
necesita tomar tanto tiempo, sobre todo si estás pensando
temprano en el desarrollo, razón por la
cual estoy tratando de
enfatizar esto a medida Intenta
tomar estas decisiones por adelantado, y es la
diferencia de tener
un refactor de 1 minuto
a un refactor de 1 hora Si estás probando tu código y algo está roto
o no funciona, solo verifica que todas las llamadas de tus padres estén conectadas. Entonces estos padres llaman aquí, los nodos naranja están
conectados y se les llama en el start play,
el tick del evento, y así sucesivamente. De igual manera, asegurarse de que
las cosas sean el movimiento habilitado está marcado tanto en la clase base aquí
como lo más importante, a través de este valor aquí arriba,
como acabo de mostrar, solo un par de
trampas ahí, en las que
puedo imaginar que algunas personas
podrían caer Así que solo revisa dos veces las cosas que
hemos ido cambiando. Para el siguiente tema, claro, vamos a
saltar a lo mismo, pero para el enemigo
y debería tomar un poco menos de tiempo. Ahora ya
hemos visto cómo hacerlo aquí.
15. 14: Refactorización del enemigo: Refactorizar al enemigo.
Ya lo hicimos una vez. Debería ir un poco más rápido. Obviamente, si
aún no tienes esto abierto, vamos a asegurarnos de
abrir la clase enemiga llana. a verificar aquí si
aún no has hecho el cambio
que tenemos esto
reiniciamos la clase padre aquí
a BP subrayado plano base Recuerda, podemos
hacerlo a través de la
configuración de clase y el
menú desplegable justo aquí. Las mismas cosas otra vez
que con el jugador. Vamos a eliminar
la malla estática, lo que nos va a dar un
pequeño problema aquí. Sólo diremos, Esto está
bien, así que haremos clic en sí. Esto me ha bajado directamente a
donde está el problema,
y es que hemos vinculado la función de
golpe del componente anterior, esa comprobación de colisión a
la malla estática original. Eso en realidad no es un problema porque queríamos
arreglar esto de todos modos. No queremos usar la
malla como colisionador en cambio vamos a tomar
el componente esfera aquí, así que vamos a agarrar este, y queremos volver a hacer lo
mismo Entonces en el lado derecho
en el panel de detalles, solo
dejamos caer esto. Vamos a encontrar la función de cadera
en componente y crear un enlace a esto. Y eso es todo lo que está haciendo esto. Es solo vinculante
cada vez que ocurre una acción, está vinculando esta función
para luego ser llamada. que podamos eliminar éste,
enganchar las mismas cosas, así pin de ejecución y pin de actor, y esa es la parte inicial
de ese problema resuelto. Entonces sólo voy a
saltar rápidamente al viewport. Vamos a agarrar
la malla estática, y queremos asegurarnos de que estamos actualizando el material. Entonces nuevamente, en el elemento cero aquí, este es el que controla
el cuerpo del plano. Vamos a bajar esto,
y ahora podemos encontrar el otro material que
quizás hayas hecho para tu enemigo, que para mí es solo MI
subrayado avión enemigo Selecciona esa, y estamos prácticamente de vuelta donde estábamos. Lo mismo con la velocidad de
movimiento también. Queremos hacer
click derecho sobre esto, encontrar las referencias del miembro de
la clase solo para asegurarnos de
deshacernos de todos estos. Podemos hacer doble clic en uno de estos y ver dónde se
están utilizando. Podemos ver que tenemos algunos de estos para asegurarnos de que en
realidad no nos perdamos ninguno cuando estamos tratando de volver a enganchar
las cosas. Solo voy a
hacer clic derecho en el
gráfico de eventos de aquí abajo,
buscar la velocidad de movimiento, y aquí vamos a obtener la variable de velocidad de
movimiento, la que se creó
en nuestra clase padre. Engancha esto aquí, duplica
esto, engancha esto aquí abajo, quítalos solo para ordenar un poco
las cosas, y haz doble clic en la final
, que está por aquí. Y nuevamente, sólo
vamos a hacer clic derecho y buscar la velocidad de movimiento. Vamos a establecer
la velocidad de movimiento aquí, y luego
enchufaremos esto. Deshazte de eso, y volvemos a donde estamos. Ahora bien, hay una opción, que no
quería mencionar porque me pareció un
poco juguetona De hecho, en la versión actual, simplemente no parece funcionar. Pero algo que
podría ser útil si arreglan esto en el futuro, es que en el pasado,
hemos podido hacer click derecho sobre la variable. Podemos seleccionar aquí para
reemplazar referencias. Lo que me falta
en este momento, no
sé a dónde han ido
esas características. Normalmente puedes desplegarlo, y podríamos haber encontrado la variable de velocidad de
movimiento creada en la clase padre. Por cualquier razón, solo
puedo acceder a variables del actor
y del peón directamente, no a la base real de reclamo de
subrayado de BP, aunque debería poder hacerlo Pero solo
para decir, por esas razones, tal vez solo necesitemos
pasar y hacerlo de
la manera un poco más manual que
solo tenemos los quitados, recuerda deshacerte
del
subrayado de velocidad de movimiento cero Ya no deberíamos estar usando
eso en absoluto, y luego simplemente presione compilar para asegurarnos de que
todo haya pasado. Lo mismo con el jugador. Ahora
que tenemos estos en su lugar en la clase enemiga,
solo queríamos verificar dos veces. Ya he tomado
este camino mientras
estábamos haciendo el contenido del jugador si decidiste no
saltar a la clase enemiga estoy enfocado solo en la clase de jugador
simple. Entonces solo verifica que
tengas la reproducción inicial, la llamada de los
padres y la anulación
EventI de la llamada padre también Entonces vamos a
R pincha aquí. Vamos a hacer la función add
call to parent, y nuevamente, solo
asegúrate de que estamos conectándolos a medida que avanzamos. Para la lógica del movimiento, vamos a hacer lo
mismo otra vez. Así que en realidad queremos que suceda la misma lógica de
movimiento. Podemos agarrar todo esto. Nada
va a cambiar realmente. Podemos agarrarlos, así que solo selecciona
Shift para agarrarlos. Queremos presionar control en X para cortar todos los
nodos de aquí. Vamos a ir
a anular, y
anularemos la función de
movimiento del mango. Después de hacer cualquier cosa
que pueda necesitar suceda en la función padre, vamos a pegar
estos aquí y luego asegurarnos de que nuestro
movimiento sea llamado. Con eso hecho, eso
solo me recordó que también
podríamos mejorar
otra cosa por aquí. Entonces queremos asegurarnos de que con nuestra superposición
que estábamos haciendo, anteriormente solo
estábamos llamando a destruir actor y
dejando un mensaje aquí. Podemos traer nuestra función de muerte de
mango, dejar esto aquí y reemplazarlo con la función de destruir. Entonces nos desharemos de Destruye.
Tenemos nuestro manejado. Lo que tal vez queramos
hacer es entrar aquí. Nos dejaremos un
comentario. Entonces se toma esto. Si hacemos doble clic sobre esto, eso nos
llevará a
la base del plano. Así que ahora estamos en
la clase de padres. Podemos sacar de aquí, y algo que
siempre vamos a querer
hacer al final se llama
el actor de destruir. Una cosa que podríamos querer
hacer otro uso de los comentarios, puedo hacer las cosas más fáciles
para rastrear las cosas. Entonces, si presionamos C
para hacer un comentario aquí, me gusta
dejarme este tipo de me gusta
dejarme este tipo de
notas postas, casi Podemos decir algo como
implementar el efecto pre muerte. Entonces, ¿qué pasa
antes de que destruyamos a nuestro actor? Vamos a
hacer eso justo aquí. Esto lo hace realmente
fácil porque
puedes presionar Control en F en cualquier clase y puedes
buscar Do. Haga doble clic en esto. Y donde quiera que estés
dentro de tu clase, si te quedan muchos comentarios por
hacer, puedes saltar rápidamente a ellos y ver en qué
puedes trabajar. También podemos llegar
al lado derecho. Podemos darle a esto
un color diferente solo para que esto
destaque un poco. Completamente depende de
ti cómo quisieras manejar esto. Pero como mencioné, es
solo una buena manera para mí de encontrar rápidamente las características que quizás aún no estén completamente
listas para implementar porque no estamos tocando
esas partes del sistema, pero sé que
tendré que
volver aquí y hacer
eso en algún momento. Entonces, cuando volvamos a
actualizar esto más tarde, y nuevamente, es como realmente deberías estar enfocándote en tu flujo de trabajo. Esto realmente no ha hecho
nada por nosotros en estos momentos. Lo que esto significa es que
cuando volvamos a agregar efectos y
cosas así después, no
necesitamos regresar
y cambiar nuestro código enemigo. Esto ya está listo para funcionar. seguir desarrollándonos alrededor de todo
el proyecto, y esto se
contabilizará
automáticamente cuando hayamos
actualizado las características aquí. El resto de la colisión
sigue siendo el mismo. Esto va a ser todavía más
o menos lo que
tenemos que hacer aquí. Podrías reemplazar
esto con un comentario, otro para hacer comentario si
quisieras, pero de nuevo, no
hemos llegado
al sistema de salud, así que necesitamos algo
que nos recuerde volvamos aquí, y esa cadena de
impresión está bien. Solo queremos verificar
que todo esto está funcionando, así que volveremos al modo de
juego, nos aseguraremos de que los enemigos y el jugador
sigan moviéndose. Destinado, y eso es
todo bastante bueno. Siguen
rebotando en las paredes. Todavía están tomando
su dirección aleatoria, velocidad
aleatoria, rebotando entre sí, y podemos
volver de nuevo y cambiar eso dependiendo de cómo creamos que debería desarrollarse
el juego Pero creo que con
eso hecho, ahora
tenemos la paridad de comportamiento Todo funciona
como antes, pero haciendo uso de la herencia
adecuada. Es solo un rápido recapitulación ahora que hemos terminado nuestro refactor, pasando al
uso de la herencia,
averigua qué nos
ha traído esto Las cosas centrales
van a ser que
hemos compartido la configuración de colisión. Podemos configurar
esa esfera una vez, y va a estar funcionando en ambas clases
que hagan uso de esa. Tenemos el manejo compartido de
la muerte. Entonces nuevamente, cuando lleguemos a
sumar cosas como explosivos, sonidos, ambas clases
podrán usar eso. Podemos anular el
efecto si es necesario, pero no necesitamos
hacer ningún cambio en nuestro código base ahora. Tenemos el toggle de lógica de
movimiento compartido, así que cuando lleguemos a
agregar las animaciones, ese movimiento habilitado
será válido para escenas de corte tanto para
el jugador como para el enemigo. Tenemos las variables compartidas
como la velocidad de movimiento. Existe una vez que
no tenemos duplicación o múltiples versiones
de esas en toda clase. Podría ver mi exageración
en este momento solo
por estas dos clases
diferentes, pero estamos a punto de agregar
cosas como salud,
proyectiles, efectos espornos, Ahora tendremos un grupo de características
compartido para extraer de donde las cosas son relevantes
para hacer uso de lo
mismo en
lugar de duplicarlo Una cosa que acaba de
venir a la mente es que ya
podríamos hacer esas actualizaciones de
esfera. Como he mencionado, el tipo de enfoque
general que gente toma con este tipo
de juegos es para el jugador. Queremos que la esfera tal vez sea un poco más pequeña de
lo que cabría esperar. Entonces esto en realidad podría
estar bien. Potencialmente podríamos aumentar un poco el radio de la
esfera. Podemos ver en este momento que en
realidad está dentro del cuerpo. Es tan pequeña, no
podríamos verla. Entonces proyectil va
a volar
completamente por toda la envergadura
y la mayor parte del cuerpo Esto, como mencioné,
es solo para hacer que el jugador sienta que un poco
mejor de lo que son. Si piensan en
sus ojos que casi les falló
una bala, pero de hecho, les pegó. Van a
sentir que lo han esquivado. Y lo que no queremos es que vaya
para otro lado, donde sientan que
deberían haber esquivado algo, aunque claramente no lo
hubieran hecho, y se sienten engañados al tomar ese daño extra en su mente Con la esfera
seleccionada, sin embargo, queremos encontrar el radio de la
esfera aquí, y podemos
establecer esto en algo así como 50, y verás dónde entra en juego
eso. Entonces ahora, esta es la zona la
que el jugador
estaría tomando daños. Entonces tal vez solo voy a reducir
eso un poco, así que es solo puramente el cuerpo, algo así como 45, y creo que probablemente sea tanto margen de
maniobra como queremos darles Si golpeamos compilamos y luego
volvemos a la
clase enemiga, lo mismo. Vamos a entrar en el
viewpot, agarrar la esfera,
pero creo que esta vez, lo que podría hacer es hacer que
esto sea algo así como
64 o duplicarlo Y de hecho, eso podría ser tal vez incluso eso es un
poco demasiado pequeño, así que hagamos algo así como 70. Así que de nuevo, solo
va a sentir el jugador sentirá
como si estuviera
haciendo sus tiros mucho mejores que cada vez
que disparen, realidad
están
golpeando al enemigo exactamente como planearon, en realidad
están
golpeando al enemigo
exactamente como planearon,
donde, de hecho, van
a estar perdiendo el cuerpo, pero vamos a
recoger eso por ellos y hacerlos sentir como si estuvieran haciendo mejores en el juego
de lo que podrían ser. Obviamente, queremos
equilibrar esto. No queremos que
sea demasiado fácil, pero puedes ver que es agradable y fácil modificar estas
cosas de todos modos Entonces así es como la configuración de herencia. Ambas clases están funcionando, ambas heredan de
la base del plano A continuación, podemos pasar a
sumar la salud y el daño. Y aquí será donde
realmente empieces a ver los beneficios de tomar este tiempo antes de la implementación para
configurar la herencia.
16. 15: HealthSystem: Tiempo para agregar salud y daños. Ya tenemos nuestra clase base establecida para compartir los datos
importantes, así que saltemos directamente a la base del plano de subrayado
BP Aquí vamos a necesitar
dos variables distintas. Queremos rastrear
nuestra salud actual, la salud que tenemos
actualmente y nuestra salud máxima. Podemos hacer esto con
el uso de flotadores, así que tomaré la
velocidad de movimiento, presionaré el control,
efectivamente, duplicaré esto una vez y llamaré a este salud
actual Duplicarlo por segunda vez, y le
llamaremos Max Health. Si le pegamos a compilar, voy
a agarrar la salud máxima, y voy a establecer esto en
un valor por defecto de 100. Podemos dejar vacía la
salud actual. Y lo que estamos haciendo en cambio
es en la jugada de inicio, dejar caer nuestra salud actual en
el pin de ejecución justo aquí, y queremos tomar nuestra salud
actual y establecer
que esta sea nuestra
salud máxima. Sin errores humanos. Cada vez que empecemos a
jugar, siempre nos aseguraremos de
comenzar con plena salud. Entonces, una manera agradable y sencilla de simplemente
asegurarnos de que
no nos equivoquemos nada
con nuestro sistema de salud. Una vez más, solo un recordatorio. Por eso es
realmente importante. Cuando golpeamos compilar y guardar, vuelve al jugador simple y solo
verifica que tengas el ce de anulación para
comenzar a jugar, y
lo mismo para el enemigo. Entonces aquí es donde se
vuelve importante, porque queremos asegurarnos de
que ambas clases inicialicen su salud a
cualquiera que sea su
salud máxima que esté destinada a ser Con eso confirmado, también
podemos implementar nuestro manejador de daños.
Esto es realmente sencillo. RL Engine tiene un
sistema de mensajería
incorporado específicamente
para manejar daños. Si hacemos clic en
el gráfico de eventos, necesitamos buscar un
evento llamado cualquier daño. Entonces es éste de aquí,
el suceso, cualquier daño. Y esto se llamará
cada vez que mandemos un mensaje de otro actor, ya sea un proyectil,
un explosivo que impacte en el
avión o la clase enemiga, podemos mandar un mensaje para decir:
Oye, te han dañado Cuando se envíe ese mensaje
y este se reciba aquí, realizará
esta
llamada de evento o función. Y cuando eso suceda, lo
único que queremos
hacer es establecer
nuestra salud actual, así que vamos a
arrastrar esto al pentágono de ejecución Haremos de eso
nuestro infierno actual, así tomaremos la
salud actual por segunda vez, controlaremos arrastrarla a la
gráfica para leer el valor, y eso será
negativo nuestro daño. Entonces el infierno actual
menos un valor aquí, que será nuestro daño
que estamos pasando, así que esto será algo que
coloquemos en la llamada
de la otra clase. El resultado de ese cálculo
será nuestro valor para la salud. Una cosa que normalmente se recomienda para este
tipo de cálculo es evitar que las cosas se pongan un poco hacky o raras No queremos permitir el daño o si implementamos la
curación, también, no
queremos permitir que
esos valores nos lleven más allá de nuestro umbral máximo o
mínimo. Entonces podemos usar algo
llamado pinza. Sacaremos de este pin aquí
y buscaremos abrazadera. Queremos la opción de flotación de abrazadera, que es justo aquí arriba un
poco. Así pinza de flotación. Y vamos a enchufar
el resultado de esta sujeción en nuestro pin justo aquí. Para que podamos ver lo que
esto nos permite hacer. Podemos tomar nuestro valor mínimo. Entonces la cantidad mínima de
salud que deberíamos ser cero. Y las cantidades máximas de
salud que podamos tener
serán nuestro valor máximo para la salud.
Tan agradable y sencillo. Esto solo significa que si agregamos
algo como botiquines de salud, cuando eliges uno de
esos, no puedes
superar la salud máxima con la
que empezaste. Por lo que siempre
mantendrá los resultados de ese cálculo
dentro de ese rango. Una vez que hayamos confirmado que el
ajuste de la salud está todo hecho correctamente y no
podemos equivocarnos nada de esto, vamos a hacer
nuestra comprobación para ver si el daño que acabamos de recibir
es suficiente para destruirnos. Entonces sacaremos de nuestro pin de
ejecución justo aquí. Vamos a
buscar una sucursal. Nuestro verdadero falso control
de flujo aquí. Y todo lo que queremos
hacer es que vamos a volver
a obtener nuestro valor actual para
la salud, así que el control arrastra eso.
A ver si esto es menor que. Así que aquí vamos a buscar
al menos que operador. Y lo que voy a hacer es que
en realidad voy a comprobar si esto es menor o igual
a un número determinado. Enchufa esto a la rama
justo aquí, la booleana, y ahora tenemos un
cheque que dice que si nuestra salud actual es
menor o igual a cero, entonces podemos manejar
nuestro llamado de la función death o la función
handle death Estar preguntando por qué estamos usando
menos abajo a igual que, especialmente porque
acabamos de sujetar esto para asegurarnos de que
nunca va por debajo de cero Y esto es sólo una especie
de hábito de seguridad. Si algo aplica más
daño que el infierno restante, o obtenemos alguna rareza de
punto flotante, o incluso si simplemente
refactorizamos el código nuevamente más tarde y decidimos
no sujetar esto, quiero asegurarme de
que esta comprobación
siempre será relevante para
asegurar que estamos muertos Entonces, por ejemplo, si
tomamos esta pinza, si estamos a los cinco de salud y tomamos otros diez
daños, obviamente, vamos a estar en
menos cinco, lo que significa que si solo
comprobamos cero, entonces algo que ha sufrido más daño del que deberían evitaría ser matados. Con eso hecho, sin embargo,
desde nuestra rama aquí, podemos tomar nuestro mango de la muerte. Y si esto es cierto,
podemos simplemente enchufar esto solo esto
es lo que ahora
comenzará a manejar toda
la funcionalidad de muerte para cualquiera de los aviones que tal vez
te sientas tentado a hacer, y, por supuesto, los dos
que ya tenemos Manejar
la muerte ya tiene la función destruida en ella, y como he mencionado, vamos a
volver aquí más tarde para agregar cosas como explosiones, efectos de
sonido, y todas las cosas divertidas y jugosas que
queremos poner en nuestro juego Entonces, para empezar realmente a hacer
uso del sistema de daños, ya
tenemos algo
en su lugar para probar al
menos parte de
cómo
va a funcionar esta estructura dentro de nuestro enemigo. Entonces, si volvemos a la clase
enemiga, este pedacito de aquí, que hace mucho tiempo que acaba de hacer
nuestra cadena de impresión, por fin podemos eliminar esto. Lo que queremos en cambio es que
vamos a llevar a nuestro actor de éxito, así controlaremos arrastrar
esto a la gráfica. Vamos a sacar del otro actor, y estamos buscando
ese mensaje global que mencioné un poco
antes, el daño de aplicar. Entonces podemos ver aquí
tenemos aplicar daños. Esto solo hace una llamada a cualquier actor con el que pueda
comunicarse. En este caso,
va a ser en el
que acabamos de rebotar Vamos a enganchar
esto justo aquí, así que tomaremos nuestros pines de
ejecución, aseguraremos de que estén todos conectados
, moveremos esto en el camino, y queremos aplicar
cierta cantidad de daño al jugador. Pienso por los enemigos,
voy a darle salud a esta mitad de los jugadores. Sé que el jugador
va a tener 100 sanaciones. Estableceremos esto en 50, y esto
significa que el jugador puede recibir dos golpes de un enemigo para que no quiera rebotar
en ellos con demasiada frecuencia. No va a ser una forma
rápida y limpia de ganar puntos
extra con solo volar hacia todos los enemigos. Ahora,
eso sí me recuerda. Otra cosa que podemos hacer
con nuestras variables heredadas es si vamos y seleccionamos
al enemigo, por ejemplo, y obtenemos los detalles de la clase justo aquí, en el lado
derecho, queremos asegurarnos de
que la salud del enemigo probablemente
va a ser diferente
a la salud del jugador. Entonces podríamos establecer la salud del
enemigo en 50, y en el jugador,
solo verificaremos dos veces, debería
haber
incumplimientos a 100 Asegúrate de que la
salud del jugador esté establecida en 100. Así que de nuevo, una manera
fácil y agradable podemos establecer el valor de salud solo
una vez y manejar esto en la clase padre
tanto por el daño recibido
como por la salud dada aquí porque están
basados en variables que existirán en
todas las clases. Y luego en las clases secundarias, todo lo que tenemos que hacer es
ajustar estas variables en el editor si quisiéramos
cambiar el tipo general
de marcado de nuestro juego Y como he mencionado,
porque
ya hemos configurado esto de cierta
manera, ahora
significa que
tenemos el mango de la muerte. No necesitamos
volver y tocar esto. Necesitábamos hacer un
pequeño cambio de lado de la clase enemiga
no necesitaba ser contabilizada y todo
va a seguir funcionando como estaba. Una cosa que quiero
mostrarles muy rápido, solo porque este
es otro de esos lugares muy claros donde podrías haber
tenido la tentación de adoptar
un enfoque
diferente para manejar la muerte para el enemigo es que podríamos
desenchufar esto solo por ahora Otra cosa que
podrías hacer es que podríamos duplicar nuestra función de aplicar
daños. Podríamos enchufar esto
aquí porque lo principal es que cuando
golpeamos
el avión del jugador, sabemos que la clase enemiga necesita
dañarse a sí misma, esencialmente. Lo que podríamos hacer es
tomar nuestro valor MAX para la salud. Para que podamos buscar MaxEl
y enchufar esto aquí. Y luego el
actor dañado,
básicamente podríamos aplicarnos
daño a nosotros mismos. Entonces, si sacamos
del actor
dañado aquí y buscamos una celda, obtenemos esta opción incorporada en funcionalidad que
quería introducir, obtener una referencia a uno mismo. Entonces esto básicamente
es un poco raro. Esto básicamente
encontrará una referencia a sí misma, que se encuentra aquí. Llamará al mensaje de aplicar
daño en sí mismo, que obviamente
será recogido en la clase base porque ahí es donde
tenemos el evento cualquier
daño
que se despida. Y porque estamos pasando
en una salud máxima, y esto es solo una cosa de seguridad. Yo después, decidí
que, de hecho, la salud del enemigo
a los 50 era demasiado baja, y entré y
cambié esto a 75. Obviamente, lo que no
queremos hacer es tener este código
duro 50 porque
cualquier cambio que
hagamos en una base más amplia que solo este nodo de aquí
sería un poco olvidado y perdido. Sólo otra manera, de nuevo,
solo tratando de llegar a pensar en cómo
estructuras tu código, el uso de variables,
principalmente solo una especie de
pruebas futuras para que no tengas que
hacer más trabajo en el futuro. Lo principal con los programadores
es que somos bastante flojos. La menor cantidad de trabajo que
tenemos que hacer mejor, evitando volver a nuestro código y cambiar
variables en todas partes. Si podemos
configurar algo así, puedo cambiar la
salud máxima a cualquier cosa. Podría bajarlo,
podría aumentarlo. Esta función
siempre lo hará. Como mencioné, sin embargo, simplemente no se
lee muy limpiamente. Se necesita un poco
más de tiempo para averiguar por qué tenemos un daño
aplicado, otro aquí, y cuáles son
estos diferentes actores. Creo que tiene más sentido
si solo vamos a hacer un tipo completo de enemigo al estilo
kamikaze, podemos simplemente enchufarlos,
y lo hace mucho más claro Entonces vamos a aplicar
daño a la cosa que tenemos apenas una vez que hayamos hecho eso, vamos a aplicar
daño a nosotros mismos. Y recuerden, esto es realmente seguro porque estamos
mirando aquí abajo, estamos comprobando si
el actor de éxito es lo que actualmente controla el jugador humano,
y sólo si eso
es cierto,
vamos a hacer esto. Entonces esto no va a estar aplicando
daño a las paredes, los proyectiles, a otros enemigos Todo eso se
contabilizará aquí abajo. Entonces esta es una
forma agradable, fácil y segura de estructurar los daños por impacto. Algo que
realmente no he mencionado, pero también tenga en cuenta que el orden de operación
es realmente importante. En cuanto lo piensas, si no lo has
pensado antes, se vuelve realmente obvio. Es algo
que la gente echa de menos. Si solo manejamos la muerte primero, así podríamos lanzar esto
al revés también. Si enchufamos esto aquí,
desenganchar estos, mover esto. Sólo un ejemplo muy rápido, vuelve a
enchufar esto. Y esto es solo porque lo he
visto pasar antes. Los estudiantes no estaban muy seguros de por qué ciertas funciones no
se estaban llamando cuando
esperaban que lo hicieran. A veces también puede estar
en el sistema. Algunos sistemas podría funcionar, algunos sistemas podría
no depender de qué tan rápido
va a suceder la iteración del ticket y cosas así Pero básicamente, si
piensas en lo que está pasando aquí, si golpeamos al jugador y
llamamos a manejar la muerte primero, esto será saltar a
la función padre, llamando a destruir, y
potencialmente si esto se agrega
inmediatamente a la recolección de
basura y
se borra de la memoria, esta clase ya no existe. Eso significa que no va a ser dar un paso atrás de aquí, volver a esta función, y aplicar daño al jugador. Así que podrías terminar con un juego en el que el
jugador simplemente nunca recibe daño por impacto. Así que ten cuidado con
ese tipo de cosas. Y nuevamente, es muy
común que la gente
ya haya manejado el
lado de la muerte de las funcionalidades, y luego
volverán y luego
agregarán los efectos de partículas y el
sonido y luego no tendrán claro de inmediato
por qué no se reproducen las partículas y los efectos de
sonido. Es porque tu
clase probablemente está siendo borrada de la
memoria y no existe. Esa función se
llama. Por lo que el orden de operación también es importante. Control de flujo es
otra palabra para eso. Este fue un ejemplo realmente
simple, pero es una trampa fácil en la que
caer si no estás
prestando suficiente atención. Incluso si
entiendes el concepto, es un simple error de cometer. Entonces con eso, si solo
golpeamos compilar y guardar, podemos volver a entrar y
probar o golpear play. Lo que estamos
buscando aquí es asegurarnos de que aún
se destruyan
cuando golpeen al jugador. Y lo más importante, después de
dos hits como vimos ahí, también
están
destruyendo al jugador. Entonces ni el jugador y el
enemigo tienen un sistema de salud, teniendo en cuenta que no
estamos implementando ese sistema de salud
en cada clase. Lo estamos haciendo solo
una vez en la clase base, y toda esta funcionalidad
para calcular el estado, verificar si su clase está muerta, y luego llamada a la función
está siendo manejada ahí. Mientras miro esto, me acabo de dar cuenta de que
probablemente he hecho un poco de un par
falso de codificación, esto en realidad
va a causarnos
un poco de problema porque estamos llamando a
manejar la muerte cuando calculamos
que la muerte
sería apropiada, y la
estamos llamando aquí. Hay una buena posibilidad de que
consigamos que dos juegos de partículas
jueguen. Vamos a obtener uno
de la llamada de disfunción, y luego uno de la llamada de
disfunción, que está sucediendo en
función de la salud. Entonces ahora que estoy mirando
hacia atrás a través de mi propio código, lo que creo que deberíamos estar
haciendo es en realidad la forma que estaba tratando de usar como
solo un ejemplo de aprendizaje. Pero si volvemos a duplicar esto, creo que tendremos que
hacerlo de otra manera. Entonces nos vamos a aplicar
daños a nosotros mismos. Entonces otra vez, vamos a sacar
del actor de daños. Diremos vender, y
vamos a enchufar esto aquí. Esto solo asegura que
sea realmente fácil pasar por alto
cosas como esta Suerte que
volvimos y echamos un vistazo rápido al código. Esto solo asegura que el daño
se aplique a nosotros mismos. Vamos a usar ese
mismo truco que mencioné hace
un momento, entonces Maxel Y nuevamente, me doy cuenta de que podría
editar esto fuera del video. Pero como he creado todo
este proyecto con la intención de intentar
enseñar a pensar en la codificación, creo que este es un ejemplo
de aprendizaje bastante
bueno del tipo de cosas que
puedes pasar por alto y cómo puedes
meterte fácilmente una situación que necesitas
volver y arreglar más tarde Entonces esto asegurará que
definitivamente nos matemos a nosotros mismos. Siempre estamos pasando
en la
cantidad máxima de salud que
podríamos tener. Eso activará
esto para que se llame, lo que asegura que nuestro mango la muerte solo se llame una vez, es
decir, que cuando lleguemos
a los efectos de partículas,
los efectos de sonido,
vamos a tener que
llamarlo una vez aquí y luego
también tocarlo una vez aquí. Entonces eso es
lo principal que queremos evitar, así puedo eliminar esa.
No lee tan bien. Aquí es donde
tal vez quieras traer un comentario solo para dejarlo
claro. Esto es para el jugador. Esto es por ti mismo para
asegurarte de que siempre nos
alejamos del juego
después de golpear al jugador. Cosa realmente simple,
muy pequeña cosa. Lo convirtió en un tema más grande
solo porque es más
un momento de aprendizaje que acaba de
aparecer ahí accidentalmente La última cosa pequeña
que podemos hacer mientras aún
estamos en la clase enemiga. Podemos eliminar el uso
de números mágicos. Entonces, por el momento, solo
estamos aplicando 50
puntos de daño al jugador. Podemos promover esto
a una variable, y llamaremos a esta daño
de impacto. Solo revisa dos veces para cualquier otro que
podamos haber perdido. Creo que fue solo esa.
Nosotros sí tenemos estos, de hecho, si quisieras
crear una
velocidad mínima y máxima de movimiento porque el enemigo tiene la posibilidad
de esa aleatorización Compilar guardar,
volver al jugador,
doble check aquí. No creo que tengamos tantas
variables
que hemos estado
creando recientemente, así que eso está bien en
la clase de jugador y luego en la clase
base también. Algo más que
quizás quieras hacer si realmente
estás tratando de mantener ordenadas todas
estas variables
a medida que empiezas a obtener muchas
más variables, puede llegar
a ser un
poco más difícil encontrar con qué están relacionadas. Por lo que puedes dar
categorías de variables, lo que puede ayudar. Entonces, por ejemplo,
tenemos aquí la velocidad actual, la velocidad
objetivo, la velocidad interp Entonces estos tres están todos
relacionados con el movimiento, y luego estos dos están
relacionados con la rotación. Entonces lo que podemos hacer
es si seleccionamos uno de estos en
el panel de detalles, obtenemos esta opción por
aquí para una categoría, y podemos configurarlo en
algo así como movimiento. Y entonces podemos
simplemente arrastrar y soltar los otros movimientos
en la categoría de movimiento. Podemos agarrar la rotación,
y tal vez podríamos darle a esto una categoría
de rotación. Lo mismo otra vez, deja caer estos , y luego podemos
colapsar estos. Lo hace un poco más fácil
especialmente cuando tienes una larga lista de variables que empiezan a aparecer
en clases más grandes Eso significa que puedes
navegar muy rápido para encontrar todas las
cosas relacionadas con
el movimiento si estás buscando
un valor muy específico para ajustar y
lo mismo para la rotación Puedes tener combate. Puedes
tener una categoría de Booleanos, vectores, lo que
quieras configurar aquí. Mucho cómo tu proceso de trabajo va a encajar mejor con tu
proyecto, pero solo una idea rápida. Si quisieras hacer
algo entre temas, siéntete libre de hacer una pausa, tener un pequeño descanso
de
seguir y tal vez volver
a través de las otras clases y ver cómo podrías querer
categorizar las cosas en la clase base y tal vez
incluso en la clase enemiga No voy a hacer eso en pantalla,
pero es solo una idea poner marcha
esos conceptos y
hacerte saber que esas
características existen. Sin embargo, con eso hecho, ese es nuestro
sistema de salud completo. Lo hemos implementado una vez,
y está funcionando en todas partes. Significa que podemos pasar a
los proyectiles. Y nuevamente,
ahora podemos simplemente construir sobre la base que ya
hemos creado. Eso va a ser cuando
el combate se vuelva más interesante y cuando en realidad
podamos devolver el fuego.
17. 16. Mejoramiento del movimiento: Recuerda ese error
de velocidad de fotogramas que
reconocimos y
acabamos de pasar. Es hora de volver
a eso y arreglarlo. Estaremos reemplazando el código de movimiento
problemático con algo listo para la producción. Independencia adecuada de la velocidad de fotogramas , estructura
más limpia
y un mejor relleno. Me doy cuenta que antes
de comenzar a agregar cosas
elegantes como reproductores de
actores, proyectiles y desarrollar el
sistema de daños, mientras estamos haciendo este factor y mejora
del código base, probablemente
deberíamos regresar
y asegurarnos de que no nos
olvidemos del movimiento y
el error del que El código infractor
que necesitamos arreglar está en nuestra clase de jugador Entonces, si aún no
tienes ese abierto, sigue
adelante y abre jugador llano de BP
Underscore En mi caso solo voy a
pres botón medio del ratón, cierra las pestañas que no
vamos a estar usando Así que la clase base y
la clase enemiga y navega hacia la función de
movimiento del mango justo por aquí. Entonces este es el código que
queremos reemplazar y mejorar. Ahora, lo primero es después
del movimiento del mango padre, queremos hacer clic y
desenganchar este código Algunas personas tienen
diferentes opiniones sobre este tipo de cosas. Una vez más, quiero seguir
enfocándonos en la estructura del código , las
buenas prácticas y
cosas así. Lo que puedes ver, especialmente
en el código C plus plus es algunos desarrolladores podrían mantener el código antiguo que estamos
tratando de reemplazar. A lo mejor pon esto en un comentario
por si acaso quisieras verlo más tarde en caso de
que creas que podrías necesitar recurrir
a esto. Eso termina con un espacio de
trabajo desordenado. Tienes tal vez mucho más código en tu C plus plus del
que necesitas. En Blueprints
obviamente podemos tener muchas más cosas solo en
la gráfica de las que necesitamos E idealmente
estaríamos usando algo como Github para el
control de fuentes de todos modos. Entonces, si alguna vez necesitábamos
mirar el código antiguo, idealmente, simplemente
revisaríamos nuestro repositorio y lo veríamos a través de Git
o Perforce o algo así Ahora bien, en este caso
me voy a quedar esto solo por un momento
porque creo que hay algunas cosas que simplemente podemos
copiar y pegar para mayor rapidez, pero vamos a estar deshaciéndonos
de este código por completo Entonces vamos a
empezar éste fresco. Lo primero que
queremos hacer es que
vamos a sacar de nuestro
pin de ejecución aquí arriba y vamos a crear algo
llamado secuencia. Queremos esta opción justo aquí. Y si no las has
visto antes, las secuencias están muy
subutilizadas Hacen que nuestro plano se
lea como código tradicional,
es decir, de arriba a
abajo, de izquierda a derecha Cada uno de los pines maneja
una tarea específica, o al menos esa es la forma en que deberíamos
pensar en usarlos. Es mucho más limpio que la lógica que se extiende a través de
los tres monitores, solo porque tienes
esta larga línea de lógica. Sólo para señalar, no
estoy presumiendo. Eso fue una exageración. En realidad no
tengo tres monitores. Hay otros
beneficios y razones por las que quizás quieras usar
esto, pero lo principal, volver a las secuencias
es que
solo son una
manera muy agradable de ayudar a estructurar nuestro código y ayudarnos a pensar lógicamente
dividiendo las cosas esencialmente en pasos Estás diciendo, haz esto,
luego haz esto, luego haz esto, y tratas de mantener todo algo único para una tarea determinada. Entonces, lo primero que realmente queremos en nuestra tarea dada es que necesitamos calcular nuestra velocidad de movimiento
objetivo. Ya estamos haciendo
eso aquí abajo, así que esta es una de las cosas
que podemos simplemente agarrar. Si agarramos el código hasta el nodo de velocidad de movimiento
objetivo, presione Control en X, y luego venga
y pegue esto. Entonces esta será la
primera tarea que nos demos
en nuestra secuencia. Otra cosa que
nos puede ayudar a mantener el código un
poco legible es que si hacemos
doble clic en un cable, esto nos dará un nodo de rearranque. Podemos mover esto
aquí arriba porque queremos asegurarnos de que vamos
a tener suficiente espacio, esencialmente para el camino diferente entonces
que estamos siguiendo. Ahora una cosa que
vamos a cambiar es que
vamos a estar creando
nuestra propia intercalación. No usaremos F interp dos. Por esa razón,
vamos a cambiar un poco de los segundos Get
World Delta. El hombre se deshace de este nodo
aquí, el multiplicar. Engancha esto
directamente a la velocidad objetivo establecida, y vamos a
hacer que esta velocidad de fotogramas independiente un poco
más tarde. Mantendremos esto alrededor. Esto lo necesitaremos
en un momento. El get World Delta segundos. Pero eso es prácticamente todo.
Ese es nuestro primer paso. Lo primero que tenemos que hacer
es tener un objetivo que alcanzar. Eso entonces nos alió.
Podemos bajar a entonces uno. Y lo que vamos a
hacer aquí es calcular nuestra propia
interpelación personalizada Entonces esto se va a poner un
poco matemático, pero va a ser la clave para la independencia fama
propiamente dicha Vamos a pasar
vamos a agregar esto, y luego voy a dar un
paso atrás y tratar explicar por qué terminamos con
un cálculo que tenemos. Entonces,
lo primero que queremos es nuestra velocidad de interp de movimiento aquí, así que vamos a
controlar arrastrar esto y obtener la velocidad de interp de
movimiento Multiplicaremos esto
por nuestros segundos Delta, razón por la
cual está disponible hace
apenas un momento, así que vamos a
tener nuestros segundos Get World Delta para comenzar a hacer que nuestra
tasa de fotogramas de cálculo sea independiente nuevamente. Entonces queremos negar o invertir el cálculo que creamos, así que vamos a multiplicar aquí Vamos a llegar a multiplicar nodo y multiplicar esto por uno negativo. De nuestro cálculo aquí,
vamos a tirar de nuevo. Voy a buscar
algo llamado EXP. Este es el
valor exponencial, así dice aquí, esto devolverá la E
exponencial a la potencia del valor.
Entonces usaremos esto. Y luego finalmente, después de
nuestro nodo exponencial, vamos a tirar de aquí, y vamos a restar, así que solo presiona la tecla menos, encuentra restar y restar
uno del cálculo uno del Lo importante
antes de que
nos olvidemos obviamente no queremos
ningún número mágico, vamos a sacar
del pin final. Vamos a promover
esto a una variable, y vamos a llamar a
esta MV Alpha. Si has estado
creando categorías, es posible que quieras mover esto
a la categoría de movimiento. Como, por supuesto, esto va
a ser específico del movimiento. Vamos a
conectar esto a nuestro pin de ejecución, luego uno, y ahora tenemos
nuestro código Alpha listo para funcionar. Entonces esta es nuestra
interpolación suave que usaremos de una
manera más manual e
intencional en nuestro código Entonces solo para volver a enfocarnos
en, lo que esto está haciendo, esto nos está dando uno menos E a la
velocidad negativa multiplicada por Delta. Esencialmente, esto está proporcionando
una curva de decaimiento suave. Esa es la razón principal por la que
necesitamos usar el restar uno al final ya que queremos que
esto se detenga con el tiempo Y la razón por la que
necesitamos usar una fórmula como esta es volver a la fuente principal del
problema que estamos teniendo entre
diferentes
velocidades de fotogramas y mantener las cosas independientes de la velocidad de fotogramas. La función F interp
en realidad proporciona una aproximación
lineal,
y eso es en realidad proporciona una aproximación
lineal, lo que se rompe
a bajas velocidades de fotogramas En comparación, si
creamos una función como esta que podemos usar con
una función larp estándar, este
enfoque exponencial nos da interpolación
matemáticamente correcta Entonces ese era el
objetivo principal aquí es que en realidad solo queremos dejar de usar esto
por completo. Por último, teniendo en cuenta
que queremos intentar hacer
cosas específicas muy únicas por línea. Vamos a añadir otro pin, y queremos el entonces
dos pin justo aquí. Vamos a tirar de aquí, y queremos hacer
esa cosa final,
que en realidad es usar
la velocidad actual, proporcionándole interpolación Todavía queremos
usar la interpolación, pero solo la versión básica más
rudimentaria con nuestro propio cálculo Entonces podemos sacar
del pin de ejecución. Podemos encontrar la velocidad actual
establecida. Entonces estableciendo el valor que
hemos estado rastreando, y aquí es donde
queremos sacar de este pin aquí, y vamos a
buscar bucle. Y esta vez,
solo queremos usar el bucle flotante estándar. Entonces puedes ver que está
un poco más simplificado. En lugar de tener la
corriente al objetivo en tiempo Delta y
una velocidad de interp, si quisiéramos cambiar
la velocidad de interp, necesitamos agregar algún
tipo de desplazamiento aquí Todo lo que estamos haciendo es proporcionar
esa curva exponencial, que va a ser nuestro Alfa Entonces, si tiramos en el movimiento Alfa, podemos dejar esto aquí. Pero además de eso
esencialmente seguimos haciendo lo mismo. Vamos a estar
pasando de A a B. Y
lo mencioné cuando
miramos por primera vez a la F entre los dos primeros, como que
tenemos 0.1 en 0.2 o punto A y punto B. Así que
seguimos haciendo lo mismo. Vamos de A, que
es la velocidad actual a B, que es nuestra velocidad objetivo a
lo largo de un tiempo, y ahora estamos basando
esto en nuestro propio Alpha móvil personalizado Entonces ese es el cambio principal
aquí es la forma en que estamos configurando la
velocidad actual se está actualizando. Entonces, si pasamos por,
en realidad podemos eliminar esto ahora. Así que podemos ver que estamos en
cierto modo la mayor parte del camino
a través de la actualización de nuestra base de código. Voy a hacer doble
clic aquí de nuevo para hacer otro nodo de rearranque solo para
mantener esto algo ordenado, sacar las cosas del camino, solo darnos
suficiente Entonces, lo último es que queremos volver
a establecer nuestra ubicación. vamos a hacer algo Aquí también vamos a hacer algo
ligeramente diferente. Entonces, después de que hayamos establecido
la velocidad actual, una vez que ahora estemos
rastreando la velocidad, queremos sacar de
nuestro pin de ejecución, y queremos
buscar algo llamado add actor world offset. Para que podamos ver la
opción justo aquí en la cima, en Actor world offset. Entonces, para nuestro caso de uso, esta es
en realidad la mejor solución en comparación con establecer la
ubicación del actor para el movimiento
consciente de la física. Lo único que realmente
necesitamos cambiar es que vamos
a hacer clic
derecho sobre el vector de
ubicación Delta aquí, dividir el pin de estructura para que
tengamos los mismos resultados que antes. Queremos tomar
nuestra velocidad actual, así podemos enchufar eso
si quisieras, pero en este caso, solo
voy a Control drag current speedom Vamos a multiplicar
esto por Delta segundos. Así que vamos a conseguir otro
G world Delta segundos, y vamos a conectar esto
a nuestro resultado aquí. Y entonces, claro,
vamos a hacer de esto la Y porque nos estamos
moviendo de lado a lado. Entonces queremos eso en el
eje Y. Eso es más o menos. Así que ya hemos actualizado. También podemos
deshacernos de esto. Ahora hemos actualizado
nuestro código de movimiento. Estamos rastreando la
velocidad objetivo de manera un poco diferente. Tenemos nuestro alfa de movimiento completamente
personalizado basado en una curva de decaimiento, y hemos cambiado un poco la forma en
que manejamos la velocidad actual y cómo la estamos enchufando a
la ubicación mundial Ahora una cosa que
podríamos hacer aquí, sólo para mejorar un poco las cosas, es que podríamos volver
a comentar las cosas Así que de nuevo, este es un buen uso de comentarios cuando tenemos
estas grandes divisiones agradables de lógica específica en nuestro así que lo que podríamos hacer es
agarrar estos nodos aquí arriba, presione C. Y si quisiera darle un comentario
a esto, tal vez
diría algo así como establecer velocidad para que llegue el avión Y para que no tuviera que
sumergirme en el código más tarde, solo podría especificar
que esta es específicamente la
velocidad objetivo que estamos viendo. Nuevamente, podría darle este tipo de
colores más únicos solo para que los comentarios se destaquen
frente a otras cosas como hacer que
creamos antes. No necesitamos hacer esto y
hacer que todo
se vea realmente bonito. Definitivamente puedes dejarte
llevar por eso. Pero cuando cambio
el color de las cosas, es más que de
un vistazo,
sé que uso un
gris específico para los comentarios. Yo uso un rojo específico para el código
potencialmente roto o algo que
necesita moverse todos juntos. Normalmente uso, como,
un verde para hacer. Así que de nuevo, sólo de
un vistazo, puedo ver como estoy
pasando por mi código. Estos son solo comentarios
donde necesito una actualización esto es algo de lo que realmente
necesito deshacerme más tarde, y cosas así
pueden llegar a ser útiles. Entonces les doy a estos
como un color muy azul, grisáceo solo
para recordarme a mí mismo. Simplemente voy a presionar
Control C y Control V para obtener otro
comentario por aquí, tipo de duplicar este, y vamos a moverlo aproximadamente en su lugar solo para
no necesitar volver a establecer el color. Y esta
es una de esas cosas. Una vez que te acostumbras a los atajos
y cosas así, el poco de
tiempo extra que lleva
darte un
color personalizado y un tipo de cosas
temáticas un
poco en realidad no agrega tanta sobrecarga a
tu tiempo de desarrollo. Entonces esto, si me estaba dejando
un comentario para después, nos
está ayudando a rastrear Alpha para su uso en nuestra función de
intercalación. Una vez más, solo
recordándome que específicamente, esto es actualizar la función
mover Alpha Y entonces queremos tal vez
un comentario más. Ya lo he mencionado, no voy a hacer
esto por cada línea de código, y no voy a hacer esto por el
resto del proyecto y los videos ya que los videos se
harían demasiado largos. Pero solo para mostrar el
concepto, a medida que
pasamos por algunos de estos
refactores y cambios más grandes, que podrían ser un
poco más confusos, creo que esto es definitivamente
valioso de ver Así que sólo vamos a
moverlas a su lugar. Y lo que podría llamar a este
es que estamos actualizando nuestra velocidad actual y luego fijando la
ubicación de nuestro avión. Y como digo eso,
esto es en realidad otra cosa muy útil es que en realidad ahora estoy cuestionando mi propio código porque estamos
haciendo dos cosas por línea. Y si recuerdas, dije, la regla general es
con una secuencia, que los tratamos
un poco como funciones donde las
funciones deberían estar haciendo una cosa específicamente
y una cosa muy bien. Entonces, por el momento, en
su mayoría estamos siguiendo eso. Esto es establecer específicamente
la velocidad objetivo. Esto es calcular y establecer específicamente el movimiento Alpha, pero esto ahora en
realidad es hacer dos cosas. Está estableciendo la velocidad actual, y luego está moviendo el avión. Entonces, lo que podría tener la
tentación de hacer es agregar otro luego pin aquí abajo, control de
mama en X,
control en V. Engancha esto Y nuevamente, más que nada, podría
haberlo dejado, pero solo para mostrar lo
fácil que es mantener limpio
tu código y algo así seguir reglas
y estructuras específicas. Entonces es ahora que
en realidad nos estamos apegando a las
reglas que nos dimos a nosotros mismos, y solo necesito
mover
las cosas un poco y tal vez
agregar otro nodo reroot aquí Las cosas ordenadas un poco. Nuevamente, no estamos tratando de
hacer esta obra de arte, pero cuanto más fácil
sea trabajar con ella, nuestro yo futuro
estará agradecido. Lo que estamos haciendo ahora es
si pensamos en el código. Podemos venir y darle a
este su comentario final. Entonces esto es establecer la velocidad
actual en base a una simple intercalación,
tan Entonces eso es lo único que esta línea está haciendo específicamente. Y entonces, nuevamente,
necesitamos un comentario final, entonces Control C control
V puso esto en su lugar. Quiero decir, tengo un ladrillo lógico muy
bonito, así que esto ahora es simplemente
actualizar la ubicación del avión. Entonces, si tuviéramos
que leer esto,
podemos ver específicamente
lo que está pasando. Estamos fijando la velocidad objetivo. Estamos actualizando el movimiento Alpha, que se utiliza para la función de
interpretación más adelante. Estamos usando esa función de
interpretación y configurando la
velocidad actual en base a eso. Y luego estamos tomando
esas variables, y estamos actualizando la ubicación final del
avión. Entonces esto es ahora probablemente mejor que lo que tenía hace
apenas un momento. Es solo un pequeño
cambio, pero de nuevo, solo apegándonos a esas reglas, pensamos en estas como pequeñas funciones, esencialmente, y todas están
haciendo ese trabajo muy específicamente, y lo
están haciendo bien. Mantén las cosas ordenadas, mantén
las cosas fáciles de leer. Y si alguna vez necesitábamos
volver y eliminar algo, agregarle, entonces va a
ser mucho más fácil actualizar y arreglar nuestro
código en el futuro. Entonces ahí es como tangente lateral. No esperaba ir tanto
a fondo
en la limpieza del código, pero solo volví a ver la
oportunidad porque
como que fui en contra de lo que
mencioné al
principio del tema. Eso hecho. Ese es el
movimiento ahora listo para funcionar. Lo que tenemos que mirar a continuación
es el sistema de rotación. Va a ser el mismo
problema porque estamos haciendo uso del
mismo tipo de cosas. Si vamos a manejar la rotación. Tenemos una
función realmente simple, que es, nuevo, lo realmente bonito
que Unreal hace por nosotros. Proporciona muchas de
estas funciones de ayuda, esta incorporada R interp dos, agradable y simple,
un nodo, algunos nodos al lado
para el cálculo, y luego establece la rotación
activa, y estamos un poco
buenos para ir a la prueba Pero algo de lo que la
gente necesita ser consciente es que en general, solo es
bueno para las pruebas. Probablemente queramos empezar
a rodar nuestro propio código cuando nos pongamos más serios y de
hecho con las cosas. Antes de pasar a
fijar la rotación, solo un par de cosas para
verificar en el movimiento del mango. Debido a que vamos a estar
manejando la velocidad actual un poco más
manualmente de esta manera, probablemente
queremos asegurarnos de que
acabo de notar cuando la hice
clic antes, velocidad
actual tiene
un valor predeterminado El valor predeterminado aquí era
esencialmente cuando esta era originalmente nuestra velocidad de
movimiento general. Así que vamos
a querer restablecer esto y asegurarnos de que la velocidad actual, la velocidad interp de movimiento de
velocidad
objetivo va a tener un valor, pero la velocidad objetivo de la mafia y velocidad
actual están todas
establecidas en cero por defecto, y estas solo se
calcularán en tiempo de ejecución La otra cosa, el mismo problema,
realmente fácil de hacer de nuevo, es que casi me olvido de
marcar la función de barrido, así que esta tiene
la misma función que la
función de ubicación real establecida que usamos anteriormente, así que necesitamos asegurarnos de
que el barrido esté habilitado. Eso debería ser
bastante bueno para ir. Esto no va a funcionar
del todo en este momento. Y me acabo de dar cuenta de que hicimos
esto de la manera equivocada. Creo que te estaba diciendo
que restaras lo
correcto antes, pero durante la implementación,
conecto esto de manera incorrecta Entonces, si hacemos clic alt
después de lo exponencial, realmente importante
aquí, queremos
restar nuestro
cálculo de uno Así que estamos trabajando de vuelta a partir de
uno. Estamos haciendo esa curva de decaimiento a partir de una basada en
esta actualización a lo largo del tiempo. Así que sí, es solo probar rápidamente allí para
asegurarse de que esto todavía funcione. Como mencioné, la rotación va a
estar un poco trabajada, pero seguimos teniendo
el mismo movimiento, así que tenemos algún movimiento
suave agradable, la rotación porque se basa en la velocidad que
tenemos, eso está completamente roto, pero esto es algo con lo que
podemos trabajar, y eso como que lo
mejoramos a medida que
avanzamos y
refaccionamos la rotación Entonces solo un par de recapitulaciones
finales ahí. Asegúrate de que estamos
haciendo nuestro cálculo para nuestro valor exponencial, y luego nos estamos quitando
eso de uno Entonces es uno menos nuestro cálculo
exponencial aquí, y ese es el resultado que
queremos para nuestro movimiento Alpha Velocidad actual, velocidad objetivo, lo
ideal es que te pongas a cero. Estamos calculando eso aquí, multiplicando esos de nuevo juntos, y aquí obtenemos un buen movimiento
independiente de la velocidad de fotogramas Entonces esto sigue siendo
una especie de sentimiento y trabajando muy similar a
lo que teníamos anteriormente. Puede que encuentres que necesitas
ajustar un
poco la velocidad ahora, pero estamos
muy cerca de lo que teníamos Rotaciones rotas,
que como mencioné, se espera porque aquí estamos usando un cálculo muy simple basado en la velocidad objetivo y simplemente multiplicando eso
contra el factor de inclinación, y ahora la
velocidad objetivo o velocidad actual,
perdón, se está manejando de una
manera muy diferente Con eso hecho, sin embargo,
tenemos el movimiento mejorado. Es una muy buena
base para comenzar, y luego podemos saltar
directamente a la rotación Aprecio estos temas
bastante pesados medida que avanzamos por esto, pero espero tomarnos un tiempo
entre los temas, hacer una pausa de nuevo cuando
sientas que necesitas y realmente tratar entender lo que
hemos estado haciendo y por qué estos cambios
van a estar funcionando. Traté de explicar las matemáticas
y las cosas detrás de ellos. Algunas de las cosas son
muy difíciles de cruzar sin tener realmente experiencia práctica con
el código fuente. Entonces esa es otra cosa
es que podrías
saltar al código fuente de Unreal Engine, encontrar la función Ler
en C plus plus Y nuevamente, aunque
no
entiendas completamente C plus
plus, está bien. La mayor parte es
muy legible por humanos. Los comentarios están todos ahí. Es explicar lo que está sucediendo en la
función F interp paso a paso Y a veces simplemente sumergirse en
el código fuente de esa manera, ya que todo está
fácilmente disponible. Sea realmente útil y
comenzará a comprender algunas de las limitaciones de solo
usar la funcionalidad reconstruida y
predefinida
proporcionada por el motor irreal No quiere decir que sea malo, como mencioné,
tiene sus casos de uso, pero sí encontramos estos casos de franja donde
simplemente no funciona, y necesitamos
rodar nuestro propio código
18. 17 - Mejorada rotación: Ajuste de movimiento. Ahora tenemos que hacer lo mismo
para nuestra rotación. Todavía queremos estar dentro
del jugador del avión. Vamos a entrar en la función de rotación del
mango. Voy a hacer una actualización muy
similar aquí. Esto es otra cosa
agradable que
podemos empezar a hacer
el código un
poco más uniforme porque la lógica detrás de él
será muy similar. Entonces, de hecho, aquí podemos dar
nuestros pasos iniciales. Vamos a mover esto hacia abajo. Desengancharemos esto,
y nos quedaremos cualquier cosa a la que podamos
volver un poco más tarde, pero como dijiste,
anteriormente, simplemente nos estaremos deshaciendo
completamente
de eso al final Ahora, lo primero es que
queremos obtener nuestra secuencia. Podemos volver a hacer lo mismo. Así que vamos a tomar un nodo de secuencia, y vamos a empezar a mantener
esto agradable y ordenado porque vamos a necesitar hacer bastantes
cálculos para esto. Así que nos aseguraremos de mantener nuestro código alineado
agradable y ordenado. Ahora bien, hay un poco
extra que tenemos que hacer para la rotación porque
como dije, anteriormente, era algo así como un valor
arbitrario simplemente multiplicándose
contra la velocidad actual sin nada
más contabilizado realmente. Así que vamos a hacer un
poco de sujeción y puesta en orden para que esto también sea un
poco más refinado Lo que queremos es que vamos
a tomar nuestra velocidad actual. Llegaremos a la
velocidad actual que tenemos, así que todavía vamos a
basarla aproximadamente en lo mismo, pero con algunas modificaciones. La forma en que vamos a hacer
esto es a partir de la velocidad actual. Queremos hacer uso
de algo llamado un rango de mapa sujeto Esto va a mapear un
rango de valores a otro, perfecto para convertir la velocidad
a un ángulo de inclinación específico. En el rango A va a ser
nuestra velocidad de movimiento negada. Entonces haremos clic derecho,
buscaremos la velocidad de movimiento porque se está accediendo a esta
desde nuestra clase padre, la velocidad objetivo real, la velocidad máxima que podamos movernos, así que vamos a obtener
la velocidad de movimiento. Vamos a multiplicar
esto por uno negativo. Siéntete libre de darte
espacio a medida que estás atravesando. Entonces ese va a
ser nuestro en rango A.
En el rango B simplemente va a ser la velocidad de movimiento,
tan inalterada ahí Y otra vez, solo darme
un poco más de espacio, ya que vamos a necesitar
algunas cosas más aquí abajo. Entonces vamos a
necesitar un nuevo valor para nuestra
inclinación máxima y mínima que queremos alcanzar. Entonces aquí es donde en realidad
no conseguimos un
poco de control. Entonces podemos decir que o queremos que
esto sea capaz de inclinar un máximo de 15 grados
en cualquier momento o
25 o lo que quisieras
en la categoría de rotación. Y otra vez, si tienes
categorías, está bien. Si no, simplemente agarra cualquier
flotador que tengas. Voy a agarrar
mi factor de inclinación, duplicar esto, y voy a
llamar a este Max tilt. Golpea compilar, y
creo que por defecto, voy a darle a esto un valor
máximo de 15, así que esto se clampas a
rotar 15 grados de cualquier Podrías crear una inclinación mínima, que sería negativa 15, pero similar a lo que hemos
hecho aquí, en cambio, solo
vamos a
agarrar nuestra inclinación Max y vamos a multiplicar
esta por una negativa. Y esa será
nuestra gama A, y empezarás a ver
cómo funciona todo esto. Ojalá, como veas
estos se junten. Y voy a
agarrar nuestra inclinación máxima y entonces esta
será nuestra fuera de rango B. Así que vamos a tomar
nuestra velocidad actual,
sea cual sea nuestra velocidad actual, ya que esta se ha calculado, si está en algún lugar
entre cero y negativa nuestra velocidad máxima de
movimiento. Creo que fueron mil. Entonces nuestra inclinación máxima
va a
oscilar entre cero y negativo 15
basado en una especie de porcentaje,
un valor uniforme que
coincidiría aproximadamente donde está
esa velocidad Y luego viceversa,
si nos movemos a la derecha, entonces vamos a tomar
nuestra velocidad máxima de movimiento, cero a 1.000 positivos, y voy a escoger un valor de
inclinación de 0-15 grados Entonces así es como realmente podemos
sujetar en lugar de simplemente tener una
rotación completamente arbitraria de cualquier manera. De hecho, estamos basando eso
específicamente entre cualquiera que sea nuestra velocidad
actual y luego mapeamos entre las
velocidades reales que podamos Esto hace que sea realmente
fácil de actualizar. Si alguna vez quisimos decir
tener más inclinación, pero mantener la velocidad igual, entonces solo podemos aumentar esto. Podría decir que ahora
se puede inclinar hasta 25 grados en lugar de sólo 15. Para las pruebas,
creo que lo voy a mantener a los 15, pero podemos jugar
con eso muy fácilmente. No queremos promover
esto a una variable. Entonces, sea lo que sea que esto
calcule, vamos a promover a otra variable. Voy a llamar a este objetivo inclinación. Es muy similar a cómo
lo primero que hicimos en movimiento fue calcular
nuestra velocidad objetivo. Y enchufa esto en entonces
cero, mueve esto hacia arriba. Y probablemente vamos a
tener que hacer una buena cantidad de marea aquí para que esto
sea más legible solo porque hay mucho más tipo de matemáticas
en esta función La rotación
siempre es un poco más intrincada y complicada que calcular el movimiento
o el tipo general
de ubicación o incluso compensaciones de
escala Ahora bien, el objetivo
Alfa en realidad es tan similar que voy a
ser un poco perezoso. Voy a volver
al movimiento del mango. Voy a agarrar todo
el código aquí, presionar el control C, así que voy a conseguir todos estos nodos aquí. Lo único que no
queremos es el movimiento Alfa. Vamos a volver
aquí dentro de la rotación, y vamos a enchufar esto
a un valor en un momento. Lo único que tal vez
queramos hacer es que voy a mover nuestra inclinación objetivo a
la categoría de rotación. De hecho voy a cambiar el nombre de
esto porque tenemos algunas convenciones de
nomenclatura ligeramente diferentes en curso Entonces voy a agarrar la velocidad de interp de
rotación y cambiar esto a tilt porque hemos decidido
que todo lo demás se clasifica como
basculante en lugar de basculante en lugar Voy a controlar arrastre
la velocidad de interp de inclinación. Y enchufa eso ahí. Para que podamos deshacernos de la velocidad de interp de
movimiento
al principio Pero aparte de eso, estamos
haciendo exactamente lo mismo. Estamos tomando nuestra velocidad de interp de
inclinación multiplicada por los segundos Delta
del mundo G, multiplicada por uno negativo, obteniendo el retorno exponencial, y luego estamos
creando eso nuevamente, nuestra curva en descomposición Así que estamos quitando todos
estos valores a uno solo. Entonces los resultados de esto serán
entonces otra nueva variable, así que promoveremos esta
a otra variable, y llamaremos a esta
Tilt Alpha. Porque vamos a querer volver
a hacer lo mismo. Estaremos enchufando esto
a nuestra propia interpolación o nodo lop del que vamos
a tener el control total del Así que vamos a mover esto de nuevo tratando de mantener las cosas
algo ordenadas. Creo que solo por limpieza y espacio, solo voy
a eliminar esto ahora. No necesitamos pasar
paso a paso como lo
hicimos antes. Simplemente no vamos a usar nada
del código antiguo aquí. Entonces vamos a crear
otro pin de secuencia. Queremos hacer nuestra
siguiente etapa de lógica. Este es muy
sencillo. Así que muy similar otra vez a la tercera etapa
en nuestro código anterior. Vamos a establecer
nuestra inclinación actual. Y creo que solo
mirándolo ahora, probablemente
vamos a
empezar a mezclar valores aquí. Entonces Max hasta que queramos
y actualmente estamos usando el factor Tilt, creo que
vamos a fallar. Entonces voy a
cambiar el nombre de este
factor de inclinación a inclinación actual. Y esa palabra poco a poco va
perdiendo todo sentido. Eso lo he dicho
demasiadas veces. Vamos a arrastrar esto
y enchufar el pin de ejecución. Y nuevamente, el valor que
queremos rellenar aquí, asegurándonos de que si golpeamos compilar
que este ya no tenga un valor predeterminado,
así que pondremos eso a cero. Este valor se calculará
en base a otro bucle. Así lo mismo otra vez,
un bucle flotante. Y otra vez lo mismo.
Así que vamos a tomar nuestra inclinación actual, nuestra inclinación objetivo, y nuestro
Alfa. Tan agradable y sencillo. Bastante, como mencioné,
como el movimiento, pero ahora todo relacionado con la rotación
o la inclinación. Para que puedas ver el
patrón. De hecho, hemos sido capaces de usar
básicamente el mismo código. Entonces, ¿no
entiendes esto una vez? Muy fácil de
reutilizarla y rehacerla. Necesitábamos ponernos un
poco más intrincados con la parte inicial de
la rotación aquí arriba, pero por lo demás, muy similar Para que podamos volver a hacer lo
mismo. Queremos un pin más,
y esto va a ser realmente usando estos valores
y estableciendo la rotación. Así lo mismo otra vez.
Esta vez sí queremos usar la llamada
a la función de
rotación del actor set. Así que vamos a tapar esto aquí abajo, y volveremos a subir y hacer un poco de orden con
algunas revueltas un poco más tarde Dividiremos el
pin de estructura como lo hicimos anteriormente. Vamos a tomar nuestro valor de inclinación
actual, y vamos a enchufar eso en el que estamos haciendo
esto en el rollo. Y eso es más o menos, pero tenemos los
mismos pasos otra vez. Así que establece el objetivo, establece el Alfa, establece la corriente y luego usa la
corriente como valor. Ahora, sólo voy a
entrar, como mencioné, vamos a hacer un poco de
orden porque esto se está volviendo algo estrecho
y difícil de leer Creo que está bien si no
voy a pasar demasiado tiempo pritting
up los nodos, pero eso es suficiente solo para
mantener las cosas separadas Y como
mencioné, no quiero usar enormes trozos de tiempo solo
comentando mi código No es lo más útil para
ver en streaming o en un video. Pero si quisieras
hacer algo similar, solo una pequeña cosa
para llevar entre temas, tal vez de nuevo, pausar el contenido y
solo decir que está fuera una tarea para asegurarte de
entender lo que está pasando. Lee el código y la rotación
y mira si puedes
darte algunos buenos comentarios para describir exactamente
lo que está sucediendo aquí, por qué estamos usando la
abrazadera de rango y cosas así. Y lo central es que
si necesitabas volver y mirar el código dentro de uno
o dos meses, de un vistazo, esto es mucho más fácil ver
lo que está pasando que esto, actualmente, ya que tendría que
volver y leer en profundidad. Pero vamos a seguir adelante y comprobar que todo está funcionando. Creo que lo principal que tenemos nuestra inclinación Max está establecida en 15, así que solo deberíamos ver una inclinación de 15
grados de cualquier manera. Y obviamente, solo estamos negando eso con base en
la velocidad de movimiento La velocidad de movimiento sigue siendo de mil, lo que creo que está perfectamente bien. Si se siente un
poco más lento, podemos volver y
aumentarlo La velocidad de interp, creo que
queremos ralentizar esto
un poco agradable Creo que vamos a establecer
esto en tres en lugar diez porque nuestra
curva de decaimiento va a funcionar un poco
diferente a lo que estamos haciendo con F interp dos y luego
objetivo actual y Alfa deberían estar todos
configurándose en tiempo de ejecución, por lo que deberían comenzar en
cero, lo cual es perfecto Y entonces solo estamos usando
eso aquí. Entonces esto debería, creo, ahora funcionar. Entonces, si volvemos a entrar, presiona
play. Sí, ahí vamos. Se ve creo que
se ve diferente, pero podemos ver que es
muy lo mismo. Creo que prefiero
la forma en que se ve esto. Es mucho más tipo de que
solo se siente un poco más refinado.
Entonces eso es bastante bueno. Y como he mencionado, aquí es ahora donde entra la
flexibilidad. Si querías cambiar
la velocidad, entonces tal vez eso fue intercalar demasiado lento. Esto lo podemos incrementar. Así que volveremos al modo de juego por aquí. Así que estamos
volviendo a
enderezarte un poco
más rápido. Entonces eso está bien. Y luego si quisieras,
como te he mencionado antes, si no estás seguro de
lo que está
haciendo algo o de qué manera debería ir
un valor, si lo haces realmente drástico, hacer un cambio realmente grande Y se puede ver
que es casi
como devolver el golpe
cuando soltamos Así que la decadencia está ocurriendo mucho más rápido y estamos
devolviendo el golpe. Así que eso podría parecer un
poco más agradable, en realidad. Entonces tal vez me equivoqué, tal vez ir a un
valor más alto en lugar menor hubiera sido
mejor para eso agradable y fácil de probar, pero
esto es lo principal. Intenta inculcar en la forma en que piensas
sobre tu propia base de código, facilitarte las cosas
actualizarlas y ajustar las cosas tarde hará que sea
más probable que refines el juego
y lo hagas Si es realmente
difícil trabajar con tu proyecto, mucho menos probable que
quieras hacer refinamiento Dedica ese tiempo a
mejorar el juego. Entonces solo
hay algo más de diseño , que siempre es
divertido pensar en ello. Lo último es la inclinación máxima. Entonces si agarramos Max tilt, si hago algo mucho más grande, como 45 grados solo para mostrar la diferencia que podemos
conseguir, si ne flotamos, puede ver que cuando empezamos a alcanzar la velocidad máxima, estamos golpeando ese ángulo de inclinación
máximo más alto. Entonces así es como
entra en juego eso. Probablemente no quiera que
rote tanto,
pero es posible que quieras
subir algo tal vez más como 25 para que sea
más perceptible visualmente. Pero lo principal que
tenemos sobre la
implementación anterior es, como ustedes vieron. Realmente no estaba haciendo ningún cálculo
específico para alcanzar un cierto ángulo de rotación basado en la
velocidad o cualquier cosa. Simplemente iba lo más lejos
posible dentro de una cantidad de tiempo
determinada. Mientras que ahora,
tenemos un poco de control. Dependiendo de nuestra velocidad actual, podemos controlar exactamente
cuánto giramos. Y entonces lo realmente
importante a verificar es que voy a lanzar algunos comandos de consola
para deshacerme de los enemigos. No los necesitamos. Sólo
sigue volando hacia nosotros. Voy a entrar en
modo de juego. Voy a darme el comando stat de
consola FPS, para que podamos ver que estoy
corriendo a 120 FPS. Me puse
recto abajo a 30. Y nuevamente, deberíamos
ver que estamos obteniendo un
marco mucho menos agradable de ver, pero todavía estamos obteniendo
solo 25 grados de rotación, y lo estamos golpeando
a lo que ojalá veamos en un momento,
aproximadamente a la misma velocidad. Entonces, si ahora lo aumento a 60, solo
estamos llegando a
la misma rotación, el mismo tipo de pitch
tilt o roll tilt, lo siento. Lo estoy haciendo en aproximadamente
la misma cantidad de tiempo. Y entonces si subimos a 120 o en realidad,
simplemente destaparemos esto Diré como 600, así puedo
conseguir alrededor de 300 FPS. ven más suaves, pero los movimientos suceden
a la misma velocidad, y la rotación está
tomando el mismo número de fotogramas o segundos
para llegar allí. Así que ahora hemos solucionado completamente el
problema de independencia de la velocidad de fotogramas que teníamos anteriormente. Entonces el movimiento, recuerden, no
era realmente un problema tan
grande,
pero la rotación tenía
un problema en el que a
pesar de que estábamos multiplicando por abajo a segundos por eso, solo el tipo de lógica que están usando las funciones F
inter, recuerda que fuimos capaces
de rotar esencialmente el ala hacia el piso porque la rotación no
estaba sujeta Las diferentes velocidades de fotogramas lo estaban
afectando de manera diferente. Así que ahora hemos
resuelto completamente ese problema. Tuvimos que llegar un
poco más rodilla hasta
la rodilla en algunas
de las matemáticas,
hicimos uso de la función de acecho
simplificada más rudimentaria acecho
simplificada Pero tomando las lluvias un
poco con nuestro propio código, ahora
hemos resuelto
un montón de problemas que
se han enviado en
probablemente encontrarás muchos juegos
porque se lanzan muchos
juegos
basados en el ejemplo de porque se lanzan muchos
juegos contenido, ejemplo, código de
producto y
cosas así. Esa es la prueba completa.
Misma velocidad de movimiento. Tenemos los mismos límites
de rotación. No hay alas
recortando el piso. La fórmula exponencial
es la que nos da la interpretación matemáticamente
correcta a cualquier velocidad de fotogramas Espero que un
contenido más profundo como este no haya congelado
completamente tu cerebro y te haya impedido seguir el ritmo. Ese ha sido realmente el
objetivo de los temas cuando estaba creando
estos es tratar de hacer que la
gente piense más en su base de código y lo que está sucediendo bajo el capó y no solo seguir adelante. Entonces ojalá esto
ahora esté llegando al
punto en
el que puedas ver los beneficios de lo que hemos sido mencioné
desde el principio, esto está tomando mucho
más tiempo de lo que podría haber hecho, y podría haber
editado gran parte de la información trivial o lo que pudo haber parecido información
trivial, pero creo que te
habrías perdido mucho sido mencioné
desde el principio,
esto está tomando mucho
más tiempo de lo que podría haber hecho,
y podría haber
editado gran parte de
la información trivial o
lo que pudo haber parecido información
trivial,
pero creo que te
habrías perdido mucho de los
potencial de aprendizaje y realmente entender
lo que estás haciendo. El objetivo aquí es que ojalá
puedas ver algo como esto, ahorrarte
viendo otras dos o tres series o cursos de tutoriales o cualquiera que sea el
caso porque
en
realidad estás poniendo mucho más manos a la obra con los sistemas y arreglando cosas que incluso existen en el
contenido oficial de aprendizaje de Epic. Entonces ojalá haya
valor en eso. Entonces, si realmente querías
empezar a refinar tu proyecto ahora, aquí es donde probablemente
tengas el tipo general de comprensión de lo que
vamos a estar haciendo. Tenemos nuestro proyecto organizado un lugar bastante rígido
y sólido. Entonces, si querías empezar a
experimentar entre temas, aquí es donde quizás
quieras poner un poco de freno. Nuevamente,
esto no es una carrera. No pretendemos
que el proyecto termine lo más rápido posible. Nuestro objetivo es que te vayas, entiendas lo
que estás haciendo y
cómo ampliar lo
que ya aprendiste. Entonces tal vez haga algo simple, incluso si solo está
entrando en tu propio código, viendo si ahora puedes comentar y describir lo que tu
código está haciendo de nuevo a ti mismo usando
algunos buenos comentarios o categorizar las variables Si has notado que tienes
esta larga lista de variables, y puedes ver una manera de mejorar eso luego
comienza
a agregar categorías
a tus variables, cosas
simples para mantener
tu proyecto estructurado, ordenado, fácil de trabajar. Recuerda, el objetivo principal es que las secuencias sean tu control de flujo, haciéndola más legible, como el código normal con guión o el
código escrito Buenos comentarios,
explicar la intención en lugar de simplemente
describir la variable. Cosas como
podrías tener un comentario diciendo interpolación alfa,
pero un buen comentario sería, calcular los valores de
independencia de velocidad de fotogramas basados en interpolación alfa, cosas así para darte un descriptor,
de un
vistazo de lo que estás haciendo, y por qué Sin embargo, con eso hecho, el sistema de movimiento
está listo para la producción. Tenemos movimiento y
rotación
independientes de velocidad de fotogramas suave y
controlada para el jugador, que es la clase más pesada
y compleja que vamos
a tener en el proyecto A continuación,
veremos cómo engendrar enemigos dinámicamente
durante el juego, en lugar de simplemente
colocarlos manualmente, lo que obviamente
va a ser un
poco restrictivo para un juego completo
19. 18: EnemySpawner: Es hora de mirar a automatizar
nuestro desove enemigo. Estaremos construyendo esto de manera
flexible desde el principio. Esto funcionará para
los enemigos para empezar, pero vamos a probarlo en el
futuro solo un poco, así que esto funcionará con cosas
como objetos de fondo o cualquier otra cosa que pueda
necesitar aparecer con el tiempo. No más
colocar enemigos manualmente, lo que será el
primer paso importante. Entonces, para comenzar,
vamos a
entrar en nuestra carpeta Blueprint, y simplemente
crearemos esto dentro de una nueva estructura de carpetas Entonces voy a presionar
Control shift y N para una nueva carpeta, llamar a
este spawners Haga clic derecho, iremos
a la clase Blueprint y queremos crear nuestra clase de actor estándar de
pantano Como ya he mencionado, esto
es sólo un contenedor. Tiene una transformación, un
lugar en el mundo, y entonces podemos dejar caer
nuestra lógica aquí. Le daremos a éste el nombre de BP Underscore Spawner Entonces, como he mencionado,
planeación hacia adelante un poco. No vamos a especificar que esto será sólo para los enemigos, y es posible que tengamos otros
engendros que serán hijos
de esta clase
con herencia Dentro de esto,
solo queremos ir directamente a nuestro gráfico de eventos. No hay nada que necesitemos agregar visualmente para representar esto. Creo que en este
caso, podemos deshacernos de que el actor sea una superposición, y la mayoría de las cosas de aquí
deberían ser receptivas, así que no deberíamos estar
haciendo comprobaciones y actualizaciones constantemente
sobre los eventi, para que podamos deshacernos
de ambas llamadas a funciones Podemos impulsar nuestra lógica central desde una función personalizada.
Yo solo muevo esto. Vamos a crear una nueva
función aquí, y voy a llamar a este
actor spawn Así que de nuevo, todo lo que
estamos haciendo a medida que avanzamos y planeamos es tratar de
mantener esto muy genérico. No estamos diciendo pieza de
fondo de desove, recolección de
desove, enemigo de desove Todo lo que necesitamos pasar
es un argumento del tipo de actor
que queremos engendrar, y probablemente necesitaremos
tal vez alguna rotación aleatoria, un desplazamiento, ubicación
y cosas así Podemos hacer esto
bonito y genérico
y hacer que todo sea
muy reutilizable. Así que siempre tratando de planificar con anticipación. Recuerda, piensa perezoso,
planifica el programa una vez y usa tantas
veces como sea posible. Dentro de esta función,
sacaremos del pin de ejecución, y en realidad tenemos una
función incorporada dentro de Unreal, llamado actor spawn de Cuando estamos usando esta función, lo principal que queremos, como he mencionado,
es una transformación, así que dónde queremos que
esto genere y específicamente en qué tipo de
clase queremos generar Entonces por el momento, eso podría
ser cosas como nuestro enemigo, pero de nuevo, eso
sería demasiado específico. Entonces, si resaltamos y colocamos el
cursor sobre el pin morado aquí, podemos ver que
esto solo
hace referencia específicamente al tipo de actor Entonces estos pines morados son las
referencias de clase reales en sí mismas, no una instancia en el mundo. Cuando tenemos estos pines azules, esta es una instancia real
que existe en el mundo. Podemos pensar en los pines
morados como una referencia a la ubicación dentro
de nuestra estructura de carpetas. Entonces vamos a hacer uso
de esta tipificación genérica. Vamos a sacar
de aquí y de
hecho promoveremos esto a una variable. Le daremos a éste el
nombre de tipo actor. Aprovecha esto ahora
que podemos llenar esto con cualquier tipo de
actor en nuestro proyecto, ya sea un
enemigo, una camioneta,
una pieza de fondo cuando los
agregamos, lo que queramos, ahora
podemos decirle a esta función genere eso en un momento dado Las principales cosas que
vamos a querer exponer son los detalles de la transformación de spawn Entonces si escribimos,
pulsamos sobre esto,
dividiremos la estructura pi. Vamos a dejar la escala de
transformación de spawn a 11 y uno Generalmente, tratamos de no
anular estos. Si todo se ha
configurado correctamente, como con este proyecto, todos
los activos deben ser la escala
correcta para empezar. Entonces nos quedaremos con esto
y solo asumiremos que los activos son importados
y funcionando como se pretendía. Tienes la opción de
aleatorizar o compensar
la rotación, pero voy a mantener esto
agradable y limpio por ahora, y siempre podemos volver
y volver a trabajar Lo que voy a hacer en su lugar,
voy a hacer clic derecho y buscar Obtener rotación de
actor. La razón de esto es que esto significa que podemos enchufar
esto directamente. Y donde quiera que
rotemos nuestro spawner, tenemos el control total
en el editor, así que esta es más
una herramienta de edición ahora, donde si quiero que esto
genere las cosas de lado, solo
necesito recordar
rotar el Alternativa sería exponer esto
a una variable y
enchufar manualmente la rotación, pero me parece que esta puede ser una forma
bastante agradable de trabajar. Es sólo un poco
más intuitivo para mí, siempre y cuando no sea
demasiado restrictivo, lo cual creo, en este
caso, deberíamos estar bien. Para la ubicación, vamos a tirar de aquí y
agregaremos un pin más. Este puede necesitar un
poco de aleatorización, alguna varianza y
compensación suministrada Si hacemos clic derecho, podemos
buscar la ubicación del actor G. Entonces lo mismo otra vez,
vamos a usar las propiedades generales de
donde sea que esté el spawner, así que ese será nuestro punto de partida
base Ahora para este tipo de juegos,
porque sabemos que solo
vamos desde una perspectiva de
arriba hacia abajo, no
necesitamos ninguna
aleatorización en la Z, y probablemente queremos hacer todo nuestro desove fuera
de pantalla, lo que significa que
tampoco necesitaremos ninguna aleatorización en el eje X. Entonces lo que podríamos hacer es
hacer clic derecho sobre este segundo pin vectorial
y dividir la estructura. Vamos a sacar de nuestro Pin
Y justo aquí, y queremos usar ese
nodo de selección que hemos visto anteriormente. No queremos seleccionar flotador. Queremos este de aquí
con el icono único. Esto nos da el comodín
que hemos usado anteriormente. Cambiaremos esto a un booleano, así que o vamos
a aleatorizar o no, y promoveré el índice
aquí a una nueva variable, y nombraremos esta Nuevamente, recordando
darle a eso una minúscula B. Si decidimos agregar
un desplazamiento aleatorio, queremos proporcionar algún tipo de valor flotante
dentro de un rango Y nuevamente, hemos
visto cómo hacer esto, así que ahora solo estamos superando las funcionalidades
y enfoques que ya hemos
tomado en el pasado Entonces, si esto es cierto, si estamos
agregando un desplazamiento aleatorio, vamos a tirar de aquí
y vamos a usar esa función flotante aleatoria en rango que
hemos visto antes. Y a partir de esto,
queremos solo una distancia, así una distancia mínima y una distancia lateral máxima
que podamos aplicar Entonces, si conseguimos nuestro flotador
máximo aquí, y solo promoveremos
este a una variable, y solo le daremos a esta
el nombre de distancia de desplazamiento. El mínimo es como
hemos visto antes, con velocidades y
cosas así,
solo va a ser el negativo
inverso, así podemos controlar el arrastre
en la distancia de desplazamiento, multiplicar esto por uno negativo, y luego tapar el
resultado aquí. Entonces, si establecemos una distancia
de digamos 100 unidades, y queremos que eso suceda
a ambos lados desde el centro
de la pantalla, colocaríamos a este
actor desove en el centro
de la pantalla, enchufaríamos el valor 100
en la distancia de desplazamiento Eso significa que puede
engendrarlo -100, positivo 100 o algún
valor intermedio Si decidimos no exponer la variable y no tenemos habilitado
el desplazamiento aleatorio, entonces solo
vamos a agregar false. Así que vamos a agregar cero
a nuestra transformación general, lo que significa que el actor generará exactamente donde lo hemos colocado Tan relativamente simple, pero sigue siendo una especie de herramienta para desarrolladores, algo sobre lo que podemos construir
si se necesita más complejidad, pero nos da cierta flexibilidad y variación en nuestro proyecto, lo que
generalmente hará que las cosas vean más interesantes
y divertidas de jugar. Cosa que aún no he mostrado,
y quiero presentarlo aquí porque estamos haciendo
un desarrollador muy rudimentario Esto es algo que es realmente útil dentro de Unreal Otros motores hacen cosas similares, y eso es permitir que la
gente vea las variables fuera
de la clase. el momento, por
ejemplo, si agarramos una de nuestras clases de spawner y simplemente
dejamos esto en el mundo, asegurándonos de que hemos
compilado y guardado todo, podemos ver aquí que
los objetos seleccionados, ninguna de esas
variables que
acabamos de crear están
realmente expuestos No sería
capaz de
entrar manualmente por instancia. Entonces, si tuviéramos tres
o cuatro de estos, no
podríamos
escoger que este tuviera alguna aleatorización y
una distancia única, y esta no tuviera
aleatorización, por ejemplo Actualmente solo tenemos un
lugar podemos cambiar eso, y eso es justo
aquí en la gráfica. Entonces, o obtendría este
booleano y lo apagaría, y luego eso está encendido o
apagado para todos ellos Y de igual manera, por la distancia. La manera realmente útil en la
que podemos anular esto son estos iconos aquí. Puede que aún no los hayas
tocado, pero si hacemos clic en estos,
proporciona un pequeño icono de ojo. Por defecto, empiezan cerrados,
y podemos abrir el ojo. En otros idiomas,
esto se conoce como
hacer público algo. Está expuesto a
otras clases y legible y escribible
fuera de solo esta clase Fuera de un plano irreal,
esto es solo hacer que la variable sea
editable esencialmente fuera de la Entonces, si
volvemos a entrar en nuestro punto de vista con los mismos
objetos seleccionados, se
puede ver que en
el desplegable predeterminado, tenemos acceso al tipo de actor que
queremos que esto genere Entonces aquí es donde
podríamos empezar a hacer cosas como esta podría ser
un engendro enemigo No vamos a hacer esto, pero esto podría ser
un generador de jugadores. Entonces ya tenemos
cierta flexibilidad en lo que estos
van a engendrar Y luego como los enemigos podrían querer ser más aleatorios, podríamos encender este
para que sea cierto para agregar un desplazamiento aleatorio
en cualquier dirección,
y podríamos
establecer que sea , como he dicho, tal vez 100 unidades a la izquierda y a la
derecha del generador. Tan agradable y simple,
como has visto, no
es una configuración muy compleja, pero ya tenemos
una cantidad relativa de flexibilidad y libertad
con la forma en que usamos esto. Entonces, por el momento, si
tuviéramos que agregar esto en comenzar
a jugar y conseguir que esto se llame
una vez, un enemigo no va a ser un gran
desafío para nuestro jugador. Entonces lo que queremos hacer es agregar
algo de desove continuo. Vamos a evitar
usar cosas como retrasos y bucles ya que esto se vuelve
desordenado e inflexible Entonces quizás hayas visto
algo como esto antes, donde al empezar a jugar, de nuevo, solo
quiero visualizar algunas de las cosas que he visto
en muchos proyectos. Entonces tal vez tengas algo así como, vendremos en la primera vez y engendraremos un actor una vez.
Luego agregaremos un retraso. Entonces, un retraso es solo un
tipo de proceso de espera cronometrado. Esperaremos,
digamos, 3 segundos. Antes hacemos lo siguiente, y luego volveremos a engendrar actor. Y puede que se sienta tentado
a entonces entrar aquí, y tal vez después de cada
vez que se haga esto, intente encontrar la manera de recordarse
a sí mismo Se va a ensuciar. Terminas viendo a la
gente hacer cosas así, vamos a
bucle de fondo, y terminas con
este bucle infinito donde la gente dice que
después de que hayamos engendrado esto, vamos a esperar
otros 3 segundos
y volver a llamar al actor spawn Así que vamos a evitar
este código de estilo para principiantes. Lo que queremos usar en cambio
es algo llamado temporizadores. Estos son mucho más limpios,
y nos da mucho más control sobre si
y cuándo los llaman. Entonces, fuera de nuestro start play, el pin de ejecución, queremos encontrar una función llamada I valid. Queremos esta opción con el signo de
interrogación en la parte inferior. Esto es verificar
si otro objeto o actor es actualmente
válido, es decir, ¿existe, y no
se envía a recolección de
basura para su limpieza si está siendo destruido
o algo así? Desde el objeto de entrada, así que lo que
queremos comprobar si existe, vamos a tirar de aquí y usar esa función incorporada, el peón get player Entonces esta es, de nuevo, solo una
de esas cosas a considerar. Sucede en muchos
juegos nuevos para desarrolladores donde has
hecho un juego como este, y los enemigos han
destruido al jugador. Pero incluso cuando estás en
el juego por encima de la pantalla o simplemente
estás
esperando los créditos o lo que sea que suceda después, puedes ver al
enemigo aún desove o disparando al jugador, especie de perro amontonado
en un cadáver Simplemente se ve un
poco intenso, y suele ser porque no
hay chequeo en mitad de juego para ver si los jugadores realmente se clasificaron como muertos o ya
no Lo que vamos a hacer es que si el jugador ha sido
retirado del juego, ya no
hay necesidad de
que aparezcan enemigos , así que
vamos a parar Si esto es cierto, así que si el
jugador sigue siendo válido, vamos a llamar a
una función aquí, que es el temporizador establecido
por nombre de función. Queremos esta opción aquí, y lo primero que podemos
rellenar es el tiempo aquí. Entonces este es el tiempo que
vamos a esperar hasta llame a
esta función que vamos a
crear en un momento. Entonces, por el tiempo mismo,
podemos sacar de aquí, y podemos buscar otro flotador
aleatorio en rango. Y un pequeño truco, que puede ser bastante útil
cuando no se busca solo
tener el mínimo y el máximo o algo simplemente ser lo inverso
el uno del otro. Podemos hacer uso de
algo llamado un vector dos D. Así que si creamos
una nueva variable, vamos a nombrar a esta una
spawn interval. Y vamos a
bajar esto, y vamos a buscar
aquí en lugar de un vector, que es un valor flotante de tres
puntos, vamos a
buscar vector, también. Queremos este de
aquí abajo, el vector dos D. Y si golpeamos Compilar, podemos ver todo esto es solo dos
valores de punto flotante en su lugar, donde el valor X va a ser nuestro mínimo y el
valor Y será un máximo. Así que podríamos establecer esto en
algo así como un mínimo de 3 segundos antes de
que algo genere en y un máximo de seis Y podemos volver
y retocar esto más tarde. Podemos controlar arrastrar
esto a la gráfica, hacer clic
derecho sobre el pin de estructura, dividir el
pin de estructura aquí, y
podemos decir mínimo, máximo. Así que un buen tipo de
forma limpia y ordenada de configurar la función de
sincronización. Para el nombre de la función, tenemos a
nuestro actor spawn por aquí. Una cosa siempre
tiendo a hacer, de nuevo, en parte porque soy perezoso y no
quiero escribir cosas,
pero también para evitar cometer errores
ortográficos o errores de mecanografía. Voy a presionar F
dos para renombrar esto, presionar Control N C para
copiar y luego controlar NV por aquí para pegar esto en asegurar que
tengamos la misma ortografía, las mismas mayúsculas, evitando cualquier error en el nombre porque esto es
sensible a mayúsculas y minúsculas y necesita ser
deletreado exactamente igual No vamos a
establecer esto en bucle, pero si tuvieras
una función en la que
quieres que siga
funcionando constantemente, podrías establecer esto en bucle, y simplemente
seguiría dando vueltas
y vueltas y
esencialmente llamándolo Para querer un poco
más de control manual. Me aseguraré de que
esto no esté marcado. Y lo que podemos hacer
es si agarramos todo este código, incluido
el es válido, porque si piensas en esto, cuando comenzamos a jugar por primera vez, no
hay razón para
que el peón del jugador no
sea realmente un objeto válido Siempre va a
existir cuando presionemos play. Entonces, lo que vamos a
hacer en su lugar es clic
derecho en cualquiera
de estos nodos, y vamos a colapsar
esto en una función. Le daremos a esto el nombre
de llamada spawn Aca timer. Así que aquí solo estamos
ofuscando un poco la lógica Entonces, nuevamente, los pasos son
un poco más claros y fáciles de entender a medida
que avanzamos por nuestro código. Y la forma en que
realmente queremos
manejar esto es que probablemente
vamos a querer crear
algunos enemigos de inmediato Entonces, en lugar de desovar
basado en un temporizador, podemos evitar esto antes que nada Entonces comenzaremos por engendrar a
un actor directamente en. Dejaremos esto en
nuestro pin de ejecución. Y nuevamente, solo
pensando en el orden de la lógica en nuestro código. Así que siempre podemos
reelaborar cosas como. Vamos a empezar a
tocar, y vamos a engendrar a un actor de inmediato Lo que esto va a hacer,
caerá aquí. Entonces vamos a buscar nuestro tipo de actor si
tenemos un conjunto, elegir una ubicación y un desplazamiento, si hay un desplazamiento
a aplicar, y seleccionar la rotación y
generar eso en un punto Y después de esto, aquí
es donde podemos empezar a hacer un looping casi
automático aquí Entonces, si quisiéramos que
esto siguiera adelante, podríamos tomar nuestro temporizador de actor de
engendro central, dejar esto justo aquí Y lo que esto
hará ahora es que esto va a entrar, y esto es más importante
aquí porque en tiempo de ejecución, es donde algo después
del primer o segundo engendro, posible que
hayamos tenido que destruir al
jugador Entonces este que hago
nuestro es cheque válido, un cheque realmente simple,
barato para
asegurarse de que el jugador
sigue en el juego. Y si lo son,
vamos a permitir que genere otro actor, así usando la
función spawn actor, básicamente, llamando de nuevo a esta
función después un periodo o
intervalo de tiempo establecido Ahora bien, es algo que
me gusta bastante hacer, y esto es completamente opcional. Pero debido a que cuando estamos usando la set time by function
name, no
podemos hacer doble clic y encontrar lo que esto
realmente está llamando, necesitamos mirar a través de
nuestra lista de funciones y encontrar el nombre que coincide. Lo que me gusta bastante hacer es
que voy a la función por aquí y simplemente deje caer esto debajo del temporizador
establecido por nombre de función. Entonces esto significa que si alguna vez estoy mirando a través de mi
código en el futuro, si llego a este punto
y me doy cuenta arreglar o cambiar algo
en esta función aquí, solo
puedo
hacer doble clic en este nodo, y eso me llevará a lo
que está llamando esa función. Entonces solo un
pequeño consejo ahí, pero me parece que puede
ser muy útil, sobre todo cuando
vuelves a
retocar las cosas si esto terminó por
no ser lo suficientemente flexible, necesitábamos quitar
algo, solo una buena manera de navegar Pero eso es prácticamente
todo lo que necesitábamos. Ese es un buen tipo
de generador autoencapsulado, autocontrolado con cierta flexibilidad en los diferentes tipos de actores en los
que podemos desovar, dónde van
a desovar y si hay alguna También podríamos bajar y exponer los
intervalos de desove también Entonces podríamos tener a cada actor
diferente, cada engendro diferente, teniendo diferentes intervalos cronometrados sobre cuándo las cosas deberían Así que asegúrate de
compilar y guardar. Una cosa que sí quiero
agregar antes de que realmente vayamos probar esto es si vamos a
la sección de componentes, vamos a agregar algo
aquí, voy a buscar el componente flecha. Entonces, en realidad hay
un componente aquí que
podemos usar que es
solo una flecha visual. Podemos cambiar el
color si quisieras cambiar el color
por diferentes razones. Pero lo principal es, de
nuevo, de un vistazo, esto solo nos permitirá
saber qué camino va a seguir,
así que siempre es por defecto señalar
hacia adelante Entonces, si golpeamos compilar y guardar volver
al nivel principal, podemos ver, de hecho,
aquí, los enemigos
van a estar enfrentando el camino equivocado. Así que me voy a
deshacer de algunos de estos sólo vamos a probar
con uno a la vez. Asegúrate de que esto no
se superponga con el piso, lo contrario los enemigos
no podrán moverse. Y entonces podemos simplemente rotar
esto 180 grados sobre la Z. Y se puede ver que
eso ahora está apuntando hacia nuestro inicio de jugador, lo que significa que si ponemos
esto a nuestra clase enemiga, podríamos darle a esto una
distancia aleatoria a cualquiera de los lados, y unos intervalos de engendro
bien ahí Podemos presionar play, y eso generará
uno en seguida Entonces dentro de tres a 6 segundos, deberíamos ver a otro
desovar en, y ahí vamos Entonces tenemos a nuestro
actor desove aleatorio funcionando correctamente. Al proporcionar la rotación
que mencioné, podemos ver exactamente dónde
va a desovar esto en qué
dirección vas a estar mirando El principal problema que
tenemos ahora es, claro, que podemos verlos aparecer, así que queremos retroceder un
poco
esto para que estén
desove fuera Ellos harán esa animación, y luego van a aparecer
con ese intervalo dado Si quisieras mit una posición
ligeramente diferente, o si quisieras más de ellas, podrías escalonarla de esta manera, así podríamos tener
múltiples reproductores Podrías proporcionar diferentes distancias de
desplazamiento, diferentes
intervalos de generación, y
podrías escalonarlos un poco de
esa manera Nuevamente, para hacer que la jugabilidad y la interacción sean
mucho más interesantes. Creo que por el momento, probablemente
podríamos salirnos con la suya con un solo engendrador
para nuestros enemigos Entonces, si nos enteramos
o decidimos no se está
generando lo suficiente en tiempo de ejecución, podemos volver y
agregar más o
jugar con estos intervalos de
generación. Entonces otro poquito
de experimentación o tarea que te
puedes dar a ti mismo. Aquí puedes hacer algunas
cosas simples como duplicar el spawner y probar
diferentes configuraciones,
como acabo como acabo Pruebe diferentes intervalos de generación,
diferentes distancias de desplazamiento, diferentes distancias de desplazamiento habilite o deshabilite
la aleatorización E idealmente, si hasta ahora has
salido
del contenido y creado tus propios tipos de enemigos
diferentes, es posible que tengas enemigos que
solo se mueven hacia adelante o hacia atrás o de lado a lado,
cualquiera que sea el caso. A lo mejor intenta agregar algunos
generadores diferentes
para diferentes
enemigos solo para ver cómo puedes hacer uso realmente
fácilmente de este sistema algo
flexible Y eso es lo principal aquí. Estamos viendo y
pensando en cómo
diseñamos nuestro sistema. Podría haber creado
una clase de actor específicamente para
engendrar sólo enemigos. Podríamos haber entrado en
la clase y
codificar la lógica aquí para engendrar
específicamente enemigos Habríamos necesitado entonces
haber hecho lo mismo para un tipo de enemigo diferente o los antecedentes
cuando lleguemos a eso. Esencialmente, muchos
duplicados funcionan de nuevo, más cosas que salir mal
y más errores que corregir. Mientras que con este
enfoque, podemos reutilizarlo para los
fondos posteriores, diferentes tipos de enemigos, jefes, para
lo que quisieras
hacer uso de esto
20. 19 - ProjectileBase: Entrando en una de
las partes divertidas ahora, es el momento de agregar
algo de poder de fuego. Esta va a ser de nuevo una clase de
proyectil que funcionará para los
jugadores y los enemigos Al igual que antes, vamos
a pensar en el futuro antes, haciendo esto personalizable
para los colores, el daño, centrándonos en ese
diseño inteligente por adelantado, ahorrando en la duplicación más adelante. Entonces podemos dejar el
subrayado BP Sponerbse
si aún estás aquí Vamos a entrar en
nuestra carpeta de planos. Voy a volver a
la carpeta principal de planos aquí Crearemos una nueva carpeta,
así que controlamos el turno en N, y llamaremos a
ésta proyectiles Ahora por el momento, hay muchas posibilidades de
que este proyecto sólo
acabe alguna vez con
un tipo de proyectil Como he mencionado,
vamos a tratar hacer esto lo más flexible
posible. Pero nuevamente, en
versiones ligeras más avanzadas o destelladas de este proyecto, tal vez quieras cosas
como misiles caseros,
láseres, estilo escopeta,
explosiones de proyectiles y cosas por el estilo Por lo que no
necesariamente siempre
podremos reutilizar el
proyectil que tenemos Así que todavía vamos
a asumir que podríamos querer
construir sobre esto más adelante, aunque no lo hagamos para
este proyecto más pequeño. Así que vamos a hacer click
derecho aquí nuevo dentro de la nueva carpeta. Crearemos una nueva clase de
planos. Una vez más, este
será un actor sencillo, y le daremos a
éste el nombre de proyectil
BP Underscore Volveremos a lanzar la palabra
base al final si acaso
quisiéramos expandir esto un poco más tarde con versiones secundarias
similares pero ligeramente
únicas. Dentro de nuestra nueva
clase de actores, solo queremos, primer lugar, crear
una nueva malla estática. Así que vamos a
agregar un nuevo componente, malla
estática, y podemos arrastrar esto directamente a la raíz de escena
predeterminada. Entonces nuevamente, haciendo de este
el nuevo componente raíz. Con la malla estática seleccionada, vamos a ir
al lado derecho. Yo proporcioné aquí el proyectil de
subrayado SM, así que seleccionaremos este Y esta será nuestra
visual del proyectil. En el lado izquierdo,
volvemos a los componentes. Podemos dejar caer esta línea
nuevamente, y podemos ver aquí si buscamos la
palabra movimiento de proyectiles Tenemos nuestro componente de
movimiento de proyectiles. Unreal tiene un sistema incorporado para que esto simplifique
parte de la configuración Ahora bien, en realidad no vamos a estar
usando esto porque de nuevo, es bueno tener el
control total de nuestra propia lógica. Déjame
mostrarte cómo funciona esto. Entonces, si golpeamos compilar y
guardar con este set
activado, queremos ir al lado
derecho aquí en el panel Detalles con el movimiento del
proyectil seleccionado Queremos convertir la escala de
gravedad a cero. De lo contrario vamos a tener
alguna caída con el tiempo. Y le daremos a esto la velocidad de movimiento
inicial de 300. Si entramos,
golpeamos compilar, vamos a
entrar en nuestro viewpot y simplemente bajaremos
esto al nivel Ahora, no voy a presionar play porque realmente queremos
ver esto moviéndose. Pero la forma en que esto básicamente funciona es que podemos golpear simular, y veremos que
se dispara a aproximadamente 300 unidades. Entonces funciona. Es agradable
y sencillo de configurar. Pero como mencioné, hay una razón por la que
no vamos a usar esto. Y eso se
debe principalmente a que el componente incluye la replicación de red, cosas que
realmente no necesitamos. Muchos
cálculos físicos, de nuevo, que no son necesarios para lo que
vamos a estar haciendo, manejo de la gravedad, que hemos desactivado explícitamente,
pero sigue ahí. También es un
poco inflexible. Queríamos agregar cosas como
aceleración, con el tiempo,
homing, todo esto está un poco
encerrado en la implementación de Epix Por mucho tiempo, creo que el homing no
funcionó correctamente Hay algo de trabajo alrededor
que puedes forzar en eso, y la aceleración
definitivamente no funciona. Es muy difícil
si
quisieras enfatizar la velocidad y
hacer que algo se vea un poco caricaturesco y pasar
de 100 unidades de velocidad y luego subir a 600 con el tiempo,
para luego volver a bajar Es muy difícil controlar la velocidad de estos
componentes en tiempo de ejecución. Esencialmente, si generas
esto al mover 100 unidades, esa va a ser
la aceleración, el valor de
la velocidad
para ese proyectil
hasta que lo restableces o lo destruyas Entonces por esa razón,
vamos a deshacernos de este actor y solo por
esa razón. Más bien mostrarte cómo
podemos implementar alguna lógica muy similar y mucho
más simplista para nuestro propio movimiento de proyectiles Entonces solo para hacerle saber
que estoy al tanto de que esto existe, aunque lo vamos
a eliminar. Vamos a deshacernos
de ese componente, y esencialmente vamos
a rodar nuestra propia versión
personalizada específicamente para hacer lo que necesitamos en nuestro proyecto. Entonces, si saltamos
al gráfico de eventos, aquí
vamos a hacer
el estándar. Vamos a deshacernos de
nuestra Ley para comenzar a superponerse. Y recuerda lo que he dicho
antes, podemos usar venti, y esta es una de
esas instancias nuevamente, donde queremos que esto se
mueva sin problemas a lo largo tiempo con alguna lógica de
movimiento simple Entonces eventk es donde
queremos que esto funcione. Interesarse y
quería indagar
en el código fuente
del motor Unreal, así es como
está funcionando ahí el componente de
movimiento del proyectil está funcionando ahí el componente de
movimiento del Eso se está ejecutando en venti para mantener las cosas actualizadas constantemente, marco independiente
y agradable y sin problemas La lógica que necesitamos para
esto es realmente sencilla. Entonces, si sacamos de
nuestro pin de ejecución, vamos a buscar
el offset local del actor add. Esto asegura que
la ubicación
del proyectil se mueva hacia adelante en relación con
su propia rotación Entonces esto es otra
cosa realmente agradable es que solo necesitamos enchufar de qué manera enfrentarnos
cuando lo empecemos a desovar Y al usar esta funcionalidad, asegura
que siempre se
moverá en la dirección correcta. Vamos a dividir la
estructura aquí, puramente porque sabemos
que sólo queremos que esto
se mueva sobre el eje X, hacia adelante y hacia atrás. Pero definitivamente podrías
volver y hacer
algo de movimiento lateral
si quisieras convertirlo en algo de movimiento lateral
si quisieras convertirlo un proyectil homing o
algo así Todo desde el Delta X. Promocionaremos esto a una
variable para que obtengamos un flotador, y llamaremos a esta velocidad
de movimiento. Hit compile, y le daremos a
esto un valor predeterminado de algo así como 2000
unidades, o tal vez 2,500. Podemos regresar y
cambiar eso más tarde si eso resulta
ser demasiado rápido. Entonces, claro, sólo
tenemos que entrar aquí. Tomaremos nuestra velocidad de movimiento. Multiplicaremos esto
por nuestros segundos Delta, haciendo que como con el movimiento de los
aviones, todo sea independiente de la
velocidad de fotogramas, y luego conectaremos ese resultado aquí. Y eso es prácticamente todo. Tenemos un movimiento de
proyectil independiente de velocidad de fotogramas, que se moverá en la
dirección en que se genere, haciéndolo agradable y
fácil de usar
ya sea para el jugador o para el enemigo, independientemente de la
forma en que el
avión inicial esté enfrentando una implementación simple y
rápida, pero es personalizable si necesitábamos
extender Entonces, en los temas anteriores
sobre Mirando a los enemigos, mencioné que el
proyectil estaría manejando su propio sistema de colisión
y daño, y eso es exactamente lo que
implementaremos ahora Entonces con la
malla estática seleccionada, vamos a bajar a
los presets de colisión Y queremos cambiar el
preset aquí de bloque todo a solapamiento o dinámico.
Así que vamos a bajar esto. Encontraremos la
superposición o dinámica, y podremos ver qué le hace eso
a los ajustes preestablecidos de colisión La razón principal es
que el proyectil no
debe
empujar físicamente las cosas. Eso puede terminar en situaciones
donde las cosas se ven con fallas, donde todo lo que realmente
necesitamos hacer es ser conscientes de que han
tocado Y si empiezas a
ser empujados hacia atrás o los enemigos empiezan a moverse con proyectiles, puede
parecer un poco
extraño para el jugador Si queremos agregar knock
backck como característica, eso está perfectamente bien, pero
lo haremos a través del código para
que tengamos el control total Generalmente, cuando dos
cosas
se superponen físicamente con la función de
bloqueo, todos modos no
parece
llamar atrás. Parece que dos cosas están luchando por habitar
el mismo espacio, y simplemente no es
agradable de ver Todo lo que necesitamos que haga el proyectil es detectar y golpear algo, y cuando eso suceda,
aplicar daño. No hay simulación física
o cosas así. Haremos lo mismo
que hemos hecho antes. Vamos a desplazarnos hacia
abajo hasta el fondo. Encontraremos la sección de eventos, y queremos agregar
el componente on para comenzar la llamada
a la
función de superposición aquí. Entonces, cuando esto se superpone a
algo más, igual que lo
hemos hecho antes, necesitamos encontrar
alguna información y ver si se
aplicará daño. Llevaremos aquí al actor,
así que al otro actor, nuevamente, igual que antes,
promoveremos esto a una variable, y llamaremos a
éste solapamiento a actor. Y esto es porque la misma
razón que con los enemigos. Vamos a querer
verificar alguna información
contra esto. No queremos seguir
tirando de este pin aquí, así que usaremos una variable que
hemos almacenado como referencia. Entonces, lo primero
que creo que queremos dar cuenta es si lo que hemos solapado es referenciado como lo que es sponda
entonces el actor propietario Entonces, por ejemplo, si
el enemigo dispara, y esto está clasificado como
un proyectil enemigo, no
queremos que aplique
daño al avión de ese enemigo Y de igual manera, si el
jugador dispara un proyectil, éste se clasifica como el proyectil de
capas Obviamente no queremos
aplicarnos daño a nosotros mismos. Entonces, lo primero
que podemos hacer es conseguir que nuestro actor se superponga, y
comprobaremos si esto es igual a un
tipo específico de actor nuevamente Entonces, si esto es igual a, y podemos buscar
otra variable
rastreada incorporada proporcionada y rastreada por el motor Unreal por defecto, lo que también podemos
hacer uso de ella Vamos a
buscar dueño de G. Entonces, cada vez que algo se
genera en el mundo, inmediatamente
se le da el
concepto de lo que es poseerlo, lo lo engendró a la existencia.
Entonces podemos usar esto. Entonces podemos decir que si
lo que hemos solapado es también el dueño, entonces sólo vamos a
omitir aplicar daños. La razón principal de esto es
que es posible que queramos elegir nuestro punto de desove tal vez directamente en
medio del avión Entonces va a haber
un momento muy breve donde el proyectil
que
genera el jugador esté realmente dentro
del avión por un momento Si ese es el caso, entonces sólo
vamos a ignorar la primera superposición
aquí, no vamos a hacer nada. Entonces vamos a tirar una rama aquí, que es nuestro flujo condicional, así comprobaremos si debemos hacer algo
basado en este resultado. Y si eso es cierto, entonces
esencialmente podemos simplemente saltarnos,
no haremos nada en absoluto. Ahora bien, la forma en que generalmente me
gusta leer estos, sin embargo, es que me gusta hacer cosas fuera de la tropa en la medida de lo posible. Esta es una preferencia personal. Nuevamente, diferentes programadores siempre
tendrán diferentes preferencias
sobre cómo abordan las cosas Pero prefiero mi código finalizado
real, lo que sigue adelante para hacer la funcionalidad principal se haga
realidad. Entonces, lo que voy
a hacer es en realidad hacer un checkout ligeramente diferente solo
quería mostrar la forma más
legible en primer lugar, pero con un cambio muy pequeño, en realidad
podemos
buscar no es igual a. Entonces un signo de exclamación
e igual
nos dará un cheque no igual
al factor de superposición Vamos a enchufar esto
aquí, y esto ahora hace el cheque invertido. Entonces esto es verificar si
la cosa es el dueño, y esto ahora está comprobando
que la cosa no es entonces. Entonces, si enchufamos esto en su lugar, obtendremos este resultado aquí. Entonces estamos diciendo que si el
dactor de superposición no es el dueño, y así es como me
gusta ejecutar mi código, es que si ese no es
el objeto propietario, entonces podemos hacer nuestra aplicación de
daños Entonces, una vez más, algo de
esto es realmente solo para mostrar la diferente manera en
que puedes pensar sobre tu código y la
manera diferente en que puedes tener múltiples enfoques para
resolver el mismo problema, incluso si solo se reduce
a cómo se lee el código. Y esto es agradable y sencillo ahora. Podemos volver a conseguir nuestro actor de
superposición, Control arrastra esto,
sacarlo de este pin, y ya lo
hemos hecho antes. Vamos a llamar al daño
de aplicación esa función universal global. El que se puede aplicar
a cualquier tipo de actor. Para que podamos verterlo
en el verdadero alfiler. Si lo que
golpeamos no es nuestro dueño, entonces podemos aplicarle daño. Creo que por defecto, le
voy a dar a esto un valor por defecto de 20, así que
enchufaremos 20 aquí. Promocionaremos esto
a una variable. Nuevamente, recuerde, si coloca un valor aquí antes de
promoverlo a una variable, esa variable
ya lo tendrá almacenado. Y lo principal es que no
queremos números mágicos. Sólo voy a renombrarle este
a daño de proyectil. Pulsa compilar y solo vuelve a
verificar que
deberíamos tener el número
20 rellenado aquí. Ahora, idealmente, una vez que
hayamos hecho esto, posible
que queramos comenzar a
reproducir algunos efectos de sonido y efectos de partículas
específicos del proyectil Yo proporcioné algún tipo
de chispas
realmente pequeñas en lugar de
una explosión completa, solo para indicar que
algo ha golpeado una superficie en lugar de
causar realmente una explosión. Entonces para hacer eso, voy a usar el mismo concepto que
mencioné anteriormente. Voy a presionar C dentro de la gráfica de eventos
sin nada seleccionado. Sólo voy a presionar C
para crear un nuevo comentario, y voy a darle a esto
una gran señal para hacer aquí, y luego solo diremos algo
como implementar efectos. Esto será algo
que hagamos en nuestro pase de pulido un poco más tarde. Eso está bien. Ni esto solo
nos recordará que volvamos aquí. Como ya he mencionado,
normalmente le doy a esto una especie de color amarillo verde solo para recordarme y realmente standite frente a otras cosas que puedan aparecer en la gráfica Pero lo que
definitivamente queremos hacer es que una vez que hayamos
jugado nuestros efectos, queremos asegurarnos de que el proyectil se
retire del juego Entonces vamos a sacar
del pin de ejecución, buscaremos al
actor destructor y nos
desharemos de nosotros mismos. El proyectil ha hecho su trabajo para que pueda desaparecer. Y
eso es prácticamente todo. Entonces vamos a comprobar
lo que hemos solapado. Si no es el dueño, entonces vamos
a aplicar daños. Ahora bien, esta es una llamada realmente segura. Quizás se pregunte qué pasa
si golpeo los límites laterales o algo así como un piso en el que
pueda colocar o una camioneta
o algo así Ahora bien, si eso sucede
y no tienen el on ninguna función de daño
que vimos antes, así podemos ver aquí
el suceso cualquier daño. No tienen esto implementado dentro de su base de código,
entonces eso está perfectamente bien. Recibirán
esta información, pero no tienen un sistema de salud ni
nada con lo que lidiar. Entonces es como un mensaje de tirar
muy, muy barato. No vamos a tener problemas de
rendimiento a
menos que hagamos algo realmente drásticamente
malo con esto, y no va
a hacer nada No voy a estar destruyendo los pisos ni las paredes
ni nada de eso. Entonces es una función agradable y segura. No necesitamos saber
nada del otro actor. Mientras hayamos
tocado algo,
podremos encontrar alguna
información genérica al respecto. Y si pensamos que tal vez
queramos intentar aplicar daños, entonces
eso está perfectamente bien. Sólo podemos mandar este mensaje. Entonces lo último es
hacer esto reutilizable. Ese es el daño implementado
de manera bastante universal. Queremos asegurarnos de
que nuestros proyectiles coincidan con el color del tirador, así el jugador disparará
proyectiles azules y los enemigos
dispararán proyectiles verdes o
lo que quieras personalizarlo lo que quieras Así que vamos a volver a subir a nuestra función de comenzar a jugar aquí. Solo queremos hacer esto una vez cuando se genere el proyectil Queremos realmente
agarrar nuestro componente. Podemos hacer algún código sobre los componentes que ya
tenemos, así que lo arrastraremos
al gráfico de eventos, y vamos a tirar
de aquí y
buscar crear instancia de
material dinámico. Entonces aquí solo tenemos esta
opción. Y este es uno de
los beneficios de usar instancias de
material sobre
nuestro material maestro, el código de sombreado base es
con la instancia de material, podemos convertirlas en
una versión dinámica, y de hecho podemos actualizar
sus propiedades en tiempo de ejecución Queremos tomar el valor de
retorno aquí, que esa versión dinámica
que se cree, queremos promover
esto a una variable, y vamos a llamar a este
material R. Así que es solo una referencia
a nuestro material. A partir de esto, podemos hacer nuestro código para cambiar algunas de
las propiedades principales. Lo principal si querías
hacer más sobre esto es solo
necesitas conocer los nombres de las
variables con las que
puedes trabajar. Y
esto es realmente sencillo. Si agarramos la malla estática, simplemente mostrarte muy rápidamente
algunas de las otras cosas que puedes hacer una vez que hayas aprendido una que estoy a punto de correr
contigo. Si hacemos doble clic en el proyectil
MI subrayado, sabemos que esta es
nuestra instancia material Esto nos abrirá el activo. Y básicamente, cualquier cosa que te haya expuesto por
aquí, recuerda, he dicho que he
creado este material grande, algo personalizable. Cualquier cosa que se nombra en nuestra sección aquí
se puede acceder en código. Para que puedas cambiar la
especulación en tiempo de ejecución, si quisieras hacer que
las cosas se vean más brillantes y potencialmente húmedas Puedes cambiar la textura
en tiempo de ejecución, los colores, los colores de anulación, la propiedad
emisiva, si quisieras hacerla
brillar. Tú querías hacer. Siempre y cuando conozcas el naming
y la ortografía específica, podrás alterar y
afectar a cualquiera de estos Entonces, la forma en que podemos
hacer algo realmente sencillo para mostrar este tipo de inacción es que queremos obtener
nuestra referencia material Y nuevamente, preferencia personal, siempre
consigo un nuevo nodo
para sacar de aquí, pero solo podrías encontrar
la información de esta
referencia material que acabas promocionar a una variable. Voy a agarrar nuestra
referencia de variables aquí, y a partir de esto, quiero encontrar el valor del parámetro de
vector conjunto. Entonces es esta opción aquí. Vemos que esto viene bajo
la categoría material, así que estamos buscando
lo correcto. Esto nos permitirá establecer el color
de un vector, en este caso. Entonces vamos a enchufar esto
al pin de ejecución. El vector que queremos alterar
va a ser el color,
entonces el color emisivo Y de nuevo, siempre podemos
simplemente cs checar aquí. A esto se le llama color emisivo, así que ese es el que
estoy buscando Y el nuevo color que
quiero que esto sea se
basará en el
actor que haya engendrado Entonces, si es enemigo verde,
podría convertir esto en verde. Si es nuestro jugador, lo
giro para que sea azul. Si tienes un enemigo rojo, es posible que quieras darle la
vuelta para que sea rojo. Así que vamos a comprobar
que esto está funcionando. Si cambiamos esto a
algo bastante obvio, solo
haremos esto amarillo
por ahora, golpeamos compilar, guardar. No vamos a ver que esto
suceda hasta que empecemos a jugar. Así podemos dejar esto en la gráfica y podemos
golpear simular aquí. Deberíamos ver que
empiezan a brillar. Otro problema que
creo que tengo aquí es para el proyectil MI
underscore Quiero asegurarme de
que esto esté marcado. Pero también, necesito
asegurarme de que esto tenga alguna propiedad emisiva Entonces voy a entrar
y asegurarme de que el valor predeterminado para la propiedad
emisiva aquí sea diez Porque de nuevo, lo estamos
multiplicando por el momento, cualquier color por cero
hará que no Entonces si pulsamos Reproducir de
nuevo o simulamos, hecho, podemos ver que ahora se
ha vuelto amarillo. Entonces, si solo me
acerco un poco más, golpearé simular para que podamos ver todo y tenemos
un proyectil amarillo resplandeciente Entonces el único cambio que
quieres hacer es abrir el material y solo
asegúrate de tener este resplandeciente tanto
como quieras Puedes hacerlo mucho
más exagerado, así que podemos hacer de este
un proyectil muy brillante y resplandeciente
completamente hasta Entonces voy a poner eso en 100
solo para que sea muy, muy visible. Y eso es
más o menos lo que hacemos aquí. Así que estamos agarrando esa
propiedad por su nombre, y la estamos poniendo a un
nuevo valor, agradable y simple Ahora algo más
que quizás quieras hacer es tener algunos resplandor
más que otros. Así que solo he
necesitado entrar manualmente editar la fuerza emisiva aquí Entonces, lo que podríamos hacer
en cambio es simplemente mostrar
la forma en que
podemos usar este sistema. Podemos duplicar la referencia
material, y esta vez, voy
a establecer un valor escalar Entonces los valores con los que
estamos trabajando, aunque se les
conoce como flotadores, cuando estamos trabajando
con materiales,
desafortunadamente, se llaman escalares Esto se debe a que están
hechos de un flotador escalable. Podemos cambiarlos en tiempo de ejecución. Así que solo intenta y recuerda eso. Es una terminología ligeramente nueva, pero la que
necesitas aprender para trabajar con materiales
específicamente. Entonces vamos a tomar
nuestro valor escalar. A éste lo he llamado fuerza
emisiva. Entonces vamos a enchufar
esto. Vamos a encontrar nuestra fuerza emisiva Y entonces puedes cambiar esto a cualquier valor que
quisieras que esto fuera. Entonces podríamos
convertir esto en algo realmente tonto por defecto como 1,000. Entonces mil pudo haber sido
un poco extremo, pero mostró el concepto
general. Voy a poner
esto de nuevo a 100. Creo que eso se ve
bastante genial como una
propiedad algo emisiva ahí para un proyectil que
se mueve bastante rápido Quizá sea necesario enfatizar eso
para que sea más visible. Como con todo, no
queremos que estas sean
de nuevo variables mágicas. Solo podríamos cambiar esto aquí directamente en el código. Así que vamos a
promover nuestro color a una variable que
podamos rastrear y usar posteriormente. Estamos nombrando este color de
proyectil por nuestro valor. Entonces el valor de
punto flotante aquí. Promovemos esto a
una variable y llamaremos a este proyectil fuerza
emisora Entonces eso nos dará
cierta flexibilidad cuando
empecemos a engendrar estos
en nuestras clases de padres, el enemigo o el jugador Ahora, algunos de ustedes se
habrán dado cuenta de que hay otro problema que aún no hemos tocado
realmente. Y es que los
proyectiles pueden
volar potencialmente en el espacio para siempre si
no golpean nada en absoluto He considerado si las cosas
golpean el piso y las paredes, he dicho que simplemente se
limpiarán. Dispara una función de
usar y tirar muy barata, que está perfectamente bien para
aplicar daños a la pared, lo que esencialmente
será ignorado, pero no hemos considerado qué pasa si no
golpean nada en absoluto Lo que van a hacer en este momento
es volar a la eternidad, devorando la memoria. Entonces hay dos cosas
que podríamos hacer. La primera es que si agarramos
nuestra propiedad principal por aquí, en realidad
podemos darle toda la vida a cualquier actor con el
que trabajemos. Entonces solo voy a encontrar
esto en el panel de detalles. Podemos buscar aquí de por vida, y podemos darle a esto
una esperanza de vida inicial. Si sabemos que esto definitivamente no estará en pantalla
por más de,
digamos, 10 segundos, entonces podemos darle a esto
una vida útil de diez segundos. Y después de ese tiempo, si
no toca nada, si aquí no llamamos a la función
destruir, simplemente se
destruirá automáticamente. El problema aquí es
que podemos terminar con algunos proyectiles que se mueven
un poco más lentos que otros, o los vamos a usar
y tal vez reciclarlos más tarde, lo que significa que podemos simplemente
esconderlos y ponerlos de
nuevo en juego Y obviamente, no queremos que
nuestros proyectiles salgan de la pantalla
al azar a los 10 segundos Así que en realidad no voy
a usar este enfoque. Otra cosa que podrías
ver está en el eventi, una comprobación constante para ver si
actualmente está fuera de
cámara o fuera de zona Y vamos a hacer
algo un poco similar, pero quería volver a centrarme en las buenas prácticas de programación. Como ya he dicho, algunas
cosas definitivamente pueden y deberían estar en Tick, pero esto no es uno de lo que
vamos a hacer es crear una nueva función
llamada fuera de límites check Y esto sólo va a ser una
matemática muy, muy sencilla. Entonces vamos a hacer click
derecho y
buscar la ubicación del actor G, la ubicación del proyectil
en su punto actual Vamos a sacar
de este nodo, y vamos a
quitarle otro vector. Entonces vamos a
restar un nodo aquí, y podemos usar algo llamado el administrador de cámara del jugador Entonces, si conseguimos player
camera manager, podemos encontrar el premade siempre tipo de referenciado y
en memoria irreal de todos modos, así que bien podemos hacer
uso de estos valores que ya existen para Y desde el
manager del jugador, lo que
actualmente está rastreando la cámara activa
actual, podemos obtener la ubicación de la cámara. Entonces esta será la ubicación
actual de la cámara que
estamos viendo. Entonces podemos llevarnos a estos dos, y esto nos proporciona un nuevo
vector, una distancia para nosotros. A partir de esto, podemos sacar
del pin vector aquí, y queremos tomar
la longitud del vector. Entonces, si buscamos longitud,
podemos obtener la longitud del vector. Esto convertirá esto en un valor de punto flotante para nosotros, esencialmente dándonos una distancia en línea
recta. Entonces sabemos exactamente cuántas
unidades en línea recta está
nuestro proyectil actual lejos de nuestra cámara Esto funciona independientemente
de la dirección, que es otra cosa
realmente útil de este tipo de enfoques, es
decir, que esto
funcionará para proyectiles vuelan en cualquier
dirección, cualquier ángulo Y entonces lo que queremos hacer
es desde nuestro pin de ejecución, vamos a tirar de aquí y vamos a conseguir una sucursal. Tú mismo suficiente espacio
para trabajar con esto. Y básicamente
vamos a decir, si esta longitud de vector es
mayor o igual
a cierto valor, entonces vamos a
destruir a este actor. Entonces digo más o
igual a para dar cuenta, de
nuevo, si va
por encima de este valor. Si eso es cierto, vamos
a enchufar esto aquí, dy las cosas arriba un poco aquí. Y voy a dar
esto, creo que funciona un valor de 3 mil 500 unidades Entonces eso es más o menos fuera
de las zonas de la cámara. Podemos ser un poco más científicos
e intentar probarlo más tarde. Si encuentras que las cosas están
saliendo de la pantalla demasiado pronto, entonces solo quieres
aumentar este valor, y si las cosas están tardando
demasiado, entonces puedes disminuirlo. Pero creo que
eso definitivamente va a funcionar. No importa
si existen unos segundos
más de lo que deberían. Lo principal es que no
queremos verlos simplemente mágicamente de la
pantalla y desapareciendo Y no queremos que
cientos y cientos de proyectiles existan todos
por minutos a la vez Eso es más del problema
que estamos tratando de resolver. Si esto es cierto, entonces
voy a sacar de aquí, voy a decir destruir
actor solo para que
podamos despejar ese proyectil
de la memoria Tan agradable y sencillo. Como siempre, no hay números mágicos,
así que voy a bajar y promover
esto a variable. Llamaremos a esto algo
así como distancia fuera de límites. Y de nuevo, esto
hace que sea agradable y sencillo
que siempre podamos volver directamente aquí. Y si estamos teniendo problemas donde
necesitábamos cambiar esto, aumentarlo o
disminuirlo, ahora tenemos un bonito fácil de encontrar un lugar
para hacer ese cambio. Por el momento, no hemos
llamado a esta función, así que un
problema muy simple de hacer o cosa
fácil de pasar por alto es que no podemos simplemente
hacer la función Tenemos que llamar a esto también. No queremos
simplemente llamar a esto una vez. Obviamente, no quisiéramos
hacer esto en comenzar a jugar. Y como he mencionado, no
queremos
hacerlo constantemente en eventi Entonces, en cambio, lo que
vamos a hacer es desde el pin de ejecución, después de nuestro
parámetro escalar establecido aquí, vamos a volver a
hacer uso de temporizadores Son muy, muy flexibles. Entonces buscaremos
esa misma función, que se establece temporizador
por nombre de función. La función que queremos obviamente
va a ser nuestra comprobación fuera de límites Así que lo mismo otra vez,
voy a renombrar esto en realidad renombrarlo
pero presione
Control C, Control V para colocar esto en, y podríamos establecer esto en bucle
tal vez una vez cada segundo. Así que recuerda que si
hiciéramos esto en Tick, esto estaría verificando
potencialmente 120 veces cada segundo
en función de mi velocidad de fotogramas actual. Entonces eso es un poco
exagerado. No necesitamos que sea tan preciso. Hacer esto una vez por
segundo no va a agregar una sobrecarga masiva
al rendimiento del juego, y significa que
todavía estamos comprobando en una iteración o
intervalo relativamente rápido los proyectiles que no necesitan estar Como he mencionado,
tener un proyectil alrededor por varios
segundos extra no va a ser potencialmente tener cientos de
proyectiles revisando
120 veces cada segundo,
si aún existieran
sería más
un proyectiles revisando
120 veces cada segundo, si aún existieran
sería más Queremos asegurarnos de que
esto se llame continuamente, así que más de una vez, así que
pondremos esto en looping Entonces, una vez cada segundo, ahora se llamará a
esto. Tenemos una
iteración de un looping de este temporizador, que seguirá verificando dos veces la ubicación del proyectil contra la cámara y si está técnicamente
fuera de la vista. Para que podamos ir a probar esto.
Si enchufamos uno de estos, haremos tal vez un
par de estos, y golpearemos simular solo para que podamos ver
que se dispara. Y se puede ver
uno de ellos ahí realmente golpeó el avión enemigo, así que eso quedó destruido
al golpear el avión. Pero el otro
se apaga, y después de que está cierta distancia,
ya no lo vemos. Entonces si presiono el
avión desde aquí, lo principal es que no los
vimos simplemente desaparecer a través de la cámara, eso es lo que queremos evitar. Pero sabemos por las
pruebas anteriores que están siendo aniquiladas cuando estamos probando
esto en modo simulación. Por supuesto, están
volando y están saliendo fuera
de la vista
de la cámara Entonces esa es una forma agradable
y limpia de hacer esto. No va a
proporcionar una gran sobrecarga. Esto definitivamente no
causaría ningún problema de rendimiento. es un
cálculo relativamente simple Aquí es un
cálculo relativamente simple
y ligero. Creo que es mucho más seguro que usar de por vida
porque no sabemos cuánto tiempo o qué tan rápido
se van a mover
todos los proyectiles y
cuánto tiempo podrían estar en pantalla Y esto es lo suficientemente barato como para ejecutar este cálculo que no proporcionará ningún problema de rendimiento. Y quería demostrar solo una
comparación simple de dónde
podríamos usar tick y dónde
evitamos usar Tick. Recuerda, cuando estamos
jugando con estas cosas, siempre vuelve y borra los actores que quizás ya
no estés usando. No queremos
quedárnoslos cerca. Vamos a engendrar esos de alguna funcionalidad de fuego
un poco más tarde Entonces, una vez más, si todavía
estás jugando con estas cosas, siéntete libre de probar
diferentes velocidades, diferentes colores,
mira si quieres afectar alguna de las
otras propiedades en la instancia del material. Vea si puede averiguar
cómo cambiar algunos de los otros valores escalares
o parámetros vectoriales Nuevamente, lo principal es que
solo necesitas su nombre y la ortografía exacta, y
estarás perfectamente bien. Puedes cambiar los valores como te parezca. Otro reto
genial. No, ojalá te estés poniendo más cómodo con un
poco del programa. Para agregar aceleración de horas extras con tal vez algún tipo
de interpolación Se pueden ver esos enfoques desde el otro
código que tenemos. Y es una de las cosas
bonitas como
mencioné sobre
rodar nuestro propio código. Es simplemente algo que
es casi imposible hacer con el componente de
movimiento del proyectil Entonces, si quisieras que pasara de una velocidad más lenta y acelerara
con el tiempo o en reversa, podrías comenzar a
volar muy rápido y luego ralentizar
perdiendo impulso. También podrías haber visto
cosas como proyectiles de
orientación usando técnicas
similares,
intercalando hacia un
objetivo específico horas extras Ya lo he mencionado,
recomendaría mantener la clase actual tal como está. Si estás haciendo estas pruebas y probando algo de
esta experimentación. Siempre recomendaría
duplicar lo que
tienes e intentar rodar
tu propia versión a partir de eso Sin embargo, es una gran
manera de aprender. No quiero que dejes
de probar cosas nuevas,
pero, claro, en los temas futuros,
vamos a estar usando estos proyectiles
exactamente como son Así que recomendaría
tener esa versión
también para que podamos completar
el proyecto juntos.
21. 20: proyectilfuego enemigo: Para que las cosas realmente
disparen sus proyectiles. Vamos a hacer esto
otra vez, bonito y ordenado. Una función de fuego en la clase base personalizada
por los niños si es necesario. mismo patrón que hemos
estado usando antes, así que vamos a terminar con
la misma funcionalidad nuestro proyecto de ejemplo que estamos trabajando para recrear un poco, pero estamos tomando un enfoque ligeramente
diferente Entonces primero, solo un recordatorio, si tuvieras alguno
de los proyectiles por
ahí, te
recomendaría eliminarlos Antes de comenzar,
estaremos generando todos
estos dinámicamente en
tiempo de ejecución cuando sea necesario Vamos a empezar
en nuestra clase de avión base. Entonces, si vamos a la base del
plano central y vamos a hacer nuestra
implementación inicial justo aquí, crearemos una función
aquí llamada fuego. Haremos algo muy parecido a
lo que hemos hecho con nuestra clase de engendradores enemigos Vamos a sacar
del pin de ejecución y buscar al actor
spawn de clase Podemos una vez más,
sacaremos de aquí y promoveremos
esto a una variable. Y en caso de que quisiéramos
cambiar esto más tarde por el momento, creo que solo vamos a tener una sola clase de proyectil Pero en caso de que quisiéramos
diferentes proyectiles, promoveremos esto para
que este sea reutilizable Cambiaremos el nombre de éste
a clase proyectil. Deja esto como el tipo
actor predeterminado hit compile, y eso está bien. Ahora, cuando hacemos clic en compilar, obtenemos este error
diciendo que necesitamos proporcionar alguna información
extra. Necesitamos el TransponPin. Podemos hacer dos cosas. Podemos
dividir el pin de estructura. Y si quisieras dejar
esto completamente vacío, podemos darle a compilar y eso
hará que el error desaparezca. Ahora, voy a
presionar Control in Dead. Hay otra cosa
que podemos hacer aquí. Para la ubicación de desove,
necesitamos saber exactamente dónde queremos que nuestros proyectiles
entren en existencia Y una forma en que podemos hacer
esto y hacer esto algo visual es
agregar un nuevo componente. Voy a
entrar en el viewpot. Voy a agregar
un nuevo componente, y seleccionaré el
componente de escena justo aquí. Una cosa que debería haber
hecho es tener esto ya seleccionando la malla, pero
eso está perfectamente bien. Quiero que estos componentes de escena sigan siempre lo que
pase con la malla. Así que solo voy
a agarrar esto y
dejar esto nuevamente enfocándome en jerarquía para que el
nuevo componente de escena sea hijo de la malla estática. Para dejar esto claro, si
realmente quisieras,
podríamos cambiarle el nombre a esto, y llamaré a este proyecto
nuestra ubicación de desove Entonces, cuando estamos mirando hacia atrás
a través de nuestra jerarquía, tenemos una idea de rap sobre de
qué son responsables estos diferentes componentes. Ahora bien, no necesitamos que
esto sea visual, pero lo que podemos hacer con el uso de esto es
que ahora podemos
moverlo y tener el control directo de dónde queremos que genere el
proyectil Podríamos tener eso ligeramente
frente al avión. Bueno, como he
mencionado, es posible que queramos que esto esté un poco
dentro del avión, así que no parece
que esté
desove mágicamente de Cuando estés satisfecho
con la posición de tu ubicación de
generación de proyectiles, de nuevo, si golpeamos compilar, en realidad
obtendremos este mal resultado de plano en la ventana gráfica pero
eso está perfectamente Sólo queremos volver
a nuestra función de fuego. Vamos a controlar arrastrar la
ubicación de generación del proyectil al suelo Voy a tirar de aquí
y voy a buscar algo llamado get
world transform. Entonces queremos esta opción justo
aquí con la función verde? Get World transform va
a proporcionar la transformación de este
componente específico en el mundo en relación con la rotación y
todo lo que ha sucedido. Por lo que podemos asegurar que el proyectil
estará mirando hacia adelante Vamos a enchufar eso,
vamos a golpear Compile, y ya podemos ver que los problemas ya
se han ido. Solo quería
mostrar otra cosa, y creo que en realidad podría valer la pena cambiar
esto aquí de actor a específicamente
la clase basada en proyectiles Si solo volvemos a
nuestra clase de proyectiles aquí, haremos doble clic para
abrir la clase base y solo asegurarnos de que tenemos
dos cosas expuestas aquí Entonces queremos que el
color del proyectil quede expuesto, la fuerza de
emisión del proyectil, y tal vez la velocidad de
movimiento del proyectil también podría
ser útil Asegurarse de que estos
tres sean públicos. Puedes volver y otra vez, estoy tratando de sentar las
bases para ti. Puedes regresar y una vez que hayas visto lo que
estamos a punto de
hacer, haz cualquier otro cambio
que quisieras. Son completamente opcionales, pero
creo que estos tres
serán buenos para probar. Y si golpeamos compilar y guardar, volveremos a
nuestra clase base de avión y a la función fire. Ahora, por defecto, debido a que este
se establece en un actor genérico, no
hay datos expuestos. Ahora lo que podemos hacer haciendo
uso de mecanografía específica es que podemos buscar nuestro proyectil de subrayado
BP Queremos usar la opción base, necesitamos desplegarla y seleccionar el tipo de referencia de clase,
no el tipo de objeto. Esto solo nos dirá que algunas cosas van
a necesitar cambiar. Podríamos tener algunas referencias esencialmente
rotas o enlaces a diferentes tipos de clases, y eso está perfectamente bien. Digamos cambiar esa variable. Dejaremos que esto haga lo suyo. Realmente no va
a romper nada porque de todos modos no estamos usando nada específico en este punto. Sólo teníamos un actor genérico.
Para que podamos cerrar eso. Y lo que quería mostrar es
que si hacemos clic derecho sobre el actor spawn y elegimos la opción de nodo de actualización aquí o asegurarnos de que primero
golpeamos compilar, lo que deberíamos estar viendo son esas propiedades que
acabamos de exponer,
y me acabo de dar cuenta de
cuál es el problema Hay otro paso que
es muy fácil de pasar por alto. Y vamos a regresar a
la base del proyectil. Además de hacerlos públicos, hay otra
casilla de verificación que necesitamos. Entonces solo algunas de esas cosas que
necesitas saber sobre Unreal, y vas a
recoger esto a medida que vayas Entonces para la velocidad de movimiento y los otros dos que
hemos expuesto, también
queremos elegir
esta opción aquí, exponer en spawn en
el panel de detalles Entonces tenemos que hacer esto
para cada uno de ellos, así que toma tu variable y luego marca en la exposición en span. Yo sugeriría que solo expone esta propiedad cada vez que
engendramos esta clase También es muy importante que
tenemos que asegurarnos compilar y guardar en
la clase de proyectiles De lo contrario, si volvemos a nuestra base de aviones,
no vamos a ver esto. Y puedes ver ahora la razón
principal por la que
queríamos esto es al
especificar que
específicamente vamos a estar usando la base del
proyectil de subrayado BP en lugar de un actor genérico Ahora tenemos estas
propiedades expuestas, lo cual es realmente útil. Esto nos da el
poder de cambiar el color en función la clase en la que vamos a
estar generando esto, así
como la velocidad de movimiento, la fuerza emisiva,
y cosas así, dependiendo de cómo quisieras Con tus clases de proyectiles. Ahora, todo esto se hace
una vez en la clase base. Queremos que esto sea
fácilmente reutilizable sin necesidad de
sumergirse en el código. Entonces, claro, no vamos
a dejar estos números mágicos. En cambio, vamos a promover cada uno de
estos a una variable. Promocionaremos el
primero, y llamaremos a éste velocidad de
movimiento de proyectiles Y entonces nosotros por supuesto,
haremos lo mismo. Vamos a promover el color del
proyectil y la fuerza de
emisión del proyectil a sus propias propiedades. Y
eso es todo bueno para ir. Eso significa que ahora podemos tener esta función reutilizable tanto
en el plano
del jugador como en el enemigo jugador, y todo lo que necesitamos ajustar por clase es qué tan rápido queremos que se muevan los
proyectiles Porque recuerdo en
el proyecto de ejemplo, el enemigo es disparado
más lento que el jugador, y podemos cambiar
el color
dependiendo de quién esté desove
el proyectil Significa que no necesitamos
cargas de diferentes tipos de proyectiles específicos Podemos simplemente tomar nuestra base de
proyectil, y podemos hacer algunos cambios rudimentarios realmente
simples sobre una base por avión. Lo único realmente importante antes de salir de aquí, recuerda esa funcionalidad sobre la colisión que estamos haciendo
donde estamos diciendo aquí, si estamos superponiendo
en este momento, nuestro propio dueño, entonces no
queremos aplicar daño a ninguno. Tenemos que asegurarnos de que la
cosa que genera la clase, que ahora estamos haciendo en
la base del avión es en realidad pasar a lo largo de la información
de quién es el dueño Entonces otra cosa
que podemos
bajar aquí en el spawn actor en la base del avión es
el dueño justo aquí Entonces, agradable y sencillo,
podemos sacar de este pin, y vamos a buscar G de referencia
para vender. O simplemente puede escribir
la palabra celda y verá obtener
referencia a uno mismo aquí. Entonces esto es ahora
solo asegurar que
cualquiera que sea el avión que genere este proyectil cuando se llame a
esta función, se
esté etiquetando a sí mismo como el
dueño del proyectil, asegurando que no
se Tan agradable y limpio,
podemos golpear y apile, ahorrar, y
ese está listo para funcionar. Así que ahora estamos en un buen
punto donde podemos agregar la
versión más simplista del disparo, que va a
ser nuestra clase enemiga Antes de hacer eso, creo que
hay una variable más que ambas clases
podrán hacer uso,
y esa es la
velocidad de disparo, con qué frecuencia va
a poder disparar
el avión. Así que vamos a crear una nueva
variable aquí abajo. El primero va
a ser de tipo de vuelo, así que presiona Control ID en
cualquiera de los otros vuelos, y voy a llamar a este
fuego cadencia. Compila. Creo que solo para
asegurarnos de que
no nos olvidemos de establecer esto más tarde, solo
voy a poner
esto a cero, y nos aseguraremos de
que lo
modifiquemos por plano. Y entonces la otra cosa
que creo que será bastante útil en nuestras dos clases más adelante será un vector dos D para la cadencia mínima y
máxima de disparo. Entonces tenemos algo de aleatorización. Entonces voy a crear una nueva
variable. Queremos que este sea un vector dos D otra vez. Pero por ahora, solo llamaremos a
esto un mínimo de velocidad máxima de disparo. Queremos ese vector dos
D que teníamos anteriormente, y de nuevo, podemos dejar
estos en cero por ahora. Volveremos y los
modificaremos más tarde. Y este es uno de esos
casos en los que estamos obteniendo muchas variables similares
para un solo sistema. Por lo que quizá queramos
ponerlos en una categoría, específicamente para proyectiles o combates o lo que
quieras que sea También podríamos tener una categoría de salud,
algo así. Como mencioné, no voy a
seguir haciendo esto en pantalla, ya que es solo un
trabajo ocupado en segundo plano, pero definitivamente podría
ayudar ya que obtenemos muchas más variables a medida que
flasamos las clases individualmente. Esto está bien,
sin embargo. Esto es bueno para un punto de trabajo base, así que ahora podemos entrar en
nuestra clase enemiga, así que vamos al núcleo. Juega enemigo, y queremos
crear una secuencia
en nuestro inicio de juego. La razón de esto
es que ahora estamos recibiendo algún tipo de lógica embarrada Estamos haciendo algunas cosas
diferentes sobre la inicialización de nuestra clase, lo cual está perfectamente bien, pero
podemos simplemente mantener las cosas ordenadas de nuevo. Así que un truco rápido aquí
es que podemos sacar
del pin de ejecución después la llamada principal y entre
lo que ya estamos haciendo, y vamos a llamar a un nodo de
secuencia aquí. Y esto
automáticamente conectará la lógica que tenemos
sin romper ninguna de las así entonces cero es esencialmente nuestra inicialización para la aleatorización
genérica Entonces podríamos tener un comentario
diciendo, aleatorizar valores aquí. Entonces lo siguiente que
vamos a querer hacer es configurar nuestros detalles de disparo. Entonces, de hecho, esto
todavía se va a
basar en algún nivel
de aleatorización Entonces voy a
hacer click derecho, y voy
a conseguir la propiedad de cadencia de fuego. Entonces queremos establecer aquí
el ritmo de fuego, y esto se establecerá una vez más en un flotador aleatorio en rango. Vamos a enchufar esto, y
ese flotador aleatorio es, por
supuesto, va a ser el minmax que
acabamos de crear Entonces obtendremos la velocidad de disparo
mínima máxima, dividiremos el
pin de estructura como lo hemos hecho antes y los conectaremos aquí. Tan mínimo, máximo
para la X y la Y. Así que otra
aleatorización sencilla y agradable para que cada enemigo no esté disparando exactamente
al mismo ritmo, y va a parecer muy
repetitivo y aburrido, de lo repetitivo y aburrido, Si pegamos a compilar,
solo queremos asegurarnos,
también, de que para
la clase enemiga, establecemos una cadencia de disparo Minimax, que creo que tal vez en algún lugar
entre 0.4 y 0.8 Nuevamente, puedes ajustar todos
estos valores como quieras, y luego la
velocidad de disparo se establecerá específicamente entre ese rango Entonces a partir de la segunda salida y ahora que hemos hecho nuestra
aleatorización, en realidad
podemos comenzar a configurar la funcionalidad de fuego
que se va a llamar Así que vamos a hacer
uso del temporizador establecido por nombre de función de nuevo,
vamos a tirar de aquí. Vamos a usar el
temporizador establecido por nombre de función. Por supuesto, vamos a
llamar a la función de fuego. Que hemos creado
en nuestra clase base, y el tiempo va
a ser nuestro ritmo de fuego. Así que vamos a obtener la velocidad de disparo que
acabamos de aleatorizar, y nos aseguraremos de que
esto esté configurado en un ciclo. Entonces esto seguirá siendo llamado mientras el
enemigo esté en juego. La aleatorización asegura que cada enemigo dispara a su
propio ritmo aleatorio Algunos serán un poco
más agresivos y otros más tranquilos Otra cosa para los enemigos es que cuando
vuelan fuera de la pantalla, si el jugador los extraña, como con los proyectiles, también
deberían estar
limpiándose Así que vamos a entrar en
la clase de proyectiles, y de hecho voy
a tomar la lógica exacta de verificación
fuera de límites aquí Podemos copiar todo esto, presionar control NC, volver
a la clase enemiga. Crearemos una nueva
función. Nuevamente, vamos a llamar a este
cheque fuera de límites Y simplemente pegamos esto
en la gráfica aquí. Entonces un poco de duplicación. Y nuevamente, aquí es donde
podrías empezar a considerar cosas como el uso de componentes sería algo
valioso aquí. Puede ver cuando se está metiendo más en
la programación el concepto a menudo referido a herencia
versus composición, haciendo uso de
componentes como este. Un poco fuera de alcance para este sistema realmente introductorio. Entonces algunas de las cosas vamos a estar tomando el ligero atajo, pero este todavía no es un
enfoque terrible para hacer esto, solo un poquito de duplicación. Pero la
variable de verificación fuera de banda aquí que hemos copiado de la otra clase obviamente no existe aquí, así que vamos a hacer clic
derecho y
vamos a crear una variable. Y éste
acabamos de golpear Compile. Vamos a verificar la ubicación del enemigo
desde la cámara. Para la distancia fuera de límites, podemos usar un valor similar Creo que 3,500
funcionaban bastante bien. Solo queremos
asegurarnos de que estamos
vigilando a los enemigos que
salen del área de juego, y si notamos que simplemente
salen de la existencia, posible
que queramos modificar
esto de alguna manera Ahora con eso listo
para funcionar, queremos
volver a nuestro gráfico de eventos. Tal vez queramos comenzar a ordenar un poco
las cosas y simplemente mover las cosas
para darnos espacio Lo principal aquí, podríamos
configurar otro momento aquí, así que esta podría ser nuestra lógica para configurar las
funciones repetitivas Entonces crearemos otro TO por nombre de
función para este. Esta va a ser nuestra comprobación
fuera de límites, y tal vez queramos hacer
esto una vez por segundo Entonces fijaremos una hora aquí
pero una vez cada segundo. Promocionaremos esto a
variable. Y voy a configurar este para que se llame fuera
de límites verificar la duración Como antes, le pegaremos a Compilar. Queremos asegurarnos de darle un valor a esto, así que eso tiene el 1 segundo, y pondremos esto en un
ciclo, así que va continuamente hasta que
se elimine del juego Como lo he hecho en
el pasado, también. Creo que voy
a escribir pincha aquí y encuentra la función de fuego. Así que sólo vamos
a CallFireFunction. En realidad no lo
vamos a usar. Es solo para que, de nuevo, si
quisiéramos volver a verificar lo que está sucediendo dentro
de esta función, simplemente
podamos hacer doble clic aquí. Voy a sacar el cheque fuera de
límites, obtener el nombre, y asegurarme de que
rellenemos esto por aquí en nuestro tiempo y luego simplemente arrastramos
esto por la misma razón otra vez Por si acaso quiero
ver lo que está pasando, solo
puedo hacer doble clic
y ver el código exactamente. Como he mencionado, solo
una preferencia personal, pero algo que siempre
tiendo a hacer en mi propio código. Una última cosa que creo que nos hemos
olvidado de hacer es porque tuvimos un poco de
intercambio de clases de proyectiles, si volvemos a la clase base donde implementamos
la función fuego, si agarramos nuestra clase de
proyectiles aquí, podemos ver que la
clase está puesta Entonces, si intentáramos esto ahora, no
estaríamos consiguiendo que ninguno
de los enemigos realmente disparara nada
porque no se les da el
tipo específico de clase para disparar. Entonces por el momento, solo
tenemos uno, que
es la clase base. Pero si hiciéramos algunas clases
infantiles a partir de esto, también
podríamos usar esas versiones
únicas. Entonces enviamos esto para que fuera un defecto de base de proyectil
porque por el momento, es
lo único con lo que
tenemos que trabajar Golpear compilar y guardar.
Y luego en el enemigo, lo que verás es que esto propagará automáticamente cenar Entonces tenemos la
clase proyectil puesta aquí también. Golpear compilar y guardar, y
podremos anidar al enemigo disparando. Entonces nada súper elegante,
pero sí lo son. Disparando y podemos
ver que conseguimos que unas tasas diferentes,
diferentes velocidades. Así que tenemos algún tipo de juego un poco único de
los diferentes enemigos. También debemos ver que después de cierto número de golpes, el jugador debe ser
retirado del juego, por lo que el daño está
funcionando automáticamente. Entonces tenemos todo tipo
de trabajo según lo previsto, al
menos para la
clase enemiga, lo cual es genial. Lo último que noto
ahí, eso probablemente va a ser un poco
rápido, y eso está bien. Es por eso que hemos establecido todos estos valores para que sean expuestos para que sean fáciles de modificar y
cambiar en función de las pruebas de juego, comentarios y el campo de juego general al
que podrías estar apuntando Entonces pienso en el enemigo,
vamos a frenar sus proyectiles
un
poquito porque va
a haber muchos de El jugador probablemente
quiera disparar más rápido, y los enemigos pueden estar un
poco más relajados. Entonces pondremos esto en
algo así como 1,500. Y si sentimos que esto es demasiado lento. Entonces solo estoy seleccionando
aquí arriba en la clase enemiga, agarrando la velocidad de
movimiento del proyectil y bajando esto a 1,500 También podemos cambiar el color. Entonces mis enemigos son verdes.
Va a conseguir un color, que aquí está un poco más
cerca del estilo enemigo. Deberías poder
usar el seleccionador de color para que podamos entrar en el color,
obtener el seleccionador de color, y puedes hacer clic en la parte
del avión que querías
que coincida con el color Para mí, esto no está funcionando. Esto es seleccionar
la coincidencia estática. Así que sólo voy a
agarrar un color que es más o menos similar al cuerpo
del avión. Eso estaría perfectamente
bien, creo. Entonces ahora, de nuevo, si
golpeamos compilar, tenemos proyectiles moviéndose
a diferentes velocidades, y en realidad están
representando el color
de la nave, que los
está disparando También puedes cambiar cosas como la fuerza emisiva
si no querías que brillaran o si querías que
brillaran más o menos Pero eso es todo. Entonces esos son
los enemigos establecidos y hechos. Solo una pequeña tarea secundaria para ti, vuelve a
pausar el contenido
entre los temas, y tal vez empieces a buscar diferentes variables
que creas que podrían funcionar para la velocidad de disparo mínima
y máxima. A lo mejor no estás sintiendo
suficiente diferencia entre los diferentes
enemigos a medida que engendran A lo mejor cambiar
el color, los diferentes tipos
de velocidad de movimiento, el daño proporcionado,
exponer otras variables, jugar con
todos los valores a los que ahora
sabes que tienes acceso. A continuación, echaremos un vistazo a la funcionalidad player fire. Va a ser un
poco diferente, un poco más práctico, pero se puede ver que
ya tenemos una base muy buena sobre la que construir.
22. 21: Reproductor de ProjectileFire: Ahora se puede mover
directamente para conseguir que el jugador dispare de manera
similar a la del enemigo. Así que vamos a reutilizar
parte de esa lógica base, las
propiedades expuestas del proyectil, y tener un control un poco
más refinado sobre si y cuándo el
jugador debería estar disparando Entonces, si entramos y abrimos el jugador del avión de guión bajo
BP, aquí
tenemos dos
opciones diferentes Ahora, una es que mucha
gente podría simplemente dejar caer la funcionalidad central fuera de las funciones en su gráfico de eventos
principales. Algo más que
quería introducir, aunque es que podemos hacer nuestras
propias gráficas personalizadas. Entonces el gráfico de eventos predeterminado viene con cosas
como el start play, el eventi, esas
cosas integradas en el motor por
defecto. Perfectamente bien. Una cosa que me gusta bastante
hacer es que podemos presionar este botón más aquí y podemos crear una gráfica completamente nueva. Voy a dar el nombre
de esta nueva entrada gráfica. Y aquí será donde
pongamos toda nuestra lógica específicamente basada en recibir
entrada para el jugador. Entonces nuevamente, comenzamos a
agregar cosas más tarde, como un botón de reinicio o un botón de menú o diferentes
tipos de power-ups y cosas, todas esas entradas
podrían ser rastreadas aquí en un lugar agradable y
conveniente. Para registrar la
entrada de fuego, finalmente
vamos a hacer
uso de un evento de entrada. Así que anteriormente
solo hemos estado usando las variables que se
almacenan en cosas como el guión bajo IA en nuestro movimiento de mango que
hemos visto aquí Entonces este es nuestro ejemplo de usar solo el
valor flotante devuelto. Dentro de la gráfica de entrada,
vamos a hacer clic derecho y vamos a
buscar IA underscore Fire Y vemos que aquí tenemos
la opción, en realidad
queremos hacer uso de este evento que se devuelve. Entonces cada vez que se presiona el
botón de disparo, podemos hacer que algo
suceda fuera de ese resultado desencadenado de
la entrada que se recibe. Ahora bien, lo primero que siempre
queremos
considerar es que queremos esa retroalimentación
inmediata, algo que es más
del lado del diseño del juego y el tipo teoría de las cosas, es que cuando el jugador
presiona algo, tiene esta expectativa de
ver retroalimentación inmediata. No hay rezago entre ellos presionando algo
y algo que sucede. Entonces por esa razón, en
cuanto se reciba el insumo, queremos asegurarnos de que
algo empiece a suceder. Así que tenemos un montón de eventos
diferentes
que se despiden aquí, y queremos hacer uso antes que
nada de los iniciados. Por lo que queremos asegurarnos de
que la función fire se llame inmediatamente en Start. Vamos a
llamar aquí a la
función de fuego de nuestra clase de padres. Podemos ver que esta es
la clase base. Iniciado se llama
inmediatamente tan pronto como se reconoce la pulsación de
ese botón y luego completado se
apagaría tan pronto como se suelta el
botón. Entonces podemos hacer uso
de estas diferentes etapas de la pulsación de botones, pero
lo importante por ahora es que se llame
al fuego de inmediato. Entonces después de que se haya llamado a esa primera
función de disparo, vamos a sacar
del pin de ejecución, y vamos a
hacer otro
temporizador establecido por nombre de función. La función, por supuesto,
va a ser fuego. Principalmente solo por costumbre aquí. Sólo voy a duplicar la función fire que
ya tenemos, y de nuevo, simplemente
voy a dejar caer eso
por debajo del temporizador porque sabemos que
es la que estamos usando aquí. La cantidad de tiempo
entre, vamos a sacar de aquí y voy
a encontrar nuestra cadencia de fuego. Entonces vamos a obtener
el valor de la velocidad de disparo. Y pienso para el
jugador, aunque dije, quizá
queramos
mirar la aleatorización, esta es otra de
esas cosas ahora al pensar en cosas desde
más de un principio de diseño Probablemente queramos
establecer esto en
lugar de tener un
mínimo y un máximo, el jugador va a
tener la expectativa de que cada vez que disparen y cada
vez que juegue el juego, su cadencia de disparo
sea la misma. A menos que estés haciendo
algo así como un roguec en el que
le estés
diciendo específicamente al jugador que según tu personaje o estadísticas aleatorias, la velocidad de disparo puede ser diferente En este tipo de juegos,
van a tener expectativa de que siempre sienta lo mismo para
que puedan acostumbrarse a la mecánica y
aprender a jugar. Entonces, si golpeamos compilar,
agarraremos la velocidad de disparo, y vamos a
poner esto en 0.2. Nos aseguraremos de que
configuramos esto para que sea un bucle. Entonces, esencialmente, lo
que estamos diciendo es que presionaremos fuego, y luego una vez que mantengas pulsado el botón, vamos a llamar a
esta función para
que cuando estés sosteniendo,
sigas disparando. Entonces podemos volver
por aquí y
ya podemos hacer uso de esta función
completada. Entonces como mencioné,
esto se llama cuando sueltas el botón
que estás sosteniendo. Entonces, a partir de terminado,
podemos hacer uso de otra parte del tiempo de funcionalidad incorporado
, y esta es una manera muy agradable de mantener su código
nuevamente limpio y ordenado. Es posible que hayas visto en otros
ejemplos esto
arrojado al eventic
con algunos retrasos, lo que puede ser muy confuso
si piensas en ejecutar un eventic y un delay juntos, esencialmente
combinando lógica, que está destinada a ejecutarse
constantemente en un intervalo dado, y luego también
tratando de retrasar eso mientras la ejecuta Así que vamos a evitar código
descuidado como ese. Lo vamos a hacer en cambio
es que vamos a encontrar una función llamada
Tir claro por nombre de función. Entonces usaremos esta función aquí, y esto es realmente
agradable y simple. Vamos a agarrar
nuestro nombre de fuego aquí, así que agarraremos el texto aquí, y luego lo
pegaremos aquí. Entonces ahora tenemos un control
total sobre cuándo esto ha comenzado
y cuándo termina esto. Entonces, la primera vez que
presionemos el botón de disparo, vamos a llamar a
la función de disparo. Entonces también vamos
a asegurarnos de que
sigamos recordando esto
mientras mantengamos pulsado el botón. Pero si alguna vez
queremos que esto se detenga, cuanto reconozcamos que se ha soltado el
botón, vamos a borrar
este nombre de función, así que esta función de temporizador. Entonces va a encontrar esto porque comparten
el mismo nombre. Aquí va a cancelar
el bucle, y significa que ya
no vamos a disparar. Entonces no tenemos cables
yendo a todas partes, las cosas que intentan
cancelar en el evento tick. Es solo un solo evento de incendio, y solo estamos agregando una
pila de cada 0.2 segundos. Llamar a una función realmente simple. Así que de nuevo, gastos generales muy bajos, muy buenos para
el rendimiento, muy limpios leer, y mucho
más fáciles de manejar. Y realmente para el jugador, eso solo deja un
par de cosas aquí. Entonces la funcionalidad de disparo
es relativamente simple. Solo queremos
entrar en los detalles de la clase aquí y hacer algunos cambios
similares a lo que hemos hecho antes. Entonces la velocidad de
movimiento del proyectil, creo, 2,500 para el jugador está bien Dejar el emisivo
está perfectamente bien. Y sólo vamos
a cambiar el color. Mis jugadores son una especie
de color azulado, así que vamos a ir.
Con eso justo aquí. A lo mejor tratar de igualar
eso un poco más. Como mencioné, en su sistema, es posible que pueda salirse con la suya
con el seleccionador de color Pero para mí, eso es
solo seleccionar el negro. Así que sólo voy a establecer
esto de una manera más manual. Entonces podremos pulsar compilar, guardar, y luego podremos entrar
y jugar a probar esto. Ahí vas. Por lo que el jugador
tiene retroalimentación continua al
presionar el botón. Esto es un bucle continuo hasta que soltamos
el botón de disparo Entonces como mencioné,
muy agradable y limpio. Si no lo has visto
antes, no voy a encontrar tutoriales
específicos para llamarlos, sino que echa un vistazo en YouTube antes de algo
como motor Unreal, funcionalidad de
blueprint fire
o lógica de disparos, algo genérico así
y ve el resultado que Ten un ojo para
esos específicamente, lo que te
llevará a los eventi, y tener algunos retrasos
arrojados en función una cadencia de disparo y ver
la forma en que usarán cosas como puertas para
cancelar
la llamada a la función de disparo cuando se presiona o suelta
un botón Y luego compara eso con lo que
acabamos de hacer aquí con dos llamadas realmente simples para iniciar la función y terminar
la función horas extras Nuevamente, como mencioné, con los ejemplos épicos
y cosas así, esto nunca es para llamar a
otras personas o proyectos. manera explícita. Mcde definitivamente
no siempre es el mejor, pero es solo para
hacerte pensar y criticar
lo que estás viendo a medida que
estás aprendiendo porque
una de las peores cosas que puedes hacer es simplemente seguir todo ciegamente y asumir que siempre es
el Siempre habrá diferentes formas de
abordar un problema, y solo quiero que
pienses si lo que estás
haciendo en tus proyectos o lo que estás viendo en línea es una manera que quieres
implementar en tus propios proyectos para que sean manejables y
fáciles de trabajar Eso es más
o menos para proyectiles. De nuevo, solo
asegúrate de que
verificas dos veces todo
tiene los valores precisos llenos si quisieras
esos pasos adicionales que podrías tomar para
mejorar tu proyecto. Voy a dejar esto en paridad con el proyecto de ejemplo, pero sí tenemos problemas
que tal vez no se noten
fácilmente, pero definitivamente
están ahí Por ejemplo,
en realidad podemos hacer clic en
el botón de disparo de spam más rápido que la velocidad de disparo. Es muy difícil de
hacer porque de todos modos he establecido el ritmo de fuego relativamente
rápido, pero pueden ver que
estoy haciendo clic aquí más rápido que si solo
aguantara. Entonces tal vez considera cómo
podrías arreglarlo tú mismo. No voy a
pasar por ese proceso. Esencialmente
sería un caso de rastrear un valor en tal vez un temporizador
separado cuando presionas por
primera vez el botón. La próxima vez que
presione el botón si eso es inferior a lo que sea
la tasa de disparo, entonces simplemente cancelaría la
llamada a la función de disparo. En este caso, no es un proyecto
tan complejo que realmente creo que eso
hace una gran diferencia. Y como mencioné, esta
misma funcionalidad está en el proyecto de ejemplo con el que estamos
tratando de golpear la paridad de todos modos Pero es solo un buen tipo de práctica de pensamiento y mira si
puedes pensar en cómo
incorporarías una lógica similar, pero impidiendo que el jugador
haga clic y dispare más rápido que
la cadencia de disparo dada. Nuestros siguientes pasos principales, sin embargo,
tenemos que los barcos están armados. Tanto el jugador como los
enemigos están disparando, ambos usando diferentes colores,
diferentes ritmos de disparo. También puedes retocar esos
valores. Si encuentras que el
juego es demasiado duro o demasiado fácil, cambia cosas como el daño, que se aplica en función dónde
dispararon los proyectiles,
las tasas de disparo,
cosas así A continuación, vamos a
volver a hacer uso de nuestro engendrador genérico de Actor Y voy a empezar a agregar algunos fondos de desplazamiento para que las cosas nos parezcan un poco más interesantes
23. 22 - Desplazamiento de fondos: Es hora de llevar este
proyecto un poco más lejos y de hecho hacer
que parezca un juego. Vamos a agregar algo de agua,
algunas islas de desplazamiento, y lo haremos
reutilizando nuestro sistema Spanus, por lo que hemos construido eso para tener una configuración tan genérica Podemos cerrar cualquiera de las clases que tenemos
en este momento. Haz clic derecho en la pestaña principal y solo selecciona para cerrar otras pestañas, y eso te deshará de
todo lo que no te encuentres actualmente, y luego simplemente
podremos cerrar al jugador. De vuelta en el arranque de vista principal,
queremos usar el
botón Agregar justo aquí, y vamos a
agregar un plano simple. Entonces, si vamos a formas, y podemos encontrar un plano,
solo queremos que esta
sea una superficie plana. Vamos a
restablecer la ubicación, así que pondremos esto a cero haciendo clic en el
botón de deshacer justo aquí. Pulsa el botón de bloqueo para asegurarnos de que esta
escala de manera uniforme, y luego solo vamos a establecer el valor en algo así como 80 para asegurarnos de que cubrimos toda
la zona de juego, así todo lo que podamos ver. También podemos
deshacernos del piso. Anteriormente estamos
usando eso solo para
contexto para que podamos ver exactamente dónde y
cuándo nos movemos. Estamos usando esa cuadrícula
esencialmente para detectar movimiento. Ya no necesitaremos eso,
así podremos deshacernos de la ubicación real
del avión en sí. Queremos que esto sea
negativo 4,000 en la z. Y nuevamente, esto se basa solo en cómo tengo mi cámara configurada, el avión y las ubicaciones enemigas. Puede encontrar que su nivel tiene
una configuración ligeramente diferente, pero si vamos de un proyecto
más o menos similar por ahora, puede
modificar esto más tarde Tener tan abajo mantiene las sombras un poco más
sutiles y nos da espacio para las
islas flotantes porque algunos de los objetos que he proporcionado
son intencionalmente bastante grandes. Desde la carpeta, vamos a ir
a nuestra carpeta de activos. Encontraremos los materiales,
y podremos encontrar el agua de subrayado MI y simplemente
arrastrarla al avión Por lo que esto
nos dará un material de agua animado bonito, sencillo, básico. Como mencioné,
algunos de los detalles y propiedades pueden necesitar
ser cambiados aquí, como el tamaño del
avión o la ubicación. hacemos un tipo completo de
barrido y
refinamiento una vez que llegamos al final del tema Sin embargo, hacemos un tipo completo de
barrido y
refinamiento una vez que llegamos al final del tema en
función de cómo
se ven las cosas. Si quisieras cambiar
tu agua, nuevamente, podemos hacer doble clic en el material de agua de
subrayado MI Arrastre esto a la ventana aquí. Esta es una buena manera
de, una vez más, hacer uso de la instancia
material. Si encuentras que el agua que fluye era demasiado rápida o no te
gustó el color, podemos obtener esa retroalimentación en vivo
incluso mientras jugamos para ver exactamente
lo que querías
hacer con cosas como
el desvanecimiento de profundidad, la distancia, las diferentes propiedades del
color y
cosas así. Entonces tienes control total sobre cómo quieres que se vea
tu agua. Esto voy a
mantener esto tal como está, pero sólo para decir
que estos valores están aquí si
quisieras modificarlos. A continuación, queremos
considerar nuestras islas. Así que vamos a volver a nuestra
carpeta Blueprints. Crearemos una nueva
carpeta aquí. Vamos a nombrar a esta Islas. Dentro de la carpeta islas, vamos a hacer clic
derecho, ir a clase
Blueprint,
crear un nuevo actor Solo necesitamos algo con presencia en el mundo otra vez, y llamaremos a éste
BP Underscore Island Dentro de la clase, configuración
muy estándar ahora. Vamos a agregar
una nueva malla estática. Estableceremos esto como la raíz de escena
predeterminada, así que anularemos la raíz de escena
predeterminada aquí. Y con la
malla estática seleccionada, vamos a ir
al panel de detalles. Encontraremos la ronda de isla de
subrayado SM, así que la grande para
comenzar Podemos presionar F en el mirador, para que podamos ver cómo sería esa
isla. Y luego solo queremos bajar
a las propiedades de colisión, y vamos a tomar los detalles de
colisión aquí. Vamos a dejar esto abajo,
poner esto en ninguna colisión. Desactivaremos los eventos de superposición de
generar. Solo asegurándose de que
esto no tenga física, no
tenga comprobaciones de solapamiento. Este va a ser un objeto de usar y tirar muy
barato, que solo está ahí para Ahora, antes incluso de entrar en usar nuestro spawner para
traerlos al mundo, sabemos que esto
va a parecer muy repetitivo, muy Vamos a obtener la misma malla
estática en el mismo tamaño, la misma rotación cada
vez que se genera una. Pasemos a la jugada de inicio, y resolveremos
eso de inmediato Como si fuéramos,
vamos a deshacernos del Actor comenzar
la llamada de función de
superposición Queremos que comience a jugar
aquí, y podemos hacer algunas cosas simples desde
el pin de ejecución aquí. Entonces, antes que nada,
podemos aleatorizar un poco
la escala del
actor Entonces llamaremos al set
Actor escala tres D. Y vamos a hacer
esto de una manera un poco extraña. Pero si hacemos clic derecho y
buscamos float aleatorio en rango, podemos establecer ese rango
una vez más
en base a un vector dos D. Así que
crearemos una nueva variable. Llamaremos a esta
escala Min Max. Despliega esto, encuentra el
vector dos D. Compilar y proporciona
algunos valores aquí para tal vez algo así como 0.8 a 1.2. Déjelos caer como
lo hemos hecho antes. Para que puedan ver, de nuevo estamos
llegando al punto en que mucho código va a llegar
a ser muy familiar. Y esta es esa
idea de repetición. Te pondremos más
cómodo con el proyecto y trabajando con Unreal. Entonces
dividiremos la estructura en. Lo conectaremos al
mínimo y al máximo. Y en realidad podemos simplemente
tomar nuestro valor flotante aquí y
convertirlo en un vector. La forma en que esto
funciona, puede parecer un
poco extraño cómo estamos usando
un flotador o un vector. Básicamente solo va
a asegurar que la X, la Y, y la z tomen
lo que sea este resultado. Entonces, si esto elige
1.1, significa que X Y y Z se establecerán
en 1.1. Ahora bien, si
querías
estirar las cosas , ten un control más refinado. Por supuesto, sabes que
puedes dividir el pin de estructura para el vector y tal vez hacer un flotador
aleatorio en la X, la Y y la z individualmente El problema que encuentro con
eso es que en realidad no tienes mucho control refinado sobre evitar que la malla
sea completamente. Puede terminar con algo así
como realmente raro y aplastado o realmente
extraño y estirado Entonces por esa razón, solo
voy a establecer
esto para que sea uniforme, así que es solo escalar todos
los ejes juntos. Entonces también podemos agarrar
nuestra malla estática. Dejaremos esto en
el gráfico de eventos, y vamos a sacar de
nuestra referencia de malla aquí, así que una referencia a nuestro componente, vamos a buscar la función de malla estática
establecida. Queremos este de
aquí, el que nos
dará el componente mesh, solo para asegurarnos de que viste que queremos ir a los componentes static mesh y establecer static
mesh. No esta de aquí. Esto en realidad es actualizar
la propia variable, mientras que esto es tomar el
componente que tenemos y está accediendo a los detalles a través de
nuestro panel de detalles aquí. Entonces queremos tal vez aleatorizar la malla estática que
usamos, también Para que podamos sacar de
aquí. Probablemente tengas una idea a dónde
va esto porque de nuevo, lo
hemos hecho
muchas veces antes. Solo tenemos dos
opciones estáticas diferentes para las islas Entonces voy a
usar un nodo select. Y como solo tenemos
dos, la forma más fácil que puedo ver esto es
si tuviéramos más, podríamos querer usar algún entero
aleatorio dentro de un rango, y si tuviéramos cinco,
elegiríamos un rango 0-4 o uno, cinco, lo que sea Y dependiendo de lo que se escogiera entre ese rango entero, elegiría uno de cuatro
o cinco modelos diferentes. Ahora, porque sólo tenemos dos, sólo
voy a usar un booleano Aquí voy a escoger una pelota
al azar. Ni siquiera necesitamos que
esto sea una variable. Y entonces básicamente
tenemos 50 posibilidades de desovar en la
isla grande o en la pequeña isla Entonces, agradable y simple,
no necesitamos hacer
esto demasiado complejo, al
menos ahora estamos obteniendo
algo de aleatorización Podríamos engendrar la misma
isla grande tres veces seguidas, pero al menos la escala
será ligeramente diferente
en cada una Si no, entonces podemos
estar aleatorizando entre la isla grande y
la pequeña Y nuevamente, todavía
van a tener algún buen escalado aleatorio aplicado Y luego, finalmente, todos
van a seguir luciendo de
la misma manera. Así podemos agarrar nuestros detalles de
rotación, y podemos aleatorizar
eso también Entonces sacaremos de
la malla estática, y voy a encontrar
el conjunto de rotación activa. Este, solo queremos rotar alrededor del eje z
porque recuerden, eso va a ser arriba
o abajo en el mundo. Así que vamos a hacer clic derecho
y dividir la estructura en. En realidad solo voy
a ser un poco perezoso y agarrar el
flotador aleatorio en el rango. Duplicar eso por aquí, sólo
vamos a rotar esto 0-360 grados. Entonces esta es una de esas
veces que no creo que haya ningún valor en
promover esto a una variable. Creo que eso está bastante claro.
Cuando miramos algo, estamos configurando la rotación de
actores, y vamos 0-360, así que obviamente estamos permitiendo
una rotación completa Así que en realidad no
recomendaría promocionar
esto a una variable. Algunas cosas pueden estar bien
como un número mágico, sobre todo porque
sabemos que no vamos
a estar actualizando o ajustando esto No hay razón por la
que pueda ver que vamos a querer
sujetar eso a una diferente. Estaba promocionando esto
a una variable significa que no necesitamos
volver al código. Y si quisiéramos cambiar
completamente la escala sin
encontrar el código en sí, podríamos establecer esto en
0.4 o 2.5 o lo que
queramos que sea esto
para hacer realmente exagerar el escalado.
Yo no voy a hacer eso. Voy a mantener eso como 0.8 y 1.2. Entonces solo esos tres
cambios, vamos a tener algo que ahora se
ve mucho más aleatorio y un poco más único que solo tener
los mismos dos objetos apareciendo exactamente
la misma escala y rotación cuando se
ponen en juego Ahora podemos pasar
al movimiento. es por eso que hemos mantenido lo evasivo. Nuevamente, queremos un movimiento agradable,
consistente, suave, y con una lógica realmente
simple, esto no va a ser
demasiado caro para correr. Sacaremos del pin
de ejecución, y encontraremos el offset del mundo del
actor publicitario. ¿Queremos este de
aquí? Agregar Actor offset mundial para todo el
actor de la isla. Darnos algo de espacio
porque necesitamos hacer algún cálculo
aquí para el offset. Crearemos una nueva variable. Voy a promocionar de nuevo los
segundos Delta solo
para ser perezoso aquí. Promueve esto a variable para que
obtengamos el tipo correcto, y llamaré a este velocidad
de movimiento. Pulsa Compilar, y configuramos esto a un valor predeterminado de algo
así como 400 unidades de velocidad, pero vamos a querer
asegurarnos de darle a esto
un valor negativo, así que negativo 400 para asegurar que esto se
desplaza hacia abajo en la pantalla Podemos deshacernos de
nuestra velocidad de movimiento. Solo queremos tomar
nuestra velocidad de movimiento multiplicada por Delta segundos. Y vamos a enchufar esto
a nuestro valor aquí. Me acabo de dar cuenta
mirando esto. No queremos agregar
un desplazamiento mundial aquí, así que eliminaremos esto. En realidad queremos
agregar el offset local. Entonces usaremos el complemento
actor offset local. Dividir la estructura
p para el Delta, y luego lo conectaremos a nuestra ubicación Delta X
porque nuevamente, solo
estamos moviendo esto
en la X avanzando
hacia atrás a través de la pantalla. No necesitamos calcular con ninguna física ni
nada por el estilo,
ni tratar de hacer alguna
pseudo física a lo largo del tiempo Entonces no estamos usando
el offset mundial. Podemos usar el offset local. Tomaré donde está actualmente el
actor, y solo agregará este
valor a esa dirección X. De hecho, la razón
que me vino a la mente es que si volvemos al tutorial
shoot 'em up, iremos a nuestros proyectiles
y abriremos una clase de proyectiles Podemos ver el evento aquí. Esta es en realidad la misma lógica que estamos usando para
mover nuestros proyectiles La isla es esencialmente
solo un proyectil
muy lento, muy grande en la
forma en que tenemos nuestro código De nuevo, esto es en realidad
algo que está haciendo uso del mismo código. Es solo algo a
tener en cuenta que estamos haciendo un poco de
duplicación nuevamente, y esto podría ser
en un proyecto más grande donde empieces a
mirar cosas como la composición donde podríamos tener un componente de
movimiento personalizado, que por ser tan
similar y todo lo que
realmente necesitamos es una
dirección o una velocidad, podemos tener esos valores
expuestos en un componente personalizado y podríamos dejarlos caer sobre los diferentes actores que los necesitan. Como he mencionado, un poco fuera de alcance para
el contenido por el que estamos pasando
en este momento, pero solo algo a considerar. Este no es el fin del mundo, así que vamos a
mantener esto como está. Y ahora en realidad podemos
empezar a desovar estos en. Entonces aquí es donde va a ser bastante útil
la clase de actor
genérico simple, la clase de engendrador
que hemos creado va a ser bastante Entonces, si entramos en
nuestro nivel, primero, solo
quiero
probar muy rápidamente cómo
van a quedar las islas, así agarraré una de
las islas y dejaré caer esto en ese
avión de agua en el fondo. Queremos hacernos una idea aproximada de la altura que
queremos engendrar esto Nuevamente, esto se reduce
a un poco de retoques. Voy a hacer algo de
eso ahora, pero
probablemente refinaré esto fuera de la pantalla Así que creo, en realidad la primera vez que se me cayó uno de estos en, fue, en realidad,
lo mismo que el avión
en sí, entonces -4,000 Entonces podemos ir con
eso como línea de base. Probablemente estableceremos el
generador en la misma ubicación. Queremos
asegurarnos de que esto esté más atrás fuera de cámara. Entonces esto es algo que ahora
podemos probar fácilmente. Vamos a agarrar a
nuestro actor de cámara. Vamos a anclar esto aquí,
y podemos comenzar
realmente a ajustar y
asegurarnos de que todo se genere fuera de
la pantalla. Así que para la isla grande aquí, además tal vez algunos
contabilizando podemos hasta una escala de 1.2, recuerden, es nuestro escalado
aleatorio Entonces, si conseguimos el spondm de isla
más grande, necesitamos que esté al
menos en el punto de 11,360 en la X para estar completamente fuera de
vista cuando hay Entonces ese es nuestro
punto esencial en el que
queremos que se coloque nuestro engendro de
la isla Entonces, de hecho, voy
a agarrar esto aquí, convertir ese cero en la y, así vamos a
empezar en el medio. Lo que voy a hacer
es con los seleccionados, voy a volver a
la carpeta de planos aquí Voy a ir a
la carpeta spawners. Seleccione esto. Y con esto
seleccionado en el sorteo de contenido, solo por consejo práctico que estás a
punto de ver aquí. Podemos hacer click derecho
sobre esta isla. Bajaremos para reemplazar a Actor, y podemos reemplazarlo con
lo que actualmente
hemos seleccionado dentro
de nuestro cajón de contenido. Así que vamos a renombrar
esto. Este objeto, podemos ver es ahora una Spaner de subrayado
BP Voy a cambiarle el nombre a Island spawner. Entonces eso está
claro lo que está haciendo eso. Y de hecho, a la hora de nombrar, esto va a empezar a ponerse
un poco descuidado como nosotros Lo que realmente debería
haber hecho es que llamaremos a esta isla de subrayado spawner porque podemos ver que
esto Así que también podemos entonces
cambiar el nombre de éste para engendrador subrayado enemigo Entonces ahora está un poco claro que este es
nuestro engendrador enemigo Este es nuestro engendro de la isla, y van a ser
agrupados Ahora bien, otra cosa que
podemos ver como un problema es que la malla estática es
simplemente del tamaño incorrecto. Creo que podría haber
estado considerando un activo
diferente con el que estaba
trabajando antes. Entonces solo queremos tal vez
aumentar esto a algo así como 120 en todos los ejes, tal vez incluso 160. Perfectamente bien. Lo principal esto es
cubrir toda la cámara. Así que ya podemos ver en modo play, tenemos el agua
cubriéndolo todo. El spawner estará justo
afuera de la cámara para que podamos asegurarnos de que
las islas aparezcan fuera de la Ahora bien, una cosa realmente importante que
estaba a punto de
echarme de menos por completo es si volvemos
a la isla de los engendros, cuando estaba ajustando esto,
puse la escala Ahora siempre queremos
asegurarnos de que mantengamos estos uniformes porque en
algunos de los códigos de desove, posible
que estés tomando la rotación de ubicación del
actor en escala como el punto
en el que desovar Entonces no queremos
agregar ningún valor predeterminado, algo así como offset preestablecido
a la escala de cualquier cosa, así que solo asegúrate de que
volvamos eso a uno. Entonces para que esto funcione
para el desove de la isla, vamos
a querer dejar esto y seleccionar nuestra clase de isla Entonces queremos la isla de
subrayado BP. Vamos a permitir un
desplazamiento aleatorio, así que marcaremos esto. Proporcionaremos una distancia de
desplazamiento de, digamos, 5,000
unidades a cada lado. Así que recuerda, esto es solo usar la funcionalidad
incorporada que ya implementamos cuando
planeábamos un
poco con anticipación al crear nuestra clase
genérica de generación. Y en los intervalos de desove, no
queremos que demasiadas islas
abarroten la escena. Así que pondremos esto
en algo así como 5 segundos y cada 10 segundos. Entonces 5-10 segundos,
deberíamos conseguir una nueva isla. Solo tengo un resumen muy
rápido de la razón por la que estamos usando
el desplazamiento aquí, recuerda, hemos creado en
nuestra base de spawner, tenemos nuestra rama el spawn comenzado o
un cheque booleano aquí,
lo siento, sobre si deberíamos Si decimos que no, entonces simplemente
engendraríamos la isla exactamente en
el punto del engendrador, lo que significa que solo tenemos una línea recta
de isla constante, que de nuevo, sería
un poco rara Si decimos que sí, entonces
va a elegir un flotador aleatorio dentro de un
rango, que en nuestro caso, porque hemos establecido esto en 5,000, lo que sería entre
5,000 en la Y y negativo 5,000 en la Y. Así que eso debería darnos mucha
variación en su punto de inicio, su escala, su rotación,
e incluso la malla. Entonces podemos probar esto ahora si
presionamos deberíamos ver
en algún lugar dentro de los 5 segundos. Voy a deshacerme de
la cámara muy rápido. En el modo de juego, podemos probar esto y solo esperar
un poco, y deberíamos ver que las
islas empiezan a desovar en Estamos buscando
cosas como asegurarnos no solo
estén
apareciendo,
asegurándonos de que
van en la dirección correcta, con
lo que creo que podemos
tener un problema aquí, y también que están
desove correctamente dentro del offset que hemos
proporcionado de que no solo
estén
apareciendo,
asegurándonos de que
van en la dirección correcta, con
lo que creo que podemos
tener un problema aquí,
y también que están
desove correctamente
dentro del offset que hemos
proporcionado. Entonces no estoy
viendo algo. Hay una isla muy pequeña. Eso pudo haber tomado
los 10 segundos, pero tenemos una isla muy pequeña ahí apenas aflorando
desde abajo Es algo cómico, pero creo que eso todavía
se ve bastante bien Y deberíamos ver,
ojalá, algunas islas más llegando en los
próximos segundos. Bien, entonces en realidad
tenemos muchas
islas este es un problema estamos teniendo es que con
su rotación aleatoria, están avanzando en función de
la dirección en la que
han sido engendradas Entonces, sigamos adelante. Creo que tal vez sí
estropeé parte de la lógica cuando estamos
creando la lógica del movimiento. Y creo que, en serio,
es solo volver a lo que estábamos
viendo anteriormente. Entonces, de vuelta en la clase de la isla,
creo que fue esto de aquí, el offset local versus el
offset mundial que tenía en mente. Entonces sería bueno si
pudiéramos mantener el código, similar al
proyectil, y
probablemente podríamos cambiar el código del
proyectil Pero creo que lo que
estamos haciendo solo para mantener esto agradable y sencillo, vamos a
cambiar esto de nuestro offset
local porque recuerden, cuando estamos haciendo una adición
local o una compensación a la
posición local del actor, eso tomará en cuenta la rotación actual
que tiene, porque queremos rotar o si estamos rotando 180
grados el otro dirección, luego avanzar localmente
ha cambiado, así que vamos a movernos
en la otra dirección. Decir eso, sin embargo, eso me
hizo darme cuenta de que probablemente
podríamos hacer algo un poco más limpio aquí, centrándonos en la jerarquía. Entonces nuevamente, esto es
algo donde en el pre desarrollo,
simplemente pasé por alto esto Y este soy yo, pienso
algo así como en el acto, por
lo que estoy guardando esto solo para mostrar formas
en las que podemos resolver diferentes
problemas de varias maneras. Entonces, lo que estoy tentado a hacer es porque sí quiero
mantener esta lógica Quiero hacer el movimiento de
desplazamiento local. Lo que creo que vamos a hacer en cambio es que
vamos a añadir
un nuevo componente. Vamos a crear un componente de escena
vacío, y haremos de esta
la nueva ruta. Entonces el componente de escena
será la forma en la que estamos enfrentando, que simplemente siempre va
a estar adelante en el mundo. Y creo que lo que
vamos a hacer en cambio es que
vamos a establecer nuestra rotación, pero no vamos a establecer la rotación de todo
el actor. Vamos a dejar el componente de escena
siempre mirando hacia adelante. Y esto solo
te dará un buen ejemplo de diferentes formas en las que podemos
usar la jerarquía, también. Podemos agarrar nuestro partido estático, y en su lugar, vamos a
establecer la rotación de esto. Esto también es algo
que aún no hemos visto, por lo que podemos establecer la rotación
relativa de nuestros componentes en relación con
su componente padre al que están unidos. Pero exactamente la
misma lógica, sin embargo. Vamos a enchufar
esto. Vamos a tomar este flotador aleatorio
que ya tenemos, dividir el pin de estructura
como lo hemos hecho antes. Solo vamos a enchufar esto a la Z aquí
en su lugar. Eso significa que podemos mantener nuestra lógica de movimiento
exactamente igual. Y ahora no estamos
cambiando la rotación de todo
el actor y
la forma en que se enfrenta. Eso sigue en
la misma dirección. Sólo estamos cambiando la
rotación del elemento visual. Algo parecido a cómo
separamos eso
con los planos,
donde el elemento visual
es solo el cuerpo plano, pero la
colisión real y en lo todo descansa
es esa colideosfera Entonces, si volvemos a entrar y jugar,
deberíamos ver que esto está funcionando ahora. Otro comando de consola útil aquí es que podemos presionar
la tecla Tilda, escribir slow mo, y luego establecer esto a cuántas veces
más rápido queremos que esto vaya Entonces, si configuramos esto
para frenar mo cinco, se
puede ver que esto se está
moviendo cinco veces más rápido, mucho más fácil para
probar y realmente ver si las islas
están desove correctamente Así que ahora se mueven
por la pantalla. Eso parece que está
funcionando correctamente. Tenemos esa prueba en recordar, donde no vamos a
seguir desove cosas Si el jugador está muerto. Comando de consola nuevamente,
podemos escribir un nivel de reinicio, volver directamente a Slom cinco, y podemos hacer algunas pruebas
solo para asegurarnos de que las islas solo
asegurándonos de que obtengamos varias
pruebas sobre la marcha, que las islas
estén funcionando bien Entonces se están agrupando
mucho, pero quiero decir, de
nuevo, aquí es donde entra la
aleatorización Puede que eso suceda,
pero está proporcionando algún tipo de variación agradable, y creo que
se ve bastante bien. Quizás quiera agregar un
poco más de retraso entre las islas
iniciales, pero creo que solo para
este tipo de proyectos, eso se ve bastante
genial y tener algo de superposición solo
le da esa variedad extra. Otra cosa
que quizás quieras hacer es en la clase base spawner, si entramos aquí,
vamos a engendrar
inmediatamente Actor engendrar
inmediatamente Actor Entonces deberíamos tener
uno. Si acabamos golpear simula. Deberíamos
simplemente verificar dos veces. Sí, conseguimos uno de inmediato, lo
cual está perfectamente bien. Estaba pensando que
podríamos haber
tenido ya un retraso inicial, pero creo que la única
razón por la que no lo
vemos por un
tiempo es solo
porque lleva un poquito de tiempo
bajar por la pantalla. Así que en realidad engendramos con
una isla de inmediato. , sólo me Sin embargo, sólo me
pregunto dónde
está eso ahora mismo. Entonces, es solo que está tomando sobre todo si genera uno
pequeño, antes que nada Va a tomar un
poco más de tiempo verla antes de que entre en marco.
No el fin del mundo. Nuevamente, aleatorización, vas a tener algunos resultados
diferentes ahí Incluso con la
isla más grande, creo que eso está tomando bastante tiempo
entrar en la pantalla aunque. Entonces tal vez lo que estaría
tentado a hacer, y de nuevo, esto se reduce a muchos viajes ahora jugando por ahí A lo mejor estábamos
demasiado preocupados por lo
lejos que está esta mañana esta mañana. Así que solo traeremos esto de
vuelta en un poco, y solo otra vez, asegurándonos que cada vez que presionas placa, vigilando para
asegurarnos de que nada simplemente aparece, pero queremos que esa isla tal vez muestre en la pantalla solo un
poco antes. Entonces como mencioné, prueba y
error, mira cómo van las cosas, vigila los resultados
que estás obteniendo y
asegurándote de que el juego se ve bien a medida que
vas atravesando. Entonces creo que
ahí es bastante genial. Aquí es donde las cosas deberían empezar a ponerse un poco más
interesantes, sin embargo. Ahora tienes el control total sobre el diseño de niveles, donde
querías que las cosas engendraran
, la velocidad que quieres que se muevan, realmente solo refinando la jugada y el aspecto del juego que tienes Si las cosas están apareciendo
, entonces puedes simplemente mover al engendrador
un poco más atrás Si quieres
que aparezcan antes, entonces podríamos acercarlos
un poco más. Si el agua no está
cubriendo toda la vista, entonces simplemente aumente el
avión como acaba de ver. Y si las islas
están demasiado cerca, entonces solo baja la
velocidad de desove y cosas así Y esto es solo pura iteración, jugar, observar, ajustar, repetir Es raro que consigas
esta primera vez perfecta. Acabas de verme hay que
retocar y cambiar algunas cosas incluso para
esta demostración aquí, pero ahí debería ser
donde
entra algo de la diversión de crear juegos porque es donde ahora
tienes mucho más control de refinar ese resultado final Ahora bien, una cosa que
diría es que
va a valer la pena en
este momento también, vigilar al outliner, como ya he mencionado antes Tenemos algunas cosas, tenemos nuestros volúmenes de bloqueo
están perfectamente bien. A lo mejor poniendo
las cosas en carpetas como con la iluminación
que venía por defecto. Una cosa de la que me he dado cuenta de que en realidad
no estamos haciendo uso es la esfera del cielo en el fondo.
Se trata de un objeto antiguo. No está haciendo nada. Podemos deshacernos de
la esfera del cielo. No se ve nada cambia, solo para asegurarnos de que no tenemos más objetos en el
nivel de los que necesitamos. Todo lo demás está bien. Esto es proporcionar la luz y la atmósfera en
el fondo. Pero siéntete libre de comenzar a
jugar con estos, cambiando la dirección de la luz direccional,
la fuerza de
la misma para hacer que
las cosas se vean más brillantes, más oscuras. De nuevo, realmente empieza a ser
creativo y a jugar con las diferentes
propiedades y detalles para hacer que el juego se vea como
tú pretendía. Entonces eso es todo para nuestro
nivel. Ahora las cosas se ven un
poco más vivas. Tenemos islas de agua,
paralaje de puedes jugar con. En realidad está empezando a parecer un
poco de juego. A continuación, podemos empezar a
meternos en el pase pulido, haciendo que las cosas se sientan
realmente interesantes y mucho más
atractivas visualmente para el jugador.
24. 23 - Partículas del Niágara: Punto donde podamos
comenzar a mejorar la sensación general y atraer a alguien que
juega nuestro juego. Vamos a comenzar con el
pulido pase de efectos,
agregando cosas como
propulsores, explosión,
impacto, todo mediante el uso del motor
Unreal construido en Así que una rápida visión general
nuevamente de los sistemas y emisores que vamos a estar viendo
dentro de nuestro proyecto Si navegamos a nuestro proyecto, entra en la
carpeta Activos y efectos, tenemos nuestros
sistemas Niagara justo aquí. Pero solo abre uno de
estos. Iremos con el motor de píxeles por ahora solo para mostrar con qué
estamos trabajando. Entonces, en lo que estamos dentro
en este momento es un sistema de Niágara. Los sistemas generalmente están
construidos de uno y muy a menudo
más de un emisor Podemos ver aquí los paneles con pestaña
naranja son nuestros emisores que componen los diferentes puntos
de nuestro sistema general Esto hace que Niagara sea mucho
más flexible para
trabajar que el sistema de partículas
en cascada más antiguo. Es mucho más fácil
en el nuevo sistema crear algunos emisores base, y luego podemos comenzar a
coserlos juntos para hacer sistemas personalizados y
únicos De una
manera realmente simplista, se puede pensar en esto
como algo así como un sistema de partículas de
llama Es posible que tenga muchos emisores
que entrarían en esto. Tendrías las chispas
que vienen de lo alto de la llama.
Tendrías algo de humo. Podrías tener el efecto de
distorsión, y tendrías el cuerpo
principal de la llama y el fuego mismo. Todos estos podrían ser emisores
individuales construyendo ese gran sistema Lo importante
a tener en cuenta es que los emisores están
destinados a ser reutilizables No colocamos estos directamente en nuestros planos o en
los sistemas que vamos a estar tomando para
usar y realmente hacer uso de dentro de nuestro código
o el propio nivel Si querías empezar
a intentar jugar con algunos de los sistemas que
ya te he proporcionado, puedes ver que
tengo varios aquí. Puedes
entrar muy fácilmente y empezar a jugar con las
propiedades en los emisores. Si quisieras ver qué
parte es la responsable cierto efecto que está
ocurriendo aquí en la olla de vista, podemos
desmarcarlas aquí Podemos ver que esto es
solo una fuente de luz, así que nada cambia realmente. Si volvemos a encender esto, pero luego apagamos el otro emisor, podemos ver que este es claramente
el responsable cuerpo
del efecto de
partículas de nuestro motor ahí Entonces, si entonces querías
venir y empezar a
tratar de jugar con
cosas como el color, el tamaño de este, puede que
no sepas exactamente lo que estás buscando de inmediato, lo
cual está Pero solo por un vistazo rápido a las
propiedades proporcionadas, podemos ver que
probablemente podríamos cambiar el color de nuestros valores de
escala aquí. Esto está haciendo el color amarillo
anaranjado aquí. Si le damos a esto más azul,
entonces vamos a obtener
un color diferente a lo largo de la
vida útil de la partícula. Es otra gran
manera de acostumbrarse a algunos de los sistemas
dentro de Unreal, simplemente encontrando las cosas que
instintivamente tienen sentido para ti y jugando y tejiendo con los
valores Puedes agregar diferentes
cosas como velocidad
extra para hacer que este
viaje sea más lejos, también. Y como he
mencionado antes, una manera
realmente genial de averiguar de qué son
las cosas responsables es agregar un
gran valor realmente tonto a esto, así podemos ver que si
hacemos la velocidad aquí 11,000 en lugar de 1,000, podemos ver exactamente de qué fue
eso responsable, y luego podemos refinar
y retocar a un valor con el que pensamos que
podríamos querer trabajar Entonces, al igual que con algunos de
los otros sistemas dentro del proyecto que
hemos mirado hasta ahora, el lado más artístico
de las cosas realmente no es el foco de lo que
estamos tratando atravesar en estos temas. Entonces no voy a
adentrarme más en el Niágara. Quiero mostrarte
cómo usarlo y cómo podemos
implementarlo en un proyecto. Útil si tienes cosas como acceso a los PACs de Asset o algunos de los ejemplos gratuitos
de cosas como el
proyecto de ejemplo de contenido proporcionado por Epic Lo primero, como
ya estamos en esta partícula, podríamos hacer uso de
esto para el propulsor para nuestras dos clases de avión Ambos necesitarán esto, tanto el enemigo como el jugador. Entonces, si vamos a nuestra clase de
planos, iremos a CR, y encontraremos del plano de subrayado BP Para que podamos volver a poner esto en
la clase base, y esto se utilizará para nuestros
dos planos diferentes. Tenemos que ser muy cuidadosos otra vez donde
vamos a colocar esto. Podríamos colocarlo
directamente sobre la esfera, pero creo que por el momento, en caso de que quisiéramos hacer alguna rotación de desplazamiento
específica, cosas así a
la malla estática, colocaremos aquí en su lugar. Entonces agarraremos la malla estática. Vamos a agregar
un nuevo componente, y queremos
buscar Niagara. Podemos ver aquí
solo tenemos la única opción, el componente
del
sistema de partículas Niagara. Y en el panel de detalles,
veremos el menú desplegable que probablemente
estemos buscando y con el que ya estamos bastante familiarizados. Podemos bajar esto y
seleccionar el motor de píxeles. Si navegamos hasta el viewpot, podemos ver que esto ha sido
atracado en medio de
Amopla,
así que solo vamos a necesitar retroceder un poco atracado en medio de
Amopla, así que solo vamos a necesitar esto Y creo que simplemente
colocaré esto aproximadamente por el círculo metálico que he
agregado en el avión justo aquí. Si golpeamos Compilando seguro, hay algunas cosas que podríamos
necesitar probar con esto Entonces la primera es
la rotación diferente que vamos
a aplicar a las diferentes clases infantiles. Entonces, si empezamos dentro
del jugador llano y solo
revisamos el punto de vista aquí, este se ve
perfectamente bien. Esta es esencialmente la
misma configuración que la base del plano. Si entramos en enemigo llano,
adentramos en el mirador aquí, para que podamos ver que
el efecto de partícula se ve bien aquí también No obstante, si vamos
y presionamos play, así que si entramos en nuestro
viewpot y modo play aquí, podemos ver que le parece bien al jugador, pero las partículas enemigas se
ven un poco
extrañas ya que son esto
va a ser porque recuerden,
cuando entramos en modo de juego, estamos volteando completamente la rotación de nuestro enemigo en función
de la ubicación de
los Y aunque este efecto de
partícula esté anidado, si miramos la configuración en el motor de píxeles de subrayado
P, podemos ver que la
velocidad se establece una dirección específica,
negativa 1,200 Entonces, qué queremos hacer, y
esto solo va a ser un tweak muy simple a un sistema de partículas
existente Para que puedas empezar a tener
al menos un poquito manos a la
obra, necesitamos hacer un duplicado
del motor de píxeles. Entonces vamos a
volver a entrar en nuestros efectos. Vamos a ir a
nuestros sistemas Niagara. Tenemos nuestro
motor de píxeles justo aquí. Otra cosa, estos
fueron copiados de los ejemplos de contenido
no tienen el mejor naming, así que vamos a
tomar esto y
cambiaremos el nombre de éste a Ns Entonces, la convención de nomenclatura adecuada
sería el sistema Nagra, motor de píxeles de
subrayado, y llamaremos a este jugador de subrayado Para que podamos dejar
éste exactamente como está. Entonces podemos presionar
Control, de hecho, para duplicar esto,
y llamaremos a este guión bajo enemigo Y si hacemos doble clic para
abrir la versión enemiga, lo que queremos hacer es que
vamos a encontrar nuestra velocidad. Ya hemos visto que
esto es controlar la dirección en la que va el efecto de
partícula, y aquí solo vamos a eliminar
la opción de negar También podríamos hacer algo
mientras estamos aquí, haciendo que este tal vez sea un
poco más verde para que
podamos arrastrar el valor aquí para darle un tinte ligeramente
diferente. Y si tomamos ese más
allá del valor rojo, podemos ver que
aquí es un
poco más de
un propulsador verde solo para hacerlo poco más único para la versión enemiga en la que
vamos a colocar esto Para que podamos golpear compilar
y ahorrar en eso. Volveremos a
la clase enemiga. Vamos a agarrar nuestro sistema de
partículas de Niágara aquí, y todo lo que queremos hacer es
cambiar esto del jugador, que es el que
acabamos de renombrar y cambiar esto a
la versión enemiga Entonces esto va a parecer
roto en el plano. Eso está perfectamente bien, porque cuanto entramos en playode, esto es tomando en cuenta
la dirección mundial del
movimiento
del sistema de partículas
más que la entidad que está encendida Entonces podemos ver que ahora está
funcionando perfectamente bien. Un poco diferente porque
tenemos diferentes colores, así que también se ve un
poco más interesante. Un bonito y sencillo retoque solo para
ponernos un poco en las manos con
el sistema de partículas ahí, y tenemos funcionando tanto al jugador
como al sistema enemigo Así que esa es una forma en la que
podemos aplicar partículas sin código directamente en componentes
y características existentes. Ahora bien, si recuerdas,
tenemos algunas cosas
alineadas listas para comenzar a
implementarlas también en nuestro código. Recuerda algunos de
esos para hacer comentarios. Entonces uno de esos que recuerdo
haber sido en realidad estaba en nuestra clase de planos
para nuestros proyectiles Entonces, si entramos en BP
subrayado base de proyectil, y exactamente lo que
mencionaba antes, solo
voy a
escribir todo aquí abajo. Encontraremos ese
comentario que me he dejado , y es justo aquí abajo. Entonces, si no dejaste ese
comentario, solo necesitas
navegar hasta que tu
componente comience a superponerse, y aquí es donde queremos
poner algunos efectos. Y vamos a comenzar con
nuestro sencillo sistema de partículas para demostrar que dos
cosas han impactado. Entonces entre nuestro daño de aplicación, y nuevamente, realmente importante antes de destruir
el proyectil, vamos a sacar
del
pin de ejecución y vamos
a buscar algo llamado
sistema de desove en Entonces queremos esta
opción justo aquí, span system at location. Ahora, hay un par de cosas
diferentes si
empiezas a buscar más partículas tú mismo para construir sobre lo que
estamos haciendo aquí. También puede encontrarse con
el término emisor de desove. Entonces, si buscamos el
emisor Born en el lugar, es una terminología muy similar, y esta es esencialmente
la versión heredada del sistema
de partículas Entonces aún no se ha eliminado completamente, pero lo he mencionado muy
brevemente hace un momento. Solía haber
algo llamado sistema
de partículas en cascada. No era tan flexible, no tiene tantas características. No es tan fácil
programar, mientras que ahora usamos
el sistema Niagara. Entonces, cuando quieras
trabajar con Niagara, que es idealmente en lo que
te vas a centrar, deberías estar
buscando algo llamado sistema de palabras que
surja bastante. Cuando estás trabajando con
cascada, si estás en un proyecto heredado o en
un proyecto anterior, es posible que veas aparecer la
palabra emisor Así que los artículos en cascada fueron
referidos como emisores, mientras que ahora, como he mencionado, un emisor es solo
un elemento único que construye todo un sistema
Niagara Entonces esa es la
forma más fácil de
recordarlo . Entonces estamos
buscando un sistema. Sabes que
también tienes
el correcto , porque si
bajamos esto, no
tenemos nada
válido para poner en la ranura del emisor. Entonces
nos desharemos de esto. Si dejamos caer este, queremos
encontrar nuestro impacto metálico. Entonces esto es lo que
queremos usar cuando dos proyectiles o un proyectil
chocan Entonces ese es el emisor
que queremos engendrar. Y esto nos permite
incorporarlos en tiempo de ejecución, haciendo que los proyectos se vean un
poco más dinámicos. La ubicación va
a ser muy sencilla. Vamos a tirar de aquí,
y sólo vamos a
buscar la ubicación del actor get. Entonces
aquí será donde queremos que genere el efecto
partícula, el punto de impacto, esencialmente,
de donde golpean dos cosas La rotación en escala la
dejaremos por defecto. No necesitamos
cambiarlos. Volveremos y haremos algunos
efectos de sonido y cosas más tarde. Entonces en realidad voy a dejar este comentario para mí más tarde, ya que tendré que volver
y agregar algunas cosas más. Pero nuevamente, ahora podemos
entrar y probar,
y lo que deberíamos
ver es que cada vez un proyectil golpea algo, vamos a conseguir que se juegue algún tipo de efecto de partícula Entonces es un
poco extremo, pero definitivamente podemos
ver que está sucediendo. Y nuevamente, puedes
entrar, refinar las diferentes escalas
y cosas así. Pero ahora tenemos algunos comentarios de que dos
cosas han chocado, lo que simplemente hace que el
juego se sienta mucho más interesante e
intuitivo de jugar También he proporcionado,
así como el impacto metálico. También podrías
usar potencialmente la explosión de píxeles, así que depende completamente de ti. Creo que se ven
un poco diferentes. Sólo revisa de
nuevo cómo se ven. Ese podría ser un
poco más adecuado en realidad para el
menor impacto allí. Entonces me voy a quedar
con eso con la explosión de píxeles. Pero eso es lo principal que
ahora tenemos esa retroalimentación visual. Y entonces queremos
hacer lo mismo por nuestros dos aviones. Así que de nuevo, hemos flasheado
esto en la clase base, así que vamos a entrar en la base del plano de subrayado
BP Creo que también me he dejado
un demasiado aquí, y simplemente haremos doble
clic sobre esto. Entonces para hacer implementar efectos de muerte en
avión. Entonces estos serán los
efectos que quiero
jugar cuando cualquiera de los
aviones sea destruido. Así lo mismo otra vez.
Vamos a tirar de aquí. Buscaremos la opción del sistema
Born. Tome el sistema span en la
ubicación. Misma propiedad. Entonces donde quiera que el avión
acabe de ser destruido, esa
será la ubicación. Entonces vamos a encontrar
el acto de llegar a la ubicación. Y vamos a hacer esto de una manera
muy ligeramente
diferente aquí. Entonces, como lo hemos hecho en
el pasado, queremos
hacer esto flexible
porque estamos exponiendo esto para su uso en
las clases hijo del padre donde está
la lógica central. Entonces vamos a tomar
nuestra plantilla de sistema aquí, y solo vamos a
promover esto a una variable. Estamos renombrando éste a efecto de partículas de
explosión. Y tendremos que cambiar esto en las clases infantiles
porque el jugador y el enemigo tienen apenas efectos de
partículas muy ligeramente diferentes. Así que golpeamos compilar y guardar. Vamos a
entrar en la clase de avión,
la clase de avión jugador. Asegúrate de que tenemos
el elemento superior seleccionado, y deberíamos poder
ver en algún lugar aquí abajo, ahora
tenemos un efecto de
partícula de explosión. A partir de este, voy a
encontrar Pixel explosion player, y luego golpearemos compilar,
guardar entrar en el avión enemigo. Lo mismo otra vez. Agarra
el elemento superior. Vamos a encontrar nuestra partícula de
explosión, y cambiaremos esta
a la versión enemiga. Tan agradable y sencillo,
compilar y guardar de nuevo. Y ahora queremos ir a
probar y ver cómo está
funcionando esto cuando las cosas
realmente se soplan entre sí. Entonces vemos que hay un poco de retraso la primera
vez que entra. En un juego ligero completamente destellado, vas
a querer ejecutar algo para conseguir que los shaders
se precompilen, para asegurarte
de que todos los efectos son esencialmente redondos al menos
encendido, así que no obtenemos Pero ahora que ya hemos
superado eso,
podemos ver que tenemos los
diferentes efectos. Y podemos simplemente probar, también. Cuando el jugador muere,
obtenemos lo mismo. Entonces es ligeramente diferente si verificamos dos veces y miramos estos. Creo que uno es
un poco más azul, así que aquí tenemos una especie de explosión
azul, y el otro
tiene ese tinte verde. Por lo tanto, es posible que desee entrar y cambiar las propiedades de color. Y se puede ver como las cosas se vuelven
un poco más complejas, podemos ver la complejidad, el número de emisores va Pero una vez que empiezas a
familiarizarte con las cosas que estás buscando, estas son relativamente
fáciles de modificar y cambiar y se configuran para que
funcionen exactamente como quieras Ese es el
lado de programación de las cosas. Eso es realmente todo
lo que necesitamos hacer para que jueguen algunos efectos de partículas Entonces, es un paso relativamente simple agregar un poco de buen pulido
a nuestro proyecto. Y esta es otra de esas cosas donde la
experimentación y jugar con
las cosas realmente te va a beneficiar
más que a cualquier otra cosa. Por ejemplo, he tomado los efectos de partículas directamente de los ejemplos de contenido épico, y creo que solo para
la configuración general que las explosiones se ven
un poco demasiado delgadas, no tan gruesas como
podría haber querido Entonces, lo que podría tener la tentación de hacer en ambos
sería entrar y encontrar las cosas específicamente relacionadas con la
escala de la malla Entonces estas son tres
estas medidas estáticas. Puedo ver aquí que
tenemos el tamaño de malla de escala, y podría simplemente
aumentar esto a algo mucho
más grande por defecto. Puedo ver aquí exactamente qué elemento está
surtiendo efecto, así podemos ver cuáles
acaban de hacerse mucho más grandes. Lo he hecho cuatro veces
más grande de lo que era. Ahora bien, de nuevo,
esto
consume algo de tiempo porque necesito
hacerlo por cada uno de los
diferentes elementos. Entonces entraría en éste,
por ejemplo, pondría esto
en cuatro, cuatro y cuatro. Pero ahora tenemos de inmediato
una explosión mucho más agradable y gruesa para el tipo de estrella
que vamos por Así que cambios realmente simples como este realmente pueden
marcar la diferencia en los emisores y todo
lo que he tenido que hacer es entrar y encontrar el tamaño de malla Entonces, si quisiera probar eso en nuestro enemigo, simplemente volvería a hacer
lo mismo, para que pudiéramos agarrar la escala de malla, establecer esto en cuatro, cuatro y cuatro, para que coincida con el jugador. Y solo estamos haciendo
esto para cada uno de los diferentes emisores para que
todo quede algo uniforme porque están
destinados a representar diferentes elementos
del sistema de explosión Así que compila y guarda
eso, podemos
entrar y jugar y ver
cómo se ve esto. A Creo que eso es mucho mejor. Creo que solo muestra una
buena diferencia entre el
impacto general del proyectil en
comparación con la explosión de las naves. Así que cosas muy
pequeñas como esa. También podrías encontrar los
colores, sobre todo si tienes enemigos de
diferentes colores
a lo que he elegido. Podrías entrar en
la explosión enemiga, encontrar todas las
propiedades de color entre todos los diferentes emisores, ver cuáles son los
responsables qué color y luego
cambiarlos a tu gusto Recuerda, el consejo rápido
es si no estás seguro qué elemento es el que
estás buscando cambiar, solo
podemos desmarcar los diferentes emisores aquí y podemos ver qué es responsable de qué parte.
Para que puedas pasar. Esto solo sería
ese tipo de después del humo, así podemos
apagarlo. El medio es
para el color principal. Entonces si mi mi, mis enemigos
son en realidad verdes. Entonces tal vez tendría más
sentido
tener un color más verde, para
que podamos tener un valor verde, llevar esto
hasta el final. Y luego nos vamos. Tenemos más de una
explosión verde para la noche enemiga. Así que tenemos un buen
tipo de o amarillo comenzando con una explosión
acalorada. Pero entonces estamos demostrando
que esto en realidad
va a bajar a
una prórroga verde, que es el color de la carrocería
de la nave enemiga Entonces, de nuevo, un cambio
muy, muy rápido. Siempre y cuando sepa aproximadamente
lo que está buscando, podemos hacer estos cambios con
bastante rapidez sobre la marcha. Y vea que ese tipo de
confluir muy bien. Así que juega con
este tipo de cosas. Se trata de un tipo de enfoques
que te harán entender los sistemas
mucho más rápidamente. No necesariamente
sabrás exactamente lo que estás buscando a medida
que estás comenzando,
pero creo que, especialmente
con algo como el sistema Niagara, las convenciones de
nomenclatura,
las cosas que estás
buscando y retroalimentación inmediata que
obtienes en
el punto de vista es una manera muy práctica de
aprender esto muy rápidamente solo un error de prueba y
ajustando con diferentes valores Entonces ese es el primer paso para mejorar nuestra retroalimentación
visual. Hace que todo se sienta vivo. Los enemigos siguen apareciendo
de la nada. Después al siguiente tema,
queremos agregar esas animaciones de
desove realmente agradables que se proporcionaron en
el proyecto de ejemplo
25. 24: efectos de audio: Podría haber dicho que
vamos a saltar al Festival de animación,
pero me doy cuenta de que
en realidad estamos pasando por alto la pieza que falta
de nuestro esmalte aquí. Y esto suele ser algo
que se deja demasiado tarde en el desarrollo de
los juegos, y eso es el audio. Queremos empezar a
mirar el uso
de las señales San para aleatorizar una cantidad mínima de archivos de
audio para hacer que las cosas suenen un poco
más variadas También es una de esas cosas
que si estás creando prototipos de tu propio
juego, es muy,
muy fácil pasar por alto y subenfatizar la
importancia del audio Es posible que sientas que tu juego
se siente plano o aburrido. Puedes agregar cosas
como efectos de partículas, sacudidas de
cámara y todas
estas otras cosas, y podría ser
que al proyecto
le falta algún audio que realmente
ayudaría a
darle vida. Entonces nos vamos a centrar
en este festival. Entonces, si entramos en
nuestro sorteo de contenido, vamos a entrar en
la carpeta de audio. He proporcionado algunos archivos de sonido
diferentes. Tenemos uno para la explosión, así que vamos a estar haciendo uso de estos para nuestros aviones
cuando exploten, y tenemos el efecto de disparo, que jugará
cada vez que estemos Probablemente no vamos a ponerle esto al
enemigo, pero de nuevo, puedes retocar y jugar
alrededor de las cosas para ver cómo te gusta que se establezca el
proyecto Creo que si hay demasiadas
cosas disparando a la vez, puede convertirse muy fácilmente en
una sobrecarga auditiva Si quisieras probar los archivos de audio y
ver cómo son el sonido, podemos saltarlo sobre
el botón de reproducción aquí, y obtienes
reproducción inmediata en el editor. Si nos enfocamos en nuestros disparos, antes que nada, ya que
tenemos dos de estos, queremos cambiar
seleccionar ambos, hacer clic
derecho en cualquiera de ellos , y tenemos esta opción aquí
para crear una sola cola Entonces, si elegimos
crear una cola múltiple, esto creará un
archivo, un archivo que para cada archivo de onda que
tenemos aquí abajo. En cambio, podemos tomar
ambos archivos de onda y comprimirlos
en una sola cola. Entonces vamos a hacer clic en
esa. Cambiar el nombre de éste a SC Underscore disparo Se puede ver que es un tipo de activo ligeramente
diferente. Y básicamente, las señales SN son una forma muy sencilla si hacemos
doble clic para abrir Nos permiten trabajar con múltiples archivos de audio sin necesidad de editar el archivo fuente. Así podemos mantener el
disparo uno y 71 exactamente como estaban
cuando son importados, y podemos hacer anulaciones
aquí individualmente a cosas como si
debería bucle, el volumen predeterminado,
y cosas así Una cosa a tener en cuenta
es que puedes ver los nrails lo suficientemente inteligentes Sabe que debido a que
trajimos más de un archivo firmado
diferente, probablemente
quisimos aleatorizar el orden en que se reproducen
estos,
que es, de hecho,
lo que queríamos Después de eso
se hicieron aleatorizaciones, sin embargo, queremos sacar de
aquí, y vamos a buscar algo
llamado modulador O, de hecho, se puede
ver justo aquí abajo. Vamos a enchufar
el resultado de nuestro modulador a la salida. Entonces esto alternará entre
qué sonido reproducir. Va a aleatorizar
uno de esos. Va a lanzar
un modulador para que
podamos ajustar ligeramente el audio Y entonces cualquiera
que sea ese resultado de salida
es lo que se jugará
al usuario final. Con el modulador
aún seleccionado. Se puede ver lo principal
que quería anular aquí es el mínimo
y el máximo pitch. Esto solo va
a ayudar a asegurar que aunque solo
tengamos dos archivos de sonido, no
van a sonar
exactamente igual cuando
los disparemos potencialmente cientos o
por muchas veces seguidas. Les doy a ambos un cambio de tono
bastante grande, así que pondremos 12.5 y
el otro en 1.5. Y nuevamente, estos pueden
ser valores bastante extremos, y si el sonido
está demasiado distorsionado, entonces aquí es donde podemos
regresar y comenzar a refinarlo poco a
poco para que
suene exactamente como queramos Lo mismo con el
volumen, podemos establecer uno a 0.9 y uno a 1.1. Así que tenemos una especie
de desplazamiento similar
al volumen mínimo y máximo para ambos efectos de sonido
cada vez que tocan. Entonces eso estuvo genial.
Pudimos ver que eso definitivamente estaba
surtiendo efecto exactamente como
queríamos con una pequeña advertencia Gotcha común con
el antiguo sistema Q que estamos usando aquí La aleatorización no es
realmente tan aleatoria. Puedes ver que es
simplemente flip flopping entre
las dos opciones Tocará A luego B, luego A,
luego B. Bastante predecible. Entonces, si agarramos nuestra nota aleatoria, una cosa que queremos hacer es
que queremos desmarcar esto aquí, el aleatorizar Algo que la gente
suele pasar por alto. Pero ahora si presionamos play, no necesariamente
necesitamos escucharlos, así que simplemente silenciaré
el volumen rápidamente. Pero solo
revisa dos veces que puedas ver qué cable se está apagando. Y lo que deberíamos ver es que
tuve unos cuatro o
cinco clics ahí, mientras que conseguir la
misma reproducción de audio, que se está acercando mucho más a verdadera aleatorización en lugar ese flip flop entre A y B. Obviamente, también querrías
hacer esto si tuvieras múltiples ondas de sonido encima
de esto en tu single que. Entonces, si tuvieras cinco o seis, no
querrías que fuera uno, dos, tres, cuatro, cinco, uno,
dos, tres, 45, y así sucesivamente. Querrías que escoja
aleatoriamente entre esos cinco o seis efectos de sonido. Así que siempre recuerda
entrar y desmarcar aleatorizar Con eso hecho, queremos hacer una cosa similar
con las explosiones. Entonces voy a hacer clic derecho sobre
la onda de explosión. Vamos a crear una sola cola de
sonido para ésta. A este le llamaremos SC
subrayado Explosión. Obviamente no necesitaremos ninguna aleatorización
entre ésta Solo tenemos el
archivo único, pero aún podemos hacer uso de cosas como lanzar un modulador de nuevo en el medio. Entonces solo voy a conectar otro modulador aquí
de la misma manera y tal vez proporcionar algunas diferencias un poco menos intensas aquí. Entonces tal vez 0.7 a 1.3. Y de nuevo, podemos
volver y refinar si eso es demasiado cambio
de tono. Voy a dejar el volumen mínimo y
máximo como están. Y es solo un tweak realmente
simple que vamos a hacer dentro
de nuestra cola de sonido Si vienes de más
de un fondo de audio, puede
haber otras
terminologías y características
con las que puedas jugar en el lado derecho, y simplemente puedes
arrastrarlas a la gráfica, jugar a la propiedad y jugar a la propiedad y
ajustarlas como mejor te parezca Para esta simple demostración, bueno, me quedaré con esto
como tenemos aquí. Entonces solo voy a
pasar muy rápido y comenzar a cerrar algunas de las
ventanas que no necesito, especialmente los efectos de partículas, así que nos desharemos de esas. Y si empezamos
en la base de juego, ya
estoy aquí, así que
voy a manejar primero el efecto
muerte. Voy a dejar el
comentario aquí, ya que probablemente necesitaremos algunas
cosas más un poco más después. Entonces, entre nuestro sistema de partículas
engendradas y la llamada a la función de destruir
actor, voy a sacar
del pin de ejecución, y voy a buscar
reproducir sonido en la ubicación Entonces esta es una
característica realmente agradable nuevamente dentro de Unreal. Ya hemos construido en audio espacial
predeterminado. Así podemos proporcionar
el punto inicial de donde queremos que se reproduzca este
audio. Entonces podemos tener las cosas un
poco más creíbles
si un avión está siendo destruido al tipo de lado superior
izquierdo de la cámara, entonces vamos a tener un efecto de sonido que
debería sonar un
poco más en el
lado izquierdo de tus auriculares Entonces vamos a usar la función
estándar aquí. Vamos a usar la ubicación de
get act para averiguar dónde fue destruido el
avión explosivo Y luego vamos a usar el menú desplegable de sonido
aquí y elegiremos nuestro SC nuestra señal de sonido que hemos personalizado la explosión de
subrayado Ahora bien, en realidad no necesitamos
promover esto porque, de nuevo, ambos
van a usar los mismos efectos de
sonido de explosión, y ambos tienen su propia aleatorización
y cosas así Ahora, no
lo voy a usar aquí, pero quería
mostrarles las características a las que
sí tenemos acceso, también. Entonces, si usamos el menú
desplegable en este nodo, si no querías
jugar con señales de sonido o simplemente querías
usar el archivo de onda de regla, aún
podemos entrar
y hacer cosas como volumen, multiplicación de
tono Podríamos lanzar algo
así como un flotador aleatorio, de nuevo, así que hemos visto esto
muchas veces o idealmente un flotador aleatorio en
rango, como hemos visto antes. Y eso es muy similar
a lo que hemos configurado en la señal de sonido para
el multiplicador de tono. Pero como tenemos una
cola de sonido agradable y
personalizable con la que trabajar, solo
usaremos eso en lugar de los archivos rurales predeterminados de ondas de
sonido. Hay muchas más cosas en
profundidad en las que podríamos
entrar con cosas como
la configuración de atenuación también Entonces eso es proporcionar el sistema de sonido de
tres D, una especie de caída, un rango en el que el audio
debería hacerse más fuerte y silencioso, dependiendo de dónde sea Para esto, sin embargo,
solo voy a copiar la funcionalidad
que tenemos aquí porque
queremos agregar esto a
nuestra función fire. Por lo que sólo vamos a mover
el comentario sobre. Vamos a
volver aquí y hacer algunas cosas más cuando hagamos nuestros pases finales en los efectos, así que esto sigue siendo relevante. Pero vamos a agarrar
este control de prensa en C. Voy a entrar en
la función de fuego. Y después de que el proyectil haya
sido generado, podemos dejar caer esto aquí Otra vez lo mismo,
queremos la ubicación en que se debe reproducir el
efecto de sonido de fuego. Y vamos a
agarrar nuestro disparo aquí, y esto automáticamente reproducirá un disparo ahora cada vez que
algo Es porque creo que si hay cuatro o cinco enemigos
en la pantalla y todos lo
están disparando
en rápida sucesión, posible que
queramos
bajar su volumen. Entonces creo que lo que voy
a hacer es más que tener funciones de fuego
separadas
en cada clase, nuevo, vamos a hacer uso de la herencia donde podamos. Voy a promover
el modificador de volumen y voy a promover
esto a una variable, y llamaremos a esto desplazamiento de volumen de un
disparo. Entonces podemos por defecto esto
a un valor de uno, que ya era. Entonces vamos a tocar
por defecto el volumen completo de la señal de sonido de
disparo Entonces, por supuesto, si hemos configurado esto para aleatorizar un poco
aquí con el modulador,
el volumen predeterminado podría
ser 0.9 hacia 1.1 Entonces vamos a tomar una anulación sobre esto y tomar eso o multiplicar eso por un total de uno o para los
enemigos, por ejemplo. La razón por la que quiero usar esto es que vamos a golpear compilar y guardar. Voy a entrar en
la clase enemiga. Encontraremos ese valor
aquí a partir de las propiedades. Le daré a esto un desplazamiento de
volumen predeterminado de 0.5. Entonces vamos a
tener el
volumen predeterminado para disparos enemigos. Entonces, aunque empiecen a
apilar un poco, no
deberían volverse completamente insoportables y como he dicho, completamente sobreestimulantes
para Bien, entonces hay una prueba de juego muy
rápida. Descubrí que los disparos
probablemente fueron casi tan fuertes o tal vez más fuertes que
las explosiones Entonces pienso en lo que voy a hacer, vamos a establecer
un volumen mínimo, y esto solo está
potencialmente
basado en los tipos de
signos que encontré. Probablemente
solo se exportaron, no con un buen volumen
normalizado. Entonces tal vez por defecto, en realidad, vamos a llevar
esto a 0.5 a tal vez 0.7 o tal vez 0.4 a 0.7. Y ya
veremos cómo suena esto. Bien, entonces después de una buena
cantidad de ajustes ahí, en realidad
encontré que un
buen valor era 0.1 y 0.2 para un mínimo y un
máximo para el default, y luego vamos a
tomar eso aún más bajo en el enemigo agregando este desplazamiento de
volumen aquí Entonces este no es el fin
del mundo. Como dije. Los activos son perfectamente viables, pero estas son solo cosas
útiles a tener cuenta de las que quizás
te entreguen o podrías encontrar activos de
mercados y cosas así, y algunos pueden haber
sido exportados con un volumen completamente
diferente Entonces es útil saber que tenemos múltiples lugares en los que podemos aplicar diferentes compensaciones de
volumen y
cosas así Un proyecto o un juego
de producción completa. Por eso también es
muy importante
tener algo así como
un menú de configuración con algunos
deslizadores de audio realmente flexibles para que la gente
pueda elegir hacer que sus efectos de sonido sean más
silenciosos o más ruidosos que su música y su voz en
off y cosas así Y por amor a los
oídos de todos, incluido el mío, por favor establezca su volumen
maestro
predeterminado en alrededor del 50%. A nadie le gusta encender el juego
y destruir sus
tímpanos en y destruir sus
tímpanos volumen
100% maestro
cuando tu juego tiene un nivel de
volumen completamente diferente a cualquier otra cosa que el sistema
pueda haber estado jugando Así que el audio realmente puede ser bastante
importante y puede causar una
primera impresión realmente buena o mala en tu juego,
dependiendo de cómo lo uses. Pero nuevamente, esto es
algo más con lo que
vas a querer retocar
y jugar Escucha lo que piensas los disparos en tu sistema
versus la explosión Mira dónde podrías querer
cambiar los modificadores de volumen, jugar con las
diferentes opciones que
te he mostrado para intentar tu juego suene bien mezclado y lo más interesante de
escuchar posible, aunque solo tengamos unos pocos
archivos de audio diferentes para jugar También puedes ir a
diferentes sitios web, HIO, freesound y cosas
así para descargar algunos nuevos efectos de sonido
y ver qué puedes agregar al proyecto para
empezar realmente a hacerlo tuyo Lo principal que
estás buscando es simplemente jugar el juego
por unos minutos. ¿Algo empieza
a ponerse molesto después de esa marca del 32 al minuto Y si es así, ¿puedes
arreglarlo
reduciendo el
volumen general en la cola de sonido? O si es necesario, como ya he dicho, tal vez
queramos incluso
entrar y quitarle el disparo al enemigo porque va a
estar sucediendo muy a menudo Ninguna de estas son reglas
específicas claras que
tenemos que seguir. Al igual que con muchas otras
cosas, solo va a ser mucho
ensayo y error para ver qué funciona y qué
impacta mejor tu resultado final. Con la
retroalimentación de audio completa, el juego ahora tiene
presencia, proporcionando retroalimentación
visual y auditiva A continuación, pasaremos a
las animaciones de spawn, que es solo un extra
opcional además de la llamarada visual que ya
comenzamos a
agregar a nuestro proyecto
26. 25 - SpawnAnimations: La capa de pulido final, vamos
a dar a nuestros barcos una gran introducción. Haremos que tanto el jugador
como las naves enemigas se deslicen y giren en posición en lugar de simplemente aparecer
en existencia Una vez más, una animación en la clase base
que funcionará para todos los planos con los que
queremos trabajar. Entonces, por esa razón,
vamos a ir
directamente a nuestro cajón de
contenido, carpeta de
planos,
núcleo, y
encontraremos la base del
plano de subrayado BP Queremos navegar de nuevo
a nuestro gráfico de eventos principales, y junto a nuestro inicio de juego, vamos a hacer clic derecho
y vamos a buscar una función útil aquí
llamada Agregar línea de tiempo. Entonces es esta opción
en la parte inferior. Podemos darle un nombre a esto.
Es una especie de función que tiene su propia gráfica incorporada. Veremos eso
en un poquito, pero podemos dar estos nombres. Entonces llamaremos a este
anime, como en animar en. Como con cualquier otra cosa,
estos sólo se
activarán cuando una
ejecución les llegue. Vamos a sacar de
nuestro pinhe de ejecución y queremos enchufar esto
en juego desde el principio Entonces esta va a
ser una curva gráfica que podamos animar a través, y solo queremos asegurarnos de
que siempre comience a jugar desde el fotograma cero en la
curva hasta el final Tenemos otras opciones como
jugar desde cierto punto,
detener la animación, jugar
al revés o lo que sea. Solo queremos jugar esencialmente desde el fotograma cero hasta el final. forma en que esto funciona es
como una actualización temporal, así que muy útil si no necesitas algo para animar constante Esto disparará cada
fotograma mientras se reproduzca la línea de tiempo
antes de que llegue a su fin. Y entonces
mientras eso esté disparando, llamará al pin de
actualización justo aquí. Y luego una vez que haya
terminado la animación, llamará al pin terminado. Entonces sabemos si y cuándo todavía
se está reproduciendo, y también sabemos cuándo se llega al final
de la animación. Todo esto va
a ser muy útil. Entonces, si hacemos doble clic en
este nodo amarillo aquí, y esto es una cosa para
empezar a notar es que muchos de los nodos con los que hemos estado trabajando tienen
diferentes colores Estas azules son las
funciones que estamos creando, así que siempre ves que una función
se denota con azul Cualquier evento personalizado o un evento en la gráfica como este es
esencialmente una función todavía, pero estos se denotan con rojo Tenemos cosas como
las variables verdes, y ahora tenemos una función
basada en el tiempo ligeramente personalizada aquí, nuestra línea de tiempo de animación,
que son amarillas. Cuando los vemos con bastante frecuencia, podemos hacer doble clic en estos y tendremos una
nueva característica aquí. Así que haz doble clic en ese
nodo, y estaremos dentro de la línea de tiempo. Hay algunas cosas
que queremos hacer. En primer lugar, necesitamos
una pista para trabajar con una curva de animación
para comenzar a crear. Entonces, si presionamos la pista
más aquí, tenemos algunas opciones diferentes, podemos crear una curva flotante,
una curva vectorial, una
pista de eventos o
curvas de color, esencialmente. Solo queremos un simple cero a uno realmente
agradable, esencialmente un
valor normalizado que podamos rastrear. Así que aquí vamos a crear
una pista de flotación. Y algo que
es realmente importante, podemos hacer clic derecho y arrastrar para movernos por el medio
del mouse hasta Zoom innit, como muchas de las otras
navegaciones dentro de Pero una
cosa realmente importante antes de comenzar a agregar cualquier fotograma clave
o pines aquí, queremos establecer la
duración de nuestra animación Si empezamos a agregar pines ahora, puedes ver que vamos
de un marco
de tiempo de cero a 5 segundos. Así que vamos a tomar esta longitud
hasta una, y esto solo significa que
estamos
trabajando inmediatamente con una línea de tiempo de curva, que es la longitud que
queremos que sea. Ahora bien, la razón por la que hago
esto, vamos a ver esto un poco más cuando
encarnemos las cosas, pero no estamos pensando en
esto como un momento. No vamos a hacer esto
a lo largo de 1 segundo. Esencialmente podemos pensar
en esto como un porcentaje. Esto sería 0%
de nuestra animación, y esto sería 100%
de nuestra animación. Te muestro práctico
truco que
no veo muy a menudo
un poquito después. Y esta es la forma en que realmente
podemos adaptar esto entonces para que sea una animación de cinco
segundos, una animación de diez segundos, la animación de medio segundo,
lo que quisiéramos que fuera. Siempre y cuando hayamos normalizado esto a un rango de cero a uno, entonces podremos tratarlo
más como un porcentaje. Ahora bien, si acercamos
un poco aquí, ahora
hemos hecho la curva
un poco más pequeña, podemos mantener el desplazamiento a la izquierda y el
clic izquierdo y vamos a crear
estos fotogramas clave aquí Entonces, si has trabajado con algún
otro software de animación, estos te van a ser
bastante familiares. Este va a ser nuestro
tiempo que esto suceda y la fuerza o el valor en ese
momento. Si has estado
dando click al azar como yo, en realidad solo
necesitamos
dos puntos aquí. Así que voy a agarrar arrastre
seleccione algunos de estos puntos,
estos fotogramas clave, y
voy a deshacerme de estos Primer fotograma clave, voy
a establecer esto en un tiempo de cero y un valor de cero Entonces en este punto, exactamente ninguna de las animaciones ha sucedido. Y luego para el
segundo fotograma clave, solo
voy a
arrastrar seleccione este, y configuraré esto en un tiempo
de uno y un valor de uno Así que este es nuestro 100% de la animación
ahora está 100% completa. Entonces puedes empezar a ver cómo
estamos viendo esto como un porcentaje
más que como un valor específico. Otra cosa que
queremos hacer es que queremos que esto se vea bien y
suave de inmediato Si tuviéramos que animar a lo largo de
esta pista, por el momento, solo
sería una animación
muy plana, consistente y algo aburrida Entonces, si arrastramos seleccionamos
ambos, clic
derecho en cualquiera de los fotogramas clave y simplemente
configuramos esto en Auto, esto nos va a dar una agradable suave flexibilización
de entrada y Ahora puedes jugar
con estos si lo deseas. Puedes tenerlo exagerado
cuando entra por primera vez, o puedes tenerlo muy
lento cuando entra por primera vez Y ese es uno de los beneficios
realmente geniales de trabajar con
estos fotogramas clave como este es que podemos
jugar con la animación para
hacerla más estilizada,
más caricaturesca, lo que sea que
estés buscando BDefelt, aunque lo voy a mantener
así. Lo último es
esta pista cero o nueva pista cero es algo
que también podemos retocar Entonces voy a hacer click en esto. Presionaré F dos para cambiar el nombre de esto, y solo le daré a esto
el nombre de Alpha. Porque cuando empezamos
realmente a animar nuestros aviones para volar, esto será esencialmente el tiempo extra
Alfa que estamos
rastreando en lugar del valor rotacional
específico Y eso es una cosa
es que en muchos ejemplos, trabajando
con líneas
de tiempo, posible que
veas a la gente
animando directamente la ubicación o rotación de valores
vectoriales
reales una cantidad específica de tiempo, y ojalá
veas al final de esto cómo eso puede ser bastante
inflexible, porque, de
nuevo, si animar algo que toma exactamente ejemplos, trabajando
con líneas
de tiempo, es posible que
veas a la gente
animando directamente la ubicación
o rotación de valores
vectoriales
reales en una cantidad específica de tiempo,
y ojalá
veas al final de
esto cómo eso puede ser bastante
inflexible, porque, de
nuevo, si animar algo
que toma exactamente 7 segundos, y tú
he hecho eso en todos los valores XY y Z de la ubicación
o rotación, y luego decides
que en realidad está rotando demasiado, y necesita tomar la
mitad de la cantidad de tiempo. Tendrías que entrar,
volver a cambiar la longitud de la pista, mover todos los fotogramas
clave, y puede volverse un poco
complicado y llevar mucho tiempo ¿Dónde está esto?
Podemos establecer esto una vez, y ahora tenemos el control total de la animación en nuestro código
real en su lugar. Eso es. Eso está más
o menos hecho. Así que tenemos nuestra curva lista para proporcionar un
valor Alfa a lo largo del tiempo. Entonces, si golpeamos compilar
y luego
volveremos a nuestro
gráfico de eventos aquí arriba, todo lo que ha hecho es
simplemente dejarte caer en una pestaña dentro de la línea de
tiempo de animación que hemos creado. Entonces vamos a volver
al gráfico de eventos. Entonces, para establecer realmente nuestra animación primero que nada, desde
nuestro pin de actualización, recuerda la que
está en constante ejecución ahora hasta que esta
animación haya terminado, queremos llamar a la función set actor Location desde aquí. Esto va a ser el
resultado de un lp, de nuevo, así que solo vamos a usar la función larping
que hemos visto antes Entonces nuestra interpolación lineal
entre dos vectores, no la interp dos
ni nada elegante, solo punto A a punto
B con un alfa Así que en realidad puedes ver la
razón por la que hemos llamado esto Alpha es que podemos
enchufarlos directamente y ya tenemos
parte de la respuesta aquí solo basada en convenciones de
nomenclatura Entonces entonces solo necesitamos
calcular o averiguar qué punto A será y
cuál será el punto B. Para desglosar esto como concepto, el punto A simplemente va a
ser el lugar de desove Entonces, donde sea que
partimos de cuando engendremos
en, será el punto A. Entonces queremos llegar
a cierto número de unidades por delante de
ese punto de desove, que será nuestro punto B, algo que tropieza
bastante a la gente cuando
trabaja con
animaciones al acecho y es
confuso porque
parece que es un animaciones al acecho y es
confuso porque poco funcionando Pero cuando lo piensas,
lo que estoy a punto de mostrarte
en realidad estaría confundiendo un poco
la animación. Entonces, lo que algunas personas
harían cuando están trabajando por
primera vez con interpolaciones
lineales es
que sabemos que el punto A es nuestro punto de
partida Así podemos hacer clic derecho y podemos buscar Obtener ubicación del actor. Esto para mucha gente
podría tener sentido que vamos a ir de nuestro punto de
inicio a un punto final. Y podríamos decir que el
punto final, por ejemplo, sería simplemente
donde estamos ahora más una unidad vectorial en
cierta dirección. Entonces, si tomamos donde estamos en el punto de partida
y luego
proyectamos, digamos, 300 unidades por delante, ahí es donde
queremos terminar. Ese
sería esencialmente nuestro punto final. Ahora bien, esto no funcionaría de todos modos, pero solo para poner muy rápidamente algún código para mostrar eso,
podríamos decir algo así como, sabemos que X está
adelante, así podríamos obtener x ubicación más 300
unidades adelante en la X. Eso parece como si
pudiera ser nuestro principio y fin. Y quería cubrir
esto y por qué no vamos estar usando esto
precisamente porque lo
veo en tantos proyectos
estudiantiles y nuevos proyectos de desarrollo, porque como mencioné,
sí tiene sentido. Tenemos nuestro punto de partida, y tenemos nuestro punto final
basado en eso. Pero lo que la gente no está
considerando cuando está haciendo esto es que esto no es
sólo disparar una vez. Creo que ahí es donde la
gente se tropieza un poco. Yo imaginan esto solo siendo despedido una vez y este
valor permaneciendo igual. Entonces, si empezamos en 000
y sumamos 300 a eso, esperaríamos tener
30000 como punto final Pero lo que realmente está sucediendo es que cada fotograma a este
se le llama, y esto se está volviendo a verificar Entonces si empezamos en
cero, cero, cero, y luego movemos algunas unidades,
digamos que hemos movido cinco unidades. En el siguiente fotograma, cuando esto se enfríe, ahora estamos en 500. Entonces eso significa que el punto final
va a ser 30500 en su lugar. Entonces ambos valores se
mueven continuamente. Sólo vamos a
estar animando para ese 1 segundo o por mucho tiempo que
sea de todos modos va a ser Entonces eso significa que
llegaremos a su fin, así que parece que las
animaciones suceden, pero siempre lo hará y se verá un
poco apagada, y tal vez incluso un
poco impredecible porque estos dos valores
se
vuelven a verificar y
actualizar constantemente y aplicando un resultado lp diferente al final del cálculo,
si eso tiene sentido Fue solo para presentar por qué
vamos a necesitar
darnos algo de espacio, hacer
algo de espacio por aquí. Y lo que queremos hacer es
asegurarnos de que estos valores estén
almacenados e inmutables Entonces no es
algo difícil, pero solo quería destacar que esto
sucede con relativa frecuencia, y puedo ver, creo,
por qué la gente haría eso. Y es simplemente
algo a tener cada vez que vayas a intentar crear tu propia animación o una personalización
de esto más adelante. Solo recuerda que un bucle
necesita un inicio constante y un objetivo constante para
animarse suavemente entre ellos. Entonces lo que vamos a hacer
en cambio es que tomaremos esto, así que voy a cortar Control X y pegar la ubicación del
actor get. Promocionaremos esto
a una variable, y llamaremos a esta ubicación
de inicio. Tan agradable y claro, engancha esto, y luego vamos
a hacer algo muy similar por aquí. Y como he mencionado,
esto no funcionaría todos modos porque
solo estamos agregando una unidad. En realidad no estamos
tomando en cuenta la dirección que está mirando
el avión, así que tenemos que hacer un
poco más que esto de todos modos. Pero aunque
hiciéramos el proceso completo, esto como estaba todavía no
funcionaría. Así que sólo vamos a
mover esto, agarrar esto, así que corta y pega esto por aquí. Todavía podemos hacer uso
de un montón de esto. Ahora bien, lo primero
es recordar que los enemigos también quieren
usar esto, y van a estar
volteando cuando engendren Entonces no queremos que se
animen en la pantalla como el jugador. Queremos que
se
animen en base a la dirección
que están enfrentando. Entonces lo que vamos a hacer es que
vamos a buscar G actor forward vector. Por lo que esto obtendrá
la dirección en
la que se está rotando
o enfrentando actualmente el actor. Recuerda esa flecha que
aplicamos al proyectil, esencialmente
estaré comprobando qué dirección está orientada esa
flecha Entonces queremos multiplicar
esto por un valor. Entonces vamos a tomar
el vector forward, que es una dirección,
no un valor, así que esto o bien
será algo así como 11 y uno o 100 si está mirando hacia adelante o menos 100 si está mirando
hacia atrás, por ejemplo. Vamos a multiplicar
la dirección, no la posición real del vector, por
lo que
podemos multiplicar esto. Vamos a multiplicar
esto por un flotador, así que vamos a
hacer click derecho sobre el pin aquí, convertirlo en un
flotador, y
todavía podemos tomar ese valor de 300
unidades aquí. Por lo que queremos mover 300 unidades en la dirección hacia adelante. Entonces
podemos hacer uso de esto. Entonces queremos tomar
este valor y agregaremos esto a
otro vector. Y de hecho, nos
desharemos de éste. Así que estas notas ya no
serán necesarias, solo para mantener las cosas
bonitas
y ordenadas, y las
arreglaremos un poco. Y lo que queremos llevar
es a donde empezamos, queremos nuestro XY y Z
de nuestra posición de inicio. Más 300 unidades en la dirección
hacia adelante. Entonces multiplicando nuestro avance para
obtener ya sea un negativo o un positivo de vuelta sobre si estamos mirando hacia adelante o
hacia atrás y la X, y vamos a tomar esto
y dividir algunos valores aquí Entonces, lo primero que hace que
esto sea un poco más fácil leer es que voy a promocionar
este pin a una variable, y nombraremos esta
ubicación objetivo. Podemos alt y
click izquierdo para soltar esto hacia abajo. Dividiremos el pin de
estructura aquí. Y ahora tenemos todos
los nodos que necesitamos. Podemos
ordenar esto un poco, en realidad
queremos que nuestro primer
pin sea nuestro lugar de inicio. Así que de nuevo, solo preferencia
personal, voy a controlar y arrastrar la ubicación de inicio
y reemplazar esta. Así podemos tomar donde
empezamos más un desplazamiento en la dirección que estamos buscando por el número X de unidades. Eso
nos va a mover 300 unidades en la X es lo que estamos
viendo aquí porque X es cuatro. Entonces, si pudiéramos obtener el vector
get actor up, y si enchufamos
esto en su lugar, esto aplicaría un desplazamiento en el eje z puramente porque
Z está arriba dentro de irreal X está hacia adelante, Y está de lado. Así que podemos obtener diferentes posiciones
vectoriales con algunas
funciones incorporadas aquí. Sólo queremos considerar seguir
adelante. Y entonces no podemos
usar el valor completo aquí porque queremos mantener nuestra Y y Z consistentes independientemente de dónde estemos rotando o moviéndonos aquí. Entonces voy a agarrar de nuevo la ubicación de
inicio, duplicar esto aquí abajo,
dividir el pin de estructura. Y podemos enchufar la Y y
la z a estos valores aquí, razón por la
que dividí
esto hace un momento. Y luego sea cual sea este valor, así que el cálculo de
hasta dónde queremos avanzar en nuestra dirección de avance local, también
vamos a dividir esta
estructura, y este será nuestro valor
X que queramos. Así que recuerda, esto sólo está
calculando la X de todos modos, así podemos tomar ese valor X. Esa será la cantidad de
unidades hacia las que queremos volar en el valor
X o hacia adelante. Y esa será nuestra ubicación
objetivo. Entonces vamos a enchufar estos. Tal vez necesitemos ordenar
las cosas y
mover las cosas un poco,
pero eso está perfectamente bien. Podemos simplemente mover
esto hacia abajo y
volver y
aclarar esto un poco más tarde Lo principal es que ahora podemos
saltar de nuevo a nuestro bucle. Y nuevamente, esto está haciendo
las cosas bonitas y claras ahora. Vamos a darle a esta
nuestra ubicación de inicio y nuestra ubicación objetivo como los argumentos
A y B. Entonces, si entramos,
probablemente podríamos probar esto solo para asegurarnos de que definitivamente algo está sucediendo aquí. Y podemos ver que el avión
del jugador
definitivamente se desliza
hacia adelante un
poco ahí, y también lo
es el avión enemigo. Entonces se desliza hacia adentro y luego
se mueve de lado a lado. Entonces podemos ver que la animación
inicial está funcionando y lo
mismo para el jugador, lo que sí significa que
probablemente queramos agarrar
nuestro inicio de jugador e iniciarlo un
poco más atrás. De hecho, sólo
podemos venir aquí. Algo más de lo que
quizás no estés al tanto. Y esto es bastante
útil es que podemos agarrar nuestra ubicación porque sabemos que aquí es donde
queremos terminar en este
punto de la pantalla, y podemos escribir aquí -300 Entonces, si tecleamos -300, esto realmente funciona
como una ecuación matemática, así que eso nos da -190 -300, y obtenemos exactamente menos 490, que será nuestro punto de partida, y luego volaremos y terminaremos exactamente
donde Entonces eso realmente se ve un
poco más interesante. Creo que eso se ve bastante genial. Entonces ese es definitivamente
un buen comienzo. Y ya pueden ver,
ojalá como esta matemática esté
uniendo y funcionando. Y nuevamente, hemos hecho
esta obra al tomar en el
vector delantero del actor. Entonces, la forma en que se ha
rotado y solo para recapitular por qué eso es relevante es porque cuando engendramos
en los enemigos, los estamos rotando
180 grados para coincidan con la dirección de apuntado
de nuestra clase de engendradores aquí Entonces están avanzando en
relación con si apuntando, que significa que todo se está
animando de la manera correcta Entonces esa es la primera
parte del rompecabezas. La segunda parte hará
que esto sea aún más interesante al proporcionar un desplazamiento de
rotación también. Entonces, después de la ubicación de nuestro actor set, queremos efectuar solo
el elemento visual de la rotación porque no
queremos meterse con el colisionador de
esferas y cambiar potencialmente la forma en
que se enfrentan los actores Así que sólo vamos
a hacer de esto un
cambio visual en lugar de una posición o cambio
real. Entonces para hacer esto,
a menudo obtenemos cosas como, usaremos la
malla estática en su lugar. Arrastraremos esto al suelo, sacaremos de esto
aquí, y vamos a buscar la rotación mundial establecida. Algo tan similar, pero ahora
solo estamos afectando a la malla en su lugar. Y esto es mucho mejor
porque no estamos haciendo colisiones ni nada importante con la malla de todos modos Esto es aquí puramente
para hacer cosas visuales, y esto es un cambio visual. Entonces vamos a enchufar esto para que
esto se llamenmediadamente, y vamos a hacer Vamos a tomar
nuestro Alfa y vamos a hacer un bucle para el rotador Así que vamos a tirar de aquí
y buscar bucle de nuevo, p rotador, y otra vez, obtener lo mismo, A
y B con un Alfa Esto es completamente opcional.
Podrías promover el Alfa a una variable solo para
su uso dentro de esta función. Algo más que
quiero presentar, aunque es que
podríamos simplemente hacer esto. He hecho doble clic en el cable. Y otra vez, sólo para mantener
las cosas un poco más ordenadas, sólo
voy a tapar a
los Alfas de esta manera Porque estas son
las únicas dos veces que lo vamos a usar aquí, creo que tal vez haciendo
una variable tract solo para este evento de incendio una
vez, tal vez un poco exagerado Así que sólo voy a introducir
el uso de nodos reroot. Esto todavía mantiene
esto algo ordenado y fácil de
visualizar y trabajar con él. Y luego para el A&B, vamos a hacer algo muy
similar por aquí otra vez, pero vamos a obtener
los valores de rotación Entonces tal vez quieras comenzar a ordenar algunas de
las cosas aquí Aquí es donde como
he mencionado las secuencias pueden ser realmente buenas. Así que corte muy rápido aquí. Queremos comenzar a
rastrear lo que estamos haciendo
para inicializar valores,
esencialmente, cuando estamos estableciendo y fracking valores
en Eso normalmente se conoce
como inicialización. Y creo que podría
separarlo de nuestra animación de línea de
tiempo real. Tan agradable y sencillo, de nuevo, estos factores ref
realmente no tardan mucho. Si sacamos
del pin de ejecución aquí y buscamos una secuencia, eso automáticamente
conectará eso para. Así que en realidad no estamos
cambiando nada. Nuevamente, esto es simplemente organizar el orden en el
que se manejan las cosas. Simplemente desengancharé estos
nodos justo aquí, y luego moveré
la animación cenar Y lo que
haremos es asegurarnos de
tener todas las variables
listas antes que nada, y luego una vez que hayamos rastreado
todas las variables que vamos a usar
en el entonces, entonces llamaremos a
nuestra animación para ser reproducida. Así que de nuevo, realmente todo
lo que está haciendo es simplemente mantener las cosas
un poco más ordenadas, más fáciles de leer y más
fáciles de trabajar con ellas Entonces eso significa que ahora podemos comenzar a mover algunos de estos
porque
queremos primero todas estas verificaciones
basadas en la ubicación. Entonces eso está consiguiendo nuestra posición de
inicio todavía. Y luego después de esto,
vamos a querer obtener nuestra rotación de inicio, también. Entonces a partir de aquí, podemos buscar rotación del mundo
G en la malla estática, de la misma
manera que lo hemos hecho anteriormente. Arrastraré nuestra malla estática
usaremos la rotación G world. Y como hicimos
con las ubicaciones, solo
vamos a tomar este valor y promoverlo
a una variable. Y esto es
exactamente por la misma razón. Cuando estamos usando esto
en una animación, no
queremos que este valor
cambie con el tiempo. Sin embargo, comenzamos nuestra rotación cuando
estamos engendrados al mundo Ese es nuestro punto de partida,
y vamos a tener una compensación permanente contra eso como nuestro punto
objetivo permanente, también. Ahora bien, esto lo podemos hacer un
poco más fácilmente. No necesitamos un
objetivo real para el B. Puedes promover una variable
a target si quisieras, pero esto es un
poco más sencillo. Entonces, para nuestra rotación de inicio, solo
vamos a dejar caer la rotación de
inicio sobre A, así que ahí es de donde estamos rotando
. Y luego nuestro objetivo. Entonces B, podemos simplemente dividir el pasador de estructura
aquí porque lo
único que
queremos dar cuenta es que estamos haciendo una rotación de 720
grados de balanceo. Al menos eso es lo que
hicieron en el proyecto de ejemplo. Y nuevamente, solo estamos recreando
eso de una manera un poco
más ordenada. Entonces lo que podríamos hacer
es que podamos arrastrar en nuestra rotación de inicio aquí,
dividir el pin de estructura. Sabemos que queremos que la Y
y la z permanezcan igual. No queremos agregar ninguna rotación
hacia arriba o de arriba hacia abajo. No estamos rotando
alrededor de nosotros mismos. Sabemos que estamos afirmando que
la malla estática siempre está comenzando con una rotación de cero porque
no hemos cambiado eso. E incluso con los
enemigos, estamos rotando a todo su actor en
lugar de su
malla estática para empezar. Entonces eso significa que
podemos de manera muy segura simplemente agregar una rotación de 720 grados a la X, que está rodando alrededor de sí misma. Recuerda lo que estamos haciendo
para que ruede de esa manera
alrededor de sí mismo. Estamos haciendo algo muy
parecido aquí. Entonces, si golpeamos compilar y seguro, podemos probar esto, y
nuevamente, esto debería funcionar. Así que agradable, fácil. Se puede ver que está
funcionando perfectamente bien. Entonces eso es lo que queríamos
ahí, una rotación de 720 grados o dos veces
alrededor de sí misma. Si quisieras que
solo fuera un solo 360, así que roten un
poco más despacio, definitivamente
podemos volver
a bajar eso, así que solo será un rollo adentro, o podrías ir un
poco salvaje, tal vez conseguir que haga cinco rotaciones
diferentes de 360 grados, y va a girar
bastantes veces aquí Para que puedas divertirte. Puedes jugar con
eso exactamente como quieras. Como dije, pienso desde
el proyecto de referencia, el que estamos
tratando de recrear, creo que eso fue solo un rollo de 720 grados
que hicieron ahí Entonces así es como podemos aplicar eso. Agradable y sencillo. Realmente
no necesitamos un objetivo específico porque es solo la rotación inicial con un desplazamiento de 720 grados para
que ese giro sea dos veces. Esto también une una gran cosa que nos hemos estado perdiendo
desde hace mucho tiempo, pesar de que hemos tenido el
código listo en nuestro proyecto. Y es que el jugador y los enemigos
en realidad no deberían estar moviéndose de lado a lado hasta que hayan hecho su animación
sporn Nuevamente, esto es sólo por la paridad
con el proyecto de ejemplo. Si lo juegas a partir de
los ejemplos de contenido, verás que en realidad
no tienes permitido controlar y mover los barcos hasta que hayan
terminado esta animación de introducción Así que en realidad podemos
hacer uso de eso. Ya tenemos nuestro
movimiento habilitado. Eso siempre se ha estado
comprobando, así que simplemente no hemos estado
haciendo nada con él. Así que ahora podemos tomar esto
de nuestra clase base. Podemos establecer esto
por defecto en false, así que no vamos a permitir
el movimiento para empezar. Entonces, si entramos y presionamos play, ahora
estamos completamente
atascados, y también lo está el enemigo, que es
algo así como lo que queríamos. Y aquí es donde
era importante introducirte el sistema de animación. Porque recuerden, dije que
esto nos está contando toda
la información
mientras se llama aquí a las animaciones que
siguen sucediendo. Y luego en
cuanto
terminaron las animaciones , se está llamando a esto. Así que ahora podemos tirar
de aquí o
simplemente podríamos arrastrar en el
movimiento B habilitado. Eso nos daría
un setter justo aquí, y podríamos establecer esto para que sea cierto solo cuando se haga la intra
animación Entonces ya podemos entrar y
podemos probar, podemos jugar. No vamos a
poder movernos hasta que
termine esa animación. Así que de nuevo, completamente opcional, pero solo tratando de acercar esto a la paridad lo
más cercana posible con el proyecto
Example Es una característica que implementaron, así que pensé en
cubrir eso aquí. Eso es prácticamente todo, sin embargo.
Técnicamente está funcionando. Como con cualquier cosa, quería bucear un poco
más profundo contigo. Esta es definitivamente una opción del 100%, pero me parece que esto es
algo
realmente, muy poderoso de saber sobre las líneas de tiempo y una forma en
que podemos manipular velocidad de
reproducción de nuestra animación sin saltar
al gráfico de eventos Ahora una cosa que
creo que sí quiero hacer, solo una última cosa para ajustar es que voy
a agarrar el nodo aquí, y voy a darle a
eso un poco más de un movimiento exagerado hacia Va a entrar una especie
de velocidad y luego disminuir a través de
esa animación. Entonces esto es puramente visual, pero esto te da una buena cantidad de libertad sobre lo suaves o nítidas que son algunas de
las animaciones. Entonces no quiero que se sobrecargue. Si tuviéramos una curva como esta, en
realidad pasará
más allá del punto objetivo, que estaría
por aquí. Entonces los puntos objetivo aquí, pasaría por
ese punto objetivo, y luego se animaría de
nuevo a su punto objetivo Entonces eso se vería un poco raro. Echemos un
vistazo rápido. Va a mejorar en realidad si le pego a Simular. Se puede ver que el enemigo estaba mucho más
allá de su punto objetivo
y necesitaba animarse hacia atrás. Así que ten cuidado de que no
hagas nada de eso, pero yo podría hacerlo un
poco más agudo, así entramos un
poco más rápido Un poco difícil de
ver porque hay
ese tiempo de carga, pero eso probablemente esté
perfectamente bien. Ahora lo que
quería introducir, sin embargo, es, como he mencionado, una cosa que veo que
hacen
muchos desarrolladores es que podrían
probar esto y pensar,
Oh, en realidad, 1
segundo es demasiado rápido. Quiero que esta animación
tome 3 segundos. Entonces necesitas volver a
subir, ajustar tu longitud,
agarrar tus fotogramas clave, mover tus fotogramas clave a través,
jugar de nuevo con las curvas Se puede ver cómo esto se
va a poner bastante complicado, si hay que seguir
yendo y viniendo Entonces no vamos a hacer eso. Si solo estabas
siguiendo a lo largo entonces, presiona control eso varias veces, y volveremos a obtener la longitud
de la curva , así que la
longitud completa vuelve a una. Lo que podemos hacer
en cambio, y este es ese truco que creo que
es realmente poderoso con líneas de tiempo es que podemos
volver aquí arriba y tal vez justo después de que estemos estableciendo
la ubicación y la rotación Podemos tomar nuestra información de
línea realidad
se
convierte en un componente. Entonces, si desplegamos este componente en la sección de
variables, podemos agarrar nuestro Anim en detalles de la
línea de tiempo y
dejarlo caer aquí Entonces obtendremos la
información para Anim en. A partir de aquí, podemos
tirar y podemos encontrar algo llamado set play rate. Entonces podemos ver que este
es el playrate qué tan rápido se está reproduciendo esta
línea Y entonces si enchufamos eso
aquí, ahora tenemos control
total porque sabemos
que hemos normalizado esto, así que hemos hecho esto 0-1 segundos. Si hacemos la
tasa de juego, digamos que trabajaremos con
números redondos simples. Diremos dos. Esto ahora está jugando el
doble de rápido, así que va a
tomar medio segundo, porque si está
jugando un default de 1 segundo, esa es su duración. Si está jugando el doble de
rápido, obviamente va a jugar la mitad
de tiempo Por lo que toda esta
animación se
hará ahora dentro de medio segundo. Entonces nosotros básicamente debido a la carga,
ni siquiera vemos que eso suceda. Tendría que simular. Y si, es casi
imposible de ver. Pero si pusiéramos esto
en algo así como 0.5, esto ahora va a
tomar el doble de tiempo, así que va a tomar 2 segundos. Así que ahora tenemos una animación agradable, larga y
suave, 2
segundos para que lleguen. Entonces ahora tenemos con algunas matemáticas
realmente básicas, ahora
tenemos el control total
sobre cuánto tiempo lleva esto Podemos bajar esto a
algo muy, muy lento, 0.1 sigue haciendo
la misma curva. Sigue haciendo
la misma animación, pero ahora está tomando la cantidad
extra de tiempo en
función de lo que hagas
a la tasa de reproducción aquí. Ojalá se pueda ver el valor en eso,
como ya he mencionado. Simplemente significa que nunca
necesitamos
volver a nuestra línea de tiempo. No necesitamos
volver a ajustar la curva porque hemos
normalizado esto para organizarlo Y si quisiéramos aumentar o disminuir el tiempo de reproducción, entonces podemos simplemente agarrar
este valor por aquí. Y creo que lo que
podría hacer, creo que 1 segundo probablemente fue
un poco demasiado rápido, así que podría establecer esto en
algo así como 0.75. Podemos golpear compilar y
guardar, ir y verificar dos veces. Creo que se ve
bastante bien y suave, así que estoy contento con eso. Pero de nuevo, definitivamente puedes jugar, retocar los valores Y ese es
todo el objetivo de estos temas ya que no
te estoy dando algún resultado
específico predefinido al que apuntar. Estoy tratando de mostrarte
todas las diferentes formas que puedes exponer
y extrapolar algunos de los valores y
variables con las que estamos trabajando y realmente
hacer tuyo el proyecto Entonces, si quieres que sean realmente rápidos y roten tres veces, tienes un
control total sobre eso con las variables de aquí abajo Tienes al
dramaturgo. Y nuevamente, probablemente
sea un
buen momento para empezar a considerar la limpieza
de tu proyecto, también. Ahora tenemos muchas variables. Por lo que tal vez queramos empezar a
poner estos en categorías. Tenemos algunos números mágicos, así que también podríamos empezar a promocionar cosas como
esta a una variable. Podríamos promover esta a
otra variable, llamarla algo así como
intro role degrees o algo así.
Tratando de dejarlo algo claro. Es la animación de introducción y no específicamente la
rotación que queremos terminar, sino el número de
grados que está rodando Y luego por aquí, podríamos tener la tasa de reproducción de
animación, así que promocionaremos esto
a variable también. Entonces esto es agradable porque
lo principal, como sigo mencionando
con variables, aunque no estemos haciendo nada
específicamente con ellas, esto es genial porque
no necesitamos sumergirnos en nuestro código. Siempre queremos evitar
tener que entrar y
sumergirnos en
piezas codificadas de nuestra lógica. En cambio, si alguna vez
quisiéramos probar algo rápido, podríamos simplemente agarrar
la base del avión ahora. Podemos acertar a compilar,
asegurarnos de que haya sido actualizado. Podemos agarrar todas las variables y simplemente encontrar aquí
que podríamos ajustar la tasa de juego de cualquier manera
y cualquiera de los valores con los que quisiéramos
ver rápidamente algunos cambios Como mencioné, lo mismo con C plus plus, y
sucede en Azul. Terminas con
muchas variables, así que quizás quieras
empezar a poner las cosas en categorías lógicas agradables
o algo así, pero eso sería
algo que debes hacer entre temas. Otra cosa para ti entre temas,
una pequeña pieza de experimentación
aquí porque
en realidad
solo acabamos de echar un
breve vistazo a las animaciones. Definitivamente recomiendo
jugar con cosas. ver si puedes conseguir que esto
juegue en reversa después de que ya se haya jugado una vez. Haz algo como hacer
uso de eventos personalizados. Recuerda cómo podemos crear
nuestros propios eventos personalizados, cómo podemos
llamarlos desde cualquier lugar. Definitivamente podríamos conectar
algo para llamar inversa. Así que de nuevo, tratando de evitar cosas como cuando
esto termine, verás que muchos
ejemplos de código vienen de fondo y tienen este horrible tipo
de lógica de bucle aquí Sería mucho mejor
ver algo así como el evento personalizado que has creado, tener este llamado en código Entonces, si quisieras jugar al revés, algo
realmente sencillo. Dije que experimentes
con eso tú mismo, pero acabo de mostrarte
las respuestas reales ahí. Pero haz cosas
así. Juega con las diferentes propiedades y
características que proporcionan estos. Tal vez conseguir que se detenga a mitad de camino, retroceda desde un punto diferente, que entre en juego con
diferentes curvas, tal vez sobrepase intencionadamente o agregue diferentes fotogramas clave a la animación de
la curva
y vea qué sucede
en y vea qué sucede Tal vez incluso agregue algo de escalado. Entonces puedes hacer que se
vea realmente caricaturesco con ellos comenzando
a una escala realmente pequeña, rebotando en la existencia haciendo algún tipo de escalado de animación de
estiramiento de squash, y luego terminando en
su escala normal Empieza a
divertirte y
jugar con las diferentes
opciones disponibles para ti. Pero esas son las
animaciones de spawn completas. Los barcos ahora entran
con estilo, y a continuación, vamos a meternos en el movimient
27. 26 - CameraShakeKnockback: Aún no se ha hecho. Todavía hay más pulido que podemos
agregar a este proyecto. Vamos a estar
viendo knock backck
para las colisiones
y los batidos de cámara, asegurando que cada golpe
se sienta como si Veremos el knock
back un poco más tarde. Eso es un poco más manos a la obra que
el movimiento de la cámara. Empezaremos por aquí. Entonces, para comenzar, solo
vamos a ir a nuestro cajón de contenido y solo asegurarnos de que tenemos nuestra estructura de
carpetas configurada. Y dentro de la carpeta principal de
Blueprints, vamos a crear
una nueva carpeta aquí, y solo llamaremos a
esta cámara shake Podemos agregar algunos tipos diferentes sacudidas
de cámara a nuestro proyecto. Entonces podemos tener algunas intenciones
para las explosiones, y podemos tener quizás
algunas más suaves
para los proyectiles
disparando De nuevo, completamente depende
de ti, dependiendo cuánto impacto
quisieras llegar al jugador. Para crear un movimiento de cámara, en realidad
necesitamos una clase personalizada, lo cual es realmente agradable y
fácil. Hacemos clic derecho. Podemos ir a nuestra clase de
planos aquí arriba. No estoy muy seguro de
dónde está en las categorías, pero simplemente, podemos
buscar shake de cámara. Puedes ver, porque es
algo que Epic New algo muy popular
para agregar a muchos juegos, en realidad
han creado
algunas clases personalizadas para que podamos trabajar con ellas. Queremos este de aquí,
la base de sacudidas de cámara. Tenemos algunas opciones heredadas y una versión personalizada de esto, pero solo
vamos a trabajar con la versión base rudimentaria,
golpea Select, y
llamaremos a esta
BP Underscore Camshak BP Underscore Haremos doble clic para abrir esto, y en realidad no necesitamos el gráfico de
eventos en el
fondo aquí. Así que solo voy a cerrar
esto
muy rápidamente porque una forma muy
sencilla de volver a vista de
datos solo en algunos Blueprints es
cerrarlos , hacer doble clic
para reabrirlos Y todo lo que realmente
necesitamos ver son nuestras
propiedades de movimiento de cámara justo aquí. No vamos a estar
programando nada, así que solo podemos trabajar con las
propiedades predefinidas proporcionadas. Lo principal que queremos
cambiar, tenemos el
patrón de temblor de raíz establecido en ninguno. Vamos a dejar esto
abajo y buscar a Perlin. Esto está proporcionando una aleatorización
agradable usando algunos patrones de ruido de
Perlin pregenerados Si recuerdas estos atajos que mencioné hace muchos temas, aquí es donde cosas
como mantener el turno y soltar las flechas
aquí abajo pueden ser de gran ayuda. Entonces, si
volvemos a hacer clic en esto con Shift retenido, esto despliega
todas las categorías. Y si queremos volver a plegar
todos estos,
podemos mantener Shift,
hacer clic en estos de nuevo hacia arriba. Y otra vez, eso simplemente los
arroja amablemente. Entonces porque hay tantas propiedades diferentes a las que sí
queremos acceder, voy a
plegar todo, que podamos pasar por
estas en orden y encontrar qué así para empezar, tenemos el multiplicador de amplitud
y frecuencia de ubicación. Voy a dejar estos
a la una. Esto toma toda
la animación que se genera y agrega
un multiplicador a la amplitud y
frecuencia en la X, la Y y la z
para la rotación, ubicación y el campo de visión. Esto es útil si queremos
hacer algunos cambios realmente grandes, pero generalmente, queremos
trabajar sobre una base por punto. Entonces, por el pequeño impacto que
estamos haciendo en este momento, tal vez cada vez que un
proyectil golpea algo, queremos que la cámara se
mueva un
poco hacia adelante solo para demostrar que se ha recibido algún
impacto Entonces sabemos que
adelante es la X, por lo que podemos tomar eso
y comenzar a agregar algo de amplitud a
la ubicación X. Si aquí agregamos un valor de 200, se
trata de una amplitud, una
especie de fuerza
que se aplica. Y entonces la frecuencia
es cuántas sacudidas hacia adelante y hacia atrás tocará
esto Entonces, si solo mantenemos esto a la
una, solo será como una buena sacudida individual cada
vez que un proyectil golpea Se quiere evitar agregar
demasiada frecuencia en muchos casos porque eso es
lo que hará que la gente se sienta un poco motionsick Hará que sea un
poco más difícil leer y juzgar lo que
está sucediendo en la pantalla. Pero nuevamente, todo esto puede deberse a la preferencia
personal, tipo de proyecto y el estilo
general en el que tenías. Voy a dejar eso
como uno para la frecuencia, y lo estoy tomando en mente, podemos pasar un poco más rápido por los otros ejes aquí. Entonces quiero que esto se
tambalee de lado a lado un poco más, pero
con menos intensidad Entonces voy a establecer esto en
40 y diez para la frecuencia. Nuevamente, diez pueden ser
demasiadas oscilaciones de lado a lado, pero al vender esto
a algo más grande, podemos volver y refinar eso más tarde si eso es un problema Para la rotación,
voy a dejar todos estos como su defecto. Muy a menudo,
no queremos rotar la cámara que es casi
más que cualquier otra cosa, eso está casi
garantizado para causar algún tipo de
retroalimentación visual molesta, definitivamente
obtendrás algo de mareo por
movimiento proveniente de. A menos que tengas una
muy buena razón para usarlo y sepas
lo que estás haciendo. Entonces voy a dejar la
rotación completamente intacta. Similar para el campo de visión, puedes jugar
con estos si quieres, pero yo no quiero
modificarlos demasiado Las cosas finales aquí, la
mezcla en la noche,
cuánto tiempo tardan estas en llegar
a su cima y cuánto tiempo lleva pasar del pico de nuevo
a no animar y
luego la Entonces voy a hacer que
esto dure 3 segundos. Va a ser un impacto
relativamente pequeño, pero va a durar
una cantidad decente de tiempo. Así que teníamos compilar y guardar. Esa es prácticamente nuestra configuración de clase de batido de
cámara. Ahora, con la configuración de la
propiedad principal aquí, mientras estamos haciendo esto, también
podemos hacer
algunas opciones diferentes para que dejemos caer y
probar las cosas. Así que voy a tomar
nuestra cámara shake small, presione control, de hecho,
para duplicar esto, y voy a crear
una llamada medium. Duplicaré ese
y llamaré a éste grande. Entonces podríamos tener tal vez
diferentes tipos de impactos, especialmente para cosas
como las explosiones Probablemente querría un impacto ligeramente diferente pero mucho mayor porque de todos modos no está sucediendo con
demasiada frecuencia, y luego podemos alterar o iterar entre los impactos pequeños y medianos por
diferentes razones Por medio, voy a
entrar aquí. Tomaremos la amplitud hasta
algo así como 500, tal vez aumentaremos la
amplitud en la Y a 90, 15 en la frecuencia. Nuevamente, siempre podemos
volver y podemos cambiar estos si alguno de
estos es demasiado. Me acabo de dar cuenta
de
hecho pensando en cómo
quería configurar esto. En cámara shake pequeño,
creo que queremos que la duración sea
0.3, no 3 segundos. Durando por 3 segundos. me
imaginas hablando ahora
es de unos 3 segundos. La pantalla
habría estado tambaleándose por la longitud de esa oración, que es un poco demasiado. Entonces vamos a
compilar eso,
bajarlo a 0.3 porque
no queremos sobreestimular visualmente a la gente. Así que aquí podemos
hacer lo mismo. Estableceremos esto en
0.3. Tal vez podamos hacer esto 0.4 porque
hay más sacudidas sucediendo. Podría haber razones para que se quede un poco más
de tiempo Entonces estableceremos esto en 0.4.
Lo mismo para los grandes. Queremos que este realmente
tenga una patada bastante grande porque va
a haber sensación ya que está
bastante cerca de la cámara
cuando algo realmente explota esos
efectos de partículas grandes están sonando Entonces este tiene sentido que pueda ser un
poco más fuerte. Así que en realidad
voy a cambiar el multiplicador
general aquí para
realmente darle algo de patada a esto. Entonces configuraremos esto a cinco, y luego el amplitde, voy a configurar esto hasta 900 La amplitud Y,
puso esto hasta 160. Voy a dejar
la frecuencia a las diez. No queremos que esto vaya demasiado de
lado a lado. Creo que el marco de tiempo otra vez, tal vez alrededor de
establecer este 0.5 segundos o simplemente
darles pequeños incrementos, así que todos son
notablemente diferentes cuando estamos haciendo nuestra
reproducción y prueba Así que de nuevo,
no hay bien o mal. Puede que haya subido a valores
realmente altos, tal vez incluso demasiado altos, pero siempre podemos
refinarlo y traerlo de vuelta, diciendo que
definitivamente esto es demasiado alto. Dije 900, pero hasta en 9,000. Eso sería casi imposible ver
lo que estaba pasando, así que vamos a asegurarnos de que lo
tonificamos de nuevo. No digas eso demasiado alto. Entonces no tenemos tres
intensidades para probar, y solo necesitamos implementar
esto en nuestro código Tan agradable y sencillo, es un sistema pre
construido listo para nosotros. Va a volver a la base del plano de
subrayado BP. Voy a mantener estos abiertos
por si acaso quiero volver y ajustar
los valores en cualquier momento Dentro del plano BP Base, una de
las obvias para manejar primero sería la función
muerte. Entonces tenemos nuestra función Manejar
la Muerte. Todavía tenemos nuestro que hacer aquí si necesitabas
encontrarlo de esa manera. Entonces tengo mi
comentario de todo, y este es el efecto final que
sabía que quería
volver e implementar. Entonces podemos sacar del pin de
ejecución aquí. Buscaremos
una función llamada Play World camera shake.
Se puede ver eso justo aquí. Esto es muy similar
a nuestros tres signos D, por lo que nuestros signos direccionales e
incluso nuestro sistema de partículas. Entonces todo de nuevo,
una vez que empiezas a
aprender a hacer una de las diferentes características
dentro de Unreal, entiendes de alguna manera cómo hacer también
entiendes de alguna manera cómo hacer
las otras cosas,
si eso tiene sentido Entonces tenemos aquí,
por ejemplo, el epicentro,
que es el lugar desde el que comienza a tocar el
batido Entonces, agradable y sencillo,
vamos a duplicar esto, la ubicación del actor get
y enchufar eso. Así que el movimiento de la cámara
debería estar
a partir del cual la nave Abe
acaba
de explotar, y luego va a rasgar luz hacia la cámara es el
tipo general de idea aquí Esto lo hacemos con base en un radio, así que el radio interior es donde este va
a ser más fuerte. Entonces, si la cámara está justo al
lado del avión que explota, va a obtener toda la fuerza del plano de sacudidas de cámara Entonces pondremos esto en algo así
como 2000 unidades de radio. Y entonces el radio exterior
es donde cualquier cosa fuera de esa zona probablemente no se verá afectada por el movimiento de la cámara, o si está muy
cerca, podría simplemente obtener el último tipo
de bamboleo final Y creo que pondremos
esto en algo así como 5,000, y de nuevo, puedes jugar
con estos si está pasando demasiado
o demasiado intenso, puedes cambiar el radio
y tipo de jugar con eso. Como ya he dicho, para
las explosiones, cuando los barcos reales están explotando, vamos
a bajar esto, y vamos a
buscar el
subrayado BP Cam Shake Lidge, así que ese va a ser nuestro movimiento de cámara de
explosión Podemos golpear compilar y guardar, y solo podemos probar este
porque definitivamente tenemos la funcionalidad lista para Bien, así que eso es lo que quise decir donde algunos de estos podrían ser
un poco demasiado intensos. Entonces eso va
a ser fácil de arreglar. Podemos pensar que la
radio debería estar bien
porque la cámara
apenas comprobaba dos veces. Si el inicio de los jugadores es 130 en la z y la cámara es de
2,400 unidades en la Z, eso significa que estamos
un poco fuera del radio interior de cualquiera de las explosiones
de todos Así que deberíamos estar
consiguiendo un
temblor de cámara algo ahusado. Lo que podemos hacer. Creo que
tal vez solo fui directo al multipler
un poco demasiado alto. Pero como he mencionado,
ese es en realidad un enfoque muy común para
este tipo de cosas es doble, driple o cuádruple lo que
piensas que podría
ser un
valor razonable y luego alcanzarlo una vez
que lo hayas probado como Le ahorra hacer un montón de cambios incrementales
realmente pequeños que a menudo pueden
tomar incluso más tiempo. Entonces eso se siente un
poco mejor, tal vez 1.5, para que podamos
hacer una anulación más grande, pero mantener la
configuración general aquí igual. Y creo que eso está
bien. Entonces no voy a pasar demasiado tiempo refinando esto. Eso ahora es observable. Puedo ver y
seguir jugando eso con demasiado perturbado, así que
voy a dejar eso como eso es. Entonces ese es nuestro gran movimiento de
cámara y nuevamente, puedes refinar esto
y
cambiarlo por completo para que se ajuste a tu
proyecto como quieras. Entonces llegamos a la
cuestión de nuestros proyectiles. ¿Deberíamos hacer esta
sacudida cada vez un proyectil dispara o cada
vez que un proyectil golpea algo o Eso sería esencialmente un temblor
constante, lo que podría ser
algo nauseabundo Entonces creo que en este
tipo de proyectos, un mejor enfoque
podría ser solo convertirlo en algo que
notifique al jugador que ha sido golpeado porque de
esa manera estamos tomando este pulido visual pero realidad
lo
estamos implementando en el juego Entonces, una de las
cosas más molestas para cualquier jugador de juegos con combate
involucrado es ser golpeado pero no darte cuenta de que
has recibido daño o
poder diferenciarlo del daño bronceado del enemigo. Entonces este tipo de resuelve dos problemas diferentes
porque por el momento, recibimos un poquito de
retroalimentación si nos golpean porque obtenemos los
picos en nuestro barco. Pero no está súper claro
que estamos perdiendo daño o perdiendo salud hasta que
hayamos sido destruidos. Entonces esto podría ser un buen
tipo de arreglo a eso. Esto comunica que el
jugador está recibiendo daños. No demuestra que el
enemigo está recibiendo daños, pero están
a punto de explotar de todos modos Entonces no es tan
importante porque
no tienen tanta
salud por la que pasar. Y seguimos dando esa retroalimentación visual de
que las partículas están impactando al avión enemigo Entonces eso va a
quedar algo claro. Una manera sencilla y agradable de que
podamos hacer esto, entonces, con eso en mente es que
vamos a ir
a nuestra clase de proyectiles Queremos hacer
todo lo
relacionado con proyectiles en la clase proyectil Si aún no estás
aquí, simplemente resulta que estoy justo al lado de
mi para hacer comentarios, así que vamos a ir a
eso para volver a hacer comentarios. Y de hecho
voy a ser un
poco perezoso como lo he
hecho en el pasado. Voy a ir a
la clase de avión. Voy a agarrar
todo este código, así que la ubicación del actor get
y la cámara playworld Presiona control en S para copiar esto. Mientras estoy aquí, también puedo
deshacerme de este comentario. Ahora en realidad hemos hecho
toda nuestra lista de tareas pendientes. Tenemos todos los
diferentes efectos que vamos a implementar,
así que me desharé de eso. Y luego volveremos a la base del proyectil, colocados en el movimiento de cámara
del mundo de juego, moveremos las cosas un
poco Y la lógica es muy similar. Entonces queremos volver a hacer lo
mismo. Queremos obtener la ubicación en la que acaba de ocurrir el impacto, y vamos a
jugar a partir de ahí, mismo radio porque
todavía queremos que se caiga el mismo tipo
de cámara. Pero todo lo que vamos a
hacer es tal vez comprobaremos, ver si el pequeño impacto es lo suficientemente
grande para empezar, y es posible que queramos
cambiar esto a medio. Y eso es otra cosa.
Si crees que esto no es lo suficientemente
impactante,
podrías intentar cambiarlo. Entonces cada golpe
proporciona una sacudida, pero tal vez en las naves enemigas, es solo el pequeño
batido, y en el barco jugador,
es un batido medio. De nuevo, completamente hasta usted. Ahora tenemos diferentes clases. Puedes jugar con
eso y ver qué funciona. Creo que para mi proyecto, lo
voy a dejar solo para indicar que los jugadores
reciben daños, aunque. Ahora, hay una cosa para la que solo
necesitamos hacer un
poco de espacio, y quiero volver a
mostrarte el tipo de forma en que he visto a la gente romper
accidentalmente su código. Entonces sabemos que aquí
tenemos una condición. Solo queremos que esto suceda si estamos golpeando
el barco jugador. Entonces lo que podrías hacer es que estás
lanzando una sucursal aquí, así que vamos a
hacer una revisión de sucursal. Y queremos comprobarlo. Ya sabemos que estamos rastreando lo
que estamos pegando, así podemos llevar a nuestro actor
superpuesto No creo que nada de esto sea una especie de conceptos nuevos para ti. Así que vamos a duplicar esto en,
así que voy a ir a buscar mi actor de superposición,
asegurándome de que esté sosteniendo ese. Control de prensa, en
efecto, para duplicar. Y queremos comprobar si
lo que estamos superponiendo, sabemos que no es el dueño, ya
hemos pasado ese problema. Pero si es igual a, y ya hemos
visto esto antes, podemos usar el get PlayerPawn Entonces, si es igual
a lo que actualmente
se rastrea
como el PlayerPawn,
solo si eso es cierto, ¿
queremos tocar el batido de cámara del
Mundo Así que solo mareamos hicimos
esto un poco. Y probablemente hayas
visto que este no es exactamente el mayor
problema o problema a resolver. Algunos de ustedes podrían
haberlo visto ya, pero si eso no es cierto, si eso es falso, si
es otra cosa, entonces estamos bloqueando
esta llamada de función aquí. Entonces, recuerda que esto es
algo con lo que solo familiarizarte es
el orden de operación, el control de flujo de tu código. En escrito C plus plus, es mucho más fácil porque
vamos a estar usando declaraciones
FL que podemos simplemente abandonar dentro del cuerpo de
la función. Así que es mucho más fácil hacer un seguimiento
de eso. En Blueprints, es muy fácil detener por
accidente el resto de
la funcionalidad que ocurre cuando se ha realizado
una sola
comprobación de sucursal Entonces solo quería
mencionar, con esto, si estás siguiendo este flujo
donde solo estás actualizando y mejorando aditivamente tu
código o agregando características, es muy fácil accidentalmente
cada vez que el enemigo es
golpeado ahora, no nos
destruiríamos a nosotros mismos Entonces algo que podríamos
hacer en cambio es, de nuevo, podríamos resolver todo esto
con el uso de una secuencia. Entonces, si acabo de pasar esto de nuevo, y esto es realmente solo
para intentar martillar a casa la importancia de
pensar en la limpieza del código, no solo para perder el tiempo y hacer que el código se vea
bonito en Blueprints, sino también porque literalmente está haciendo que sea más fácil de leer y mantener y asegurarse de
que no esté haciendo estos sean realmente
fáciles de cometer errores Entonces, si lanzamos nuestra secuencia aquí, y nuevamente,
queremos
pensar
en esto como hacer una línea específica
de funcionalidad,
que en nuestro caso, está aplicando daño, y podría ser tentado a hacer es todo lo que
entonces no está relacionado con el daño, todo lo que está
relacionado con jugar un efecto Vamos a tirar
a la de entonces. Entonces solo estoy presionando Control X. Y vamos
a enganchar estos. Entonces vamos a
aplicar primero los daños. Y luego si se aplica daño, vamos a jugar
nuestro efecto de partículas, y vamos a
jugar nuestro temblor de cámara, pero sólo para el jugador. Y luego vamos
a hacer lo final. Entonces nuevamente, nos da un
buen orden de operación. Podemos ver el orden exacto en el que
se van a llamar nuestras funciones. Y como ya he
mencionado anteriormente, cuando miramos secuencias, lo que haría que
esto fuera un poco más claro es que usted
diera estos comentarios. Entonces esta podría ser la fila de daños. Esta podría ser la fila de efectos, y esta podría ser la fila clara o
algo así. Y podrías darte un recordatorio de eso en los comentarios. Así que de nuevo, solo un cambio realmente
rápido
y simple, y ahora sabemos que independientemente de que esto se
despida o no, definitivamente
vamos a
destruir siempre a nuestro actor porque
una vez
que se haya comprobado esto, si esto se llama, va a entonces
volver a subir a la siguiente parte de
la secuencia y volver. Si esto no se llama, todavía
va a
volver a la siguiente parte de la secuencia y luego
volver a bajar. Entonces lo importante es que esto se
llame independientemente. Así que ahora podemos entrar y
probar, y solo verificar dos veces. No está pasando
con los enemigos. Entonces esa fue la explosión.
Entonces, la otra cosa es que si los proyectiles
se estuvieran golpeando entre sí, podría haber provocado
que la cámara temblara cuando
los proyectiles se golpearan
entre sí Entonces ahora solo me
voy a dejar que
me golpeen sin que pase
nada más. Ahí vamos. Para que puedas ver si no me estoy muriendo
al mismo tiempo. Se puede ver tal vez
un poco demasiado
difícil de ser golpeado, pero se puede ver un movimiento de cámara, que es lo importante. Como he mencionado,
eso puede ser demasiado sutil. Si es así, eso está
perfectamente bien porque
tenemos nuestro batido medio
que podemos probar. Si realmente quisiéramos
dejar claro, que los jugadores están siendo
golpeados. Ahí vamos. Entonces eso está dando una indicación mucho
mayor de ser golpeado. Nuevamente, personalmente, creo que el pequeño
está perfectamente bien. Quizá queramos agregarle tal vez un poco más de
fuerza,
pero mantener la frecuencia igual o algo así, pero solo como aviso
de que han perdido la salud, creo
que eso es lo suficientemente claro. El siguiente paso será entrar en cosas como materiales y hacer un material de
daño a la salud parpadeante o algo así si realmente
quisieras visualizar eso. Pero creo que esto
ya es un gran paso
adelante a lo que teníamos antes
porque solo está haciendo las cosas un
poco más visuales y un
poco más claras. La cosa es que vamos
a agregar rápidamente un simple knockbck cuando los aviones chocan entre
sí Para este, queremos
manejar esto puramente en la clase de jugador porque esa es la única que está haciendo una especie
de pseudofísica Entonces voy a cerrar
todas las demás pestañas. Creo que terminamos con
los batidos de cámara, y entraremos en el jugador de avión de
guión bajo BP Y dentro de aquí,
lo que queremos
hacer es que vamos a
agarrar esa esfera. Vamos a
bajar a la
sección de colisión en el panel de detalles, y vamos a
enlazar la función de
golpe de componente aquí, como lo
hemos hecho en el pasado. Y voy a mantener esto
muy agradable y sencillo. Y de nuevo, creo que
esto es lo mismo el proyecto de ejemplo de todos modos, donde podemos rebotar de
los enemigos y las paredes. Entonces cada vez que
golpeamos algo, no necesitamos
verificar qué es. Sólo vamos a tomar
nuestra velocidad de movimiento actual, y vamos a
multiplicar eso por un valor negativo con
un poquito extra. Hace que el juego se sienta
un poco divertido y hinchable. Y lo más importante, de nuevo, solo darle al jugador esa
retroalimentación de que en realidad estás tocando otro objeto en el mundo que tiene
cierta permanencia en él Entonces vamos a conseguir la velocidad
actual, como mencioné. Vamos a multiplicar esto por un negativo más un poco de valor porque no
queremos simplemente invertirlo. Queremos añadir un poquito
de contundente knock back. Entonces digamos -1.5. Y sea lo que
sea, entonces vamos
a volver a establecer la
velocidad actual a eso. Esto obviamente se está
contabilizando en el larping de todos modos Entonces la interpolación larping, que está sucediendo con nuestra función
de movimiento general va a tratar de tomar nuestra nueva velocidad de movimiento
y luego suavizar esa de nuevo en
el tipo de velocidad normal que debería ir y en la
dirección que estamos presionando Entonces esto no va a parecer
demasiado desagradable, creo. Otra cosa que
podríamos hacer aquí, mientras hemos estado haciendo muchos de estos batidos de cámara de
todos modos, pensando en ello Y otra vez, completamente opcional, pero sólo algo
que voy a probar. Voy a entrar en
la base del proyectil. Voy a copiar el código
aquí, el movimiento de la cámara mundial, pegar esto aquí, y
tal vez vamos a hacer uso del batido de cámara medio,
así que vamos a bajar esto. Mismo radio, mismo Apicenter, y solo podemos
entrar y presionar play No, eso es definitivamente
que probablemente sea demasiado pesado, solo
estaba pensando que
podríamos hacer que se sacuda un poco cuando ocurra
el rebote. Intentaremos hacer esto con los enemigos. Ahí están pasando
demasiadas cosas. Entonces, de nuevo, prueba y error, eso pudo haber funcionado puede que
me haya parecido bastante genial, pero no lo hizo. A lo mejor sólo podemos hacer que
sea un pequeño batido. Lo principal que queremos es
asegurarnos de que rebotemos de los enemigos, también. Así que
solo verificaremos dos veces. Tan bien rebotando en la pared. Rebotando en el enemigo.
Creo que los enemigos están recibiendo demasiado
daño de nuestra sacudida. Deberían saber que fue un golpe, no
fue así, así que está bien. Es el jugador que
muere tras dos hits. Entonces sí, perfectamente
bien con el infierno. Y entonces si te estás preguntando por qué esto no afecta a
los proyectiles están actualmente todavía podemos ser golpeados por proyectiles, pero no
estamos Sólo estamos
rebotando de las paredes
y de los enemigos, lo que
creo que se ve bastante genial La razón de eso es
volver a nuestra configuración de colisión. Entonces ojalá esto ayude a toda
la estructura de colisión tenga más
sentido, también. Así que recuerda que nuestra esfera
en el jugador está lista para golpear. Entonces solo es verificar si
hay colisiones físicas con otros objetos físicos Entonces esto es hacer un
hit on hit check aquí dentro de nuestro
jugador y nuestros enemigos. El proyectil, aunque se
ve relativamente similar, algo así como lo mismo esto está haciendo un tipo diferente
de chequeo recuerda Esto se establece como un colisionador de
superposición. Entonces por eso es
útil pensar en cómo vas a configurar
tus diferentes colisionadores Significa que puede obuscar
completamente diferentes tipos de configuración de colisión para reaccionar y
responder a sus diferentes
contrapartes de formas únicas Entonces eso significa que no
necesitamos
preocuparnos por los proyectiles, proporcionando ningún retroceso o tipo de empuje físico
a Literalmente
solo están volando por el espacio. No están
haciendo ninguna física. No están
colisionando físicamente con las cosas. Sólo están comprobando si hay algo más
en el mismo espacio. Y si algo más
termina en el mismo espacio, todo lo que está haciendo es
tratar de aplicar daño, intentar jugar algunos efectos
y luego destruirse a sí mismo. Entonces por eso podemos
salirnos con la suya. Y nuevamente, por supuesto,
los límites de nivel se establecen con la
misma colisión, por lo que estos están configurados para bloquear a
los enemigos y al jugador Entonces, eso es todo. El
proyecto está pulido. Creo que ahora se siente mucho más interesante
para interactuar. Proporciona un poco más de una
experiencia animada e interesante para interactuar. Nuevamente, mucho de esto se
reduce al refinamiento. No espero que dejes
el proyecto, como te he dado con
estos pasos hasta ahora. Si no te gusta nada el movimiento de la
cámara, o crees que
puedes hacerlo un
poco más, eso está perfectamente bien. Agrega, elimina, cambia todas esas propiedades
como mejor te parezca. Y eso es solo
algo de nuevo para que pruebes y experimentes entre temas y realmente tengas en
tus manos el proyecto. Y crea nuevas
clases de shake de cámara si puedes ver un caso de uso para
algo que sacude con más frecuencia
o menos frecuencia, pero con más
amplitud, por ejemplo Lo principal es que
cada impacto debe sentirse apropiado a la retroalimentación que el juego está tratando de enfatizar. Y eso es lo que va a llevar tus proyectos de sentirte como un
tipo de juego principiante muy amateur a algo que tenga un
poco más de pensamiento, cuidado y atención
aplicados a todos
los diferentes elementos con los que el jugador estará
interactuando. Otras cosas para probar
es que podrías probar la ola en lugar
de la perla en el
ruido mientras la cámara tiembla y cualquiera de los otros temas que como que
he mencionado, pero no tendremos tiempo de ir completamente
a fondo con cada advertencia de todos los
diferentes procesos Con eso hecho, sin embargo,
tenemos nuestro batido, knock back. El peso y el impacto
del campo se están volviendo
bastante reales ahora, lo que deja el final de
crear una interfaz de usuario para manejar
el ciclo completo del juego. Por el momento, los jugadores
simplemente se quedan atrapados en un vacío sin fin si
son destruidos, y obviamente no
queremos que ese sea el caso.
28. 27: interfaz de usuario: Bien, entonces estamos en
el tema final. Este va a ser
el juego sobre pantalla, la interfaz de usuario, proporcionando un sistema de reinicio
y una salida adecuada. Idealmente, tendríamos
algunos botones para presionar. Pero vamos a mantener
esta interfaz de usuario agradable y simple. Tú terminas. Puedes presionar el botón I para reiniciar y luego volver
directamente al juego. En un proyecto más grande,
es posible que desee agregar una pantalla de menú o
algo así. Pero con esto, tendrás un juego
completo y jugable. Lo primero que
queremos mirar es el concepto de widgets. Entonces el UnrelEngine maneja los sistemas de
menú y las
superposiciones de interfaz de usuario, las pulsaciones de botones
y cosas
así a través de algo
llamado clase de Entonces dentro de nuestra estructura de
carpetas, voy a crear
una nueva carpeta, y voy a llamar a esta
widgets o UI. A menudo verás esto
llamado uno de esos dos cuando estás mirando a través de los proyectos de
otras personas. Dentro de mi carpeta Widgets, queremos hacer click derecho aquí. Vamos a ir
a Interfaz de Usuario. Podemos ver aquí
tenemos la opción de un plano Widget Entonces todavía hay clases de
blueprint, pero esto solo
nos permite poner una especie de interfaz
visual con
algún código vinculado a ella Seleccionaremos esta
opción aquí y crearemos un widget de usuario estándar. Simplemente y luego presionaremos Seleccionar, y le daremos a este
el nombre de WBP para Widget Blueprint
guión bajo Haremos doble clic para abrir esto, y puedes ver que el
diseño es ligeramente diferente. Lo primero es anotar
en el lado derecho, parte superior derecha,
tenemos dos pestañas diferentes. Tenemos la pestaña de diseñador,
que es donde estamos ahora. Esto proporciona un diseño
visual y un
sistema de lienzo realmente agradable para arrastrar y soltar diferentes elementos para
configurar la forma en que esto
se mostrará en la pantalla. Entonces tenemos la gráfica, que es nuestro editor de planos estándar, muy similar a lo que has visto antes con solo
algunos ligeros matices Mientras todavía en el elemento
diseñador aquí, vamos a ir
al lado izquierdo, y queremos algo
llamado superposición de estas diferentes categorías se
puede ver que hay un montón
de categorías diferentes, así que solo voy a
buscar overlay. Y esto es esencialmente
un panel para que
coloquemos todas las demás cosas
importantes en. Entonces dejaremos caer esto
, y puedes ver aquí esta es nuestra
superposición en la pantalla. Solo queremos asegurarnos de que se
trata de un panel de 19 por 20. Para que podamos arrastrar esto,
y vamos a poner esto. Sólo necesito darme
un poco más de espacio. Podemos dejar esto y
podemos verlo como que se ajusta al hacer clic
en los límites aquí, y esto
encajará en su lugar Por lo que tenemos un panel de
altura por defecto de 19 por 20. Ahora bien, estos se
establecerán a escala y cambiarán en función de la pantalla en la
que se estén colocando. Pero solo vamos por defecto, asumiendo que
estamos en una pantalla de 19 por 20, y podemos trabajar en esa premisa. A continuación, podemos agregar algún tipo de visual agradable
a esto, también. Así que podemos buscar
algo llamado un panel de desenfoque o un desenfoque de fondo, y simplemente
dejaremos esto. Podemos ver que la
jerarquía aquí, la superposición es donde todo va a caer sobre, y entonces el desenfoque de fondo
es un hijo de la superposición. Podemos ver si hacemos zoom en el
fondo el desenfoque es
un poquito pequeño. Esto nos resultará
un poco difícil de
ver si tuviéramos que presionar
Reproducir y tener esto mostrado. Entonces lo que queremos hacer es
en el lado derecho, podemos alinear esto
a nuestro overlay. Entonces si le decimos que
ocupe, llene todo el espacio horizontalmente
y llene todo el espacio verticalmente se puede
ver que ahora está coincidiendo con el tamaño
del componente padre,
que es el overlay. Para la fuerza de desenfoque, solo
voy a agarrar este valor aquí
en el panel de detalles, y le daremos a esto una fuerza de
desenfoque de 15, y podemos ver que se le agrega
un ligero desenfoque a nuestro panel, que creo que va
a quedar bastante bonito, algo moderno y solo darle un poco de destello visual. A continuación, queremos
ver cómo podríamos formatear el texto que vamos
a querer mostrar en pantalla. Así que vamos a mostrar
algo como esto, solo un simple poco de texto
diciendo juego terminado, y luego un consejo
de herramienta sobre cómo reiniciar. Una manera fácil y agradable de administrar
múltiples elementos en una sola área en un menú
sería usar algo como una
compra horizontal si quisieras que las cosas se
extendieran horizontalmente a través de tu
widget o una caja vertical. En este caso,
vamos a ir verticales. Entonces, si buscamos
un cuadro vertical, podemos soltarlo y
solo asegurarnos de que este sea un hijo de la superposición y
no del desenfoque de fondo. Para la alineación
de éste,
se puede ver que esto está
ocupando toda la caja. En cambio, vamos a
establecer esto en la línea central para la configuración horizontal y
vertical justo aquí. Eso está perfectamente
bien. Podemos hacer esta escala a los elementos del interior un poco más tarde. Los elementos, como mencioné, van a ser muy,
muy sencillos para ello. Sólo vamos a darle a
esto un elemento de texto, así que vamos a
buscar un texto, y dejaremos caer nuestro primer
elemento de texto en el cuadro vertical. Y se puede ver que
realmente salió la caja vertical para
encajar
el Para el
texto inicial, voy a
configurar esto para que diga GameOver Entonces con el texto seleccionado, queremos encontrar nuestra opción de
texto aquí. Se puede ver que actualmente está
diciendo bloque de texto, y sólo voy a
cambiar esto a game over. Cambiar nuestro tamaño de fuente. Entonces por el momento, si
bajamos nuestras
propiedades de fuente justo aquí, el tamaño es 24,
y creo que un tamaño de alrededor de 50
sería ideal para este. Podemos cambiar el tipo de letra. Roboto audaz a menudo se ve
un poco desagradable. Podemos simplemente cambiarlo a regular o incluso la luz puede
verse bastante bien. Sólo se ve un poco más limpio. Eso ahora
no se ve del todo impactante. A lo mejor queremos cambiar
el tamaño de fuente a algo así como 60 para que se vea y suene un
poco mejor. Ahora con este texto
seleccionado, podemos presionar. Entonces vamos a agarrar
esto por aquí en el lado izquierdo o
duplicar nuestro texto. Así que el control, en efecto,
para duplicar. Y se puede ver
eso porque está dentro de esta caja vertical, ahora
es asegurarse de que
ésta esté alineada verticalmente. Y si seguimos agregando elementos de
texto, tendremos esta bonita alineación
en orden vertical. Así que esto solo hace que
sea un poco más fácil de administrar y trabajar con múltiples elementos cuando
quieres que estén aproximadamente alineados entre
sí en el mismo lugar. Ahora para este, solo voy a agarrar el nuevo elemento de texto, o cambiar el texto para
decir presione R para reiniciar. Probablemente no sea el juego más
interesante sobre pantalla, pero
consigue el punto a través. Vamos a cambiar un poco el
tamaño de esto. No necesita ser del todo
impactante ya que el juego terminó. Entonces le daremos a esto
un tamaño de fuente de 30. También podríamos darles
un poco de relleno a estos. Entonces, si agarro el GameOver, antes que nada, en el panel de
detalles de la derecha, podemos darle a esto un
encabezado predeterminado de digamos diez, así que se pone un poco
boider Y podemos hacer lo mismo
con la prensa R para reiniciar. También le daremos a esto un
poco de boider. Y lo principal es que queremos que
esto esté alineado al centro. Así podemos agarrar la alineación
horizontal y asegurarnos de que
ambos estén alineados al centro. Así que se colocan en medio
de su caja
vertical, agradables y ordenados, y no
necesitábamos hacer mucho trabajo. Otra cosa que quizás
quieras hacer es cambiar un poco los colores visuales. Así podríamos apoderarnos del juego. oververs de juego
normalmente se representan con un rojo o un naranja o
algo así,
así que podríamos cambiar
el color aquí para que sea un poco más
de un color negativo, hacer que eso simplemente destaque
contra la entrada aquí Se ve un
poco más interesante porque tenemos algunas cosas
más en marcha. Algunos pases más pulidos que quizás quieras hacer
a esto, puedes traer tus
propias fuentes muy fácilmente para unreil
y luego
simplemente puedes cambiar la fuente
que quieres usar
para que se vea un
poco más personalizada Juega con cosas como
la audacia, el tamaño de la fuente. Incluso puedes agregar
cosas como contornos si quisieras
enfatizar ciertas partes. Entonces si solo me
acerco un poco. Podría agregar un
contorno de dos píxeles alrededor y obtenemos un esquema a los elementos de nuestro menú justo aquí. Entonces, sea lo que sea que quisieras
hacer para que esto vea un poco más
interesante, como dije, vamos a
mantener esto agradable y sencillo solo para demostrar
que el juego
ha terminado y darle al jugador un aviso sobre lo
que puede hacer a continuación. Así que vamos a
sumergirnos muy brevemente nuevo en el sistema de entrada porque ahora necesitamos
tener algo de fuego cuando esta interfaz de usuario
se muestre en pantalla. Entonces, si volvemos a
nuestro sistema de entrada, solo recapitulamos lo que tenemos Ya tenemos nuestra clave de reinicio. Ahora, como mencioné, en un juego
completo donde tienes un
sistema de menús
más complejo y cosas así. Puede tener diferentes clases de contexto de
mapeo de entrada. En este caso, acabamos todo a una jugabilidad única, y creo que eso está
bien porque no tenemos usos superpuestos así si quisieras
usar, por ejemplo, el botón Atrás en un gamepad, así que B en el gamepad, para ser una entrada como salto, pero también querías
que fuera el botón de reinicio, ahí sería donde quizás
quieras compartirlo . Entonces, si estuvieras en un menú, entonces B se mapearía para reiniciar Entonces tendrías tu contexto de mapeo de
menú. Y luego, cuando estás en el
juego y era saltar, entonces tendrías tu contexto de mapeo de
juego. En este caso, creo que solo usar este
estaría perfectamente bien. Así que vamos a
volver a nuestro GameOver, y solo queremos hacer ese enlace que hemos
hecho anteriormente Entonces aquí es donde entra el
lado del código de nuestro menú, y aquí es donde parte de la flexibilidad
realmente genial
del sistema de entrada mejorado hace que cosas como esta sean mucho
más fáciles de lo que solía ser. Definitivamente fue posible
con el sistema heredado, pero esto es
definitivamente un paso adelante. Navegaremos hasta
la gráfica de aquí, y estos son bastante similares
a lo que hemos visto antes. Entonces tenemos un
tick de evento, y en este caso, no
vamos a estar haciendo
nada en tick en nuestro menú, para que podamos
deshacernos de esto. Entonces, la construcción del evento es esencialmente la
misma que la obra de inicio. Esto sucederá tan pronto
como comience el juego, y el menú se genere
a la existencia Entonces, cuando mostramos el
menú en pantalla, este será de cinco una vez. Pre construcción, hay que tener
un poco de cuidado con. Esto es útil para los cambios de
editor. Así que podríamos codificar
cosas para que
pudiéramos obtener actualizaciones del editor en vivo, pero hay que tener cuidado
aquí porque si estás referencia a otras clases o haciendo cosas fuera
del menú, esto puede causar problemas si aún no
estás en modo de reproducción Entonces, para evitar confusiones, nos vamos a
deshacer de este, y solo pensaremos en esto
como nuestro así sucesivamente Empezar a jugar, lo que queremos hacer o
en la construcción del evento es que vamos a llegar nuevamente al controlador
del jugador, y queremos hacer exactamente
lo que hemos hecho anteriormente. Queremos encontrar el subsistema de reproductor local
de entrada mejorada . Este de aquí con el icono de función
púrpura rosáceo justo Y nuevamente, igual
que lo hemos hecho antes, vamos a agregar
el contexto de mapeo. Así que varias clases pueden tener
el mismo contexto de mapeo, así que vamos a tener
el contexto de mapeo ahora en nuestra clase de jugador, que está manejando la entrada
para moverse y disparar. Podemos agregar ese mismo
contexto de mapeo a nuestro menú. Entonces, cuando esto se genere en, también estará rastreando las pulsaciones de botón
relevantes Ahora bien, en este caso, esto está bien porque la pulsación de
botón relevante solo
va a ser IA
underscore restart Por lo que podemos hacer clic
derecho aquí. Buscaremos reinicio
de subrayado de IA Queremos de nuevo el evento,
así que cuando algo sucede, obtenemos el archivo pin de ejecución
de cuando se presiona esto. Simplemente queremos recargar el nivel que estamos actualmente
y solo estamos reiniciando Solo tenemos un nivel, así que
esto es agradable y sencillo. Hay una función que
podemos usar para hacer esto, una característica incorporada en irreal Podemos usar el nombre del nivel get
current. Entonces esta función justo aquí,
conecta esto para comenzar. Así que de nuevo, cuando esto
se presiona una vez, esto devolverá el nombre
del nivel en el que
nos encontramos actualmente, que recordar se
acaba de llamar principal. Así que podríamos hacer esto
codificado duro y simplemente escribir
el nivel principal para el nivel
que estamos a punto de recargar Pero por si acaso
alguna vez comienzas a agregar más niveles o cambiar
el nombre, esto es solo, nuevo, una forma agradable, dinámica y reutilizable de
implementar esto. Entonces, una vez que tengamos esto,
vamos a sacar de aquí, y vamos a
buscar el nivel de carga de la función, y vamos a
buscar la función open. Se puede ver la opción aquí, nivel
abierto por nombre. Ahora obtenemos dos variables ligeramente
diferentes, por lo que tenemos el
nombre del nivel actual devuelto como una cadena, y tenemos nivel
para cargar devuelto esperado que se alimente
como una variable de nombre. Perfectamente bien. Nuevamente,
podemos simplemente enchufarlos. Ambos son un tipo
de texto, esencialmente, e irreal hará
esa conversión para nosotros. Entonces esto tomará el nombre actual del
nivel en el que estamos principal, y abrirá el
nivel por el mismo nombre. Entonces solo estamos
reiniciando nuestro derecho, el otro problema del que me
acabo de dar cuenta aquí es que no tenemos
forma de dejar el juego Algo
con lo que
realmente estoy tratando de ayudar aquí es que esto sienta como un
juego completo para principiantes al final de este proceso. Una cosa que encuentro
al probar y demostrar juegos de
nuevos desarrolladores es que a menudo estás atrapado
en su juego y
tienes que alt F para
cerrar el panel Entonces, mientras estamos
viendo la entrada, también
podemos
deshacernos de este problema, también Lo que voy a hacer es que
voy a duplicar el reinicio de
subrayado de IA Voy a renombrarle
este para que deje de fumar. Dentro del
subrayado principal IMC, solo
queremos
agregar un nuevo mapeo Entonces sabemos que reiniciar es
un booleano, una entrada binaria. Entonces ya hemos dejado de establecer como un booleano digital,
también, lo cual es perfecto Entonces en IMC Underscore main, vamos a agregar
un nuevo mapeo Desmontaremos esto y
seleccionaremos el botón de salir. Entonces para probar en el editor, esto es un poco
complicado porque por defecto, escape se mapea para
terminar la reproducción de todos modos. Entonces, si estamos jugando y probando, no
podríamos probar. Sin desactivar nuestro
sistema de menús o nuestro botón rápido. Entonces voy a dar esto.
Si tuviéramos que empaquetar esto, sin embargo, y dárselo
a alguien más. Yo sí quiero la llave de escape
para cerrar el proyecto. va a haber menús, no va a
haber pop ups, solo una forma rápida de
cerrar el proyecto, así que al menos no me atascado una vez que construya
el proyecto. Para las pruebas de editor, lo que
a menudo hago es
darme otra unión, y configuraré esto en
algo realmente aleatorio que otro modo no estaría
presionando dentro de mi jugabilidad. Entonces podría establecer esta
para que sea la clave de eliminación. Y esto significa que
lo que puedo hacer es volver a mi clase de jugador. Entonces voy a entrar en
el núcleo el jugador de avión. Y nuevamente, nos estamos
alejando un
poco de las formas ideales de
configurar esto ahora. En un proyecto real, probablemente
harías esto dentro de un controlador de reproductor
o diferentes sistemas de menú, pero no vamos a ir tan profundo para hacer sistemas de menú completos. Así que vamos a dejar esto en nuestro sistema de entrada aquí. Entonces tenemos nuestra
gráfica de entrada. Seguimos manteniendo las cosas bien
y ordenadas, al menos. Esto todavía está dentro de
nuestro subrayado principal de IMC. Entonces eso significa que todas nuestras nuevas fijaciones
siguen siendo rastreadas Y lo que podemos hacer es que podamos
encontrar que el subrayado de IA deje de fumar. Y cuando se pulsa este botón, así queremos que vuelva a ocurrir el evento. Y cuando se presiona este botón, así se inicia, solo queremos
llamar a la
función incorporada, que es salir. Juego tan rápido. Y
esto simplemente cerrará
automáticamente la
instancia del juego por ti. Entonces, si golpeamos compilar y guardar, podemos probarlo de inmediato Recuerda que en modo play, si
presiono Escape, de todos modos se
habría cerrado. Entonces voy a presionar
la tecla de borrar, y acaba de terminar la reproducción. Entonces eso funcionará para
nuestra versión empaquetada, así
como nuestra versión de
editor aquí. Entonces no necesitamos hacer
nada más aquí. Y solo quería
presentarte la funcionalidad rápida, porque como he mencionado, es realmente fácil de pasar por alto, pero es súper, súper
simple de implementar Y es solo una de
esas cosas que lleva tus sentimientos iniciales
y la calificación de un juego que estás jugando
solo lo
lleva un paso y
te hace sentir como si estuvieras jugando a un juego hecho por alguien con un poco
más de experiencia. Lo último es que queremos que
esta interfaz
de usuario muestre cuándo muere el jugador. Sabemos exactamente cuándo
sucede eso porque tenemos nuestra función de mango muerte
dentro de la clase de jugador. Entonces con esto,
vamos a encontrar nuestra función de manejar muerte. Queremos ir a anular, y queremos
encontrar a Dyna manejada Queremos asegurarnos de
que todavía estamos llamando a todas esas cosas importantes para
padres, así que nuestro efecto y todo
eso se está manejando. Pero justo antes de que eso
suceda, o tal vez sí, justo antes de que eso
suceda porque estamos llamando a Destroy en
la versión principal, queremos generar en
nuestra interfaz de usuario Y podemos hacer esto de manera
muy simple, así que vamos a tirar
de aquí y encontraremos una función llamada Crear Widget. Entonces esta es una función para crear uno de nuestros widgets de blueprint Podemos enchufar esto
aquí, y queremos
encontrar nuestro juego de subrayado WBP Ahora de nuevo voy
a hacer un poco de punto de esto
solo porque te
sorprendería cuántas personas olvidan el siguiente paso importante. Ese tipo de siente como
si esto debiera funcionar. Pero si rápidamente entro y permito que mi avión sea destruido, estamos llamando a esa función, le
hemos dado el widget
determinado, pero no estamos viendo
ese widget en pantalla. Entonces otra vez, cosa muy común. A pesar de que
sienta que eso es todo lo que
tenemos que hacer. En realidad hay un paso extra. Queremos sacar de
este pin de retorno. Entonces esto se crea
en el fondo. Hay un juego sobre widget que
simplemente se queda en
la memoria Queremos tomar esa
referencia y memoria
y queremos decir
añadir al punto de vista. Una función especial llamada
Need to Make aquí, y luego solo vamos
a enganchar todos estos. Y ahora, esto
realmente funcionará. Entonces, si entramos y
presionamos play de nuevo, solo consigue que mis aviones sean
destruidos, y ahí vamos. Entonces esto creó ese menú, pero también
lo agregó al mirador. Si presiono R, tenemos
ese enlace en el menú, así que ahora tenemos un
reinicio, también. Así podemos entrar y
reiniciar el juego muy, muy fácilmente ahora. Vamos a terminar
con lo mismo. Y si presiono Eliminar,
algo que ahí pasé por alto. Iba a decir, si
presiono Eliminar, puedo dejar de fumar. No puedo porque los
jugadores han sido destruidos. Y recuerda, nuestra encuadernación
para dejar de fumar está en el jugador. Entonces algo que podríamos querer hacer un poco de duplicación. Vamos a tomar
nuestro subrayado IA quit y la función quit
game aquí Aquí no lo vamos a
quitar. Lo queremos en ambos lugares.
Vamos a volver al juego por encima
de sólo vamos
a pegar esto aquí abajo. Entonces, cuando el jugador
ha sido destruido, ya no existen. Obviamente no podemos
dejar el juego. Así que vamos a mover
esa funcionalidad al
widget
GameOver en su lugar Así que perfectamente bien de hacer. Solo asegúrate de que
el jugador aún muere. Y luego ahora si
presiono eliminar, podemos cerrar el juego. Así que la misma funcionalidad, solo siempre
tenemos que dar cuenta de si algo está completamente
eliminado del juego, completamente eliminado de la memoria, tenemos que asegurarnos
de que todas las funciones que eran relevantes todavía estén
disponibles en otro lugar. Y otra vez, si estás encontrando, como cuando yo estaba mirando eso, siento como si tuviéramos bastante espacio en
la pantalla ahí. Entonces creo que lo que podría hacer son solo unos pocos ajustes muy pequeños es tal vez hacer que este realmente grande
doble el tamaño de nuestro juego Y luego duplicar el tamaño
de nuestra punta de herramienta aquí. Entonces no es nada importante, pero solo va a volver a
hacerlo, solo conseguir una
especie de relleno general y hacer que todo
se vea lo mejor posible, tratando de presentar el
juego de la mejor manera. Entonces sí, probablemente un tipo de estilo
general
mucho mejor ahí. Presiona para reiniciar, todo está funcionando. Así que bastante perfecto. Creo que para un proyecto principiante, un tipo de remake muy simple
de algo que existe, pero tratando de
expandirse y mejorar, especialmente la
base de código donde sea posible, pero también la retroalimentación general y el relleno
y las imágenes,
ojalá sea un buen tipo de
punto de aprendizaje y paso en la dirección correcta para
sus proyectos futuros Pero eso es
más o menos una envoltura en esto. Entonces algunas cosas más
para que te lleves en
esos puntos de aprendizaje. Puedes jugar, disparar
a los enemigos, ser golpeado, morir, aparece
juego sobre pantalla, y puedes hacer todo de nuevo.
Todo se ve bastante bien. Tenemos una especie
de interfaz de
usuario simple, de aspecto
moderno y semi borrosa . Puedes presionar escapar o eliminar y cerrar el
juego desde cualquier lugar. Así que de nuevo, no estamos
haciendo que esto se sienta como un completo proyecto novato donde estás atascado y
tienes que alterar F four del proyecto de fin de
semana de alguien Así que ojalá eso sea
una buena mejora en lo que podrías
haber visto también. Así que tenemos un bucle
completo de juego completo. Podemos jugar, morir,
reiniciar y dejar de fumar. Así que en el espacio de
todo este tiempo, hemos pasado de un
proyecto vacío a un juego completo, movimiento con
independencia de wrate de fotogramas, proyectiles, materiales
dinámicos, enemigos con herencia y una breve mirada Tenemos generadores
con aleatorización, asegurando que han sido
hechos de manera genérica,
pero genéricos de buena
manera que podemos crear
la clase una vez y utilizarlos
para Miró partículas, audio, movimiento de
cámara, knock
backack y ahora UI Entonces esta es, ojalá,
una buena base. Se puede construir sobre esto. Como he mencionado,
sería genial si añades algunos enemigos únicos,
tratas de darles diferentes patrones de
movimiento, diferentes patrones de armas, tal vez los aceleres y solo
los conviertes enemigos kamikaze
con Lo que sea que estés sintiendo
por tus pasos adicionales para que este proyecto sea único. Trae algunos activos nuevos y comparte tus avances y
actualizaciones con otras personas. También podría agregar cosas
como anotar, lo que sería muy fácil de hacer a través de la función de muerte de
mango compartido. Sabemos exactamente cuándo mueren
los enemigos, así que podrías construir
sobre eso y crear algún tipo de sistema de puntuación. Así que realmente haz tuyo este
proyecto. Toma referencias
de otros juegos, mira los ejemplos de contenido, y definitivamente recomiendo
que en este punto es en realidad mirar
los ejemplos de contenido. Eche un vistazo al mapa de
entrada del plano y vea exactamente
de dónde se inspiró
este proyecto y compare el código que tiene con
el código de ese proyecto Y nuevamente, esto no es
para emitir juicio, sino solo para ver
que siempre hay diferentes maneras de
abordar un solo problema. Y mira cuál es tu
opinión sobre lo que
tenemos frente al proyecto
original. Pero lo importante
es que ya has construido un juego, y
eso no es nada. Eso es un logro, y más aún si has
estado dando esos pasos adicionales, y realmente sientes como si
estuvieras empezando a entender al menos un poco de lo que puedes hacer
dentro de Unreal Algo de esto requerirá un
poco de repetición. Es posible que tengas que volver atrás
e intentar las cosas de nuevo, pero poder modificar e implementar estas
características por ti mismo es realmente el gran
primer obstáculo de aprendizaje que creo que mucha
gente se queda atascada Así que gracias por
seguirte en serio. Si has llegado hasta aquí, realmente
aprecio que dediques tu tiempo a
algo que he ayudado a crear Pero voy y sigo haciendo las cosas. Ese es todo
el punto aquí.