Transcripciones
1. Introducción al curso: Hola. Bienvenidos a
este curso de Unity. Soy Rome Faze, y he sido desarrollador
de juegos y
artista de tratados durante muchos años He enseñado a más de 9,000 estudiantes cómo desarrollar
juegos en Unity En este curso,
vamos a desarrollar un juego de shooter ferroviario afín al
miedo a la serie Talk Op o House
of the Death. Con más de 7 horas de contenido, este será un curso
completo con un juego completamente terminado
y pulido al final del curso. Voy a cubrir las
mejores prácticas del desarrollo de juegos de Unity, incluida la programación
orientada a objetos, como herencia
e interfaz, eventos, para la comunicación de scripts y dos posprocesamiento para
mejorar el aspecto del juego. Para estos proyectos,
voy a usar Unity 2019 0.2, pero cualquier versión de
2018 debería estar bien. Entonces, si eres un desarrollador de Unity y en ti mejoras tu habilidad, te lo pasarás genial
en este curso. Entonces, inscribirte hoy y
aprendamos juntos.
2. 01 Configuración del proyecto: Bien, así que vamos a crear
un nuevo proyecto. He lanzado el Unity Hub, y luego bajo el nuevo botón, voy a presionar el botón
desplegable aquí, y voy a elegir
la última versión que tengo instalada en mi PC, que es 2019 0.2. Puedes usar esto o
los anteriores deberían estar bien. Y luego una vez hay
crear nuevo proyecto. Ventana, voy a
seleccionar el proyecto de tres D y navegar por la ubicación. Y voy a llamar a este proyecto
virtual estilo Cp. Bien. Entonces voy a presionar crear y va
a iniciar la unidad. Y aquí vamos a importar un par de activos básicos que vamos a necesitar utilizar para
crear este proyecto. Ahora, entonces el proyecto ya
está abierto. Voy a ir a
la pestaña de iluminación, y si no tienes esto,
solo tienes que ir a la ventana y debajo de renderizar abre
una configuración de iluminación. Aquí voy a desactivar
la casilla de verificación de generación automática, para que no genere
el GI todo el tiempo Y queremos generar más tarde una vez que ya
armamos la escena. Lo siguiente que necesitamos
importar es el pro builder, y podemos importarlo
desde el gestor de paquetes. Es gratis de Unity. Entonces este tipo pro builder y si comprobamos el paquete
show preview, comenzará a
cargar el paquete. Una vez cargado, podemos
instalarlo. Ahí vas. Aquí tenemos pro builder, y luego solo instalamos esto. Ahora tenemos el
Pbiler instalado. Se puede ver que el
cambio instantáneo a un botón de quitar. Esto significa que ya lo
instalamos. Lo siguiente que necesitamos
instalar es el paquete pro grid. Vamos a escribir O son
los paquetes de carga. Voy a teclear la grilla. Ahí tienes, e instala esto
y esto hará que el ajuste sea más fácil en unidad
usando las rejillas pro Ahora, tenemos el
progreso instalado, y lo siguiente
que necesitamos
instalar es el postprocesamiento. Simplemente escribe post y
verás que
tenemos post procesamiento,
instala esto. Tenemos instalado el post
procesamiento, y ahora queremos cerrar esto, y vayamos a la tienda
Asset y
vamos a importar un par de
cosas de la tienda de activos. He abierto la pestaña de la
tienda de activos aquí. Actualmente está un poco rezagado. Ahora vamos a abrir la pestaña de la tienda de
activos, y si no tienes
esto, solo tienes que ir a la ventana y presionar
la tienda de activos. Una vez cargado,
queremos importar el robot espacial. Escriba de nuevo, robot espacial. Aquí, queremos
descargar este. Vamos a usar
esto para el enemigo. Después el
paquete de partículas de la unidad. Solo escribe pack de partículas
y ya verás eso, creo que este es el último. Solo seleccionemos este de aquí. Después hay una actualización, así que necesito actualizar este verso. Voy a pausar el video y continuar una vez que
terminemos de descargarlo. Ahora ya terminó de descargarse y voy a importar esto. Presiona importar porque aún no hemos establecido ninguna configuración del proyecto. Este es un proyecto nuevo,
por lo que debería estar bien. Simplemente instalemos y actualicemos las
dependencias del administrador de paquetes Ahora solo importa esto
y deberíamos estar bien. Ahora terminemos de descargar. Importa un par de cosas
también como Tex Mash pro, y podemos usar esto
también, así que es bueno. Ahora los otros activos que necesitamos descargar
es el creador de path. Esto es creado
por Sebastian leg. Lo siento si
pronuncié mal el nombre, pero esto es bastante poderoso y
es gratis crear un camino y podemos usar este
camino como el movimiento
para que el jugador se mueva
para que la cámara se mueva Solo descarguemos
esto y luego importemos. Hemos terminado de
importar la ruta crea, y ahora vamos a
crear una nueva carpeta, y vamos a llamar a este juego. Lo siento, voy a
renombrar esto, así que está en la parte superior
con guion bajo Voy a poner todos los activos del juego como
los
efectos de la partícula, el creador de
Pat, Robert Kyle, y esta carpeta de tres
dentro de la carpeta del juego. Está ordenado, no está disperso, y también podemos dirigir las escenas a esta carpeta
del juego aquí. Ahora que ya importamos
de los bienes que necesitamos. Voy a crear una nueva carpeta y vamos a
llamar a esta textura. Bien, a continuación, vamos a importar el mapa que he creado aquí y también la
textura de cuadrícula al proyecto aquí. Sólo secta de esto aquí y luego directo a
la textura más completa Ahí vas. Esto concluye
nuestro video de configuraciones de proyectos
3. 02 Modelado del entorno: Entonces ahora con las
escenas de muestra está abierta, primero
vamos a crear la guía
para nuestra escena. Para crear la guía, queremos crear un
nuevo objeto plano. Y esto debería tener
diez rejillas de ancho, creo, pero
al parecer es más grande Sólo, son diez. Son diez por diez, pero queremos aumentar el tamaño dz a 1.3, así es entonces y voy
a establecer el chasquido a la mitad, así y luego volver a uno y
establecer la posición y también a cero Ahora tenemos este plano aquí, podemos crear un nuevo material. Vamos a crear una
nueva carpeta de material. Debajo de las carpetas de material, vamos a crear nuevo material. Este será nuestro chico
y para la guía, queremos establecer la textura
albedo a
la textura del mapa que hemos importado y luego
dirigir este material Ahora tenemos una correcta
representación de nuestra C aquí. El camino varilla es de 13
unidades por diez unidades. Ahora vamos a crear una nueva
forma a partir del constructor profesional. Si no tienes
esta ventana aquí, solo ve a las herramientas
el pro builder y luego presiona la ventana
probable. Estará flotando
por defecto así, y podremos arrastrar el
nombre de la pestaña y luego ponerla además
del panel del proyecto. Ahora que tenemos esto y también cuando instalemos
el progrit, éste mostrará aquí los ajustes
del progrid, y podremos deshabilitar o
habilitar el También podemos cambiar el valor
del incremento de ajuste
usando el signo
negativo y el signo positivo en el teclado Voy a poner este 21 primero, pero si necesitamos esto, también
podemos hacerlo más pequeño. Lo siguiente que queremos
hacer es que queremos
crear una nueva forma. Presiona más además del
nuevo botón de forma aquí, y vamos a tener esto, y ahora queremos crear
esta caja primero aquí. Son cuatro por dos, y vamos a establecer este cuatro. No, perdón, debería ser dos
en la x y cuatro en la z. Vamos a poner esto
a tres en la y. Entonces es alto, es una pared, y luego presione construido. Ahora podemos posicionar esto
y luego moverlo hacia arriba. Ahí vas. Lo siguiente que queremos crear
es otro cubo aquí. Podemos poner esto en la z, pero aquí tenemos uno,
dos, tres, cuatro, cinco, seis, calzado
ser seis en los z xs Simplemente coloquemos
esto aquí y luego movamos esto hacia arriba. Ahí vas. Ahora necesitamos crear
otra forma, y esta debería ser
tres en el eje x y también seis en el eje z, y presionando construido, podemos insertar este objeto aquí y reposicionarlo en consecuencia Como pueden ver, he contado mal las cuadrículas aquí, está bien. En probilder, podemos
modificar el objeto aquí seleccionando el sub
objeto en la parte superior Entonces aquí está el vértice, y éste es el borde,
y esta es la fase En vértice, puedes
seleccionar los vértices, y luego puedes moverlo
. Se puede modificar. El mapeo UV se conformará, no
se estirará,
se expandirá. Entonces eso es bueno para
crear el nivel. Voy a usar esta selección de
fase y seleccionar esta fase aquí y luego
moverla una cuadrícula hacia un lado. Se ajusta correctamente
a nuestra guía de mapas. Ahora una vez que ya estamos
satisfechos con el dimensionamiento, podemos volver al
modo objeto selección de objetos, y ahora vamos a crear
otra forma. Y esto va a estar en la x, ¿cuántos es esto?
Tenemos que contar esto. Uno, dos, tres, cuatro, cinco, seis, siete,
debería ser siete en la x xs y luego en la z xs. Sí. Ahora voy a reposicionar esto y
luego mover esto hacia arriba. Necesitamos crear tres muros
más aquí. Vamos a crear nuevas formas. Esta calzada estará en la
x y otra en la z. y luego moverla hacia arriba,
y luego presione construir Vamos a crear otro. Pero esto está mal
en términos de tamaño así que voy a borrar ese, y luego voy a
crear este aquí, uno
pequeño, es uno por uno. Pero voy a establecer
el valor y en dos, así que voy a
presionar o ya está aquí. Ahora muévelo hacia arriba y luego
presione construido. Ahí vas. Agreguemos esto es tres b uno. Debería ser uno sobre
tres bajo el eje z, y podemos dos, está bien, y luego mover esto aquí, y luego moverlo Ahí tienes, tenemos la escena creada. Ahora el último objeto que
queremos encajar es el suelo. Vamos a crear el terreno, debería ser diez por 13 en la z, y voy a
cambiar el y20 0.1 Vamos a mover esto aquí, y voy a
establecer el valor y 20. Y voy a
alinear esto aquí. Ahí vas. Ahora
tenemos la escena aquí. Podemos simplemente ocultar la guía ya que no vamos a necesitar
esto por ahora. Lo siguiente que quiero
hacer es crear un nuevo material para
este objeto probilar Aquí voy a
crear un nuevo material, y voy a llamar a
este entorno grid. Voy a habilitar
el material de emisión. Aquí, solo usemos la
textura de cuadrícula que hemos creado, textura de cuadrícula en blanco y
negro. Verás que
tendremos un emisivo de blanco porque establecemos que el color de la
emisión es blanco, y podemos establecer el color base
a un probablemente azul oscuro Algo así, sí, y cambiar la grilla a
algo naranja. Con esta configuración,
verás que cuando
vayamos a usar el efecto de post
procesamiento más adelante, la línea estará brillando Ahora tenemos esto aquí. Simplemente apliquemos
esto al objeto. Voy a seleccionar
el editor de material, y después voy a asignar el material de ambiente aquí, y después voy
a aplicar esto. Ahí vas. Ahora tenemos una grilla de aspecto muy agradable
para el medio ambiente.
4. 03 Movimiento de la trayectoria de la cámara: Ahora, continuando desde
nuestro último video, ya
hemos creado
el entorno. Ahora vamos a empezar a crear el
movimiento de trayectoria para nuestra cámara. Aquí voy a volver a habilitar
nuestro avión guía aquí y luego moverlo un poco
hacia arriba para que podamos verlo. Todavía estamos usando Snap. Voy a reducir
el incremento aquí
presionando el signo negativo,
y luego mover esto hacia arriba. Ahí tienes, y luego vuelve a
poner esto en uno. Bien, así que primero, primero, tenemos que cambiar
la vista a vista superior aquí, y luego voy
a mover nuestra cámara a nuestra posición de inicio por aquí. Solo movamos esto
aquí y luego rotemos esto 180 grados
sobre el exceso, para que podamos ver nuestro nivel. Voy a
reposicionar esto a unos 11.5 metros
del suelo aquí Vamos a empujar esto 1.5 metros. Ahora esta es la
estatura promedio de un adulto, o podemos
aumentarla a 1.7 si queremos. Y aquí se puede ver esta
es, la primera vista aquí. Y ahora necesitamos
crear el camino. Para crear la ruta, primero
necesitamos crear un objeto de dar
vacío. Solo reorganicemos
la escena aquí. Voy a resetear este de aquí y voy a llamar a
este entorno. Y voy a poner todo el cubo que hemos creado
por el pro builder,
el ambiente para ser el hijo
de este objeto de juego aquí. Entonces podemos colapsar
esto y
cambiemos el nombre del avión
a la guía del mapa. Llamemos a esta
guía de mapa de objetos, así que es mucho más claro. Y ahora vamos a crear
otro objeto anti juego, y este será el
camino de nuestra cámara. Podemos ajustar la posición, la posición de inicio aquí.
Y probablemente aquí. Ahora necesitamos agregar un componente creador de
ruta. Una vez que hemos creado esto,
ves que tenemos un nuevo camino. Ahora vamos a ir a la
parte superior de la vista aquí y luego seleccionar el nodo de la ruta y podemos mover este
camino aquí como se puede ver. Voy a mover la cámara
desde esta posición aquí, y luego voy a
ajustar los mangos y a extra esto
podemos mantener turno, y luego podemos sumar puntos entre nuestros dos puntos
iniciales aquí. En el camino, podemos mantener el turno, y luego podemos pulsar el
botón izquierdo para crear un nuevo punto. Voy a ajustar
esta posición aquí. Voy a mover esto
a nuestra última posición, y luego voy
a insertar un punto en medio y luego
ponerlo en consecuencia, así y luego agregar
un nuevo punto aquí, y luego lo voy
a poner aquí. Para que podamos ajustar
el control de Bézier. Y vamos a poner esto aquí. Para el último punto, solo
podemos acercar el zoom y
luego arrastrar el baser. Está encarando de esa
manera, y esta está enfrentando de esta manera y ésta
debería estar enfrentando de esta manera. Podemos ajustar la
curva más tarde cuando
empecemos a mover nuestra cámara
a lo largo de esa línea aquí. Ahora bien, si voy a la vista frontal al eje z sobre la vista aquí, voy a poner esto
a una vista isométrica, y luego voy a
alinear nuestro punto aquí Solo movamos esto un poco aquí
arriba y también éste, voy a mover esto ligeramente por encima de su posición
anterior, y luego voy a realinear el bezier y mover
este también Y esta última
esta posición aquí. Esto debería hacer por ahora, pero siempre podemos
ajustar el camino más adelante. Sólo vamos a guardar esto. Ahora que hemos creado el camino aquí. Vamos a la
carpeta del juego y creamos una nueva carpeta llamada scripts. Y vamos a empezar a crear los guiones para
el movimiento de la cámara. Abre la carpeta de scripts
y voy a crear un nuevo guión CHR, y voy a llamar a
este movimiento de cámara o probablemente jugador
Mover sería más adecuado esto porque la
cámara es nuestro jugador, el sitio de nuestro jugador o
la división de nuestro jugador. Una vez que haya creado el script de
Player Mo, voy a abrir esto en Visual Studio y comenzar a
crear el script para ello. Bien. Déjame simplemente
aumentar el tamaño primero. Bien. Ahora para tener acceso al componente path
que hemos creado aquí, el objeto creador de path, voy a cambiar
el nombre de
este objeto voy a cambiar
el nombre de
juego de movimiento de trayectoria de cámara antes. Para tener acceso
a este componente aquí, necesitamos ing el espacio de nombres del
creador de ruta Vamos a la creación de caminos. Entonces aquí, podemos crear una variable de campo serie y el tipo será
el creador de ruta, y este será nuestro camino. También voy a crear una
nueva instrucción de fin de ruta, y este debería ser el campo de
fin de ruta. Y podemos ajustar esto
ya sea para parar o para loop o Ping Pong si queremos crear un tipo diferente de fin
de instrucciones pasadas. También voy a crear un nuevo campo celular y este
será un tipo de flotador, y este será el
movimiento de velocidad de nuestra cámara. Por ahora, voy a establecer esto tres como valor predeterminado. Otro campo que necesitamos
crear es un flotador privado, y llamémoslo a
este recorrido a distancia. Para usar el creador de path, realidad
es bastante fácil. Primero podemos establecer el
nivel de distancia al movimiento de nuestro camino, y podemos modificarlo con nuestro valor de velocidad y
multiplicarlo por tiempo Delta tiempo. El incremento
del valor será consistente independientemente
del fotograma por segundo. Actualmente, nuestro juego se ejecuta
en una máquina específica. Si el FVS es bajo, tendrá la misma velocidad PC potente que
tenga
un FVS más alto Y ahora vamos
a usar este valor aquí a un método que
pertenece al creador del camino. Voy a acceder a la posición
de transformación de nuestro objeto de juego, que es el jugador que se mueve aquí. Sólo podemos acceder
al camino doth. Tiene una trayectoria tecnológica
propiedades o campo. Y aquí podemos conseguir
vamos a utilizar el punto
get a distancia. Y aquí vamos a pasar la distancia
distancia ravel Para las instrucciones de fin de
ruta, vamos a usar la variable end of path que
hemos preparado aquí. También, queremos asignar la rotación de acuerdo
a la trayectoria, y podemos obtener su rotación a distancia y también más allá
del nivel de distancia. Seguridad. Ahora ves que una vez que le pongamos el
guión a la cámara, ésta modificará la posición en
función de la distancia revelada. Y la distancia
recorrida cambiará con el tiempo en función de
nuestra velocidad aquí. Nos vamos a mover a
través del camino. A salvo esto, y
volvamos a la unidad. Y para la cámara principal, voy a agregar este
jugador mover aquí guión, y voy a configurar esto para que se detenga, el final de camino,
y vamos
a dk el
creador de ruta objeto de juego aquí a la ranura aquí a la ranura de ruta en
el jugador se mueve. Vamos a guardar las escenas y
voy a presionar play y ver si esto funciona o
no. Ahí vas. Está funcionando, pero las
rotaciones están equivocadas, así que podemos ajustar la rotación Ahora bien, si vamos a la trayectoria de movimiento de la
cámara aquí, podemos expandir la normal y verás que el
factor está encarando de esa manera. Voy a cambiar el ángulo
global 90 grados, el factor arriba está mirando hacia arriba, y de esta manera tendremos
la rotación correcta. Cambiemos la
velocidad a alrededor de 1.5. Actualmente es demasiado rápido. Vamos a darle una oportunidad de
nuevo. Ahí vas. Como pueden ver, Pero
hay una cosa. Actualmente, parte
de esta posición. Comienza desde este punto
aquí y vuelve
al primero.
Tenemos que voltear eso. Termino
reordenando los nodos de ruta aquí y cambio el primero aquí a esta posición aquí y reordeno la posición en
base a sus guías Ahora bien, si presiono play,
verán que
aquí
pararemos desde esta posición. Ahí vas. Comienza desde aquí y
ahora mismo sigue moviéndose, pero más adelante vamos a
agregar un mecanismo donde podamos detenernos en cierta posición y luego volver a movernos después de eso. Bien. Ahora bien, si
volvemos a abrir nuestro script aquí, necesitamos crear un
par de campos aquí. Solo vamos a crear un nuevo campo s, y este
sería un tipo de bleion, y voy a llamar a
esto se mueve y se
va a establecer
cae por defecto Y aquí dentro de la actualización, voy a crear una comprobación
nula de nuestro camino. Si nuestro camino no es nulo
y mover el movimiento es cierto. Queremos establecer estos
dos verdaderos por defecto. Si la
variable is moving es true, entonces queremos ejecutar
este código aquí. Vamos a copiar todo
esto aquí y ponerlo aquí. Hay un truco pulcro
que podemos ajustar aquí. Podemos crear alguna variable de
depuración, así que voy a crear un
nuevo encabezado de atributo y voy a llamar a
esta opción de depuración. Y voy a
crear un nuevo campo Sus y este será un flotador, y vamos a llamar a
esta distancia de previsualización y establecer este valor predeterminado 20. Podemos usar la función incorporada
o método de unidad
llamada fecha válida. Vamos a escribir fid fecha válida. Básicamente, lo que
está haciendo este método es cada vez que
cambiamos un campo o una
variable en nuestro inspector, este método se ejecuta. Simplemente agreguemos otro campo
sus llamado Bullion, y llamemos a
esto enable debug Y queremos comprobar si
habilitar el error es verdadero, entonces queremos establecer su posición y
rotación a la ruta. Pero en lugar de usar
el nivel de distancia, queremos usar el valor de
distancia de vista previa aquí. De esta manera, nos será más fácil comprobar a
qué distancia, queremos establecer el
primer encuentro enemigo y el segundo
y el tercero. Ahora si guardamos esto, este trabajo. Así que volvamos a la unidad, y si vamos a la vista del
juego aquí, puedes ver que si
selecciono la cámara aquí y he habilitado
el bug, ahí tienes. Una vez que habilito el error D, válido se ejecuta y nuestra posición se establece en la distancia de
previsualización a cero, y si froto esto,
ves que podemos mover esto. Este es un truco bastante aseado para ajustar y ahora
podemos ver que, si queremos esta posición, entonces podemos usar este
valor aquí, 9.54 Voy a poner esto de nuevo
a cero y desactivar el error. Ahora que tenemos esta variable bulion se mueve,
si presiono play, verás
que si desmarca esto, se detendrá, y
si comprobamos esto, irá avanzando Si volvemos a desmarcar esto, se detendrá y se moverá Vamos a usar esto
siempre que nos encontremos con un enemigo.
5. 04 Creación de un punto de disparo: Bien, ahora en este video, vamos a crear
un punto de rodaje donde podamos definir un área
para que un enemigo embosque y también comparar la
distancia en ese punto para que nuestra cámara pueda detenerse en
ese punto de área de disparo Entonces primero, vamos a crear un nuevo guión de tiro en
la carpeta de scripts, y luego voy a
llamar a este punto de rodaje. Y vamos a crear
dos nuevas propiedades, no una variable,
sino una propiedades. Y permítanme simplemente aumentar
el tamaño del texto aquí. Y ahora primero vamos a crear un nuevo bulion privado
para área clara Y esto sería una brecha, pero con un conjunto privado. Entonces las propiedades solo se pueden
configurar con esta clase aquí, pero podemos obtener el valor de otra clase que
necesita este valor aquí. Entonces hay un error. Sí, necesito
asegurarme de que esto sea
público, no privado. Entonces debería ser público, para que podamos obtener este valor, pero para establecer este valor, aquí
deberíamos ser privados. Y también queremos crear unas propiedades para hacer referencia
al movimiento del jugador Así que vamos a crear un
nuevo movimiento de jugador público, y vamos a establecer
esto para que se establezca. Lo siento. Tenemos que definir un nombre, así que voy a llamar a
este jugador movida. Bien. Y ahora queremos
crear un nuevo método público para inicializar esta clase para
que pueda tener una referencia
al objeto player move Vamos a crear un nuevo vacío
público inicializar. Y queremos pasar
una jugada de jugador. Podemos simplemente llamar a
este valor aquí. En esta clase, podemos simplemente establecer el movimiento del jugador a
este valor aquí. Hagamos que este jugador
se mueva a una variable. Quizás sea mejor
hacer esto como una variable como una variable
privada local. Y necesitamos cambiar
la P a una minúscula, porque aquí cambiamos
el nombre. Y vamos a
eliminar el método start. Ahora vamos a crear una declaración if
para probar esto. Vamos a crear un
nuevo evento de pulsación de teclas, bajar la tecla y usar barra espaciadora para detener el
movimiento del jugador Pero para hacer eso, necesitamos crear primero un método
público para acceder a eso. Vamos a crear un nuevo método llamado set player movement. Y esto va
a ser un Bulion, y llamemos a esto
enable para el argumento Y vamos a pasar esto
al valor as movimiento b aquí. Vamos a establecer access
the as moving y luego asignemos el valor
enable aquí. Ahora podemos usar ese
método para hacer una pausa. Vamos a poner el
movimiento dos caídas aquí. Entonces para volver a
movernos, solo podemos crear un nuevo
evento, y esta vez, podemos usar una tecla return o enter para configurar la
cámara para que se mueva de nuevo. Ahora volvamos a
pagador muévete aquí y
vamos a crear
un nuevo ser fiel Y esto es para el punto de
rodaje. Primero, necesitamos crear una
nueva clase pública aquí abajo. Esto sólo va a
ser una clase personalizada que vamos a utilizar para
divinar una variable personalizada. Vamos a usar el atributo
serializable del sistema y
luego crear la nueva clase Voy a llamar a
este tiroteo tres. Y tendrá dos campos. El primero debería
ser el punto de tiroteo. Simplemente llamemos a este punto de
tiroteo. El segundo
sería la distancia y este será
el tipo de flotador. Esta será la
distancia que
necesitamos comparar cada vez que el jugador se mueva o la cámara esté llegando a esta
distancia en el camino. Entonces queremos
iniciar la balacera. Vamos a crear una nueva matriz de entrada
para disparar. Y voy a llamar a
este rodaje entradas. Con este campo aquí, podemos poner el
punto de rodaje dentro de esta matriz aquí. Volvamos a Unity, y aquí, voy a
volver a la vista en perspectiva, y luego vamos a crear
un nuevo objeto de juego T, y este sería el manager de shoot
out o no manager, pero podemos simplemente llamar a este grupo. Entonces vamos a crear un nuevo Mt. Podemos posicionar este vacío en cualquier lugar.
Realmente no importa. Solo agreguemos un punto de
rodaje. Aquí ahora no
tenemos ningún valor, pero vamos a
modificar esto más adelante. En el objeto de juego de cámara, ahora tenemos estos
nuevos campos aquí. Voy a agregar un nuevo tamaño y luego poner
el punto de disparar. Aquí. Y aún no hemos establecido la
distancia, pero está bien. Y vamos a renombrar
el objeto del juego que tiene
aquí este script. Dispara 0.1. Y ahora guarda esto.
Y ahora actualmente, aún no funcionará
porque necesitamos
agregar un nuevo código de inicialización
dentro del movimiento del jugador Así podemos asignar podemos asignar la instancia
de nuestro jugador mover a esta variable aquí. Así podemos establecer el movimiento del jugador con
este código ficticio aquí Así que vamos a acceder a la colección de entradas de
rodaje. Lo siento, la
colección de entradas de rodaje aquí matriz. Y luego voy a llamar
a los miembros individuales entrada, y vamos a acceder a la
entrada, disparar punto, inicializar, y luego pasar esta clase aquí como
el valor aquí Entonces solo escribe esto. Entonces, lo que está haciendo
este código es básicamente, vamos a mirar
hacia fuera las entradas de rodaje, y por cada entrada dentro de
estas entradas de tiroteo, vamos a inicializar el punto de rodaje pasando esta clase aquí
al método aquí Bien. Entonces ahora si
volvemos a Unity, intentemos jugar esto
y ahora si presiono espacio, ves que se detiene y luego si
presiono return,
empieza a moverse otra vez. Lo siguiente que
tenemos que hacer es, queremos establecer
el movimiento del jugador para que el movimiento del jugador detenga en cada punto de tiroteo en
función de su distancia Básicamente, lo que
queremos hacer es, queremos crear un
bucle de cuatro aquí y queremos recorrer la
longitud de las entradas de
tiroteo Y ahora vamos a comparar la distancia con
ciertas entradas de tiro, y solo podemos acceder a
la trayectoria del objeto path, y luego obtener punto a distancia, y luego queremos
pasar la distancia aquí, la distancia de entrada de tiro. Sólo vamos a acceder al índice de entradas de
rodaje de I, y luego a la distancia. Y queremos restar esto porque esto va
a devolver un vector te, queremos restar esto con nuestra
posición de transformación carn de la cámara Cerremos esto con un conjunto
de paréntesis para que podamos obtener su distancia o su
magnitud de estos dos vectores Para magnitud, podemos usar
magnitud o magnitud cuadrada. Para un mejor rendimiento,
recomendaría usar la magnitud
cuadrada porque no
tendremos ninguna operación de raíz
cuadrada con la magnitud cuadrada. Y como no necesitamos
una distancia precisa, podemos usar la magnitud cuadrada, y simplemente verificar esta distancia entre la cámara
a la distancia, dos valor muy pequeño. Significa que hemos llegado
a este punto aquí, y si llegamos,
queremos detener la cámara. Entonces ahora queremos comprobar si
las entradas para disparar, perdón, disparar entradas, disparar
área de punto es clara, y si está claro, entonces
queremos regresar. Y
aquí vamos a
cambiar el togal o el valor bleion cuando acabemos derrotar a todos los enemigos
en el punto de tiroteo Y ahora queremos comprobar si se está moviendo actualmente,
entonces queremos parar. Vamos a acceder de nuevo a las entradas de
rodaje, al punto de rodaje, y luego
vamos a crear un nuevo
método para este de aquí. Vamos a crear un nuevo método, y este es un método público. Empezar a disparar. Y ahora vamos a poner
las dos caídas aquí. Simplemente llamemos al método
start shoot out. Para probar, solo
podemos agregar un área clara verdadera aquí dentro de la
clave. Regresar obtener llave abajo. Vamos a establecer esto
para probar esto. Si volvemos ahora a la unidad, aquí bajo la cámara principal. Ves que tenemos una distancia, y podemos cambiar esto. Para probar esto, podemos simplemente habilitar el
valor de depuración aquí y luego establecer la distancia de vista previa a algún valor
determinado que
queremos detener. La primera posición que queremos que pare
la cámara es alrededor de
esta zona verde de aquí. Son 3.15. Vamos a establecer
la distancia en 3.15, y vamos a crear un nuevo punto de
rodaje
duplicando este de aquí Vamos a llamar a
esta sesión al 0.2. Y seleccionando la cámara principal, queremos agregar este punto de
rodaje, el segundo punto de rodaje
al segundo miembro de la matriz de entradas de rodaje.
Solo dirijamos esto. Para éste, vamos
a correr esto y queremos
detenernos en este punto aquí. Podemos simplemente copiar este valor aquí y luego pegar
al segundo punto aquí. Ahora vamos a poner esto de
nuevo a cero y desactivar
el habilitar el total de dólares
y guardar la escena de nuevo. Ahora si pulsamos play, Verás que se detendrá, se detendrá en este punto aquí, y luego si presionamos enter, comenzará a moverse de
nuevo, y luego se detendrá en el
siguiente punto aquí. Lo siento. Encontré el problema. No es la distancia aquí, pero he establecido esto
en 0.0 0.01 de todos modos. Y es porque
este método de actualización, cada vez que presionamos return, despejaba el área para ambos
puntos de tiroteo. Tenemos que
asegurarnos de que tenemos un bulion para verificar si este es el punto de
lanzamiento activo o no Vamos a crear un nuevo punto activo de lingotes
privados, llamemos a este punto activo y esto será
falso por defecto Si iniciamos un tiroteo, entonces queremos que esto sea cierto. Entonces cada vez que
presionamos return, queremos poner esto de
nuevo en false. Y queremos
asegurarnos de que solo podemos presionar return siempre que el punto
activo sea verdadero. Solo agreguemos una condición N y luego agreguemos el punto activo Bulan De esta manera, cada vez que presionamos return y es
el punto activo, entonces queremos establecer este movimiento y luego volver a establecer el punto
activo en false. Ahora volvamos a
Unity y probemos esto. Ahora es parar aquí, y si presionamos return, se mueve de nuevo, y luego se detendrá en
el segundo punto. Ahí vas, y si presionas
enter, se moverá de nuevo. La lógica básicamente que
queremos hacer es que queremos
establecer un contador y el número de enemigos por cada punto de
tiroteo, y cada vez que matamos,
derrotamos a todos los enemigos,
entonces queremos dejar despejada derrotamos a todos los enemigos, el área Eso lo vamos a hacer
en el siguiente video.
6. 05 Mecanismo de disparo básico: En este video, antes de que
sigamos disparando punto, necesitamos
asegurarnos de que creamos un mecanismo de disparo
para el jugador. Para hacer eso, vamos a
crear un nuevo guión, y llamemos a este guión de
jugador. A continuación, vamos a crear una interfaz un script de interfaz para crear un
método básico para el objeto hable. Vamos a crear
una nueva carpeta y vamos a esta interfaz. Y voy a crear
un nuevo guión C sharp, y voy a llamar a
esto me hittable Básicamente, para la
práctica estándar en C sharp, interfaz, nombramos la clase con un I delante del nombre de
la clase aquí. Interfaz capaz. Y
vamos a quitar toda la ONU aquí y no
va a ser un comportamiento mudo, y tampoco
va a ser una clase, sino que va a
ser una interfaz Y queremos
eliminar también este método aquí. Y básicamente la interfaz es un contrato básico para que otro
script implemente un método. Entonces, por ejemplo, podemos
declarar un nombre de método y todas las demás arcillas que implementan esta interfaz necesitan
implementar ese método Por ejemplo, vamos a crear
un nuevo método llamado él. Y básicamente, si
creamos un nuevo script, por
ejemplo, si volvemos
a UT aquí, y vamos a crear vamos a
crear un nuevo script SSH, y llamemos a esto objetos
dinámicos dinámicos L et abre este guión aquí. Y podemos hacer que este objeto implemente el hit capaz
agregando una coma después comportamiento
mono y luego escriba la interfaz que
queremos implementar Ahora nos dio un error
porque nuestra clase aquí no implementa el hit
miembro de la interfaz . Tenemos que hacer eso. Pero antes voy a
implementar el método hit, lo
voy a modificar y para el hit, va a pedir un objeto
para el argumento. Vamos a llamar a esto
hit. Y la seguridad. Ahora bien, si está
utilizando Psal Studio, puede simplemente resaltar la interfaz en
la
clase de objetos dinámicos y luego presionar show potential fix y luego
implementar la interfaz Verás que implementará
automáticamente el método que son
declarados por la interfaz. Simplemente eliminemos esto aquí, y ahora podemos hacer
cualquier cosa con él. Por ejemplo, si acabo de
borrar el método incorporado, y vamos a crear un nuevo RB de cuerpo rígido
privado y podemos simplemente inicializar
el cuerpo rígido al inicio Vamos a comprobar si obtener componente rígido del cuerpo es no, Entonces nosotros uno para crear uno nuevo. O tal vez será
mejor si tratamos de agarrar. Vamos a poner aquí el cuerpo rígido del
componente get dentro de esta variable. Vamos a duplicar esto
y luego pegarlo aquí. Ahora podemos comprobar si el RB es, entonces queremos crearle
un nuevo cuerpo rígido. Vamos a escribir RB objeto de juego
igual. Creo que es en el componente cuerpo
rígido. Ahí vas. De esta manera, se asegurará de que cualquier objeto que esté usando esta clase va a
tener un cuerpo rígido en ella. Ahora cada vez que nos golpean, siempre
podemos aplicar una
fuerza al cuerpo rígido. Por ejemplo, podemos simplemente
escribir cuerpo rígido a la fuerza, y podemos obtener el vector
de la información ca it, y la información de golpe cas
tiene mucha información. Por ejemplo, podemos agarrar la normal y luego podemos inversar la normal y luego multiplicar por algún valor 50 aquí o un 100. Esto va a ser un básico, y por
supuesto,
vamos a modificar esto. Volvamos a la unidad, y luego abramos nuestro archivo de scripts de
reproductor aquí. En este guión, queremos
crear un mecanismo donde
podamos disparar a un
objeto de nuestra escena. Dado que el guión del reproductor
va a estar unido a
la cámara, podemos crear una nueva variable de cámara
privada y agarrar el componente de la cámara. Vamos a crear una nueva variable de
cámara llamada CM. Al inicio, siempre podemos simplemente
usar la cámara de componentes GT. Y guárdala. Lo siguiente que tenemos que hacer es asegurarnos de que cada vez que el mouse esté haciendo clic en
el botón izquierdo, baje el botón del mouse, y el botón izquierdo sea cero. Uno es para el botón derecho, y dos es para el botón del
medio. Cada vez que hacemos clic con el clic
izquierdo del ratón, entonces queremos
crear un nuevo y cast. Vamos a escribir ray, y
esto es objeto objeto ray, y vamos a llamar a este rayo. Y esta será
una cámara para cámara. Tengo un método, que es pantalla 0.2 ray, y esto es básicamente va a
disparar rayo desde un punto de pantalla. Para el punto de pantalla,
vamos a poner la posición del mouse
input position mouse position. Ahí vas. Ahora siempre
podemos intentar probar el rayo usando
el elenco de rayos físicos. Tiene muchas anulaciones,
como puedes ver aquí. Vamos a usar este, creo, éste. Si, esta,
podemos usar esta. Entonces básicamente, queremos
pasar el rayo y queremos sacar
los RCA hit info Entonces necesitamos crear
un nuevo cs aquí. Vamos a crear un hit de Cas.
Vamos a llamar a esto hit. Y podemos pasar
el valor para golpear. Entonces, cualquiera que sea el hit ras
resultante será seguro para
esta variable hit, y podemos pasar esto
a la otra clase. Eso necesita esa información. Y creo que lo siguiente
será la distancia máxima. Sólo pongamos 50 unidades. Y si golpea algo, entonces se ejecutará el código dentro de la
sentencia if. Vamos a crear un
nuevo objeto benéfico. Lo siento. Tenemos que asegurarnos primero no se conozca
el colisionador Vamos a crear una nueva declaración I
y aquí queremos comprobar si la variable hit
o el objeto hit tiene un
colisionador unido a ella Entonces, si golpea algo,
debería tener un colisionador. No es nulo, entonces queremos agarrar el
objeto hittable si está disponible Vamos a crear un nuevo hit de i hit,
llamemos a esto hitable Entonces voy a
agarrar del golpe,
conseguir golpe colisionador, obtener componente, y aquí podemos
agarrar el i hable. Ahí vas.
Vamos a comprobar esto de nuevo si itable no es nulo, entonces queremos ejecutar
el método hit aquí, y luego pasar la información del
cast hit. También podemos imprimir su nombre ejecutando el comando debug log y pasar el nombre del punto del objeto del
juego collider Bien guarda esto, y ahora podemos
adjuntar esto a nuestra cámara. Volvamos a Unity, y si seleccionamos
la cámara aquí, podemos agregar el componente de
script del reproductor, y para probarlo, vamos a crear
un nuevo cubo aquí. Voy a crear
un nuevo cubo normal. Probablemente voy a ponerlo
aquí o aquí en el medio. Y ponlo encima aquí, y agreguemos el script de objeto
dinámico. Vamos a guardar esto y
vamos a darle una oportunidad. Y abramos nuestra consola aquí. Si hago clic aquí, verán que aquí estamos golpeando
este cubo. Y si yo, como el nombre del
objeto es el mismo, el bloqueo de depuración es colapsar. Entonces llamemos a esta caja, esta de aquí, y guardemos esto. Y ahora ya verán que
si tiro esta caja aquí, se mueve porque tenemos esto
Tenemos esto ¿dónde está? Porque tenemos esto en un primer
comentario sobre nuestro método de aciertos. Básicamente, este
script comprobará si el objeto que es
golpeado por nuestro Cs, ¿tiene un componente hit o alguna clase que implemente interfaz
hitable Y si no es nulo, si está disponible
o si el objeto tiene una interfaz hablable
unida a él, entonces queremos ejecutar
el método hit. Y podemos implementar esto de cualquier
manera que queramos. Para enemigo, podemos
poner la salud. Podemos disminuir la
salud dentro del golpe. La interfaz del método
es bastante potente. Y así es como hacemos el mecanismo
básico de disparo. Y claro, vamos
a ampliar este mecanismo.
7. 06 Configuración inicial del enemigo: Hola, en este video,
vamos a continuar con
nuestro proyecto, y vamos a crear el mecanismo básico simple
enemigo, y claro, vamos
a ampliar ese mecanismo. Primero, vamos a
borrar la casilla aquí. Ya no necesitamos eso. Y necesitamos definir
el área de malla NAF. Para ello, podemos
ir a la ventana debajo de la IA, clic en el menú de navegación, y se abrirá este panel de
navegación. Y aquí bajo el horneado, primero por el medio ambiente, queremos poner a
estos dos una estática. Solo habilitemos la estática y luego, cambiemos a los niños. Ahora una vez que cambiemos
esto a estático, si vamos a navegación, podemos presionar el botón grande
y luego horneará nuestra área aquí. Ahí vas. Como podemos ver,
tenemos un área aquí, pero en esta posición, Aquí
hay un problema porque
vamos a necesitar que el enemigo se esconda de esta zona aquí, y no tenemos matemáticas de
navegación. Tenemos que disminuir el
radio aquí a tal vez 0.3. Tenemos un tamaño de
agente más pequeño y lo
tendrá creará más área
para el área de malla N la N. Vamos a crear bolsa de
nuevo y ver si. Como puedes ver aquí,
ahora tenemos malla NAF
dentro de esta y está
conectada aquí. Es mejor. Podemos crear a partir de esta posición y luego podrá
trasladarse a una determinada posición fuera
de este pasillo o callejón Una vez que ya
creamos la malla NF, si volvemos al inspector, esta
malla de navegación azul se oculta. Lo siguiente que queremos
hacer es que voy a crear una nueva cápsula Para el enemigo, voy a crear un
nuevo objeto cápsula, y este será el enemigo. Y estar al tanto de la
dirección de la cápsula. Voy a agregar otro objeto cubo de
tres d, y voy a
hacer esto más pequeño, así y luego mover
esto al frente aquí. Entonces sabemos cuáles son actualmente la cápsula que
se enfrenta ahora mismo. Sí, vamos a la iluminación aquí y quiero
desactivar el ato generar. Por lo que no genera
la iluminación cada vez y guarda la escena. Este va a ser el enemigo. Simplemente llamemos a este enemigo. Primero, necesitamos agregar un agente de malla de
navegación, y también un cuerpo rígido. Dado que este objeto
se va a mover, también
necesitamos
asignar cuerpo rígido. Pero si no necesitamos las interacciones físicas o
el cálculo de
la dinámica
a este objeto, solo
podemos desactivar
el uso de la gravedad y luego habilitar
la es cinemática Bien. Ahora cambiemos el radio del desorden de
navegación a 0.3, así que es lo mismo con nuestra configuración de malla de
navegación. Para la cápsula,
voy a cambiar también el radio del
colisionador de cápsulas a alrededor de 0.3 también Ahora tenemos al enemigo. Lo siguiente que tenemos que
hacer es crear un
nuevo guión para el enemigo. Vamos a crear
un nuevo guión de Shop, y luego llamemos a este
guión enemigo. Vamos a abrir esto. Ahora hay un par de variables que necesitamos definir
para este guión enemigo. Primero, necesitamos un campo
serializado, y este debe ser entero, y llamemos a esto Mx salud Esto es para definir
la salud máxima. Entonces
también vamos a agregar un
entero privado y esta será la salud real o
la salud actual que usemos para calcular
la salud del enemigo. Entonces también necesitamos un tipo de transformación de
campo serializado, y esta será la posición
objetivo Y la posición objetivo es donde el enemigo va
a reposicionarse
o moverse después de que salió del escondite o de
la posición o moverse después de que salió del escondite o de de
emboscada La otra cosa
a la que debemos tener acceso es a la
transformación del jugador. Vamos a crear una nueva variable de transformación
privada, y llamemos a este jugador, y también necesitamos una variable
bleion, y esto es para alternar si el enemigo
ya está muerto o no, y el último será un componente de agente de malla
NF Pero si puedes ver aquí, no
se muestra en el out
completo porque necesitas usar la unidad de
motor AI. Si destacamos la clase aquí y
luego mostramos la solución potencial. Tendremos una
opción para agregar esto. Yo solo voy a
hacer clic en esto y también se
agregará automáticamente en el script, y voy a
llamar a este Agente. Vamos a crear un nuevo método de
inicialización, y este va a
ser un método público Vamos a llamar a esto en él. Otra cosa que
necesitamos crear, se me olvidó, necesitamos tener una referencia
al punto de rodaje. Vamos a crear un punto de lanzamiento
variable U. Ahora en el init, vamos a pasar el punto de tiroteo y
simplemente llamar a este punto Vamos a asignar aquí el
punto de valor que pasamos como parámetro al punto de
tiroteo. Bien. Ahora vamos a
agarrar al jugador,
también el agente de malla NF. Vamos a escribir agente igual
obtener componente NF agente de malla. Para el jugador, solo podemos obtener la clase de cámara y luego obtener la cámara principal y
obtener la transformación. Ahí vas. Tenemos
la transformación del jugador. Dentro de la actualización, también
queremos asegurarnos de que el enemigo también
siempre nos enfrentemos al jugador. Vamos a comprobarlo. Dentro de la actualización, queremos
comprobar si el jugador no es nulo, y si el enemigo
tampoco está muerto actualmente, entonces queremos enfrentarnos al jugador. Para enfrentar al jugador, vamos a crear
un nuevo factor tres, y llamemos solo a esta
dirección, y para dirección, será el jugador
esa posición, sustraer con nuestra posición enemiga,
posición actual Entonces voy a poner a
cero el valor y. La rotación será estrictamente
en el plano x y z, y podemos establecer la rotación de
transformación,
rotación a un cuaternión mirar
rotación en la Ahora dentro del método init, también
vamos a agregar el
destino para el agente Comprobemos esto
si el agente no lo es. Entonces queremos establecer
el destino a nuestra posición objetivo. Posición objetivo. Queremos agarrar la posición objetivo como destino para el agente. Otra cosa que
necesitamos para asegurarnos de que
necesitamos desactivar la
rotación del agente, el componente me agent
no impulsa la rotación. que ya manejamos la rotación nosotros mismos dentro
del método Pate aquí Vamos a agregar código aquí, Rotación de
agente y
establecer esto en falle Esto es básicamente
ignoraremos la rotación, y también vamos a
crear un método hit y necesitamos implementar
la interfaz hittable Ahora una vez que haya implementado esta interfaz, verás
que tenemos un error, así que voy a hacer clic en el show potential fixes y luego
implementar la interfaz, y automáticamente
implementará la interfaz aquí. Ahora mismo, podemos simplemente
restar la salud actual, pero tenemos que
inicializar esto Dentro del init, vamos a poner la salud actual
a la salud Mx I. Y entonces
podemos restar el
estado actual en el método hat, y también imprimir un
mensaje de registro a la consola, estoy cerrado y si el estado actual es
menor o igual cero, entonces queremos habilitar
el s es ese bulto true, y también queremos deshabilitar el componente agente
establecido Otra cosa que
tenemos que hacer es, tenemos que asegurarnos de que si eso es cierto entonces queremos
devolver este método, que no ejecute ninguno
de los códigos aquí abajo. La otra cosa que
tenemos que montar es, creo que eso sería todo. Vamos a darle
una oportunidad y tenemos que hacer un par de modificaciones
en el punto de tiroteo. Sólo vamos al punto
de tiroteo. Ahora necesitamos crear
entradas enemigas. Voy a crear una clase
personalizada aquí afuera, y voy a agregarle un atributo
serializable del sistema y llamar a esta
clase pública entrada enemiga Y esta es una clase personalizada, por lo que no necesita
derivar del comportamiento mono. Voy a crear un nuevo guión enemigo
público, el enemigo. Entonces para el otro valor, sería un retardo flotante, y este es el
retraso en segundos. Cuánto tiempo necesitaremos
para que aparezca este enemigo. Ahora vamos a agregar
un nuevo campo serializado, y esta será la matriz de entrada
enemiga, y llamemos a
esta lista de enemigos Y vamos a crear una nueva corrutina para
desovar a este enemigo aquí Vamos a crear un nuevo método enumerador
i que devuelve el tipo enumerador Simplemente llamemos a
esto enviar enemigos. Y dentro del cotin aquí, queremos mirar a través de la colección de listas de
enemigos aquí Solo escribamos
para la variable, será el enemigo y
dentro de la colección de
listas de enemigos. Aquí, vamos a agregar un yield return nuevo
peso por segundos, y aquí vamos a pasar
el retraso enemigo. Esta es la demora
que declaramos en la entrada enemiga aquí. Y después de retrasar la ejecución del
código aquí, queremos acceder al enemigo
que el enemigo inicializa Entonces cuando se inicialice, iniciará el
enemigo para
que se mueva aquí, como pueden ver aquí,
una vez que inicialicemos, establecerá el destino
para el agente enemigo del NMS Entonces el enemigo iniciará movimientos. Pero tenemos que pasar
el punto de tiroteo. Vamos a pasar
aquí
este punto de tiroteo con la palabra clave dis Si queremos, podemos simplemente también depurar el nombre del objeto
enemigo. Vamos a escribir enemigo, enemigo, juego o nombre spawn Dentro del guión del
punto de tiroteo. También necesitamos agregar
una variable privada, que es un entero, y
llamemos a este enemigo muerto. Esto es para contar
cuántos enemigos que
ya matamos y después de matar a todos entonces podemos pasar
a la siguiente zona. Vamos a crear un
nuevo método público y llamemos a
este enemigo matar. Para este método público, vamos a incrementar
este enemigo k entero. Vamos a escribir el
enemigo kel plus plus. Esto significa que
estamos aumentando uno o incrementando
por valor de uno, y queremos verificar si el valor de kel enemigo es igual
a la longitud de nuestra lista de enemigos Entonces queremos continuar
el movimiento aquí, el movimiento del jugador. Vamos a usar esto
este valor aquí. Copia esto y luego
pegarlo aquí. Bien. Entonces, ahora que hemos creado el método público
para la kilt enemiga, necesitamos llamar a esto
desde el guión enemigo Siempre que cada una
de una instancia del script enemigo sea asesinada, entonces queremos ejecutar
este método aquí. Yo aumento el valor de los enemigos
muertos aquí. Solo volvamos
al guión enemigo y dentro de la salud
actual aquí, solo
podemos acceder
al punto de tiroteo y ejecutar
el método enemigo asesinado Y guarda esto. Por supuesto, esta sigue siendo la
implementación básica y vamos a
modificarla más adelante. Solo volvamos a la
unidad y probemos esto. Este será el enemigo aquí. Voy a configurar esto o guardar esto como pref
Dentro de la carpeta del juego, voy a crear
una nueva carpeta Y dentro de esta carpeta de prefabs. Voy a dirigir
este objeto de juego enemigo como los prefabricados Ahora como ya
cambiamos esto a un prefes, solo
podemos agregar un script, que es el script enemigo, y luego podemos aplicar
esto a los prefabs Ahora necesitamos
reposicionar al enemigo. Solo habilitemos la
navegación y
voy a mover a este enemigo
a esta posición aquí. Yo probablemente aquí. Voy a
duplicar a este enemigo. Pero primero, vamos a establecer el valor de salud porque
actualmente sigue siendo cero. Simplemente fijemos este
23 y apliquemos esto. Será el valor por defecto. Podemos duplicar al enemigo aquí, y podemos ponerlo aquí. Si vamos a la navegación, podemos ver, podemos
ponerlo para aquí. Entonces en el punto de tiroteo, podemos crear un
nuevo objeto de juego t Y esta será la posición. Esto es para este enemigo de aquí. Podemos moverlo a
esta posición aquí, y podemos duplicar este objeto anti juego
y ponerlo atrás aquí. El segundo aparecerá aquí
en esta posición. Podemos mover esto ligeramente
al sitio aquí. Vamos a cambiarle el nombre a esto. Esta es la posición objetivo uno, y esta será la posición
objetivo dos. Bien. Ahora bien, si seleccionamos
al enemigo aquí, voy a poner a
este enemigo aquí, la posición objetivo a la
segunda posición objetivo. Y para el primer enemigo aquí, voy a establecer esto como
la primera posición objetivo. Bien, vamos a guardar la escena aquí y bajo el punto de
tiroteo, queremos configurar menos
al enemigo, solo
pongamos este 22, y para cada una de estas entradas, pongamos al primer
enemigo dos este de aquí, y el segundo enemigo estará en la segunda entrada aquí y probablemente necesitamos establecer un retraso,
así que vamos a poner
este 23 por ahora El próximo enemigo,
podemos establecer estos dos. Básicamente, esto se
activará después de que esto se muestre es B si
volvemos al código aquí, lo verás en
el punto de tiroteo. El bucle de cuatro e será liderado
por el primer retraso enemigo. Y entonces
inicializará a ese enemigo. Y luego en el siguiente bucle, retrasará el código basado
en basado en los retrasos del
segundo enemigo. Por ejemplo, este este enemigo aquí o lo siento, el segundo, se mostrará después 5 segundos después de 5
segundos aproximadamente. Así que vamos a
darle una oportunidad aquí. Voy a verificar una
vez más por el código aquí. Cuando empezamos a disparar, hay otra cosa que
tenemos que hacer es, tenemos que iniciar esta
corrutina aquí cuando ejecutemos el método start shoot
out aquí Vamos a ejecutar la
rutina de inicio SN Enemigos. Guarde esto, y
volvamos a la unidad. Ahora después de que esté compilado. Vamos a darle una oportunidad. Voy a habilitar la ventana de la
consola para que
podamos ver el mensaje aquí, el mensaje de bloqueo de depuración. Presionemos play. Lo siento, voy a generar
la iluminación una vez. Ahora tenemos la bolsa de luz, guarda la escena nuevamente
y luego presiona play. Ahora echemos un vistazo
cuando nos detengamos aquí, el enemigo después de 3 segundos espectáculo, ahí tienes. Podemos dispararle. Y si vamos al enemigo aquí, el bajo el inspector,
el primer enemigo. Podemos verificar su estado, y ahora nuestra salud actual
sigue siendo una para que podamos hacer clic una vez
más. Ahí vas. Es cero. Pero tenemos que destruir o más tarde si
usamos al personaje, tenemos que jugar la animación de la
muerte. Solo usemos destruir.
Primero ahora aquí. En el guión enemigo.
Después de matar, queremos destruir
el objeto del juego. Guarda esto vamos a probarlo. Si voy aquí al prefet, vamos a arreglar un
par de cosas aquí Vamos a quitar el colisionador del objeto de juego de caja aquí Solo quitemos el colisionador. Sí. Y guarda esto otra vez. Ejecutemos esto una
vez más y pruébalo. Ahora aparecen los enemigos, podemos eliminar aquí, y luego
podemos disparar tres veces. Después de que matemos a todos los enemigos, ves que el jugador
empieza a moverse de nuevo, y aquí podemos definir otro punto de
tiroteo Sí, esa es la base de
la configuración inicial enemiga, y posteriormente vamos
a cambiar el modelo con el personaje de robots reales
y también con animaciones.
8. 07 Preparaciones de animaciones de enemigos: Bien. Ahora en este video, vamos a seguir
desarrollando nuestro mecanismo enemigo, y ahora comencemos a
preparar modelo. Si vamos a la carpeta del juego
y dentro de la carpeta del juego, tengo un modelo Robot Kyle, y dentro del modelo de carpeta, tenemos el archivo FBX, que consiste en el modelo tres
D del Robot Primero, necesitamos cambiar la configuración de RIG a un
humanoide y presionar apply, y podemos dejar las otras
configuraciones por defecto Ahora una vez que tengamos el tipo de
animación, cambio, queremos abrir
esto en Explorer, para que podamos ver el modelo FBX, y ahora necesitamos preparar
un par de animaciones Para hacer eso, he usado Mixamo para crear animaciones
personalizadas Puedes ir a la dirección, que es mixamo.com.
Sólo tienes que registrarte. Es gratis, y luego de
eso puedes iniciar sesión, y también podemos subir
nuestro propio personaje. Presiona el
personaje de subida y voy a copiar la ruta del modelo aquí. Voy a seleccionar un archivo de caracteres y
luego pegar la ruta, después voy a
subir el archivo FBX Una vez que subamos los archivos FBS, vamos a elegir uno
de la biblioteca de animación, y esa biblioteca se
reorientará al objeto
Robot kyle Así que podemos usar la animación correctamente y encajar muy bien
al personaje del robot. Presiona siguiente una vez ya
hecho solo PressNx, y ahora podemos seleccionar muchas de las animaciones que están
disponibles. También podemos buscar. Voy a registrar
un paseo con arma de fuego. O podemos buscar solo arma y debería
haber un montón de armas relacionadas. Solo busquemos
el paseo con arma de fuego. O simplemente podemos buscar
rifle. Sí, podemos usar esto. Necesitamos una moción hacia adelante. Probablemente el que no están
disparando sería el mejor. Podemos usar este paseo con fusil. No estoy seguro si lento, vamos solo por el
que probablemente sea más rápido. Esto debería ser mejor. Queremos la
información de traducción porque vamos
a usar eso para crear un movimiento muy agradable que se sincronicen
con la animación. Presiona descargar y luego
establecer el formato dos FBX cuatro unidad y
podemos elegir sin skin, y luego simplemente descargarlo Una vez que presionemos descargar, preparará los activos
y podremos guardar el archivo FBX Voy a pegar
nuestro camino aquí. Y luego ir a la carpeta del juego y voy
a crear nuevas animaciones. Entonces voy a salvar esto. Pero probablemente
voy a cambiar esto para correr hacia adelante rifle. Una vez que guardemos esto,
busquemos el que son sts. Este, podemos usar
este para esquivar, pero creo que esto es demasiado lento, así que busquemos
uno que sea más rápido ¿Tenemos esto en la parte superior? Solo busquemos
desde las otras páginas. Éste debería hacer.
Podemos usar esto. Voy a presionar
descargar de nuevo y tenemos la
configuración anterior reed, solo presiona descargar y luego
guardar en la misma carpeta. Probablemente necesitamos una animación. Este es bastante agradable
en realidad. O éste probablemente. Sí, podemos usar
esto, presione descargar. No puedo incluir estos
activos en el tutorial porque los términos y
licencia para usar Mixamo, por lo que solo puedes
registrarte tú mismo y luego descargar la
animación que necesites Voy a descargar
este y vamos llamar a s para la animación. O fusil eso. Sí. Creo que
podemos usar esta. Ahora podemos presionar descargar
y dentro de las animaciones. Ahora que tenemos todo
esto, animaciones preparadas. Volvamos a la unidad, y tendrá las animaciones importadas
automáticamente. Pero queremos configurar primero el tipo de
animación. Vamos a seleccionar todos
los archivos FBX aquí dentro la carpeta de animaciones
y elegir humanoide Entonces para la definición de Avatar, ya que este es solo
un archivo de animación, no
hay avatar
dentro de él, así que necesitamos copiar
del otro vor,
Vamos a copiar
del otro Avatar, y podemos elegir el avatar de
Robot Kyle aquí. Éste de aquí. Es del modelo Robot Kyle
dentro de la carpeta del modelo, y es del
Robot Kyle FBX Simplemente seleccionemos este
y luego presionemos aplicar. Bien. Entonces ahora si seleccionamos uno de ellos, y si vamos a la animación, aquí
hay algún problema. Vamos a revisar. El problema fue con
la configuración del modelo. Entonces necesitamos cambiar el factor de
escala a 0.01. Tenemos que asegurarnos de que
la configuración aquí la misma con nuestro modelo
Robot Kyle aquí. Como puede ver, establece
en factor de escala 0.01, y todos los
ajustes están desmarcados excepto combinar formas y
ordenar jerarquía por nombre Y esto es lo más importante. Esta conversión de unidades no está marcada. Así que tenemos que
asegurarnos de que las animaciones tengan esa misma configuración. Una vez desmarcamos las
unidades convertidas y el resto de las opciones, presione aplicar Ahora bien, si vamos a la plataforma, verás que ya no
tenemos el error. Y si seleccionamos una de las animaciones y vamos
a la ventana de animación, ya ves que tenemos unas animaciones muy bonitas para
el robot aquí. Bien. Ahora tenemos que configurar
un par de cosas aquí. Primero, queremos
establecer la rotación, no a la orientación del cuerpo, sino a la original y
luego presionar aplicar. Aquí, queremos
cambiar los dos pies. Queremos poner a estos
dos grandes en pose aquí, y esta también es
una gran pose. Ahora tenemos un movimiento de movimiento muy
agradable. Si cierro esto, y
trato de volver a seleccionar esto, verás que el robot se
moverá linealmente en esta línea aquí Entonces se mueve muy bien. Pero asegúrate de que para la posición de transformación
raíz, no
queremos verificar las opciones de interposición
grande Por el otro la portada
izquierda aquí, vamos a poner lo mismo. Establezca esta pose original de dos pulgadas
grandes, y esto es dos pies para
la transomposición de raíz y. pose de pulgada
grande, y
dejemos la transomposición de raíz Y ahora si presionamos play, ves que aquí se mueve muy bien
al eje x. La otra cosa que
necesitamos establecer es para las reacciones del sombrero, y esto asegura que la raíz trafposition y alimente y deje
los otros ajustes Para la animación des, asegúrate de que tenemos
los mismos ajustes. Y lo que este escenario
es básicamente hacer. Estamos preservando la rotación
original. Entonces está mirando correctamente sobre el eje z, de la manera en que debería. Y para la posición de
transformación de raíz y, queremos hornear en
la pose para que no cambie la traducción
en la animación, y se inicia en base a los pies en el primer
fotograma de la animación. Hay una animación
que nos olvidamos de recoger. Entonces básicamente, queremos
recoger al ídolo del rifle. Así que vamos a recoger este. O podemos, el
ídolo de puntería del rifle debería ser mejor. Y luego descarga esto y guárdalo en la carpeta de
animaciones. Si volvemos a ello, verás que tenemos
esta nueva animación. Creo que es esperar un
minuto. Éste. Vamos a configurar primero los toques del
modelo, establecer el factor de escala en 0.01 y verificar todas estas opciones,
excepto las formas de mezcla y
la jerarquía corta por nombre. Para la plataforma, cambia
esto a humanoide, y copia de otro Avatar, y voy a elegir el robot Kyle avatar
y presionar aplicar Una vez que ya lo hayamos establecido, tendremos esta puntería. Para el apuntamiento, podemos establecer estas opciones de bucle para
habilitar el tiempo de bucle. Establezca esto en original,
Big en pose, ponga estos pies, Si. Para la ejecución,
también necesitamos habilitar el tiempo de
bucle que olvidé antes. Presiona aplicar, verifica esto
y luego presiona aplicar. También para la cubierta izquierda, también
queremos establecer el tiempo de
bucle para habilitar.
9. 08 Scripting de animaciones de enemigos: Bien, ahora vamos a seguir preparando las
animaciones para el enemigo. Ahora bien, lo siguiente que
tenemos que hacer es que tenemos ir
a la
carpeta de prefabs y luego abrir los prefabricados enemigos
presionando los prefabricados abiertos
aquí en el inspector,
e irá a los modos prefabricados e Ahora aquí sobre el enemigo, podemos eliminar el objeto cubo. Para el enemigo,
también podemos eliminar el componente mesh, caps mash filter, y también el render de malla. Solo tenemos el colisionador, el agente de malla, el
cuerpo rígido y el scrip enemigo Ahora voy a arrastrar
el robot kyle modelo. Vamos al archivo de modelo y luego arrastremos esto como
un objeto hijo. Ahora bien, si vamos a la perspectiva o a la vista
isommétrica desde
la vista derecha, si selecciono al enemigo, verás que el robot está básicamente en esta posición aquí Vamos a alinear el
objeto del juego del robot con la base del
colisionador y el agente NM Selecciona el robot Kyle,
solo mueve esto hacia abajo. Y ahí tienes. También podemos
ajustar la altura de la cápsula. Solo seleccionemos el colisionador
cápsula. Y si estás por encima de la
parte superior del codificador de capsul, verás un cuadrado amarillo muy
pequeño Es como un asa y
puedes arrastrar esto, arrastrarlo y moverlo, así queda alineado
con la parte superior de la cabeza del robot. Para el agente de masa NF, podemos cambiar la altura, y aquí tenemos el valor
de nuestro planeador de cápsulas, simplemente seleccione el valor de
altura copy, y luego pegue esto dentro del valor de altura de
nuestro agente Nap mas Tendremos la misma altura. Ahora tenemos esta configuración, necesitamos crear un controlador de
animación. Si vamos a la carpeta de
animaciones, voy a crear
otra subcarpeta dentro de la carpeta de animaciones, y voy a llamar a
este controlador Aquí, voy a crear
un controlador animador, y voy a llamar a
esta base enemiga Si hacemos doble clic en esto, verás que tenemos
esta ventana del animador abierta Tenemos que montar un árbol soso. Estado aquí, y este
será el estado predeterminado. Dentro de los
tres sosos, tendremos las opciones para cambiar
el tipo de tres insípido Voy a usar un
libre de direccional, dos d libre de direccional, necesita un parámetro. Si vamos al parámetro, automáticamente
crea un parámetro float con
el nombre de soso Voy a crear el
otro parámetro float. Esta será la velocidad x. Voy a renombrar esto
haciendo doble clic en él, y luego llamar a esta velocidad x, y esta será la velocidad z. Y ahora vamos
a utilizar la velocidad x y la Z como los parámetros de nuestro
plan tres tipo aquí. Necesitamos crear un
par de movimientos. Solo agreguemos el campo de movimiento. Necesitamos cinco mociones. El primer movimiento será
el rifle apuntando inactivo, este de aquí, queremos tener un valor para la posición x
20 y la posición y 20. Las posiciones x e y
corresponden aquí
al valor de velocidad x y
velocidad z. La otra cosa que necesitamos
es el fusil de carrera hacia adelante. El tercero
sería la portada izquierda. Vuelva a recoger la tapa izquierda aquí. Para el último, este
sería el fusil de carrera hacia adelante. Básicamente, vamos a
invertir las dos últimas animaciones. Esto irá al lado derecho y esto va a correr hacia atrás. Para revertir
la carrera hacia adelante, necesitamos cambiar la velocidad
a negativa en el,
el rifle de carrera hacia adelante, entrada de
animación. Para la portada izquierda, queremos habilitar la animación de
espejo, por lo que reflejará la animación. Y ahora tenemos que
cambiar su valor aquí. Si estamos al ralentí, entonces queremos establecer la posición
x y la posición y20, y si corremos hacia adelante,
queremos establecer la posición El valor z debe ser uno
para activar esta animación, pero la velocidad x debe ser cero. Para la cubierta izquierda, queremos establecer este
dos negativo,
correcto, y para el derecho,
que la cubierta izquierda invirtió con las opciones de espejo aquí, queremos establecer este 212
positivo, y la posición
Y 20. Para la carrera hacia adelante que son inversas en cuanto a
velocidad de animación aquí, queremos establecer la posición x20 y la posición y
dos negativos uno Ahora tenemos una
configuración muy agradable por aquí. Si presionamos súplica, y
luego amplío esto, ya ves que tenemos
la animación ideal Pero si empezamos a modificar
la velocidad x aquí, ves que va
al lado derecho y aquí, va al lado izquierdo,
como puedes ver aquí. Si establecemos la velocidad z en uno, se moverá hacia adelante y
comenzará a moverse hacia atrás. Y podemos
probar esto arrastrando, creo que podemos arrastrar esto todavía. Verás, si me muevo
esto de lado, tendremos un movimiento ligeramente
desplazado o inclinado, y se mezcla muy bien
con las animaciones Como puedes ver
aquí. Ahora configuramos correctamente
el árbol soso Vamos a poner esto de
nuevo a cero, cero. Ahora necesitamos ir
a la capa base y luego comenzar a configurar esto
para que funcione con el script. Volvamos a la vista de escena aquí y seleccionemos el robot kyle, y ahora queremos dirigir el controlador enemigo base al controlador robot kyle
dentro
del inspector y
dejar los movimientos de root de aplicación habilitados por ahora Pasemos al guión enemigo. Ahora necesitamos agregar una variable animadora
privada, vamos a escribir animador, y vamos a llamar a
esto ym Al inicio, queremos agarrar el
componente ym escribiendo ym igual, y luego queremos
obtener Pero esta vez queremos obtener el componente en
los niños. ¿Por qué es eso? Porque si volvemos a ella D, ve
que el guión está en el padre y el animador
está en el objeto hijo Volvamos
al guión aquí, y luego agarremos el componente
animador La otra cosa que tenemos que
hacer es que necesitamos crear un método llamado Run blend. Y guarda esto. Ahora la animación impulsará el traducir o
el movimiento de los enemigos. Necesitamos desactivar la posición
de actualización en
los componentes del agente. Simplemente escriba agent, actualice
la posición, establezca esto en false. La otra cosa que
necesitamos crear es una variable privada para tres. Vamos a escribir el vector tres
como el tipo o la clase, y voy a llamar a
este movimiento local. Bien. Ahora dentro del método
run blend, queremos comprobar si la m
no es o la m no está desactivada,
así habilitada, pero con
el signo de exclamación Entonces queremos regresar. Pero si es o si está deshabilitado,
entonces queremos regresar. Este método no se ejecuta. Ahora tenemos que verificar si
el agente siguiente posición. La siguiente posición es
básicamente obtiene o establece la
posición de simulación del agente NMS De esta manera estamos obteniendo
la siguiente posición, la posición simulada, y queremos restar con
nuestra posición actual Queremos verificar la distancia de esta posición usando
una magnitud cuadrada. Podemos usar magnitud, pero la magnitud
cuadrada es más eficiente porque
no hay operación de raíz cuadrada Es menor que, por ejemplo, un valor muy pequeño 0.01. Entonces queremos asegurarnos las animaciones estén funcionando
para traducir al enemigo. Aquí dentro de la declaración, queremos modificar el movimiento local a la dirección
de este vector aquí. Vamos a escribir o simplemente duplicar este vector
de cálculo. Pero queremos basarnos en la transformación local del objeto
de juego de anime. Solo obtengamos la transformación y luego usemos la dirección de
transformación inversa. Ya que este es método, en cuanto a
un factor tres dirección, como se puede ver aquí en la ayuda, por lo que estamos alimentando esta
dirección a este método aquí. Asegúrate de poner un sem
cooln al final de la línea. Ahora fuera de esta sentencia if, queremos acceder a
la variable anim, que es la compañera del animador Entonces queremos establecer
el valor float, que es el, este
debe ser string,
X speed, y este
debe ser nombrado correctamente como el que está
dentro del animador Ventana aquí, los parámetros
para el animador. Ahora queremos pasar el
movimiento local punto x. Entonces para la siguiente línea, debería ser el
flotador establecido para la velocidad z, y este sería
el movimiento local z. Ahora guardamos esto
Ahora para probar esto, podemos simplemente ejecutar el método
dentro del método update. Vamos a ejecutar el
plan de carrera aquí y guardar esto. Vamos a probarlo y
volvamos a la aplicación UT. Ve a la escena aquí. Si salimos de los prefabricados, ves que nuestros dos enemigos
son cambio o cambio al
objeto de juego robot, ya que este es un prefabricado,
se Ahora bien, si presionamos la súplica, vamos a probar esto. Al parar, cuando aparezca, debería reproducir la animación
correcta. Aquí hay un problema. Lo siento, hay un tipo de mis
en el código aquí de mi parte. Básicamente, necesitamos
asegurarnos de que la magnitud cuadrada sea
mayor que este valor, entonces queremos calcular
el movimiento local. Significa que si la
posición de transformación aún no ha llegado, entonces queremos calcular el movimiento
en función de la dirección. Ahora volvamos
a la unidad y luego presionemos para probar esto. Si nos detenemos aquí,
calzados empiezan a jugar. Ahí vas. Pero se mueve
más allá, como puedes ver aquí, el enemigo, porque el objeto de juego
padre se queda aquí y el que se mueve
es el objeto de juego infantil. Tenemos que asegurarnos de que
el movimiento raíz de nuestro animador o animaciones están impulsando el objeto del juego
padre Vamos a crear
un guión para eso. Aquí dentro de la carpeta de scripts, vamos a crear un script CO, y vamos a llamar a
este movimiento animador Entonces queremos
eliminar el inicio y
el método de actualización para
la materia muévase aquí. Salvemos el guión enemigo. Aquí, queremos crear un método
on animator move,
que es un método incorporado desde unity,
y esta devolución de llamada
se invocará en cada fotograma
después de que se hayan
evaluado las máquinas de estado y la animación, pero antes en Solo usemos esto. Básicamente,
necesitamos el componente ym. Vamos a crear un animador
privado, llamar a esto anym solo
recrear el método start, y luego para el an ym, vamos a obtener
animador componente Dentro del movimiento del animador,
queremos desplazar la posición de la panorámica de
transformación en
función de la posición Delta de la animación Vamos a disculparnos no esto aquí, sino dentro del anima
mover en movimiento animador Queremos acceder a la posición
Transformar Parn, y luego queremos
incrementar esta por la posición m Delta Esto, L s esto y
volvamos a la unidad. Aquí, solo
modifiquemos el prefep, así que actualizo el
objeto del juego anima aquí en escena Vamos a abrir prefep. Debajo del objeto de
juego Robot Kyle aquí, objeto, queremos agregar
el script de movimiento animador Como puede ver, una vez que agregamos aquí
el script de movimiento animador, los movimientos raíz son
manejados por script Animador reconoce
que dentro del guión, tenemos esto en el
método del animador o callback, y volvamos a nuestra
escena aquí y Ahora vamos a darle una oportunidad y
ver si esto soluciona el problema. Ahora si nos detenemos, deberíamos
ver aparecer el robot. Ahora se mueve y una vez que llegó, se
detuvo, como pueden ver. Ahí vas. Ahora tenemos los robots y los robots y las
animaciones funcionando. En el siguiente video,
vamos a continuar para las
implementaciones de animación.
10. 09 Corrección de movimientos de enemigos y animación de golpes: Vamos a seguir
trabajando en el guión enemigo y vamos a suavizar
algún movimiento en este video. Echemos un vistazo a
lo que tenemos ahora mismo, y voy a presionar play. Verás que cuando seleccionamos
al enemigo y habilitemos a Gizmo, verás que el agente del NMS se mueve más rápido y sigue Y si intento volver a jugar esto, verás también
que el objeto robot
o el objeto de juego están
caminando por la pared. Si perro esto abajo
aquí, la ventana del juego, verás que si
tratamos de reproducir esto
y presiono play, verás que el agente se
moverá correctamente, evitando la pared,
pero el objeto
del juego está tratando de obtener
la dirección más cercana al agente gizmo aquí,
el gizmo
del agente de malla N Tenemos que arreglarlo. Voy
a revertir el diseño aquí Para arreglar esto,
abramos el script enemigo, y ahora tengo abierto aquí, y vamos a
crear un par de
modificaciones dentro
del método run soso Lo primero que necesitamos
cambiar es en lugar de medir o comparar la magnitud
cuadrada entre la posición de transformación y
la siguiente posición del agente, podemos simplemente agarrar la
distancia
restante del objeto agente. Tecleamos la variable agente. Podemos obtener la distancia
restante, y podemos verificar si
la distancia restante es mayor a 0.01. Entonces significa que aún no hemos llegado al destino. También podemos usar la velocidad del agente en lugar de
calcular la dirección. Voy a agarrar la velocidad del
agente aquí. Y quiero asegurarme de que
el agente de desastre de NaF permanezca junto con el objeto del juego
o la transformación principal Aquí podemos poner Abajo aquí, podemos escribir Agente,
la siguiente posición, y podemos asignar la siguiente
posición a la transformación. Básicamente, lo que está haciendo este
código es, vamos a asegurarnos de
que la malla de NaF no vaya tan rápido como antes y se
pegue al objeto del juego Ahora podemos guardar esto y
vamos a darle una oportunidad. Vamos a la
vista de juego y presionemos play. Si destaco al enemigo aquí, verás ahora que la malla NF se
quedará con el
planeador cápsula cuando se mueva Ahí vas. Y hay un problema cuando lleguemos,
así que tenemos que arreglarlo. Pero si echas un vistazo, verás
que cuando
el trasero empiece a moverse, se mueve correctamente.
Sigue el camino. Ya no pasa por el
mundo porque estamos compensando la
malla NAF siguiente posición
a nuestra posición de transformación, cada
fotograma Entonces estamos obteniendo la velocidad, e impulsa la animación
para que se mueva en función de su velocidad. Pero después de eso,
estamos corrigiendo la siguiente posición del agente. Ahora podemos retocar esto aún más. Primero, podemos normalizar
este valor aquí. Entonces es gusto uno, y queremos agregar una condición else y
para la condición else, básicamente que queremos
establecer el valor
local del movimiento 20
cada vez que lleguemos. Vamos a escribir movimiento
local igual al factor 30, y guardar esto. Ahora volvamos a la
unidad y pruébalo. Ahora empieza a moverse y
cuando llegue, debería detenerse. Sí, todavía tenemos problemas. Bien. Ahora podemos mover esta línea aquí para estar dentro de la declaración
if aquí. Queremos asegurarnos de que estamos actualizando la siguiente mag cuando todavía nos
estemos moviendo y cuando
lleguemos al destino, no queremos
ejecutar este como. Vamos a t a
jugar esto otra vez. Ahora se mueve, y
cuando llega, se detiene. Ahí vas. Pero ya ves que la transición de
parada, las animaciones dal transitan muy abruptamente.
Tenemos que arreglarlo. Volvamos a fical Studio. Y aquí vamos a agregar un árbol vectorial y luego
ejecutar el método erb No queda. Básicamente, este lb interpolará el
vector A dos vectores, para el vector B, queremos
usar este valor aquí, y para el vector A, va a ser nuestro
movimiento anterior local Solo usemos el movimiento local. Después del vector
B, necesitamos pasar un float como el valor de
interpolación Voy a usar
valor de dos aquí y multiplicar esto por tiempo Delta T. Ahora que tenemos
esto. Cuando lleguemos, también queremos que el vector a
este valor de vector 30 aquí. Vamos a crear un
nuevo método vectorial y luego pasar el movimiento local como vector A y vector B. Queremos establecer este
dos vector 30. Vamos a establecer el mismo valor
para que el valor de interpolación se
multiplique por deta
Vamos a guardar esto Y volvamos a la unidad y volvamos jugar esto para ver si
esto soluciona el problema o no. Ahora cuando el enemigo empiece a moverse, podemos ver que las animaciones se detendrán muy
bien. Ahí vas. Nosotros hemos arreglado el movimiento
y ahora el enemigo
seguirá muy cerca el
movimiento del agente de la NAPM Lo siguiente que necesitamos
crear es que necesitamos
crear una animación cada vez que el trasero sea golpeado por la bala. Vamos a la carpeta de prefs y abramos el enemigo
actualmente en un inspector de depuración Voy a cambiar de nuevo
a inspector normal, y luego presionar Prefet abierto Aquí, si selecciono el robot kyle aquí, vaya al animador Vamos a la capa base.
Sólo tenemos esta planta. Necesitamos crear
dos estados diferentes, y el primero debe
ser el estado jefe. Y el segundo
será el estado muerto. Lo siento. Éste debería
ser el hit y eso. Oh, aquí cometí un error. Vamos a cambiar el nombre de este estado
predeterminado aquí. Este debería ser el plan tres,
y este será el golpe. Para la animación de hit, solo
escojamos la
reacción del hit y para los muertos, voy a escoger el disparo frontal de la
muerte en la cabeza Vamos a crear una transición
de cualquier estado al estado golpeado y de cualquier
estado al estado muerto. Y vamos a hacer transición de hit back
a los sosos tres aquí Probablemente podamos
reorganizar esto mejor. Necesitamos crear un par de nuevos parámetros
dentro del animador Sólo vamos a crear
un gatillo y éste será disparado y
otro gatillo. Muertos, y también vamos
a crear un bulion, y vamos a
llamar a esto está muerto Por lo que el gatillo muerto
activará la animación de muertos, y el bulion será una caja fuerte o una verificación segura
para la animación de golpe Así que sólo podemos ir a
la animación hit cuando nos disparan
y el es falso. Ahora volvamos
al guión aquí. Y queremos establecer
cada vez que el bot sea eso, entonces queremos
activar la animación. Solo intentemos
activar la animación, establecer el disparador, y deberíamos
activar la animación muerta. También queremos establecer el conjunto b, y este sería el is b y la cadena debería
ser
la misma con nuestro nombre de parámetro aquí
en la ventana del animador Vamos a establecer esto cierto. Siempre que estemos vivos, necesitamos agregar una condición
else, y si sigue viva, entonces queremos tocar
el gatillo de golpe,
hit, shot trigger y guardar esto. Ahora vamos a asignar la
condición de transición aquí desde el cualquier estado a golpear, queremos agregar un disparador de disparo y queremos
asegurarnos siempre que sea falso. El valor será
falso por defecto. Para los muertos, queremos poner esto que queremos
usar el gatillo muerto. Tenemos
que asegurarnos de que tiene tiempo de salida está deshabilitado y para que el golpe
vuelva a la t soso, queremos asegurarnos de que tiene tiempo de
salida es cierto y
no hay condiciones en absoluto Automáticamente volverá al soso t cada vez que termine de jugar
la reacción de golpe Bien. Ahora bien, si
revisamos el guión, nuevo, creo que es bueno. Solo vamos a probar
esto ejecutando el juego, y vamos a disparar al
bicho cuando llegue. Ahí vas. Se juega
la reacción de golpe. Oh, no podemos verificar a los muertos porque lo
destruimos enseguida, así podemos agregar el
retraso en la destrucción. Agrega un coma aquí, y
entonces tal vez podamos establecer los dos 4 segundos de retraso por
ahora y volver a la unidad, y vamos a probar esto de nuevo. Uno, dos, tres, y está muerto. Sí. Después de 4 segundos , quedará destruida. Sí, ahí tienes.
Aquí en este video, arreglamos el movimiento, ahora es mucho
mejor que antes, y también agregamos la reacción
del sombrero y la animación de la muerte.
11. 10 efectos de golpes básicos: Hola, en este video,
vamos a crear los efectos de partículas
en la superficie. Entonces, cuando queremos
crear una característica, cada vez que disparamos en el
suelo o en la pared, queremos crear
un efecto de partículas. Entonces para hacer eso, vamos a crear un
nuevo script de tienda C. Y llamemos a este efecto. Y abramos el guión. Y en este script,
queremos implementar el
capaz Vamos a hacer eso, y luego vamos a
implementar la interfaz, por lo que va a crear
el método public. No necesitamos el
método uplate para este script. Y ahora necesitamos
crear un campo serizado para sostener las prefs de partículas El eff de partículas prefs. Vamos a llamar a esta
partícula prese o eff prefs. Vamos a guardar esto. También queremos crear un sistema de
partículas privado. Y vamos a llamar a
esta caché de partículas o FX quizás describa mejor
la variable. Y al principio, queremos
instanciar esto, y queremos hacer de este
objeto como hijo de
este juego un objeto que
tenga aquí este guión Y para las prefs de efectos, debería tener un sistema de
partículas Así que tenemos que asegurarnos de que el objeto que son referencia a esta variable aquí debe tener un
componente del sistema de partículas unido a él. Entonces queremos verificar si el
efecto prefs no es nulo, entonces queremos
instanciar esto Así que vamos a crear una nueva referencia de objeto de juego,
efectos, temporales, y vamos a crear una instancia de
los prefectos de efecto, y queremos establecer este objeto de
juego como Así que vamos a escribir transform. Entonces queremos establecer la variable de
caché de efectos a los componentes del
sistema de partículas del objeto del juego que se adjuntan a ella. Vamos a escribir caché aquí, y luego tomar el efecto tem y el tipo get component
particle system. Bien. Así que ahora hemos creado esto. Queremos reproducir
la partícula cada vez que se active este
método. Así que vamos a eliminar esto, y queremos comprobar si
el caché FX no es nulo. Lo siento, puse el
paréntesis equivocado por ahí. La caché de FX no es nula, entonces queremos
establecer la posición de la
caché de efectos en el punto de acierto. Establece también la rotación, bits su normal y juega
el efecto de partícula. Vamos a hacer eso. Podemos agarrar la memoria caché
del sistema de partículas aquí, y luego
escribir transform type position, y podemos establecer
esto al punto. Y también podemos establecer
la rotación
accediendo a la variable del
sistema de partículas. La
rotación de transformación, y podemos agarrar usando la rotación de
aspecto cuaternión, y queremos
enfrentar la normal del punto de golpe o
la variable hit
Cas aquí Así que ahora podemos salvar esto. Y entonces queremos tocar
también la partícula. Así que solo podemos acceder
al método de juego. Y como el caché Flex
es un sistema de partículas, entonces podemos acceder directamente al método de
reproducción. Así que vamos a guardar esto. Y vamos a darle una oportunidad. Bien, aquí, si
selecciono el cubo aquí, podemos agregar los efectos ha, y pide un ef prefab Entonces, si vamos a esta carpeta de ejemplos de efectos
y bajo los efectos de arma,
bajo prefabs, se ve que
tenemos un impacto metálico Solo usemos esto. Pero
en vez de usar esta pref, voy a duplicar esta
prefabricada presionando Control D, y voy a
modificar los De esa manera, tendremos
el prefe original Y siempre podremos duplicar los prefabricados originales
cuando queramos hacerle alguna modificación Así que vamos a dirigir esto
a la carpeta prefes. Y voy a abrir las prefbs y
tenemos que modificar esto Como las partículas residen aquí
en el objeto hijo, vamos a crear
una modificación. Podemos simplemente quitar todo
el mesnder aquí,
y el filtro, también el collider, y podemos duplicar el sistema de partículas
copiando el componente y
luego pegar esto Y queremos arrastrar las chispas, el polvo y la calcomanía como hijos de
esto y simplemente borrar esto. Ahora bien, si vamos a
los subemisores, se ve
que todavía tienen
la misma referencia Y como se puede ver, emite
a cierta forma de lanza. B aquí bajo la forma, tenemos un hemisferio, queremos usar creo, en lugar de usar una lanza, deberíamos estar usando cono aquí Sí. Ahí vas. Ahora tenemos el cono que
está encarando de esa manera. Y probablemente podamos cambiar
la dirección del spawn aquí configurando el vamos a
revisar las chispas aquí Podemos rotar el objeto hijo. Simplemente rotemos
este conjunto este 20, y ahora debería estar
encarando de la manera correcta. Bien, vamos a seleccionar todo
el objeto de juego infantil y
luego establecer el valor y 20. Entonces me enfrento de la manera correcta. Bien. Y ahora queremos asegurarnos de que la
partícula no esté en un círculo. Simplemente deshabilitemos el ciclo
y luego presionemos play. Y es un ciclo. Entonces queremos establecer la tasa a lo largo del tiempo bajo el panel de
emisión en cero y establecer la emisión de partículas
usando birst en su lugar Vamos a presionar más
sobre los pájaros aquí y establecer este 21 debería ser suficiente. Para el niño, también
queremos establecer esto. Esto ya está configurado correctamente, así que vamos a revisar también
el polvo. Está usando ráfaga la mayor parte de ella. Bien. Entonces si presionamos
ph play solo una vez. Et's stop y luego presiona play de
nuevo. Sí. Ahí vas. Y queremos establecer el mundo espacial de simulación
para toda la partícula aquí. Vamos a seleccionar toda
la partícula y establecer el mundo espacial de simulación. Bien. Ahora si intentamos volver
a jugar, sí. Bien. De esta manera nos aseguramos de que la partícula no
vaya a bucles, y solo queremos reproducir
la partícula siempre que invoquemos el método
de reproducción desde el script aquí Bien. Otra cosa que tenemos que
configurar es que queremos desactivar
las opciones de play on wake en la partícula padre,
así que vamos a hacer eso. Entonces la partícula no se
pone en juego cada vez que instanciamos a la escena Volvamos a la escena
aquí y guardemos la escena. Y selecciona el primer cubo aquí, y queremos arrastrar
los prefabricados de metal impact nuestra carpeta
prefes
a los prefabs de efecto Ahora vamos a guardar esto.
Y si presionamos play, vamos a darle una oportunidad. Ahí vas. Si disparamos en la superficie, se ve que tenemos el efecto de
partícula instanciado Y lo bueno de esto, solo
tenemos una partícula, pero básicamente estamos
moviendo la posición de
la partícula en función de la partícula en función nuestro disparo o golpe rac
como ubicación de golpe, y jugamos la partícula Y como el
espacio de partículas se enrolla, esas partículas
se quedan en ese lugar, pesar de que hacemos clic
en otra área y movemos la p no
el padre lo siento, movemos el objeto de juego
del sistema de partículas. Como puedes ver aquí,
tenemos rastros de
nuestra
invocación de partículas anterior o juego de partículas Entonces ahora tenemos esta configuración. Podemos simplemente duplicar
el componente aquí. Lo siento, lo pego por error. Así que sólo voy a deshacer esto. Y podemos copiar componente
este componente de efectos de golpe y luego seleccionar todos los demás e, y podemos pegar esto como nuevo. Bien. Esos son los efectos
básicos de golpe, y en el siguiente video, vamos a crear
unos efectos de golpe específicos para el enemigo cada vez que
cerremos al enemigo.
12. 11 efectos de golpes enemigos: Hola. En este video,
vamos a continuar en nuestro proyecto de juego virtual Cp. Y en este video, vamos a crear los efectos de golpe
para el enemigo. Entonces, para crear
efectos de golpe en el enemigo, simplemente
podemos reutilizar el guión anterior
que hemos creado, que son los efectos de golpe
y asignar el efecto. Pero aquí hay un tema. Esto no funcionará de
inmediato porque el guión enemigo también
implementa I hitable, y los efectos hit
también implementan eso Entonces, si echamos un vistazo aquí
en el guión del jugador aquí, ves que cada vez que el jugador presiona el botón del mouse,
el botón izquierdo del mouse, y comienza a disparar, detectará solo
un componente hitable Entonces necesitamos cambiar esto
para que funcione con múltiples golpes o un componente
múltiple que implemente I hitable Así que vamos a hacer
eso. Y primero, vamos a cambiar la clase de
caridad aquí por una matriz, y
llamemos a esto itables Y entonces vamos a usar
el método get components, el caso pleural para el método
get component Entonces queremos comprobar
si los golpes no son u y hables longitud Es mayor que cero. Significa que tenemos al
menos un componente hitable dentro de esta matriz capaz,
yo hittable Entonces queremos ejecutar este
código dentro de la sentencia. Vamos a usar un
cuatro cada declaración, y básicamente podemos crear una
matriz o colección hable in able. Vamos a cortar esto
aquí y pegar esto dentro de los cuatro
cada declaración. Sólo vamos a guardar esto. Y
ahora volvamos a la unidad. Y ya he preparado
un efecto prefs, y se adjunta en la descripción de este
curso aquí, echa un vistazo Básicamente, necesitamos
importar ese paquete. Se llama paquete de
unidad eléctrica FX, y cuando acaba de importar. Y aquí, utilizó
la textura de la partícula eff
ejemplo de la unidad Entonces no necesitamos
reimportar esto. Solo podemos importar los pre, prefs
eléctricos, importación de prensa Y ahora tenemos este prefs. Si hacemos doble clic en los prefs, verá que tenemos un efecto eléctrico
muy agradable Ahí vas. Solo usemos esto como el
efecto prefs para el enemigo. Solo abramos las prefs enemigas, y queremos cambiar esto
en el nivel prefabs Así que vamos a agregar de nuevo el componente
Hat ex, y luego seleccionar el fx
electric drag this como el efecto prefs debajo
del componente at ex Y si volvemos
a la escena aquí, ya ves que tenemos múltiples
componentes solo eliminamos este. Bien. Ahí vas. Usamos el componente hit ex que agregamos en
el nivel de prefabs, y vamos a guardar la escena Y esto debería aplicarse
también al otro enemigo. Sí. Y ahora si presionamos play, y luego empezamos a
disparar al enemigo. Voy a desactivar
el artilugio para que
podamos verlo mejor. Ahí vas. Tendremos un efecto
eléctrico muy agradable. Ahí vas. Y sigue funcionando en la pared, independientemente de los cambios
de nuestro guión de jugador aquí. Porque va a agarrar cualquier cantidad de itable o cualquier componente de
script cantidad que implemente hittable Entonces, si solo hay una, entonces esta
rueda de acero se ejecuta.
13. 12 accesorios explosivos: Hola otra vez. Y en este video, vamos a continuar con nuestro proyecto de juego
Virtual Cp. Y en este episodio, vamos a crear un
objeto explosivo o un utilería que podamos
disparar y luego explotar y también crear
daño al enemigo Entonces para hacer
eso, vamos a
crear primero la explosión
prefex Si vamos a los ejemplos de
efecto y la explosión de fuego bajo
la carpeta prefes, tendremos esta gran
explosión prefep Simplemente dupliquemos esto. Y luego queremos ir
a la carpeta prefs,
lo siento, no a la carpeta prefs Queremos arrastrar el prefet
duplicado la
carpeta prefet. Vamos a hacer eso. Y ahora tenemos una
versión duplicada de la misma. Si hago doble clic aquí,
verá que tenemos una explosión
muy agradable. Actualmente, se pone en bucle, así que queremos desactivar eso. Seleccione aquí todo el objeto de juego y el objeto de juego hijo, y todos ellos tienen
este
componente de sistemas de partículas unido a él, eso es desactivar las opciones de
bucle Ahora bien, si voy al objeto de juego más
padre, y si presionamos play, solo jugará
una vez. Ahí vas. Y ahora vamos a crear el script de
explosión que maneja el
daño aplicado tras la explosión, y vayamos a la carpeta de
scripts. Y voy a crear
un nuevo guión de ChoB, y voy a llamar a
esta explosión daño. Y abramos este equipo. Ahora podemos crear un
par de variables. El primero debe ser
el radio de daño del flotador. El alcance de los daños por
explosión, a qué distancia esta
explosión va a dañar
al enemigo u otro
objeto que haya implementado la interfaz de
caridad. También queremos crear un retraso de
flotación hasta que se destruya. Sí. Entonces este será el retraso, cuánto tiempo antes de que
se destruya este objeto de juego de
explosión, y no necesitamos
el método object, así que vamos a eliminar esto. Y ahora queremos
crear un método,
un método incorporado llamado
dro Gizmos seleccionado Y esto es básicamente
para manejar cualquier Gizmos cuando se selecciona este
objeto Queremos acceder a la
clase Gizmos y acceder al color. Y voy a poner
el color al rojo. Entonces con artilugios de color de puntos, esto aplicará cualquier
Geismo que implementemos debajo de esta línea
aquí a este Y por ejemplo, si
implementamos un par
de códigos aquí y luego implementamos otros cambios de
color a verde, por
ejemplo, entonces
esta implementación afectará a todos
los Geismos que
implementamos después de esta línea Entonces así es como funcionan los colores
de puntos de los gizmos . Entonces, simplemente eliminemos eso. Y luego vamos a borrar
toda esta línea usada,
y vamos a acceder de nuevo a
la clase Gizmos, y podemos dibujar par nuestros muchos cubos en forma de frustum
gutture Voy a usar
la esfera de alambre. Y este es un método. Y para el centro, voy a usar la
transformación de la posición del objeto de juego de daños por explosión aquí. Y para el radio, lo
adivinaste que aquí
vamos a usar este valor Así que solo duplico esto y lo
pego aquí. Y seguridad. Y si volvemos aquí a la unidad, ya ves que si aplicamos el guión de daño por
explosión, ves que si aumentamos
el radio de daño, tendremos un indicador de radio. Entonces, cuando aproximamos el
tamaño del radio de daño en la pantalla, podemos estimar el tamaño óptimo antes de que esta explosión
afecte a los enemigos cercanos. Entonces, vamos a establecer este 23. Y aquí si vamos a
la vista superior aquí, verás que pulse play, la explosión es
aproximadamente
del tamaño de tres en cuanto a radio. Esto debería ser suficiente. Para el retraso hasta destruir, podemos verificar la duración, que es de 2 segundos actualmente. Sólo vamos a establecer el retraso hasta que se destruya a
también 2 segundos, pero voy a agregar 2.2. Tardó más tiempo hasta que
destruyamos este objeto de juego. Volvamos a Fiscal Studio y continuemos con el guión aquí. Ahora queremos ejecutar
el método destroy,
y luego vamos a destruir
este objeto del juego después del retraso hasta que lleguen los segundos de
destrucción. Ahora lo siguiente que tenemos que
hacer es crear un método y este
será un método personalizado. Voy a llamar a este
daño objetos cercanos. Aquí, cuando
ejecutamos este método, queremos agarrar todo el colisionador dentro
de una
esfera que estamos lanzando Así que vamos a crear una clase
colisionar aquí u objeto, y matriz de colisionador, y vamos a llamar a
esto llamadas Y podemos usar la clase de
física acceder a su método miembro y
usar la esfera de superposición. Esto también piden una
posición y también radio. Solo pasemos la
transformación de esa posición, y para el radio,
solo usemos el radio dañado. Ahora, vamos a obtener un montón de colisionadores almacenados dentro de
esta matriz de llamadas, y tenemos que mirar a
través de ese colisionador Vamos a crear una declaración de
cuatro e. Para la variable,
voy a llamar a
esta llamada Stans Form collider, y para la colección,
podemos simplemente agarrar la colección de llamadas
aquí y guardar Básicamente, queremos
comprobar si la variable o el objeto que
estamos iterando actualmente, queremos comprobar
si el objeto tiene un i hable componentes
unidos a él o no Vamos a crear una matriz capaz, o simplemente podemos copiar el código del
script del reproductor. Solo echemos un vistazo. Podemos agarrar esto, y luego pegarlo
aquí. Ahí vas. Básicamente, tenemos que cambiar la cadera al objeto de
juego de llamadas aquí. Vamos a escribir llamada. Como esto ya es colisionador, no
necesitamos
acceder al colisionador Simplemente borremos
eso. Y queremos pasar un rayo fundido dentro de
esta declaración if aquí. Entonces básicamente, en cada mirada
de nuestros cuatro cada uno de aquí, queremos crear
un rayo lanzado desde la posición
central de daño de explosión hasta el objeto de juego que ha
golpeado als unido a él. Así que vamos a crear un nuevo ray cast it, llamemos a este hit. Y entonces vamos a
crear otra declaración if. Y esto sería una
física que tiene Rak, y vamos a usar anulaciones
el
octavo override Entonces queremos usar esta
variante del método. Básicamente, queremos usar el origen de la explosión
y la dirección, y el rac ha golpeado
como parámetro out Así que vamos a escribir transformar esa posición aquí
como el origen. Y para la dirección,
podemos simplemente agarrar el objeto de juego colisionador que actualmente
estamos iterando Agarrarlo transforma esa posición, y podemos restarlo con
la posición de transformación Y con la resta de factores, obtendremos la dirección desde la posición central hasta la posición objeto
del juego del colisionador Aquí para el tercer método, vamos a sacar la operación de fundición resultante
al parámetro o variable hit
que hemos declarado aquí, y ahora podemos guardar esto. Aquí dentro de este hables o el
segundo para cada bucle aquí, podemos pasar el hit cast como argumento para
el método
hit y la seguridad Pero para el daño de explosión, queremos
asegurarnos de que mata al enemigo con
solo un golpe. Necesitamos modificar nuestra interfaz
o hittable. También tenemos que pasar
un daño entero, y podemos establecer este
valor por defecto en uno. Bien. Básicamente, con
este valor predeterminado, si no especificamos el valor de
daño, entonces pasará uno como valor de
daño por defecto. Simplemente podemos dejar la implementación
anterior sin cambiar el código aquí, por ejemplo, el objeto dinámico. Podemos simplemente sí, aún
necesitamos
implementar el daño. Entonces vamos a escribir daño, pongamos estos dos iguales a uno. Comprobemos el otro
guión. Para guión enemigo. También necesitamos
modificar el hit able. Sí. Ahí vas.
Tenemos un error. Sólo vamos al método
de golpe y luego
sumemos un h daño igual a uno. Ahora aquí en el guión enemigo, solo
podemos usar ese daño para restar nuestra salud
actual. Vamos a solo Y la seguridad. La otra cosa que tenemos que comprobar
son los efectos hat. Sí. Tenemos que modificar
esto también en daño uno. No vamos a estar usando
este entero aquí, pero aún así porque implementamos
eso en nuestra interfaz, necesitamos pasar
esos valores aquí. Y ahora si vamos
al daño por explosión, ve
que el método del sombrero ahora pronto va a pedir
un daño entero. Pero como establecemos el valor
predeterminado en uno, no
necesitamos pasar eso. Pero para este daño por explosión, queremos pasar un
valor muy alto, por ejemplo, 100. Por lo que matará al enemigo
instantáneamente y salvará esto. Posteriormente,
también vamos a usar este valor de daño para crear una variante de arma donde podamos tener un arma mejor o una mayor que tenga
un mayor valor de daño. Para el
guión del jugador, ahora mismo, podemos simplemente encender esto tal como está. Bien. Ahora tenemos
esto implementado. Tenemos que ejecutar esto al principio. Simplemente ejecutemos el método de daño cerca de mis objetos al
inicio y guardemos esto. Lo último
que tenemos que hacer es crear un spawn on
shoot un guión que la explosión al
disparar o en la Vamos a crear un subíndice U, y vamos a llamar a este engendro
en un solo vamos a abrir Para spawn on it script aquí, este es un
script bastante simple en realidad, por lo que podemos eliminar el inicio
y el método de actualización, y necesitaremos implementar
la interfaz capaz, y luego solo
implementemos la interfaz Ahora vamos a
crear un campo de seriales, y este será
el objeto del juego Podemos simplemente llamar a
esto prefabricados pata. Entonces podemos crear
otro campo Serres, y este será A B y
podemos llamar a esto destruir en él Y vamos a implementar
el método hit aquí. Básicamente, queremos comprobar primero si el p choose
paw no es nulo. Para evitar la excepción de
referencia nula, y dentro de esta declaración, entonces queremos instanciar
la pata de elegir, y queremos establecer el spawn en el objeto del juego
hit
transformar Y después de transformar
esa posición, queremos pasar una rotación
por defecto, que es cuaternion Y ahora queremos comprobar
si el on hit es cierto, entonces queremos destruir
este objeto de juego. Y el engendro en él objeto de
juego será el objeto que
genere la explosión, por
ejemplo, o cualquier otra cosa Por ejemplo, un
barril, un barril de gas, o algo que sea
explosivo o inflamable Solo guardemos esto, y
volvamos a Unity. Lo siguiente que
tenemos que hacer es, ya
he descargado
estos activos de Unity ***. Es gratis. Se llama
Ci Barriles 40 muestra, y voy a poner el enlace
a la descripción aquí. Vamos a presionar importar. Solo importemos esto. Pero no
voy a importar la escena aquí porque
no vamos a necesitar eso. Bien. Solo importemos esto. Una vez que se haya importado,
voy a dirigir la muestra de la carpeta de barril de ciencia ficción al
interior de la
carpeta del juego del
proyecto del juego de guión bajo aquí Ahora, vayamos
aquí al prefecto y seleccionemos el
que queramos usar Probablemente voy
a usar esta. Vamos a solo d barril blanco S al
grupo de ambiente aquí objeto de juego. Y debería estar
en algún lugar de nuestra escena aquí, está aquí, y
pongámoslo aquí. Vamos a comprobar el tamaño de. Creo que podemos
ponerlo ahí. Solo ocultemos esta guía aquí. Ya no vamos a necesitar
esto. Vamos a
desactivarlo y guardar la escena. Ahora si seleccionamos aquí el objeto de juego barril
blanco, primero
voy a agregar
un colisionador Necesitamos un colisionador.
Solo agreguemos un colisionador de cajas y se ajuste Después queremos agregar el componente
spawn on hit. Para que el pref genere, vayamos al
poseedor del prefex y arrastremos la gran explosión que
hemos preparado antes, y habilitemos la destrucción
al golpear Ahora vamos a abrir la
ventana de la consola aquí y presionar play. Entonces, esperemos un
rato hasta que
aparezca el enemigo . Ahí vas. Aparece y también aparece, y vamos a disparar el
explosivo aquí. Ahí vas. Mata a
todo el enemigo. Entonces es bastante agradable que
tengamos esto y podamos usar esto para ayudar al jugador a
navegar por un área más difícil. Y si le echa un vistazo aquí, tenemos un problema de que la distancia restante de obtener sólo se
puede llamar
a un agente activo. Y esto está sucediendo porque
aquí en la carrera soso, estamos comprobando si la distancia restante del agente es mayor que este valor aquí, y esto se
ejecuta en la actualización Entonces después de que el enemigo es asesinado, estamos inhabilitando al agente Ahí van, y
este problema causante. Así que vamos a agregar una condición aquí encima
de la declaración if. Y agregar si el
agente está deshabilitado. Básicamente, queremos verificar
si el agente no está habilitado, entonces queremos
regresar, y guardar esto. Y vamos a
probarlo una vez más para ver si este error sigue mostrándose o sigue
ocurriendo o no. Presionemos play, y
esperemos al enemigo. Bien. Entonces ahora volvamos
a disparar el cañón. Bien. Ahí vas.
Matamos a los dos enemigos, y ya no tenemos
ese error. Sí, así es como
creamos un utilería explosiva, y puedes usar cualquier otro tipo de
explosión si quieres Simplemente agregue el
daño de explosión a las explosiones.
14. 13 arma personalizada: Hola. En este video, vamos a crear un mecanismo
de arma personalizado. Para que podamos cambiar arma basándonos en el
arma que recogemos, y si el MO
se queda sin esa arma, queremos volver
al arma por defecto Bien, primero, primero, necesitamos crear
un nuevo script CS, y esto derivará
del objeto scriptable Así que voy a crear
una nueva subcarpeta dentro la carpeta scripts y voy a llamar a esto objetos
scriptables Aquí dentro de la carpeta de
objetos descriptibles, vamos a crear
un nuevo script de Shap, y llamemos a esta arma Datos. Y vamos a abrir un guión. Como este script va
a ser un objeto scriptable, necesitamos cambiar el tipo de comportamiento
mono aquí a un objeto scriptable Y objeto scriptable es
básicamente un script que
podemos guardar como un activo
en nuestra carpeta de proyecto, y puede contener y también método Y también queremos mover el método arriba aquí del guión del jugador
a estos datos de arma. Queremos mover todo
este guión o código de disparo
a los datos del arma aquí. Otra cosa que
tenemos que hacer, necesitamos definir un menú
para crear un menú fijo aquí. Encima, vamos a
crear un atributo y pida dos argumentos. Primero es el
nombre del archivo. Ambos son de cadena. El primero es nombre de archivo y el segundo es el nombre del menú. Para el nombre del archivo, podemos establecer este nombre de archivo dos datos de arma
iguales o podemos agregar un dato de arma
personalizado. Entonces aquí dentro del nombre del
menú entre paréntesis, queremos pasar datos de armas Y cerrar esto con unos
padres, y seguridad. Básicamente, esto nos
permitirá crear este objeto scriptable usando el menú dentro de la carpeta del
proyecto Simplemente eliminemos la actualización y comencemos, no vamos
a necesitar eso. Vamos a crear
un dato personalizado aquí. Primero, necesitamos crear
un enumerador personalizado. Vamos a crear una costumbre aquí fuera de nuestra clase de datos de
armas. Vamos a escribir am pública, y voy a
llamar a este tipo de fuego. Y habrá una
sola y rápida. Rapid es para el
tipo de arma automática y solo es para el arma normal o
el arma por defecto. Vamos a crear las variables
necesarias aquí. Primero, vamos a
necesitar el tipo fuego. Vamos a escribir el tipo de fuego
como el tipo de variable, y voy a llamar a este tipo. Y el segundo
será la tasa, pero esto debería ser un float, entonces escribe float y llámelo rate. Voy a establecer este
valor predeterminado en 0.15. El siguiente campo
será un entero, y este será el MO máximo. Y el otro sería un entero también y este
sería el valor del daño. También necesitamos crear
otro bleion para definir si estos datos de armas
son el arma por defecto o no Vamos a crear un bleion
llamado arma por defecto. Y también necesitamos declarar un par de variables privadas. Primero, necesitamos tener una
referencia a nuestra cámara. Vamos a crear un tipo
privado de cámara. Simplemente llamemos a
esto CM. También necesitamos tener una referencia
al guión de nuestros jugadores. Simplemente llamemos a este jugador, y también una referencia
a la O actual, y también necesitamos crear
una variable flotante para mantener nuestro próximo tiempo de disparo. Bien. Y como necesitamos una referencia al
script del jugador y también a la cámara, necesitamos inicializar este objeto scriptable
usando un método,
y ese método se
llamará desde el script del
reproductor aquí Entonces voy a crear un arma de configuración de vacío
público. Y voy a pasar la
cámara como primer argumento, y el segundo
sería el guión del jugador. Yo sólo llamo a este jugador también. Bien. Entonces dentro de
este método aquí, podemos definir primero la variable KM aquí
usando esta declaración, esta igual K, y esto se referirá
a esta variable aquí, la variable local que
tenemos dentro de nuestra clase, y esto será referido al argumento que
estamos pasando aquí. El segundo
debe ser el jugador
a jugador igual jugador, y también queremos establecer el
siguiente tiempo de disparo para que sea cero, para que podamos disparar de inmediato
cada vez que comience el juego. También para el MO actual, queremos llenar
esto al siguiente MO que hemos establecido en
el inspector aquí. Eso será todo por
la configuración del arma, y el otro método
que queremos crear es el fuego del vacío público. Para el fuego, no
necesitamos ser públicos, así podemos configurar esto
solo para que sea privado. Solo vamos al guión del
jugador aquí, vamos a copiar todo esto
aquí dentro del método de actualización. Lo siento, voy
a
resaltarlos todos desde la declaración I
hasta los corchetes de cierre, haga clic
derecho, y
luego presione copiar, y luego voy a pegar
esto dentro del método fire. Tendremos errores. Bueno. No hay errores
porque ya definimos el CM aquí para que podamos
usar esto de inmediato. Y voy a
crear un vacío público, y solo voy a
llamar a esta actualización de armas. Y este es el método al
que vamos a llamar desde nuestra actualización del
guión del reproductor, reemplazando todo esto aquí. Bien. Dentro de la
actualización de armas, básicamente, queremos comprobar
si el tipo de fuego es un solo disparo
o un disparo rápido. Vamos a crear sentencia if, y si el tipo igual
a fuego tipo single. Entonces queremos tener
otro código aparte. Si es rápido, entonces deberíamos tener un tipo diferente de mecanismo de
disparo. El primero,
vamos a usar la entrada if, obtener el botón del mouse hacia abajo, y vamos a
agarrar el click izquierdo. Este valor cero indica
el click izquierdo, y dentro de aquí,
queremos ejecutar el método fire. Queremos ejecutar este
de aquí. Oh, lo siento. En el método fire, ya no
necesitamos la instrucción input get button
down. Así que vamos a eliminar esto
y el último paréntesis aquí, y voy a organizar esto volviendo
a la sangría Y luego cuando estamos disparando, entonces queremos restar por uno
el MO actual Y aquí, dentro del tipo de disparo
rápido, queremos usar una entrada
que obtenga el botón del mouse. Cero. Entonces este
es para sostener, y volverá
strug cada vez que mantengamos pulsado el botón del ratón Y esto es sólo en el primer fotograma cuando el
usuario presiona el botón del ratón. Entonces esto solo sucedió una vez, y esto sucede
a lo largo de muchos fotogramas, depende de cuánto tiempo el usuario
esté sosteniendo el clic izquierdo. Y queremos agregar una declaración donde el tiempo el
tiempo sea
mayor que el siguiente
tiempo de incendio. Y prueba segura. También queremos verificar si el MO actual es
mayor que cero. También queremos verificar si el MO actual es
mayor que cero, y queremos crear
una sentencia if, y esta si el O actual
es menor o igual que cero. Para esto aquí, solo podemos
crear la declaración else. Aquí, vamos a
escribir el registro de errores y escribir O se
agota, por favor vuelva a cargar Podemos simplemente copiar esta línea
aquí y pegarla aquí, así que arrojará
el mismo mensaje. Y ahora aquí, queremos ejecutar el método de fuego y
también restar el MO actual Entonces queremos establecer el
siguiente tiempo de disparo para que sea igual a nuestro tiempo actual cuando
estamos disparando en este momento aquí y
luego sumar el valor de la tasa. Este es el valor de la tasa. Por lo que solo
podremos disparar automáticamente en este momento o si el tiempo tiempo es mayor que
nuestro último tiempo de disparo siguiente. Habrá un
intervalo entre disparo. Aunque esta es
una muy corta, igual que un arma automática, y podemos cambiar este
valor de tasa en el inspector, así podemos afinar esos
valores para que se ajusten mejor a nuestra característica
de arma,
y vamos a guardar esto. Ahora que tenemos esto
dentro de la actualización de armas, también
queremos crear una condición de
Pareja. Y
esta sería si actualmente estamos usando
el arma por defecto, y estamos presionando el botón. Lo siento, no para obtener botón,
obtener la mayoría botón hacia abajo. Y éste
será el click derecho. Entonces por eso estoy usando
uno como argumento. Entonces queremos rellenar la O. Corriente O igual al MO máximo. Y esto es para el arma
por defecto. Queremos establecer que podamos
recargar para el arma predeterminada, pero para un arma personalizada, no
podremos recargar Y luego aquí, también
queremos declarar si esto no
es un arma por defecto, y la O actual es
igual o menor que cero, entonces queremos volver a cambiar
al arma por defecto. Pero aún no hemos implementado esto en el guión de los jugadores, así que voy a voy
a escribir un comentario aquí. Bien, guarda esto, y
creo que debería estar bien. Vamos al guión del jugador. Voy a arrastrar
el guión de reproducción, para ser el sitio de
nuestros datos de armas, así que es más fácil cambiar. Y ahora solo podemos
eliminar de manera segura todo esto, la actualización. Voy a crear
un nuevo campo Suris, y esto sería un dato de arma, y esta sería
el arma por defecto Y voy a crear
una variable privada, y llamemos a esta arma data, y esta sería
el arma cur Actualización interna,
queremos comprobar si nuestra arma curn no es nueva, entonces queremos ejecutar
el arma cur arma Y aquí, vamos a
crear un método público, y llamemos a
esta arma de cambio. Y para cambiar de arma, necesitamos pasar un
dato de arma como argumento, pero queremos establecer un valor
predeterminado de null aquí. Entonces podemos ejecutar este
método sin pasar ningún argumento y
automáticamente pasará un
dato de uL a este método aquí. Entonces queremos establecer el valor actual del arma a
lo que sea que estemos pasando aquí. Queremos verificar si no es nulo, entonces queremos pasar el arma, y si es nula,
entonces queremos
pasar el arma por defecto aquí. Entonces parece que
he escrito mal esto, así que debería ser arma por defecto Y voy a
usar este nombre aquí. Entonces básicamente, este es
un operador ternario. Y si esta afirmación es cierta, entonces ésta se pasará
al arma actual. Pero si esto es falso, entonces ésta se pasará
al arma actual. Y después de cambiar de arma, queremos ejecutar el arma
actual, establecer un método de arma, y tenemos que pasar la cámara. Entonces este sería el CM aquí. Y el siguiente argumento es
el propio guión del jugador, así que solo podemos pasar esta
afirmación como argumento. Y aquí, cada vez que
empezamos, queremos ejecutar el
arma switch sin argumentos. Entonces estamos asignando el arma por defecto
al arma carino, y esa va a ser el arma que vamos a usar dentro del método de actualización Vamos a guardar esto. Y
para los datos del arma, también
voy a usar el arma switch aquí dentro de
esta declaración if aquí. Entonces básicamente, si no es el arma por defecto y nos
estamos quedando sin MO, entonces queremos volver a cambiar
al arma por defecto. Así que sólo podemos acceder a la variable
player que
hemos preparado. Y vamos a llamar
al arma switch, y no necesitamos pasar
el argumento para volver a poner esto al arma por defecto. Guarde esto. Bien. Entonces volvamos a la unidad
aquí y vamos a darle una oportunidad. Ya terminó de compilar. Entonces si vamos a la cámara
principal aquí, ahora tenemos una ranura de arma
predeterminada dentro de la cámara o
el guión del jugador. Voy a crear una carpeta. Oh, perdón, esto debería
estar dentro del juego, así que voy a
arrastrar esto debería estar dentro de la carpeta del juego. Y dentro de los datos, voy a
crear un dato de arma aquí. Como puedes ver,
ya
tenemos este menú de activos , crear menú de activos. Entonces hagamos clic en esto, y esta
sería la pistola por defecto. Y para el arma por defecto,
podemos establecer estos dos sencillos, y por el valor de daño, podemos establecer este 21, y el
MO 210 máximo, probablemente, y vamos a comprobar esta arma
por defecto. Y para el arma por defecto, entonces podemos seleccionar la cámara principal, y podemos asignarle esta
al arma por defecto aquí. Bien. Entonces ahora voy a crear otra arma y esta
será una ametralladora. Y para la ametralladora,
tendremos un MO máximo de 13. Establecer este tipo dos envolverlo y un mayor
valor de daño para masticar, y voy a desactivar
el arma por defecto aquí. Guarde esto. Ahora para probar esto. Básicamente, este código aquí
no va a funcionar todavía porque necesitamos implementar la recolección de
armas más adelante. Pero vamos a probar
esto si ves que si cambiamos los datos
del arma, ¿funcionará el guión
del jugador?, solo probemos esto. Voy a presionar play. Ahora sólo puedo disparar
una vez cada clic. Y tenemos que disparar tres
veces para matar el trasero. Lo siento, aquí hay un problema
con el trasero. Voy a comprobar esto primero. No estoy seguro de qué causó
el error antes, pero ahora parece
estar funcionando bien. Así que vamos a
darle una oportunidad de nuevo. Ahora usando el
arma por defecto, arma por defecto. Necesito disparar tres veces uno,
dos, tres, uno, dos, tres. Cambiemos esto
a una ametralladora. Voy a volver al
objeto guionable
de ametralladora aquí Voy a cambiar el valor del
daño a tres. Entonces veremos que solo
necesitamos disparar una vez para matar al enemigo, pero hay una cosa que
tenemos que modificar en
el guión aquí. En el arma que aquí, tenemos el
valor del daño declarado. Pero aquí, cada vez que
golpeamos, no pasamos un valor de daño, así que por defecto será uno, como puedes ver en
el abrigo ahí dentro. Entonces voy a agregar la variable de valor de
daño como segundo argumento y
seguridad, y esto debería funcionar. Y no necesitamos probar el arma por defecto
porque es Lo siento,
V. Sí, V. Sí, porque el arma por defecto
tiene un valor de daño de uno. Entonces debería comportarse
igual que si antes porque tenemos
el valor predeterminado de uno. Y la ametralladora tienen valor de
daño de tres. Cuando salió el enemigo, podemos ver que podemos
disparar una vez y
matará al enemigo
enseguida. Oh, lo siento. Se me olvidó reemplazar esto. Todavía estamos usando los datos del arma
ametralladora. Entonces, cambiemos esto a la ametralladora y volvamos a
guardar la escena. Bien. Vamos a escribir. Le
disparas a estos robots. Ahí vas. Un disparo, y mata automáticamente. Entonces sí, ahí tienes. Tenemos un arma personalizada, y podemos crear muchas armas diferentes
dependiendo
de la característica
del arma en sí.
15. 14 Recogida de armas: Entonces, continuemos con nuestro mecanismo
de armas personalizado. Y ahora vamos a crear el mecanismo para recoger
un arma de un bonus. Entonces primero, vamos a crear un guión, y este sería
un nuevo guión CH, y llamemos a esta arma pick up y este sería un guión muy
simple, en realidad. Entonces voy a
abrir esto ahora aquí, ir al estudio iso. Sí. Ahora está abierto. Voy a volver
a guardar los datos del arma Y aquí, necesitamos crear
un nuevo campo serializado, y este será un
tipo de datos de armas, y llamemos a esta arma Y también necesitamos una
variable privada de guion de jugadores, y vamos a llamar a este jugador. Y empiezo, queremos agarrar el guión del jugador
de nuestra escena. Así que vamos a escribir player
igual objeto fino de tipo y pasar el
guión del jugador como el tipo, y queremos eliminar
el método de actualización. Y básicamente, queremos
asegurarnos de que ese arma recoja, implemente la interfaz i hable. Vamos a escribir el i hittable, y voy a implementar la interfaz
automáticamente aquí Y vamos a eliminar aquí
la excepción. Bien. Así que básicamente, cada vez que disparamos este arma
recoger objeto, queremos ejecutar el cambio de arma
jugador, y luego queremos pasar
esta variable arma aquí. Entonces esto configurará una nueva
arma en el lado del jugador, y podremos usar esa
nueva arma personalizada inmediato cuando
disparemos este objeto de juego. Y entonces queremos
destruir este objeto de juego. Bien. Así que volvamos a Unity, y vamos a
crear un nuevo cubo, y voy a escalar
esto aquí abajo, 20.6 Entonces agreguemos el
arma, recoja guión. Si vamos a la carpeta de datos, queremos poner esto
a la ametralladora. Y vamos a guardar esto. Si vamos a la cámara principal, o si seleccionamos el objeto de la cámara
principal, queremos
volver a ajustar el arma
predeterminada a la pistola predeterminada aquí. Solo guardemos esto y
cambiemos el inspector a la ventana de depuración aquí para que podamos ver nuestra arma actual por aquí Vamos a cambiar el nombre de este cubo
aquí que acabamos crear como la
ametralladora pick up. Y vamos a guardar esto como un prefabricado. Si vamos a los prefs,
voy a arrastrar esta ametralladora pick
up como un objeto prefs, y vamos a borrar
éste de la escena, y voy a duplicar
este objeto barril Pero en lugar de
generar una explosión, voy a engendrar
la ametralladora aquí, y voy a asegurarme de que
esté destruida Desactivemos este de aquí. Sólo podemos probar esta arma
pick up prefs. Guarde esto. Ahora si presionamos play, voy a tratar de disparar
y sólo puedo disparar una vez antes de disparar
la otra arma. Y ahora está vacía. Ya
no puedo disparar. Si hago clic con el botón derecho,
debería poder recargar. Voy a disparar este cañón, y ya ves que cambió
a nuestra arma, coge y vamos a hacer clic en esto. Ahora bien, si hago clic en esto, si
vamos a la cámara principal, ve
que nuestra
arma actual es la ametralladora. Solo intentemos filmar
esto tantas veces, y ahora estoy manteniendo pulsado el
botón del ratón, como pueden ver. Ahora cuando está vacío, vuelve a cambiar automáticamente a la pistola predeterminada. Por supuesto, vamos
a implementar la UI, por lo que le dará al
jugador una indicación si actualmente estamos usando el arma por defecto o
la pistola personalizada, y además nos mostrará advertencia o un mensaje si
necesitamos recargar nuestra arma
16. 15 efectos de armas: Hola. En este video, vamos a crear
un efecto de arma. Así que comencemos. Primero, vayamos a la carpeta de scripts debajo de la carpeta de objetos
programables, abramos el script de datos de armas Ahora queremos crear una
nueva variable de campo cero S, y esto sería un
tipo de objeto de juego. Simplemente llamemos a este bozal ex. También queremos crear
una nueva variable flotante, y esta sería la escala ex. Probablemente, queremos establecer
esto en 0.1 por defecto. También queremos crear un sistema de partículas
privado. Campo aquí, y vamos a
llamar a esto efectos de caché. Aquí, dentro del arma de configuración, queremos agregar una sentencia if y verificar si el
efecto bozal no es nulo Entonces si no es nulo, queremos instanciar
esto y luego guardar el
componente del sistema de partículas como un efecto de caché Primero, necesitamos crear un nuevo
objeto de juego de objetos temporales, y queremos crear una instancia
del efecto bozal Y aquí, necesitamos crear un nuevo método dentro
del guión del jugador, y vamos a crear
un nuevo vacío público. Y vamos a llamar a
los efectos musculares establecidos. Entonces queremos pasar la
transformación de los efectos. Y necesitamos también crear una nueva transformación y
llamemos a este efecto hijo. Primero, comprobemos si el eff
hijo no es nulo, luego si no es nulo,
queremos destruir el objeto de juego hijo Entonces queremos establecer el objeto
que estamos pasando
del arma para establecer su
a este objeto de juego. Entonces queremos
establecer el eff infantil. A esta corriente los efectos que
estamos pasando actualmente. Guarde esto. Volvamos a
los datos de armas aquí. Y luego queremos
ejecutar el guión del jugador, que es el jugador aquí, y luego queremos ejecutar el método
set bozal effect Y pasemos el objeto
tamp game, pero necesitamos pasar el componente
transform Vamos a escribir la transformación. Entonces aquí abajo,
queremos guardar en caché el sistema de partículas que se adjuntan a
este objeto de juego. Vamos a escribir el componente tat, y luego llamemos
al sistema de partículas. Y ahora tenemos que ir al método
del fuego aquí. Siempre que
disparemos, queremos reproducir la partícula de efecto caché. Para hacer eso, voy a crear un nuevo factor tres, y luego voy a llamar a
esta posición de hocico Voy a usar el objeto de
cámara y luego acceder al método
que se llama pantalla dos
punto mundo y pantalla dos punto mundo como para un
factor tres argumentos. Voy a crear uno
nuevo y voy
a agarrar la
posición del ratón x sobre el eje x. Para las Y xs, solo vamos a agarrar
la entrada más posición Y. Para las z xs, queremos establecer un valor muy pequeño que estén
muy cerca de la cámara. Por ejemplo, 0.2 debería hacer, y luego queremos
terminar aquí esta línea. Otra cosa que queremos
asegurarnos es que queremos crear una sentencia if y luego verificar si los
efectos de caché no lo son. Entonces queremos ejecutar
este código aquí. Simplemente pongamos la posición del
hocico dentro de la declaración if Entonces vamos a establecer
los efectos de caché, la posición do de transformación. La pausa del hocico que
acabamos de crear. Entonces vamos a establecer la rotación
del efecto de caché. Th rotación del cuaternión, y
vamos a obtener la dirección del rayo. Queremos usar la
dirección del rayo aquí. Lo último que
queremos hacer es jugar las partículas. Llamemos al método
de
reproducción de efectos de caché y guardemos esto. Ahora bien, esto debería funcionar. Volvamos a la unidad
y probemos esto. Dentro del ejemplo de efecto, vamos a los efectos de arma, y luego bajo prefs
tenemos esta carne muscular Duplicemos esto, y luego arrastremos este flash muscular
duplicado a nuestra carpeta de prefs Y ahora voy a abrir el efecto flash de hocico
y modificar esto Si vamos aquí, ya ves, en realidad ya
es un flash muscular muy
bonito, pero necesitamos cambiar un poco
los ajustes. Aquí, queremos
desactivar el looping, para que
ya no haga loops, solo juegue una vez Vamos a establecer la rotación y 20. Vamos a salir de los prefabs
y voy a renombrar
este objeto prefabs
a este objeto prefabs
a Aquí dentro de la carpeta de datos, queremos establecer los
efectos de bozal a ese objeto de juego Simplemente abramos los prefectos
y luego arrastremos aquí los efectos de bozal al objeto scriptable de nuestra arma y
para la ametralladora, también
podemos usar eso Pero después podremos crear ocho efectos de hocico
diferentes. Ahora vamos a probar esto. Si presiono play, deberíamos
poder ver el. Tenemos un problema aquí. Como puedes ver aquí, si
selecciono la cámara, los planos de recorte se establecen en
0.3 en las propiedades cercanas,
pero aquí, cuando posicionamos
el flash de boca aquí,
ya ves, hemos establecido esto un valor que son
más pequeños que los planos de recorte Entonces, para arreglar esto, podemos simplemente establecer el
valor cercano a un valor muy pequeño, escriba cero, y se ajustará
a 0.01 y guardará esto. Ahora bien, si presionamos play, de nuevo, podemos pero tenemos un efecto muscular
muy grande. Entonces necesitamos aplicar la escala
que aquí hemos declarado. Si ves aquí bajo
el campo serializado, tenemos una escala fX campos declarados, pero
nunca usamos esto Entonces para poder usar esto, solo
podemos ir aquí
y luego insertar una nueva línea y acceder a la
escala de nuestro objeto de juego de tiempo, y luego establecer este valor en vector
igual tres punto uno, y quiero multiplicar
esto con nuestra escala f X. Y para el
valor por defecto es 0.1. Entonces vamos a escalar la partícula en una décima parte
de su tamaño predeterminado. Volvamos a la unidad aquí. Y si comprobamos la
pistola por defecto y la ametralladora, tenemos una escala de efectos de 0.1. Entonces, si presionamos play ahora, el efecto hocico debería ser
menor. Sí. Ahí vas. Si queremos disminuir esto, podemos simplemente establecer estos dos valores
aún más pequeños. Y para la
ametralladora, podemos establecer esta una ligeramente más grande
que la predeterminada. Así que vamos a escribir 0.07 aquí. Bien. Ahora si disparamos, verás que tenemos un destello de hocico muy
pequeño Pero si disparo esto, y luego cojo
la ametralladora, verás que tenemos un destello de hocico
más grande Bien. Hay otra cosa
que tenemos que arreglar aquí. Si presiono play, se ven
las partículas de impacto. Las calcomanías se enfrentan por
el camino equivocado. Básicamente, tiene
una rotación celular. Deberíamos alinear esta
partícula con la pared aquí. Vamos a abrir la partícula de
impacto de metal aquí, la p, abrir aquí
si expandimos esto, vamos al objeto de calcomanía me, y ves debajo
del renderer aquí, tenemos los conjuntos de
alineación de render para ver Solo cambiemos esto a local, y volvamos. A la escena aquí y
vamos a probar esto. Ahora si tiro aquí, las calcomanías se alinean perfectamente Ahí vas. Sí, eso es básicamente cómo
crear efectos de un arma.
17. 16 extensiones de acción de retraso: En este video,
vamos a crear un conjunto de herramientas en un script
de extensión. Para hacer eso,
vamos a la carpeta de scripts,
y dentro de la carpeta de scripts, vamos a crear una nueva carpeta
llamada extensión. Dentro de esta carpeta, vamos a
crear un nuevo script de Shop, y llamemos a esta extensión.
Y abramos esto. Entonces para ti que se pregunta
sobre el script de extensión. Tal vez algunos de ustedes
ven a menudo que cada vez que
creamos control o
detección de entrada, estamos usando la
clase de entrada así, y luego estamos ejecutando un método como get button
o get button down. Y esto es básicamente una extensión para hacer cosas relacionadas con la
entrada. Y también podemos crear
nuestra propia extensión para otro conjunto de herramientas que se proponen
hacer otras cosas Así que vamos a eliminar esto, y vamos a empezar
y el método upput Y también vamos a eliminar ahí
la
herencia de comportamiento mono. Y vamos a establecer esta
clase para que sea una clase estática. Y ahora podemos crear un método estático que van
a ser usados en otra clase, y este script
no tiene que estar unido a un
objeto en la escena. Entonces ahora voy a crear
un nuevo método estático público, y voy a llamar a
esta acción retardada. Y vamos a estar requiriendo un
par de argumentos en su interior. Lo primero,
vamos a usar esta palabra clave, y luego el tipo
será comportamiento mono, y voy a llamar a esta B, y la segunda
será una acción, así podremos pasar un método o delegar al
segundo parámetro. Vamos a escribir la acción del sistema. Y llamemos a esta
acción y guardemos esto. Y también necesitamos crear un nuevo enumerador estático para
hacer la rutina principal aquí Entonces, llamemos a esta rutina central
retrasada. Y luego queremos volver a
pasar una acción. Vamos a escribir sistema esa acción para declarar
la clase de acción, y luego
llamemos a esta acción. Y también necesitamos un
flotador como retraso. Y aquí también necesitamos pasar un flotador como tercer argumento. Y ahora dentro del enumerador, podemos simplemente usar el yield, devolver nuevo peso por un segundo, y luego pasar el
delay como valor Y después de eso, podemos
simplemente ejecutar la acción. Podemos verificar si la acción es
nula o no usando el signo de interrogación y
luego escribir punto invoke Entonces esto es básicamente verificar
si la acción es nula o no, y si no es nula,
entonces queremos invocar el método
dentro de esta Entonces la seguridad, y ahora dentro de
la acción retardada, podemos simplemente escribir la MV, que es nuestro comportamiento mono, porque iniciar la corrutina
solo puede ser ejecutada desde
una clase de comportamiento mono, así que necesitamos pasar
esto, iniciar co rutina, y luego podemos pasar
el nombre de corrutina, que es la corrutina retardada
que tenemos aquí abajo Y entonces podemos pasar la acción, que es la acción,
y para el retraso, podemos pasar el retraso. Seguridad. Y esta palabra clave
será como una extensión
del comportamiento mono. Entonces ahora mismo, si vamos al
player skip,
por ejemplo, podemos usar esa extensión usando la palabra clave dis, y esto hará referencia a este comportamiento mono ahora mismo que tenemos el script del reproductor, y luego podremos ejecutar
la acción delay. Como puedes ver aquí,
ahora tenemos este método, y dice que es una
extensión allá. Y ahora podemos pasar un método. Y luego después de pasar el
método, podemos pasar el retraso. Entonces por ejemplo, si quiero ejecutar un determinado método o
un determinado delegado, y luego paso cinco por el
retraso este delegado
se ejecutará 5 segundos después de que se ejecute
el inicio. Entonces ahora sólo voy a
crear un nuevo delegado aquí. Y luego voy
a crear un código. Vamos a escribir depurar ese registro. Y luego
acabemos el código aquí. Podemos simplemente escribir ejecuciones de acción
retardadas después de 5 segundos y guardar esto. Y esto reside en
el guión de los jugadores. Entonces ahora si volvemos a Unity, y luego verificamos en
el panel de la consola, y luego si presionamos play, verás que vamos a
tener ese mensaje. En 5 segundos. Ahí vas. Aquí, ves que ese código dentro del delegado se
ejecuta después de 5 segundos. Ahora hemos creado esta extensión de acción
retardada, y esto será bastante
útil para ejecutar un método retardado o un código
retrasado si es necesario, y así es como
creamos esa extensión. Básicamente podemos extender
cualquier tipo de clase, comportamiento
moo, factor tres, o cualquier otro objeto
18. 17 estados de administrador de juego: En este video, vamos a
empezar a crear nuestro manager de juegos, y también vamos a
empezar a implementar
los estados del juego. Así que cada estado, podemos
ejecutar unos códigos separados, como cuando estamos
iniciando el nivel, podemos establecer el listo para
probablemente alrededor de 3 segundos y podemos mostrar un
texto animaciones y luego iniciar el juego. Y también al final, queremos cambiar de estado a
nivel para que podamos comenzar a
calcular la puntuación. Entonces, para hacer eso, vayamos a la carpeta de scripts, y vamos a crear un
nuevo guión C sharp, y llamemos a
este juego Manager. Notarás que una vez que
creamos el administrador del juego, tiene iconos diferentes, y este es el
ícono predeterminado que Unity ha proporcionado para cualquier script que esté usando el
nombre Game Manager. Ahora podemos abrir esto
en estudio fisial, y para el manager del juego, primero, queremos declarar un gestor de juego
estático público, y llamemos a esta instancia Esta será una propiedad, así que
voy a establecer un getter público Pero para el armador, voy
a establecer un setter privado. Y de esta manera, esta propiedad sólo se
puede establecer a partir de
este script aquí, pero puede ser
o se puede acceder a ella
desde cualquier otro script. Y la referencia estática, asegúrese de que esta variable solo tenga una instancia
transversal en el proyecto. Entonces es compartido.
Y ahora queremos crear un nuevo método void weight, e inicialicemos la variable de instancia
o
las propiedades y
pasemos este script por sí mismo Ahora fuera de esta clase, vamos a crear un nuevo público en y este
será el estado del juego. Y para el estado,
voy a establecer un estado por defecto y
para el estado de inicio. Y el estado de jugabilidad, y el último debería
ser el nivel y el estado. Ahora que hemos
declarado el estado del juego, podemos usar esto en nuestra clase de manager de
juegos. Así que vamos a crear
un nuevo campo sealizado, y para un tipo, este será un estado de juego, el um que hemos declarado aquí, y para el nombre del objeto o
el nombre de la variable,
llamemos a este estado Y también
necesitaremos una referencia al guión de movimiento del jugador. Vamos a crear un
nuevo campo serializado. Y voy a mecanografiar
jugadora movida por un tipo, y vamos a llamar a
este jugador movida. Y ahora queremos eliminar
el método de actualización, ya que no lo vamos a
usar ahora mismo, y vamos a crear
un nuevo vacío público, y este será un método de estado de
cambio. Y con este método nos encargaremos del estado
de cambio de nuestra jugabilidad. Entonces, para el argumento, vamos a escribir game state, y llamemos a este nuevo estado para el nuevo estado
que estamos pasando. Y queremos comprobar si
nuestro estado actual es igual al nuevo estado que
estamos pasando cuando estamos
ejecutando este método, queremos devolver este método. Así que no ejecutes ningún
código abajo aquí. Y si es diferente, entonces queremos poner el estado al nuevo estado
que estamos pasando. Y aquí queremos
usar la caja del switch, y queremos verificar el valor del estado
actual. Así que aquí, vamos a
abrir un paréntesis, y luego si es el caso inicio del estado del
juego, entonces queremos
ejecutar un cierto código aquí y luego agregar break. Y luego podemos simplemente duplicar estos bloques de código y
luego pegarlo dos veces. Y vamos a cambiar
el estado a jugabilidad, éste, y el
último debería estar nivelado. Entonces ahora tenemos una declaración
switch que maneja tres estados
de nuestro juego. Y ahora mismo no hemos configurado ninguna interfaz de usuario o texto para
el estado de inicio. Así que vamos a ejecutar un registro de depuración, y vamos a escribir game Start. Así lo podemos ver en la consola. Y luego aquí, podemos usar la acción retardada que hemos implementado
en el último video, y luego simplemente podemos pasar a un
nuevo delegado. Como la acción. Y para el delegado, queremos ejecutar el método
switch state. Y luego para el estado, queremos cambiar
esto a jugabilidad. Y aquí como segundo argumento, podemos simplemente pasar la duración. Entonces queremos ejecutar este
código aquí después de 3 segundos. Y ahora podemos simplemente ejecutar un registro de atrás aquí
dentro de nuestro juego, y vamos a escribir el juego de
estado. Y podemos agregar tiempo aquí. Tiempo tiempo. Se ve que el tiempo se
deriva cuando se ejecuta este
código. Así que ahora al inicio, también
queremos asegurarnos de que el
guión de movimiento del jugador esté deshabilitado. Oh, he escrito esto mal. Debería ser el movimiento del jugador. Por lo que queremos asegurarnos de
que el movimiento del jugador esté actualmente deshabilitado
en este estado. Así que vamos a establecer el valor
habilitado en caídas. Y podemos simplemente copiar
esta línea aquí, y al comenzar la jugabilidad, queremos habilitar el guión. Ahora tenemos esto implementado. Vamos a
ampliar esto más adelante. Pero ahora mismo en
el método de inicio, vamos a ejecutar el estado del interruptor y establecer esto para iniciar el juego. No vamos a usar
el valor por defecto, pero queremos asegurarnos de
que cuando estemos ejecutando arranque la primera vez que se inicie
este nivel, el estado y el nuevo
estado serán diferentes. Será por defecto
al estado predeterminado, y luego cuando ejecutemos inicio
del estado del switch
en el método start, voy a cambiar el estado Judi aquí Entonces ahora vamos a guardar esto. Y como creamos una referencia de instancia estática
para este gestor de juegos, podemos acceder a este script desde cualquier lugar desde cualquier otro script. Y como este
también es un método público, podemos acceder a este método
desde cualquier otro script. Así que después cuando hayamos
terminado el juego, podremos activar este nivel
y estado desde otro guión. Ahora volvamos a Unity. Una vez compilado,
voy a crear un nuevo objeto anti juego y
restablecer el valor de transformación, y voy a llamar a
este gestor de juegos, luego agregar el guión, y voy a asignar
el movimiento del jugador. Dirige la cámara principal a
este movimiento del jugador y
registrará el guión de movimiento del jugador que está adjunto a
la cámara principal aquí. Voy a poner al
manager del juego encima aquí para que podamos acceder a él fácilmente
y guardar la escena. Ahora si abrimos la consola aquí,
voy a aclarar esto, y si presionamos play, verás que el
juego comenzará, y después de 3 segundos, se ejecuta. Aquí, cuando comenzamos a registrar
el estado del juego aquí, imprime el
estado de tiempo que es de 3 segundos. Así que después de 3 segundos, podemos iniciar la jugabilidad. En esos 3 segundos después, podemos crear una animación de interfaz como un texto listo
o algo más. Posteriormente cuando terminemos el juego, podremos cambiar
al nivel y estado
y comenzar a activar los cálculos de
puntaje. Entonces eso es para crear
el estado del juego, y posteriormente, vamos a expandir este manager de
juego agregando un cálculo de puntaje y vida
o salud para el jugador.
19. 18 puntuaciones y vidas de Game Manager: En este video, vamos
a continuar con nuestro manager de juegos, y en esta parte, vamos a crear
las vidas y la partitura. Así que vamos al estudio de sal, y he abierto el manager del
juego aquí. Entonces ahora necesitamos declarar un
par de variables privadas. Entonces voy a crear
un nuevo entero privado, y el primero
sería el enemigo golpeado y luego disparó fuego. Y también necesitamos una carroza privada para nuestra salud actual,
para la salud del jugador. Y aquí, ambos, necesitamos
crear un nuevo campo serializado, y este sería
un tipo de entero, y llamemos a
este jugador salud y establezca su
valor predeterminado en diez seguridad Abajo start, vamos a crear
un nuevo método llamado en él. Aquí, queremos inicializar
la salud actual a la salud del jugador que aquí hemos declarado en el campo Ses Lo siguiente que tenemos que
hacer es crear un nuevo método de vacío público. Llamemos a este golpe de disparo, y queremos pasar un bulion, y llamemos a este golpe de bulion Y si hit es cierto, entonces queremos sumar
el valor de hit enemigo. Y queremos sumar también el valor de
los disparos disparados, ya sea que
faltemos o golpeemos al enemigo. Y vamos a utilizar esta ambas variables para calcular
la precisión de nuestros disparos. El siguiente método que
necesitamos crear es el golpe público del jugador vacío, y esto es para que
el jugador reciba
daño del enemigo. Queremos pasar un daño por flotación. Y al ejecutar este método, queremos subusar la
salud actual por el valor del daño Y asegúrese
de que todos los métodos estén usando el modificador de alcance público, para que pueda ser accesible desde otro script. Entonces,
vamos a guardar esto. Y ahora vamos a
los datos del arma, y dentro de los datos del arma, tenemos el método del fuego. Y aquí queremos comprobar
si golpeamos al enemigo o no. Entonces dentro de las cuatro H, podemos verificar si Nuestro objeto de golpe
actual es una instancia de
un guión enemigo. Entonces podemos verificar usando la palabra clave y luego escribir
el tipo del script. Y aquí podemos acceder a
la instancia del manager del juego y ejecutar el método shot hit y pasar a través
como argumento. Y asegúrate de que te devolvemos
el método aquí. Por lo que se saltará los
otros hitables. Porque si encontramos un
guión enemigo en el hitable, entonces significa que
debe ser el enemigo Aquí podemos agregar una
declaración L porque si
golpeamos otras instancias de hitable ese no es
el guión enemigo, entonces queremos pasar false como argumento
del método
shot hit aquí Y queremos
asegurarnos de que devolvemos el
método cuando golpeamos algo. Entonces bajo esta afirmación, la física tiene paréntesis. Queremos devolver el método. Y aquí, si
no pegamos nada, también
queremos ejecutar el
golpe de tiro con argumento falso. Así que vamos a copiar esta línea
aquí y luego pegarla aquí. Entonces básicamente, lo que
estamos haciendo aquí, estamos comprobando si el hitable es una instancia de
un guión enemigo o no Y si es cierto, entonces estamos pasando el verdadero
argumento como el golpe de disparo. Y devolvemos el
código porque
no queremos verificar si hay
más componente hitable Y si no encontramos
un script enemigo en absoluto, entonces estamos ejecutando
este código aquí. Y aquí, si echamos de menos
No pega nada, entonces todavía
queremos contar el disparo golpeado pasando el
falso argumento. Así que vamos a guardar esto, y volvamos a Unity. Y aquí, podemos seleccionar
al manager del juego. Debajo de la pestaña Inspector, queremos asegurarnos de que
damos clic derecho sobre ella, y luego seleccionamos el error. Así podemos ver la
variable privada en nuestro inspector. Entonces ahora presionemos play
y probemos esto. Y ahora ves
si disparo al aire, agregamos los disparos fuego. Y si disparo en la pared, también
agregamos los disparos fuego, pero el golpe enemigo se queda cero. Y ahora si golpeamos a un enemigo, ves que sumamos el enemigo golpeado y también los disparos disparan. Y vamos a tratar de
matar al enemigo aquí. Y se ve que tenemos
seis impactos enemigos y ocho disparos disparan porque
hemos intentado disparar en la escena porque
hemos intentado disparar antes
de disparar al enemigo, y estamos disparando en la escena sin golpear al enemigo. Entonces tenemos dos disparos adicionales disparados en comparación con el golpe enemigo, y podemos usar este valor para calcular la precisión más adelante. Hay una cosa
que tenemos que
hacer en el guión del manager del juego. Vayamos al estudio de Fificial. Bajo el
manager del juego. Al inicio, queremos ejecutar el método init Sólo vamos a escribir en él. Y queremos asegurarnos de
que la salud actual se establece al valor de
salud del jugador al inicio. Ahora bien, si volvemos a intentarlo, comprobamos nuestra
salud actual, deberían ser diez. Ahí vas. Pero aún no hemos
implementado esto, así que vamos a implementar
esto en el siguiente video.
20. 19 visual de captura de armas: En este video,
vamos a seguir creando una visualización
para nuestra captación de armas. Entonces para hacer eso, primero, necesitamos ir a la tienda de activos y descargar cualquier modelo de arma. He escogido esta,
la luz del arma Sipi, y pondré el enlace
en la descripción Entonces ya descargué
e importé este activo, y ahora está bajo
la luz del arma Sipi Entonces voy a arrastrar esta carpeta y ponerla
dentro de nuestra carpeta del juego. Y sólo para hacer
las cosas aún más ordenadas, voy a crear
una nueva subcarpeta
dentro de la carpeta del juego
y llamar a esto modelos Y vamos a poner todos
los modelos dentro de los modelos dentro esta subcarpeta que
acabamos de crear Para el Robot Kyl,
voy a mover eso también y también para
la luz del arma Sipi Ahora hemos puesto
todos los modelos
dentro de nuestra subcarpeta de modelos Vamos a la
vista del juego aquí, y primero, necesitamos modificar el
objeto prefs para nuestra recogida de armas Aquí tenemos la
ametralladora pick up prefs debajo de la carpeta prefs Solo abramos los prefs. Y si vas a la escena aquí, ves que estamos en modo prefs Y ahora podemos arrastrar el prefe de
nuestra luz de arma de ciencias ficción que
acabamos de importar Entonces voy a ir
a la carpeta prefs, y dentro de la carpeta gun light, la pistola tiene cinco
variaciones de color, así podemos escoger una de ellas. Creo que voy
a elegir este o tal vez este encendedor y establecer esto como un niño de
nuestra ametralladora recoger objeto de juego prefps Y ahora está en escena,
pero la posición no
es cero fuera, así que está en algún lugar por aquí. Para centrar la pistola acuerdo a su posición
padre, solo
eliminemos a cero
la transformación, así que podemos simplemente hacer clic en la configuración de la rueda **** aquí
y luego establecer la posición de reinicio. Y vayamos al objeto de
juego padre y simplemente eliminemos el componente de filtro de malla y también el renderizado de malla. Y voy a aumentar
el tamaño de nuestra escala de
recogida de armas masticando en cada eje Y luego coloquemos el objeto hijo alrededor del
centro de su objeto padre. Entonces creo que sí, esto
debería ser suficiente. Y si te cuesta
reposicionar esto debido
a la grilla pro, simplemente mantén presionado el
signo negativo en tu teclado, y puedes cambiar presionando el signo negativo y el signo más cerca del teclado del espacio posterior Puede cambiar el tamaño
del incremento o el valor de
las instantáneas de la cuadrícula Entonces ahora he reposicionado
mi arma aquí. Voy a volver
a nuestra escena aquí. Y ahora necesitamos
modificar el guión. De nuestra arma pick up y
también el spawn on hit script. Solo vamos a
la carpeta del script, y voy a seleccionar el script de pick up de armas
y abrirlo en fis Studio Ahora necesitamos crear un nuevo tipo de
campo serializable de flotador, así que vamos a crear eso, y voy a llamar a
esta velocidad de rotación Vamos a establecer este 290 predeterminado, y esto es en grado. Y como
vamos a multiplicar este valor por tiempo Delta tiempo, va a ser por segundos. Así que ahora vamos a crear
un método de actualización FOID. Y dentro de la actualización, voy a acceder
al componente transform y luego acceder al método rotate. Y voy a usar la
segunda sobrecarga del método, que es una para un
eje y un ángulo. Para el eje, voy a
escribir Vector tres puntos hacia arriba, entonces es el eje y, y para el ángulo, solo
vamos a alimentar la velocidad de rotación, pero vamos a multiplicar
esto por el tiempo Delta. Por lo que la velocidad de rotación
será consistente, que es de 90 grados por segundo. Así que vamos a guardar esto. Y la otra cosa
que tenemos que modificar es el spawn on hit script, déjame mostrarte
ahora si presionamos play, y si disparo en
esta arma pick up, ves que nuestra pistola está de alguna manera
sumergida al suelo Esto se debe a que el arma se está
instanciando en
la posición cero de nuestro
objeto de juego padre en este de aquí Por lo que se instanció
en este punto. Para arreglar esto, solo
abramos el script spawn on hit, y voy a agregar un
nuevo campo serializado Y para el tipo,
será un flotador, y voy a
llamar a esto y offset. Entonces este es el desplazamiento
en la posición y. Y voy a poner
estos dos hábil 0.5. Y al instanciar
el spawn prefab, queremos compensar la posición y aquí sumando con
el factor tres, y esto básicamente
va a compensar la posición de transformación
por uno en el eje y,
y luego queremos multiplicar
este valor por Entonces más tarde podremos ajustar la altura dependiendo de
nuestro valor de compensaciones y Solo guardemos esto, y
volvamos a la unidad. Ahora bien, si vemos el script, se actualiza y
tenemos un nuevo campo, que es un desplazamiento
y, y podemos cambiar este valor de acuerdo
a nuestras necesidades, dependiendo del tamaño
del objeto o de la
posición del objeto. He puesto a prueba esto y 0.5 parece ser una buena
relación calidad-precio en este caso. Voy a dejar
esto como está, y vamos a salvar nuestra escena. Ahora si presionamos play, Si disparo el cañón, ves que nuestra arma está
ahora en la posición correcta, y podemos
recoger esto disparándole, y ahora tenemos la
ametralladora activada. Entonces sí, así es como cambiamos la visualización del
modelo de captación de armas, y con esto, podemos crear tantas tomas de armas como sea posible.
21. 20 sistema de ataque de enemigos: En este video, vamos a seguir implementando
el guión enemigo, y esta vez
vamos a crear una habilidad para que el enemigo le dispare
al jugador. Para ello,
abramos el guión enemigo, y aquí necesitamos implementar
un nuevo golpe para mantener el valor del intervalo de disparo
enemigo. Vayamos aquí abajo y fuera de la clase de guión
enemigo. Vamos a crear
un nuevo público golpeado, y llamemos solo a
este intervalo. Rango. Y hagamos
esto serializable agregando un
sistema de atributos do Ahora vamos a crear un
nuevo campo serializado, así que está disponible
en el inspector, y este será
un tipo de float, y llamemos a esto
mínimo y máximo Entonces queremos crear un constructor
público
para los golpeados. Vamos a escribir public, y luego el rango de
intervalo de nombre tachado. Y luego abrimos con unos juegos de paréntesis y necesitamos
pasar aquí el mínimo y
el valor máximo Y esto básicamente
no es esta variable aquí. Es un argumento para
el constructor, y vamos a crear un corchete
de apertura. Y aquí queremos
establecer este valor mínimo usando la palabra clave este
punto significa igual a mínimo, y luego este máximo igual
a máximo y seguro. Ahora tenemos al constructor. Lo último que
queremos crear es un tipo de flotador público getter, y llamémoslo a
esto get value Aquí podemos usar un getter. Como esta va
a ser sólo una línea, podemos usar una expresión directa o
una Lamda Entonces simplemente escriba return
random random range, y podremos pasar el
mínimo y el máximo. Oh, lo siento, no necesitamos
la palabra clave escrita aquí, solo escribe rango de puntos aleatorio. Y el alcance será el
mínimo y el máximo. Esto devolverá este
valor aquí cada vez que
llamemos a estas propiedades.
Vamos a guardar esto. Ahora dentro de nuestra carpeta de
scripts enemigos, vamos a crear un nuevo campo serializado de esa estructura que
acabamos Vamos a escribir intervalo de intervalo, y vamos a llamar a
este intervalo, y queremos establecer un nuevo valor por defecto usando
el constructor con el valor predeterminado de probablemente
1.5 segundos, 2.7 segundos. Esto establecería el valor predeterminado de nuestras variables de intervalo, pero podemos cambiarlo
en el inspector. La siguiente variable
que queremos
crear es una variable flotante, y esta va a
ser la precisión de disparo. Y vamos
a establecer esto en 0.5 por defecto. Por lo que la precisión será
del 50% a este ritmo aquí. Y ahora vamos a crear un nuevo encabezado para organizar mejor
al inspector, y llamemos a esto propiedades de
tiro. Y ahora hemos declarado
las propiedades de tiro. Empecemos a crear la
rutina co para manejar el tiroteo. Aquí abajo el método de
anularlo público. Voy a crear
una nueva rutina central, y al igual que con la corrutina, necesitamos devolver el
tipo de numerador IE Simplemente llamemos a esta sesión, y no necesitamos
argumentos ni parámetros en ella. Ahora dentro de la corrutina de rodaje, necesitamos retrasar
nuestra rutina central hasta que el jugador llegue
a su posición Podemos usar el retorno de rendimiento
y usando la nueva palabra Q, tendremos esta espera hasta. Básicamente, esta espera
hasta que el método suspenda la ejecución de la corrutina hasta que el delegado de suministro
evalúe Q true Y básicamente pide
unos delegados que devuelvan
un tipo de booleano Para poder usar esto, solo
podemos usar una expresión
Landa,
y en solo
podemos usar una expresión
Landa, realidad es bastante fácil
usar la expresión Lamda, necesitamos proporcionar un
conjunto de paréntesis, y esta sería la
firma o el argumento Ya que pide un delegado que devuelva un tipo de toro
sin ningún argumento, podemos simplemente insertar un conjunto de paréntesis y luego un signo
igual con un signo aro Después de la rosign,
necesitamos poner un conjunto de corchetes para definir
la condición Ahora aquí podemos
crear la condición para este peso
hasta evaluar. Básicamente, queremos comprobar
si el enemigo ya llegó a su posición o no. Podemos simplemente agarrar aquí usando
la distancia restante del agente, y vamos a copiar
esta línea aquí, y luego pegarla aquí. Pero en lugar de verificar si el
descenso restante es mayor, solo
podemos verificar
si es más pequeño. Y podemos aumentar el
tamaño aquí para aumentar el umbral y luego agregar un punto y coma al final como de costumbre Y ahora ves que
todavía tenemos un error porque necesitamos usar
la palabra clave return. Entonces necesitamos devolver aquí
la condición o la comparación
de esta afirmación, ya sea verdadera o falsa. Y entonces si es cierto, entonces vamos a ejecutar
el código más abajo aquí. Y si es falso,
entonces esperará hasta que esta afirmación sea cierta. Ahora, después de que llegue el enemigo, queremos comprobar si
el enemigo no está muerto. Sólo podemos comprobar
es que es falso. Este signo de exclamación, carajo
si este bulion es falso. Si es falso, entonces se
ejecutará el código dentro del corchete. Y si el enemigo está muerto
o si eso es cierto, entonces el código se saltará
o no se ejecutará, y la corrutina se detendrá Y ahora aquí dentro de
los bloques wil, queremos generar un cierto valor
aleatorio, rango aleatorio, y queremos verificar 0-1, es menor que
nuestra precisión de disparo, entonces queremos
dañar al jugador Y ya declaramos cómo dañar
al jugador dentro nuestro manager de juego accediendo
al método de golpe del jugador. Así que vamos a usar ese
tipo game manager y agarremos la instancia o la referencia
estática y luego ejecutemos el método player hit, y podemos restar esto por uno Además, podemos ejecutar un registro de
depuración aquí y luego agregar un mensaje de que el
jugador ha sido golpeado. Y después de filmar aquí, queremos retrasar la corrutina
usando el valor de rango de intervalo Vamos a escribir retorno, nuevo peso por segundos, y pide un valor flotante. Y esto retrasará
nuestra co rutina usando el valor float que
pasamos aquí en segundos. Y podemos agarrar nuestra
variable de intervalo u objeto aquí. Al escribir el nombre del intervalo, y podemos usar la propiedad
get value, y la propiedad devolverá un valor aleatorio entre nuestro valor
mínimo y máximo. Así que ahora solo vamos a guardar esto. Y lo siguiente
que tenemos que hacer, tenemos que ejecutar esta
corrutina en la inicialización Entonces, si verificamos aquí dentro
del método init, podemos ejecutar la rutina co después de establecer el destino
de nuestro agente Y asegúrate de que la corrutina corra después de esta línea
aquí. ¿Por qué es eso? Porque aquí porque aquí estamos esperando que este
valor se haga realidad. Y si hemos establecido
un destino, entonces esto será
cierto enseguida, y esto
se ejecutará enseguida. Entonces ahora
comencemos el Curtin pasando el nombre Curtin, disparemos y guardemos Y ahora si
volvemos a Unity, podemos comprobar en la consola. Y también podemos seleccionar
el administrador del juego y cambiar el Inspector masticar
el error haciendo clic derecho, y vamos a comprobar nuestro valor de salud
actual Si presionamos play, y podemos
esperar hasta que comience el juego, y después de que llegó el enemigo. Podemos verificar, ahí
tienes. Nos han atropellado. Nos han golpeado de
inmediato, y como pueden ver, nuestra salud actual ahora está
disminuyendo a medida que nos golpean. Pero aquí hay un problema porque el tiroteo
cotin corre enseguida. Encontré el problema aquí
dentro de la rutina de rodaje. Tenemos que retrasar un poco
este código. Para arreglar esto, solo
podemos agregar un nuevo rendimiento, devolver nuevo peso por segundo, y luego pasar un valor
muy pequeño. En este caso, voy
a pasar 0.2 segundos. ¿Por qué tenemos que retrasar esto? Tenemos
que asegurarnos de que el destino del
conjunto del motor se haya ejecutado y ya
se haya inicializado De lo contrario, si la
rutina co ocurre
en el mismo marco con esta ejecución de código aquí, y esto devolverá
verdadero inmediatamente. Tenemos que demorar eso. Y
una vez que tengamos un destino, la
distancia restante del agente cambiará a un valor bastante grande dependiendo de la posición
del enemigo a la posición
objetivo. Al retrasar esto, si
volvemos a la unidad, verás que si
presiono play ahora, una vez que comenzó el juego, podemos ver el registro de errores aquí, y nos dirá
si el enemigo ha sido girado y el primero ya ha sido engendrado y el
segundo ha sido engendrado, y comenzará a
disparar cuando deje de pararse o llegue
al destino Ahora ya le dispara al jugador dos veces tres
veces y ves que nuestra salud actual es actualmente seis y decreciendo aún más. Entonces tenemos el
ataque enemigo funcionando, y luego necesitamos
crear un visual para dar retroalimentación al jugador de que
ha sido golpeado.
22. 21 Visual de ataque de enemigos: En este video,
vamos a seguir
trabajando en el mecanismo de
ataque enemigo, y esta vez vamos a trabajar en el aspecto visual del mismo. Entonces para hacer eso, vayamos a la carpeta de modelos
y a la luz de la pistola Sipi Y bajo la prefe tenemos
un par de variantes aquí. Voy a duplicar
el rojo, y voy a dirigir
esto a la carpeta pref Y ahora voy a
renombrar esto a ganancia enemiga. Después de renombrar esto,
voy a abrir a este prefecto y comenzar a trabajar en
las imágenes de rodaje Y con las imágenes de disparo, vamos a utilizar
un sistema de partículas Ahora vamos a
crear un ob hijo, un objeto hijo vacío, y luego para el objeto hijo, llamemos a esta toma X. Luego agreguemos un sistema de
partículas. Lo primero que queremos
hacer es que queremos expandir
la pestaña de emisión y luego
asegurarnos de que el valor de la tasa a la pestaña de emisión y luego
asegurarnos de que el lo largo del
tiempo establezca 20, y queremos usar
la emisión de ráfaga
en lugar de la tasa a lo largo del tiempo. Solo presionemos más aquí
y luego fijemos el conteo 21. Esta voluntad sólo emite
una partícula a la vez. Vamos a establecer la duración uno aquí, para que podamos ver cada segundo. Movamos la posición
del emisor alrededor de esta posición aquí al cañón frente a la posición
del cañón Y queremos asegurarnos de
que la posición z esté mirando hacia adelante. Lo siguiente que tenemos que
hacer es que necesitamos expandir la pestaña de forma aquí
y establecer el ángulo 20, y también el radio cero. Entonces vamos a tener unas partículas
hacia adelante. Ahora, siguiendo el eje z aquí. Ahora vayamos a la pestaña
render aquí, expandamos esto y cambiemos
el modo de renderizado a mesh, y podemos usar la malla
predeterminada de unity, la cápsula uno.
Solo usemos esto. Para la alineación de render, cambiemos esto a local. Lo siguiente que tenemos que
hacer es que tenemos que ir a la pestaña principal aquí y luego habilitar la rotación de inicio de tres
d y establecer el valor
x en 90 grados. Ahora la bala se alinea
perfectamente con la pistola y también con la dirección de la
partícula este momento es demasiado grande,
así que necesitamos cambiar el tamaño inicial a
un valor muy pequeño y 0.07 así que sea un
buen tamaño inicial Y ahora tenemos unos efectos de bala de
partículas muy bonitos. Creo que voy a hacer
esto aún más pequeño 20.05 k Y ahora necesitamos
habilitar también el rastro
de esta partícula aquí. habilitar también el rastro
de esta partícula aquí Vamos a desplazarnos hacia abajo, y luego, debajo de la
pestaña de senderos , habilitemos esto y expandamos esto. Ahora tenemos un rastro, pero el tamaño es aproximadamente el mismo que el diámetro
de nuestra cápsula, así que
ya no podemos ver la cápsula porque está
superpuesta entre sí. Así que vamos a cambiar el tamaño modificando el ancho
sobre el sendero aquí. Voy a establecer esta curva dos haciendo clic el menú desplegable del lado derecho, y con la curva aquí, podemos modificar el
tamaño del rastro n a uno muy pequeño. Ahora ves que
tenemos una muy n y también
podemos disminuir un poco el tamaño
inicial. Como pueden ver, aquí tenemos una forma de sendero
muy bonita. Y ahora necesitamos crear un
material para esta partícula. Solo vamos a las carpetas de
material, y voy a
crear un nuevo material, y esta será
la bala enemiga. Y el segundo
sería el rastro. Vamos a crear un nuevo
material de nuevo y luego llamar a este rastro de balas enemigo. Para la bala enemiga,
voy a cambiar el material a
partículas estándar let, y voy a
habilitar la emisión. Para el LBD, voy a
cambiar esto a un color rojo. Para la emisión,
voy a establecer esto un color naranja y establecer
las intensidades en 0.5 Con los
efectos de disparo de partículas, objeto de juego seleccionado, vamos a dirigir
la bala enemiga al material de aquí. Y debería cambiar el
material de bala, como pueden ver. Para el sendero,
vamos a configurar esto como un material t y establecer este color al color naranja
bala. Podemos simplemente usar el seleccionador de
color aquí y luego elegir el
color naranja por aquí Pongamos este
rastro de bala enemigo como material de rastro. Si vamos por debajo en el componente
del sistema de partículas aquí, podemos dirigir el rastro de bala
enemigo
al material del rastro,
y ahora tenemos esto. Bien. Ahora necesitamos establecer la velocidad de inicio
a un valor más alto, probablemente diez, así que es más rápido, y queremos
desactivar también el looping
y también desplay en una casilla de verificación de
wake aquí Entonces debería jugar sólo una vez, y vamos a desencadenar
esta partícula de script. Entonces volvamos
a la escena aquí y abramos a los prefectos
enemigos Ahora vamos a expandir la raíz ósea aquí y más allá
hasta el hombro, el antebrazo superior del brazo
y la muñeca. Una vez que hayamos visto la muñeca
derecha unirse aquí, vamos a trazar el arma enemiga mientras el hijo de la muñeca
derecha se une Y vamos a reajustar aquí la
transformación del arma enemiga. Y vamos a rotar esto, está alineado con los huesos
de la mano aquí. Solo rotemos esto.
Al mantener el control, podemos ajustar la rotación
cada cinco grados. Voy a rotar también
en el eje z aquí. Ahora podemos mover esto, pero
como el progrid está habilitado, solo
deshabilitemos esto primero, para que podamos moverlo de manera
más precisa Y si queremos comprobar si
el arma está alineada correctamente, mientras el poste apunta, solo
seleccionemos el objeto de juego
Robot Kyle. Pasa por la ventana de
animación aquí. Y si no ves
la ventana de animación, solo
pasemos por la ventana. Debajo de la animación, solo abre
el panel de animación aquí. Voy a esto, esto, y luego bloquear la ventana del
panel de animación aquí. Siempre que seleccionemos
otro objeto de juego, el robot permanecerá
en el poste de apuntamiento. Ahora vamos a ajustar aquí la
rotación del arma. Y luego solo giremos un poco el eje
z también un poco y movamos esto ligeramente hacia arriba y rotemos
esto sobre el eje x aquí. Bien. Entonces sí, esto
debería ser suficiente, y ahora volvamos
a la escena aquí. Ahora vamos a trabajar
en el guión enemigo. Entonces vayamos a la pestaña del proyecto aquí y luego abramos
el guión enemigo. Y ahora tenemos abierto el guión
enemigo. Necesitamos crear un
nuevo campo suizado. Y este será un tipo
de sistema de partículas. Y llamemos a
esto efectos de disparo. Esta será la referencia
al sistema
de partículas del arma enemiga. Guarde esto. Y aquí abajo dentro de
la corrutina de rodaje, queremos ajustar la dirección de los efectos de
disparo según el estado de
golpe o no Entonces aquí queremos establecer
los efectos de disparo que transformen la transformación de
la rotación, y vamos a pasar la rotación de aspecto cuaternión en base a que el enemigo se
transforme hacia adelante, y luego vamos a sumar un valor aleatorio usando
la esfera unitaria interior Esto agregará desviación. Aquí dentro de la declaración I, queremos anular de nuevo
la rotación. Y esta vez, tenemos que
asegurarnos de que la dirección de la partícula
llegue a la cámara. Vamos a usar de nuevo la rotación de
aspecto cuaternión. Esta vez vamos a
agarrar la referencia del jugador, y como
ya lo hicimos,
así podemos simplemente escribir player, agarrar su posición y
restarle esto con los efectos de disparo,
transformar esa posición Y de esta manera, el
delantero de nuestra partícula se alineará perfectamente con
la posición de la cámara, y dará la
ilusión de que la bala está
golpeando al jugador. Guarde esto. Y fuera de
la sentencia if, queremos acceder
nuevamente al sistema shot ex particle y luego ejecutar el método play. Y esto activará la
partícula una vez y guardará esto. Volvamos aquí a la unidad, y vayamos al prefe poseedor y
abramos los prefs enemigos Y aquí, bajo
el guión enemigo, deberíamos tener un nuevo campo EffX de
tiro, y vamos a abrir
el arma enemiga,
expandir el arma enemiga aquí, y luego arrastrar el objeto del juego de
disparos como el sistema
de partículas de este efecto de disparo Así que volvamos
a nuestra escena aquí, y luego probemos esto. Presiona play, y mira si el enemigo ahora tiene una
representación visual del ataque. Ahí vas. Tenemos una
representación fisial de nuestro ataque, pero necesitamos modificar la
partícula. Vamos a hacer eso. Ahora vamos a la pestaña del proyecto. Bajo prefs.
Abramos los prefs enemigos Aquí, selecciona el
Robot Kyle y
queremos interpretar al ídolo de puntería. Y vamos a bloquear de nuevo la ventana de
animación. Y aquí bajo los efectos de disparo, queremos seleccionar
estos efectos de disparo, y queremos acortar la
vida útil de nuestro rastro Aquí, vamos a desplazarnos hacia abajo debajo
de la pestaña del sendero, abrirla. Para toda la vida,
vamos a establecer este 20.1, o incluso más corto 0.08 La otra cosa que
necesitamos cambiar aquí bajo el panel principal o
la pestaña principal aquí, para el espacio de simulación, necesitamos establecer este dos mundo. Y solo apliquemos
el juego de armas enemigas o, presionemos aplicar todos, para que los ajustes se
pongan seguros a la prefeb. Ahora bien, si presionamos play, la partícula es mucho
más corta el rastro. Y si actualmente nos estamos
moviendo, la partícula se quedará
en el espacio mundial. No consigue rotar con
el objeto del juego padre. Ahora solo
volvamos a la escena aquí y probemos esto de
nuevo. Presiona play. Y puedes esperar hasta que llegue
el enemigo. Y ahora se puede ver que
dispara y nos golpea. Actualmente. Si ampliamos la depuración, se ve
que nuestra salud
es muy baja ahora. Entonces, ahí vas con la visualización del ataque
enemigo.
23. 22 efectos de daño de los jugadores: En este video,
vamos a crear un efecto cuando el jugador
esté siendo disparado por el enemigo. Entonces para hacer eso,
primero, necesitamos
importar un nuevo activo,
y este activo es
un y este activo es error de Keno creado
por K Jio Takahashi Es un efecto de imagen, y voy a poner el enlace
en la descripción. Entonces para no anotar esto, podemos ir a comprometernos aquí y luego seleccionar el paquete Keno
glitch unity Una vez que estemos en la página del paquete Kino Glitch
Unity, simplemente descargue el archivo aquí, y se descargará
el paquete Ya lo he descargado. Y ahora vamos a importar
ese paquete. De vuelta en Unity, vamos
al menú assets import package, haga clic en custom package,
y voy a importar el paquete de Kino glitch Unity,
y luego presione import Ahora, después de importar
la falla de kino, vayamos a la cámara
principal aquí, y luego agreguemos el componente de
falla digital Ahora vamos a trabajar
en el guión del jugador. Vamos a la carpeta de scripts y luego abrimos el guión del reproductor. Aquí tengo abierto el guión
del jugador, y primero, queremos crear
un efecto de movimiento de cámara. Entonces para hacer eso, voy a crear un
nuevo cotin aquí abajo Y voy a llamar a
esto hacer movimiento de cámara. Voy a añadir un
par de argumentos. El primero
sería un tipo de flotador, y este será un temporizador. El segundo
sería también un flotador, y esta sería la amplitud, y el tercero también un flotador, pero esta sería la frecuencia. Dentro de la rutina c, queremos crear un nuevo vector t para almacenar la
posición inicial de nuestra cámara. Así que vamos a escribir en él pausa, y luego vamos a agarrar la
transformación de esa posición, y queremos también crear
una nueva variable vector t, y esta será
la nueva posición. Pero para comenzar,
también
vamos a utilizar la transformación de
esa posición. Y abajo aquí,
queremos crear un nuevo float llamado duration, y queremos pasar el temporizador como el valor de nuestra variable
duration. Abajo aquí, voy a
retrasar el código aquí por un valor muy pequeño,
un 0.2 segundo. Y luego voy a
crear el loop aquí. Entonces vamos a usar la sentencia
wild y luego pasar el valor de duración
si es mayor que cero. Entonces, si bien la duración
es mayor que cero, queremos ejecutar el método
shake aquí. Y aquí, primero,
voy a restar la duración por el tiempo
el valor de tiempo Delta Y entonces voy a
ejecutar el yield return No, para mirar esta declaración while. Y con substriting
la duración con un tiempo que Delta time, estamos haciendo la
duración como un temporizador Entonces ahora, lo primero
que queremos hacer, queremos verificar la
distancia entre
el nuevo factor de posición
con la posición actual. Si La distancia es muy pequeña, o la posición de la cámara está muy
cerca de la nueva posición, entonces queremos calcular
una nueva posición aleatoria. Entonces voy a volver a poner la nueva posición a la posición
init Pero esta vez voy a modificar la posición x sumando un rango aleatorio de
uno negativo a uno positivo, y voy a multiplicar
esto por la amplitud. Y para la posición y, vamos a hacer lo mismo. Voy a pegar este
código aquí y luego cambiar el componente al valor y y luego usar el mismo rango aleatorio multiplicado
por el valor de amplitud. Entonces, básicamente, queremos
comprobar si la cámara es a o casi llega
a la nueva posición, entonces queremos establecer una nueva posición aleatoria en
el eje x y. Y luego queremos fijar la posición de nuestra cámara
a la nueva posición. Pero vamos a utilizar un factor tres punto b para interpolar
nuestra posición anterior, que es nuestra posición actual
a la nueva posición Y para el valor de interpolación, vamos a usar
el argumento de frecuencia que estamos pasando
sobre la corrutina, y luego vamos a multiplicar
esto con tiempo punto delta T. Entonces la frecuencia
será relativa al tiempo,
no a frame por segundo Y después de esta declaración salvaje, queremos establecer la
transformación de esa posición de nuevo a la posición
innata Y ahora necesitamos un método público para ejecutar esta rutina central. Así que vamos a crear una nueva cámara
pública de sacudidas de vacío. Y necesitamos el mismo
argumento que nuestra co rutina. Así que vamos a copiar
todo el argumento aquí y luego pegarlo dentro
del método de la cámara de sacudidas. Dentro del método de la cámara de sacudidas, queremos iniciar
la rutina co y luego pasar el nombre de la rutina co, luego pasamos el argumento, el temporizador, la amplitud
y luego la frecuencia. Bien. Así que ahora vamos
al manager del juego, y cada vez que el jugador golpea, necesitamos ejecutar este método de cámara de
sacudidas. Entonces ahora necesitamos una referencia al guión
del jugador de
nuestro manager de juegos. Así que vamos a crear un nuevo campo de serialización y
luego escribir el guión del jugador Y luego llamemos a
este guion de jugador. Y aquí, podemos simplemente ejecutar el método de script del jugador llamado shake camera que
acabamos de crear, y luego pasar el tiempo, la amplitud y
el valor de frecuencia. Para el temporizador, voy a
configurar estos dos medio segundo, y para la amplitud, voy a establecer este 20.2, unidades, y para la frecuencia, voy a establecer este 25 Puedes cambiar este valor para ajustar el batido a tu gusto, pero este va a
ser mi valor aquí. Y ahora volvamos a la unidad. Primero, en el manager del juego, tenemos que asignar la referencia del guión
del jugador. Así que vamos a arrastrar
la cámara principal a esta ranura de guión del jugador
aquí en el administrador del juego, y luego sake la escena,
y luego presione play. Entonces después de que se ejecute el juego, voy a esperar hasta que aparezca
el enemigo y luego esperar a que
nos disparen el enemigo. Ahí vas.
Tenemos un efecto de sacudida. Y ahora abramos
el guión del enemigo, y arreglemos el
disparo en dirección F X cuando el enemigo pierda dispararnos. Entonces aquí dentro del tiempo no
es esa afirmación.
Aquí tenemos esta línea. Y lo que queremos hacer
es que queremos multiplicar esta esfera unitaria interna aleatoria
con un valor muy pequeño. Entonces tenemos una desviación muy
pequeña. De lo contrario, tendremos una
desviación máxima de una unidad, que es bastante si ves. Entonces, vamos a
multiplicar esto por 0.1. Bien. Y lo siguiente
que queremos hacer es, queremos implementar el efecto de falla
digital que acabamos de importar al inicio
del video Entonces para hacer eso,
ir al guión del jugador, y luego encima del guión
del jugador, vamos a usar
el espacio de nombres de Keno Y luego aquí, vamos a crear una nueva falla digital privada, y luego
llamemos a esta falla ex Al inicio, queremos
inicializar esta falla eff. Solo usemos el componente get y pasemos el tipo de falla
digital Y ahora podemos usar esto dentro nuestra rutina de carbón de sacudir cámara. Aquí dentro de la duración while, solo
podemos acceder a los objetos del
efecto glitch y luego
modificar la intensidad Pero antes de modificar
la intensidad aquí, necesitamos crear una curva para modificar la intensidad
de nuestros efectos de falla Vamos a crear un nuevo campo s, y este será un tipo
de curva de animación. Y llamemos a
esta curva de falla. Y básicamente, con esta curva, podemos establecer un valor
de manera curva. Entonces podemos tomar esos
valores de nuestra curva evaluados por el tiempo o
la duración de la forma. Así que aquí dentro de la corrutina, vamos a agarrar la curva de
falla y luego ejecutar el método de evaluación
y luego pasar el tiempo Por el momento, voy
a usar la duración, pero voy a
normalizar la duración, así que voy a dividir
esto por el valor del temporizador. El temporizador es constante
en este caso, y la duración que
estamos modificando es la variable
duración. Salvemos esto, y
volvamos a la unidad. Ahora estamos de vuelta en la unidad. Tenemos que establecer la curva de falla
a algo como esto, así comenzará a cero,
y luego con el tiempo, la falla se elevará hasta
uno y luego volverá a disminuir 20 Y podemos probar esto, ejecutar la escena, y
veamos el efecto de falla Ahí vas. Tenemos el efecto
glitch funcionando, y si es demasiado fuerte, siempre
podemos ajustar
la curva para empujar hacia abajo la posición media a algún valor que sea
inferior a uno, probablemente 0.7 aquí, y vamos a ajustar
la tangente basi Entonces se alinea, y vamos a
probar esto de nuevo. Ahora verás que cada vez que nos está disparando el enemigo, intensidad de
la falla digital sube a 0.7 Ahí vas. Ahora está funcionando, pero tenemos que asegurarnos de que la falla digital de intensidad B sea cero cada vez que terminemos de
sacudir la cámara Entonces volvamos al
estudio visual, el guión del jugador aquí. Queremos establecer la intensidad de los
efectos de falla aquí, cero. Así que eso será todo por crear el
efecto de daño para nuestro jugador.
24. 23 Configuración de rehenes: En este video,
vamos a crear un
aspecto rehén o civil del juego Entonces queremos crear un nuevo guión para manejar
el movimiento de rehenes, y también queremos
asegurarnos de que
si disparamos al rehén o al civil, nuestras vidas se vean Y lo primero
que tenemos que hacer es abrir la carpeta de
animaciones, y necesitamos importar
el archivo de animaciones. Y ya preparé
el FBX para esto, y también incluyo los
archivos necesarios en las lecciones de video Así que vamos a dirigir
las manos de rehenes en el aire FBX a la carpeta de
animaciones Y luego vamos a
la carpeta Modelos, Textura
Robot Kyle, y voy a importar el robot color rehén.
Así que vamos a dirigir esto. Y ahora comencemos a
implementar el rehén. Ahora vayamos a
la carpeta de prefs, y luego para el enemigo,
seleccione al enemigo, y luego presione Control
D para duplicar,
y vamos a cambiar el nombre de
este rehén o civil Y ahora abramos esta
Pref y modifiquemos esto. Entonces no vamos a necesitar el arma. Sólo podemos quitar
el arma enemiga. Y luego queremos
crear un nuevo material
para el rehén Así que vamos a la
carpeta de modelos debajo de la carpeta
Robot kyle. Hay una carpeta de materiales. Simplemente dupliquemos
el color del robot, y llamemos a este
robot color rehén Y cambiemos el
color base o el albedo, el robot rehén
. Es el verde. Simplemente seleccionemos este, y creará un nuevo material. Y luego vamos a arrastrar este rehén de color
al modelo robot Ahora tendremos un robot
con diferente color. Entonces queda claro que
este es el rehén. Lo siguiente que tenemos que hacer, tenemos que preparar
el guión de rehenes Vayamos a la carpeta del script, y luego vamos a crear
un nuevo script C sharp, y llamemos a
este script de rehén Antes de modificar el script, vamos a la carpeta de
animaciones, y en la carpeta del controlador. Voy a duplicar el controlador enemigo
base, y llamemos a este controlador de
rehenes Y ahora queremos modificar esto. Así que vamos a hacer doble clic
en el Controlador de rehenes. Y ahora necesitamos
crear una nueva capa, y vamos a llamar a
esta capa superior del cuerpo. También queremos
crear una máscara de avatar. Simplemente hagamos clic derecho
en el proyecto, creemos, y luego vayamos a la máscara de avatar, y llamemos a
esta máscara de parte superior del cuerpo. Ahora con la máscara de la parte superior del
cuerpo seleccionada, expanda aquí el humanoide, y queremos
desactivar el suelo, la pierna, la pierna y el cuerpo Queremos dejar la mano en
el IK y la cabeza habilitada. Ahora con la masa superior del cuerpo, podemos ir al gallo de los ajustes
de capa aquí Queremos establecer el
ancho en uno y luego elegir la masa de capa como la masa de nuestra capa superior
del cuerpo aquí. Vamos a presionar el círculo aquí y luego elegir la máscara de la
parte superior del cuerpo. Y ahora lo siguiente que
tenemos que hacer es que tenemos que
poner las manos de rehenes
en los archivos aéreos FBX Rick tipo Q humanoide. Así que vamos a establecer el tipo de animación che
humanoide, y luego presione un pastel Y ahora, si ya
configuramos este humanoide, y luego deseleccionamos esto
y luego lo volvemos a seleccionar, vaya a la Verás que
tenemos esto aquí. Y las animaciones
solo tienen 50 fotogramas de largo. Entonces necesitamos cambiar
el valor de n a 50, y vamos a llamar los clips o cambiar el nombre de
los clips a rehenes Y también queremos
asegurarnos de que el
tiempo de bucle esté habilitado. Entonces ahora presionamos aplicar. Después de que preparamos las manos de
rehenes en el aire, queremos crear
un nuevo estado et, y luego para el estado, llamemos a
esta pose de rehén Y vamos a expandir las
manos de rehenes en el aire y dirigir
el clip de rehenes a esta ranura de movimiento en el estado del poste de
rehenes Bien. Una vez que hayamos configurado esto, queremos volver a nuestra escena aquí bajo
el modo prefs, seleccionar el kyle raíz, y luego cambiar
el controlador al
controlador rehenes uno Entonces ahora que hemos configurado el robot, empecemos a hacer el guión. Ahora vamos a crear
el guión de rehenes. Entonces ya creamos el archivo. Abramos esto
en visual studio, y queremos asegurarnos de
que el guión de rehenes deriva o heredó
del guión enemigo Vamos a cambiar el nombre del
comportamiento mono aquí al guión enemigo. Y ahora si guardamos esto, Luego eliminamos el
inicio vacío y el método de actualización. Si volvemos a la unidad aquí, verás que si voy a la carpeta de prefax y al pref de
rehenes, la abro, puedo borrar el script enemigo,
y luego puedo agregar
el script y luego puedo agregar
el Y el guión de rehenes
tendrá las mismas propiedades el enemigo porque este guión de
rehenes hereda
del Posteriormente vamos a
ocultar algunas de las opciones que no vamos a
utilizar para el guión de rehenes Pero ahora necesitamos modificar un par de cosas
sobre el guión enemigo. Simplemente abramos
aquí el guión enemigo y modifiquemos esas cosas. Arriba aquí, queremos
asegurarnos de que el agente NMS, el modificador de acceso al alcance
estén establecidos en protected Así que vamos a escribir protegido. De esta manera podemos usar este
agente en el script hijo. De lo contrario, si es privado, entonces el agente no
estará disponible en el guión hijo
o en una clase secundaria. Y aquí, en el guión enemigo, Queremos excluir el tiro de
cotin de inicio del guión de
rehenes No queremos ejecutar este cotin en el guión de
rehenes Para hacer eso,
necesitamos crear un nuevo método protegido, y este debería ser un
método virtual y luego anular, llamemos a este
comportamiento configurado. Con este comportamiento configurado, queremos cortar esta línea
aquí y luego pegarla aquí. Ahora podemos llamar a
este método dentro este si el agente
no es ahora declaración. Vamos a llamar a este
comportamiento configurado. La otra cosa que
tenemos que hacer es aquí, bajo el golpe, queremos
cambiar esto por el guión de
rehenes Para hacer eso,
necesitamos extraer esto también en un método virtual. Vamos a escribir otro vacío virtual
protegido, y llamemos a
esto ese comportamiento. Y luego aquí, queremos cortar esto y luego pegarlo aquí. Y entonces queremos ejecutar este método dentro de esta sentencia
if aquí. Así que vamos a escribir
ese comportamiento. Y ahora lo siguiente
que queremos hacer es en el script de rehenes, podemos sobrescribir esos dos
métodos que hemos creado Entonces para hacer eso,
vamos a escribir sobrescribir. Y entonces podemos elegir el método que
queremos sobrescribir Hemos creado la
configuración de comportamiento y el comportamiento muerto. Así que vamos a crear primero la configuración del
comportamiento. Y quiero eliminar las llamadas de configuración de comportamiento
base. Y vamos a sobrescribir esto escribiendo agente set destination Y esta sería
la posición objetivo. Y como puedes ver aquí, no
tenemos la posición
objetivo porque
la posición objetivo se
establece en un campo privado. Entonces, para arreglar esto,
volvamos al guión enemigo. Y para que la posición objetivo
transforme esta, voy a agregar una palabra clave
protegida. De esta manera, el puesto objetivo seguirá siendo serializado
en el inspector, pero la clase secundaria
tiene acceso a él Así que ahora podemos simplemente escribir posición
objetivo
posición y seguridades De esta manera, cuando
se llama al método init dentro
del crit rehén, la configuración de comportamiento que se ejecute será
diferente Y va a ser
esta configuración de comportamiento. Entonces no tenemos que iniciar el método de tiro de rutina
co. De esta manera, el enemigo no
disparará al jugador. Ahora lo siguiente que
tenemos que hacer es que tenemos anular
también el otro
método que hemos creado, que es el comportamiento muerto, y aquí queremos eliminar las llamadas base En lugar de
agregar la quilla enemiga, como esta de aquí, queremos
restar la salud del jugador Así que vamos a escribir game manager, la instancia, y luego
llamémoslo al jugador. Y ahora mismo podemos
sustraer esto por uno, pero probablemente necesitamos
sustraer con un valor mayor Entonces es más castigador cuando matamos a un rehén o a un Bien, vamos a guardar esto. Y ahora
volvamos a la unidad. Y para el rehén aquí, voy a poner el Mx retenido 21 Entonces solo necesitamos tomar un
disparo para matar al rehén. Y ahora aquí, vamos a crear una nueva zona de rodaje en el
segundo punto de lanzamiento. Queremos agregar
aquí al rehén para probar esto. Así que vamos a arrastrar aquí al rehén para que sea el hijo del
tiroteo 0.2, y coloquemos esto Creo que aquí podemos posicionar al
rehén en esta zona. Y rotar 90 grados. Y necesitamos crear un objeto
vacío para la posición
objetivo. Vamos a hacer eso, crear
un nuevo objeto de juego vacío. Vamos a llamar a esta posición
objetivo uno. Pongamos esto alrededor de
esta posición aquí. Bien. Ahora bien, si
seleccionamos al rehén, pongamos aquí la posición objetivo al slot pos objetivo Solo arrastremos esto
y luego pongamos esto como la posición objetivo.
Ahora, guarda esto. Vamos a probar esto. Ahora, matemos a este enemigo de aquí. Ahí vas. A ver si
el rehén está saliendo. Bien, aquí hay un error. El error fue al parecer, olvidé poner el objeto de juego de
rehenes aquí a la
ranura enemiga de aquí Entonces ahora mismo vamos a dirigir
aquí
al rehén a la ranura enemiga Y dado que el guión de rehenes es la clase hijo
del guión enemigo, es por eso
que somos capaces dirigir el objeto de
juego de rehenes a la ranura enemiga y
el guión de rehenes es
registrado por esta Y tenemos que hacer otra
ranura para el enemigo, y tenemos que
duplicar al enemigo. Simplemente dupliquemos a
este enemigo aquí y luego hagamos de este el hijo del
segundo punto de tiroteo, y pongamos
aquí a este enemigo y rotemos esto 90
grados sobre el eje y Vamos a crear una nueva posición
objetivo
duplicando esta y
probablemente ponerla aquí Y al seleccionar aquí al enemigo, queremos establecer la
segunda posición objetivo como la posición objetivo. Vamos a cambiar el nombre de esto,
seleccionar al enemigo y arrastrar esta posición objetivo a la ranura
de posición objetivo del guión enemigo aquí. Y ahora si seleccionamos
el tiro en el punto, vamos a arrastrar el objeto de juego
enemigo a la segunda
ranura enemiga de aquí. Y guarda esto y
vamos a probar esto. este momento, habrá
un tema donde necesitamos
matar tanto al rehén
como a los enemigos para
pasar el área del punto de lanzamiento Y eso lo vamos a arreglar.
Voy a matar a esto. Y ahora aquí se ve eso
cuando llegó el enemigo. Después de matar al primer enemigo, no
va a progresar
porque necesitamos matar al rehén y
el punto de tiroteo registra al rehén como Ahora después de disparar, entonces podemos continuar.
Tenemos que arreglar esto. Así que volvamos a la carpeta de scripts y abramos el guión
del punto de tiroteo. Y aquí, Bien. Dentro del método de la escotilla enemiga, en lugar de comparar el
valor de la escoba enemiga con la longitud
de la lista de enemigos, necesitamos crear
un nuevo número entero para dar cuenta del enemigo total
en esa zona de lanzamiento Entonces llamemos a
este enemigo total y creemos una nueva variable. Y ahora cuando estamos
enviando al enemigo, agreguemos la variable
enemigo total dependiendo de la
clase enemiga de aquí. Solo podemos usar un operador
ternario, y aquí necesitamos verificar si el objeto enemigo y la entrada enemiga desde
el objeto enemigo, que es un guión enemigo,
d no es un guión de rehenes Ahora tenemos este signo de
exclamación, y esto comprobará si esta
afirmación es negativa, entonces queremos sumar
al enemigo total Enemigo total suma por uno más, queremos que sumes al enemigo
total por cero. De esta manera, si el enemigo
es un guión de rehenes, entonces el enemigo total
no conseguirá sumar por uno Y vayamos abajo aquí, y ahora vamos a comparar al enemigo asesinado con la variable enemigo
total. Y ahora después de modificar esto, solo
agreguemos un log de depuración para ver si esto se
ejecuta o no. Así que vamos a imprimir el nombre del objeto del
juego en A, cadena, claro, y guardar esto. Volvamos a la unidad
y probemos esto. Así que presiona play, y voy a abrir aquí
el área de la consola. Entonces, vamos a disparar al enemigo. Y disparar 0.1 es claro, y vamos a matar
al segundo enemigo. Ahí vas. El
tiroteo 0.2 es claro. Entonces así es como implementamos el rehén usando herencia, y podemos comportarnos
anulando el método
25. Configuración del temporizador de 24 áreas: Hola. En esta lección, vamos a
crear un temporizador de área para cada punto de tiroteo. En cada zona,
vamos a iniciar un temporizador, y si el temporizador está terminado, entonces vamos a
pasar a la siguiente zona. Y esto creará
una posibilidad que el jugador no pueda
matar a todos los enemigos, así podremos crear un
sistema de puntuación más adelante basado en eso. Ahora para hacer eso, primero, queremos
abrir Pis Studio, y después queremos modificar
la clase de entrada al rodaje Vamos a ir más abajo y el
jugador mueve el guión aquí. Tenemos una clase personalizada para
el objeto de entrada de tiroteo. Y aquí queremos crear
un nuevo tipo de campo de flotación, y vamos a llamar a
este temporizador de área. Y también queremos establecer el valor predeterminado
para el temporizador de área. Y voy a poner
estos dos 15 segundos. Y dentro del guión del punto de
tiroteo, queremos agregar un nuevo método para anular el Vamos a crear un nuevo
método público llamado area Clear. Dentro de este método,
queremos verificar primero, no
podemos usar el nombre claro del
área porque ya ha sido
utilizado por esta propiedad aquí. Entonces, vamos a llamar a
esta área establecida clara. Y queremos comprobar si el bulion de
área clara es cierto, entonces queremos devolver esto y no ejecutar más el
método Y si el área aún no
está clara, entonces queremos despejar el área y queremos retomar
el movimiento del jugador. Vamos a acceder a
los
objetos de movimiento del jugador o variable aquí, y vamos a establecer el movimiento
del jugador en true. Y ahora, siempre que
el área esté despejada, queremos evitar que el
enemigo dispare. Entonces para hacer eso, necesitamos agregar un
nuevo método público dentro del guión enemigo. Voy a abrir aquí el guión
enemigo. Dentro de esta clase aquí, voy a crear
un nuevo método público, y voy a llamar a
esto dejar de disparar. F dejar de disparar, solo
podemos detener todas las cotinas dentro de
este comportamiento mono Como aquí solo tenemos una corrutina
dentro del script, podemos ejecutar este
método desde el comportamiento mono, y detendrá todas las
proteínas dentro de esta clase Bien, volvamos a
disparar punto aquí, y queremos mirar a
través del enemigo aquí. Y para los capaces,
solo llamemos a este enemigo. Y para nuestra colección de enemigos, se llama lista de enemigos. Vamos a escribir lista de enemigos. Para cada uno de los enemigos, queremos acceder al subobjeto
enemigo. Y este sub objeto enemigo
es un tipo de guión enemigo, por lo que podemos acceder de inmediato al método stop
shooting. Hola, esta es Roma
del futuro. Y en este guión,
el punto de tiroteo, hay un bicho que ha
sido señalado por Matt Hills Muchas gracias por
avisar este tema, y tenemos que
verificar si el enemigo
está destruido o no Porque si terminamos un área, cuando el temporizador va a cero, pero no hemos matado a todo el enemigo y matamos a
parte del enemigo, ese enemigo probablemente
ya sea destruido, y esto arrojará un error. Entonces para hacer eso, necesitamos verificar si el enemigo
y esta es básicamente
la entrada enemiga, y cada una de las
entradas enemigas tendrá el objeto de guión enemigo en ella, así que tenemos que verificar ese objeto. Y queremos comprobar
si el script enemigo que pertenece a esta entrada
enemiga es nal, entonces queremos continuar
a las siguientes iteraciones
de esto para cada bucle, así que solo podemos escribir continue, y esto omitirá
este código aquí Entonces para esa entrada enemiga, si el objeto script enemigo
ya está renovando o
ha sido destruido, entonces queremos saltarnos este código, y pasará al
siguiente enemigo de la lista. Entonces con este pequeño código, vamos a evitar
que ese bug suceda. Ahora tenemos este
método declarado. Queremos modificar el método
start shoot out. Y lo primero
que queremos agregar es, queremos pasar un flotador, y llamemos a este temporizador. Y dentro de este método, queremos usar la extensión de acción
retardada
que hemos creado. Y con esta acción retardada, queremos ejecutar el área
establecida despejada con el retraso de nuestro temporizador aquí
que pasamos en el método. Ahora si guardamos esto, volvamos al movimiento del
jugador, guion aquí, y verás que
tenemos un error porque ahora el inicio dispara un
para un argumento flotante. Solo pasemos el argumento
float
accediendo al índice de
entradas de lanzamiento de I, y queremos pasar
el temporizador de área. Ahora, básicamente, cuando
esto se ejecute aquí, el punto de lanzamiento
inicializará el
valor o variables necesarias, y luego retrasaremos
el
método set area clear con el tiempo como
intervalo retardado Ahora, volvamos a la unidad, y probemos esto. Entonces yo Selecciono la cámara
principal aquí. Verás que ahora tenemos
el temporizador de área de 15 segundos. Hagamos de esto un valor
muy pequeño. Por ejemplo, 5 segundos. Ahora probemos esto
, presionemos play, y veamos cuándo llegamos
a la zona de tiroteo. Ya ves después de ciertos segundos
, comenzará a moverse. Ahí vas. Se inicia movimiento. Significa que el
temporizador ya está terminado y empieza a
pasar a la siguiente posición. Vamos a agregar una interfaz de usuario más adelante. Pero ahora
lo siguiente que tenemos que hacer es que necesitamos crear
un nuevo objeto temporizador para contar
el temporizador para la interfaz de usuario más adelante. Voy a crear un
nuevo script C sharp, y vamos a llamar a este objeto. Y voy a abrir este
script dentro de Visual Studio, y voy a quitar
el comportamiento mono. Entonces esta será una clase personalizada. Dentro de esta clase de objeto de tiempo, queremos crear un nuevo objeto de rutina co
privado, y llamemos a esto,
y queremos crear un nuevo método público
llamado starter. Y como aquí vamos a
usar una rutina co, necesitamos pasar un
comportamiento mono a este método. Vamos a escribir un comportamiento mono
como primer argumento, y voy a llamar a esto B. Y para el segundo argumento, voy a pasar la duración. Y básicamente,
queremos saltarnos si el objeto timer no es nulo aquí o si ya iniciamos a, entonces esta vez
los valores del objeto no deberían ser nulos. Así que vamos a comprobar
si la hora es, entonces queremos devolver
este método aquí. Voy a agregar
un registro de depuración aquí, para que podamos ver si pasa
algo. Vamos a escribir el registro de depuración, y vamos a atar el
temporizador ya se ejecuta. Necesitamos crear la corrutina
del temporizador. Vamos a escribir yo enumerador
para el tipo escrito, y vamos a llamar a
este temporizador se ejecuta Queremos pasar la
duración aquí al cotin Dentro de la corrutina, queremos crear un bucle salvaje
con una condición si la
duración es mayor que cero Entonces queremos comenzar a
contar el temporizador. Aquí podemos restar la
duración con un valor de uno, y luego podemos sumar
un retorno de rendimiento Pero en lugar de usar Nu, que va a
devolver cada fotograma. Así que los bucles while se van
a ejecutar en cada fotograma. Voy a retrasar el
bucle por cada segundo. Voy a usar nuevo peso 4 segundos y establecer
el valor en uno. Esto funcionará
exactamente como un temporizador. Cada 1 segundo, vamos a restar la
duración por uno Si la duración es cero, entonces queremos salir de
este bucle de alambre y ejecutar
cualquier código de abajo aquí. Cuando se agote el temporizador, queremos volver a configurar el temporizador
cotin a nulo Y ahora tenemos
este objeto temporizador. Voy a exponer
un entero público, y voy a llamar a
este temporizador de visualización, que podamos ver el temporizador
en el inspector, y voy a pasar el valor de duración a
este temporizador de visualización. Así que vamos a establecer el valor del temporizador de
visualización a la duración que se está ejecutando
actualmente en
el bucle actual. Entonces es un flotador, y
esto es un entero, así que necesitamos lanzar
esto a un entero. Voy a agregar un casting
frente al valor de duración. Entonces ya no arroja el error
. Vamos a guardar esto. Lo siguiente que
queremos hacer es que
queremos agregar este
objeto temporizador al gestor del juego. Puede preguntar por eso que
creamos otro script
para el objeto timer. Esto es para cumplir con el patrón de responsabilidad
única. Entonces voy a tratar de
hacer que cada guión sirva sólo
a un único propósito de
responsabilidad. Por lo que es más fácil para
nosotros depurar más tarde. Cuando hay un error, podemos aislar un error
en un solo script. En lugar de poner
el temporizador dentro del manager del juego también con todas
las co rutinas
y el método. Y esto es muy
fácil de usar aquí. Como este no es
un comportamiento monel, podemos simplemente crear
un nuevo campo privado y con un tipo de objeto de tiempo Y vamos a llamar a este objeto de
tiempo aquí. Lo siento. Y voy a
inicializar esto. Y guarda esto. Y ahora podemos usar todo el método
dentro del objeto timer. Entonces aquí dentro del manager del juego, queremos crear un nuevo
método público para iniciar el temporizador. Entonces aquí abajo, voy a
crear un nuevo vacío público, y voy a llamar a
este temporizador de inicio, y vamos a preguntar por la duración del
temporizador como argumento. Y ahora para iniciar el temporizador, solo
podemos acceder a
nuestro objeto time, y luego podemos ejecutar el método
start timer, y luego pasar el comportamiento mono. Y como el manager del juego
es un comportamiento mono, podemos simplemente pasar
esta clase aquí, y luego pasar la duración. Otra cosa que
necesitamos crear es, necesitamos crear un
método para detener el temporizador. Así que vamos al objeto
temporizador aquí, y voy a crear un nuevo vacío público
o un método público, y voy a llamar a
este temporizador de parada. Y para el temporizador de parada, vamos a pedir un
comportamiento mono como argumento. Y aquí queremos comprobar
si el temporizador es actualmente nulo o si actualmente no hay
tiempo funcionando, entonces queremos
devolver este método. O simplemente podemos agregar un registro de punto de
depuración aquí, y digamos que actualmente no
hay ningún registro en ejecución. Y quiero
devolver este método. Pero si el temporizador no es nulo, entonces queremos detener el
cotin usando el comportamiento mono que pasamos aquí y luego
ejecutar el método stop cotin Y para el crotin, podemos simplemente pasar aquí este objeto
ter cotin Vamos a establecer el argumento de la
cotina para el método de la proteína de parada Y luego después de
detener el cotin, queremos volver a poner el
temporizador a nulo Hemos creado el método del temporizador de
parada. Volvamos al administrador
del juego, y luego queremos crear un
nuevo temporizador público de parada de vacío. Y aquí, solo podemos
acceder al objeto timer, ejecutar el
método stop Ter y luego pasar el comportamiento mono
con esta palabra clave. Bien, ahora que hemos creado el temporizador de inicio y
el temporizador de parada, queremos activar esto
desde el punto de rodaje. Siempre que ejecutemos el
método
start shoot out para el punto de lanzamiento
aquí, también
queremos iniciar el
temporizador dentro de nuestro manager de juego. Simplemente accedamos a la instancia del administrador del
juego y luego ejecutemos el temporizador de inicio. Y esto como para la duración, así podemos simplemente pasar el
tiempo como la duración. Y luego aquí, queremos
detener el temporizador si ya han matado a
todo el enemigo. Entonces aquí, solo accedamos instancia
del administrador del juego y luego ejecutemos el
método del temporizador de parada y guardemos esto. Para que se despeje el área establecida, no
necesitamos detener el tiempo
porque para cuando se despeje
el área, esto significa que se acabó el tiempo, por
lo que el temporizador se detendrá solo y guardará esto. Ahora volvamos a la unidad. Y voy a modificar de nuevo
el temporizador y hacer esto probablemente a 10 segundos
y guardar la escena. Y si seleccionamos
el gestor del juego, no
podemos ver el
objeto timer porque no hemos establecido la clase como una clase
serializable Entonces volvamos
al estudio fisal y dentro del objeto ter Voy a añadir un atributo
serializable. Así Sistema Tipo serzable. Guarde esto. Otra cosa
que tenemos que hacer es, me olvidé, ya que el objeto temporizador es privado, no podemos verlo. Pero si queremos verlo, podemos agregar un atributo de
campo de tamaño o simplemente
podemos habilitar la
vista de desarrollo de nuestro inspector. Entonces aquí podemos ver
nuestro objeto temporizador y
podemos ver el campo
timeer de visualización Ahora vamos a guardar la escena
aquí y toquemos esto. Ahora, si llegamos
a la zona de rodaje, ve
que el
temporizador de pantalla arranca de verdad. Bien. Hay algo
que olvidé que hiciste, y por eso el
temporizador de pantalla no funciona. Así que volvamos aquí al estudio
Fiscal. Y dentro de nuestro objeto Tier, olvidamos ejecutar la rutina co dentro del método del temporizador de inicio. Entonces ahora necesitamos ejecutar la
corrutina si la corrutina es. Así que vamos
a t igual para iniciar co rutina, y queremos ejecutar
la rutina corre co, y luego pasar la
duración como argumento. Antes de que este
enumerador se ejecute el tiempo, nunca se ejecuta porque
nos olvidamos de ejecutar esto Entonces ahora voy a
guardar el guión aquí, y volvamos a Unity. Ahora, después de compilar el
script, vamos a correr y
ver este valor aquí. Tome nota del valor del temporizador de
pantalla. Una vez que lleguemos a la zona, empieza a contar nueve, ocho ,
siete, y cuando este
valor se convierta en cero, entonces seguirá
moviéndose uno, cero. Ahí vas. Y
en la siguiente zona , comenzará a contar el área. Empezará a contar de nuevo
el temporizador. Así es como creamos un temporizador
con un objeto separado, por lo que manejará
todo el código de tiempo. En el siguiente video,
vamos a empezar a crear la interfaz de usuario
para nuestro juego aquí.
26. 25 estadísticas de juego: En este video, antes de
continuar creando la interfaz de usuario, queremos crear primero las estadísticas del
juego. Entonces queremos registrar cuántos disparos nos
han disparado y cuántos enemigos
nos han matado y cuántos enemigos hay
en totales en la escena Así que empecemos a eso. Vamos al estudio
visual aquí, y dentro del manager del juego, ya
creamos
dos variables enteras para el enemigo golpeado
y los disparos disparados. Esto es básicamente para
calcular la precisión más adelante, pero queremos agregar
también el contador de
muertos enemigo y
el enemigo total. Contador, y también contador de
rehenes muertos. Entonces ahora necesitamos crear un
método para agregar este valor aquí. Así que vamos a crear un nuevo método
público a continuación aquí. El primero que
queremos crear es que
queremos crear un método de
registro enemigo. Y esto es para registrar a
un enemigo, y para registrarse, solo
necesitamos sumar al enemigo
total por uno, y esto será llamado por
el guión enemigo al inicio. El siguiente método que
queremos hacer es también un método público y
llamado asesinato de rehenes Para este, queremos sumar el valor de
los muertos como rehén. Lo siguiente que
queremos crear es que
queremos crear un método de matar
al enemigo. Et acaba de crear un
nuevo método público y llamar a este enemigo asesinado. Solo agreguemos la variable enemiga
asesinada por una. Ahora hemos creado este nuevo método de
tres. Vamos al guión enemigo aquí, y tras la inicialización, en la configuración de comportamiento, queremos agregar el gay manager
instance register enemigo Siempre que
se inicialice al enemigo, queremos registrar a
un enemigo aquí Aquí abajo, cada vez que
el enemigo es asesinado. Y creo que sí, aquí, queremos
registrar la matanza. Así que vamos a ejecutar
la
instancia del manager del juego punto enemigo asesinado. Oh, perdón, en vez
de agregar esto aquí, solo
podemos agregar esto dentro del comportamiento de muerte.
Así que vamos a hacer eso. Y a esto se sumará el contador de muertos
enemigo. Y para el script de rehenes, queremos agregar la instancia del
administrador del juego do rehén asesinado cada vez que se ejecuta
el comportamiento de muerte en el script
de rehenes Vamos a guardar esto. Ahora
volvamos a la unidad. Con el inspector configurado para depurar, podremos ver aquellas variables
privadas
que hemos creado. Ahora vamos a probar esto. Creo que necesito
aumentar el temporizador, así que voy a ir a
la cámara principal aquí. Lo primero, voy a poner el temporizador de área a 30 segundos. Entonces tenemos tiempo para matar a todo
el enemigo y salvar esto. Ahora vamos a presionar play
y probar esto. Seleccionemos al manager del juego y veremos las estadísticas aquí. Entonces ahora matemos a
este enemigo de aquí. Y hemos matado a dos enemigos. Ahora intentemos matar primero
al rehén para ver y matemos a este
enemigo. Necesito recargar Ahí vas. Ahora
ves que he disparado 15 veces y
he golpeado al enemigo 13 veces, y también hemos matado a tres enemigos de tres enemigos
totales en la escena, y también matamos al rehén Posteriormente vamos
a utilizar este valor para calcular las puntuaciones al
final de la jugabilidad.
27. 26 barra de salud de la interfaz de usuario: Hola, en este video,
vamos a empezar a
trabajar en la interfaz de usuario. Y en este capítulo, vamos a crear la
IU de Salud para el jugador. Entonces, para crear
la IU de Salud, ya
preparé un paquete. Así que vamos a importar
ese paquete. Voy a ir al menú
de activos, importar paquete, y
elegir paquete personalizado. Y entonces aquí tengo
el paquete UI Pa. Una vez que se abre, la ventana de importación del paquete,
vamos a importar todo. Y voy a arrastrar la UPAC
dentro de nuestra carpeta de
juego de guiones bajos Ahora, si abres el UiPac, tendremos una carpeta prefabs
y dentro de esta carpeta prefabs y dentro Ya preparé
un objeto HUD jugador, y podemos arrastrar esto
a la cámara principal Voy a arrastrar esto para ser el hijo de la cámara principal. Y ahora vamos a ajustar
el parámetro. Como puedes ver aquí,
tenemos una barra de ayuda. También tenemos el
contador MO y también la notificación de
recarga La forma en que se configuran las prefs
ya está orientada de la
manera correcta en relación con la cámara Si puedes ver aquí, si
vamos a la vista del juego, ves que tenemos la interfaz de usuario siguiendo a la cámara
porque está aparentada a la cámara, y está ligeramente
girada sobre el eje y Entonces ahora estamos listos para irnos. También voy a importar un fondo
personalizado y para este paso, solo
puedes elegir
tu propio estanque y reemplazar el fondo en el
texto después de ese paso. Dentro de la carpeta del
juego de guiones bajos, voy a crear
una nueva subcarpeta, y voy a
llamar a esto fondos, y ya he
preparado una diversión aquí Sólo voy a arrastrar este
fondo que voy a usar. Y ahora una vez que hayamos
importado el fondo aquí, voy a hacer click derecho en el teléfono y luego
elegir crear menú, y debajo del menú de texto Mash, voy a hacer clic en
el activo aficionado. Por lo que generará el
activo aficionado para el texto Mash pro. Entonces ahora que hemos
generado el activo aficionado, solo
podemos seleccionar el objeto
hijo que tiene los
componentes text mesh pro unidos a él. Y aquí podemos escoger el
teléfono que hemos generado. Entonces ahora tenemos un teléfono
más parecido. Y para el texto real, también
voy a cambiar el
texto telefónico aquí. Ahí vas. Y ahora podemos empezar a trabajar en el script para
el UI Manager. Así que vamos a la carpeta de
scripts, y voy a crear
un nuevo script C sharp, y voy a llamar a
este UI Manager. Y vamos a abrir este Administrador de UI. Entonces ahora que hemos abierto
el script UI Manager, voy a eliminar el
inicio y el método de actualización. También voy a eliminar aquí
la
herencia de comportamiento mono. Y voy a agregar un atributo
serializable del sistema. Y voy a usar esta clase de administrador de
interfaz de usuario
al igual que la clase de tiempo u objeto que
hemos creado previamente. Así que vamos al manager gay, y voy a mover al manager
del juego para que
esté al lado de nuestro script del gestor de
UI, así que es más fácil cambiar. Y aquí podemos
declarar el UI Manager como un campo u objeto dentro del script
del gestor de juegos. Entonces aquí voy a
agregar un campo serializado. Para el tipo, voy a usar
la clase UI manager aquí, y voy a llamar a
este gestor de UI. Ahora que hemos creado esto de
nuevo a nuestra clase de administrador de interfaz de usuario, primero
queremos importar la biblioteca Tex
Mash pro. Voy a escribir usando
tex TM pro class, y luego también voy a estar
usando la interfaz de usuario del motor Unity. Aquí, dentro de la clase
UI manager, queremos crear un
nuevo campo serializado, y este sería
un tipo de slider, y esto es para nuestra barra de salud Voy a llamar a
este bar de salud. Entonces queremos crear un método público para
actualizar la barra de salud. Pero antes de
crear ese método, queremos crear un nuevo método de inicio de vacío
público, y esto es para inicialización Y para inicializar,
queremos pasar la salud máxima que
tenemos para este jugador Vamos a escribir float, y vamos a llamar a este float Mx health como argumento
para el método init Y luego aquí para
la barra de salud, queremos asignar su valor x a la salud Mx que acabamos de
pasar por este método, y queremos establecer también valor de
la barra de salud
al
Argumento de salud Mx aquí.
Lo siguiente que queremos crear es que queremos crear
un nuevo método público para actualizar la salud. Vamos a llamar a esto salud
actualizada. Y entonces podemos
simplemente pasar un flotador, y llamemos a
este valor flotante. Y ahora cada vez que
llamamos a este método, queremos actualizar el
valor de nuestra barra de salud. Vamos a escribir barra de
salud, valor, igualar el valor que hemos
pasado aquí y guardar esto. Ahora si vamos al gestor
de ganancia, queremos inicializar
el gestor de UI Vamos a igualar
al nuevo gestor de UI. Instancia y guardar
des, y aquí abajo. Dentro del método de salud del jugador, queremos actualizar
la salud actual al valor de la barra de salud aquí. Simplemente escribamos aquí debajo de la resta de salud
actual por el daño. Escriba UI manager, actualice el estado
y, a continuación, pase el valor de salud
actual. Y esto actualizará el valor de la
barra de salud y guardará esto. Y ahora
volvamos a Unity. Ahora si seleccionamos el gestor de
juegos aquí, verás que tenemos un nuevo
campo llamado UI Manager, y podemos
expandirlo, y podemos ver el campo dentro de la clase
UI manager. Ahora queremos arrastrar la barra de
salud a la ranura aquí. Entonces solo selecciona la barra de salud
padre debajo del HUD del jugador aquí, y ya preparé el componente slider aquí
y establecí su valor diez, y verás que si
deslizamos este valor aquí, nuestra barra de salud disminuye Así que vamos a seleccionar de nuevo al
administrador del juego y luego arrastrar el
objeto del juego Health Bar y guardar esto. Una cosa que olvidé es que necesitamos ejecutar este método
inicializado Entonces vayamos al manager del juego. Dentro de su método innato, queremos asegurarnos de que
estamos inicializando el UI Manager Simplemente llamemos al método init del
objeto UI manager y luego pasemos el estado actual que
estamos inicializando antes Y guarda esto. Ahora,
volvamos a Unity, y ahora vamos a probar esto. Voy a presionar
play y a ver si lo siento, primero
necesitamos ocultar el texto leído , así que voy
a ocultar esto. Y ahora veamos que
si la barra de salud se actualiza cada vez que
nos dispara el enemigo. Ahí vas. Así es como
creamos la barra de salud. Siéntase libre de explorar
el prefecto que he creado y cómo he
diseñado la interfaz de usuario aquí También para esta recarga, cuenta con un componente animador Básicamente, solo está
animando su valor Alfa. Aquí, como puedes
ver, anima el valor Alfa del color cuatro
te del texto aquí En el siguiente video,
vamos a seguir trabajando en la
información de armas de nuestro HUD
28. 27 HUD de armas de interfaz de usuario: En este video, vamos a seguir trabajando en nuestro sistema UI. Y esta vez estamos
queremos cambiar el icono de arma si
recogemos una nueva arma, y queremos también
actualizar el contador MO aquí y también habilitar la notificación de recarga
cuando se acabe el MO Ahora para hacer eso, vamos a ir a es Sudio, y necesitamos
acceder al arma que
primero, y también a los jugadores Dentro del script del reproductor, queremos crear un nuevo evento estático
público. Así que vamos a crear
una nueva estática pública, y para el evento,
voy a establecer
esto a un sistema no a una acción. Y voy a pasar aquí un
objeto para nuestro evento. Para la firma, voy
a agregar los datos de armas, y voy a llamar a este
evento sobre cambio de arma. Y voy a llenar este
evento con un delegado vacío. Por lo que no tenemos que
verificar ningún suscriptor cada vez que queramos invocar
este evento. Guarde esto. Y a propósito
hago esto estático. Por lo que es más fácil
acceder a esto desde cualquier otro guión sin tener una referencia al guión
del jugador. Bien. Lo siguiente
que tenemos que hacer es, tenemos que ir al interior
del método del arma del interruptor. Y aquí, después de
montar la nueva arma, queremos transmitir este evento. Vamos a invocar el evento de cambio de
arma, y pasemos los datos de armas
de carbono Porque
los datos actuales de armas, es un dato de arma, por lo que podemos pasar esto a nuestro
propio evento de cambio de arma, y este evento
transmitirá estos datos, y el que
se suscriba a este evento recibirá
un nuevo dato de arma Ahora lo siguiente
que queremos hacer
es ir a los datos de armas, y dentro de la clase de datos de
armas, queremos crear un
nuevo evento público, y este no
será un evento estático. Simplemente va a
ser un evento público, así que solo podemos escribir
system dot action. Y queremos pasar el
MO como la firma
o el objeto que estamos
transmitiendo a través de este evento. Así que vamos a añadir un entero
como su firma. Y entonces podemos simplemente llamar a
esto al fuego de armas, y podemos simplemente establecer un anti delegado tal como lo
hicimos en el guión del jugador, seguridad y o tal vez podamos
simplemente llamar a esto al fuego de armas. Y queremos transmitir el evento de disparo
de arma aquí dentro de la
actualización de armas aquí y siempre que estemos presionando
el botón del mouse aquí. Entonces ahora vamos a invocar
aquí el evento disparado con arma y luego pasemos
el auto en MO Y para la ametralladora aquí, queremos invocar también el evento aquí. Ahora solo
guardemos esto. Y queremos
añadir también el icono del arma. Vamos a ir arriba aquí en
nuestra declaración de campo. Y voy a agregar un
nuevo campo serializado, y este será
un tipo de sprite Y llamemos a
este icono de arma. Voy a exponer este campo serializado
usando una propiedad Abajo aquí, voy a crear un nuevo
tipo de propiedad pública de sprite Y entonces voy a
llamar a este ícono de GT. Y luego para el accesor GT, voy a devolver
el icono del arma Aquí. Bien. Ahora
podemos guardar esto, y vamos a ir a UI Manager. Así que ahora dentro del Administrador de UI, queremos declarar un
par de variables, y voy a agregar el atributo
header, y voy a pasar una cadena
para este atributo header. Y voy a llamar a esta
arma HUD, y abajo aquí, voy a crear una nueva
imagen para el icono del arma Entonces para los otros
campos que
necesitamos crear es
un texto Mash pro. Solo busquemos el
texto Mash pro object, UGI, asegurémonos el UGI, y llamemos a este impuesto MO Y la otra cosa que
necesitamos crear es un objeto de juego para
la advertencia de recarga Llamemos a esta advertencia de
recarga. Y aquí dentro del método in, queremos suscribirnos a un
evento en el guión de los jugadores, el evento estático
que hemos declarado. Así que solo accedamos
al guión de los jugadores, y luego accedamos
al evento de cambio de armas. Queremos suscribir este método que tenemos aquí
dentro del UI Manager. Entonces necesitamos crear
el método primero. Sólo voy a
suscribirme a un método. Y voy a hacer iso Studio para generar esto
automáticamente. Ahí vas. Tenemos esto en arma y ya pasó
los datos del arma aquí. Entonces voy a quitar la
nueva excepción de Trow no implementada Y aquí queremos crear también una nueva variable privada
para contener nuestros datos de armas. Vamos a escribir datos de armas
privadas, y llamemos a
esta arma actual. Aquí dentro del método de
actualización del arma. Queremos comprobar si el arma
actual no es nula. Entonces si no es nulo, queremos eliminar
el evento de fuego de arma dos un método llamado update MO, y aún no lo hemos creado,
así que vamos a crear un nuevo vacío, llamado update MO, y vamos pasar un entero para el MO. Y aquí queremos
actualizar el texto MO. Usando el método set text de
la malla de texto pro y pasar la O que pasamos
como argumento aquí en el método y convertir
esto dos una cadena, y voy a
formatear esta cadena dos un valor de dos dígitos aquí usando el argumento string
de este método de dos cadenas. Ahora aquí, si el
arma actual no es nula, queremos dar de baja el evento de arma disparada
de este método aquí Solo escribamos negativo
igual actualizado MO, y esto se dará de baja
porque estamos cambiando los datos
del arma a
una nueva arma que pasamos por este evento aquí Entonces ahora queremos actualizar
el arma Caron
al nuevo objeto arma que hemos pasado en este argumento aquí. Y luego queremos suscribirnos a este nuevo evento de datos de armas
a nuestro método de actualización MO. Y a continuación aquí,
queremos actualizar también el sprite de icono de arma
accediendo a las
propiedades de sprite y luego pasar el arma Caron, obtener propiedades de sprite C,
y Ahora que tenemos una suscripción a
eventos, también
necesitamos eliminar esto
cada vez que este gestor de interfaz de usuario
se desactive Entonces voy a crear
un nuevo método público y simplemente llamar a este evento remove. Y luego voy a copiar
esta línea aquí, pegarla aquí. Pero en lugar de usar
el signo positivo, voy a cambiar esto
a signo negativo para cancelar la suscripción de este método
a este evento aquí Vamos a guardar esto y
dentro del manager gay, queremos crear un nuevo método
void on disabled. Este es un
método incorporado desde la unidad. Básicamente, se
ejecutará cada vez que este
script se deshabilite, ya sea que detengamos al editor o si el manager
gay es destruido, esto también invocará Dentro del método undisabled, queremos acceder
al gestor de UI, y luego queremos acceder
al método remove event Otra cosa que
queremos agregar aquí, dentro del gestor de UI. Siempre que actualicemos la O, queremos habilitar también
la advertencia de recarga, siempre que la O sea cero Aquí, antes de establecer
el texto O aquí, vamos a acceder al objeto de juego de advertencia de
recarga y luego ejecutar el método activo Entonces para el argumento,
el matón y el valor, podemos simplemente pasar O menor
o igual a cero Entonces esto comprobará si el MO
es igual o menor que cero, entonces esto será cierto y activará
la advertencia de recarga se activará
la advertencia de recarga. Y
vamos a guardar esto. Y volvamos a Unity. Voy a esperar un rato a que se compila
el guión, y ahora está terminado. Seleccionemos al manager del juego. Y aquí tenemos nuevos
campos para el arma HUD, para el icono de arma,
queremos dirigir este objeto de icono de arma
desde nuestro jugador HUD El texto MO solo dirige
este objeto fiscal, y para la advertencia de recarga, queremos dg el objeto de juego
de recarga. Vamos a guardar esto. Ahora vamos a probar esto. Bien, hubo un problema, y al parecer, está
relacionado con el estado de la carrera. Entonces para arreglar esto, tenemos que ir al
estudio fiscal, y básicamente, el arma switch se ejecuta desde el inicio del guión de
nuestro jugador. Y en el UI Manager, El init también se activa desde el inicio
del manager del juego Si el inicio del guión del jugador resulta ser
anterior a los del administrador del juego, entonces el administrador de la interfaz de usuario no se pondrá en contacto con los nuevos datos de armas que el
guión del jugador está pasando Para arreglar esto,
tenemos que retrasar esto un poco. Voy a usar esta extensión que hemos creado,
la acción retardada, y luego voy a pasar un delegado que
ejecuta este método. Y entonces voy a
pasar un valor muy pequeño, muestra 0.1 segundo,
y guardar esto. Otra cosa que
tenemos que arreglar también
está en nuestros datos de armas. Siempre que
actualicemos o recarguemos el MO aquí, como pueden ver,
también queremos disparar este evento aquí Vamos a copiar esa línea
y luego pegarla aquí. Por lo que esto actualizará el
MO en nuestro gestor de UI. Otra cosa que
tenemos que hacer es, volvamos a Unity y
dentro de la carpeta de datos, necesitamos agregar un sprite
para el icono del arma Entonces voy a seleccionar aquí
el arma por defecto. Y con el UiPac que
hemos importado antes, tendremos este icono de arma, y voy a usar esto
para el arma por defecto Y para la ametralladora, vamos a usar
aquí el
otro arma de icono de UI . Y vamos a guardar esto. Una vez que hayamos configurado el ícono aquí, también
necesitamos agregar un poco de modificación dentro de los datos
del arma aquí, y copiemos esta línea de fuego de
arma aquí. Y también queremos ejecutar el evento de disparo de arma cada vez que instalemos esta nueva arma aquí. Así que vamos a ejecutarlo aquí. Y después de que disparemos el evento
sobre el método del arma establecida, queremos ir al guión
del jugador. Y luego queremos cambiar
el orden de nuestro evento aquí. Entonces queremos asegurarnos de que
el evento se desencadene o se transmita antes de
configurar los datos del arma carbo Así que vamos a pegarlo aquí y eliminar esta línea vacía aquí. Guarde esto. Y ahora
volvamos a Unity. Bien. Entonces ahora
probemos esto de nuevo, y si esto funciona, entonces el texto real se
oculta de inmediato, y el Oh se
actualiza de inmediato. Así que vamos a presionar
play. Y ahí tienes. Como puedes ver aquí, la O
se actualiza de inmediato, y podemos disparar y luego
cuando recarguemos es actualización, y también podemos
elegir esta arma, y cambia el icono También actualizamos la O, pero
no podemos recargar con esta arma. Entonces, si esta arma está vacía, entonces volverá
a la pistola predeterminada aquí. Y vamos a disparar,
y si se acaba el MO, verás que el impuesto de
recarga está habilitado Y una vez que recarguemos, se deshabilitará Entonces sí, terminamos con
nuestro sistema HUD de armas, y en el siguiente video, vamos a trabajar
en otros elementos de la interfaz
29. 28 temporizador de la interfaz de usuario: En este video lecciones, vamos
a seguir trabajando en el elemento UI. Y esta vez vamos
a trabajar en el tiempo. Entonces, para poder
trabajar en el temporizador, vayamos aquí al manager
gay, y voy a crear
un nuevo objeto UI Canvas como hijo de nuestro manager gay. Ahora con este lienzo seleccionado, voy a cambiar
su configuración para el modo de escala de UI bajo
el escalar Canvas Cambiemos esta
escala dos con tamaño de pantalla, y voy a establecer las resoluciones de
referencia para que sean un full HD 11920 por 1080 Voy a establecer el modo de coincidencia de
pantalla a 0.5, por lo que estará a medio camino
entre el ancho y el alto y guardará
la escena nuevamente Y ahora dentro de este sondeo, si vamos a la
vista D aquí y luego presionamos F mientras
seleccionamos el lienzo, ya verán que aquí tenemos
este lienzo muy grande Y cada interfaz de usuario que
hayamos preparado dentro este lienzo aquí se
superpondrá frente a nuestra
cámara en la vista del juego aquí Entonces ahora voy a crear
un nuevo objeto hijo, y será un tipo
de malla de texto pro. Y si hacemos zoom esto aquí, este será el contador del temporizador. Voy a llamar a este temporizador, y voy a poner
esto encima aquí, pero primero voy a
cambiar su tamaño. Voy a establecer su altura
a 75 y la anchura a 150. Para el texto, voy
a establecer este 200 y también establecer el fuera de
tamaño para que se habilite. Voy a alinear
esto a la mitad. Y también cambiar los activos telefónicos al rex LA que hemos
creado en el video anterior. Ahora tenemos esta configuración de temporizador. Vamos a alinear
esto accediendo a los presets de anclaje y
manteniendo pulsado el botón outt
en el teclado, podemos simplemente elegir este medio
superior aquí, y se ajustará nuestro temporizador a
la parte superior de nuestro lienzo Ahora vamos a abrir el script
UI Manager. Vayamos al FSO Studio
y accedamos al gestor de UI. Y aquí, para el gestor de UI, queremos agregar un nuevo campo
debajo de nuestra barra de salud. Vamos a escribir un nuevo
campo Serializar, y para el tipo, será una malla de texto P UI, y voy a
llamar a este Tier tex Ahora queremos modificar el script de objeto Tier
que hemos creado antes, así que vamos a abrir
el script Tier. Aquí, queremos crear un
nuevo evento estático público, evento estático es bastante poderoso. Nos facilita la
comunicación entre script sin tener
dependencia entre
sí se suele
llamar desacoplamiento Vamos a escribir public static, y queremos establecer esto
como una acción del sistema, y luego queremos
pasar un entero. Simplemente agreguemos entero
como su firma, y llamemos a
esto el cambio de tiempo. Y configurar un anti delegado. Con el evento estático, declare, podemos ir a nuestras carreras de tiempo aquí, y luego aquí antes de
restar la duración, podemos pasar esta duración a través de
nuestro evento de cambio de tiempo Vamos a invocar esto o
transmitir el cambio en el tiempo, y queremos pasar un entero Pero como la
duración es un flotador, necesitamos lanzar
esto a un entero. Voy a agregar un elenco al tipo
entero usando paréntesis de
activos y luego la
palabra clave integer y luego escriba el nombre de la variable duration aquí Esto convertirá la
duración en entero, y el
evento de cambio a tiempo lo transmitirá. Ahora dentro del gestor de UI, queremos suscribirnos a
este evento de cambio a tiempo. Dentro del método init, vamos a añadir un
nuevo objeto time, y vamos a acceder al evento on
time o change, y queremos crear un nuevo
método llamado update Ter Pero no hemos creado esto, así que vamos a decirle a Visual
Studio que genere automáticamente. Y
ahora tenemos esto. Voy a cambiar el nombre de los
argumentos a Ter actual. Dentro de este temporizador de actualización, vamos a actualizar
nuestro texto de temporizador aquí. Vamos a escribir impuesto de
tiempo, establecer texto, y luego queremos convertir la hora actual en una cadena
usando el método de cadena, y luego formatear este
dos un número de dos dígitos. Usando el argumento string. Guarde esto. Ahora que tenemos un par de suscripciones
en el gestor de UI, necesitamos asegurarnos de
que esto también se elimine cada vez que el
objeto se active. Dentro del evento remove, queremos pegar esta
línea aquí y luego
cambiarla al tipo de suscripción. Y aquí, queremos
asegurarnos también de que estamos baja el arma disparada
dentro del evento remove, así que simplemente copia esa línea y
péguela aquí, y guarda Ahora volvamos a Unity, y probemos esto. Primero, necesitamos
configurar el texto del temporizador aquí, y ya creamos
el objeto de juego TR con
el componente de malla de texto adjunto a este objeto de juego de
tiempo. Solo arrastremos esto a
esta ranura de texto Ter aquí, y registrará el componente de interfaz de usuario de Mash Pro de
texto. Ahora vamos a guardar esto y
vamos a probar esto. Ahora, cuando
llega, actualiza el temporizador, y empieza a contar el
temporizador aquí, como puedes ver. Entonces, simplemente matemos al enemigo, y vayamos a la siguiente zona, y volverá a contar atrás el
área cuando llegue. Entonces ahí tienes, como puedes ver, es bastante fácil implementar el I usando el evento estático.
30. 29 rehenes de la interfaz de usuario muertos: En este video, vamos a seguir trabajando en la interfaz de usuario, y esta vez
vamos a agregar un texto cada vez que
matemos y secuestremos Pero antes de profundizar en
el texto de asesinato de rehenes, voy a mostrarte que he creado otro punto de
rodaje, el tercer punto de lanzamiento, y he duplicado el
tercero del segundo En el tercer punto Shula, consiste también
rehén y enemigo, y lo puse aquí en
esta posición Para el rehén, lo puse aquí, también la posición objetivo
sobre esta posición Y para el enemigo, lo
pongo aquí, y la posición objetivo
es correr esta posición. Así que solo puedes hacerlo
tú mismo para seguir este video. Otra cosa que
queremos arreglar aquí, vamos a ejecutar este
juego para probar esto. Pero verás que al final, la cámara está un poco inclinada. Ahí vas. Está un poco inclinado. Queremos arreglar esto.
Pero antes de arreglar esto, asegúrese de que el tercer punto de
tiroteo se ingrese al guión de movimiento del jugador como tercer punto de tiroteo He agregado una entrada aquí, y luego arrastre el tercer objeto de punto de
tiroteo
a la ranura Y luego puse la
distancia en 17 aquí. Ahora arreglemos esto.
Tenemos que ir a la vista de escena aquí y seleccionar
el movimiento de la trayectoria de la cámara. Y después selecciona aquí el
último punto. Y si seleccionamos el punto
individual aquí, y si seleccionas rotar, verás que tenemos
este gizmo de rotación, y podemos rotar solo este punto para
ajustar el vector hacia arriba Pero me pareció que el mejor
valor para esto es 358, así que solo voy a ingresar
aquí el ángulo debajo las opciones de punto seleccionadas en
el componente creador de ruta. Ahora bien, si vuelves a seleccionar
la cámara, y luego voy a fregar
esto para actualizar esto, verás que tenemos una rotación
correcta de la cámara, no ligeramente inclinada Solo habilitemos la opción
back y luego voy a establecer la
distancia de previsualización de nuevo a cero. Lo siento, voy a habilitar
esto y luego deshabilitarlo. Ahora que hemos establecido el
tercer punto de tiroteo, vamos a crear el texto de quilla de
rehén Bajo el manager del juego
Canvas, amplía esto. Y voy a crear
una nueva interfaz de usuario de malla de texto pro, y voy a ir
a ver aquí y luego presionar F para enfocarme en
este objeto de malla de texto. Y al alejar, voy a aumentar
el ancho del texto, tal vez alrededor de 350,
para la altura, voy a hacer este 100, y voy a
escribir rehén kel Y ahora dentro de gamevi,
podemos ver el texto aquí, y vamos a ajustarnos
para que se vea mejor Voy a establecer la alineación
al centro y al medio. También para los colores verte, voy a elegir un color rojo y luego elegir el activo de fuente
que hemos creado antes. Y entonces voy a
poner esto fuera de tamaño, pero quiero hacerlo más grande. Entonces voy a
aumentar el ancho a alrededor de 450 y luego
la altura alrededor de 150. Entonces tenemos un impuesto más grande aquí. Y vamos a
aumentar el máximo. Bien. Creo que este es el tamaño máximo de impuestos según el ancho
y nuestro ajuste de altura. Entonces, si queremos
hacer esto más grande, necesitamos aumentar
el tamaño aquí. Así que vamos a aumentarlo de nuevo. Bien. Creo que debería estar bien. Y vamos a llamar a
este rehén kel. Y ahora queremos
modificar el guión. Lo primero que
tenemos que hacer es abrir el gestor de UI. Y aquí dentro del UI Manager, queremos crear un
nuevo campo de seriales con tipo de transformación Así que sólo voy a escribir esto. Y luego para el tipo transform. Y para este campo,
llamemos solo a este texto de rehén asesinado Y ahora dentro de este UI Manager, necesitamos crear
un nuevo vacío público para mostrar este texto aquí. Voy a crear un nuevo vacío público y luego llamar
al método show hostage kill, y necesitamos tomar una posición Entonces voy a pasar un
factor tres como argumento. Y también queremos pasar un
Bulion por mostrar esto. Y queremos habilitar el impuesto
basado en el bleion aquí. Simplemente accedamos al objeto
de juego de
la variable de impuesto de
quilla de rehenes, y luego ejecutemos este un método activo y luego
pasemos el bulion del espectáculo Y queremos comprobar
si el show es falso, entonces queremos
devolver esta función, así que no necesitamos
ejecutar más código a continuación. Ahora necesitamos crear
una función auxiliar para mantener nuestra interfaz de usuario dentro
de nuestra pantalla. Porque si el rehén está muy cerca de nuestra pantalla, entonces podríamos mostrar aquí el texto de la quilla del
rehén, pero alguna parte
estaría fuera de
la pantalla aquí porque la
posición de la quilla del Necesitamos contar eso para
asegurarnos de que la interfaz de usuario no se
salga de la pantalla. Para hacer eso, vamos a
abrir nuestra clase de extensión aquí, y luego vamos a crear un
nuevo método estático público. Voy a crear un nuevo método estático
público,
pero este método devolverá un factor tres Vamos a llamar a esta
posición get dentro de la pantalla. Aquí, queremos pasar un vector a través para la resolución,
la resolución base. Vamos a llamar a esta base res, y luego queremos
pasar un vector dos también para la posición
anclada Entonces solo vamos a
crear el método. Dentro de este método, queremos
crear un nuevo flotador, y
llamémoslo con límites. Para el límite de ancho,
queremos usar la resolución base x. Substract con el ancho de
re transform En lugar de pausa anclada, necesitamos pasar una transformación rec Vamos a cambiar esto a una t, y luego voy a
restar aquí el componente base re x
con el rectángulo t width y vamos a
crear el límite de altura Esta será la base S punto y, substract con altura
directa del punto Estamos agarrando el ancho y
la altura de nuestro componente de interfaz Además, queremos sumar un
flotador para el desplazamiento, y luego también
queremos restar este valor resultante
con el desplazamiento Aquí tenemos algún margen al
borde de la pantalla. Y luego para la altura, también
queremos agregar el offset. Entonces ahora que tenemos el
ancho y el alto encuadernados, podemos usar esto para sujetar la posición anclada de
la transformada rec aquí Voy a explicar esto un
poco para esta fórmula aquí. Volvamos a la unidad, y vamos a
crear una nueva imagen. Y ahora, como puedes ver, esta imagen es de 100 píxeles de ancho
con 100 píxeles de alto. Si queremos aumentar este
tamaño para cubrir la pantalla, entonces necesitamos insertar la resolución
base con Sizo En este caso, es 1920. Y con esto, necesitamos obtener el medio tamaño de
la pantalla aquí. Y luego tenemos que
tener en cuenta
nuestro ancho en la mitad
de nuestros elementos de UI. Entonces, por ejemplo, si lo
pongo esto en el 960, que es el 1920 dividido por, entonces esta es nuestra posición. Pero esto dará como resultado
que la interfaz de usuario se recorte o alguna parte de la interfaz de usuario
esté fuera de nuestra pantalla. Entonces para arreglar esto, necesitamos restarlo con la
mitad del tamaño de nuestro
ancho, que es 250 Esto es básicamente
lo que estamos haciendo. Y para el
lado izquierdo de la pantalla, entonces solo necesitamos
multiplicar esto por uno negativo. Ahí vas. Con esta fórmula, podemos
calcular el elemento UI, por lo que permanecerá
dentro de nuestra pantalla. Voy a eliminar esta imagen aquí y regresar
al estudio fiscal. Ahora voy a
crear un nuevo vector u, y voy a llamar a
esta posición ajustada, y voy a establecer el valor de posición
ajustada para que sea el rectángulo, las retrans del objeto que
pasamos y su posición anclada Voy a agarrar la posición de
anclaje como el valor base de nuestra posición
ajustada. Entonces voy a ajustar
el componente x de la variable de posición ajustada
usando la almeja matemática F, y para el valor, voy a pasar
su valor x él mismo Y para lo mínimo, voy a usar
el límite de ancho, multiplicar esto por
cero negativo, perdón, negativo 0.5. Porque queremos
dividir esto por dos, y para la posición mínima, queremos multiplicar
esto por uno negativo. Entonces solo podemos hacer
esto en una toma
multiplicando por un valor de la mitad o
la mitad negativa Y luego para el valor máximo, podemos simplemente usar el
ancho encuadernado de nuevo y multiplicar esto
por 0.5 positivo. Entonces de esta manera obtendremos la
posición dentro de nuestra pantalla. Y para la posición y, queremos hacer lo mismo
modificando el componente y, luego, usar la clase matemática
f aquí y el método almeja y luego pasar la posición y de nuestra posición
ajustada, y luego usar los límites de altura, multiplicar esto por 0.5 negativo, y luego también para el máximo y, queremos multiplicar
esto por 0.5 positivo Ahora que tenemos la posición
ajustada, queremos devolver esta posición
ajustada, tipo return adjusted
position. Ahora tenemos esto. Podemos usar esto para posicionar el impuesto a
los muertos por rehenes. Volvamos al administrador de UI, pero voy a
guardar esto primero. Y dentro de este gestor de UI, vamos a establecer la posición fiscal de
rehén k, y esta es la posición mundial A la posición que
estamos pasando aquí. Y luego vamos a crear un nuevo vector dos
ajustar la posición. Y aquí queremos ejecutar la clase de extensión y el método get position
inside script. Para la res base, voy
a crear un nuevo vector dos. Y como ya
declaramos esto, solo
vamos a escribir el valor
que es 1920 por 1080, y esto va a estar en fluido, así que voy a agregar un signo F. Para el segundo argumento, voy a pasar el impuesto a los rehenes
kel y para el offset, probablemente voy
a sumar 25 pixel Ahora guarda esto. Una vez que
tenemos este valor aquí, necesitamos aplicar este valor a la posición anclada de
nuestro impuesto kel rehén Voy a acceder a
la posición anclada, y vamos a ajustar esta posición
aquí y guardar esto Ahora ya hemos terminado con
el gestor de UI Park. Necesitamos modificar
el administrador del juego para agregar la función para
activar este método aquí. Aquí voy a crear
un nuevo método privado, y voy a llamar a
este espectáculo rehén kel Y queremos pasar un
vector de tres posiciones, y queremos pasar también un bulion para mostrar
el texto aquí Y ahora dentro de este
espectáculo quilla rehén, necesitamos crear
un nuevo actor tres, y podemos llamar a este Vector
tres posición de pantalla Y para la posición de la pantalla, vamos a agarrar
la cámara
del jugador mover objeto. Y como este es un
jugador, podemos agarrar esto, y luego podemos usar
el componente gap y luego escribir cámara. Y aquí, podemos usar
el punto de pantalla Mundial, y luego pasamos el
vector tres que pasamos en el método aquí. Y recibiremos esta posición de vector T
de nuestra posición de rehén
en el mundo Y luego después de convertir
la posición de la pantalla mundial, queremos ejecutar el gestor de UI, lo siento, el UI Manager, y luego ejecutar el
show rehén Keel y queremos pasar
la posición de la pantalla Y también el argumento show
bulion que hemos pasado
en el método aquí Solo escribamos
show y guardemos esto. Y ahora necesitamos
modificar la quilla de rehenes. Lo primero, tenemos que pasar un vector de tres posiciones mundiales. A esto se le llama esta
posición mundial, por lo que es más clara. Entonces aquí abajo, queremos
ejecutar el espectáculo quilla de rehenes
que acabamos de crear Y también queremos pasar la posición mundial que
hemos pasado aquí. Siempre que maten al rehén, queremos establecer primero el
B show t Y entonces queremos ejecutar
esta acción retrasada. Como de costumbre, necesitamos crear
un nuevo delegado aquí, y podemos pasar esta línea
aquí dentro de este delegado. Pero en lugar de mostrar el texto, podemos simplemente establecer esto en
caídas para ocultar el texto, y podemos agregar un
retraso de 3 segundos. Y luego cierra esto. Ahora hemos modificado el administrador del juego
y el administrador de la interfaz de usuario. Hay una cosa que
tenemos que arreglar aquí. Dentro del guión de rehenes, necesitamos arreglar el talón del rehén, y esto es bastante fácil Sólo podemos pasar la transformación la posición del rehén Pero como el pivote de nuestro
rehén está a sus pies, entonces queremos sumar un factor tres arriba y probablemente
multiplicar esto por 1.2 Entonces la posición será
probablemente en el pecho
del rehén o en el torso
del rehén y guardar esto Ahora volvamos a Unity. La otra cosa que
queremos hacer está aquí, queremos agregar una animación,
una animación parpadeante, y solo
podemos agregar animador Y luego usar el controlador
animador que usamos para el texto de recarga Así que vamos a agarrar aquí el controlador
del animador de lectura,
y aquí usará la
misma animación Hará que el texto
parpadee así. Entonces ahora tenemos esta configuración. La otra cosa
que tenemos que hacer es dentro del gestor de UI, tenemos que
asegurarnos de que este texto se deshabilite al inicio. Aquí dentro del método init,
voy a agregar esto. Pero en lugar de establecer
este show de valores, voy a establecer estos
dos falsos y guardar esto. Y ahora realmente podemos probar esto. Bien, entonces voy a
centrarme en nuestra cámara aquí, y luego dentro
del manager del juego, también
necesitamos
poner el texto aquí,
aquí debajo del texto de quilla de
rehén, necesitamos arrastrar el objeto
quilla de rehén de nuestro Canvas, y ahora podemos guardar Ahora juguemos y
probemos esto, e intentemos
dispararle al rehén Vamos a tratar de que así sea el rehén. Ahí vas. Aquí tenemos
el texto que muestra, y matemos aquí al enemigo. Ahora si los rehenes aparecen aquí, vamos a dispararle y sí, tratar de mantener el texto
dentro de la pantalla Podemos probar esto en realidad
cambiando el tamaño de nuestro tamaño de rehén
a un valor muy grande, por ejemplo, establecer esto en uno
que y 500 en la altura, y podemos aumentar
el tamaño máximo aquí Y podemos probar esto
solo para probar si la extensión que hemos
creado está funcionando o no. Así que vamos a
darle una oportunidad de nuevo. A pesar de que queremos
revertir eso después de esto. Re. Ahí vas. Y probablemente lo podamos ver
con este rehén de aquí. Vamos a disparar. Ahí vas. Intenta mantener nuestro texto
dentro de la pantalla aquí. Ahora vamos a revertir esto de nuevo. Una cosa que
tenemos que ajustar aquí, creo que necesitamos
ajustar la altura. No creo que necesitemos
multiplicar esto por 1.2, así que vamos a factorizar eso hacia arriba. Y vamos a revisar
aquí
el pivote de rehenes porque no estoy seguro de
si está en los pies o no, así que vamos a centrarnos
y este es el pivote Este es el centro,
esto es pivote. Sí, podemos multiplicar
esto con el vector hacia arriba, pero necesitamos
hacerlo aún más pequeño. Voy a establecer esto en 0.4, Multiplicar esto por 0.4. Entonces veremos el texto alrededor del cofre y vamos
a probarlo una vez más. Sí. Es bastante agradable, la posición correcta en el torso o en el
pecho del rehén Sí. Bien. Sí, es como creamos una interfaz de usuario que puede aparecer
en función de la posición mundial, y también podemos mantener
esas IU dentro nuestra pantalla con el
método de extensión que hemos creado.
31. Introducción y pantalla final de la interfaz de usuario de 30: En este video, vamos a seguir trabajando en nuestra UI. Y esta vez
vamos a trabajar en la IU de introducción y también en
la IU de pantalla final Entonces ahora vamos a
la revisión aquí, y luego vamos a expandir el
manager del juego. También el Lienzo. Y aquí me voy a centrar
en nuestro Canvas. Y lo siguiente
que quiero hacer es, quiero ir a la carpeta UIP Dentro de la carpeta prefabs, tenemos el prefab nscreen Entonces voy a dirigir
este prefabricado nscreen para que sea hijo de nuestro Ahora tenemos esta pantalla n aquí. Queremos modificar primero
el texto. Así que vamos a expandir esto, expandir el diseño, y
dentro del diseño, tenemos una gran cantidad de objeto
hijo que contiene un área para
el título aquí. Y bajo el objeto de juego
área de título, tenemos un pro de malla de texto. Así que vamos a seleccionar
el activo divertido xia que hemos creado antes,
para el nuevo texto. Y para el área de puntuación, vamos a ampliar todo esto. Voy a colapsar
esto y luego aguantar y luego
expandirlos a todos. Y para el subtexto y el valor, voy a seleccionar
todos juntos. Y también el título y el rango, y voy a cambiar el activo del
fondo también a Raglea Así que vamos a hacer eso. Ahora tenemos todo esto. Y lo siguiente
que queremos hacer es, queremos crear una
animación para esto. Entonces para hacer eso, Seleccione el objeto de juego
de pantalla final. Y bajo Ventana,
voy a ir
al menú de animación y
luego crear animación. Y aquí tendremos una ventana de
animación. Y si aparece flotando, simplemente
puedes hacer clic en
el nombre del panel y luego dirigir esto y luego
perro a esta área aquí. Ahora con la
pantalla final seleccionada, podemos crear una animación. Voy a presionar crear aquí para crear la animación
para la pantalla final. Y debajo de la animación de la
carpeta del juego, voy a crear
una nueva animación para que la pantalla final se desvanezca. Y ahora podemos mover aquí el objeto
de juego de pantalla final. Voy a usar
esta herramienta de movimiento aquí y luego voy a
mover esto en el eje y. Y voy a habilitar
el botón de grabación, y en 1 segundo de duración, voy a deslizar
esto de nuevo dentro. Voy a redondear el número, la vista superior 2200 y la vista de
botones 2200 también. Bien, entonces tenemos esto aquí. Presionemos play y veamos
en la vista del juego. Ahí vas. Voy a eliminar este fotograma clave aquí porque
no lo vamos a necesitar. Bien. Ahora podemos ir a la vista del proyecto aquí y
dentro de la carpeta de animaciones, queremos asegurarnos de
que la animación para nuestra pantalla final se desvanezca aquí, los tiempos de bucle están deshabilitados. Entonces voy a desactivar esto, así que no va a ser un bucle, y voy a desactivar
la pantalla final aquí Y vamos a guardar la escena. Y para comenzar el juego, voy a crear un nuevo
texto Mash pro game object y establecer esto en 500 o 600
y para la altura, voy a establecer esto en 150. Y voy a teclear listo
y cambiar el teléfono a Eje. Para este texto listo, voy a habilitar el tamaño ato y establecer el
máximo en alrededor de 400. Entonces tenemos un impuesto muy grande aquí. Voy a establecer la alineación
al centro y también al medio. Para el color, voy
a escoger un color naranja, quizá éste. Más naranja. Sí. Y voy a
eimate este texto también Antes de animar el texto, vamos a cambiar el nombre del
texto dos texto listo Y queremos revisar
nuestro guión aquí en el manager del juego, tenemos el estado, y
tenemos el estado de inicio del juego, y está retrasando el estado S
al juego en 3 segundos. Así que queremos crear animaciones
con 3 segundos de duración. Entonces volvamos a la unidad aquí. Y al seleccionar el texto listo, vayamos a la animación, y luego creemos una animación de texto
listo. Ahora tenemos este clip de animación. Podemos crear una animación. Aquí, voy a grabar. Voy a agregar una propiedad
del naufragio transformar, y voy a agarrar
la posición anclada Entonces voy a tomar
la posición aquí. Y para el fotograma inicial, voy a mover esto
al lado izquierdo de la pantalla y probablemente establecer la posición en negativo 1,500. Entonces tenemos algo así. Y me voy a quedar con
esto por 2 segundos. Y vamos a
copiar este fotograma clave aquí seleccionando el fotograma clave, presione Control C, y
luego presione Control V. Así que va a copiar
este fotograma clave Simplemente eliminemos este fotograma de
doble clave. S. Acerquémonos y simplemente eliminemos
el segundo aquí. Y a los 3 segundos aquí, voy a mover esto quizás a uno y 500 en la posición. Ahora tenemos esta animación. Así que vamos a guardar esto
y podemos desactivar la DVU de nuevo a nuestro set Ahora ya hemos preparado la interfaz de usuario, podemos empezar a
modificar el código para crear un método de
cálculo de puntaje. Entonces ahora vamos a
la carpeta de scripts. Y primero,
primero, voy a abrir el script del gestor de UI. Aquí tengo abierto el script UI
Manager. Voy a crear un
par de variables. Pero antes de crear
las variables, voy a crear
un nuevo encabezado, y voy a llamar a
este score properties. Para estas propiedades de puntuación, necesitamos crear un par
de variables pro malla de texto. Vamos a crear el primero. Para la primera entrada, voy a agregar el texto de matar
al enemigo. He escrito esto mal aquí, así que debería ser un campo
serializado Vamos a copiar
esta línea aquí y voy a pegar esto
un par de veces. Ahora el segundo
sería el rehén kel. Y el tercero
serían los tiros. Y el cuarto
sería el si, y el quinto
debería ser la exactitud. Y queremos también crear un nuevo campo serializado con
un tipo de objeto de juego, y este sería el panel de la
pantalla final, y guardar esto A continuación, queremos crear un nuevo método público para mostrar
esos valores de pantalla final. Vamos a crear
un nuevo vacío público, y llamemos a
esta pantalla del programa. Con este método, vamos
a pasar un par de variables. El primero
sería el kel enemigo. El segundo
sería un entero también, pero este es el enemigo total. El tercero sería también
un entero, matanza de rehenes. El cuarto
serían los tiros, o simplemente podemos llamar a
esto tiros totales. Y el quinto calzado
será el hit total. Ahora dentro de este método, primero, queremos habilitar
el panel de la pantalla N, así podemos simplemente ejecutar el método
set active y luego pasar un through
como argumento. Para el texto de la kilt enemiga, queremos fijar su impuesto al valor del kel
enemigo dividido por el enemigo total y queremos
multiplicar esto por 100
para obtener el porcentaje Multiplica esto por
100, y después de eso, queremos convertir
estas dos cadenas A usando el método de dos cadenas con un argumento de dos dígitos aquí, y luego queremos
agregar un signo de porcentaje. Pero como ambos de este
valor es entero, esto producirá un entero. Entonces necesitamos lanzar uno de
este valor a un flotador. Entonces vamos a tener un valor de
fracción. Entonces podemos usar esos
valores para ser multiplicados por 100 para obtener el
porcentaje de nuestro enemigo kl. Entonces voy a lanzar aquí
al enemigo total
a un valor flotante. Y para el siguiente tex, voy a modificar
el texto de kel rehén Y podemos simplemente pasar la quilla de rehenes y
convertir estos dos en una cuerda Entonces para los tiros totales, puedes simplemente agarrar la variable
shot aquí, y luego establecer su impuesto
a los tiros totales, convertir estos dos,
para el impuesto de acierto, podemos simplemente modificar la
variable h, establecer su impuesto, y luego pasar el parámetro
total aquí, y luego convertir
estos dos en cadena. El último, queremos
modificar el texto de precisión aquí. Al usar la misma fórmula
con la quilla enemiga aquí, queremos dividir el golpe total dividido
por los disparos totales, pero necesitamos lanzar el
divisor en flotador, y luego queremos
multiplicar esto por 100 y luego convertir
estos dos en cadena Y luego agrega esto con
un signo de porcentaje. Necesito convertir
esto en una cadena. Bien. Sólo vamos a verificar
para padres a C aquí. Bien. Agreguemos un padre
a C aquí y veamos. Somos uno de los padres, así que he agregado, y ahora es
correcto y guarda esto. Bien, lo siguiente
que queremos
modificar es que queremos ir
al manager gay y
dentro del manager del juego, queremos crear un vacío
privado aquí. Voy a crear un
nuevo vacío privado a continuación. Y voy a llamar a
este show screen. Y para la pantalla final, queremos ejecutar el gestor de UI, y es el método show en Screen. Y queremos pasar aquí toda
esta variable. Así que vamos a pasar
todo el neme kill. Yo pienso, no, Enemigo mata. Sí. Enemigo total, y
también el rehén asesinado Y para el total de disparos, deberían ser disparos, creo, disparos hechos. Y por el golpe. Creo que sí, es golpe enemigo, y vamos a guardar el guión del manager del
juego. Después de modificar
el manager del juego, vamos al guión de
movimiento del jugador aquí, y queremos crear un nuevo
método para despejar un área. Entonces aquí necesitamos crear
un nuevo vacío público, y vamos a llamar a
esta área clara. Y arriba aquí, en el área
variable aquí, necesitamos crear un
nuevo entero privado, y vamos a llamar a
esta área clara. Dentro de este método area clear, queremos incrementar la variable entera area
clear, y queremos verificar
si el área despejada es
igual a la longitud de las entradas
de disparo Entonces significa que hemos despejado toda el
área en este nivel. Entonces queremos transmitir
un evento aquí. Necesitamos crear ese evento. Aquí arriba, voy a crear un nuevo evento estático público con un tipo de
sistema que accione. Y voy a llamar a esto en acabado de
nivel e insertar
un delegado vacío. Y como ya lo he explicado antes, evento estático
público es una característica muy poderosa
que puede
facilitar que los scripts se
comuniquen entre
sí o que un script active otro método
en otro script. Pero una cosa que
hay que recordar, esa estática es un objeto compartido. Entonces, al usar el evento estático, debemos asegurarnos de que
los scripts solo se adjunten a un solo
objeto en nuestra escena. Si hay varios scripts, entonces static no funcionará
porque solo agarrará el primero, pero ignorará al otro. Así que asegúrate de usar el evento
estático correctamente. Entonces ahora tenemos creado este
evento. Voy a volver al método
de área despejada, y voy a
invocar este evento Y luego voy a
devolver este método. Y si
todavía nos queda área en este nivel significa que
la declaración es falsa, entonces queremos continuar
el movimiento
ejecutando el
movimiento del jugador set a true. Bien, ahora ya hemos terminado con
el jugador muévete aquí. Volvamos al administrador
del juego, y queremos suscribir
este método de pantalla de demostración
al método de acabado de nivel
que acabamos de crear. Así que dentro del manager del juego
bajo el método I, queremos suscribir la clase de
movimiento de jugador aquí y el evento de fin de
nivel, y queremos suscribir el método show y screen
a este evento aquí. Y sobre esta capaz,
queremos también eliminar
esta suscripción. Entonces voy a copiar esta
línea aquí y luego cambiar las suscripciones al método de cancelación de
suscripción. Guarde esto. Y ahora
lo último que necesitamos
modificar es el guión del
punto de tiroteo. Así que vamos a abrir aquí el guión del punto de
tiroteo. Y ahora aquí abajo, cada vez que el enemigo mató y nosotros hemos matado a
todos los enemigos, no
queremos reanudar
el movimiento aquí, sino que en vez de
reanudar el movimiento, queremos ejecutar el método de
área despejada Y con el método de área despejada, automáticamente reanudará el movimiento si
todavía hay un punto de tiroteo
que necesitamos terminar Después de que modificamos la línea de movimiento del
jugador aquí, también necesitamos
asegurarnos de que
modificamos la de aquí aquí. Entonces en el área establecida clara, en lugar de reanudar
el movimiento, queremos también despejar el área, y esto se
llamará cuando termine el tiempo en cierto punto de
tiroteo Entonces con estos cambios, aunque no hayamos
matado a todos los enemigos, deberíamos poder avanzar al siguiente punto de tiroteo
cada vez que se acaben los tiempos Entonces, cambiemos esto
al método de área despejada. Y de esta manera, podemos
terminar el nivel, aunque no hayamos
matado a todos los enemigos, pero con el riesgo de una
puntuación más baja. Entonces, vamos a guardar esto. Ahora volvamos a la unidad
y configuremos la pantalla final. Y una vez compilado el script, podemos seleccionar el administrador del juego, y bajo el gestor de interfaz de usuario de
nuestro script de administrador de juegos aquí, tenemos muchos
campos nuevos declarados. Así que vamos a arrastrar
la pantalla final como el panel de la pantalla final aquí. Y si expandimos aquí todo el objeto de juego
infantil, podemos arrastrar el valor
de la escoba hostil a medida que
el enemigo se desplomó Y para la escotilla de rehenes, arrastra su valor
al kt rehén Para los disparos, arrastre aquí el valor
de los disparos realizados. Y para el valor de golpe de tiros, podemos dirigir esto
a la ranura de golpe, y para la precisión es
directa a la ranura de precisión. Y vamos a guardar esto. Y
ahora vamos a darle una oportunidad. Entonces ahora tenemos
listo este impuesto. Oh, lo siento. Olvidamos una cosa
que por defecto, la animación que hemos
creado se establece en bucle Por lo que queremos seleccionar
la animación fiscal lista y desactivar el total de
tiempo de bucle aquí. Y luego volvamos a probar esto. Intentemos matar a
uno de los rehenes. Y esperemos a que el
enemigo se presente y
matemos a éste. Ahí vas. Hemos matado al 75% del enemigo. Bien, hay un problema.
Tengo que revisar esto. Hay una condición de carrera
donde cuando estamos mostrando la pantalla final y luego comenzamos a calcular el porcentaje
del enemigo total, no se
ha registrado toda la matanza enemiga. Entonces, para arreglar esto en
el manager del juego, necesitamos retrasar
este método aquí. Para asegurarse de que toda la variable entera,
que es el enemigo muerto, total de rehenes enemigos muertos, muestra fuego y golpe enemigo, ha sido contada correctamente y asegurarse de que
no hay condición de carrera Así que vamos a usar la extensión this
delayed action y luego crear un delegado
vacío aquí. Y vamos a cortar este código aquí y luego
pegar dentro de este delegado. Vamos a retrasar este código aquí por un valor muy pequeño. Por ejemplo, 0.2 segundo, y luego limpiemos un poco
este código. Guarde esto. Y ahora
vamos a encabezar Unity. Y voy a cambiar la depuración del
Inspector para que podamos ver todos nuestros campos enteros aquí en el manager del juego
y luego presionar play. Así que vamos a
recoger el arma aquí y comencemos a disparar al enemigo. Esperemos a este enemigo de aquí. Hasta el momento, somos el 100%
de todos los enemigos. Y acabemos con
esto. Ahí vas. Tenemos el correcto de
porcentaje de matanza enemiga.
32. 31 Correcciones de errores, parte 1: En este video,
vamos a arreglar un par de cosas
y pulir los códigos. Hay temas hasta el momento
en nuestro proyecto aquí. Entonces ahora vamos a inspeccionar
cuáles son los temas. Entonces voy a jugar a este
proyecto, y echemos un vistazo. Bien. El primero sería cada vez que matamos a
un enemigo aquí, ya ves que tenemos este error. Y básicamente, este error, es revelador que obtener distancia
restante sólo
se puede llamar a un agente activo. Entonces de alguna manera, el enemigo scrip,
queda distancia, pero con el enemigo
ya muerto, esto está causando un problema Entonces tenemos que arreglar esto. Y sigamos con esto. Y la otra cosa
que tenemos esto, el rehén o el enemigo
es visible al inicio Entonces queremos asegurarnos de que
bombamos a todo el enemigo
y rehén Entonces en la tercera zona de
tiro aquí, cuando lleguemos a esta posición, no
deberíamos poder
ver primero al rehén Y cuando paramos,
entonces el rehén tembló aparecen y luego
empiezan a entrar en la pantalla Eso también lo vamos a arreglar. Y el tercero, se refiere al conteo total de
enemigos. En nuestro punto de tiroteo aquí, básicamente
estamos
contando el enemigo total aquí para comparar cada vez que
matamos a todo el enemigo, entonces queremos despejar el área Pero aquí hay un tema. Ahora probemos esto
y echemos un vistazo a la variable enemigo
total aquí. Como pueden ver aquí, al inicio, tenemos enemigo total de uno. Pero en realidad, aquí tenemos
dos enemigos. Y el segundo
se registra un poco más tarde después de que el primer
enemigo comience a moverse. Por lo que queremos asegurarnos de
que el enemigo total sea
contado enseguida cuando el punto de tiroteo se
inicialice Entonces tenemos que arreglar eso también. Entonces aquí, he creado una lista. Entonces, básicamente, los enemigos y el rehén deberían
estar escondidos al principio Y cuando el enemigo mató, existe este error
respecto a obtener distancia
restante del componente agente
NAF Mash, y debemos asegurarnos de que el conteo enemigo
ocurra antes Así que ahora vamos a arreglar todas
estas cosas aquí. Vayamos a isle Studio. Aquí en el guión del
punto de rodaje aquí, queremos esconder a todo el enemigo y al
rehén al inicio Entonces, para hacer eso,
solo vamos a crear un método de inicio, y luego veamos aquí
la lista de enemigos. Entonces llamemos
al enemigo variable y a la colección,
la lista de enemigos. Y en todo mi interior
la lista de enemigos, queremos ocultar el objeto del juego. Solo vamos a acceder al enemigo, y vamos a acceder al objeto de juego
enemigo aquí. Pero como el enemigo
es un scrip enemigo, entonces necesitamos acceder al objeto
del juego y luego acceder al método set active
y luego establecer estas dos caídas Después de que estamos poniendo al
enemigo dos falsos aquí, en el inicio, vamos a
copiar esta línea aquí, y tenemos que
asegurarnos de que queremos activar
al enemigo dentro la rutina de enviar enemigos
co aquí. Entonces cada vez que
se inicializa a los enemigos, queremos activarlo también Así que vamos a pegar
el código aquí y luego establecer este valor verdadero. Y la otra cosa
que queremos
modificar está dentro
del guión enemigo, queremos asegurarnos de que toda esta inicialización
ocurra en OA Porque con los cambios
realizados en el punto de tiroteo, estamos habilitando el objeto de
juego enemigo e inicializando el método de inicio del
guión enemigo en el mismo Esto puede causar una condición de carrera y podría omitir el método de
configuración de comportamiento de la ejecución. Si en ese momento, el agente aún no
ha sido agarrado, provocando que
los valores del agente sigan siendo nulos Así que de esta manera nos aseguramos de
que esto suceda primero, aunque el
objeto esté deshabilitado. Para el conteo
del enemigo aquí, podemos simplemente copiar esta línea
aquí o cortar esta línea, y podemos pegar esta línea
aquí dentro del método de inicio. Así que vamos a pegarlo aquí. Vamos a contar
el enemigo total cuando comiencen las escenas.
Vamos a guardar esto. Lo siguiente que queremos
arreglar es este de aquí. Para arreglar esto, tenemos que ir
al guión enemigo, y esto sucede porque la proteína
de disparo sigue funcionando, y este código de aquí
se evalúa, pesar de que el enemigo ya
ha sido asesinado. Entonces ahora tenemos que asegurarnos de que ejecutemos el método stop shooting, que van a detener la rutina conjunta dentro de
esta clase de script enemiga. Entonces, vamos a ejecutar
este
método de dejar de disparar dentro del comportamiento muerto. Entonces voy a agregarlo aquí, dejar de disparar y guardar esto. Y ahora volvamos
a Unity y probemos esto y veamos si se corrigen todos
los errores. Entonces voy a guardar
la escena también. Y voy a volver a
poner el retraso a tres o cuatro y decir esto. Ahora echemos un vistazo al valor total
del enemigo
aquí si presionamos play. Ahora cuando presionamos play,
cuenta enseguida. Tenemos dos enemigos totales. Ahora cuando aparezca el enemigo, podemos matarlos a
los dos o simplemente podemos
disparar este cañón, matar usando la explosión. Y ahora verás que ya
no tenemos al rehén Pero cuando entramos en
el punto Shota, llega
el rehén y aquí
solo podemos matar al enemigo Y ahora, si echas un
vistazo aquí, ya no
tenemos el error de obtener la
distancia restante. Por lo que aquí arreglamos todo el tema con respecto al enemigo.
Vamos a parar esto. Hay una cosa que
tenemos que arreglar aquí, una solución muy fácil
con respecto a la interfaz de usuario. Vamos a expandir
la cámara principal aquí y seleccionar el HUD
pagador Si vamos a la vista del
juego y después seleccionamos la cámara principal, voy a cambiar
esto de nuevo a la normalidad, y vamos a activar la opción de atrás y
vamos a fregar esto. A medida que nos movemos aquí,
verás que nuestra interfaz de usuario es recortada por la pared en esta
zona, esta área en particular Simplemente modifiquemos esto aquí. Y básicamente, tenemos que
asegurarnos de que el HUD esté mucho más cerca de la
cámara. Vamos a moverlo. Voy a cambiar
la posición z a 0.2. Y voy a fregar la
posición x para que podamos verla. Ahí vas y
frotas la posición y. Pero ahora es muy grande. Así que tenemos que asegurarnos de que la escala sea mucho
más pequeña que antes. Vamos a probar una décima parte de ella. Y ahora tenemos que fregar de nuevo
el yo para agarrarlo. Echemos un vistazo al
interior del editor aquí. Ahí tienes, así que voy
a moverme sobre el eje x. Cambiemos esto a
local y muévalo aquí. Tenemos habilitados estos pros. Voy a desactivar el
prog y esto manualmente. Y podemos usar el matorral
aquí para ver la interfaz de usuario. Ahora tenemos esta interfaz de usuario aquí
y es bastante pequeña, así que voy a establecer este 20, y luego voy a asegurarme de que esté mucho más cerca en el eje z. Hágalo un poco más lejos
y frote la posición. Hagamos este 23 o cuatro, negativo 0.0 45, y
hagamos esto negativo 0.08 Creo que esta es una
buena posición aquí. Ahora vamos a seleccionar la cámara
principal y vamos simplemente fregar la distancia de vista previa
bajo la opción de depuración, para que podamos ver si nuestra interfaz de usuario
está recortando un objeto Porque está muy cerca de
la cámara en estos momentos. Es visible todo el
camino hasta el final aquí. Sí. El debería
solucionar el problema de la interfaz de usuario. Y solo guardemos esto. Así que sí, arreglamos todos
los pequeños errores dentro de
este proyecto aquí. Y después de esto, vamos
a trabajar en el sistema de audio.
33. 32 Cursor del ratón personalizado: En este video,
vamos a crear un punto de mira para reemplazar
nuestro cursor del mouse Sólo vamos a la vista de
escena aquí. Y bajo el administrador del juego, queremos ir al objeto de juego
Canvas, y queremos crear
un nuevo objeto de imagen. Así que voy a hacer clic derecho aquí y luego ir al menú de la interfaz de usuario, y luego voy a
crear una nueva imagen. Para esta imagen, voy a llamar
a este punto de mira. Y voy a establecer su
anchura y su altura 250. Y para la imagen de origen, voy a escoger el pelo cruzado
UI que he preparado en el paquete UI.
Así que vamos a elegir esto. Y si haces zoom aquí, ves que tenemos
el pelo cruzado, y voy a cambiar
su color a rojo. Así que vamos a ir aquí y
voy a elegir rojo. Y ahora hemos creado
este punto de mira. Tenemos
que asegurarnos de que el punto de mira esté en
el orden
más bajo en el niño de Canvas Esto se renderizará último. Y ahora vamos a abrir el guión del manager
del juego. Aquí, dentro del script del administrador de
UI, necesitamos crear
una nueva variable, y voy a declarar una con un atributo de
campo serializado Para el tipo, voy a
establecer esta transformación de dos, y voy a llamar a
esto un punto de mira Y aquí dentro del método init. Queremos comprobar
por el pelo cruzado. Si el punto de mira no es nulo, entonces queremos ocultar nuestro mouse Así que podemos simplemente escribir cursor, el ysible, y luego establecer
este valor en falls Y guarda esto. Y
ahora aquí abajo, queremos crear un nuevo método
para mover el pelo cruzado. Así que vamos a crear
un nuevo método público, y voy a llamar a
este movimiento pelo cruzado. Y queremos pasar un árbol
vectorial como argumento, y vamos a llamar a
esta posición del ratón. Entonces aquí, básicamente,
tenemos que comprobar si el pelo cruzado no es Nulo, entonces queremos
mover el punto de mira Vamos a escribir el pelo cruzado, y luego queremos
acceder a su posición, y luego queremos aplicar
la posición del ratón que pasamos por este método
aquí como argumento. Ahora vamos a guardar esto, y
vamos al manager del juego. Y aquí dentro
del manager del juego, Necesitamos crear un
nuevo método de actualización. Así que vamos a crear un nuevo vacío, y vamos a llamar a esta actualización. Y básicamente, queremos ejecutar el método UI manager
que acabamos de crear, que es el estado de ánimo cruzado, y luego para la posición, simplemente
podemos pasar
la posición de entrada del mouse. Y vamos a guardar esto. Bien.
Ahora volvamos a la unidad. Una vez compilado el código, deberíamos tener los
parámetros de pelo cruzado en nuestro inspector, y ahora podemos arrastrar el objeto de juego en
forma de cruz y ponerlo en la ranura de pelo cruzado de nuestro script de administrador de juegos aquí Ahora vamos a guardar la escena aquí, y si vamos a la vista del juego
y vamos a probar esto. Verás que al jugar, el ratón está oculto y
podemos mover el pelo cruzado a medida que
movemos el ratón y podemos disparar exactamente a donde está
el pelo cruzado. Entonces así es como creamos un pelo cruzado personalizado o un cursor de ratón
personalizado en unidad.
34. Desarrollo de 33 looks: En este video, vamos a desarrollar un looks
para este juego aquí modificando los filtros de post
procesamiento y también modificando los
materiales en nuestra escena aquí. Entonces ahora comencemos. Aquí, he importado
una nueva textura y material para el enemigo robot
y también el rehén Robot, y voy a poner el paquete Y ahora vamos a sustituir el material a nuestro enemigo
y también al rehén Entonces primero, voy a
ir a la carpeta de prefet y abrir el prefe enemigo aquí, y voy a ir a la carpeta actualizada debajo
de la carpeta Robot Kyle
aquí dentro de los modelos Y tenemos dos nuevos materiales, que es el robot actualizado
y robot rehén actualizado Voy a arrastrar el robot
actualizado a este enemigo aquí. Y como puedes ver, tenemos
un material más brillante, y esto se verá
mejor una vez que
apliquemos el post procesamiento
en nuestro seno. Y ahora volvamos a la carpeta
prefs y voy a abrir los
prefs de rehenes y esta vez, solo
arrastremos aquí el material actualizado de rehenes a abrir los
prefs de rehenes y esta vez, solo
arrastremos aquí el material
actualizado de rehenes.
Y ahí tienes. Bien, entonces ahora hemos modificado tanto al enemigo como al rehén Volvamos a nuestra escena aquí, y vamos a crear
una caja de cielo personalizada
para reemplazar esta caja de cielo
original. Entonces voy a ir a la carpeta de materiales y
voy a crear un nuevo material, y llamemos a
esta caja cielo personalizada. Para este material,
voy a cambiar el shader por el sky box uno, y debajo del skybox, voy a escoger un procedimiento Voy a cambiar un
par de ajustes aquí. Si voy a la vista del juego aquí, voy a cambiar el color del
suelo para estar lo
más cerca posible con nuestro objeto de
cuadrícula aquí color. Solo usemos este selector de color y luego solo escojamos
el color aquí Para aplicar
este skybox personalizado, necesitamos abrir el menú de configuración de renderizado
e iluminación Y ya he ahorcado mis ajustes de
iluminación aquí, así que puedo simplemente arrastrar este skybox personalizado a
este material skybox, y cambiará nuestro
skybox, como puedes Entonces ahora tenemos aplicar el
skybox a nuestra escena aquí. Podemos modificar aún más la caja del
cielo yendo al
inspector y luego usar el selector de color o
la muestra de color aquí para modificar el bit de valor Así que es un poco sin fisuras
con nuestro terreno. Sí, creo que esto
debería estar bien. Y ahora para la lata del cielo, podemos cambiar a cierto
color si queremos. Voy a elegir un color ligeramente púrpura azul y púrpura
ish por aquí, y luego cambiar el
color a uno más oscuro. Para el espesor de la atmósfera, voy a disminuir
este valor hasta que tengamos un cielo más oscuro.
Algo como esto. Podemos cambiar la
exposición si queremos. Sólo voy a establecer esto en el
valor predeterminado, que es 1.3. Y ahora tenemos el
Skybox personalizado aplicado y
configurado correctamente Vamos a crear el perfil
de postprocesamiento. Para aplicar el proceso posterior, necesitamos ir a nuestro objeto principal del juego de
cámara
en la jerarquía, y luego agreguemos un componente de capa de post
procesamiento. Aquí en la configuración de la capa de post
procesamiento, necesitamos cambiar la capa a una capa específica
que queremos usar. Aquí, ya tenemos una capa de
post procesamiento, y si no la tienes, siempre
puedes ir a las opciones de capa aquí y luego presionar en layer y luego
crear una nueva capa. Pero como ya tengo esta capa de post procesamiento,
voy a usar esta. Regresa a nuestra
cámara principal y voy
a cambiar esto a la capa de
post procesamiento. Para el anti cantar, voy a cambiar
esto a hormigas temporales. Ahora hemos configurado la capa de
post procesamiento. Necesitamos crear un objeto de post procesamiento para ser aplicado a
nuestra cámara aquí. Necesitamos crear un
nuevo objeto anti juego. Y voy a llamar a
este proceso de post. Vamos a poner
a cero la transformación, y podemos agregar un componente de volumen posterior al
proceso. Y tenemos que
cambiar también la capa a post procesamiento y asegurarnos de
que es global está comprobado, por lo que el folum post proceso
aplicará la escena globalmente Ahora podemos crear un
nuevo perfil aquí, pero prefiero crear
en nuestra carpeta assets. Voy a ir a
la carpeta del juego aquí y voy a
crear una nueva subcarpeta, solo
llamemos a este perfil de
proceso Dentro de este perfil de
proceso de post, voy a crear un nuevo perfil de
post procesamiento aquí. Voy a llamar a este
juego juego juego PP. Ahora podemos asignar esto a nuestro objeto
post proceso aquí. Vamos a dirigir este proceso de post
juego dentro de esta ranura de perfil aquí, y ahora podemos agregar efecto. El efecto que
voy a agregar son la oclusión ambiental
y también el azul El siguiente sería
la gradación de color. Voy a agregar un reflejo de espacio de
pantalla, y también una multa. Ahora podemos modificar el
volumen de postprocesamiento, cada uno de los derechos. Primero, queremos habilitar
la oclusión ambiental. Solo habilitemos el modo
aquí y luego la intensidad. Además, podemos habilitar el
modificador de espesor si queremos. Lo siguiente que tenemos que
cambiar es la intensidad. Como puedes ver aquí, la
intensidad por defecto 20, así que necesitamos
aumentar este valor y verás que tenemos una oclusión ambiental
aplicada a nuestra escena Voy a hacer de este
valor uno muy pequeño. Quizás alrededor de 0.5 o uno. Probablemente menos de
uno sería mejor. Vamos a establecer este 20.75. Y podemos ver la
diferencia cada vez que desactivamos y habilitamos el occlión
ambiental El siguiente que queremos
establecer es la floración aquí. Sólo voy a habilitar la intensidad y el
umbral de la floración. Ahora podemos aumentar
la intensidad aquí. Pero no vemos ningún efecto de
floración porque nuestro material no tiene un valor MIF de rango
alto aquí Así que vamos a probar esto estableciendo la
intensidad primero 24, y podemos disminuir
el umbral. Así que vamos a bajar a medida que
bajemos el umbral, verás que la floración
afectará cada vez más el
color en nuestra escena. Voy a establecer
el umbral en 0.8. Esto debería ser suficiente. El siguiente que quiero
establecer es la gradación de color, y voy a establecer el modo aquí en rango de alta
definición. Y para el mapeo de tonos, voy a poner
el modo a ACS, y aquí tendremos un
color muy oscuro de nuestra escena, pero podemos compensar esto
con la opción de post exposición. Solo habilitemos
esto y aumentemos la exposición posterior a alrededor de 0.5. Y vamos a tener una imagen mucho
más contrastada. Y si queremos, también
podemos habilitar las bolas de pista aquí
habilitando el lift, la
gamma, y la ganancia. Voy a habilitar el
ascensor y el juego aquí. Y voy a
cambiar el ascensor, que es la zona oscura
a un color azulado Y para el beneficio,
voy a cambiar esto a la
dirección opuesta al azul, que es el color naranja para equilibrar el color
de nuestra escena aquí. Entonces esto es lo que tenemos hasta el momento. Y si queremos tener líneas
mucho más resplandecientes
aquí en nuestro objeto de cuadrícula, podemos ir a la escena
aquí y seleccionar uno de los objetos cubo y modificar
los materiales en él Entonces voy a ir a las opciones de emisión aquí
y luego presionar el, el color HDR, y voy a aumentar la intensidad a 1.5. Y como pueden ver aquí, medida que aumento la intensidad, ahora las líneas están más resplandecientes Bien. Y como puedes ver aquí, tenemos el jugador HUD UI también aplicado por el filtro
resplandeciente, pero no tenemos esta escotilla lista y rehén
aplicada por B para el lienzo, el lienzo principal aquí está configurado
para superponer el espacio de pantalla,
y para el HUD del jugador, el modo de renderizado de
la interfaz de usuario está
configurado Entonces por eso esto se ve afectado con el filtro de post
procesamiento. Entonces para asegurarnos de que este lienzo también se vea afectado, necesitamos cambiar el
modo de renderizado a cámara de espacio de pantalla, y luego necesitamos elegir nuestra cámara como la cámara de renderizado
de este lienzo aquí. Así que vamos a dirigir
la cámara principal a la ranura de la cámara aquí. Y ahora ya no podemos
ver la interfaz porque está muy
lejos en la distancia
de nuestra cámara, así que en realidad está detrás
de nuestro objeto de juego aquí. Entonces voy a hacer de este un valle muy pequeño, que es 0.1. Y ves que nuestra
interfaz de usuario está en mal estado. Entonces, para refrescar esto, solo
podemos desactivar
y habilitar esto. Y como puedes ver,
tenemos una interfaz de usuario actualizada, y ahora está brillando Y debido a que estamos cambiando el modo de renderizado de la interfaz de usuario a
la cámara espacial de
pantalla, el punto de mira personalizado ya no
funcionará, así que necesitamos separar este
objeto en un nuevo lienzo Así que voy a crear
un nuevo lienzo de interfaz de usuario aquí. Simplemente llamemos a esto Canvas de pelo
cruzado. Pongamos el objeto de juego de
pelo cruzado debajo del niño de esta lona de pelo
cruzado. Establezcamos este lienzo
en una escala con tamaño de
pantalla debajo de
la escala Canvas y establecemos esto en una resolución
Full HD, y establecemos la coincidencia Para el punto de mira, podemos volver a
establecer la escala en uno,
y vamos a poner a cero este valor
aquí Así lo podemos ver
aquí en el medio. Y la otra cosa que
tenemos que modificar es el impuesto de quilla de rehenes porque la forma en que mostramos
el impuesto de quilla de
rehenes,
similar al punto similar Entonces para arreglar esto, tenemos que poner la escotilla de rehenes
también en este lienzo aquí Así que vamos a arrastrar esto. Y
ponlo por encima del pelo cruzado. Entonces el pelo cruzado
se rinde menos. Entonces esto debería solucionar el
problema con la interfaz de usuario. Otra cosa que
tenemos que modificar. Tenemos que asegurarnos de que
la transformación
de quilla de rehenes vuelva al valor
predeterminado aquí Así que vamos a seleccionar
la quilla de rehenes, y como puedes ver, tenemos todo tipo de números
en la
rotación de posición y la escala Entonces voy a volver a poner la
posición a cero. Y para la rotación,
también
voy a poner todo el
eje de nuevo a cero. Y para la escala, queremos
poner esto de nuevo en uno. Porque antes el texto de quilla
rehén estaba en este lienzo de
cámara espacial de pantalla, y tiene diferentes valores
para la transformación directa Cuando volvemos a la superposición del espacio de
pantalla aquí, el
valor de transformación directa se transfiere de este aquí al lienzo en
cruz Entonces tenemos diferente
transformación. Y por eso tenemos todos los valores equivocados en la transformación de nuestro texto de quilla
rehén Así que ahora vamos a guardar la escena, y vamos a probar esto. Y como puedes ver aquí,
tenemos una cruz de trabajo. Y ahora echemos un vistazo si los kel rehenes están posicionados en la
posición correcta en la pantalla Bien. Y ahora tenemos
otro tema aquí. Si disparamos al enemigo, ya ves que no tenemos
los efectos eléctricos. Con el rehén, todavía
tenemos esos efectos eléctricos, pero con el enemigo, ya no
tenemos esos efectos. Y esta es una
solución rápida en realidad. Tenemos que ir a
la carpeta prefe y abrir las prefs enemigas Y aquí, si
seleccionamos al enemigo, necesitamos mover los efectos de golpe para estar encima del guión
enemigo aquí. Así que vamos a mover
esto hacia arriba y asegurarnos de que
el método de golpe dentro nuestros efectos de golpe
también se ejecute cada vez que el enemigo reciba
un disparo o un daño. Y ahora volvamos a nuestra escena y probemos
esta una vez más. Y voy a intentar
dispararle al enemigo. Y ahí tienes.
Tenemos el efecto. Y vamos a disparar
esta bomba aquí. Y recoger esta arma
y matar a este enemigo. Sí. Bien. Entonces todo funciona bien hasta ahora, y con la aplicación de filtros de post
procesamiento, puedes ver que tenemos un juego
mucho mejor parecido. Por lo que te animo a experimentar con el filtro de
post procesamiento y también los ajustes de materiales
para lograr una mejor apariencia.
35. 34 Arreglo de la parte superior del cuerpo enemigo: Este video, vamos a arreglar el movimiento enemigo de la parte superior del cuerpo. Y aquí, si presiono súplica, y verás que
actualmente nuestro enemigo
al moverse tiene un extraño
movimiento en la mano,
la mano que sostiene las armas Como puedes ver aquí. Es raro. Y también queremos arreglar
la animación muerta, a veces no
se activaba correctamente. Así que vamos a hacer eso.
Voy a parar esto. Y ahora vamos a ir a
la ventana del animador, y si el
animador enemigo no está abierto, solo
podemos ir a la carpeta de
animaciones debajo
del controlador y
luego hacer doble clic en el controlador enemigo base Y ahora aquí en el controlador
base, primero, quiero cambiar la transición por
el estado muerto aquí. Entonces voy a
cambiar la condición para usar el interior
del gatillo muerto. Vamos a usar
el bulion muerto, y ponernos a la verdad Y bajo la configuración, queremos deshabilitar puede
transitar a sí mismo. Así que vamos a desactivar esto. Entonces la transición sólo ocurre una vez cuando
el enemigo está muerto. Y luego queremos crear una nueva capa para la parte superior del cuerpo. Entonces voy a llamar a
esto parte superior del cuerpo. Y para los ajustes, queremos aumentar
el peso a uno, y para la masa, queremos usar la masa superior del cuerpo que hemos
creado para el rehén Así que vamos a usar
esto. Y aquí, necesitamos crear
tres nuevos estados. Entonces voy a llamar a este ídolo. Voy a duplicar esto, y la segunda
será la reacción acertada, y la tercera
será la guarida. Ya que estamos anulando la parte superior
del cuerpo de la animación, necesitamos asegurarnos de que
tenemos cada animación
para cada condición Entonces si voy a la capa
base aquí, verá que tenemos tres estados, y queremos reemplazar todo el movimiento
de la parte superior del cuerpo dentro del árbol de mezcla con
este estado inactivo aquí. Y para el estado de golpe, se va a
sincronizar con el estado de golpe de la zona
superior del cuerpo, y el estado muerto
también se sincronizará con el estado muerto de la capa
superior del cuerpo aquí. Entonces ahora vamos a crear una
nueva transición de cualquier estado al estado golpeado y también de cualquier estado
al estado muerto. Y queremos
crear una transición del hit back al inactivo, al igual que nuestra capa base aquí. Entonces ahora dentro del estado inactivo, queremos usar la animación de rifle
apuntando inactivo, y para el estado de golpe, queremos usar la reacción al golpe. Para el estado de la muerte,
queremos usar la muerte por disparo a la cabeza Y ahora para los
ajustes de transición, para el golpe, queremos establecer una condición cada vez que se dispara al enemigo o se activan los parámetros de disparo. Y queremos establecer si el
bulion muerto es actualmente falso. Es decir, que el
enemigo sigue vivo, y como puedes ver aquí
en la capa base, tenemos los mismos ajustes de
transición. Así que queremos asegurarnos de que la configuración de transición sea la misma que la de la capa base. Entonces esto ya es correcto. Y queremos
asegurarnos de que del hit
al inactivo esté
usando el tiempo de salida. Entonces esto también ya es correcto. Y ahora por la muerte, queremos asegurarnos de que
yo que Ban desencadena
esta animación. Vamos a elegir es que Ban
y luego establecer esto en verdad. Y luego queremos desactivar también la transición a las opciones de
auto aquí. Entonces ahora hemos puesto aquí
al animador. Voy a guardar
el proyecto una
vez más para guardar todos los
cambios en nuestros activos. Y ahora solo vamos a verificar
dos veces. H ponemos? Ya ponemos toda
la animación, el
clip de animación correcto. Vamos a probar esto. Y echemos un vistazo cuando
el enemigo se está moviendo, debería tener la animación correcta de la
parte superior del cuerpo. Bien. Ahí vas. Es mucho mejor, y
podemos matar esto. Y como pueden ver, esa
animación es más confiable ahora, porque cuando estaba
probando antes,
a veces se activa, a
veces no
se activa, veces no
se activa, o tal vez hay salto de fotogramas cada vez que
se activa ese disparador. Entonces ahora tenemos las animaciones
correctas, y es mucho mejor a la
hora de movernos de lado, la posición de la mano que
sujetando las armas Entonces, sí, así es como arreglamos el movimiento enemigo de
la parte superior del cuerpo.
36. 35 Configuración de la biblioteca de audio: En esta sección, vamos
a trabajar en el sistema de audio. Y en este episodio, vamos a definir
nuestro guión de audiobiblioteca. Entonces para hacer
eso, vayamos a la carpeta del juego de guiones bajos
y vayamos a la carpeta de scripts Y aquí, voy a crear un nuevo objeto scriptable para contener los datos de
nuestra biblioteca de audio Así que vamos a crear un nuevo script CHO dentro de la carpeta de objetos
scriptable, y vamos a llamar a
esta biblioteca de audio Otro script que necesitamos
crear es el titular de datos de audio. Voy a crear
un nuevo script CHR, y voy a llamar a
esto datos de audio. Y abramos
los dos guiones aquí. Ahora tengo abierta la Audio ta y
la audioteca. Voy a trabajar primero en la
Audioteca. Aquí en la biblioteca de audio, necesitamos cambiar la clase base en un objeto
scriptable, clase base Y también queremos
crear un menú de activos. Así que vamos a agregar el atributo create
asset menu, y luego para el argumento, queremos establecer el
nombre del archivo en Audio Lib. Y para el segundo argumento, voy a poner el
nombre del menú a Biblioteca de audio. Y voy a eliminar el
inicio y el método applet. Ahora queremos definir
los datos de audio que podemos poblar dentro de
la biblioteca de audio Aquí dentro de los datos de audio, simplemente
eliminemos la
clase base aquí porque esta va a ser una
clase personalizada para contener un dato, y voy a eliminar
todo el método dentro. Lo primero que
quiero crear,
quiero crear un campo
serializado, y esto será
un tipo de cadena, y voy a llamar a
este campo nombre de audio Y para el siguiente método, queremos crear una
matriz de clip de audio. Vamos a crear una matriz
de clips de audio, y llamemos a
este clipse de audio Y la otra cosa
que queremos configurar es que queremos crear
una nueva variable flotante, y este va a
ser el tono mínimo. Y el segundo
sería el máximo pitch. Podemos establecer un valor predeterminado aquí. Vamos a establecer este flotador 20.9. Y para el tono máximo, pongamos este 21.1 Y vamos a
utilizar esta variable para
aleatorizar el tono de nuestro audio cada vez que
estemos reproduciendo los De esta manera hará que el
sonido sea más dinámico. Y como todo el
campo es privado, necesitamos hacer un getter público Voy a definir el getter
público a continuación aquí, como este tipo public, y voy a crear
el getter de nombres de audio Y esto devolverá
el campo de nombre de audio. También voy a crear
la recopilación de clips de audio, y este será el clip de
audio único, no una matriz. Vamos a llamar a esto
Obtener clip de audio, y podemos devolver
el clip aleatorio de la matriz de clips de audio. Vamos a escribir clips de audio. Para el índice, podemos usar un rango aleatorio y para el
mínimo debe ser cero, y el máximo sería la longitud del punto clipse de
audio Esto capturará el
audio
dependiendo del número de miembros
dentro de esta matriz de clips de audio, y elegirá aleatoriamente uno de los
clips de audio en esta matriz aquí. Así podemos definir
más de un tipo de sonido para un disparo, por
ejemplo, y éste reproducirá aleatoriamente
diferentes audio, y además tocará con
un tono diferente aquí El último que
necesitamos configurar es el getter de flotación para
el máximo pitch Y aquí, vamos
a llamar a esto get pitch. Esto es
lo de la red con Getter. Podemos crear una expresión
simple para devolver algunos datos. Con el clipse de Audi,
podemos devolver clips aleatorios, y con el get pitch, podemos devolver un valor aleatorio entre este tono mínimo
y máximo Solo usemos un método de rango
aleatorio, y luego pasemos el tono mínimo. Como el valor mínimo y pasar el tono máximo como
el valor máximo. Bien, ahora hemos terminado
con los datos de audio. Podemos ir a la biblioteca de audio, y podemos crear una matriz de estos datos de audio que
acabamos de crear. Así que vamos a definir
un campo de seriales aquí, y voy a crear
una nueva matriz de datos de audio Y voy a llamar a
esto Lista de audio. Dentro de este objeto scriptable, queremos crear
un método público para devolver los
datos de audio por su nombre Voy a crear
un nuevo método público, y esto devolverá
un dato de audio. Y voy a llamar a
esto obtener Audio por su nombre. Y aquí queremos pasar
el nombre como argumento. Dentro de este método, vamos a crear
un nuevo dato de audio. Simplemente llamemos a
este valor y pongamos esto en nulo por defecto. Y queremos revisar
la lista de audio aquí. Vamos a llamar al audio de miembro
variable. Y para la colección, solo
podemos pasar la lista de audio. Y queremos comprobar
si el nombre del audio, es igual al nombre que estamos pasando
aquí como argumento, entonces queremos llenar el valor con este audio aquí con el audio
correcto aquí. Y luego después de eso, queremos devolver el valor. Entonces con este método, podemos simplemente pasar una cadena del nombre de audio, y este método devolvemos el valor correcto de
los datos de audio en base su nombre porque
declaramos el nombre aquí. Por lo que comparará
la cadena con este campo aquí. Bien,
vamos a guardar esto. Y ahora volvamos
a Unity y creemos el objeto de biblioteca de audio
dentro de nuestra carpeta de datos. Voy a ir a
la carpeta de datos aquí, y voy a crear
una nueva biblioteca de audio y simplemente llamar a este laboratorio de audio. Si seleccionamos esto,
verás que
todavía no podemos
ver la variable porque necesitamos asegurarnos de que los
datos de audio sean serializables Voy a agregar un sistema de
atributos que serializable
aquí y guardar Ahora si volvemos a Unity, deberíamos poder ver
los datos. Ahí vas. Tenemos la lista de audio, y
podemos ampliar el tamaño. Entonces, por ejemplo,
puedo establecer la talla 21, y aquí puedo
rellenar el nombre. Entonces, por ejemplo, este
sería el disparo. Y podemos ampliar
el audioclipse, y luego podemos llenar Y no sé por qué
se establece el tono mínimo y el tono máximo 20. Así que vamos a configurar esto manualmente. Voy a establecer
este 20.9 y 1.11. Y he importado un par de sonidos dentro del audio aquí, para que podamos elegir uno de los audios. Por ejemplo, este disparo de
sci fi, y podemos elegir este de aquí Y estos serán los primeros datos de
audio que tengamos, y para el segundo ejemplo, podemos ampliar el tamaño aquí, y duplicará
el primero, y podremos cambiar este valor. Por ejemplo, digamos que
solo llamemos a este ZP eléctrico. Lo siento. Debe ser eléctrico ZAP Entonces para el audioclipse, podemos cambiar esto al crujido
eléctrico aquí Entonces ahora hemos configurado
la biblioteca de audio. En el siguiente video,
vamos a seguir implementando el audio.
37. 36 Configuración del reproductor de audio: En este video, vamos a seguir trabajando en
el sistema de audio. Y en el último video,
ya creamos la
audioteca. Entonces ahora necesitamos crear la funcionalidad
para reproducir este audio. Entonces vamos a la carpeta Asset y dentro de la carpeta scripts, voy a crear
una nueva subcarpeta Y voy a llamar a
esta carpeta Audio. Y voy a crear un nuevo Cc y voy a
llamar a este reproductor de audio. Y abramos este guión del reproductor de
audio. Primero, voy a eliminar
el método applic aquí. Y luego voy a crear
un nuevo campo serializado, y este será el
tipo de biblioteca de audio, y vamos a llamar a
esto Audio ib Y queremos asegurarnos de que este script aquí esté disponible
globalmente en nuestro proyecto. Entonces voy a crear
una referencia estática, una estática pública, y el
tipo sería reproductor de audio. Y voy a
llamar a esta instancia, y esto será un
getter público con un conjunto privado Entonces solo el script que
puede establecer este valor, pero todos los demás
scripts pueden obtener el valor dentro de
esta referencia estática. Así que vamos a crear un método de vigilia. Y podemos llenar este
valor de instancia con el script aquí. Vamos a pasar esta
palabra clave como el valor. Y ponemos esto dentro del ak, así que queremos asegurarnos de
que esta instancia esté disponible antes de que se inicie cualquier
otro script. Ahora dentro del inicio, queremos inicializar las fuentes de audio que necesitamos para reproducir un audio
en este proyecto Pero primero, queremos
crear un integrer, variable, y esto
es para definir cuántas fuentes
queremos tener en nuestro sc Y voy a establecer
esto en seis por defecto. Y también queremos crear un grupo mezclador de audio para diferenciar las fuentes de audio efectos de sonido y
para la configuración del mezclador de música. Necesitamos usar el Unity e s, Unity Engine Audio, y vamos a crear un
nuevo campo serializado Y este sería el grupo mezclador
de audio. Y llamemos a este grupo de efectos de
sonido. Y el segundo sería
el grupo de música de fondo. Y ahora lo siguiente
que queremos crear,
queremos crear una Q. privada Y por qué estoy usando Q porque
es mucho más ligera que para que no sea Veamos las breves
descripciones sobre Q. Q representa una colección primero en entrar primero en
salir de un objeto. Se utiliza cuando se necesita un acceso primero en entrar primero en salir de los artículos. Entonces digamos que tenemos una cola
de objetos llamada M Q, y la llenamos con un objeto. Cuando agregas un ítem en una lista, se llama Q y Q agrega un elemento al
final de la cola, como este ejemplo aquí. Cuando eliminas un elemento, se llama Q.
El Que elimina
el elemento más antiguo del inicio de la cola, y para poner el objeto
con la cola, solo
podemos usar y hacer cola. Y esto volverá a poner
el objeto dentro de nuestra cola
como último elemento. La otra forma de
obtener referencia
al elemento más antiguo
es mediante el uso de pk. Pak devuelve el elemento más antiguo, es
decir al inicio de la, pero no
lo elimina de la cola. Y volvamos
a nuestro proyecto. Para el tipo,
será una fuente de audio, y vamos a llamar a
estas fuentes de audio. Y vamos a inicializar esto. Y ahora queremos poblar
estas fuentes de audio con el objeto de juego que tiene componente de fuente de
audio
adjunto a él Vamos a crear
un nuevo método en. Pero antes de continuar
en el método init, vamos a crear otra fuente de audio
privada, y esta sería
una única fuente de audio, y esta será la fuente BGM Entonces ahora dentro de este método init, queremos crear un nuevo objeto de
juego y luego establecer
ese objeto de juego como la fuente BGM
o las fuentes de audio,
y luego asegurarnos de que
esos objetos del juego estén
establecidos para ser el hijo de este objeto fuente BGM
o las fuentes de audio, y luego asegurarnos de que
esos objetos del juego estén de juego reproductor de
audio Entonces primero, vamos a
crear un nuevo objeto de juego, y llamemos a este objeto BGM Y voy a crear
un nuevo objeto de juego y podemos pasar su nombre aquí. Entonces llamemos a
esta fuente BGM. Y para el campo fuente de
audio fuente BGM aquí o Objeto fuente de audio, queremos agregar el componente Fuente de audio
a este objeto de juego BGM Vamos a escribir en el componente. Desde el juego ob objeto
aquí en component, y luego podemos pasar el tipo, que es la fuente de audio, y esto creará
una nueva fuente de audio adjunta a este objeto de juego. Y lo siguiente que
queremos establecer es que queremos establecer el valor de
mezcla espacial fuente BGM 20, así que este será un sonido de dos D. Y también queremos establecer el valor del grupo mezclador de
salida,
solo el grupo mezclador de
audio de salida, para que sea el grupo BGM Y lo último que
queremos establecer es,
queremos establecer este objeto de juego para que sea hijo de nuestro reproductor
de audio objeto de juego. Así que vamos a acceder al
objeto BGM, transformar componente, y luego establecer el padre
a esta transformación de objeto Y ahora queremos crear las fuentes
de efectos de sonido
dentro de un bucle aquí. Entonces queremos hacer un bucle, y queremos hacer un bucle esta cantidad
de tiempo aquí. Voy a copiar
este nombre entero y pegar esto como la longitud, y queremos ejecutar
este código dentro de
seis veces en base a este número de fuente de
audio, y podemos cambiar esto
en el inspector, para que podamos tener más
fuentes de audio en nuestra escena. Así que vamos a crear
un nuevo objeto de juego. Y este será el objeto de efecto
sonoro. Y voy a crear un nuevo objeto de juego
y pasar un nombre, que es la fuente del
efecto de sonido. Pero voy a agregar
el índice i más uno, así que partirá de
uno en conjunto desde cero, y voy a convertir esta cadena de dos con un
formato de dos dígitos aquí. Lo siguiente que queremos crear es que queremos
crear
una nueva fuente de audio
Simplemente podemos llamar a esto temporal, y luego queremos agregar fuente de
audio a este efecto, no el grupo de efectos de sonido, sino el objeto de efecto de sonido. Podemos usar el método at
component y luego pasar el tipo, igual que hicimos con el objeto de
juego de música de
fondo aquí. Bien. Entonces ahora tenemos
la fuente de audio. Podemos configurar esta
fuente de audio y luego poner esta fuente de audio dentro del
pool de nuestras fuentes de audio. Así que vamos a establecer
el T espacial soso uno esta vez porque queremos
crear un sonido de tres D. Y entonces lo siguiente
que queremos establecer es el grupo mezclador de audio de salida, y este debería ser el grupo de efectos de
sonido, queremos
establecer también el padre de
este objeto de efecto de sonido
a este objeto de juego aquí. Simplemente accedamos
al método
parent set transform y luego pasemos la transformación de este objeto de juego reproductor de
audio. Y lo último que
queremos hacer es que queremos poner estas fuentes de audio dentro
de nuestra fuente de audio Q aquí. Entonces solo podemos acceder a
la fuente de audio Q, y luego podemos ejecutar
el método n Q y
podemos pasar el objeto de juego T. Así que esto llenará
la
cola de fuentes de audio con la
fuente de audio que
acabamos de crear dentro de
la balandro aquí Y si el valor entero es seis, entonces tendremos
seis fuentes de audio
dentro de nuestra cola de fuentes de audio
aquí. Y ahora antes de continuar
trabajando el audio, necesitamos crear un método de
extensión para reproducir el objeto de datos de audio aquí
a través de nuestras fuentes de audio. Así que vamos a abrir
el script de extensión. tengo aquí. Y voy a crear una nueva estática pública. Y se debe presentar el tipo de devolución. Podemos llamar a esto
reproducir datos de audio. Y queremos extender
la fuente de audio. Entonces necesitamos usar
esta palabra clave aquí y definir la clase o el objeto que
queremos extender, que es la fuente de audio, y llamemos a
esta fuente A, y comencemos el método aquí. Otra cosa que queremos
pasar son los datos de audio. Así que vamos a pasar
los datos de audio aquí, y vamos a llamar a
estos datos de audio. Y ahora porque estamos
extendiendo esta fuente de audio, podemos usar esto para
configurar el tono y los clips de audio y
reproducir esos clips de audio. Así que vamos a escribir una fuente y acceder a ella Propiedades de tono, y podemos pasar los datos de audio get pitch propiedad
o acceso o getup. Y esto devolverá
un valor aleatorio
del tono de audio que hemos
configurado en estos datos de audio aquí. Y para el clip, queremos asignar también esto con los datos de audio Obtener clip de audio. Y esto devolverá
los miembros aleatorios del clip de audio dentro de la matriz
de clips de
audio de nuestros datos de audio aquí. Ahora después de configurar dos propiedades
diferentes aquí, queremos reproducir el clip de audio. Simplemente accedamos a la fuente A y luego ejecutemos el método de reproducción. Ahora que configuramos este método de extensión
dentro de la extensión, podemos volver al reproductor de
audio y luego comenzar a crear un método
para reproducir un audio. Aquí queremos crear
un nuevo vacío público. Y vamos a llamar a esto
reproducir efectos de sonido, y queremos pasar
un nombre de audio de cadena porque vamos a referir el audio usando su nombre
en lugar de sus clips. Y si abrimos la
audioteca, vamos a abrir aquí la
audioteca. Verás que
tenemos esta función, obtenemos el audio por su nombre aquí, y devolverá
la rata de audio. Vamos a usar sólo
el nombre para reproducir un audio. Para ello, primero, necesitamos crear aquí una fuente de audio
temporal. Y podemos obtener esta
fuente de audio de nuestra cola de fuentes de audio aquí
o la extracción de fuentes de audio dentro de
la fuente de audio Q. Así que vamos a escribir fuentes de
audio, y vamos a usar
el método D Q, y esto devolverá la
fuente de audio más temprana en nuestra cola. Y aquí queremos pasar también
la transformación del color. Así que llamemos a
esta ubicación de audio. Y queremos establecer
la posición de nuestra fuente de audio a
esta posición aquí. Así que vamos a agarrar la posición
desde la ubicación de audio. Y luego queremos
reproducir los datos de audio. Debido a que extendemos esto, tenemos el método
de visualización de datos ahora
tenemos el método
de visualización de datos de audio para nuestras fuentes de audio. Así que vamos a usar esto y necesitamos convertir la
cadena en datos de audio. Como ya tenemos referencia
a nuestro audio lib aquí, podemos usar el método escribiendo el audio lib que
obtiene audio por nombre, luego podemos pasar la cadena de nombre de audio que pasamos dentro de
este método aquí. Solo usemos ese
nombre de audio. Y cierra esto. Y esto reproducirá los datos
de audio seleccionando sus clips de audio aleatorios y
también su tono aleatorio. Entonces tendremos un
audio diferente cada vez, y esto hará que el
sonido sea más dinámico. Y entonces lo último
que queremos hacer es que queremos volver a poner la fuente de
audio a su piscina usando el NQ y pasar aquí la fuente de audio
Tam Entonces barajaremos la fuente de audio más temprana
antes de reproducirla, y después de reproducirla, la
pondremos para que sea la
fuente de audio más reciente dentro de nuestra piscina Y esto se repetirá una y
otra vez cada vez que
toquemos efecto de sonido. Y vamos a guardar esto. Entonces
ahora tenemos esta configuración. Necesitamos crear una nueva costumbre podemos crear una cadena
en realidad para esto, pero voy a crear
un nuevo objeto personalizado para definir el audio
que queremos reproducir. Y verás por qué he creado este objeto personalizado
en el siguiente video. Primero, voy a crear un atributo un atributo
serializable Y esto sería captador de audio. Y dentro de este captador de audio, tendremos un nombre de audio de
cadena pública Bien, ahora tenemos esto. Podemos abrir los datos del arma. Y dentro de estos datos de armas, podemos crear un nuevo campo
serializado, y el tipo así que sea
el captador de audio Y llamemos a esto efectos de sonido de disparo de
pistola. Y ahora queremos tocar
este efecto de sonido. Dentro de este método de fuego, creo que es Sí, está en el método de
actualización de armas. Queremos tocar el sonido. Entonces siempre que estemos disparando, o simplemente podemos ejecutar los efectos de sonido dentro
del método de fuego porque
tenemos este método de fuego compartido por estos dos tipos de
armas diferentes. Así que vamos a ir aquí
al método del fuego. Y ahora podemos acceder
al reproductor de audio esa instancia ya que ya
creamos una referencia estática, y podemos ejecutar el método play
sound effX Y esto un para un nombre de audio. Así que vamos a pasar el sonido de
disparo de arma Nombre de audio. Y luego queremos pasar la
transformación de nuestro jugador. Y como ya
tenemos una referencia al reproductor dentro de
este objeto scriptable, podemos simplemente pasar esta transformación de este componente player aquí Así que vamos a escribir
player do transform. Entonces ahora tenemos un efecto de sonido de
trabajo
para el efecto de sonido de disparo Vamos a ampliar
esto en el video posterior, pero vamos a tratar de
configurar esto dentro de la unidad. Entonces volvamos a Unity. Y ahora para el reproductor de audio, voy a adjuntar
este reproductor de audio al manager del juego. Entonces voy a agregar el componente reproductor
de audio aquí. Y queremos agarrar
la biblioteca de audio que hemos creado dentro de nuestra carpeta de datos. Así que solo seleccionemos esta opción aquí y luego
escojamos la biblioteca de audio. Y solo podemos dejar el grupo de efectos de sonido y vacíos por ahora
el grupo de efectos de sonido y el
grupo de música de
fondo. Entonces, vamos a guardar la escena aquí. Y ahora para configurar el audio. Podemos ir a la
carpeta de datos y revisar el labio de audio y
recordar el nombre aquí, el disparo y zap eléctrico Voy a copiar
este nombre aquí. Y podemos ir a
la pistola predeterminada, y para el efecto de sonido de
disparo de pistola, podemos simplemente pegar el nombre de la pistola dentro
del campo de nombre de audio. Y para la ametralladora,
vamos a usar el efecto de sonido. En este ejemplo, pero
podemos cambiar esto más adelante. Bien. Entonces ahora
ya configuramos esto. Vamos a probar esto. Creo que necesito asegurarme que el audio no sea demasiado alto. Entonces voy a ir
a la configuración del proyecto, y voy a disminuir
el volumen a 0.1 aquí. Y vamos a probar esto.
Aquí hay un problema. Olvidé ejecutar el método init dentro
del reproductor de audio. Así
que vamos a hacer eso. Ir al reproductor de audio, y queremos ejecutar
este método init Vamos a escribir en él. Y ahora volvamos a la unidad. Ahora bien, si presiono play, y si hacemos una pausa en esto,
verás que tenemos mucho objeto de
juego abajo aquí. Y esto es para la fuente de audio que queremos usar para
reproducir efectos de sonido, y esto es para
reproducir la música. Ahora si presiono play, vamos a probar. Ahí vas. Sí, tienen sonidos, y cada vez es diferente. Sí. Tiene diferente tono. Entonces ahora tenemos unos efectos de sonido que
funcionan, y los efectos de sonido
también serán dinámicos, lo cual
es algo bueno. Y queremos
simplificar la forma en que
elegimos el nombre del audio aquí
usando un cajón personalizado. Entonces en el siguiente video,
vamos a hacer eso.
38. 37 Editor personalizado de audio Getter: En este video,
vamos a crear un cajón de propiedades personalizado
para nuestra clase de audio gator. Ahora mismo, si vamos a
la carpeta de datos y si seleccionamos uno de los
datos de arma objeto scriptable, ya sea el de false
gun o ametralladora, verás que
siempre que queramos definir los efectos de sonido
que queremos usar, necesitamos escribir el nombre del audio Y esto es propenso a error o error cada vez que estamos
escribiendo el nombre del sonido. Para que esto sea más fácil, necesitamos crear un cajón de
propiedades personalizado para esta clase. Para hacer eso,
necesitamos crear un nuevo script para
sobrescribir al editor Voy a crear una
nueva subcarpeta dentro la carpeta de scripts y
voy a llamar a este editor Y todo el archivo CSR que se encuentra dentro de
esta carpeta del editor, no
se incluirá
en el proyecto de ley Entonces, para cada
funcionalidad del editor, deberíamos estar poniendo los scripts dentro de la carpeta
del editor,
y esta carpeta del editor se puede crear en cualquier lugar dentro de
nuestra carpeta de proyectos. Aquí voy a crear
un nuevo guión CHR, y vamos a llamar a este cajón de recolección de
audio. Y abramos esto. Ahora bien, si vamos a
la biblioteca de audio, es por eso que creamos una clase personalizada para la cadena
de nombres de audio. De lo contrario, siempre podemos usar una cadena directamente
dentro de los datos del arma, por ejemplo, para definir el
ID de efectos de sonido de audio o el nombre. Pero ahora, como queremos
sobrescribir la pantalla
o el inspector, es por ello que creamos
una clase personalizada para ello Entonces ahora vamos al cajón del getter de
audio y necesitamos eliminar todo
el método incorporado Y necesitamos usar la biblioteca del editor de
Unity. Así que vamos a escribir
usando Unity Editor, y queremos reemplazar la herencia a
un cajón de propiedades. Y aquí queremos agregar un atributo llamado cajón
de propiedades personalizadas. Y dentro del argumento, necesitamos agregar un tipo
de palabra clave aquí, y luego tenemos que apuntar a la clase que
queremos modificar. En esta clase, queremos
modificar el recopilatorio de audio. Con cajón de propiedades,
en realidad es bastante simple. Primero, necesitamos
anular el método. Así que vamos a escribir método
continuo. Y como puedes ver aquí, el método en curso
tiene tres argumentos. El primero es un
rectángulo llamado posición. La segunda es propiedad
serializada, llamada propiedad,
y la tercera
es Gu content, llamada label, y label es básicamente
la etiqueta
del nombre que hemos
definido en otro script Siempre que estamos mostrando un campo, label es el nombre del campo. Bien, básicamente, esto
basado en UI con el argumento position
property y label es dibujar el inspector normal, y si queremos
sobrescribir esto, necesitamos eliminar esto Así que vamos a
darle una oportunidad aquí. Y para dibujar un
inspector personalizado para cajón de propiedades, necesitamos acceder a
la clase editor GI. No podemos usar el diseño del
editor U ni la utilidad del editor GUI. Entonces aquí, por ejemplo, si utilizo etiqueta fiel,
como pueden ver aquí, pidió una
posición, rectángulo, así podemos simplemente pasar
esta posición y sabrá dónde
poner este texto. Y para el segundo argumento, podemos usar una etiqueta de contenido de UI o podemos usar una etiqueta de
cadena personalizada aquí. Así que voy a crear
una cadena personalizada, y digamos que
hemos modificado do gether Y cerremos
esto y guardemos esto. Ahora bien, si volvemos a Unity y después de que el
script termine compilado, si vamos a la carpeta de datos
y seleccionamos la pistola predeterminada, verás que aquí
hay un texto que dice que hemos modificado el captador de audio, y no
podemos cambiar esto Este no es uno en realidad, sino solo para mostrarte cómo
modificamos el cajón de
propiedades personalizado. Y ahora solo eliminemos esto. Y ahora queremos
crear la etiqueta de prefijo. Entonces voy a escribir posición. Y luego voy a llenar
esto con el editor I, y podemos usar la etiqueta de prefijo. Y este prefijo las etiquetas devuelven
clase rectangular u objeto aquí. Por eso podemos encajar
esto a la posición. Y esto asegurará
que esta etiqueta se
dibuje antes de cualquier
propiedad croised que queramos modificar Bien, así que vamos a
pasar la posición. Y para la etiqueta, también
podemos pasar la etiqueta. Para el captador de audio,
queremos crear un menú desplegable donde podamos enumerar todos los nombres de audio que hemos rellenado dentro de
la biblioteca de audio Para ello,
necesitamos crear un par de
modificaciones en
nuestra biblioteca de audio y también en nuestro captador de audio Dentro del captador de audio, voy a escribir
public integer ID, y esto contendrá el índice de la lista de cadenas que
vamos a crear dentro de
nuestra biblioteca de audio Para facilitar
el acceso a la lista de cadenas dentro de
la biblioteca de audio, necesitamos crear una nueva lista
pública de cadenas. Vamos a crear una
nueva estática pública, y el tipo
sería lista de cadenas, y vamos a llamar a
esta lista de nombres de audio, y vamos a inicializar esto Hago esto estático
para que sea más fácil acceder
a esta variable
desde cualquier otra clase porque necesitamos
acceder a esa lista de cadenas desde este script de cajón de
propiedades personalizadas. Queremos cambiar
este valor cada vez que realizamos cambios en nuestro objeto
scriptable Podemos utilizar el método
llamado fecha válida. Vamos a escribir fecha válida nula. Este es en realidad un método
incorporado. De alguna manera no está
marcado como incorporado, pero podemos probarlo. Vamos a escribir el registro de errores. Digamos que biblioteca
de audio modificada.
Vamos a guardar esto. Ahora si volvemos a la unidad, y vamos a seleccionar
la Biblioteca de audio, y luego ir a la consola aquí. Si intentamos modificar uno de
los valores dentro del inspector
de audio aquí. Por ejemplo, cambiemos la página máxima
para el disparo Ves que la
fecha válida se ejecuta aquí y el registro posterior se
imprime en la consola. Así que podemos usar eso para modificar lista
estática de cadena que acabamos de crear en
la biblioteca de audio. Entonces voy a
borrar esto aquí. Voy a borrar la lista de nombres de audio y
ejecutar el método clear. Y voy a
revisar la lista de audio aquí. Y vamos a llamar a este
audio para cada uno de los miembros, y para la colección. Queremos pasar la colección de la lista de
audio. Y aquí, queremos
llenar la
lista de nombres de audio con los nombres de audio de cada uno de los audios
dentro de la lista de audio aquí. Vamos a escribir audio audioam. De esta manera, cada vez que cambiemos la biblioteca de audio
en el inspector, actualizará los nombres
de audio aquí. Guarde esto. Bien. Así que ahora hemos modificado la
recopilación de audio y la biblioteca de audio. Podemos continuar trabajando en
el Audio reunirnos aquí. Entonces, para crear un menú emergente
o un menú desplegable, queremos usar el
editor GY punto pop up, y para el pop up, pide una posición, así que solo podemos
pasar la posición. Y el entero para
el índice seleccionado. Y podemos usar este
ID que creamos en el cocodrilo de audio
porque básicamente el valor que van a ser seguros para el pop
up es el entero. Y usando ese entero, podemos tomar la cadena de esta
lista estática de cadenas aquí. Pero para acceder
al entero que hemos
creado en el cocodrilo de audio, necesitamos acceder a
la propiedad aquí, que es la propiedad series, y luego necesitamos usar el método fine property
relative, y solicita un nombre
de cadena de la ruta de propiedad relativa. En este caso es el
nombre de la variable, eso es solo tipo ID. Y luego para el último argumento, queremos usar una matriz de cadenas. Así que podemos simplemente escribir Audio, Clase
de biblioteca de audio y tomar
el audio sin nombre aquí Pero como esta es una lista, necesitamos convertir
esto en una matriz. Así que solo podemos usar
el método array para convertir estos dos y array. Aquí tenemos un error porque propiedad
fina relativa devuelve
una propiedad serializada Entonces necesitamos agarrar
el valor entero. Aquí. Y todo este código aquí necesita asignarlo
en un valor entero. En este caso, queremos
asignar de nuevo al valor ID. Así que voy a copiar
este valor entero aquí y luego pegar esto delante
del RGI y luego asignarle esto Así que cada vez que
cambiamos el pop up, queremos tomar el
nuevo valor entero y esos valores enteros
van a ser seguros para
el valor entero ID. Entonces lo estamos anulando. Y siempre que cambiemos
el pop up aquí, queremos modificar el
valor de cadena del nombre de audio. Así que vamos a agarrar la variable de nombre de
audio, Comprobemos si la
variable llamada Sí, es nombre de audio, vamos a
agarrar la variable, y como esta es
una propiedad SERIs, necesitamos agarrar el valor de
cadena y luego
asignar este valor usando
la biblioteca de audio,
la cadena estática de lista, que es la lista de nombres de audio Y para index, podemos simplemente pasar el valor entero de
nuestros campos ID aquí. Vamos a pegar esto aquí. Y cierra esto con Sam Colm. Ahora vamos a guardar
esto. Ahora volvamos a la unidad y veamos si
este código está funcionando. Voy a despejar
la consola aquí y vamos a seleccionar
el arma por defecto. Y como pueden ver aquí, ahora tenemos un bonito
desplegable para el efecto de
sonido de disparo Entonces podemos cambiar esto
a la z eléctrica y siempre que cambiemos esto,
no tenemos ningún error. Entonces esa es una buena señal. Y vamos a darle una oportunidad. Vamos al labio de audio aquí, y agreguemos un nuevo sonido. Y llamemos a esta recarga de
arma y cambiemos el clip de audio a la recarga de arma de
ciencia fi Ahora, hemos agregado este
nuevo nombre de audio. Veamos si se actualiza la lista de
nombres de audio. Seleccione la pistola por defecto y
abra el menú desplegable aquí. Y ahí van, como pueden
ver, tenemos un nuevo sonido. Ahora vamos a darle una oportunidad
de nuestra modificación aquí. Cambiemos aquí los efectos de
sonido de disparo de pistola al
zap eléctrico y presionemos play, ver si esta modificación
funciona o no Bien. Ahí
vas. Está funcionando. Y si cambiamos al disparo, se
puede ver que hemos
cambiado el audio Y esto facilita mucho la selección de
sonidos.
39. 38 Optimización del flujo de trabajo de audio: En este video, vamos a seguir trabajando en nuestro audio. Y hay un par de cosas
que quiero mostrarte
para que la configuración del
audio sea mucho más fácil. Y primero, queremos cambiar
la referencia al nombre del efecto
de sonido de audio. En lugar de usar una cadena,
queremos usar el ID. Entonces aquí dentro del
cajón de obtención de audio, no necesitamos esto. Así que vamos a comentar
esto por ahora. Y luego vamos al captador
de Audio. Está bajo la Biblioteca de Audio. Y aquí queremos crear
una nueva cadena getter pública. Entonces voy a cambiar
esto a nombre de audio con mayúscula A y establecer
esto como un cocodrilo. Y solo devolvamos la lista de nombres de
audio de la biblioteca con un índice de nuestro ID. Bien, ahora guarda esto. Así que ahora el captador de audio
guardará nuestro ID de índice basado en el pop up que
seleccionemos al elegir
los efectos de sonido, y siempre que queramos
hacer referencia a los efectos de sonido, en realidad
estamos devolviendo la cadena de la lista de nombres de
audio aquí Ahora volvamos a Unity. Y verás que
aquí
tenemos un error porque cambiamos el nombre de
la variable, usando una A mayúscula aquí. Y ahora si hacemos doble
clic sobre este error aquí, verás que no puede encontrar la variable de nombre de audio,
porque cambiamos esto. Entonces, en lugar de usar
el nombre de la cadena, voy a eliminar toda la cadena
de audio aquí. Y vamos al reproductor
de audio. Y queremos usar
el captador de audio. Entonces esto hará que escribir
el código sea mucho más rápido. Y en lugar de usar una cadena, queremos agarrar la cadena del captador
de audio aquí, así que vamos a escribir
ese nombre de audio aquí Y podemos simplemente renombrar estos dos SFX de audio y cambiar
estos dos efectos de audio S. Entonces es más claro. Y guarda esto. Y ahora si volvemos a Unity, deberíamos haber
aclarado el error. Todavía hay un
error. Comprobemos esto. Bien, guarda esto. Olvidé guardar
los datos del arma. Entonces volvamos a Unity. Y ahora termino de
compilar, borra todo el error Y si presionamos play
y luego probamos esto, ya ves, todavía
tenemos un sonido de trabajo. Y la razón por la que cambio el
cajón de Gether usando la identificación Más tarde, cuando estamos poblando
nuestra biblioteca de audio y luego estableciendo el nombre para cada una de las listas de
datos de audio aquí, no
necesitamos reasignar los efectos de sonido
en cada entrada de
la recopilación de audio o cada
guión que esté usando la recopilación de audio como referencia de efectos de
sonido de audio Y así saboreamos, y será menos propenso al error que la forma en que lo
estamos haciendo antes Y la otra cosa
que queremos hacer, queremos agregar
una opción para configurar los
efectos de sonido como un sonido de dos D. Actualmente, si vamos
al reproductor de audio, verás que todos los efectos
de sonido, mezcla
espacial están establecidos 21. Y por ejemplo, si tenemos un volumen muy bajo los efectos de sonido que queremos reproducir
en un objeto a distancia, probablemente no
podamos escuchar esto. Por ejemplo, un arma
capta efectos de sonido. Probablemente ese sonido no necesita ser un sonido de tres
D
porque no es un sonido que esté relacionado con la
inmersión del juego, como un disparo o una explosión Es más una
retroalimentación de audio para el juego. Podemos configurar el sonido 2a2d sound. Entonces aquí, bajo el método
play SF X, queremos agregar un valor predeterminado para la ubicación de audio
y establecer este canal. Entonces con este conjunto, podemos simplemente
ignorar este parámetro si no
queremos pasar una
transformación de la ubicación de audio. Y aquí queremos crear una sentencia if si la ubicación de
audio no es nula, entonces queremos establecer
esta fuente de audio para que sea audio A tres D. Así que vamos a cortar
esta línea aquí donde estamos fijando la posición y
pegarla dentro de la declaración I. Y luego queremos volver a establecer la
T insípido espacial en uno. Y queremos crear
una declaración L. Y esto es cuando estamos ejecutando este método sin argumento
de ubicación de audio. Entonces aquí queremos establecer la mezcla espacial de nuestra fuente de
audio hacia atrás 20. Entonces este será un
sonido de dos D. Y vamos a guardar esto. Otra cosa que
queremos crear,
queremos crear un método para
reproducir la música aquí arriba,
queremos establecer la fuente de audio
para nuestra música de fondo, opción de
bucle para que sea verdadera,
así que vamos a escribir BGM source
loop y establecer esto en true Para reproducir música, vamos a
crear un nuevo método público, tipo
escrito de vacío, y
llamemos a esto reproducir música. Queremos pasar el
audio se reúnen también, y vamos a llamar a esta música. Pero no necesitamos
ningún otro parámetro. Aquí, podemos acceder a la fuente
BGM de inmediato, y podemos usar la
reproducción de audio y vamos a usar la biblioteca de audio, obtener audio por método de nombre, y tomamos la cadena de
la música Audio Nombre de audio Y aquí queremos asegurarnos que el terreno de
juego se ajuste a uno. Queremos ignorar
el valor aleatorio del tono aquí
porque queremos tocar la música en su tono
original y sus seguridades Volvamos a Unity
y veamos por cualquier error. No hay errores,
así que es una buena señal, y en el siguiente video, vamos a empezar a
poblar el audio
40. 39 Aplicación de efectos de sonido: En este video,
vamos a comenzar a asignar el sonido a cada objeto de la escena que
necesite el sonido. Así que ahora vamos a poblar primero nuestra confiabilidad
de audio. Pero antes
te voy a mostrar ajustes para nuestro audio aquí. Entonces, si has importado los archivos de audio en
la lección anterior, verás que tenemos
un par de archivos de audio dentro de nuestro proyecto aquí. Entonces, para todos los efectos de audio, voy a seleccionar
todos juntos. Y voy a asegurarme de
que el tipo de carga esté configurado ya sea para descomprimir carga
o comprimir en memoria, y queremos establecer
la calidad 290 Y para el formato de compresión, para esto debería estar bien. Así que vamos a presionar aplicar. Y ves que ahora mismo, el tamaño original
es de 1.7 megabytes, pero el tamaño importado
es de 400 kilobytes, por lo que ya ahorramos alrededor del
75% del Y para la
música de audio, el archivo BGM. Queremos establecer
esto a streaming, y por la calidad, solo podemos dejarlo 100 y presionar aplicar. Como se trata de un archivo Petry, casi no
hay compresión, pero con la transmisión, el archivo Petry no
cabría en una memoria Se transmitirá desde un disco. Y básicamente con un tipo de carga de
streaming, necesitamos asegurarnos de que son solo una fuente de audio que
están transmitiendo desde el disco. De lo contrario, podría causar pierna, sobre
todo en dispositivos móviles. lo que el Streaming generalmente
se usa para música porque generalmente
solo tenemos una música
en nuestra escena. Ahora vamos a la carpeta de datos y configuremos la biblioteca de audio, y ya he creado
un par de entradas aquí, pero voy a
poblar esto con el resto del audio que
tenemos en nuestro proyecto Entonces voy a agregar quizá 212, y luego voy a
configurar esto uno por uno, y luego voy a
acelerar este video. Y para BGM, vamos a establecer el tono mínimo y el tono
máximo en uno, así tendríamos variación de
tono Y ahora ya he puesto
todo esto aquí arriba. Voy a guardar el proyecto que se guarde el
objeto scriptable Y ahora necesitamos crear
un par de guiones. Entonces vayamos a la
carpeta de scripts debajo del Audio. Voy a crear
un nuevo guión CHR llamado play Audio action, y el otro debería
ser la acción play music. Ahora vamos a abrir el guión
de acción play Audio. Aquí en el script de acción play
audio, queremos eliminar todo
el método incorporado, y definamos primero
la variable. Vamos a crear un campo serializado, y para el tipo, este
sería un captador de audio Y llamemos a esto efectos
de sonido de audio. Y la segunda opción
será un bulion, y voy a llamar a
este sonido dos D. Y esto es para
habilitar o deshabilitar, ya sea que queramos
configurar este audio como un sonido dos D o
un sonido de tres D. Y el último
sería un retraso. Entonces queremos agregar, lo siento, no demora, debe ser fluido, y vamos a llamar a esta demora Entonces queremos agregar una función donde podamos retrasar la
reproducción del audio. Así que ahora vamos a crear un nuevo
vacío en el método enable. ¿Por qué estamos usando el método enable? Porque enable se
activa cuando el objeto se activa y puede
ejecutarse varias veces. Ya que algunos de los objetos de la escena se
desactivan al inicio. Si usamos el método start, es posible que nunca
oigamos
la reproducción de audio porque el método start ya se
ha ejecutado, y al activar
el objeto más tarde, la acción no se ejecutará. Aquí, dentro del método
inenable, queremos usar la acción
retardada que hemos creado
en nuestra extensión, y queremos pasar una
acción usando delegado aquí, y luego después de
pasar el delegado, queremos pasar el retraso aquí Solo pasemos el retraso
y luego cerremos esto. Ahora podemos escribir nuestro código
dentro de este delegado aquí. Entonces dentro de esta acción delegada, queremos acceder
al reproductor de audio, y luego a la referencia estática, y queremos reproducir
el sonido de audio effx, usando el método play SFX Y luego queremos
pasar el geter de audio. Así que vamos a pasar
el audio Sound effx. Para la ubicación, queremos usar esta bleion para determinar si vamos a
pasar una transformación o no Así que vamos a escribir al sonido,
y luego el signo de interrogación. Y si es cierto, entonces queremos pasar Nulo. Pero si es falso, entonces queremos
pasar esta transformación del objeto al que se adjuntan el
script. Ahora, básicamente, si
habilitamos el sonido d, entonces el sonido será un
sonido D cuando se esté reproduciendo. Pero si es desactivar, entonces será un sonido de tres D. Para la acción play music, podemos simplemente duplicar
todo el guión aquí. Y voy a abrir esto. Y aquí, voy a pegar el script que
hemos copiado antes, y vamos a
crear una modificación. Simplemente eliminemos
el lingote aquí, y podemos eliminar
el segundo argumento, y queremos ejecutar el método
play music Bien. Guardemos esto, y volvamos a Unity. Ahora, queremos abrir
el script de datos de armas, para agregar el arma MT y el efecto de sonido de advertencia de
recarga Vamos a abrir aquí los datos del
arma. Y si nos desplazamos hacia arriba aquí debajo del disparo Efecto de sonido Campo gaor de
audio, queremos agregar un par de variables
más Solo agreguemos un efecto de recarga, los efectos de sonido vacíos y los efectos de sonido de advertencia de
recarga Y aquí, si te
desplazas hacia abajo, queremos agregar un sonido
cada vez que se agote el MO. Pero queremos reproducir el sonido sólo si presionamos
el botón del ratón. Entonces vamos a cambiar esta afirmación por
una declaración if. Así que vamos a escribir
entrada el
botón GT del ratón hacia abajo y
queremos agarrar el click izquierdo. Y aquí queremos
agregar una condición si el MO es menor o
igual a cero. Si se agota, entonces
queremos reproducir el efecto de sonido vacío. Simplemente accedamos a la instancia del reproductor de
audio y al método play sound EffX Para el nombre, solo podemos
pasar el efecto de sonido vacío. Y para la ubicación, solo
podemos usar la referencia del script del jugador y acceder al componente
transform. Vamos a copiar esta línea
aquí y pegarla aquí abajo, y también quiero reproducir el efecto de sonido de advertencia de
recarga Y podemos copiar esta
línea aquí y luego pegarla en el código de la
ametralladora aquí, y queremos
revisar también esta declaración. Así que vamos a copiar las
dos primeras condiciones y pegarla aquí abajo y añadir el seno final. Creamos una condición similar, pero con el O actual igual o menor que cero aquí
abajo. Guarde esto. Siempre que recarguemos el MO, queremos reproducir
el sonido de recarga Vamos a copiar esta línea
aquí, y aquí abajo, voy a reproducir los efectos de
sonido de recarga y guardar esto Ahora vamos a abrir el guión
del jugador. Aquí arriba aquí, queremos agregar un nuevo campo
serializado, y el tipo debe
ser audio recopilar, llamemos a esto efectos de sonido
dañados Y básicamente, queremos reproducir el sonido
de daño cada vez que iniciemos el temblor de cámara. Aquí, podemos simplemente poner la instancia del reproductor de audio,
reproducir efectos de sonido. Y entonces podemos simplemente pasar el captador de audio de
efecto de sonido de daño, y para la transformación, podemos simplemente pasar la transformación
de este objeto aquí Guarde esto. El
siguiente que necesitamos modificar es el script
it effect. Vamos a abrir el guión de efecto
hit, y vamos a añadir un
campo ers de recopilación de audio, y vamos a llamar a
esto hit efectos de sonido. Y cada vez que golpeamos
algo aquí, bajo el método hit, queremos
reproducir los efectos de sonido. Así que vamos a acceder
al reproductor de audio. Instancia, ejecute el método de reproducción de efectos de
sonido y luego pase los campos de efectos de
sonido golpeados. Y para la transformación, podemos simplemente pasar el sistema de partículas de
caché de efectos, pero podemos pasar el componente
transform aquí. Por lo que el sonido
se originará dependiendo de
la posición de la partícula, y este será un sonido de tratamiento. El último debería ser el guión de recogida de
armas. Así que vamos a abrir aquí el guión de recogida de
armas. Y básicamente, cada vez que
golpeamos el arma, queremos reproducir un efecto
de sonido bonus. Solo agreguemos un campo de tamaño, Reúna
audio, y
llamemos a esto efectos de sonido de
recogida. Y queremos reproducir el efecto de sonido usando
el reproductor de audio. Y solo pasemos el campo de efectos de sonido pick up
que hemos creado, y para la ubicación de audio, podemos dejarlo nulo
porque queremos que este sea un sonido dy y guarde esto. Ahora volvamos a la unidad, y vamos a poner
estas cosas dentro de la unidad. Entonces aquí, si seleccionamos
la cámara principal, vayamos al componente de
guión de los jugadores y seleccionemos el efecto de sonido de
daño del jugador. Y vayamos también a la carpeta de
datos y seleccionemos tanto la
pistola por defecto como la ametralladora. Y queremos poblar esto, solo
seleccionemos el disparo
para el efecto de sonido de disparo Para la recarga, queremos
seleccionar la recarga de la pistola. Para el vacío, queremos
seleccionar la pistola vacía, y para la advertencia de recarga, queremos seleccionar
la advertencia de recarga Y la otra cosa
que queremos configurar bajo nuestra carpeta de prefectos, podemos seleccionar el pick up de
ametralladora aquí, y ahora el pick up de arma
tendrá un campo de
efectos de sonido pick up Así que solo podemos seleccionar esto y luego elegir
el arma pick up. Para el rehén,
queremos modificar esto, solo
seleccionemos al rehén Y aquí, voy a agregar la acción de reproducir audio y agregar rehén no
dispares efectos de sonido, y pongamos esto al sonido para
que podamos escucharlo mejor, y vamos a agregar un
retraso de 2 segundos Y ahora necesitamos modificar al enemigo donde sea que
el
enemigo sea golpeado. Solo seleccionemos
al prefecto enemigo, y bajo el efecto de golpe, tenemos habilitados los campos de
efecto de sonido de golpe Solo seleccionemos
el zap eléctrico. Para el rehén, también
queremos ponerle esto al zap eléctrico Entonces para la gran explosión aquí, queremos agregar la acción
play audio, y queremos establecer
el delay C cero, y queremos
desactivar el sonido D. No queremos que esto
sea un sonido de CD. Y para el SFX de audio, solo
seleccionemos la explosión Y ahora dentro de la escena aquí, si ampliamos el entorno, seleccionamos aquí todo el objeto
cubo. Todos ellos deberían haber hit effects script adjunto a él. Vamos a seleccionar
la ranura de impacto de golpe aquí. Guarda la escena. Y luego queremos crear
la música para nuestra escena, así que vamos a crear
un objeto de juego vacío. Voy a restablecer
la transformación, y voy a
llamar a esta música, y vamos a reproducir música de
acción y establecer el delay 20, y queremos reproducir los efectos de sonido de audio
BGM Y vamos a guardar la escena. Y ahora presionemos
play y probemos esto. Entonces ahí tienes,
tenemos una música, y podemos filmar y
tenemos un sonido. Y como ves,
como puedes corazón, si disparo cerca en el borde puedes escuchar
el sonido de impacto. Y si nos golpea el enemigo, tenemos este sonido dañado, y si disparamos al enemigo, podemos escuchar la electricidad. Y también podemos
escuchar la explosión. Y podemos matar al rehén, y podemos escuchar
la voz del rehén y también el eléctrico
y el arma recoger Hay mucho sonido
sucediendo en este momento. Pero básicamente, todos
ellos están funcionando y no tenemos ningún
error en nuestra consola. Entonces, así es básicamente como
asignamos el sonido a los
objetos de nuestra escena.
41. Corrección de errores de cálculo de 40 tomas: Encontré un error con respecto a los disparos hechos y el cálculo de impactos de
disparos. Y en este video,
vamos a arreglarlo. Entonces, para verificar este error, necesitamos seleccionar
el administrador del juego y cambiar el
tipo de inspector a error D. Y ahora podemos ver todas
nuestras variables privadas aquí. Entonces, vamos a presionar. Y ahora verán que
voy a silenciar el audio. Y ahora verás que
si disparamos al enemigo, aumentaremos el
golpe enemigo y los disparos disparados. Pero los disparos disparados siempre
disparan veces que el enemigo golpeó. Y esto está sucediendo
porque dentro de nuestro código aquí en los datos del arma,
si te desplazas hacia abajo, cada vez
que disparamos el arma , ejecuta este método aquí, y ejecuta este método por
cada golpe al objeto. Entonces, por ejemplo, sobre
el enemigo aquí, solo
seleccionemos al enemigo. Y ahora si vendes al enemigo, verás que
tenemos dos hitables, que son los efectos de golpe
y los guiones enemigos Y podemos confirmarlo
comprobando el guión
en el estudio fiscal. Si abrimos el guión enemigo, verás que esta clase
aquí, implementa el hitable Y lo mismo va
con los efectos hit. También implementa este hitable. Así que esto puede ser
ejecutado varias veces, dependiendo de cuánto hittable tenga o tenga el
objeto del juego Entonces, para arreglar esto, primero, necesitamos separar el método de
golpe de disparo con los disparos realizados. Entonces, si vamos al
manager del juego aquí abajo, tenemos el método shot hit
con un argumento bleion Tenemos que separar
esto. Entonces voy a crear un nuevo vacío público. Y vamos a llamar a
esto disparos, y no necesitamos
pasar ningún parámetro. Voy a cortar esta línea de
disparos y pegarla aquí. Básicamente, cada vez que
disparamos un arma, queremos aumentar
este valor aquí. Y cada vez que
golpeamos algo que queremos contar,
ejecutamos este método aquí. Simplemente eliminemos el argumento y eliminemos aquí la
declaración if. Limpiemos esto un
poco. Y guarda esto. Y ahora volvamos
a los datos del arma, y podemos simplemente eliminar
todo esto aquí, la declaración y eliminar
la declaración return. Y ahora el golpe de tiro ya no
pide argumento, así que vamos a eliminar
el valor del bulion Y voy a eliminar
también esta declaración de retorno. Y básicamente, esto es
todo lo que tenemos que hacer aquí. Pero cada vez que disparamos un
arma de fuego o
disparamos nuestra arma, queremos ejecutar el método de
disparos disparados. Así que podemos simplemente ejecutar el método de
disparos de aquí arriba. Así que vamos a acceder
al administrador del juego, instancia, y vamos a
ejecutar el método de tiros disparados. De esta manera, cada vez que
disparemos nuestro arma, la variable de tiros en el manager del
juego aumentará, y cada vez
que golpeemos algo que queremos contar, por ejemplo, el scrip enemigo, entonces la variable de golpe enemigo
aumentará también Si volvemos a la unidad
aquí, simplemente detengamos esto. Si seleccionamos este barril aquí, verás que tenemos
este engendro al golpear Y esto crea explosión, y el otro
genera la ametralladora Entonces queremos tomar esto
en consideración, el engendro al golpear
como un golpe enemigo De lo contrario, cada vez que
cerremos estos dos artículos, contará como un disparo disparado, pero no como un golpe enemigo, y esto penalizará
nuestra precisión Entonces tenemos que volver en el guión aquí y
en los datos de armas. Bajo la declaración if aquí. Queremos agregar una segunda
condición, lo siento, no n, sino usando la operación, y queremos comparar o verificar si el itable es un spawn en él Otra cosa que
queremos comprobar es, volvamos
primero a Unity y seleccionemos la ametralladora blanca de
cañón. Y tenemos que comprobar el engendro
pref dos aquí. Si selecciona esto,
podemos verificar el objeto. Y aquí, la ametralladora también tienen un guión benéfico,
que es el arma pick up. Así que vamos a abrir
el guión aquí. Y queremos
comprobar también para esto. Volvamos al arma Datos y agreguemos otra declaración. Si el golpeable es
una pastilla de arma, entonces queremos contar también el golpe de
disparo. Vamos a guardar esto. Ahora volvamos a la
unidad y juguemos. Ahora bien, si seleccionas al manager
del juego, deberíamos poder
ver la variable, e intentemos
dispararle al enemigo. Ahora tenemos un solo disparo. Pero si le disparé al enemigo, ahora tenemos dos disparos
disparados y un enemigo impactado. Por lo que los disparos que apuntamos
al enemigo se cuentan como uno, tanto el golpe como
los disparos hechos. Así que vamos a rematar esto
y luego probar esto de nuevo, y tratemos de
no perder el tiro. Ahí vas.
Disparemos tres veces al enemigo para matarlo. Y ahora tenemos tres
impactos enemigos y tres disparos disparados. Entonces con este cambio de código, hemos solucionado el problema de
error donde los disparos realizados
siempre son dos veces
más grandes que los golpeados por el enemigo.
42. 41 Cálculo de rango: En este video, vamos a crear un sistema de
cálculo de rangos. Entonces si vamos a la interfaz de usuario aquí y si ampliamos
el gestor de juegos
Canvas, verás si seleccionas la
pantalla n aquí y habilitamos esto. Ves que tenemos
una interfaz de usuario de rango aquí, y siempre
muestra A actualmente. Por lo que necesitamos implementar esto. Para implementar esto, vayamos a Fico Studio y
abramos el script UI Manager. Y para el script UI manager, primero, queremos crear
un nuevo campo serializado Y esto debería ser un
tipo de malla tex P GUI, y llamemos a
este impuesto de rango. Y básicamente, necesitamos crear alguna fórmula para
calcular el puntaje, para convertir esto al rango. Entonces la relación máxima
del kel enemigo es del 100%. También la relación Mx para la
precisión de los apagados, también es del 100%. Con esta medición de dos puntuaciones
o dos, podemos decidir sobre la
creación de un sistema de rangos. Ahora vamos a definir. Para obtener el rango de A, queremos asegurarnos de que el kel enemigo esté
por encima, digamos, del 90%. Y como la precisión
es un poco más dura, queremos bajar este valor. Así que vamos a comprobar si la
precisión está por encima del 80%. Y para B, queremos
establecer si el enemigo mata, es mayor que digamos 75%, pero a la
vez, menos de 90%, y con precisión,
digamos mayor que 70%, pero menos de 80%. Para C, vamos a
copiar aquí esta línea. Voy a pegarlo, y
vamos a modificar esto. Porque, queremos establecer si el
enemigo mata es menor al 75%, y es mayor digamos 60%, y por la precisión, queremos asegurarnos de
que esto sea de 70,
y si es mayor al 55%, entonces queremos darle rango de C. Y si copiamos esta línea, péguela aquí, entonces
queremos establecer el rango D. Decidamos que D
es la corrida más baja. Entonces, si es menor de
60, el kel enemigo, y si la precisión
también es menor a 55, entonces queremos darle
rango de D. Con esto aquí, podemos crear un promedio total. Vamos a crear
una nueva variable. Simplemente llamemos a
este promedio total. Y esto debería ser el
monto total se divide por dos. Esto es 170/2, y obtenemos 85. Significa que el
promedio total debe ser mayor
a 85 para obtener rango de A. Este, queremos
tener un rango, que es si el promedio total es mayor que el valor
más bajo aquí, por lo que podemos simplemente agarrar
el promedio 72%. Y al mismo tiempo,
es menor que 85, entonces queremos
darle rango de B, y si duplicamos esto y
luego lo aceleramos aquí para la corrida C, entonces queremos calcular
el valor más bajo, que es 6055,
este debería ser 57, y para el máximo, siempre
es el
valor más bajo de nuestra corrida anterior Así que vamos a establecer esto
si es menor a 72, y aquí si el
promedio total es menor a 57. Entonces ahora tenemos aquí
esta fórmula. Podemos agregar un valor de penalización por cada vez que el
jugador mate a un rehén Por ejemplo, la matanza de rehenes
penalizará punto por 15. Entonces, una matanza de rehenes
restará todo
nuestro promedio Bien, con esta fórmula aquí, vamos a copiar
este bit de nota aquí, y vamos a Visual Studio y con el script UI
Manager abierto, queremos desplazarnos hacia abajo. Y luego ir al método show
y screen aquí, y voy a agregar
un nuevo método a continuación. Vamos a llamar a este
vacío calcular puntaje. Voy a pegar
el cálculo que hemos creado y
configurarlo como un comando. Así podemos verlo aquí mientras
escribimos nuestro código, y vamos a limpiar esto. Ahora tenemos este método de puntaje de
Calcate. Limpieza. Queremos
pasar el argumento de todos los argumentos dentro de nuestro método
show y screen. Vamos a seleccionar todo
el argumento aquí, y voy a copiar esto
y luego pegarlo aquí. Bien, básicamente aquí, queremos declarar un par de variables flotantes
locales. El primero sería
la pena de rehén. Y sólo podemos calcular
la quilla de rehenes, multiplicar por diez.
Obtenemos el valor. Lo siento no diez, debería ser
15 aquí, como pueden ver, entonces para la relación de quilla
enemiga flotante, solo
podemos calcular la quilla enemiga dividida
por el enemigo total Pero como ambos están en entero, necesitamos lanzar uno
de ellos a un flotador, así que voy a
lanzar el divisor, y luego voy a
multiplicar esto por 100. Obtendremos el porcentaje, y si adjuntamos esto, queremos restarlo con
el valor de penalización de rehenes Entonces solo calculemos
también la relación de precisión. Y este debería ser el golpe total dividido entre
los tiros totales. Y también, queremos
lanzar el divisor a un flotador y
multiplicarlo por 100. Y no olvides penalizar el punto por la pena de
rehén Y ahora tenemos
esto. Así que vamos a calcular el promedio total. Y esto es bastante
simple en realidad. Solo necesitamos agregar la relación de
muerte enemiga con la relación de
precisión. Y luego dividir esto por dos. Ahora hemos calculado toda
la fórmula aquí, queremos mostrar el
rango dependiendo esta clasificación
o la especificación que hayamos creado
para el puntaje. Vamos a crear
una sentencia if y si el promedio total, es mayor que 85 aquí, como puedes ver, entonces
queremos imprimir A en el rango. Así que solo podemos acceder
al impuesto de rango y ejecutar el método set tax y luego insertar una cadena como argumento. Y queremos comprobar si los promedios
totales son mayores al 72%. Pero a la vez,
es menos de 85. Entonces queremos
imprimir B Pero uno de los comparativos aquí necesita
tener un signo igual, por lo que incluirá
toda la gama. Entonces voy a
agregar include sine, entonces significa que
si es igual o mayor que 85, entonces
queremos imprimir esto. De lo contrario, si no usamos esto, entonces si es exactamente 85, entonces no
se ejecutarán ambas condiciones. Entonces, vamos a sumar
el signo igual. Oh, perdón, he escrito
un porcentaje aquí. Debería ser F, así que
vamos a arreglarlo. Y ahora queremos imprimir en el texto de rango un carácter de B. Así que vamos
a copiar esto para hacerlo más rápido, y voy a copiar el
menos para el rango D, y agregar una declaración L
y luego pegarlo aquí. Para C, sabemos que si
es mayor que 57, y al mismo tiempo, es 72, entonces queremos imprimir C.
Aquí para el mayor valor, quiero incluir
el 72 float aquí, así que voy a
agregar un seno igual y también agregar seno igual
dos, este de aquí. Y para D, queremos comprobar
si es menor a 57. Así que vamos a escribir D
aquí. Vamos a guardar esto. Y ahora tenemos creado este
método. Necesitamos ejecutar
este método dentro
del método show en screen. Entonces, después de configurar el texto de
precisión aquí, voy a ejecutar el método de
calcular puntaje y luego pasar todo
el argumento aquí. Solo pasemos la matanza enemiga, el enemigo total,
la matanza de rehenes, los disparos totales, y también
el golpe total y guardemos esto, y volvamos a
Unity y probemos esto Ahora aquí dentro de Unity, primero, tenemos que seleccionar
el administrador del juego, y luego abrir el objeto de pantalla
final aquí, abrir el diseño. Y para el área de puntuación, queremos abrir el rango y
tiene un título y un objeto de juego R. Queremos dirigir este objeto de
juego de anillo como un impuesto de rango de
nuestro campo de impuestos de rango bajo
el componente de administrador de juegos. Vamos a dirigir aquí
el impuesto de rango. Y tiene una malla de texto pro, por lo que los campos registran
el componente de inmediato. Y ahora vamos a guardar
nuestra escena aquí. Ahora vamos a probar esto. Y voy
a tratar de jugar lo más rápido
posible sin
niebla de tiro y matanza de rehenes Solo usemos esto para matar
al enemigo, usar explosión. Y solo habilitemos
la depuración aquí, para que podamos ver nuestras estadísticas, y matemos al
enemigo. Ahí vas. Tenemos unas
estadísticas perfectas por aquí, y ahora matemos
al enemigo aquí. Ahora como pueden ver aquí, tenemos una
estadística muy agradable y tenemos R A. Pero si volvemos a probar esto y
ahora intentamos hacer lo mejor de nuevo,
pero matamos al rehén esta vez Y ahora, como puedes ver aquí, pesar de que tenemos una precisión
100% hostil
o precisión de matanza enemiga, y también la precisión. Pero como matamos a dos rehenes, tenemos un rango de C. Así que matar a rehén
sancionará en gran cantidad, que es Y ahora vamos a probar
esta una vez más para la precisión de los disparos. Vamos a tratar de disparos e, así que tenemos una precisión muy mala, y vamos a tratar de matar al enemigo. Y como puedes ver aquí, aunque matemos a todos
los enemigos, nuestra precisión es muy baja, así que tenemos rango de C. Bien, así es básicamente como
calculamos la n de la jugabilidad.
43. 42 Configuración de pausa y volumen: Esta vez, vamos a
discutir un mecanismo pasado y también crear una configuración de folum cuando abramos el panel pasado Entonces para hacer
eso, ya he preparado un paquete de interfaz de usuario de
panel de pausa, y lo puedes descargar en
el recurso de esta conferencia. Entonces después de que no lo sepas, solo importa el paquete, así que voy a importar
un paquete personalizado, y voy a importar
el paquete PUI Y ahora solo importa todos ellos. Una vez que se haya importado, se ve
aquí debajo de la carpeta U PAC. Bajo las prefbs,
tenemos un nuevo prefps, y se llama pantalla de pausa Entonces ahora vamos a arrastrar estos prefs sobre el Canvas de pelo
cruzado Si vamos a la vista de escena aquí, si queremos ver
la pantalla pos, necesitamos habilitarla primero porque está
deshabilitada por defecto. Solo habilitemos esto y
verás que tenemos esta interfaz de usuario pus y tiene
dos controles deslizantes de volumen, que es un objeto slider, y vamos a atar grupos
del mezclador de audio
con este deslizador. Lo siguiente que
necesitamos crear es, necesitamos crear
el mezclador de audio. Pero antes de eso, vamos a
desactivar de nuevo la pantalla Po, y vamos a
la carpeta de audio, y vamos a crear
un nuevo mezclador de audio. Voy a crear
un nuevo mezclador de audio, y voy a llamar a
este mezclador principal. Ahora vamos a
hacer doble clic en el mezclador aquí. Una vez abiertas las
ventanas de los mezcladores de audio, tenemos estas pocas aquí, y necesitamos crear un
par de grupos aquí. Así que vamos a seleccionar el maestro y luego presionar el botón
más aquí, y vamos a crear un grupo de efectos de
sonido. Y vuelve a seleccionar el maestro. Y el siguiente grupo que
quiero crear es el Grupo
Begron Music Entonces ahora tenemos dos volúmenes
adicionales aquí. Y ahora si vamos al manager
del juego bajo
el reproductor de audio, tiene dos campos llamados Sound Effects Group y
Background Music Group. Tenemos que asignar este
objeto a la ranura aquí. Así que vamos a solo bros esto, y luego seleccione el grupo de efectos de
sonido para la ranura del grupo de efectos de sonido. Y para Begron Music Group, solo
seleccionemos el mezclador de grupo de música de
fondo Bien. Vamos a guardar esto. Y ahora necesitamos
crear un nuevo script. Entonces vayamos a la
carpeta de scripts. Bajo el audio. Voy a crear un nuevo
script llamado Configuración de volumen. Y abramos el guión. Bien, ahora hemos abierto
el guión aquí. Vamos a crear primero una
variable de par. Pero antes de eso,
necesitamos importar
el espacio de nombres de Audio
y el espacio de nombres de la interfaz Aquí arriba, solo agreguemos usando Unity Engine, no el motor editor, y vamos a importar el espacio de nombres Audio y
también el espacio de nombres de la interfaz Y vamos a eliminar
aquí la herencia de comportamiento
mono porque
vamos a instanciar este script o clase en el administrador del juego como la clase UI manager
y
la clase de objeto timer Y vamos a eliminar
el método incorporado. Y ahora necesitamos declarar
un par de variables. Voy a crear un
nuevo campo serializado. Y esto sería un
tipo de objeto de juego, y llamémoslo a este panel. Y el siguiente campo
será un deslizador. Y este sería el deslizador de efectos de
sonido
y el deslizador BGM Y el último campo
que queremos crear es el campo mezclador de audio. Y vamos a llamar a
este mezclador principal. También necesitamos crear
una cadena privada para guardar el valor de nuestro volumen
a una preferencia de jugador. Siempre que reiniciemos el juego
o entremos en una nueva sesión, se cargará la configuración de volumen
anterior. Vamos a crear una
nueva cadena privada. El primero, voy a
llamar a esta tecla de efecto de sonido, y la segunda sería
la tecla de música de fondo. También queremos crear
un getter para el panel. Voy a crear aquí un nuevo geter de objetos de juego
público. Voy a llamar a este
panel con P mayúscula, y dentro del captador, voy a recuperar
el campo del panel Así podemos acceder a este
panel desde otro script, pero otro script no puede
cambiar el valor. Entonces, lo siguiente que
queremos crear es que
queremos crear un nuevo método para modificar los efectos de sonido y
la música de fondo. Así que vamos a crear un nuevo vacío, y llamemos a
esto efectos de sonido aj. Y queremos pasar un
flotador como valor aquí. Debido a que este método
será llamado por el control deslizante, tanto del deslizador
en el evento de cambio. Necesitamos pasar un valor flotante
aquí, y este parámetro, agarramos cualquiera que sea
el valor del deslizador cada vez que cambiemos el deslizador. Antes de poder modificar el mezclador, necesitamos exponer algunos de los parámetros en
el mezclador de audio. Volvamos a Unity, y vayamos a
la carpeta de audio. Y vamos a seleccionar aquí
el mezclador principal. Y si abrimos el mezclador, podemos seleccionar el grupo de efectos de
sonido
y el grupo de música de fondo. Y ahora queremos
exponer el parámetro. Aquí, como puede
ver, aún no tenemos ningún parámetro de exponer. Entonces para
exponer un parámetro, podemos seleccionar el mezclador, y luego bajo el nombre del volumen
aquí, debajo del inspector, podemos hacer clic derecho en
este, y luego podemos exponer el volumen a un script. Y si tenemos este signo de flecha, significa que este
parámetro es exponer. Entonces ahora si presionamos el botón
post parametros, podemos ver un parámetro post.
Podemos cambiarle el nombre a esto. Así que voy a
hacer doble clic sobre un nombre y luego cambiarle el nombre
a volumen SoundEX Y después voy a seleccionar el Grupo de Música de Fondo
y también clic derecho aquí, y después voy
a exponer esto. Ahora tenemos dos parámetros
expuestos. Para estos nuevos parámetros
que hemos creado, el volumen del grupo musical
Bagrand Voy a renombrar este volumen de
dos Bagran Music. Ahora tenemos dos parámetros. Tenemos que recordar el nombre y la capitalización del
nombre porque es importante Ahora volvamos
al guión aquí. Ahora tenemos exponer
esos parámetros. Podemos acceder al mezclador principal, y podemos establecer su float, y en cuanto al nombre del parámetro
expuesto
aquí, el nombre de la cadena. Solo pasemos el nombre del volumen eff
sound. Y por el valor, queremos
pasar este valor aquí. Así que vamos a pasar el valor. De esta manera, cuando estamos cambiando el volumen
arrastrando el deslizador, este método se ejecutará, y el valor del deslizador se
pasará a través de
este parámetro,
y este parámetro modificará
el volumen de efectos de sonido Lo siguiente que
queremos hacer es, queremos guardar el
valor del slider. Solo usemos la clase
player prefs y tiene un método set float, y esto como para una clave de cadena, y aquí es donde vamos a usar la cadena
que hemos creado Para la clave sol effx, vamos a
usar la clave aquí Y queremos ahorrar el valor. Y después de eso, queremos
guardar la preparación del jugador. Así que vamos a ejecutar el
método seguro de los prefs del jugador. Tenemos que insertar una cadena aquí, voy a crear una cadena. Llamemos a esta clave de efecto
sol, y esta sería la clave de la música de
fondo. A propósito hago
esto como privado, por lo que el valor solo se puede
cambiar dentro del script, no se puede cambiar
en el inspector Y de esta manera, el valor
será más consistente. El siguiente método que
queremos crear es que
queremos crear el volumen de música a
Bground aquí Vamos a copiar
todo esto aquí. Y lo voy a pegar aquí, y luego voy a renombrar el método para ajustar la música
Bground, y queremos cambiar el float,
que es el volumen de
música de fondo Y para la clave, queremos
usar la llave Big GM aquí. Por lo que queremos guardar el valor una clave separada en
las prefs del jugador Así que vamos a pegar esto
aquí y guardar esto. Ahora tenemos este método dos. Necesitamos asignar este
método al deslizador, así que necesitamos crear un
nuevo método de inicio público Y esto tiene que
ser público porque este método init se va a ejecutar
desde el manager del juego Entonces aquí, primero, queremos
acceder al objeto
deslizador Son EffX, y luego ejecutar el evento
value change, y queremos agregar listener Y aquí podemos pasarle el método
a su oyente. Así que vamos a ejecutar
el S Soon EfFx. Y ves que este
oyente de anuncios tiene una firma flotante. Unity event float, y
necesitamos este método para tener un parámetro float porque
pide un float aquí. Para el
control deslizante Música de fondo, queremos hacer lo mismo, así que vamos a acceder al evento de cambio de valor
on, y luego agregar el oyente, que es la música de
fondo JS aquí Bien, ahora hemos creado esto. Esto debería funcionar,
pero todavía hay cosas que necesitamos
agregar aquí arriba, queremos cargar los ajustes de volumen que hemos guardado de
las prefs del reproductor Entonces para cargar el volumen, podemos simplemente ejecutar
el método de ajuste, que son los efectos de sonido, y luego podemos pasar
el valor aquí. Entonces, para cargar
las prefs del jugador, solo
podemos acceder a la clase
player prefs, y luego usar el método
GT float, y necesitamos recuperar
usando su clave aquí Solo pasemos la cadena de teclas
Sound ex. Y hay sobrecarga, que si solo selecciono
la sobrecarga aquí, verás que podemos
pasar un valor por defecto. Entonces si no hay valor
de las prefs del jugador, podemos simplemente pasar
el valor predeterminado, que es que puede ser cualquier cosa, pero voy a establecer este 20 Y voy a ejecutar el método jazz
Background music, y voy a pasar
los prefs del jugador, también el método Get float Y aquí, voy a agarrar la tecla Background y luego establecer el
valor por defecto también en cero. Y ahora con esta configuración, cargamos el valor predeterminado o
el valor seguro de nuestro volumen tanto en los efectos de sonido como en
la música de fondo. Pero también queremos ajustar el valor del deslizador a
este valor flotante aquí. Vamos a acceder al deslizador de efectos de
sonido y tomar las
propiedades de valor y luego pasar el valor de los perpetradores
del jugador aquí Voy a copiar esta línea
aquí y luego pegarla aquí. Y para el valor del
deslizador de fondo, voy a pasar el
segundo get float aquí. Bien. Ahora hemos configurado
el script de configuración de folum Vamos al
manager del juego y creamos
un nuevo campo SS para crear una
instancia de esta clase aquí Aquí debajo del campo del administrador de interfaz de usuario, voy a crear
un nuevo campo SURAL, y esta será
la configuración de Folum, y voy a llamar a
esta configuración de todos Y entonces solo inicialicemos
esto y guardemos esto. Aquí en el administrador del juego, necesitamos crear un nuevo tipo
de propiedades
públicas de b. Vamos a crear eso. Voy a crear una
b pública y voy a llamar a este juego pausado y este
será un get público, pero un set privado Solo se puede establecer a partir de
este script de administrador de juegos, pero todos los demás guiones
pueden obtener su valor de bulion Y aquí dentro del método init. Queremos inicializar los ajustes
de volumen. Simplemente accedamos a
la configuración val y luego ejecutemos el método innato Y esto ejecutará
este método innato. Y ahora queremos modificar el método de actualización de
nuestra clase de manager de juegos. Así que vamos a arrastrarnos hasta aquí, y ya
tenemos un método de actualización Aquí, vamos a
crear una declaración I, y queremos verificar si hay
una tecla abajo. Así que vamos a usar para
obtener el método key down. Y voy a pasar el código
clave escape por hacer una pausa. Y aquí queremos modificar la escala de tiempo de nuestro juego aquí. Solo accedamos a
la escala de tiempo. Y queremos verificar si la escala de tiempo es
igual entonces cero, entonces queremos volver a establecer la escala de
tiempo en uno. De lo contrario, si no es cero, entonces queremos establecer este 20. Y siempre que estemos haciendo una pausa, queremos habilitar el panel
de la configuración de volumen Vamos a acceder al objeto de configuración
fs aquí, y tenemos las propiedades
del panel. Simplemente ejecutemos el set
active set y luego pasemos la escala de tiempo igual a cero. Entonces esto significa que si
estas condiciones son ciertas, que queremos activar
el panel de volumen, y si esto cae,
el panel de volumen obtendrá el activado. Y también queremos establecer el juego pas bulion propiedades
a este valor también Lo siento, hay una
cosa que me olvidé aquí, en los ajustes de volumen. Tenemos que marcar esto
como esterilizable. Vamos a usar aquí el
atributo del sistema s y guardemos esto. Ahora bien esto debería funcionar,
y vamos a Unity. Y aquí, una vez compilado el
script, ves que tenemos este campo de ajustes de
volumen, y tiene muchos campos. Entonces primero, para el panel, queremos arrastrar el panel de la pantalla
pus. Y para el control deslizante, vamos a abrir la pantalla pus, abrir el objeto layout, y tenemos el slider
para el efecto de sonido. Así que voy a abrir tanto
el objeto de juego deslizante y luego arrastrar el control deslizante para el efecto de sonido a
la ranura de efflder de sonido Y para la música de fondo, voy a arrastrar el control deslizante
a la ranura del deslizador de fondo. Y para el mezclador principal, necesitamos hojear esto
desde el proyecto. Entonces, usemos
este botón circular y luego escojamos el
mezclador principal de los activos. Y guardar la escena. Y
ahora vamos a darle una oportunidad. Presionemos play, y
veamos si presionamos escape, la pausa del juego, y puedo
cambiar el volumen aquí. Todavía puedo disparar porque no
lo hemos evitado. Pero en un momento, te
mostraré cómo. Ahora solo intentemos
bajar la música. Ahí vas. Si
Empujamos el deslizador. Se puede ver que hemos bajado el volumen de la música, y
podemos aumentarlo. Así que voy a poner esto en esta
posición aquí, y pongamos los
efectos de sonido a un volumen más alto Sí. Y también podemos
hacerlo más pequeño. Ahí vas. Y si nos sentamos
aquí en esta posición, y luego nos detenemos. Y si presionamos play, y luego hacemos una pausa de nuevo. El valor se carga,
como puedes ver aquí. Obtiene los ajustes
de volumen de la nave del jugador.
Para que podamos salvar esto. Y esta configuración
también es segura a lo largo de
diferentes sesiones. Bien, vamos a revisar la
consola para ver si hay algún error. Hasta el momento, no hay errores. Eso es bueno. Lo siguiente que queremos hacer es que queremos
evitar que el jugador
dispare cuando se le pase. Así que vamos a abrir Visual studio, y vamos a abrir el guión
del reproductor. Y si vamos a la cima aquí
bajo el método de actualización, tenemos esta línea, y esto en realidad está
ejecutando la actualización desde el objeto scriptable de
nuestra arma activa actual Y podemos agregar una condición aquí. Podemos comprobar si la
instancia del gestor de juegos Game pause es falsa, y podemos simplemente añadir un signo de
exclamación delante aquí, y esto quiere decir que si
este valor es falso, entonces queremos ejecutar
la actualización del método Pero si este valor es cierto, entonces queremos saltarnos
este código aquí. Y guardemos esto, y
volvamos a la unidad. Ahora, cuando termine de
compilarse, probemos esto. Y tratemos de
hacer una pausa un poco más tarde cuando llegue
el enemigo. Entonces ahora es pausa. Todo el
juego de elementos es pausa aquí, y no podemos disparar. Como puedes ver, no
hay sonido de disparo, y el mo tampoco
disminuye. Bien. Sí, así es básicamente
como creamos un mecanismo de pausa y
también una configuración de volum
44. Configuración de 43 jugadores muertos: Ahora en este video, vamos
a crear un mecanismo de muerte. Actualmente, no
tenemos eso, así cada vez que nuestra salud
va a cero, el juego continúa, necesitamos
agregar esas características. Entonces vayamos al estudio fisal. Y lo primero que
queremos modificar aquí, queremos ir al manager
del juego. Y dentro del manager del juego en parte superior aquí en el área de campo, queremos crear un nuevo toro
público propiedades para declarar si el
jugador está muerto o no Así que vamos a crear
un nuevo lingote público, y vamos a llamar a
este jugador muerto, y queremos poner
esto también a un getter público,
pero un setter privado Y aquí, dentro del método hit, el método player hit,
queremos comprobar si nuestra salud actual
es cero o no. Vamos a crear
una sentencia if, y si la salud actual
es menor o igual a cero, entonces queremos ejecutar el método
show y screen, y queremos también establecer
el jugador que bul thru. Y esto se establecerá
en false por defecto. Entonces necesitamos cambiar estos dos verdaderos cada vez que el
jugador esté muerto. Tenemos que modificar otro
par de guiones, y voy a modificar
el guión enemigo. Así que vamos a abrir
el guión enemigo. Y aquí dentro
del rodaje t aquí, dentro del bucle wil,
quiero comprobar el jugador es ese estado. Sólo vamos a acceder
al administrador del juego. Referencia estática,
que es instancia, y solo podemos verificar para
el jugador ese valor Y si el jugador está muerto, queremos dejar de disparar, y el método stop
shooting
ejecutará el método stop all co
rutinas en realidad. Por lo que esta co rutina
se cancela, y el enemigo se
quedará inactivo. Guarde esto. Lo siguiente que queremos
modificar es el guión del jugador. Básicamente, aquí, queremos
agregar también una condición cuando
el jugador esté vivo, luego queremos ejecutar
la actualización del arma. Solo agreguemos una condición N y verifiquemos si el manager del juego, jugador de
instancia
está muerto es falso. De esta manera, cuando el
jugador esté muerto, el jugador ya no
podrá disparar. También quieren evitar que
el jugador
se mueva cada vez que el
jugador esté muerto. Actualmente aquí en
el punto de tiroteo. Ves que cada vez que
esto se activa, el jugador seguirá moviéndose. Y esto es un problema porque
cuando entramos en el tiroteo, tenemos una acción retardada para ejecutar el método de área
despejada establecida Y esto no se cancelará si el jugador está muerto actualmente. Esto seguirá ejecutando
esta rutina central aquí. Entonces tenemos que cancelar esto aquí. Podemos simplemente agregar una condición
aquí, A o condición. Si la instancia del manager del juego
y el jugador están muertos, entonces queremos devolver esto. El método seguirá siendo
llamado por esta acción retrasada. Pero cuando se llama, si el jugador está muerto, volverá, entonces todo este código aquí se
omitirá. Vamos a guardar esto. Lo siguiente que queremos
modificar es el tiempo
u objeto aquí. Aquí dentro del objeto temporizador, tenemos esta rutina central
que ejecuta el temporizador. Esto tampoco se
cancelará siempre que el jugador esté muerto en
el estado actual. Entonces necesitamos agregar eso aquí
dentro de la declaración salvaje, solo
podemos verificar si la instancia del manager del
juego y el jugador están muertos,
y si está muerto, entonces
queremos romper esta rutina central. Podemos simplemente romper
la cotina usando la declaración yield break
aquí dentro de la corrutina, y esto
cancelará esta rutina central Ahora continuemos modificando el último script que
necesitamos modificar, que es el gestor de UI,
así que voy a abrir eso. Aquí dentro del gestor de UI, tenemos esta pantalla final de show,
y necesitamos arreglarlo. Porque básicamente cada vez que
terminemos el juego o cuando
el jugador esté muerto, vamos a mostrar
esta pantalla final. Y existe la posibilidad de que este
valor total de disparos sea cero, y esto provocará un error. Entonces tenemos que verificar si lo
siento voy a crear un nuevo
conjunto de padres aquí. Y voy a comprobar si el total de tiros
es igual a cero. Entonces voy a pasar valor
de uno Pero si no es cero, entonces queremos pasar el
valor de los tiros totales. Entonces, vamos a guardar esto, y
este es un operador ternario. Y aquí, también necesitamos fijar la relación de precisión en
la puntuación de cálculo. Vamos a copiar esta línea aquí, y luego pegarla aquí
ya que se usa el
mismo nombre de variable, así que esto debería funcionar de inmediato. Y ahora queremos crear
otra declaración LSF. Pero voy a crear
esto por encima del rango D aquí. Así que vamos a crear una
nueva sentencia LSF, y esta vez si el
promedio total es igual a cero, entonces queremos pasar n de
E. Así que vamos a E. Así que vamos definir que este es el
más bajo corrió posible Vamos a guardar esto. Ahora modificamos
todo el guión aquí. Vamos a probar esto.
Vamos a Unity y vamos a correr el juego. Voy a hacer una pausa
y luego bajar la música y luego continuar. Y ahora solo quedemos
quietos y recibamos los
disparos enemigos tanto como sea posible. Para que podamos probar si
el jugador está muerto. Ahí vas. Ahora,
nos han matado y el enemigo deja de disparar.
Los tiempos se detienen. Ya no podemos disparar. Y como los tiempos se detienen, el juego no va a progresar. Entonces así es como creamos
la característica muerta.
45. 44 Escena del menú de Title: Ahora vamos a crear
la escena del título. Con el fin de crear
una escena de título. Vamos a crear una nueva escena aquí
debajo de la carpeta de escenas. Así que vamos a
crear una nueva escena, y llamemos a
esta escena del título. Abramos la escena del título. Con la escena del título abierta, voy a seleccionar la cámara, y voy a establecer la bandera
clara en color sólido. Y voy a cambiar el color del
desglose a negro. No vamos a estar viendo la caja del cielo, y ahora vamos a salvar la escena. Lo siguiente
que tenemos que hacer es crear un Canvas. Voy a ir al menú de UI aquí y luego crear nuevo Canvas. Para el objeto canvas
bajo el escalador Canvas, cambiemos esto a la
escala con tamaño verde y fijemos la resolución en 1920 por 1080 Esta es la re resolución
que estamos usando, y para las propiedades de coincidencia, pongamos esto en 0.5. Se equilibrará entre
la anchura y la altura. Y ya
preparé un par de prefbs para la escena del título Así que vamos a importar eso. Voy a incluir el
archivo en el recurso, y aquí voy
a importar paquete, y se llama
Title UI package. Y al importar este paquete, asegúrate de
no importar los fondos,
solo selecciona esto, y simplemente
deselecciona sprite también Debido a que ya tenemos
esto en nuestro proyecto, podría
estropearlo. Así que vamos a importar aquí la carpeta
UI pack. Ahora que tenemos
importar los prefabricados, vayamos al U IPAC Bajo el prefe
tenemos un nuevo prefs. Uno es el menú de opciones O, y el otro es el menú de título. Queremos poner primero el menú del
título. Vamos a arrastrar el
menú del título al objeto vas game, y puedes ver el objeto aquí. Hay un problema
con el botón. Para arreglar esto, solo vamos expandir el menú de título prefs, y tiene estos tres botones, la opción de inicio y quid, y le falta Entonces necesitamos generar
un sprite transparente. Para hacer eso, vayamos a la carpeta Sprite
debajo de nuestro sprite UI Queremos abrir
este editor de sprites, y voy a arrastrar un nuevo
sprite aquí a un área vacía,
y tamaño .
Realmente no importa. Y voy a
cambiar el nombre de este sprite a UI underscore sprites, Entonces una vez que hayamos renombrado esto, solo
presionemos aplicar. Ahora que tenemos un sprite
transparente, podemos usar este sprite
transparente Como pueden ver
aquí, porque puse el mismo nombre con el
que configuré aquí
este prefabs Ahora ocupa automáticamente. Pero si estás usando
un nombre diferente, puedes simplemente seleccionar todo el botón aquí desde
el botón
de inicio hasta qui
y luego simplemente elegir la imagen de origen usando el sprite transparente
que has generado Ahora bien este botón ya
configurado correctamente, tiene aquí un sprite
seleccionado diferente Si presionamos play,
verás que si hacemos clic
en el botón, tiene un borde. Vamos a usar
esto para movernos usando el teclado hacia arriba y hacia abajo.
Ahora, paremos con esto. Lo siguiente que queremos
poner es el menú de opciones. Simplemente pongamos el menú de opciones al objeto del juego Canvas, y ahora tenemos este
bonito menú de opciones. Aquí bajo el menú de
opciones prefep, tenemos mucho objeto hijo Aquí bajo las opciones,
tenemos una entrada, la primera entrada, que
es la resolución, y la segunda entrada
es la calidad. Y aquí tenemos un desplegable para la resolución y también
desplegable para la calidad. Vamos a poblar el
menú desplegable usando un script, y vamos
a recuperar toda
la resolución soportada
en el PC reproductor Y por la calidad,
vamos a
tomar los ajustes de calidad
de nuestro entorno de proyecto. Si vamos a la configuración
del proyecto aquí, y bajo la calidad,
ves que tenemos esto. Queremos agarrar esto y luego llenar este desplegable basado
en este valor aquí Y queremos asegurarnos de
que este desplegable pueda cambiar la resolución y la calidad en el final
construido del juego Ahora vamos a guardar la
escena y necesitamos crear un nuevo guión
para la escena del título. Ahora vamos a la carpeta de
scripts. Voy a crear
una nueva subcarpeta, y voy a llamar a
esta escena del título Aquí bajo la escena del título, queremos crear
dos nuevos guiones. El primero será
el encargado del menú de título. Vamos a crear esa. Y el otro
sería el guión de opción. Ahora vamos a abrir este guión aquí. Voy a abrir primero el script de
opción. Aquí dentro del script de opción, queremos crear una nueva variable para mantener el menú desplegable. Vamos a crear un
nuevo campo de seriales. Para el tipo, voy a escribir el espacio de nombres del texto Mash pro porque el
desplegable es el desplegable text
mesh pro, y aquí solo podemos usar
la clase desplegable TMP Y llamemos al primer menú desplegable
de resolución, y al segundo,
calidad, desplegable. Entonces queremos crear
una nueva variable privada para contener los datos de resolución. Vamos a escribir resolución
privada. Y esto va a ser una matriz, y voy a llamar a
esto resoluciones. Aquí dentro del método de inicio, queremos agarrar todas
las resoluciones soportadas en esa PC. Vamos a escribir resolución, la matriz que
hemos creado aquí, y luego podemos
ajustar esto con las resoluciones de clase de pantalla. Esto devolverá todas las resoluciones de pantalla
completa soportadas por el monitor.
Solo usemos esto. Aquí queremos crear una
nueva lista de cadenas para sostener las opciones o las resoluciones en
el formato de cadena, así podemos ajustar esta lista de cadenas al menú desplegable de
resolución. Simplemente escribamos estas opciones y vamos a inicializar esto Y luego queremos revisar las resoluciones que
acabamos de agarrar aquí. Vamos a pasar la resolución
y agarrar su longitud. Y para cada resolución, queremos crear
una nueva cadena para ser agregada a la
lista de opciones de cadenas aquí. Simplemente llamemos a esto resto, y para la cadena, queremos agarrar el índice de
resolución de I width, y queremos agregar
esto con una cadena x con un espacio en ambos
lados del carácter x. Y luego agrega esto con el índice de resoluciones de
I y es con valor. Lo siguiente que
queremos hacer es, queremos agregar la cadena a
esta lista de cadenas aquí. Solo agreguemos la cadena de resto, y esto
llenará la lista de opciones de cadena con esta cadena, pero con todas las resoluciones que soporta el
monitor actual. Aquí abajo, queremos tomar
el menú desplegable de resolución, y luego queremos ejecutar
el método clear options. Esto despejará cualquier opción
anterior. Entonces queremos
llenar el menú desplegable con nuevas opciones usando
el método At options, y pide un
sprite menos apagado o menos off string Así que solo podemos pasar
las opciones aquí. Y ahora queremos establecer el valor desplegable de
resolución a la resolución seleccionada actual
o la
resolución activa actual en ese monitor. Para hacer esto, necesitamos
crear una nueva variable entera,
y vamos a crear una nueva variable entera, llamar a este ID de resolución de pantalla
actual, y set es 20. Y aquí queremos
comprobar si la pantalla y
vamos a simplemente agarrar la resolución
actual y agarrar su ancho, y necesitamos comparar tanto
el ancho como el alto con
el
valor de el ancho como el alto con
el resoluciones en el índice de I. Para el ancho,
necesitamos comparar con el ancho de
resoluciones índice de I. Si el valor es igual, necesitamos
verificar también la altura. Solo agreguemos un operador n, y vamos a verificar resolución actual de
la pantalla igual a resoluciones,
índice de la misma. Voy a romper
la línea aquí, así que es más fácil de leer, y si ambas
condiciones son ciertas, entonces estamos en esa resolución. Queremos establecer este ID de resolución de
pantalla actual al valor de I. Ahora hemos establecido este valor. Queremos ir aquí abajo y acceder al menú desplegable de
resolución, y queremos establecer su
valor a este entero aquí. Vamos a pasar esto aquí. Y esto fijará el
desplegable a la resolución activa. Y ahora queremos poblar
el desplegable de calidad. Esto es mucho más sencillo, así que solo podemos
acceder al
desplegable de calidad y podemos
borrar las opciones Para agregar opciones, queremos acceder nuevamente al menú desplegable de
calidad, ejecutar el método add options Entonces queremos pasar
la configuración de calidad, y la clase de configuración de calidad tiene una matriz de
cadena llamada nombres, y esta es la lista de índice de configuraciones de calidad
disponibles. Pero como es una matriz de cadenas, necesitamos convertir
esto en una lista porque en las opciones como
para una lista de cadenas. Y si solo pasamos la matriz, va a arrojar un error aquí. Para convertir
esto en una lista,
podemos usar un enlace de sistema de espacio de
nombres dentro del espacio de nombres de enlace, tenemos una función de dos listas Podemos usar esto y
esto convertirá esta cadena a lista. Aquí, queremos establecer
el
valor desplegable de calidad a cualquier
configuración de salida en la que estemos
actualmente establecidos. Vamos a establecer el valor aquí para igualar la clase de configuración de
calidad, y queremos obtener
el nivel de calidad. Y esto devolverá un
entero del índice, la calidad en la que actualmente
estamos establecidos. Vamos a guardar esto. Y aquí,
volvamos a la unidad, y vamos a probarla aquí. Primero, voy a poner el script de opción al objeto de juego
Canvas aquí, y vamos a abrir
el menú de opciones, y para el menú desplegable de
resolución, queremos elegir el
primer menú desplegable, y para el menú desplegable de calidad, solo
arrastremos el
segundo desplegable. No podemos probar el desplegable de
resolución porque solo
funciona en una compilación, sino el desplegable de calidad, podemos probar esto en el editor Así que vamos a abrir
la configuración del proyecto. Actualmente estamos en fantástico
si presionamos play Ahora, ya ves que aquí tenemos
mucha resolución. Y también tenemos todos los ajustes de
calidad, que es el más rápido,
rápido, simple, bueno, hermoso y fantástico. Y actualmente estamos
establecidos dos fantásticos. Y aquí, si cambiamos esto, nada va a pasar ahora mismo
porque necesitamos registrar un método donde
vamos a cambiar la configuración de calidad a
este oyente desplegable Así que vamos a hacer eso. Aquí queremos crear un
nuevo método público. Simplemente eliminemos
este método de actualización. No vamos a estar usándolo. Voy a crear
un nuevo método público, y voy a llamar a
este conjunto de calidad. Y voy a pasar
una variable entera. Vamos a llamar a esta identificación de calidad. Y aquí queremos acceder a
la configuración de calidad, y queremos establecer
el nivel de calidad, entonces queremos pasar este ID de
calidad aquí. Y guarda esto. Y ahora queremos asignar el oyente para
este desplegable de calidad, siempre que se cambie el
desplegable de calidad, queremos ejecutar este método
set Y sea cual sea
el valor que cambie en este desplegable de
calidad, queremos pasar ese valor
como ID de calidad aquí. Entonces aquí en el
método de inicio a continuación, podemos acceder al menú desplegable de
calidad, y luego podemos buscar el evento de cambio de valor aquí. Y luego podemos ejecutar el método de escucha de
anuncios, luego podemos pasar el método
set quality Y aquí, como pueden
ver, pide una acción con una
firma de entero. Entonces es un método. Pero con un argumento, eso es un entero. Entonces, si tenemos otro método que no tiene un
entero como argumento, esto arrojará un error. Y la forma en que es este trabajo, cada vez que cambiamos
el
desplegable de calidad , están cambiando el valor. Entonces, cuando estamos
cambiando el valor, en realidad
estamos
cambiando el entero, representando las
opciones de cero a la longitud máxima
de las opciones. Y cada vez que
cambiamos
esos valores, esos valores están siendo enviados a este método aquí al método
set quality. Y cuando ejecutemos este método, esos nuevos valores van
a pasar como argumento aquí, y este argumento cambiará el nivel de calidad en nuestros ajustes de
calidad aquí. Y ahora vamos a crear un método
de resolución de conjunto. Aquí, vamos a crear
un nuevo vacío público y llamemos a
esta resolución establecida. Para la resolución, también
queremos pasar un entero. Simplemente llamemos a esta identificación
de resolución. Y guarda esto. Y para la resolución establecida, queremos crear una resolución
temporal de datos. Entonces voy a llamar a esto RS, y voy a agarrar
la matriz de resoluciones, y queremos agarrar la identificación
que hemos pasado aquí. Así que vamos a pasar
el ID de resolución. Y esto funciona exactamente igual que
el método de calidad Set. Esto se registrará en el menú desplegable de resolución
sobre oyente de cambio de valor Y ahora una vez que hayamos
agarrado la resolución, queremos aplicar esto a la pantalla Establecer método de
resolución. Para el método set resolution, solicita un entero de
width integer height y la opción
booleana de pantalla completa Solo pasemos el
ancho del resto y para la altura, solo
podemos pasar
la altura del resto. Para la pantalla completa, sólo
podemos acceder a la pantalla
f pantalla. Vamos a guardar esto. Y también queremos registrar la resolución establecida en el menú desplegable de
resolución. Vamos a escribir el
menú desplegable de resolución y acceder
al evento value change y agregar el listener y pasar el método
set resolution Y ahora hemos
configurado el oyente para el menú desplegable de resolución He notado que hay un
error en mi código aquí, aquí, en la cadena res. Esta debería ser la altura. Simplemente cambiemos el segundo parámetro de
resolución
al valor de altura y guardemos esto. Ahora bien, si volvemos a la unidad aquí, y luego si tratamos de ejecutar esto, abramos la configuración del proyecto. Y tratemos de cambiar
la calidad aquí. Si cambio la
calidad a simple, verá que hemos cambiado la configuración de calidad en la configuración de
nuestro proyecto. Y esto afectará a toda
la fidelidad visual
que hemos
establecido aquí o que Unity
haya establecido aquí. Bajará la textura dependiendo de la
calidad que tengamos. Sí, vamos a seguir terminando la
escena del título en el siguiente video.
46. 45 Menú de Title Continuación: Ahora, conectemos
todo el botón, para que podamos iniciar el juego o
podamos abrir el panel de opciones, o podemos salir del juego. Para ello, vamos a abrir el menú de título Administrador script. Aquí dentro del menú de
título Gerente. Vamos a crear una nueva variable, y vamos a establecer este objeto de
dos juegos, y este sería
el panel de opciones. Y la otra
variable que quiero crear es una variable de cadena, y voy a llamar a
esta escena de juego. Y queremos
agregar también un campo serize, y este será un botón Pero para poder usar el botón, necesitamos importar el espacio de nombres de
la interfaz Vamos a automatizar esto aquí y necesitamos crearlo
automáticamente. Voy a crear
un nuevo botón de inicio, botón opción, y luego botón de
opción cerrar, y el último
sería el botón Qi. Eliminemos el método de actualización. No vamos a estar usando eso. Aquí queremos crear un método de pareja. El primero sería
el método de inicio del juego. Y el segundo
sería el panel de opciones abiertas. El tercero sería el método de panel de opción
cerrada, y el cuarto
sería el método de juego quid Para el juego Quid es
bastante fácil, en realidad, solo
podemos acceder a
la clase de aplicación y luego ejecutar el método QID, y esto saldrá del juego
en el juego independiente construido No va a hacer nada
en el editor. Y para el juego de inicio, queremos cargar
la escena del juego en
función de su nombre aquí. Así que necesitamos importar la
escena Manager Name space. Voy a escribir usando el
motor Unity Scene Management. Y aquí dentro del juego de inicio, quiero asegurarme de
que no podemos iniciar juego si el
panel de opciones está abierto. Entonces queremos verificar si el panel de opciones está
activo en jerarquía, entonces queremos devolver esto. Pero si no lo es, entonces queremos acceder
a la clase scene
manager, y luego queremos ejecutar
el método load scene, y podemos pasar ya sea el índice de escena construida
o el nombre sen, y vamos a
pasar esta cadena aquí. Así podemos llenar el
nombre de la escena en el inspector y guardar esto Para el panel de opciones
abiertas, voy a acceder
al panel de opciones, y voy a ejecutar
el método set active, establecer el valor en true para
cerrar el panel de opciones. Solo podemos acceder nuevamente al objeto de juego
del panel de opciones. Ejecute el método set active y
luego pase el valor false. Siempre que estemos cerrando
el panel de opciones, queremos seleccionar
el botón de opción. Simplemente accedamos
al botón de opción y luego ejecutemos el método select. Y select method configurará este botón para que sea el
botón seleccionado en la escena aquí. Al inicio, queremos configurar el botón de inicio para
que sea el seleccionado, utilizando el método select. Entonces aquí queremos
asignar todo este método
aquí a este botón aquí. Simplemente podemos acceder
al botón de inicio, y luego podemos acceder
al evento unclick Entonces podemos agregar oyente. Y aquí queremos pasar
el método de inicio de juego. Para el botón de opción, también
queremos acceder al evento
click en Listener, y queremos abrir
el panel de opciones aquí Para la opción botón cerrado. Queremos pasar el método de panel de
opción cerrada. El último para
el botón quid, queremos pasar el método del juego
quid como oyente
aquí, y Aquí dentro del método de inicio, también
queremos ocultar el panel de
opciones de inmediato. Simplemente accedamos
al panel
de opciones inicio y luego ejecutemos
el método set active, más allá del valor falso como
argumento, y guardemos esto. Ahora hemos creado el script del administrador del menú
Título. Volvamos a Unity y agreguemos el script
al objeto de juego Canvas. Establece el juego Canvas, dirige el administrador del menú Título, y ahora necesitamos rellenar la variable en el inspector Vamos a la
carpeta de escenas y voy a escribir la escena
donde está nuestro nivel, que es la escena de muestra. Para el panel de opciones,
solo podemos arrastrar el menú de opciones aquí. Como el objeto del juego.
Para el botón de inicio, queremos abrir el menú de título y arrastrar el botón de inicio aquí. El botón de opción,
queremos arrastrar el botón de opción. Para el quid, queremos
arrastrar el botón quid. Para el botón de opción cerrar, queremos elegir el botón
de los prefabricados del
menú de opciones Solo arrastremos
este botón aquí. Este es en realidad
este botón de aquí. Queremos cerrar
el panel de opciones cada vez que hagamos clic en este botón. Vamos a guardar esto. Ahora
vamos a darle una oportunidad. Iniciará la escena con el botón de inicio seleccionado,
y si
bajamos, podremos seleccionar otras opciones, y si seleccionamos las opciones, esto abrirá la ventana aquí. Si presionamos bien,
cerrará esto de nuevo. Detengamos esto, y vamos a arreglar una cosa aquí dentro
del administrador del menú de título, cada vez que abrimos
el panel de opciones, queremos seleccionar la
opción cerrar Paton Aquí voy a acceder a
la opción cerrar Paton, y después voy a ejecutar el método select
aquí y guardar esto Esta vez, siempre que
jueguemos esto, y si abrimos el panel de opciones, Esto
seleccionará automáticamente esta patente aquí. Si presionamos enter, se
cerrará de nuevo automáticamente. Podemos navegar por el menú de la escena del título
sin ratón. Ahora probemos esto de nuevo, y presionemos start. Actualmente, las escenas de carga
no funcionarán porque no
hemos establecido las escenas que deberían incluirse
en la configuración de compilación. Para solucionar esto,
necesitamos ir al menú de archivos debajo de
la configuración de compilación. Solo arrastremos las escenas que vamos a
incluir en la compilación. Voy a arrastrar
la escena del título aquí y también la escena de la muestra. Voy a salvar el proyecto. Ahora bien, si
presionamos play y si pulsamos enter al inicio, verás que va a
cargar la escena aquí. Ahora bien, si vamos a la escena de
muestra aquí, necesitamos también tener
una manera de volver al menú
del título o a la escena
del título una vez
que terminemos el juego. Para hacer
eso, voy a abrir el script del administrador del juego, y vamos a ir al script
UI Manager aquí. Aquí bajo las propiedades doloridas, vamos a crear un
nuevo campo serializado, y este será
un tipo de botón, y vamos a llamar a
este botón de retroceso, y necesitamos
crear un nuevo método para volver a la escena del título Vamos a crear un
nuevo método privado, y vamos a llamar a
esto ir a la escena del título. Y queremos usar la clase Gestor de
escena. Tenemos que importar en la
parte superior de nuestra clase aquí. Vamos a escribir usando Unity engine scene Management y debajo de la
variable button aquí, queremos crear un
nuevo campo de cadena, y vamos a llamar a
este título Nombre de escena. Aquí abajo sobre la marcha
al método de la escena del título. Queremos acceder al gestor
de escena, Load scene, y luego simplemente podemos pasar el nombre Title Sen aquí. Necesitamos registrar
este método
al botón Atrás que
hemos creado aquí. Dentro del método init, solo
podemos acceder al botón B
en el evento click y
luego agregar oyente, y luego simplemente podemos pasar el método ir al Método Title
Sen Y guarda esto. Ahora si
volvemos a Unity, necesitamos configurar este
botón de retroceso y el título C Nombre. Para el nombre del título C, podemos escribir con seguridad la escena del título, y para el botón, queremos expandir el
administrador del juego y abrir el Canvas. Debajo de la pantalla final aquí,
queremos expandir esto, y queremos
arrastrar el botón como
botón atrás
aquí, y guardar esto. Ahora vamos a jugar esto para probar esta modificación
que acabamos de crear. Y esto no está funcionando porque el punto de mira
está bloqueando al elenco Así que no vamos a necesitar este objetivo de lanzamiento bajo el objeto de juego de punto de
mira Simplemente podemos desactivar esto de manera segura. Ahora si deshabilitamos esto y luego intentamos hacer clic en el botón Atrás, verás que va a funcionar. Así que he parado el juego aquí, y como he cambiado las
opciones en el tiempo de ejecución, tenemos que volver a poner esto aquí. Solo seleccionemos el punto de mira
y verifiquemos el objetivo RC. Bien. Ahora aquí, podemos volver a la escena del título y
desde la escena del título, también
podemos ir a
la escena del juego.
47. ¡Construye el juego!: Ahora vamos a
finalizar el juego. Queremos construir el juego
en una aplicación independiente. Es bastante fácil, en realidad. Podemos simplemente ir al archivo, construir configuraciones, y luego
presionar este botón construido aquí. Podemos decidir si queremos
establecer la arquitectura en,
el bit 64 o el bit 32.
Todo esto depende. Si estás usando dos bits, tendrás una amplia
gama de audiencia que están usando ventanas de
dos bits también incluidas. Porque si construiste a 64 bits, entonces el compilado no se
ejecutará en Windows 32 bit. En el futuro, creo que todo el usuario
cambiará a 64 bit. Entonces voy a levantar
este bit 264 en mi caso. Y lo siguiente
que queremos hacer es que queremos abrir la configuración
del jugador aquí. Y aquí queremos
cambiar el nombre de la empresa. Entonces voy a cambiar el nombre de la
compañía por mi nombre aquí. Y para el nombre del producto. Voy a cambiar
el nombre del producto el nombre del juego,
que es nexus. Versión,
solo puedes establecer este 21. También tendremos que
aplicar el icono predeterminado. Ya preparé el icono. Voy a ir a la carpeta de
texturas aquí y voy a abrir mi icono aquí, y voy a incluir este icono en la carpeta de
recursos, y vamos a seguir este icono
en la carpeta Texturas. Ahora tenemos importar el icono. Podemos elegir el ícono predeterminado
y elegir el ícono de la aplicación aquí. Y lo siguiente que
queremos configurar es aquí bajo la resolución
y presentación. Queremos desactivar el diálogo de resolución de
pantalla. Solo deshabilitemos esto. Y ahora que hemos
configurado los ajustes del reproductor, vamos a verificar los
otros ajustes. A se ve bien. Y si quieres cambiar el identificador del paquete,
debes hacerlo aquí. Entonces podemos simplemente
establecer esto en el nombre de la compañía, que es mi nombre, y
luego para el nombre del juego, solo
puedes escribir el nombre del juego. Eso será todo para configurar
los ajustes del jugador. Y ahora solo
guardemos el proyecto, para que se guarden todos los
ajustes del jugador. Voy a importar
un activo gratuito de
la tienda de activos para los
errores en la compilación Si vas a la tienda de activos, puedes buscar menos registros. Y este es un activo realmente bueno. Puedes usar esto, No este, pero este de aquí, el pewer de troncos, es gratis Y básicamente, podemos mostrar
la consola en nuestro construido. Esto es realmente útil
cuando está depurando su construido. Así que vamos a importar esto. Y ahora una vez que hayamos
impartido el paquete, podemos ir al visor de
registros de Unity aquí y
podemos comprobar el Ritmo. Así que vamos a mostrar en el Explorer y
vamos a abrir el archivo Rhythm. Y aquí, como puedes ver, para poder usar los registros de
la consola, solo
puedes hacer un
gesto circular usando el mouse, clic en arrastrar o con el
dedo en el móvil. Ahora agreguemos los activos
a nuestra escena de inicio aquí. Aquí tenemos un nuevo
menú llamado Reportero, y vamos a presionar crear, y esto
creará automáticamente un objeto de juego para habilitar los registros en la
compilación y guardar la escena aquí. Ahora hemos sumado al
reportero a nuestra escena. Vamos a crear una modificación de
sonido en nuestro script de opciones y
el administrador del menú de título. Vamos a Fis Studio, y voy a agregar un
sonido para los clics aquí Aquí en el script de opción, vamos a crear un
nuevo campo Sudo S, y este será el ger de Audio Y vamos a llamar a este
clic efectos de sonido. Aquí, siempre que cambiemos la resolución o
fijemos la calidad, queremos reproducir ese sonido. Así que vamos a acceder a la instancia del reproductor de
audio y ejecutar el método de reproducción de efectos de
sonido, y luego simplemente podemos pasar los efectos de sonido clic
sin transformar. Este será un sonido de dos D y podemos simplemente duplicar
esta línea aquí, y luego pegar esto aquí
dentro del método de calidad establecida. Ahora queremos agregar también el sonido al administrador del menú de
títulos. Aquí, cada vez que
iniciamos el juego, queremos reproducir el sonido del click. Y también queremos
reproducir el sonido de clic cada vez que abrimos
el panel de opciones. También cada vez que cerramos el panel y cada vez que
dejamos el juego. Pero no tenemos
la variable de
efectos de sonido click definida aquí. Simplemente copiemos el
que tenemos aquí, y luego peguemos esto aquí como
un nuevo campo y guardemos esto. Ahora volvamos a Unity, y tenemos que importar también
el sonido click. Voy a ir a la
carpeta del juego debajo del audio. Voy a abrir el archivo aquí. Y voy a incluir este nuevo sonido en
la carpeta de recursos. Entonces aquí tenemos el botón
UI dot wave. Vamos a dirigir esto a Unity, y luego ponerle el archivo
dentro de la carpeta de audio. Y ahora tenemos este nuevo sonido. Vamos a la carpeta de datos
y actualicemos la biblioteca de audio. Entonces voy a agregar una nueva entrada, y para la última entrada,
voy a establecer esto. Voy a llamar a
este botón UI. Y vamos a escoger aquí la onda de puntos del botón
UI. Y vamos a guardar el proyecto. Aquí en la pantalla de título, queremos crear un
nuevo objeto de juego vacío para el reproductor de audio. Voy a llamar a
este reproductor de audio, y voy a agregar el componente reproductor
de audio. Para la biblioteca, voy
a escoger la audioteca. Y para el número de fuente de audio, no
necesitamos seis fuentes de audio, así que podemos simplemente establecer este 21, y podemos configurar el mezclador al mezclador que hemos
creado antes, y volver a guardar la escena. Ahora bien, si vamos al objeto del juego
Canvas, veremos que tenemos
el efecto Click Son. Simplemente cambiemos
este botón de dos DUI, y para el encargado del título, cambiemos también este botón de
dos DUI, efecto So Ahora guarda esto, y ahora
vamos a construir el juego. Presione configuración de facturas
y luego presione Bill. Y aquí sólo podemos
seleccionar la carpeta construida. Ya he creado la carpeta
y elijo seleccionar carpeta. Simplemente puede crear el construido en cualquier carpeta
que desee. Crea una nueva carpeta y selecciona esa carpeta. Ahora está construyendo. Voy a cortar el
video y
continuaremos una vez terminado el
edificio. Bien, ahora está terminado de construir y Unity
abre automáticamente la carpeta. Entonces ahora podemos probar esto. Y ahora probemos
el panel de opciones. Y de alguna manera no funciona. Intentemos dejar de fumar. Bien. Aquí hay un problema, y tenemos que verificar los temas. Por eso he instalado
el visor de registros. Simplemente podemos crear un movimiento circular usando
el mouse haciendo clic y arrastrando y una vez ahí vas Y como pueden ver aquí, aquí
hay un tema. Verás que tenemos un error, y vamos a comprobarlo aquí. Bien. Aquí hay un problema
con el efecto de
sonido getter Entonces, cuando ejecutamos el panel de opciones
abierto, alguna manera no puede reproducir
los efectos de sonido. Entonces tenemos que arreglar esto, y aquí hay un par de
errores, como pueden ver. Entonces volvamos a Unity. Voy a dejar el
juego presionando F four. Bien, entonces sospecho que el problema está en la clase de captador de
audio Entonces, si abrimos la biblioteca de audio aquí, en el captador de audio, cada vez que recuperamos
el nombre del audio, en realidad
lo recuperamos de la lista de nombres de audio
de cadena aquí Y esta es en realidad
una clase estática, como puedes ver aquí, y si vas arriba aquí, verás que
en realidad es una clase estática. El problema con este código aquí, el unvalidate solo
se ejecuta en un editor, siempre que cambiemos el
valor en el inspector o siempre que seleccionemos el
objeto en el panel del proyecto Pero esto nunca se
ejecuta en la compilación. Así que tenemos que asegurarnos de que
ejecutamos este código
aquí en la compilación. Por suerte, en un objeto scriptable, podemos forzar esto
agregando el método despierto Y dentro del método de espera, solo
podemos agregar el método
validate. Entonces esto llamará a
este método aquí, y luego poblaremos la lista de nombres de audio
estáticos aquí Así que una vez que esté poblado, siempre que estemos recuperando el nombre de audio para reproducir
los efectos de sonido, esta lista estática de
cadenas estará disponible, y devolverá
la cadena correcta Y hay otro tema que he notado en el construido. Al desovar al enemigo aquí, tendremos aquí un marco de referencia
faltante
del componente ym Y esto está sucediendo porque el movimiento del animador se puede
ejecutar antes del inicio Así que tenemos que
asegurarnos de que cada vez que se ejecuta
el movimiento del animador, necesitamos verificar la referencia del objeto
anim aquí Entonces aquí voy a agregar una sentencia if y
si el enim es nulo, entonces queremos devolver
este método y guardar esto Lo sé porque he
comprobado el construido antes, y esto causará
un problema menor. Es solo un mensaje,
un mensaje de error, pero lo mejor sería
evitar también este tipo de errores. Así que vamos a agregar esta
línea aquí y guardar esto. Ahora de vuelta aquí en la unidad. Voy a intentar construir
esto una vez más. Pero antes de eso,
voy a ir a la carpeta de configuración del proyecto
y debajo del audio. Voy a volver a poner el volumen
global en uno. He establecido esto en 0.05. Entonces en el editor, no chow out, pero voy a poner
esto de nuevo en uno Y sólo voy a conocer
el audio aquí en el editor. Está bien, y voy
a salvar el proyecto. Y ahora vamos a construir
el juego una vez más. Ahora el juego está construido, y vamos a ejecutar esto. Y ahora voy a tratar de presionar la opción,
y ahí tienes. Tenemos el sonido sonando. Y ahora si cambias
la resolución, puedes ver que baja
la resolución y solo
podemos volver a cambiar a
la resolución máxima. Se puede escoger una resolución,
por ejemplo, ésta. Y también podemos
cambiar la calidad. Aquí. Voy a
cambiarlo a fantástico y a presionar. Y ahora comencemos el juego. Reloj. Mírela. Ahora,
vamos a probar esto. Volvamos al sí, aunque
hay un problema. Cuando volvemos al menú, no
podemos ver el cursor del mouse
aquí. Vamos a arreglarlo. Y aquí si
vuelves a Unity, ve al estudio is aquí. Bajo el gestor de UI, estamos ocultando
el cursor al inicio del nivel. Así que vamos a copiar
esta línea aquí, y queremos
asegurarnos de que el cursor vuelva a ser visible en
la pantalla de título. Así que solo podemos agregar esta línea aquí al administrador del menú Título. Y dentro del método
de inicio del Administrador del menú Título, podemos simplemente agregar
esa línea y establecer el cursor de nuevo a
través y seguridad. Bien. Entonces sí, así
es básicamente como creamos unos juegos de
disparos reales en Unit, y así es básicamente como
preparas la compilación. Un consejo de metho, cada vez
que termines de probar la compilación, debes eliminar este objeto de juego
ponente Por lo que el reproductor no puede habilitar la depuración de la consola en
el construido por accidente Pero para el desarrollo construido, deberías dejar en escena este objeto de
juego portur, para que siempre puedas depurar
el desarrollo construido Quiero agradecerles a todos por
inscribirse en este curso. Si hay algún problema o algún error en el juego,
por favor repórtame, y actualizaré
el curso para corregir los errores relacionados porque
conozco como persona, no
soy una persona perfecta, puedo equivocarme
en este curso, así que realmente agradezco cualquier
aporte de todos ustedes chicos. Gracias de nuevo, y
espero
verte en el próximo curso mío.
48. 47 áreas despejadas: Hola, en este video actualizado, te
voy a mostrar una solución de un bug que ha sido
reportado por Kyle Cooper. Muchas gracias por reportar esto. Entonces básicamente, en el
juego de disparos que tenemos aquí, la mecánica clara del área
tiene un poco de problema. Es decir, si seleccionamos la cámara principal y configuramos
el bug Inspector aquí, podemos ver que el área despejada no
se está limpiando correctamente. Entonces por ejemplo, si
presiono play ahora, Y en este ejemplo, he puesto nuestra salud en 100. Por lo que tardó un tiempo
antes de que el enemigo mate al
jugador solo para depurar esto. Y aquí, sólo voy a
matar a uno de los enemigos de aquí. Y voy a
levantar el tiempo tal como
es hasta que se acabe y podamos verificar el valor del área
despejada aquí. Entonces aquí se ve que el área despejada no se incrementa. Entonces ahora no podemos terminar
el juego en el estado, pesar de que hemos fh
despejado toda el área Y esto provocará que un
juego rompa errores, en realidad donde no se muestre el
panel de estadísticas, y no podemos
avanzar más en nuestro juego. Porque tenemos en esta escena, tengo tres grupos de disparos
y el área despejada sólo
aumentó a dos hasta el momento. Entonces el valor nunca se iguala, y esto nunca activó la interfaz de usuario. Entonces para arreglar esto, vamos
al estudio Fisial aquí,
y en el guión del
punto de rodaje aquí, Básicamente en el método de
área de set despejada, necesitamos llamar a este
jugador mover área despejada Así que básicamente, esto es llamar a este método en el script
player move aquí, y tenemos que hacer lo
mismo en este código aquí. Entonces solo voy a copiar esta línea aquí y pegarla aquí encima del área despejada igual
a verdadero método y seguridad. Y esto solucionará este problema porque cada vez que se agote
el temporizador, vamos a llamar a este método
set area clear. Y ahora vamos a darle una oportunidad. Y echa un vistazo a la variable área
despejada aquí. Simplemente matemos a uno de los enemigos y dejemos vivos a
los otros. Bien. Ahora se ve que el
área despejada se incrementa, pero hay otro problema. Si matamos a este enemigo, entonces nuestra área
despejada aumenta 22, aunque no hayamos
despejado la segunda área, y esto provocará problema donde cada vez que
despejamos la segunda área, mostrará la pantalla del
final del juego, y no vamos
al siguiente pino aquí. Entonces para poder arreglar
esto, Básicamente, tenemos que ir al guión de movimiento del
jugador aquí, y necesitamos agregar un
Boulan en este método Voy a añadir un argumento
boulano, y voy a llamar a
esto previamente claro Básicamente, voy a comprobar si el valor previamente
aclarado es verdadero. Voy a devolver
esta función. Entonces ahora necesitamos pasar un
bulion a este método aquí, y tendremos un error en
nuestro script de punto de tiroteo. Aquí en nuestro script de
punto de tiroteo, básicamente, cada vez que llamamos al método
area clear, necesitamos pasar a esta área
despejada propiedades de bulion Entonces voy a pasar esto aquí. Y básicamente, esto le pasará el bulion
a este método aquí Entonces, si aún no hemos
despejado el área, entonces este bulion será falso Y siempre que ejecutemos este método, se
ejecutará
todo este heil de abrigo Entonces vamos a incrementar
el valor del área despejada, y vamos a desencadenar el evento y vamos a continuar con el movimiento del jugador. Y si esto, por alguna razón, se
vuelve a ejecutar, por ejemplo, si limpiamos el área, entonces se
llamará a este método, y se
pasará el área despejada, y esto será falso porque no
hemos cambiado
este valor true, y lo cambiamos después de
que estamos llamando a este método. Pero por alguna razón, durante la transición a la siguiente zona, matamos a un enemigo y
terminamos de matar a
todos los enemigos. A esto se le llamará tampoco. Pero ahora con esta comprobación de bulion, el área despejada
será cierta previamente, a
pesar de que estamos configurando
esto en true porque ya se
ha cambiado
a true anteriormente aquí Entonces, si este valor es verdadero, entonces básicamente esto se
saltará todo el código a continuación, y esto ya no
se llamará. Y esto evitará que
el área despejada aumente más de una vez en
un mismo punto de lanzamiento aquí. Entonces si volvemos a la unidad aquí, voy a ejecutar esto de nuevo. Ahora podemos echar un vistazo a
nuestra variable de área clara. Y hagamos lo mismo aquí. Yo sólo voy a matar a
uno de los enemigos aquí en el primer punto de lanzamiento y
dejar vivos a los otros. Y una vez que se acaben los tiempos, intentemos matar al enemigo. Entonces ahora el área despejada
se incrementa aquí, y vamos a matar al enemigo. Y ahora una vez que he
despejado al enemigo, el área despejada permanece 21. Será sólo
aumento en por área, y ahora puedo matar a
este de aquí, y ahora hemos
despejado dos área. Y luego para el tercero, si matamos a este enemigo aquí, mostrará las estadísticas. Y ahora hagamos otro intento. Y esta vez,
dejemos vivo al segundo enemigo en la primera zona aquí
y no lo matemos, pesar de que estamos haciendo la transición
a la segunda zona Entonces voy a chequear contra todos los
escenarios posibles en nuestro juego. Ahora se acaba el tiempo. Sigamos jugando
la otra zona aquí. Y contando correctamente. La variable área clara aquí.
Vamos a matar a éste. Sí, ahí tienes. Así que básicamente, logramos
arreglar este error aquí. Y gracias a Kyle Cooper
por informar sobre este tema. Y si ustedes encontraron
algún otro error, por favor solo repórtelo
en las secciones Clave A, e intentaré
abordar esto rápidamente.