‫Hola y bienvenido.
‫En esta lección, vamos a refactorizar nuestro disparador de grupo para que esté listo para que agreguemos más
‫código.
‫Por el momento, se estaba yendo realmente de las manos quienes iban a refactorizarlo a
‫una pequeña función como esta que es mucho más sencilla de leer.
‫Profundicemos y veamos cómo hacer este refactor.
‫Bueno.
‫Así que queremos poner algo de sonido en nuestro juego y el lugar donde vamos a hacer esto es en el arma
‫cuando estamos disparando.
‫Ese es el primer puerto de escala.
‫Creo que un buen tipo de sonido de disparo, un sonido de impacto sería genial.
‫El único problema es que cuando volví a nuestra función de gatillo, noté que se había vuelto extravagantemente
‫grande.
‫No cabe en una de mis pantallas.
‫También es un poco difícil de leer y entender dónde estaríamos poniendo esta funcionalidad.
‫Entonces, mientras hacemos el esfuerzo de comprender realmente cuál es la funcionalidad aquí, tal vez valga la pena
‫hacer una refactorización rápida o extraer algunas de estas cosas en otros métodos para que no sea tan difícil de
‫leer.
‫Ahora, si vas y echas un vistazo a este código y tratas de averiguar cuáles son las
‫cosas básicas que está haciendo, entonces verás que una gran parte de esto en realidad está configurada para nuestra línea.
‫Traza todo este fragmento desde la línea 28 hasta la 43.
‫y qué estamos haciendo?
‫Bueno, obtenemos el peón del propietario, luego verificamos cómo obtener el controlador del propietario, luego obtenemos la ventana
‫gráfica de eso, luego obtenemos la ubicación final en función del rango máximo y luego estamos
‫pasando en algunos parámetros de golpe para ignorar cosas.
‫Todo esto está configurado para nuestro seguimiento de línea, entonces, ¿por qué no lo extraemos en su propia función aquí?
‫Voy a crear una nueva función privada abajo a la derecha en la parte inferior.
‫Después de nuestras variables, será de retorno booleano porque queremos reemplazar esencialmente esta llamada aquí que devuelve
‫el éxito con una que también nos da el resultado del éxito.
‫Así que vamos a hacer esto como algo que voy a llamar función de rastreo de armas y va a
‫tener algunos parámetros aquí.
‫Es decir, uno de ellos va a ser el resultado del éxito.
‫Así que presiona resultado, ampersand para convertirlo en una referencia.
‫Y como no es una referencia constante, sabemos que es un parámetro de salida.
‫Llama a esto el golpe.
‫Y en realidad puede haber otro que necesitemos aquí.
‫Es decir, puedo ver que tenemos la rotación saliendo de este fragmento de código y, de hecho, estamos
‫negando esa rotación.
‫Entonces, lo que realmente nos interesa es la dirección del disparo.
‫Así que tal vez eso es lo que tenemos que buscar.
‫Así que voy a crear un parámetro de salida de vector F.
‫Así que vector ampersand y será esta dirección de disparo.
‫Estas son las dos salidas que van a salir en el rastro del arma.
‫Ahora avancemos y creemos la implementación aquí.
‫Y lo que queremos hacer es esencialmente copiar todo este código en eso.
‫Ver cómo va.
‫Y también queremos estar revisando esta toma.
‫Dirección.
‫Saca eso y pégalo justo antes del final.
‫O tal vez solo escuchar después de que tenemos nuestra ventana de visualización del jugador, podemos establecer que la dirección de su disparo sea
‫igual a la rotación negativa.
‫Pero es importante tener en cuenta aquí que en realidad no queremos configurar una variable local.
‫Entonces, si coloca el tipo aquí, establecerá una dirección de disparo local.
‫Queremos eliminar eso para que esté configurando la dirección de disparo en los parámetros de AMP, lo que en realidad
‫significa que está configurando la dirección de disparo que vamos a pasar en la función que lo llama.
‫Lo mismo ocurre con el golpe.
‫Necesitamos eliminar este hit local para que el hit que se pasa al rastreo de línea individual por canal sea el hit que se
‫pasó al rastreo de armas.
‫Y finalmente, ¿hay algo más que hacer es hacer una línea que ahora no es necesaria y que también sea un
‫éxito?
‫Bueno, solo necesitamos volver a ser el resultado del seguimiento de línea solo por canal.
‫Eso va a ser si nuestro rastreo de armas ha tenido éxito o no.
‫Así que hemos logrado que esta sangría dure un poco.
‫Ahora podemos colocar todo en una pantalla, y es un poco más fácil de entender que, sí,
‫todo esto está relacionado con obtener un rastro de armas.
‫Podemos subir a nuestro CP de armas y ahora podemos configurar nuestro éxito base aquí.
‫Así que el éxito del Grupo B, vamos a tener que establecerlo como el rastro del arma y tenemos que pasar algunos parámetros aquí.
‫Por lo tanto, aún debemos declararlos en algún lugar si se obtiene un resultado.
‫Va a ser uno de ellos.
‫Simplemente va a golpear.
‫Y el otro iba a ser un vector F llamado dirección de tiro.
‫Y esos van a ser pasados.
‫Primero vamos a tener el golpe, luego la dirección del disparo.
‫Y luego punto y coma al final.
‫Así que eso hará que sea un poco más fácil.
‫Sin embargo, no digo que también necesitemos el controlador propietario y no quiero que el rastro del arma
‫sea responsable del controlador propietario u olvide el control propietario.
‫Eso no parece que sea responsabilidad de un rastro de armas hacer eso.
‫Suena bien que tenga éxito.
‫Suena bien para obtener una dirección de disparo, pero voy a trazar la línea para obtener el controlador propietario.
‫Entonces, para eso, lo pondré, pondré todo este código en otra función a la que ambos
‫puedan llamar.
‫Así que va a ser una función que devuelve un controlador.
‫Estrella.
‫Y lo llamaremos el controlador del propietario del jet.
‫Y podemos hacer que a.
‫Como sabemos, no está destinado a cambiar ninguna de las variables en nuestra clase de armas.
‫Vamos a crear esa implementación.
‫Simplemente traiga la implementación del rastro del arma, corrija cualquier sangría si es necesario.
‫Y vamos a seguir adelante y simplemente devolver el control del propietario.
‫Así que no hay necesidad de hacer una revisión de uñas aquí.
‫Ese control de uñas que necesitamos hacer en la función que lo está usando.
‫Así que mencionaremos que tampoco necesitamos establecer una variable aquí.
‫Podemos seguir adelante y regresar.
‫Así que va a ser bastante sencillo.
‫Tengo un controlador, pero no completamente.
‫Y luego vamos a configurar la variable en el rastreo de armas.
‫Entonces, tengo un controlador que obtendrá un controlador propio así.
‫Luego hacemos un retorno nulo a un retorno temprano nulo en el rastreo de armas, que por cierto, necesita devolver un valor
‫booleano porque el rastreo de armas está devolviendo un valor booleano.
‫Así que podemos continuar y devolver falso aquí porque si no podemos obtener un controlador propio, no podemos rastrear el arma,
‫por lo tanto, no podemos golpear nada.
‫Y luego también necesitamos ese controlador propietario más arriba.
‫Donde tenemos un actor de éxito, estamos haciendo daño.
‫Y básicamente lo que queremos hacer aquí es obtener el control del propietario aquí dentro de nuestro exitoso actor.
‫Entonces, si golpeamos a un actor, obtenemos el controlador propietario nuevamente.
‫Ahora, sé que hay un poco de rastreadores de armas llamando.
‫Súbete a un controlador y luego lo haremos de nuevo si golpeamos a un actor.
‫Pero eso solo sucederá cada vez que golpeemos a un actor.
‫Así que no me importa volver a calcular eso dos veces porque solo hará que el código sea un poco más
‫legible sin tener que almacenar variables y estados que podrían perder la sincronización.
‫Ahí vas.
‫Ahora tenemos el controlador propietario que necesitamos para recibir daños y el gatillo de Apple se ve mucho mejor.
‫Así que eso es todo por esta conferencia.
‫Uno rápido.
‫Simplemente refactorizando nuestro gatillo para que tengamos una buena base para trabajar en la próxima lección.
‫Y voy a ver eso.
‫Ah, y parece que hice un poco de booboo aquí y se ponen en un controlador.
‫Si intenta y compila, no hará nada porque este valor de retorno no está devolviendo un
‫puntero.
‫Entonces queremos devolver un puntero nulo en este caso de inmediato.
‫Básicamente, no podemos obtener un tirón y luego no podemos obtener un controlador.
‫Así que devolvemos un puntero nulo.