‫Hola y bienvenido.
‫En esta lección, vamos a hacer que nuestros componentes de disparo se vuelvan a imprimir cuando se vayan a
‫un espacio vacío y cuando coloquemos la gárgola, se desbloqueará.
‫Y si lo saco de nuevo, volverá a estar bloqueado.
‫Y la forma en que vamos a hacer esto es extrayendo nuestra funcionalidad para encontrar si
‫tenemos un actor aceptable en su propia función separada.
‫Y voy a aprender acerca de las devoluciones anticipadas dentro de cuatro bucles.
‫Para hacer eso, vamos a sumergirnos.
‫Así que este trozo de código que tenemos y el componente tecnológico ya me está empezando a parecer una
‫función.
‫Esencialmente, es una función que se apodera del actor aceptable, si tenemos uno, por lo que podemos continuar
‫con nuestro punto H del componente desencadenante y, en la sección privada, crear dicha función.
‫Ahora, ¿cuál debería ser su tipo de retorno?
‫Bueno, creo que debería ser un puntero de actor A, que siempre puede ser un puntero nulo si no hay un actor
‫aceptable.
‫Entonces podemos llamar a esto obtener un actor aceptable entre paréntesis vacíos.
‫No necesitamos darle nada.
‫Y como no cambia nuestra función, podemos hacerla constante.
‫Avancemos e implementemos esto en este archivo de montón yendo a una sangría.
‫Es darle un punto y coma del componente que activa dos puntos y reemplazarlo con llaves.
‫Y luego, el código que queremos es básicamente el contenido del componente tick, excepto que lo que no queremos hacer
‫es simplemente registrar eso.
‫Hemos desbloqueado un actor aquí.
‫Lo que queremos hacer es en el caso de que hayamos encontrado a este actor, esencialmente queremos devolverlo.
‫Así que hay un par de maneras en que podemos hacer esto.
‫Podríamos decir al comienzo de nuestra función que hay un puntero de actor, que será el actor de
‫retorno, y por defecto lo configuramos como puntero nulo.
‫Así que no hay ningún actor al que vayamos a volver.
‫Pero cuando repasamos nuestro ciclo for y finalmente encontramos un actor que tiene la
‫etiqueta aceptable, entonces podemos decir: Oye, el actor de retorno debería apuntar al puntero de actor que encontramos aquí en la
‫matriz.
‫Y luego, al final del ciclo for después de que finaliza el ciclo completo, hemos revisado a todos los actores.
‫Podemos continuar y devolver la variable de actor de retorno porque ese es el tipo correcto.
‫Esta bien.
‫Pero requiere que creemos una variable y también requiere que ejecutemos todo el ciclo completo, incluso
‫si ya hemos encontrado un actor aceptable.
‫Entonces, una mejor manera de hacer esto es usar un retorno anticipado.
‫Y hemos visto este tipo de cosas antes en I grab a C P donde hemos hecho esto.
‫Si los controles físicos son iguales a un pequeño puntero, entonces regresamos y el resto del componente no
‫necesita ejecutarse.
‫Podemos usar el mismo tipo de eficiencia dentro de los saltos también.
‫Entonces, lo que haré es si encontramos al actor aceptable, solo haremos un actor de regreso.
‫Literalmente estamos devolviendo el puntero que acabamos de encontrar en este ciclo for y el resto del ciclo
‫for no tiene que ejecutarse.
‫Sin embargo, si llegamos al final del bucle for y no hemos encontrado nada, no hemos devuelto nada,
‫el retorno detendría el bucle for, dejaría la función.
‫Pero si llegamos al final, necesitamos devolver algo por defecto y aquí es donde podemos devolver
‫un puntero nulo.
‫Así que este es el valor predeterminado.
‫Significa que hemos pasado por todo el bucle for.
‫Hemos visto que no hay un actor aceptable.
‫Ninguno de los actores se superponía con el nuestro.
‫Con la etiqueta correcta.
‫Así que devolvemos un puntero nulo.
‫Ahora eso significa que tengo esta variable de actor de retorno redundante de la que puedo continuar y deshacerme.
‫Y esto se lee realmente bastante limpio.
‫Estamos pasando, estamos obteniendo los actores superpuestos, estamos haciendo un ciclo completo sobre ellos.
‫Si cada actor lo probamos, ¿tiene la etiqueta aceptable?
‫Si es así, nos detenemos allí mismo.
‫Le devolvemos ese.
‫Si ninguno de ellos lo tiene, devolvemos un puntero nulo.
‫Así que vamos a desafiarte a que inicies sesión si encontramos al actor.
‫Así que llama a nuestra función en tu componente tick.
‫Verifique si el puntero es nulo e inicie sesión en ambos casos, ya sea que tengamos un actor o si no
‫usamos una declaración F y otra.
‫Pausa el video y pruébalo.
‫Bueno.
‫Bienvenido de nuevo.
‫Así que volvamos a nuestros componentes tecnológicos.
‫Lo que vamos a hacer es crear una variable, un puntero de actor, que será el actor, lo
‫que equivale a obtener un actor aceptable que vamos a hacer.
‫Si el actor no es igual al puntero nulo, entonces en el cuerpo de esto vamos a hacer un desbloqueo de diálogo y
‫luego en otro otro lo registras esta vez porque ese es el comportamiento que quiero que tenga nuestro
‫componente desencadenante y moverlo juntos. Si tienes la gárgola ahí, se desbloqueará.
‫Va a usar el motor y se volverá a bloquear si básicamente desmarcamos la casilla de verificación al mover
‫si eliminamos la gárgola, así que vamos a compilar eso.
‫Así que sigamos adelante y presionemos reproducir.
‫Puedes ver que se está cerrando porque no tenemos una gárgola ahí.
‫Recoge la gárgola y tráela y listo.
‫Ahora está desbloqueando, sácalo y vuelve a bloquear, quedando perfecto.
‫Si entro, no pasa nada.
‫Solo se está volviendo a bloquear.
‫Así que hemos podido averiguar con éxito si tenemos algo en nuestro componente activador o
‫no.
‫Ahora sólo tenemos que hacer que haga algo.
‫Y ese será el tema de la próxima conferencia.
‫Veré eso.