‫Oye.
‫Bienvenido de nuevo.
‫Ahora nos hemos configurado con una función de devolución de llamada vinculada al delegado al recibir algún daño.
‫Y el último paso es generar realmente ese evento de daño.
‫Y queremos hacer esto cuando nuestro proyectil golpea algo.
‫Una vez que transmitimos para este delegado, podemos aplicar daño a lo que golpeamos.
‫Y vamos a transmitir este evento usando daño aplicado, que pertenece a la clase de estática del
‫juego.
‫Así que echemos un vistazo a la función de daño aplicada.
‫Ahora aquí está la documentación para el daño aplicado que dice que daña al actor especificado con daño genérico.
‫Así que esta es una función genérica para aplicar daño.
‫Y lo que hagamos en respuesta a la transmisión de este delegado depende de nosotros.
‫Ahora aquí vemos que necesitamos incluir estadísticas de juego y en la sintaxis vemos varios parámetros de entrada.
‫Ahora obtenemos una descripción de los parámetros.
‫Si seguimos desplazándonos hacia abajo, vemos que el actor dañado está bien, el actor que
‫sufrirá daño base es el daño base para aplicar documentación realmente descriptiva aquí.
‫Gracias.
‫El instigador del evento épico es el controlador responsable de causar este daño.
‫Y dice, por ejemplo, el jugador que disparó el arma.
‫Cuando dice jugador, se refiere a ese controlador.
‫Luego tenemos al causante del daño, que es el actor que realmente causó el daño.
‫Dice la granada que explotó.
‫En nuestro caso, será el proyectil que explotó.
‫Y finalmente, tenemos la clase de tipo de daño, que es una clase que describe el daño que se hizo.
‫Ahora retrocedamos en la sección de sintaxis, podemos ver los tipos de estas entradas y vemos que la clase de tipo
‫de daño es una subclase de y hemos visto antes que la subclase TW de satisfará un parámetro de entrada de
‫clase tipo U.
‫Bueno, cuando llamamos a aplicar daño, podemos pasar una clase U que representa el tipo de daño que nos gustaría
‫usar.
‫Así que hablaremos sobre cómo vamos a satisfacer este parámetro de entrada en un momento.
‫Entonces, la función de estática del juego de tono, el daño aplicado requerirá algunos parámetros de entrada.
‫Entonces, diseñemos una estrategia sobre cómo vamos a pasar los valores apropiados cuando llamemos a esta
‫función, vimos que primero necesitamos al actor dañado.
‫Bueno, volvamos al CP de proyectil donde nos gustaría llamar aplicar daño.
‫Nos gustaría hacerlo aquí de inmediato y ya no necesitamos estos registros.
‫Así que simplemente voy a eliminarlos y notar que nuestra devolución de llamada al momento recibe algunas entradas una vez
‫que se llama.
‫Cuando se transmita el delegado de hit del componente, veremos que tenemos otro actor.
‫Entonces tenemos acceso al actor que fue alcanzado por el proyectil y este es el actor al que nos
‫gustaría dañar.
‫Entonces eso se ocupa del primer parámetro de entrada.
‫Va a ser ese otro actor.
‫A continuación, necesitamos la cantidad de daño, lo que significa que nuestro proyectil debe tener una variable de daño
‫para que sepamos cuánto daño aplicar.
‫Entonces, ¿por qué no entramos en FX de proyectil y agregamos una variable de daño y esto puede ser un flotador?
‫Así que simplemente podemos llamar a este daño y podemos inicializarlo a un valor, digamos algo como 50
‫F y dado que esto es algo con lo que probablemente querríamos experimentar, podemos darle una propiedad
‫U para exponerlo y editarlo. en cualquier sitio.
‫Así que ahora tenemos una cantidad de daño para pasar cuando llamamos a recibir daño.
‫Ahora el siguiente parámetro es el instigador y vimos que este es un controlador tipo A.
‫Entonces, ¿cómo vamos a obtener el controlador?
‫Bueno, hemos visto que podemos obtener el propietario de un componente en particular con la función obtener propietario.
‫Y esto devuelve al actor que posee un componente en particular, estos proyectiles se generan dinámicamente.
‫Entonces, debemos asegurarnos de que si vamos a llamar a obtener propietario, el propietario está configurado ahora que estamos generando
‫estos desde el peón base.
‫Así que si vamos al peón base.
‫CP Aquí está la línea en la que generamos al actor, pero Spawn Actor también devuelve un puntero al actor que se
‫generó para que podamos almacenarlo en una variable local.
‫Por ejemplo, podríamos decir proyectil automático y asignar el valor devuelto por el actor de generación.
‫Ahora, si no está familiarizado con auto, permite que el compilador descubra el tipo para asignar a esta
‫nueva variable.
‫Si pasa el cursor sobre él, verá que tiene el puntero de proyectil tipo A porque eso es lo que
‫estamos firmando desde la función de actor de generación.
‫Así que esto es lo mismo que si hubiéramos puesto un puntero de proyectil aquí y ahora podemos acceder a ese
‫proyectil recién generado.
‫Y la razón por la que queremos hacer eso es que nos gustaría establecer su propietario.
‫Nos gustaría asegurarnos de que su propietario esté configurado para el peón que lo generó.
‫Entonces podemos decir proyectil.
‫Y hay una función para esto llamada propietario del conjunto.
‫El propietario del conjunto toma un actor y vamos a pasar esto para que cada vez que uno de nuestros peones genere
‫un proyectil, establecerá el propietario de ese proyectil.
‫De esa manera, si alguna vez llamamos a obtener propietario más adelante, obtendremos la instancia de
‫la clase que posee ese proyectil.
‫Entonces, aquí en el proyectil DHCP, tenemos nuestra llamada a la función de obtener propietario y podemos almacenarla en una variable
‫local.
‫Continuaré y usaré auto nuevamente y llamaré a esto mi propietario y lo estableceré en el resultado devuelto por
‫obtener propietario.
‫Así que ahora tenemos un puntero de actor local que almacena el valor del propietario.
‫Ahora podemos acceder al controlador del instigador desde este actor.
‫Ahora, antes de hacerlo, es una buena idea verificar que mi propietario no sea nulo.
‫Así que voy a decir que si mi propietario es nulo es igual a un puntero nulo, simplemente regresaré.
‫Ahora, si el cuerpo tiene una sola declaración como esta, puede colocarla en la misma línea sin las llaves
‫en caso de que no lo sepa.
‫Y el puntero nulo es una palabra clave en C++ que le permite verificar si un puntero es un puntero nulo.
‫Entonces, si mi propietario es nulo, saldremos de la función antes y no haremos nada más.
‫Ahora, como decía, podemos obtener el controlador instigador de mi propietario y ese
‫es el uso de la función llamada obtener controlador instigador.
‫Y si pasamos el cursor sobre esto, veremos que devuelve un puntero de controlador A.
‫Simplemente usaré auto y almacenaré esto en una variable local que llamaré instigador de mi propietario.
‫Así que ahora sabemos qué pasar como instigador.
‫La siguiente entrada es el causante del daño y este es el actor que hace el daño por el proyectil.
‫Esto va a ser simplemente esto.
‫Y eso deja el último parámetro de entrada, que es un tipo de daño.
‫Y vimos que es una subclase de lo que significa que necesitamos la clase de uso adecuado para pasar.
‫N Ahora aquí está la documentación del motor irreal para su tipo de daño.
‫Dice que un tipo de daño tiene la intención de definir y describir una forma particular de daño y
‫proporcionar una vía para personalizar las respuestas al daño de varias fuentes.
‫Ahora, no vamos a personalizar nuestro daño.
‫Solo necesitamos satisfacer el parámetro de entrada, lo que significa que necesitamos un valor de clase U que represente esta
‫clase de tipo de daño.
‫Ahora, en C++, si queremos obtener la clase TÚ de cualquier clase en particular, como tu tipo de daño, podemos
‫llamar a una función llamada clase estática.
‫Esto se hereda de la clase de su objeto.
‫Ahora, por supuesto, estamos usando su tipo de daño aquí, así que necesitaremos ese encabezado.
‫Entonces, de la documentación, copiaré la línea de inclusión y la pegaré aquí en la parte superior del
‫CP del proyectil. Y ahora verá que esta función de clase estática devuelve un puntero de clase U y esa nueva clase
‫representará el nuevo tipo de daño. clase C++.
‫Ahora, dado que no estamos creando un plano basado en su tipo de daño y configurando algunos datos adicionales,
‫realmente no necesitamos una subclase de variable.
‫Entonces, en este caso, podemos usar una clase estática y esto devolverá una clase U que representa este tipo.
‫Y podemos almacenar esto en una variable si queremos, y lo llamaré clase de tipo de daño.
‫Y esto es lo que podemos pasar como parámetro final para aplicar daño.
‫Así que ahora tenemos toda la información que necesitamos para pasar a la función de aplicar daño.
‫Pero antes de hacerlo, me gustaría hacer un par de comprobaciones para asegurarme de que sea apropiado que llamemos a
‫esta función.
‫Así que haré una declaración if aquí.
‫Primero, quiero asegurarme de que otro actor no sea nulo.
‫Así que voy a colocar a otro actor aquí.
‫Voy a colocar un y aquí para poder verificar que otro actor no sea igual a este actor.
‫No queremos causarnos daño a nosotros mismos si somos el proyectil ahora voy a colocar otro extremo
‫y asegurarme de que otro actor no sea igual a mi dueño.
‫No sería bueno que el proyectil esté causando daño a su dueño.
‫Y ahora, si entramos en esta instrucción if, entonces sabemos que es apropiado llamar a aplicar daño para
‫que podamos hacerlo.
‫Y ese va a ser tu desafío.
‫Entonces, en nuestra nueva declaración if en la función on hit, llame a la función de daño de aplicación de estática de juego.
‫Esto significa que deberá incluir el encabezado correcto para las estadísticas del juego y sabrá qué parámetros
‫de entrada pasar.
‫Así que pause el video y agregue la llamada de función para aplicar daño en la función de golpe ahora.
‫Bueno.
‫Así que estoy aquí en CP de proyectiles y voy a incluir el archivo de encabezado para las estadísticas del juego y podemos ver
‫en la página de Documentación de daños aplicados que la inclusión es la estática del juego kismet slash.
‫Así que voy a pegar eso allí y ahora estoy listo para aplicar daño.
‫Así que te llamaré estática del juego que aplica daño.
‫Ahora, tan pronto como escribo los paréntesis de apertura, aparece una ventana emergente que me recuerda los parámetros de entrada
‫que necesito.
‫Y el primero es el actor dañado y ese va a ser otro actor.
‫Así que vamos a escribir otro actor a continuación.
‫Necesitamos la cantidad de daño y agregamos este daño flotante en los efectos especiales del proyectil, que establecemos en 50.
‫Así que voy a pasar el final del daño a continuación.
‫Necesitamos al instigador y tenemos a mi dueño instigador.
‫Así que voy a pasar a mi dueño instigador.
‫El siguiente es el causante del daño.
‫Y por supuesto, el propio proyectil es el causante del daño.
‫Así que vamos a pasar en esto.
‫Y finalmente necesitamos la subclase de para su tipo de daño que sabemos que un puntero de clase U satisfará eso y es por
‫eso que tenemos nuestra clase de tipo de daño.
‫Así que pasemos a la clase de tipo de daño.
‫Y con eso ahora estamos llamando a aplicar daño.
‫Entonces, cuando llamemos a esto, generaremos el evento de daño y el delegado de tomar cualquier daño se transmitirá en respuesta
‫a esto, lo que significa que en nuestro componente de salud se llamará el daño recibido.
‫Así que solo tenemos que hacer algo aquí en el daño recibido.
‫Bueno, tendría sentido tomar este daño y restar esa cantidad de la salud.
‫Sin embargo, antes de hacer eso, me gustaría asegurarme de que el daño no sea menor o igual a cero.
‫F Tiene sentido hacer estas comprobaciones antes de documentar los daños, solo para asegurarnos de que no aplicamos un valor
‫que no tiene ningún sentido, como cero o un valor negativo.
‫Entonces, si ese es el caso, simplemente regresaremos.
‫Y, por supuesto, si desea ser astuto y hacer lo que hice en proyectiles en CP, podemos colocar el retorno
‫allí mismo.
‫Ahora, si superamos esta línea, el daño es un valor positivo, por lo que podemos tomar salud y usar menos
‫es igual a daño.
‫Y solo para asegurarnos de que esto funciona, ¿por qué no colocamos un registro euy aquí?
‫Así que el registro de registro de Yui, el texto de advertencia temporal y simplemente podemos imprimir el valor de la salud con el porcentaje F y la
‫salud y con eso podemos compilar.
‫Ahora, con una compilación exitosa, volveremos al editor y con nuestro registro de salida abierto, presionemos
‫reproducir.
‫Ahora veamos si podemos ser alcanzados por un proyectil.
‫Y ahí vamos.
‫Nuestra salud ahora está en 50 y, si nos golpean de nuevo, obtendremos bastantes eventos de golpe
‫porque chocamos contra el proyectil muchas veces muy rápido.
‫Pero vemos que nuestra salud se está documentando correctamente.
‫Por lo tanto, debemos asegurarnos de implementar el comportamiento correcto después de la muerte cuando la salud llega a cero.
‫Pero también debemos asegurarnos de que este evento exitoso no se envíe spam varias veces.
‫Ahora sabemos que el proyectil debe destruirse al golpear algo, por lo que la mejor manera de evitar el envío
‫de spam al evento de impacto es destruir el proyectil.
‫Eso es lo último que haremos en este video.
‫Entonces, de vuelta en el proyectil justo después de aplicar el daño, lo que podemos hacer es que el proyectil se destruya a sí mismo y eso
‫no podría ser más fácil.
‫Simplemente llamamos a la función destroy.
‫Entonces, con una compilación más aquí en el editor, podemos seguir adelante y ser golpeados por un proyectil y mirar
‫eso.
‫El proyectil se ha ido.
‫Entonces hace su daño y luego desaparece.
‫Y, por supuesto, también podemos probar golpear las torres haciéndolas estallar con proyectiles y asegurándonos de que
‫esos eventos de golpe se activen.
‫Y como puede ver, puedo enviar spam a esto con un montón de proyectiles y veremos que
‫el valor de salud de esta pobre torre aquí se está volviendo muy, muy negativo.
‫Entonces, en resumen, llamamos a la función de aplicar daño y esto resultó en una transmisión para el delegado de
‫tomar cualquier daño.
‫Documentamos la salud en el componente sanitario y destruimos el proyectil.
‫Así que ahora nos hemos ocupado de los daños.
‫Todavía no nos hemos ocupado de la muerte.
‫Esa será una de las próximas cosas que cubriremos en un video futuro.
‫Te veré pronto.