‫Olá e bem-vindo.
‫Nesta palestra, vamos fazer com que nossos componentes de gatilho imprimam olhando quando estiver em um espaço
‫vazio e quando colocarmos a gárgula, ela será desbloqueada.
‫E se eu tirá-lo de novo, ele ficará trancado novamente.
‫E a maneira como faremos isso é retirando nossa funcionalidade para descobrir se temos
‫um ator aceitável em sua própria função separada.
‫E vou aprender sobre retornos antecipados dentro de quatro ciclos.
‫Para isso, vamos mergulhar.
‫Então, esse pedaço de código que temos e o componente de tecnologia já está começando a parecer uma função para
‫mim.
‫Essencialmente, é uma função que se apossa do ator aceitável, se tivermos um, para que possamos ir em
‫frente ao nosso componente de gatilho ponto H e, na seção privada, criar essa função.
‫Agora, qual deve ser o seu tipo de retorno?
‫Bem, acho que deveria ser um ponteiro de ator A, que sempre pode ser um ponteiro nulo se não houver um ator
‫aceitável.
‫Então, podemos chamar isso de obter parênteses vazios de ator aceitável.
‫Não precisamos dar nada.
‫E porque não muda nossa função, podemos torná-la constante.
‫Vamos implementar isso neste arquivo heap, indo para um recuo.
‫É dar a ele um ponto-e-vírgula do componente acionador e substituí-lo por chaves.
‫E então o código que queremos é basicamente o conteúdo do componente tick, exceto que o que não queremos fazer
‫é apenas registrar isso.
‫Desbloqueamos um ator aqui.
‫O que queremos fazer é no caso de encontrarmos esse ator, queremos essencialmente devolvê-lo.
‫Portanto, há algumas maneiras de fazermos isso.
‫Poderíamos dizer no início de nossa função que existe um ponteiro de ator, que será o ator de
‫retorno e, por padrão, definimos isso como ponteiro nulo.
‫Portanto, não há ator que vamos retornar.
‫Mas quando passamos por nosso loop for e eventualmente encontramos um ator que tem
‫a tag aceitável, então podemos dizer, Ei, o ator de retorno deve realmente apontar para o ponteiro de ator que encontramos aqui
‫no array.
‫E então, no final do loop for, após o loop completo terminar, passamos por todos os atores.
‫Podemos ir em frente e retornar a variável de ator de retorno porque esse é o tipo certo.
‫Tudo bem.
‫Mas exige que criemos uma variável e também que executemos todo o loop completo, mesmo
‫que já tenhamos encontrado um ator aceitável.
‫Portanto, uma maneira melhor de fazer isso é usar um retorno antecipado.
‫E já vimos esse tipo de coisa antes em eu pego um CP onde fizemos isso.
‫Se o handle de física for igual a um pequeno ponteiro, então retornamos e o resto do componente não
‫precisa rodar.
‫Podemos usar o mesmo tipo de eficiência interna para saltos também.
‫Então, o que vou fazer é se encontrarmos o ator aceitável, vamos apenas fazer um ator de retorno.
‫Estamos literalmente retornando o ponteiro que acabamos de encontrar neste loop for e o resto do loop for
‫não precisa ser executado.
‫No entanto, se irmos até o final do loop for e não encontrarmos nada, não retornarmos nada,
‫o retorno interromperia o loop for, sairia da função.
‫Mas se chegarmos ao final, precisamos retornar algo por padrão e é aqui que podemos retornar apenas
‫um ponteiro nulo.
‫Portanto, este é o valor padrão.
‫Significa que passamos por todo o loop for.
‫Vimos que não existe um ator aceitável.
‫Nenhum dos atores estava se sobrepondo ao nosso.
‫Com a etiqueta correta.
‫Então, retornamos ponteiro nulo.
‫Então agora isso significa que eu tenho essa variável de ator de retorno redundante da qual posso ir em frente e me livrar.
‫E isso lê realmente muito limpo.
‫Estamos passando, estamos pegando os atores sobrepostos, estamos fazendo um loop completo sobre eles.
‫Se cada ator que testamos, ele tem a etiqueta aceitável?
‫Se isso acontecer, paramos por aí.
‫Nós devolvemos aquele.
‫Se nenhum deles tiver, retornamos um ponteiro nulo.
‫Então vamos desafiá-lo a logar se encontrarmos o ator.
‫Então chame nossa função em seu componente tick.
‫Verifique se o ponteiro é nulo e registre em ambos os casos, tanto se tivermos um ator ou se não usarmos
‫uma instrução F e um else.
‫Pause o vídeo e vá em frente.
‫OK.
‫Bem vindo de volta.
‫Então, vamos voltar aos nossos componentes de tecnologia.
‫O que vamos fazer é criar uma variável, um ponteiro de ator, que será o ator, que
‫é igual a obter o ator aceitável que vamos fazer.
‫Se o ator não for igual ao ponteiro nulo, então no corpo disso vamos fazer um desbloqueio de diálogo e então no outro você loga
‫desta vez olhando porque esse é o comportamento que eu quero que nosso componente de gatilho e mova-o juntos
‫para ter é o se você tem a gárgula lá, ele vai desbloquear.
‫Ele estará usando o movedor e será travado novamente se basicamente desmarcarmos a caixa de seleção em
‫movimento se removermos a gárgula, então vamos compilar isso.
‫Então vamos em frente e aperte o play.
‫Você pode ver que está travando porque não temos uma gárgula lá.
‫Pegue a gárgula e traga-o e pronto.
‫Agora está desbloqueando, tire-o e está travando novamente, parecendo perfeito.
‫Se eu entrar, nada acontece.
‫É só travar novamente.
‫Assim, conseguimos descobrir com sucesso se temos algo em nosso componente de gatilho ou
‫não.
‫Agora só precisamos fazê-lo fazer alguma coisa.
‫E esse será o assunto da próxima palestra.
‫Eu vou ver isso.